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

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

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;
+        }
       }
     }
   }