rx-player 4.4.1-dev.2025101500 → 4.4.1

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

@@ -25,7 +25,6 @@ import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
 import { hexToBytes } from "../../../utils/string_parsing";
 import { getFilenameIndexInUrl } from "../../../utils/url-utils";
-import { parseXml, type ITNode } from "../../../utils/xml-parser";
 import { createBox } from "../../containers/isobmff";
 import type {
   IParsedAdaptation,
@@ -45,7 +44,7 @@ import reduceChildren from "./utils/reduceChildren";
 import { replaceRepresentationSmoothTokens } from "./utils/tokens";
 
 interface IAdaptationParserArguments {
-  root: ITNode;
+  root: Element;
   baseUrl: string;
   timescale: number;
   protections: IContentProtectionSmooth[];
@@ -109,7 +108,7 @@ interface ISmoothParsedQualityLevel {
 function createSmoothStreamingParser(
   parserOptions: IHSSParserConfiguration = {},
 ): (
-  manifest: string,
+  manifest: Document,
   url?: string | undefined,
   manifestReceivedTime?: number | undefined,
 ) => IParsedManifest {
@@ -129,12 +128,12 @@ function createSmoothStreamingParser(
       : undefined;
 
   /**
-   * @param {Object} q
+   * @param {Element} q
    * @param {string} streamType
    * @return {Object}
    */
   function parseQualityLevel(
-    q: ITNode,
+    q: Element,
     streamType: string,
   ): ISmoothParsedQualityLevel | null {
     const customAttributes = reduceChildren<string[]>(
@@ -146,9 +145,9 @@ function createSmoothStreamingParser(
               qNode,
               (cAttrs, cName, cNode) => {
                 if (cName === "Attribute") {
-                  const name = cNode.attributes.Name;
-                  const value = cNode.attributes.Value;
-                  if (!isNullOrUndefined(name) && !isNullOrUndefined(value)) {
+                  const name = cNode.getAttribute("Name");
+                  const value = cNode.getAttribute("Value");
+                  if (name !== null && value !== null) {
                     cAttrs.push(name + "=" + value);
                   }
                 }
@@ -168,7 +167,7 @@ function createSmoothStreamingParser(
      * @returns {string|undefined}
      */
     function getAttribute(name: string): string | undefined {
-      const attr = q.attributes[name];
+      const attr = q.getAttribute(name);
       return attr === null ? undefined : attr;
     }
 
@@ -287,14 +286,14 @@ function createSmoothStreamingParser(
       manifestReceivedTime,
       isLive,
     } = args;
-    const timescaleAttr = root.attributes.Timescale;
-    let _timescale = !isNonEmptyString(timescaleAttr) ? timescale : +timescaleAttr;
+    const timescaleAttr = root.getAttribute("Timescale");
+    let _timescale = timescaleAttr === null ? timescale : +timescaleAttr;
     if (isNaN(_timescale)) {
       _timescale = timescale;
     }
 
-    const typeAttribute = root.attributes.Type;
-    if (isNullOrUndefined(typeAttribute)) {
+    const typeAttribute = root.getAttribute("Type");
+    if (typeAttribute === null) {
       throw new Error("StreamIndex without type.");
     }
     if (!arrayIncludes(SUPPORTED_ADAPTATIONS_TYPE, typeAttribute)) {
@@ -302,15 +301,15 @@ function createSmoothStreamingParser(
     }
     const adaptationType = typeAttribute as IAdaptationType;
 
-    const subType = root.attributes.Subtype;
-    const language = root.attributes.Language;
-    const UrlAttr = root.attributes.Url;
-    const UrlPathWithTokens = UrlAttr ?? "";
+    const subType = root.getAttribute("Subtype");
+    const language = root.getAttribute("Language");
+    const UrlAttr = root.getAttribute("Url");
+    const UrlPathWithTokens = UrlAttr === null ? "" : UrlAttr;
     assert(UrlPathWithTokens !== "");
 
     const { qualityLevels, cNodes } = reduceChildren<{
       qualityLevels: ISmoothParsedQualityLevel[];
-      cNodes: ITNode[];
+      cNodes: Element[];
     }>(
       root,
       (res, _name, node) => {
@@ -453,36 +452,31 @@ function createSmoothStreamingParser(
     return parsedAdaptation;
   }
 
-  function parseFromNode(
-    xml: string,
+  function parseFromDocument(
+    doc: Document,
     url?: string,
     manifestReceivedTime?: number,
   ): IParsedManifest {
-    const parsed = parseXml(xml);
-    const root = parsed[parsed.length - 1];
     let baseUrl: string = "";
     if (url !== undefined) {
       const filenameIdx = getFilenameIndexInUrl(url);
       baseUrl = url.substring(0, filenameIdx);
     }
-    if (
-      isNullOrUndefined(root) ||
-      typeof root === "string" ||
-      root.tagName !== "SmoothStreamingMedia"
-    ) {
+    const root = doc.documentElement;
+    if (isNullOrUndefined(root) || root.nodeName !== "SmoothStreamingMedia") {
       throw new Error("document root should be SmoothStreamingMedia");
     }
-    const majorVersionAttr = root.attributes.MajorVersion;
-    const minorVersionAttr = root.attributes.MinorVersion;
+    const majorVersionAttr = root.getAttribute("MajorVersion");
+    const minorVersionAttr = root.getAttribute("MinorVersion");
     if (
-      isNullOrUndefined(majorVersionAttr) ||
-      isNullOrUndefined(minorVersionAttr) ||
+      majorVersionAttr === null ||
+      minorVersionAttr === null ||
       !/^[2]-[0-2]$/.test(majorVersionAttr + "-" + minorVersionAttr)
     ) {
       throw new Error("Version should be 2.0, 2.1 or 2.2");
     }
 
-    const timescaleAttr = root.attributes.Timescale;
+    const timescaleAttr = root.getAttribute("Timescale");
     let timescale = !isNonEmptyString(timescaleAttr) ? 10000000 : +timescaleAttr;
     if (isNaN(timescale)) {
       timescale = 10000000;
@@ -490,7 +484,7 @@ function createSmoothStreamingParser(
 
     const { protections, adaptationNodes } = reduceChildren<{
       protections: IContentProtectionSmooth[];
-      adaptationNodes: ITNode[];
+      adaptationNodes: Element[];
     }>(
       root,
       (res, name, node) => {
@@ -513,13 +507,13 @@ function createSmoothStreamingParser(
 
     const initialAdaptations: IParsedAdaptations = {};
 
-    const isLive = parseBoolean(root.attributes.IsLive);
+    const isLive = parseBoolean(root.getAttribute("IsLive"));
 
     let timeShiftBufferDepth: number | undefined;
     if (isLive) {
-      const dvrWindowLength = root.attributes.DVRWindowLength;
+      const dvrWindowLength = root.getAttribute("DVRWindowLength");
       if (
-        !isNullOrUndefined(dvrWindowLength) &&
+        dvrWindowLength !== null &&
         !isNaN(+dvrWindowLength) &&
         +dvrWindowLength !== 0
       ) {
@@ -528,7 +522,7 @@ function createSmoothStreamingParser(
     }
 
     const adaptations: IParsedAdaptations = adaptationNodes.reduce(
-      (acc: IParsedAdaptations, node: ITNode) => {
+      (acc: IParsedAdaptations, node: Element) => {
         const adaptation = parseAdaptation({
           root: node,
           baseUrl,
@@ -628,9 +622,9 @@ function createSmoothStreamingParser(
       }
     }
 
-    const manifestDuration = root.attributes.Duration;
+    const manifestDuration = root.getAttribute("Duration");
     const duration =
-      !isNullOrUndefined(manifestDuration) && +manifestDuration !== 0
+      manifestDuration !== null && +manifestDuration !== 0
         ? +manifestDuration / timescale
         : undefined;
 
@@ -700,7 +694,7 @@ function createSmoothStreamingParser(
     return manifest;
   }
 
-  return parseFromNode;
+  return parseFromDocument;
 }
 
 /**

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

@@ -15,7 +15,6 @@
  */
 
 import isNonEmptyString from "../../../utils/is_non_empty_string";
-import type { ITNode } from "../../../utils/xml-parser";
 
 interface IHSSManifestSegment {
   start: number;
@@ -25,18 +24,13 @@ interface IHSSManifestSegment {
 
 /**
  * Parse C nodes to build index timeline.
- * @param {Object} nodes
+ * @param {Element} nodes
  */
-export default function parseCNodes(
-  nodes: Array<ITNode | string>,
-): IHSSManifestSegment[] {
+export default function parseCNodes(nodes: Element[]): IHSSManifestSegment[] {
   return nodes.reduce<IHSSManifestSegment[]>((timeline, node, i) => {
-    if (typeof node === "string") {
-      return timeline;
-    }
-    const dAttr = node.attributes.d ?? null;
-    const tAttr = node.attributes.t ?? null;
-    const rAttr = node.attributes.r ?? null;
+    const dAttr = node.getAttribute("d");
+    const tAttr = node.getAttribute("t");
+    const rAttr = node.getAttribute("r");
 
     const repeatCount = rAttr !== null ? +rAttr - 1 : 0;
     let start = tAttr !== null ? +tAttr : undefined;
@@ -56,14 +50,9 @@ export default function parseCNodes(
       }
     }
     if (duration === undefined || isNaN(duration)) {
-      let nextNodeIdx = i;
-      let nextNodeElt: ITNode | undefined | string;
-      do {
-        nextNodeIdx++;
-        nextNodeElt = nodes[nextNodeIdx];
-      } while (nextNodeElt !== undefined && typeof nextNodeElt === "string");
-      if (nextNodeElt !== undefined) {
-        const nextTAttr = nextNodeElt.attributes.t ?? null;
+      const nextNode = nodes[i + 1];
+      if (nextNode !== undefined) {
+        const nextTAttr = nextNode.getAttribute("t");
         const nextStart = isNonEmptyString(nextTAttr) ? +nextTAttr : null;
         if (nextStart === null) {
           throw new Error("Can't build index timeline from Smooth Manifest.");

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

@@ -17,7 +17,6 @@
 import { base64ToBytes } from "../../../utils/base64";
 import { concat } from "../../../utils/byte_parsing";
 import { hexToBytes } from "../../../utils/string_parsing";
-import type { ITNode } from "../../../utils/xml-parser";
 import { getPlayReadyKIDFromPrivateData } from "../../containers/isobmff";
 
 export interface IKeySystem {
@@ -45,35 +44,28 @@ function createWidevineKeySystem(keyIdBytes: Uint8Array): IKeySystem[] {
 
 /**
  * Parse "Protection" Node, which contains DRM information
- * @param {Object} protectionNode
+ * @param {Element} protectionNode
  * @returns {Object}
  */
 export default function parseProtectionNode(
-  protectionNode: ITNode,
+  protectionNode: Element,
   keySystemCreator: (keyId: Uint8Array) => IKeySystem[] = createWidevineKeySystem,
 ): IContentProtectionSmooth {
-  let header;
-  for (const subNode of protectionNode.children) {
-    if (typeof subNode === "string") {
-      continue;
-    }
-    if (subNode.tagName === "ProtectionHeader") {
-      header = subNode;
-      break;
-    }
-  }
-  if (header === undefined) {
+  if (
+    protectionNode.firstElementChild === null ||
+    protectionNode.firstElementChild.nodeName !== "ProtectionHeader"
+  ) {
     throw new Error("Protection should have ProtectionHeader child");
   }
-
+  const header = protectionNode.firstElementChild;
   const privateData = base64ToBytes(
-    typeof header.children[0] === "string" ? header.children[0] : "",
+    header.textContent === null ? "" : header.textContent,
   );
   const keyIdHex = getPlayReadyKIDFromPrivateData(privateData);
   const keyIdBytes = hexToBytes(keyIdHex);
 
   // remove possible braces
-  const systemIdAttr = header.attributes.SystemID ?? null;
+  const systemIdAttr = header.getAttribute("SystemID");
   const systemId = (systemIdAttr !== null ? systemIdAttr : "")
     .toLowerCase()
     .replace(/\{|\}/g, "");

package/src/parsers/manifest/smooth/utils/parseBoolean.ts

@@ -18,7 +18,7 @@
  * @param {*} val
  * @returns {Boolean}
  */
-export default function parseBoolean(val: string | null | undefined | boolean): boolean {
+export default function parseBoolean(val: string | null): boolean {
   if (typeof val === "boolean") {
     return val;
   } else if (typeof val === "string") {

package/src/parsers/manifest/smooth/utils/reduceChildren.ts

@@ -14,26 +14,23 @@
  * limitations under the License.
  */
 
-import type { ITNode } from "../../../../utils/xml-parser";
-
 /**
  * Reduce implementation for the children of the given element.
- * @param {Object} root
+ * @param {Element} root
  * @param {Function} fn
  * @param {*} init
  * @returns {*}
  */
 export default function reduceChildren<T>(
-  root: ITNode,
-  fn: (accu: T, nodeName: string, nodeElt: ITNode) => T,
+  root: Element,
+  fn: (accu: T, nodeName: string, nodeElt: Element) => T,
   init: T,
 ): T {
+  let node = root.firstElementChild;
   let accumulator = init;
-  for (const elt of root.children) {
-    if (typeof elt === "string") {
-      continue;
-    }
-    accumulator = fn(accumulator, elt.tagName, elt);
+  while (node !== null) {
+    accumulator = fn(accumulator, node.nodeName, node);
+    node = node.nextElementSibling;
   }
   return accumulator;
 }