rx-player 4.2.0-dev.2024082600 → 4.2.0-dev.2024090500

package/src/parsers/manifest/dash/fast-js-parser/node_parsers/__tests__/SegmentURL.test.ts

@@ -1,12 +1,8 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
 import type { ITNode } from "../../../../../../utils/xml-parser";
 import { parseXml } from "../../../../../../utils/xml-parser";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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-explicit-any */
+import type IParseSegmentURL from "../SegmentURL";
+import type { MPDError as IMPDError } from "../utils";
 
 describe("DASH Node Parsers - SegmentURL", () => {
   beforeEach(() => {
@@ -18,7 +14,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
     const element1 = parseXml("<Foo />")[0] as ITNode;
     expect(parseSegmentURL(element1)).toEqual([{}, []]);
 
@@ -34,7 +31,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
     const element1 = parseXml('<Foo mediaRange="10-100" />')[0] as ITNode;
     expect(parseSegmentURL(element1)).toEqual([{ mediaRange: [10, 100] }, []]);
 
@@ -50,8 +48,9 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn").mockImplementation(vi.fn());
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
-    const MPDError = ((await vi.importActual("../utils")) as any).MPDError;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = parseXml('<Foo mediaRange="a" />')[0] as ITNode;
     const error1 = new MPDError('`mediaRange` property has an unrecognized format "a"');
     expect(parseSegmentURL(element1)).toEqual([{}, [error1]]);
@@ -76,7 +75,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
     const element1 = parseXml('<Foo indexRange="0-100" />')[0] as ITNode;
     expect(parseSegmentURL(element1)).toEqual([{ indexRange: [0, 100] }, []]);
 
@@ -92,8 +92,9 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn").mockImplementation(vi.fn());
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
-    const MPDError = ((await vi.importActual("../utils")) as any).MPDError;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = parseXml('<Foo indexRange="a" />')[0] as ITNode;
     const error1 = new MPDError('`indexRange` property has an unrecognized format "a"');
     expect(parseSegmentURL(element1)).toEqual([{}, [error1]]);
@@ -116,7 +117,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
     const element1 = parseXml('<Foo media="a" />')[0] as ITNode;
     expect(parseSegmentURL(element1)).toEqual([{ media: "a" }, []]);
 
@@ -132,7 +134,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof IParseSegmentURL;
     const element1 = parseXml('<Foo index="a" />')[0] as ITNode;
     expect(parseSegmentURL(element1)).toEqual([{ index: "a" }, []]);
 

package/src/parsers/manifest/dash/native-parser/node_parsers/AdaptationSet.ts

@@ -64,7 +64,7 @@ function parseAdaptationSetChildren(
           }
           break;
 
-        case "BaseURL":
+        case "BaseURL": {
           const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
           if (baseURLObj !== undefined) {
             children.baseURLs.push(baseURLObj);
@@ -73,6 +73,7 @@ function parseAdaptationSetChildren(
             warnings = warnings.concat(baseURLWarnings);
           }
           break;
+        }
 
         case "ContentComponent":
           children.contentComponent = parseContentComponent(currentElement);
@@ -93,15 +94,16 @@ function parseAdaptationSetChildren(
           children.inbandEventStreams.push(parseScheme(currentElement));
           break;
 
-        case "Label":
+        case "Label": {
           const label = currentElement.textContent;
 
           if (label !== null && label !== undefined) {
             children.label = label;
           }
           break;
+        }
 
-        case "Representation":
+        case "Representation": {
           const [representation, representationWarnings] =
             createRepresentationIntermediateRepresentation(currentElement);
           children.representations.push(representation);
@@ -109,6 +111,7 @@ function parseAdaptationSetChildren(
             warnings = warnings.concat(representationWarnings);
           }
           break;
+        }
 
         case "Role":
           if (isNullOrUndefined(children.roles)) {
@@ -126,23 +129,25 @@ function parseAdaptationSetChildren(
           }
           break;
 
-        case "SegmentBase":
+        case "SegmentBase": {
           const [segmentBase, segmentBaseWarnings] = parseSegmentBase(currentElement);
           children.segmentBase = segmentBase;
           if (segmentBaseWarnings.length > 0) {
             warnings = warnings.concat(segmentBaseWarnings);
           }
           break;
+        }
 
-        case "SegmentList":
+        case "SegmentList": {
           const [segmentList, segmentListWarnings] = parseSegmentList(currentElement);
           children.segmentList = segmentList;
           if (segmentListWarnings.length > 0) {
             warnings = warnings.concat(segmentListWarnings);
           }
           break;
+        }
 
-        case "SegmentTemplate":
+        case "SegmentTemplate": {
           const [segmentTemplate, segmentTemplateWarnings] =
             parseSegmentTemplate(currentElement);
           children.segmentTemplate = segmentTemplate;
@@ -150,8 +155,9 @@ function parseAdaptationSetChildren(
             warnings = warnings.concat(segmentTemplateWarnings);
           }
           break;
+        }
 
-        case "ContentProtection":
+        case "ContentProtection": {
           const [contentProtection, contentProtectionWarnings] =
             parseContentProtection(currentElement);
           if (contentProtectionWarnings.length > 0) {
@@ -161,6 +167,7 @@ function parseAdaptationSetChildren(
             contentProtections.push(contentProtection);
           }
           break;
+        }
 
         // case "Rating":
         //   children.rating = currentElement;

package/src/parsers/manifest/dash/native-parser/node_parsers/EventStream.ts

@@ -63,13 +63,14 @@ export default function parseEventStream(
       const currentElement = element.childNodes[i] as Element;
 
       switch (currentElement.nodeName) {
-        case "Event":
+        case "Event": {
           const [event, eventWarnings] = parseEvent(currentElement);
           eventStreamIR.children.events.push(event);
           if (eventWarnings.length > 0) {
             warnings = warnings.concat(eventWarnings);
           }
           break;
+        }
       }
     }
   }

package/src/parsers/manifest/dash/native-parser/node_parsers/MPD.ts

@@ -45,31 +45,34 @@ function parseMPDChildren(mpdChildren: NodeList): [IMPDChildren, Error[]] {
     if (mpdChildren[i].nodeType === Node.ELEMENT_NODE) {
       const currentNode = mpdChildren[i] as Element;
       switch (currentNode.nodeName) {
-        case "BaseURL":
+        case "BaseURL": {
           const [baseURLObj, baseURLWarnings] = parseBaseURL(currentNode);
           if (baseURLObj !== undefined) {
             baseURLs.push(baseURLObj);
           }
           warnings = warnings.concat(baseURLWarnings);
           break;
+        }
 
         case "Location":
           locations.push(currentNode.textContent === null ? "" : currentNode.textContent);
           break;
 
-        case "Period":
+        case "Period": {
           const [period, periodWarnings] =
             createPeriodIntermediateRepresentation(currentNode);
           periods.push(period);
           warnings = warnings.concat(periodWarnings);
           break;
+        }
 
-        case "UTCTiming":
+        case "UTCTiming": {
           const utcTiming = parseScheme(currentNode);
           utcTimings.push(utcTiming);
           break;
+        }
 
-        case "ContentProtection":
+        case "ContentProtection": {
           const [contentProtection, contentProtectionWarnings] =
             parseContentProtection(currentNode);
           if (contentProtectionWarnings.length > 0) {
@@ -79,6 +82,7 @@ function parseMPDChildren(mpdChildren: NodeList): [IMPDChildren, Error[]] {
             contentProtections.push(contentProtection);
           }
           break;
+        }
       }
     }
   }

package/src/parsers/manifest/dash/native-parser/node_parsers/Period.ts

@@ -47,28 +47,31 @@ function parsePeriodChildren(periodChildren: NodeList): [IPeriodChildren, Error[
       const currentElement = periodChildren[i] as Element;
 
       switch (currentElement.nodeName) {
-        case "BaseURL":
+        case "BaseURL": {
           const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
           if (baseURLObj !== undefined) {
             baseURLs.push(baseURLObj);
           }
           warnings = warnings.concat(baseURLWarnings);
           break;
+        }
 
-        case "AdaptationSet":
+        case "AdaptationSet": {
           const [adaptation, adaptationWarnings] =
             createAdaptationSetIntermediateRepresentation(currentElement);
           adaptations.push(adaptation);
           warnings = warnings.concat(adaptationWarnings);
           break;
+        }
 
-        case "EventStream":
+        case "EventStream": {
           const [eventStream, eventStreamWarnings] = parseEventStream(currentElement);
           eventStreams.push(eventStream);
           warnings = warnings.concat(eventStreamWarnings);
           break;
+        }
 
-        case "SegmentTemplate":
+        case "SegmentTemplate": {
           const [parsedSegmentTemplate, segmentTemplateWarnings] =
             parseSegmentTemplate(currentElement);
           segmentTemplate = parsedSegmentTemplate;
@@ -76,8 +79,9 @@ function parsePeriodChildren(periodChildren: NodeList): [IPeriodChildren, Error[
             warnings = warnings.concat(segmentTemplateWarnings);
           }
           break;
+        }
 
-        case "ContentProtection":
+        case "ContentProtection": {
           const [contentProtection, contentProtectionWarnings] =
             parseContentProtection(currentElement);
           if (contentProtectionWarnings.length > 0) {
@@ -87,6 +91,7 @@ function parsePeriodChildren(periodChildren: NodeList): [IPeriodChildren, Error[
             contentProtections.push(contentProtection);
           }
           break;
+        }
       }
     }
   }

package/src/parsers/manifest/dash/native-parser/node_parsers/Representation.ts

@@ -53,39 +53,43 @@ function parseRepresentationChildren(
       const currentElement = representationChildren[i] as Element;
 
       switch (currentElement.nodeName) {
-        case "BaseURL":
+        case "BaseURL": {
           const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
           if (baseURLObj !== undefined) {
             children.baseURLs.push(baseURLObj);
           }
           warnings = warnings.concat(baseURLWarnings);
           break;
+        }
         case "InbandEventStream":
           if (children.inbandEventStreams === undefined) {
             children.inbandEventStreams = [];
           }
           children.inbandEventStreams.push(parseScheme(currentElement));
           break;
-        case "SegmentBase":
+        case "SegmentBase": {
           const [segmentBase, segmentBaseWarnings] = parseSegmentBase(currentElement);
           children.segmentBase = segmentBase;
           if (segmentBaseWarnings.length > 0) {
             warnings = warnings.concat(segmentBaseWarnings);
           }
           break;
-        case "SegmentList":
+        }
+        case "SegmentList": {
           const [segmentList, segmentListWarnings] = parseSegmentList(currentElement);
           warnings = warnings.concat(segmentListWarnings);
           children.segmentList = segmentList;
           break;
-        case "SegmentTemplate":
+        }
+        case "SegmentTemplate": {
           const [segmentTemplate, segmentTemplateWarnings] =
             parseSegmentTemplate(currentElement);
           warnings = warnings.concat(segmentTemplateWarnings);
           children.segmentTemplate = segmentTemplate;
           break;
+        }
 
-        case "ContentProtection":
+        case "ContentProtection": {
           const [contentProtection, contentProtectionWarnings] =
             parseContentProtection(currentElement);
           if (contentProtectionWarnings.length > 0) {
@@ -95,6 +99,7 @@ function parseRepresentationChildren(
             contentProtections.push(contentProtection);
           }
           break;
+        }
         case "SupplementalProperty":
           if (isNullOrUndefined(children.supplementalProperties)) {
             children.supplementalProperties = [parseScheme(currentElement)];

package/src/parsers/manifest/dash/native-parser/node_parsers/__tests__/ContentProtection.test.ts

@@ -1,18 +1,12 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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-explicit-any */
+import type IParseContentProtection from "../ContentProtection";
 
 function testStringAttribute(attributeName: string, variableName?: string): void {
   const _variableName = variableName ?? attributeName;
 
   it(`should correctly parse a ContentProtection element with a correct ${attributeName} attribute`, async () => {
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element1 = new DOMParser().parseFromString(
       `<ContentProtection ${attributeName}="foobar" />`,
       "text/xml",
@@ -39,9 +33,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
   });
 
   it("should correctly parse a ContentProtection element without attributes", async () => {
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element = new DOMParser().parseFromString("<ContentProtection />", "text/xml")
       .childNodes[0] as Element;
     expect(parseContentProtection(element)).toEqual([
@@ -61,9 +54,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
     vi.doMock("../../../../../../utils/string_parsing", () => ({
       hexToBytes: mockHexToBytes,
     }));
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element1 = new DOMParser()
       .parseFromString(
         `<?xml version="1.0" encoding="utf-8"?>
@@ -97,9 +89,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
     vi.doMock("../../../../../../utils/string_parsing", () => ({
       hexToBytes: mockHexToBytes,
     }));
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element = new DOMParser()
       .parseFromString(
         `<?xml version="1.0" encoding="utf-8"?>
@@ -130,9 +121,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
   });
 
   it("should correctly parse a ContentProtection with cenc:pssh children", async () => {
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element = new DOMParser()
       .parseFromString(
         `<?xml version="1.0" encoding="utf-8"?>
@@ -171,9 +161,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
     vi.doMock("../../../../../../utils/string_parsing", () => ({
       hexToBytes: mockHexToBytes,
     }));
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element = new DOMParser()
       .parseFromString(
         `<?xml version="1.0" encoding="utf-8"?>
@@ -209,9 +198,8 @@ describe("DASH Node Parsers - ContentProtection", () => {
   });
 
   it("should return a warning if one of the cenc:pssh is invalid base64", async () => {
-    const parseContentProtection = (
-      (await vi.importActual("../ContentProtection")) as any
-    ).default;
+    const parseContentProtection = (await vi.importActual("../ContentProtection"))
+      .default as typeof IParseContentProtection;
     const element = new DOMParser()
       .parseFromString(
         `<?xml version="1.0" encoding="utf-8"?>

package/src/parsers/manifest/dash/native-parser/node_parsers/__tests__/Initialization.test.ts

@@ -1,10 +1,6 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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-explicit-any */
+import type IInitialization from "../Initialization";
+import type { MPDError as IMPDError } from "../utils";
 
 describe("DASH Node Parsers - Initialization", () => {
   beforeEach(() => {
@@ -16,8 +12,8 @@ describe("DASH Node Parsers - Initialization", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseInitialization = ((await vi.importActual("../Initialization")) as any)
-      .default;
+    const parseInitialization = (await vi.importActual("../Initialization"))
+      .default as typeof IInitialization;
     const element1 = new DOMParser().parseFromString("<Foo />", "text/xml")
       .childNodes[0] as Element;
     expect(parseInitialization(element1)).toEqual([{}, []]);
@@ -35,8 +31,8 @@ describe("DASH Node Parsers - Initialization", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseInitialization = ((await vi.importActual("../Initialization")) as any)
-      .default;
+    const parseInitialization = (await vi.importActual("../Initialization"))
+      .default as typeof IInitialization;
     const element1 = new DOMParser().parseFromString('<Foo range="0-1" />', "text/xml")
       .childNodes[0] as Element;
     expect(parseInitialization(element1)).toEqual([{ range: [0, 1] }, []]);
@@ -56,9 +52,9 @@ describe("DASH Node Parsers - Initialization", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn").mockImplementation(vi.fn());
 
-    const parseInitialization = ((await vi.importActual("../Initialization")) as any)
-      .default;
-    const MPDError = ((await vi.importActual("../utils")) as any).MPDError;
+    const parseInitialization = (await vi.importActual("../Initialization"))
+      .default as typeof IInitialization;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = new DOMParser().parseFromString('<Foo range="a" />', "text/xml")
       .childNodes[0] as Element;
     const error1 = new MPDError('`range` property has an unrecognized format "a"');
@@ -83,8 +79,8 @@ describe("DASH Node Parsers - Initialization", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseInitialization = ((await vi.importActual("../Initialization")) as any)
-      .default;
+    const parseInitialization = (await vi.importActual("../Initialization"))
+      .default as typeof IInitialization;
     const element1 = new DOMParser().parseFromString('<Foo sourceURL="a" />', "text/xml")
       .childNodes[0] as Element;
     expect(parseInitialization(element1)).toEqual([{ media: "a" }, []]);
@@ -102,8 +98,8 @@ describe("DASH Node Parsers - Initialization", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseInitialization = ((await vi.importActual("../Initialization")) as any)
-      .default;
+    const parseInitialization = (await vi.importActual("../Initialization"))
+      .default as typeof IInitialization;
     const element1 = new DOMParser().parseFromString(
       '<Foo sourceURL="a" range="4-10" />',
       "text/xml",

package/src/parsers/manifest/dash/native-parser/node_parsers/__tests__/SegmentTimeline.test.ts

@@ -1,10 +1,5 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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-explicit-any */
+import type SegmentTimelineParser from "../SegmentTimeline";
 
 describe("DASH Node parsers - SegmentTimeline", () => {
   beforeEach(() => {
@@ -12,8 +7,8 @@ describe("DASH Node parsers - SegmentTimeline", () => {
   });
 
   it("should return a function to parse lazily the timeline", async () => {
-    const parseSegmentTimeline = ((await vi.importActual("../SegmentTimeline")) as any)
-      .default;
+    const parseSegmentTimeline = (await vi.importActual("../SegmentTimeline"))
+      .default as typeof SegmentTimelineParser;
 
     const element = new DOMParser().parseFromString("<Root><S /></Root>", "text/xml")
       .childNodes[0] as Element;
@@ -26,8 +21,8 @@ describe("DASH Node parsers - SegmentTimeline", () => {
   });
 
   it("should return an empty HTMLCollection if no S element is present", async () => {
-    const parseSegmentTimeline = ((await vi.importActual("../SegmentTimeline")) as any)
-      .default;
+    const parseSegmentTimeline = (await vi.importActual("../SegmentTimeline"))
+      .default as typeof SegmentTimelineParser;
 
     const element = new DOMParser().parseFromString("<Root />", "text/xml")
       .childNodes[0] as Element;
@@ -43,8 +38,8 @@ describe("DASH Node parsers - SegmentTimeline", () => {
   });
 
   it("should return an empty HTMLCollection for an Invalid XML", async () => {
-    const parseSegmentTimeline = ((await vi.importActual("../SegmentTimeline")) as any)
-      .default;
+    const parseSegmentTimeline = (await vi.importActual("../SegmentTimeline"))
+      .default as typeof SegmentTimelineParser;
 
     const element = new DOMParser().parseFromString(
       "<Root><S></S><S<S></Root>",
@@ -62,8 +57,8 @@ describe("DASH Node parsers - SegmentTimeline", () => {
   });
 
   it("should parse S elements only when called for the first time", async () => {
-    const parseSegmentTimeline = ((await vi.importActual("../SegmentTimeline")) as any)
-      .default;
+    const parseSegmentTimeline = (await vi.importActual("../SegmentTimeline"))
+      .default as typeof SegmentTimelineParser;
 
     const sElement1 = new DOMParser().parseFromString("<S>1</S>", "text/xml")
       .childNodes[0] as Element;

package/src/parsers/manifest/dash/native-parser/node_parsers/__tests__/SegmentURL.test.ts

@@ -1,10 +1,6 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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-explicit-any */
+import type ISegmentUrl from "../SegmentURL";
+import type { MPDError as IMPDError } from "../utils";
 
 describe("DASH Node Parsers - SegmentURL", () => {
   beforeEach(() => {
@@ -16,7 +12,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
     const element1 = new DOMParser().parseFromString("<Foo />", "text/xml")
       .childNodes[0] as Element;
     expect(parseSegmentURL(element1)).toEqual([{}, []]);
@@ -34,7 +31,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
     const element1 = new DOMParser().parseFromString(
       '<Foo mediaRange="10-100" />',
       "text/xml",
@@ -56,8 +54,9 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn").mockImplementation(vi.fn());
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
-    const MPDError = ((await vi.importActual("../utils")) as any).MPDError;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = new DOMParser().parseFromString('<Foo mediaRange="a" />', "text/xml")
       .childNodes[0] as Element;
     const error1 = new MPDError('`mediaRange` property has an unrecognized format "a"');
@@ -84,7 +83,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
     const element1 = new DOMParser().parseFromString(
       '<Foo indexRange="0-100" />',
       "text/xml",
@@ -106,8 +106,9 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn").mockImplementation(vi.fn());
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
-    const MPDError = ((await vi.importActual("../utils")) as any).MPDError;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = new DOMParser().parseFromString('<Foo indexRange="a" />', "text/xml")
       .childNodes[0] as Element;
     const error1 = new MPDError('`indexRange` property has an unrecognized format "a"');
@@ -132,7 +133,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
     const element1 = new DOMParser().parseFromString('<Foo media="a" />', "text/xml")
       .childNodes[0] as Element;
     expect(parseSegmentURL(element1)).toEqual([{ media: "a" }, []]);
@@ -150,7 +152,8 @@ describe("DASH Node Parsers - SegmentURL", () => {
     vi.doMock("../../../../../../log", () => log);
     const mockLog = vi.spyOn(log.default, "warn");
 
-    const parseSegmentURL = ((await vi.importActual("../SegmentURL")) as any).default;
+    const parseSegmentURL = (await vi.importActual("../SegmentURL"))
+      .default as typeof ISegmentUrl;
     const element1 = new DOMParser().parseFromString('<Foo index="a" />', "text/xml")
       .childNodes[0] as Element;
     expect(parseSegmentURL(element1)).toEqual([{ index: "a" }, []]);