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

package/src/parsers/manifest/dash/common/__tests__/get_http_utc-timing_url.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 { IMPDIntermediateRepresentation } from "../../node_parser_types";
+import type IGetHTTPUTCTimingURL from "../get_http_utc-timing_url";
 
 describe("DASH Parser - getHTTPUTCTimingURL", () => {
   beforeEach(() => {
@@ -12,21 +8,26 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
   });
 
   it("should return undefined if the given intermediate representation has no UTCTimings element", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [],
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual(undefined);
   });
 
   it("should return undefined if the given intermediate representation has no http-iso UTCTimings element", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [
           {
             schemeIdUri: "urn:mpeg:dash:utc:direct-iso:2014",
@@ -40,15 +41,17 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual(undefined);
   });
 
   it("should return undefined if the given intermediate representation has no value for its http-iso UTCTimings element", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [
           {
             schemeIdUri: "urn:mpeg:dash:utc:http-iso:2014",
@@ -64,15 +67,17 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual(undefined);
   });
 
   it("should return the value of a single http-iso UTCTimings element", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [
           {
             schemeIdUri: "urn:mpeg:dash:utc:http-iso:2014",
@@ -82,15 +87,17 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual("foobar2000");
   });
 
   it("should return the first value of multiple http-iso UTCTimings elements", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [
           {
             schemeIdUri: "urn:mpeg:dash:utc:http-iso:2014",
@@ -108,15 +115,17 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual("foobar1000");
   });
 
   it("should return the first value of a http-iso UTCTimings element when mixed with other elements", async () => {
-    const mpdIR = {
+    const mpdIR: IMPDIntermediateRepresentation = {
       children: {
+        baseURLs: [],
+        locations: [],
+        periods: [],
         utcTimings: [
           {
             schemeIdUri: "urn:mpeg:dash:utc:direct-iso:2014",
@@ -142,9 +151,8 @@ describe("DASH Parser - getHTTPUTCTimingURL", () => {
       },
       attributes: {},
     };
-    const getHTTPUTCTimingURL = (
-      (await vi.importActual("../get_http_utc-timing_url")) as any
-    ).default;
+    const getHTTPUTCTimingURL = (await vi.importActual("../get_http_utc-timing_url"))
+      .default as typeof IGetHTTPUTCTimingURL;
     expect(getHTTPUTCTimingURL(mpdIR)).toEqual("foobar2000");
   });
 });

package/src/parsers/manifest/dash/common/__tests__/get_periods_time_infos.test.ts

@@ -1,10 +1,7 @@
 import { describe, it, expect } from "vitest";
 import type { IPeriodIntermediateRepresentation } from "../../node_parser_types";
 import type { IParsedPeriodsContext } from "../get_periods_time_infos";
-// https://github.com/typescript-eslint/typescript-eslint/issues/2315
-/* eslint-disable no-duplicate-imports */
 import getPeriodsTimeInformation from "../get_periods_time_infos";
-/* eslint-enable no-duplicate-imports */
 
 describe("DASH Parser - getPeriodsTimeInformation", () => {
   it("should guess duration and end from next period.", () => {

package/src/parsers/manifest/dash/common/indexes/timeline/parse_s_element.ts

@@ -47,7 +47,7 @@ export function parseSElementNode(root: ITNode): IParsedS {
       continue;
     }
     switch (attributeName) {
-      case "t":
+      case "t": {
         const start = parseInt(attributeVal, 10);
         if (isNaN(start)) {
           log.warn(`DASH: invalid t ("${attributeVal}")`);
@@ -55,7 +55,8 @@ export function parseSElementNode(root: ITNode): IParsedS {
           parsedS.start = start;
         }
         break;
-      case "d":
+      }
+      case "d": {
         const duration = parseInt(attributeVal, 10);
         if (isNaN(duration)) {
           log.warn(`DASH: invalid d ("${attributeVal}")`);
@@ -63,7 +64,8 @@ export function parseSElementNode(root: ITNode): IParsedS {
           parsedS.duration = duration;
         }
         break;
-      case "r":
+      }
+      case "r": {
         const repeatCount = parseInt(attributeVal, 10);
         if (isNaN(repeatCount)) {
           log.warn(`DASH: invalid r ("${attributeVal}")`);
@@ -71,6 +73,7 @@ export function parseSElementNode(root: ITNode): IParsedS {
           parsedS.repeatCount = repeatCount;
         }
         break;
+      }
     }
   }
   return parsedS;
@@ -88,7 +91,7 @@ export function parseSHTMLElement(root: Element): IParsedS {
   for (let j = 0; j < root.attributes.length; j++) {
     const attribute = root.attributes[j];
     switch (attribute.name) {
-      case "t":
+      case "t": {
         const start = parseInt(attribute.value, 10);
         if (isNaN(start)) {
           log.warn(`DASH: invalid t ("${attribute.value}")`);
@@ -96,7 +99,8 @@ export function parseSHTMLElement(root: Element): IParsedS {
           parsedS.start = start;
         }
         break;
-      case "d":
+      }
+      case "d": {
         const duration = parseInt(attribute.value, 10);
         if (isNaN(duration)) {
           log.warn(`DASH: invalid d ("${attribute.value}")`);
@@ -104,7 +108,8 @@ export function parseSHTMLElement(root: Element): IParsedS {
           parsedS.duration = duration;
         }
         break;
-      case "r":
+      }
+      case "r": {
         const repeatCount = parseInt(attribute.value, 10);
         if (isNaN(repeatCount)) {
           log.warn(`DASH: invalid r ("${attribute.value}")`);
@@ -112,6 +117,7 @@ export function parseSHTMLElement(root: Element): IParsedS {
           parsedS.repeatCount = repeatCount;
         }
         break;
+      }
     }
   }
   return parsedS;

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

@@ -67,7 +67,7 @@ function parseAdaptationSetChildren(
         }
         break;
 
-      case "BaseURL":
+      case "BaseURL": {
         const [baseURLObj, baseURLWarnings] = parseBaseURL(currentNode);
         if (baseURLObj !== undefined) {
           children.baseURLs.push(baseURLObj);
@@ -76,6 +76,7 @@ function parseAdaptationSetChildren(
           warnings = warnings.concat(baseURLWarnings);
         }
         break;
+      }
 
       case "ContentComponent":
         children.contentComponent = parseContentComponent(currentNode);
@@ -96,15 +97,16 @@ function parseAdaptationSetChildren(
         children.inbandEventStreams.push(parseScheme(currentNode));
         break;
 
-      case "Label":
+      case "Label": {
         const label = textContent(currentNode.children);
 
         if (label !== null && label !== undefined) {
           children.label = label;
         }
         break;
+      }
 
-      case "Representation":
+      case "Representation": {
         const [representation, representationWarnings] =
           createRepresentationIntermediateRepresentation(currentNode);
         children.representations.push(representation);
@@ -112,6 +114,7 @@ function parseAdaptationSetChildren(
           warnings = warnings.concat(representationWarnings);
         }
         break;
+      }
 
       case "Role":
         if (isNullOrUndefined(children.roles)) {
@@ -129,23 +132,25 @@ function parseAdaptationSetChildren(
         }
         break;
 
-      case "SegmentBase":
+      case "SegmentBase": {
         const [segmentBase, segmentBaseWarnings] = parseSegmentBase(currentNode);
         children.segmentBase = segmentBase;
         if (segmentBaseWarnings.length > 0) {
           warnings = warnings.concat(segmentBaseWarnings);
         }
         break;
+      }
 
-      case "SegmentList":
+      case "SegmentList": {
         const [segmentList, segmentListWarnings] = parseSegmentList(currentNode);
         children.segmentList = segmentList;
         if (segmentListWarnings.length > 0) {
           warnings = warnings.concat(segmentListWarnings);
         }
         break;
+      }
 
-      case "SegmentTemplate":
+      case "SegmentTemplate": {
         const [segmentTemplate, segmentTemplateWarnings] =
           parseSegmentTemplate(currentNode);
         children.segmentTemplate = segmentTemplate;
@@ -153,8 +158,9 @@ function parseAdaptationSetChildren(
           warnings = warnings.concat(segmentTemplateWarnings);
         }
         break;
+      }
 
-      case "ContentProtection":
+      case "ContentProtection": {
         const [contentProtection, contentProtectionWarnings] =
           parseContentProtection(currentNode);
         if (contentProtectionWarnings.length > 0) {
@@ -164,6 +170,7 @@ function parseAdaptationSetChildren(
           contentProtections.push(contentProtection);
         }
         break;
+      }
 
       // case "Rating":
       //   children.rating = currentNode;

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

@@ -59,19 +59,20 @@ function parseMPDChildren(
       continue;
     }
     switch (currentNode.tagName) {
-      case "BaseURL":
+      case "BaseURL": {
         const [baseURLObj, baseURLWarnings] = parseBaseURL(currentNode);
         if (baseURLObj !== undefined) {
           baseURLs.push(baseURLObj);
         }
         warnings = warnings.concat(baseURLWarnings);
         break;
+      }
 
       case "Location":
         locations.push(textContent(currentNode.children));
         break;
 
-      case "Period":
+      case "Period": {
         const [period, periodWarnings] = createPeriodIntermediateRepresentation(
           currentNode,
           fullMpd,
@@ -79,13 +80,15 @@ function parseMPDChildren(
         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) {
@@ -95,6 +98,7 @@ function parseMPDChildren(
           contentProtections.push(contentProtection);
         }
         break;
+      }
     }
   }
   return [{ baseURLs, locations, periods, utcTimings, contentProtections }, warnings];

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

@@ -56,29 +56,32 @@ function parsePeriodChildren(
       continue;
     }
     switch (currentElement.tagName) {
-      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] =
           createEventStreamIntermediateRepresentation(currentElement, fullMpd);
         eventStreams.push(eventStream);
         warnings = warnings.concat(eventStreamWarnings);
         break;
+      }
 
-      case "SegmentTemplate":
+      case "SegmentTemplate": {
         const [parsedSegmentTemplate, segmentTemplateWarnings] =
           parseSegmentTemplate(currentElement);
         segmentTemplate = parsedSegmentTemplate;
@@ -86,8 +89,9 @@ function parsePeriodChildren(
           warnings = warnings.concat(segmentTemplateWarnings);
         }
         break;
+      }
 
-      case "ContentProtection":
+      case "ContentProtection": {
         const [contentProtection, contentProtectionWarnings] =
           parseContentProtection(currentElement);
         if (contentProtectionWarnings.length > 0) {
@@ -97,6 +101,7 @@ function parsePeriodChildren(
           contentProtections.push(contentProtection);
         }
         break;
+      }
     }
   }
 

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

@@ -56,39 +56,43 @@ function parseRepresentationChildren(
     }
 
     switch (currentElement.tagName) {
-      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) {
@@ -98,6 +102,7 @@ function parseRepresentationChildren(
           contentProtections.push(contentProtection);
         }
         break;
+      }
       case "SupplementalProperty":
         if (isNullOrUndefined(children.supplementalProperties)) {
           children.supplementalProperties = [parseScheme(currentElement)];

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

@@ -1,20 +1,14 @@
 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 IContentProtection 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 IContentProtection;
     const element1 = parseXml(
       `<ContentProtection ${attributeName}="foobar" />`,
     )[0] as ITNode;
@@ -37,9 +31,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 IContentProtection;
     const element = parseXml("<ContentProtection />")[0] as ITNode;
     expect(parseContentProtection(element)).toEqual([
       { attributes: {}, children: { cencPssh: [] } },
@@ -58,9 +51,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 IContentProtection;
     const element1 = parseXml(
       '<ContentProtection cenc:default_KID="dead-beef" />',
     )[0] as ITNode;
@@ -81,9 +73,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 IContentProtection;
     const element = parseXml(
       `<ContentProtection
     schemeIdUri="foo"
@@ -101,9 +92,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 IContentProtection;
     const element = parseXml(
       `<ContentProtection>
     <cenc:pssh>AABBCC</cenc:pssh>
@@ -131,9 +121,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 IContentProtection;
     const element = parseXml(
       `<ContentProtection
     schemeIdUri="foo"
@@ -156,9 +145,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 IContentProtection;
     const element = parseXml(
       `<ContentProtection>
     <cenc:pssh>AA!BCC</cenc:pssh>

package/src/parsers/manifest/dash/fast-js-parser/node_parsers/__tests__/Initialization.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 IParseInitialization from "../Initialization";
+import type { MPDError as IMPDError } from "../utils";
 
 describe("DASH Node Parsers - Initialization", () => {
   beforeEach(() => {
@@ -18,8 +14,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 IParseInitialization;
     const element1 = parseXml("<Foo />")[0] as ITNode;
     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 IParseInitialization;
     const element1 = parseXml('<Foo range="0-1" />')[0] as ITNode;
     expect(parseInitialization(element1)).toEqual([{ range: [0, 1] }, []]);
 
@@ -52,9 +48,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 IParseInitialization;
+    const MPDError = (await vi.importActual("../utils")).MPDError as typeof IMPDError;
     const element1 = parseXml('<Foo range="a" />')[0] as ITNode;
     const error1 = new MPDError('`range` property has an unrecognized format "a"');
     expect(parseInitialization(element1)).toEqual([{}, [error1]]);
@@ -77,8 +73,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 IParseInitialization;
     const element1 = parseXml('<Foo sourceURL="a" />')[0] as ITNode;
     expect(parseInitialization(element1)).toEqual([{ media: "a" }, []]);
 
@@ -94,8 +90,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 IParseInitialization;
     const element1 = parseXml('<Foo sourceURL="a" range="4-10" />')[0] as ITNode;
     expect(parseInitialization(element1)).toEqual([{ media: "a", range: [4, 10] }, []]);