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

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" }, []]);

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -146,9 +146,8 @@ export default class DashWasmParser {
     /** Re-used TextDecoder instance. */
     const textDecoder = new TextDecoder();
 
-    /* eslint-disable @typescript-eslint/no-this-alias */
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
-    /* eslint-enable @typescript-eslint/no-this-alias */
 
     const imports = {
       env: {

package/src/parsers/manifest/dash/wasm-parser/ts/generators/AdaptationSet.ts

@@ -363,10 +363,11 @@ export function generateAdaptationSetAttrParser(
       case AttributeName.AvailabilityTimeComplete:
         adaptationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
         break;
-      case AttributeName.Label:
+      case AttributeName.Label: {
         const label = parseString(textDecoder, linearMemory.buffer, ptr, len);
         adaptationAttrs.label = label;
         break;
+      }
 
       // TODO
       // case AttributeName.StartsWithSap:

package/src/parsers/manifest/dash/wasm-parser/ts/generators/ContentProtection.ts

@@ -41,10 +41,11 @@ export function generateContentProtectionAttrParser(
       case AttributeName.ContentProtectionValue:
         cpAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
-      case AttributeName.ContentProtectionKeyId:
+      case AttributeName.ContentProtectionKeyId: {
         const kid = parseString(textDecoder, linearMemory.buffer, ptr, len);
         cpAttrs.keyId = hexToBytes(kid.replace(/-/g, ""));
         break;
+      }
       case AttributeName.ContentProtectionCencPSSH:
         try {
           const b64 = parseString(textDecoder, linearMemory.buffer, ptr, len);

package/src/parsers/manifest/dash/wasm-parser/ts/generators/EventStream.ts

@@ -80,7 +80,7 @@ export function generateEventStreamAttrParser(
       case AttributeName.TimeScale:
         esAttrs.timescale = dataView.getFloat64(ptr, true);
         break;
-      case AttributeName.Namespace:
+      case AttributeName.Namespace: {
         const xmlNs = { key: "", value: "" };
         let offset = ptr;
         const keySize = dataView.getUint32(offset);
@@ -99,6 +99,7 @@ export function generateEventStreamAttrParser(
           esAttrs.namespaces.push(xmlNs);
         }
         break;
+      }
     }
   };
 }
@@ -127,11 +128,12 @@ function generateEventAttrParser(
       case AttributeName.Id:
         eventAttr.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
-      case AttributeName.EventStreamEltRange:
+      case AttributeName.EventStreamEltRange: {
         const rangeStart = dataView.getFloat64(ptr, true);
         const rangeEnd = dataView.getFloat64(ptr + 8, true);
         eventAttr.eventStreamData = fullMpd.slice(rangeStart, rangeEnd);
         break;
+      }
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/MPD.ts

@@ -122,18 +122,21 @@ export function generateMPDAttrParser(
       case AttributeName.Type:
         mpdAttrs.type = parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
-      case AttributeName.AvailabilityStartTime:
+      case AttributeName.AvailabilityStartTime: {
         const startTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
         mpdAttrs.availabilityStartTime = new Date(startTime).getTime() / 1000;
         break;
-      case AttributeName.AvailabilityEndTime:
+      }
+      case AttributeName.AvailabilityEndTime: {
         const endTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
         mpdAttrs.availabilityEndTime = new Date(endTime).getTime() / 1000;
         break;
-      case AttributeName.PublishTime:
+      }
+      case AttributeName.PublishTime: {
         const publishTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
         mpdAttrs.publishTime = new Date(publishTime).getTime() / 1000;
         break;
+      }
       case AttributeName.MediaPresentationDuration:
         dataView = new DataView(linearMemory.buffer);
         mpdAttrs.duration = dataView.getFloat64(ptr, true);
@@ -162,11 +165,12 @@ export function generateMPDAttrParser(
         dataView = new DataView(linearMemory.buffer);
         mpdAttrs.maxSubsegmentDuration = dataView.getFloat64(ptr, true);
         break;
-      case AttributeName.Location:
+      case AttributeName.Location: {
         const location = parseString(textDecoder, linearMemory.buffer, ptr, len);
         mpdChildren.locations.push(location);
         break;
-      case AttributeName.Namespace:
+      }
+      case AttributeName.Namespace: {
         const xmlNs = { key: "", value: "" };
         dataView = new DataView(linearMemory.buffer);
         let offset = ptr;
@@ -186,6 +190,7 @@ export function generateMPDAttrParser(
           mpdAttrs.namespaces.push(xmlNs);
         }
         break;
+      }
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Period.ts

@@ -183,7 +183,7 @@ export function generatePeriodAttrParser(
         periodAttrs.availabilityTimeComplete =
           new DataView(linearMemory.buffer).getUint8(0) === 0;
         break;
-      case AttributeName.Namespace:
+      case AttributeName.Namespace: {
         const xmlNs = { key: "", value: "" };
         const dataView = new DataView(linearMemory.buffer);
         let offset = ptr;
@@ -203,6 +203,7 @@ export function generatePeriodAttrParser(
           periodAttrs.namespaces.push(xmlNs);
         }
         break;
+      }
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/root.ts

@@ -35,7 +35,7 @@ export function generateRootChildrenParser(
 ): (nodeId: number) => void {
   return function onRootChildren(nodeId: number) {
     switch (nodeId) {
-      case TagName.MPD:
+      case TagName.MPD: {
         rootObj.mpd = {
           children: {
             baseURLs: [],
@@ -58,6 +58,7 @@ export function generateRootChildrenParser(
         );
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
+      }
 
       default:
         // Allows to make sure we're not mistakenly closing a re-opened

package/src/parsers/manifest/local/representation_index.ts

@@ -54,8 +54,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
     const startTime = up;
     const endTime = up + duration;
     const wantedSegments: ILocalIndexSegment[] = [];
-    for (let i = 0; i < this._index.segments.length; i++) {
-      const segment = this._index.segments[i];
+    for (const segment of this._index.segments) {
       const segmentStart = segment.time;
       if (endTime <= segmentStart) {
         break;

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -91,7 +91,7 @@ export default function parseMetaPlaylist(
     try {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       parsedData = JSON.parse(data);
-    } catch (error) {
+    } catch (_error) {
       throw new Error("MPL Parser: Bad MetaPlaylist file. Expected JSON.");
     }
   } else {
@@ -118,8 +118,7 @@ export default function parseMetaPlaylist(
     throw new Error("MPL Parser: No content found.");
   }
   const ressources: Array<{ url: string; transportType: string }> = [];
-  for (let i = 0; i < contents.length; i++) {
-    const content = contents[i];
+  for (const content of contents) {
     if (
       isNullOrUndefined(content.url) ||
       isNullOrUndefined(content.startTime) ||

package/src/parsers/manifest/smooth/create_parser.ts

@@ -312,7 +312,7 @@ function createSmoothStreamingParser(
       root,
       (res, _name, node) => {
         switch (_name) {
-          case "QualityLevel":
+          case "QualityLevel": {
             const qualityLevel = parseQualityLevel(node, adaptationType);
             if (qualityLevel === null) {
               return res;
@@ -326,6 +326,7 @@ function createSmoothStreamingParser(
               res.qualityLevels.push(qualityLevel);
             }
             break;
+          }
           case "c":
             res.cNodes.push(node);
             break;

package/src/parsers/manifest/smooth/shared_smooth_segment_timeline.ts

@@ -200,11 +200,11 @@ export default class SharedSmoothSegmentTimeline {
     }
 
     this.refresh();
-    for (let i = 0; i < nextSegments.length; i++) {
+    for (const nextSeg of nextSegments) {
       addSegmentInfos(
         this.timeline,
         this.timescale,
-        nextSegments[i],
+        nextSeg,
         currentSegment.privateInfos.smoothMediaSegment,
       );
     }