rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/abr/{select_optimal_representation.ts → utils/select_optimal_representation.ts}

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { Representation } from "../../manifest";
-import arrayFindIndex from "../../utils/array_find_index";
+import { Representation } from "../../../manifest";
+import arrayFindIndex from "../../../utils/array_find_index";
 
 /**
  * From the given array of Representations (sorted by bitrate order ascending),

package/src/core/api/README.md

@@ -46,10 +46,11 @@ this event to then communicate it back to the user.
 
 To facilitate those actions, the API relies on multiple building blocks:
 
-  - __the `Clock` (./clock.ts)__
+  - __the `PlaybackObserver` (./playback_observer.ts)__
 
-    Provide an Observable emitting regularly the current playback conditions for
-    the Player. Many RxPlayer modules rely on that clock.
+    Provide multiple methods allowing to monitor the current playback conditions
+    (e.g. the current position and/or the current playback rate).
+    Many RxPlayer modules rely on this PlaybackObserver.
 
 
   - __the `TrackChoiceManager` (./track_choice_manager.ts)__

package/src/core/api/__tests__/get_player_state.test.ts

@@ -31,24 +31,14 @@ describe("API - getLoadedContentState", () => {
       .toBe("ENDED");
     expect(getLoadedContentState(mediaElement, false, null))
       .toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "buffering",
-    })).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "freezing")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "freezing")).toBe("ENDED");
   });
 
   it("should be PLAYING if not stalled nor ended and if not paused", () => {
@@ -73,19 +63,26 @@ describe("API - getLoadedContentState", () => {
       .toBe("PAUSED");
   });
 
-  it("should be BUFFERING if not ended and stalled because of bufferring", () => {
+  it("should be BUFFERING if not ended and stalled because of buffering", () => {
     const fakeProps = {
       ended: false,
       duration: 10,
       currentTime: 5,
     };
     const mediaElement = fakeProps as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "buffering",
-    })).toBe("BUFFERING");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "buffering",
-    })).toBe("BUFFERING");
+    expect(getLoadedContentState(mediaElement, true, "buffering")).toBe("BUFFERING");
+    expect(getLoadedContentState(mediaElement, false, "buffering")).toBe("BUFFERING");
+  });
+
+  it("should be BUFFERING if not ended and stalled because of freezing", () => {
+    const fakeProps = {
+      ended: false,
+      duration: 10,
+      currentTime: 5,
+    };
+    const mediaElement = fakeProps as HTMLMediaElement;
+    expect(getLoadedContentState(mediaElement, true, "freezing")).toBe("BUFFERING");
+    expect(getLoadedContentState(mediaElement, false, "freezing")).toBe("BUFFERING");
   });
 
   it("should be BUFFERING if not ended and stalled because of `not-ready`", () => {
@@ -95,12 +92,8 @@ describe("API - getLoadedContentState", () => {
       currentTime: 5,
     };
     const mediaElement = fakeProps as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "not-ready",
-    })).toBe("BUFFERING");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "not-ready",
-    })).toBe("BUFFERING");
+    expect(getLoadedContentState(mediaElement, true, "not-ready")).toBe("BUFFERING");
+    expect(getLoadedContentState(mediaElement, false, "not-ready")).toBe("BUFFERING");
   });
 
   it("should be SEEKING if not ended and stalled because of `seeking`", () => {
@@ -110,12 +103,8 @@ describe("API - getLoadedContentState", () => {
       currentTime: 5,
     };
     const mediaElement = fakeProps as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "seeking",
-    })).toBe("SEEKING");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "seeking",
-    })).toBe("SEEKING");
+    expect(getLoadedContentState(mediaElement, true, "seeking")).toBe("SEEKING");
+    expect(getLoadedContentState(mediaElement, false, "seeking")).toBe("SEEKING");
   });
 
   it("should be ENDED if stalled and currentTime is equal to duration", () => {
@@ -125,24 +114,14 @@ describe("API - getLoadedContentState", () => {
       currentTime: 10,
     };
     const mediaElement = fakeProps as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "not-ready",
-    })).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "freezing")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "freezing")).toBe("ENDED");
   });
 
   it("should be ENDED if stalled and currentTime is very close to the duration", () => {
@@ -152,26 +131,15 @@ describe("API - getLoadedContentState", () => {
       currentTime: 10 - config.FORCED_ENDED_THRESHOLD,
     };
     const mediaElement = fakeProps as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, true, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement, false, {
-      reason: "not-ready",
-    })).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, true, "freezing")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement, false, "freezing")).toBe("ENDED");
   });
-
   it("should be ENDED if stalled and currentTime is very close to the duration", () => {
     const fakeProps1 = {
       ended: false,
@@ -179,24 +147,14 @@ describe("API - getLoadedContentState", () => {
       currentTime: 10 - config.FORCED_ENDED_THRESHOLD,
     };
     const mediaElement1 = fakeProps1 as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement1, true, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement1, false, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement1, true, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement1, false, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement1, true, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement1, false, {
-      reason: "not-ready",
-    })).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, true, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, false, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, true, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, false, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, true, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, false, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, true, "freezing")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement1, false, "freezing")).toBe("ENDED");
 
     const fakeProps2 = {
       ended: false,
@@ -204,23 +162,13 @@ describe("API - getLoadedContentState", () => {
       currentTime: config.FORCED_ENDED_THRESHOLD + 10,
     };
     const mediaElement2 = fakeProps2 as HTMLMediaElement;
-    expect(getLoadedContentState(mediaElement2, true, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement2, false, {
-      reason: "seeking",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement2, true, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement2, false, {
-      reason: "buffering",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement2, true, {
-      reason: "not-ready",
-    })).toBe("ENDED");
-    expect(getLoadedContentState(mediaElement2, false, {
-      reason: "not-ready",
-    })).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, true, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, false, "seeking")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, true, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, false, "buffering")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, true, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, false, "not-ready")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, true, "freezing")).toBe("ENDED");
+    expect(getLoadedContentState(mediaElement2, false, "freezing")).toBe("ENDED");
   });
 });

package/src/core/api/__tests__/media_element_track_choice_manager.test.ts

@@ -32,13 +32,11 @@ const fakeMediaElement = {
   videoTracks: [
     { language: "", selected: true },
   ],
-};
+} as unknown as HTMLVideoElement;
 
 describe("API - MediaElementTrackChoiceManager", () => {
   it("should returns correct results for getter", () => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
     const audioTracks = trackManager.getAvailableAudioTracks();
     const textTracks = trackManager.getAvailableTextTracks();
     const videoTracks = trackManager.getAvailableVideoTracks();
@@ -71,13 +69,14 @@ describe("API - MediaElementTrackChoiceManager", () => {
     });
   });
   it("should returns correct results for setters", () => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
 
     trackManager.setAudioTrackById("gen_audio_en_1");
     // unset enabled attribute of other track, as browser is supported to do this
-    fakeMediaElement.audioTracks[1].enabled = false;
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (fakeMediaElement as any).audioTracks[1].enabled = false;
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     expect(trackManager.getChosenAudioTrack()).toEqual({
       id: "gen_audio_en_1",
       language: "en",
@@ -97,9 +96,7 @@ describe("API - MediaElementTrackChoiceManager", () => {
     });
   });
   it("should emit available tracks change when changing text contents", (done) => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
 
     trackManager
       .addEventListener("availableTextTracksChange", (tracks) => {
@@ -113,15 +110,13 @@ describe("API - MediaElementTrackChoiceManager", () => {
       });
 
     // Fake browser behavior
-    fakeMediaElement.textTracks.unshift({ language: "es", mode: "hidden" });
-    /* eslint-disable-next-line */
-    (fakeMediaElement.textTracks as any).onaddtrack();
+    (fakeMediaElement.textTracks as unknown as TextTrack[])
+      .unshift({ language: "es", mode: "hidden" } as TextTrack);
+    fakeMediaElement.textTracks.onaddtrack?.({} as TrackEvent);
   });
 
   it("should emit available tracks change when changing video contents", (done) => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
 
     trackManager
       .addEventListener("availableVideoTracksChange", (tracks) => {
@@ -132,15 +127,20 @@ describe("API - MediaElementTrackChoiceManager", () => {
       });
 
     // Fake browser behavior
-    fakeMediaElement.videoTracks.unshift({ language: "en", selected: false });
-    /* eslint-disable-next-line */
-    (fakeMediaElement.videoTracks as any).onaddtrack();
+    /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _elt = fakeMediaElement as any;
+    _elt.videoTracks.unshift({ language: "en", selected: false });
+    _elt.videoTracks.onaddtrack?.({} as TrackEvent);
+    /* eslint-enable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
   });
 
   it("should emit available tracks change when changing audio contents", (done) => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
 
     trackManager
       .addEventListener("availableAudioTracksChange", (tracks) => {
@@ -154,15 +154,20 @@ describe("API - MediaElementTrackChoiceManager", () => {
       });
 
     // Fake browser behavior
-    fakeMediaElement.audioTracks.unshift({ language: "en", enabled: false });
-    /* eslint-disable-next-line */
-    (fakeMediaElement.audioTracks as any).onaddtrack();
+    /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _elt = fakeMediaElement as any;
+    _elt.audioTracks.unshift({ language: "en", selected: false });
+    _elt.audioTracks.onaddtrack?.({} as TrackEvent);
+    /* eslint-enable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
   });
 
   it("should emit chosen track when changing text content", (done) => {
-    const trackManager = new MediaElementTrackChoiceManager(
-      fakeMediaElement as any
-    );
+    const trackManager = new MediaElementTrackChoiceManager(fakeMediaElement);
 
     trackManager
       .addEventListener("textTrackChange", (chosenTrack) => {
@@ -174,7 +179,6 @@ describe("API - MediaElementTrackChoiceManager", () => {
 
     // Fake browser behavior
     fakeMediaElement.textTracks[0].mode = "hidden";
-    /* eslint-disable-next-line */
-    (fakeMediaElement.textTracks as any).onchange();
+    fakeMediaElement.textTracks?.onchange?.(undefined as unknown as Event);
   });
 });

package/src/core/api/__tests__/option_utils.test.ts

@@ -20,6 +20,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import config from "../../../config";
 import log from "../../../log";
@@ -533,8 +535,13 @@ describe("API - parseLoadVideoOptions", () => {
     } catch (e) {
       err = e;
     }
-    expect(err).toBeDefined();
     expect(opt).not.toBeDefined();
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err.message).toEqual("No option set on loadVideo");
   });
 
@@ -553,16 +560,26 @@ describe("API - parseLoadVideoOptions", () => {
     } catch (e) {
       err2 = e;
     }
-    expect(err1).toBeDefined();
     expect(opt1).not.toBeDefined();
+    expect(err1).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err1 instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err1.message).toEqual(
       "Unable to load a content: no url set on loadVideo.\n" +
       "Please provide at least either an `url` argument, a " +
       "`transportOptions.initialManifest` option or a " +
       "`transportOptions.manifestLoader` option so the RxPlayer can load the content."
     );
-    expect(err2).toBeDefined();
     expect(opt2).not.toBeDefined();
+    expect(err2).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err2 instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err2.message).toEqual(
       "Unable to load a content: no url set on loadVideo.\n" +
       "Please provide at least either an `url` argument, a " +
@@ -579,8 +596,13 @@ describe("API - parseLoadVideoOptions", () => {
     } catch (e) {
       err = e;
     }
-    expect(err).toBeDefined();
     expect(opt).not.toBeDefined();
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err.message).toEqual("No transport set on loadVideo");
   });
 
@@ -793,8 +815,13 @@ describe("API - parseLoadVideoOptions", () => {
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid key system given: Missing type string or getLicense callback");
     }
@@ -810,8 +837,13 @@ describe("API - parseLoadVideoOptions", () => {
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid key system given: Missing type string or getLicense callback");
     }
@@ -827,8 +859,13 @@ describe("API - parseLoadVideoOptions", () => {
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid key system given: Missing type string or getLicense callback");
     }
@@ -1205,8 +1242,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary image track given. Missing either mimetype or url");
     }
@@ -1222,8 +1264,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary image track given. Missing either mimetype or url");
     }
@@ -1239,8 +1286,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary image track given. Missing either mimetype or url");
     }
@@ -1303,8 +1355,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary text track given." +
         " Missing either language, mimetype or url");
@@ -1321,8 +1378,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary text track given." +
         " Missing either language, mimetype or url");
@@ -1339,8 +1401,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary text track given." +
         " Missing either language, mimetype or url");
@@ -1357,8 +1424,13 @@ If badly set, continue will be used as default`);
       } catch (e) {
         err = e;
       }
-      expect(err).toBeDefined();
       expect(opt).not.toBeDefined();
+      expect(err).toBeInstanceOf(Error);
+
+      // Impossible check to shut-up TypeScript
+      if (!(err instanceof Error)) {
+        throw new Error("Impossible: already checked it was an Error instance");
+      }
       expect(err.message).toEqual(
         "Invalid supplementary text track given." +
         " Missing either language, mimetype or url");
@@ -1421,8 +1493,13 @@ If badly set, continue will be used as default`);
     } catch (e) {
       err = e;
     }
-    expect(err).toBeDefined();
     expect(opt).not.toBeDefined();
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err.message).toEqual("Invalid textTrackMode.");
   });
 
@@ -1440,8 +1517,13 @@ If badly set, continue will be used as default`);
     } catch (e) {
       err = e;
     }
-    expect(err).toBeDefined();
     expect(opt).not.toBeDefined();
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err.message)
       .toEqual("You have to provide a textTrackElement in \"html\" textTrackMode.");
   });
@@ -1462,8 +1544,13 @@ If badly set, continue will be used as default`);
     } catch (e) {
       err = e;
     }
-    expect(err).toBeDefined();
     expect(opt).not.toBeDefined();
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(err.message)
       .toEqual("textTrackElement should be an HTMLElement.");
   });