rx-player 3.33.0 → 3.33.1

package/src/manifest/types.ts

@@ -1,33 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/** Enumerate the different ways a Manifest update can be done. */
-export enum MANIFEST_UPDATE_TYPE {
-  /**
-   * Manifest is updated entirely thanks to a re-downloaded version of
-   * the original manifest document.
-   */
-  Full,
-  /**
-   * Manifest is updated partially thanks to a shortened version
-   * of the manifest document. The latter's URL might be different
-   * from the original one.
-   */
-  Partial,
-}
-
-/** Every possible value for the Adaptation's `type` property. */
-export type IAdaptationType = "video" | "audio" | "text" | "image";

package/src/manifest/update_period_in_place.ts

@@ -1,142 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import log from "../log";
-import arrayFindIndex from "../utils/array_find_index";
-import Adaptation from "./adaptation";
-import Period from "./period";
-import Representation from "./representation";
-import { MANIFEST_UPDATE_TYPE } from "./types";
-
-/**
- * Update oldPeriod attributes with the one from newPeriod (e.g. when updating
- * the Manifest).
- * @param {Object} oldPeriod
- * @param {Object} newPeriod
- * @param {number} updateType
- * @returns {Object}
- */
-export default function updatePeriodInPlace(
-  oldPeriod : Period,
-  newPeriod : Period,
-  updateType : MANIFEST_UPDATE_TYPE
-) : IUpdatedPeriodResult {
-  const res : IUpdatedPeriodResult = {
-    updatedAdaptations: [],
-    removedAdaptations: [],
-    addedAdaptations: [],
-  };
-  oldPeriod.start = newPeriod.start;
-  oldPeriod.end = newPeriod.end;
-  oldPeriod.duration = newPeriod.duration;
-  oldPeriod.streamEvents = newPeriod.streamEvents;
-
-  const oldAdaptations = oldPeriod.getAdaptations();
-  const newAdaptations = newPeriod.getAdaptations();
-
-  for (let j = 0; j < oldAdaptations.length; j++) {
-    const oldAdaptation = oldAdaptations[j];
-    const newAdaptationIdx = arrayFindIndex(newAdaptations,
-                                            a => a.id === oldAdaptation.id);
-
-    if (newAdaptationIdx === -1) {
-      log.warn("Manifest: Adaptation \"" +
-               oldAdaptations[j].id +
-               "\" not found when merging.");
-      const [removed] = oldAdaptations.splice(j, 1);
-      j--;
-      res.removedAdaptations.push(removed);
-    } else {
-      const [newAdaptation] = newAdaptations.splice(newAdaptationIdx, 1);
-      const updatedRepresentations : Representation[] = [];
-      const addedRepresentations : Representation[] = [];
-      const removedRepresentations : Representation[] = [];
-      res.updatedAdaptations.push({ adaptation: oldAdaptation,
-                                    updatedRepresentations,
-                                    addedRepresentations,
-                                    removedRepresentations });
-
-      const oldRepresentations = oldAdaptation.representations;
-      const newRepresentations = newAdaptation.representations.slice();
-
-      for (let k = 0; k < oldRepresentations.length; k++) {
-        const oldRepresentation = oldRepresentations[k];
-        const newRepresentationIdx = arrayFindIndex(newRepresentations, representation =>
-          representation.id === oldRepresentation.id);
-
-        if (newRepresentationIdx === -1) {
-          log.warn(`Manifest: Representation "${oldRepresentations[k].id}" ` +
-                   "not found when merging.");
-          const [removed] = oldRepresentations.splice(k, 1);
-          k--;
-          removedRepresentations.push(removed);
-        } else {
-          const [newRepresentation] = newRepresentations.splice(newRepresentationIdx, 1);
-          updatedRepresentations.push(oldRepresentation);
-          oldRepresentation.cdnMetadata = newRepresentation.cdnMetadata;
-          if (updateType === MANIFEST_UPDATE_TYPE.Full) {
-            oldRepresentation.index._replace(newRepresentation.index);
-          } else {
-            oldRepresentation.index._update(newRepresentation.index);
-          }
-        }
-      }
-
-      if (newRepresentations.length > 0) {
-        log.warn(`Manifest: ${newRepresentations.length} new Representations ` +
-                 "found when merging.");
-        oldAdaptation.representations.push(...newRepresentations);
-        addedRepresentations.push(...newRepresentations);
-      }
-    }
-  }
-  if (newAdaptations.length > 0) {
-    log.warn(`Manifest: ${newAdaptations.length} new Adaptations ` +
-             "found when merging.");
-    for (const adap of newAdaptations) {
-      const prevAdaps = oldPeriod.adaptations[adap.type];
-      if (prevAdaps === undefined) {
-        oldPeriod.adaptations[adap.type] = [adap];
-      } else {
-        prevAdaps.push(adap);
-      }
-      res.addedAdaptations.push(adap);
-    }
-  }
-  return res;
-}
-
-/**
- * Object describing the updates performed by `updatePeriodInPlace` on a single
- * Period.
- */
-export interface IUpdatedPeriodResult {
-  /** Information on Adaptations that have been updated. */
-  updatedAdaptations : Array<{
-    /** The concerned Adaptation. */
-    adaptation: Adaptation;
-    /** Representations that have been updated. */
-    updatedRepresentations : Representation[];
-    /** Representations that have been removed from the Adaptation. */
-    removedRepresentations : Representation[];
-    /** Representations that have been added to the Adaptation. */
-    addedRepresentations : Representation[];
-  }>;
-  /** Adaptation that have been removed from the Period. */
-  removedAdaptations : Adaptation[];
-  /** Adaptation that have been added to the Period. */
-  addedAdaptations : Adaptation[];
-}

package/src/manifest/update_periods.ts

@@ -1,201 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { MediaError } from "../errors";
-import log from "../log";
-import arrayFindIndex from "../utils/array_find_index";
-import Period from "./period";
-import { MANIFEST_UPDATE_TYPE } from "./types";
-import updatePeriodInPlace, {
-  IUpdatedPeriodResult,
-} from "./update_period_in_place";
-
-/**
- * Update old periods by adding new periods and removing
- * not available ones.
- * @param {Array.<Object>} oldPeriods
- * @param {Array.<Object>} newPeriods
- * @returns {Object}
- */
-export function replacePeriods(
-  oldPeriods: Period[],
-  newPeriods: Period[]
-) : IPeriodsUpdateResult {
-  const res : IPeriodsUpdateResult = {
-    updatedPeriods: [],
-    addedPeriods: [],
-    removedPeriods: [],
-  };
-  let firstUnhandledPeriodIdx = 0;
-  for (let i = 0; i < newPeriods.length; i++) {
-    const newPeriod = newPeriods[i];
-    let j = firstUnhandledPeriodIdx;
-    let oldPeriod = oldPeriods[j];
-    while (oldPeriod != null && oldPeriod.id !== newPeriod.id) {
-      j++;
-      oldPeriod = oldPeriods[j];
-    }
-    if (oldPeriod != null) {
-      const result = updatePeriodInPlace(oldPeriod, newPeriod, MANIFEST_UPDATE_TYPE.Full);
-      res.updatedPeriods.push({ period: oldPeriod, result });
-      const periodsToInclude = newPeriods.slice(firstUnhandledPeriodIdx, i);
-      const nbrOfPeriodsToRemove = j - firstUnhandledPeriodIdx;
-      const removed = oldPeriods.splice(firstUnhandledPeriodIdx,
-                                        nbrOfPeriodsToRemove,
-                                        ...periodsToInclude);
-      res.removedPeriods.push(...removed);
-      res.addedPeriods.push(...periodsToInclude);
-      firstUnhandledPeriodIdx = i + 1;
-    }
-  }
-
-  if (firstUnhandledPeriodIdx > oldPeriods.length) {
-    log.error("Manifest: error when updating Periods");
-    return res;
-  }
-  if (firstUnhandledPeriodIdx < oldPeriods.length) {
-    const removed = oldPeriods.splice(firstUnhandledPeriodIdx,
-                                      oldPeriods.length - firstUnhandledPeriodIdx);
-    res.removedPeriods.push(...removed);
-  }
-  const remainingNewPeriods = newPeriods.slice(firstUnhandledPeriodIdx,
-                                               newPeriods.length);
-  if (remainingNewPeriods.length > 0) {
-    oldPeriods.push(...remainingNewPeriods);
-    res.addedPeriods.push(...remainingNewPeriods);
-  }
-  return res;
-}
-
-/**
- * Update old periods by adding new periods and removing
- * not available ones.
- * @param {Array.<Object>} oldPeriods
- * @param {Array.<Object>} newPeriods
- * @returns {Object}
- */
-export function updatePeriods(
-  oldPeriods: Period[],
-  newPeriods: Period[]
-) : IPeriodsUpdateResult {
-  const res : IPeriodsUpdateResult = {
-    updatedPeriods: [],
-    addedPeriods: [],
-    removedPeriods: [],
-  };
-  if (oldPeriods.length === 0) {
-    oldPeriods.splice(0, 0, ...newPeriods);
-    res.addedPeriods.push(...newPeriods);
-    return res;
-  }
-  if (newPeriods.length === 0) {
-    return res;
-  }
-  const oldLastPeriod = oldPeriods[oldPeriods.length - 1];
-  if (oldLastPeriod.start < newPeriods[0].start) {
-    if (oldLastPeriod.end !== newPeriods[0].start) {
-      throw new MediaError("MANIFEST_UPDATE_ERROR",
-                           "Cannot perform partial update: not enough data");
-    }
-    oldPeriods.push(...newPeriods);
-    res.addedPeriods.push(...newPeriods);
-    return res;
-  }
-
-  /** Index, in `oldPeriods` of the first element of `newPeriods` */
-  const indexOfNewFirstPeriod = arrayFindIndex(oldPeriods,
-                                               ({ id }) => id === newPeriods[0].id);
-  if (indexOfNewFirstPeriod < 0) {
-    throw new MediaError("MANIFEST_UPDATE_ERROR",
-                         "Cannot perform partial update: incoherent data");
-  }
-
-  // The first updated Period can only be a partial part
-  const updateRes = updatePeriodInPlace(oldPeriods[indexOfNewFirstPeriod],
-                                        newPeriods[0],
-                                        MANIFEST_UPDATE_TYPE.Partial);
-  res.updatedPeriods.push({ period: oldPeriods[indexOfNewFirstPeriod],
-                            result: updateRes });
-
-  // Search each consecutive elements of `newPeriods` - after the initial one already
-  // processed - in `oldPeriods`, removing and adding unfound Periods in the process
-  let prevIndexOfNewPeriod = indexOfNewFirstPeriod + 1;
-  for (let i = 1; i < newPeriods.length; i++) {
-    const newPeriod = newPeriods[i];
-    let indexOfNewPeriod = -1;
-    for (let j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
-      if (newPeriod.id === oldPeriods[j].id) {
-        indexOfNewPeriod = j;
-        break; // end the loop
-      }
-    }
-
-    if (indexOfNewPeriod < 0) { // Next element of `newPeriods` not found: insert it
-      let toRemoveUntil = -1;
-      for (let j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
-        if (newPeriod.start < oldPeriods[j].start) {
-          toRemoveUntil = j;
-          break; // end the loop
-        }
-      }
-      const nbElementsToRemove = toRemoveUntil - prevIndexOfNewPeriod;
-      const removed = oldPeriods.splice(prevIndexOfNewPeriod,
-                                        nbElementsToRemove,
-                                        newPeriod);
-      res.addedPeriods.push(newPeriod);
-      res.removedPeriods.push(...removed);
-    } else {
-      if (indexOfNewPeriod > prevIndexOfNewPeriod) {
-        // Some old periods were not found: remove
-        log.warn("Manifest: old Periods not found in new when updating, removing");
-        const removed = oldPeriods.splice(prevIndexOfNewPeriod,
-                                          indexOfNewPeriod - prevIndexOfNewPeriod);
-        res.removedPeriods.push(...removed);
-        indexOfNewPeriod = prevIndexOfNewPeriod;
-      }
-
-      // Later Periods can be fully replaced
-      const result = updatePeriodInPlace(oldPeriods[indexOfNewPeriod],
-                                         newPeriod,
-                                         MANIFEST_UPDATE_TYPE.Full);
-      res.updatedPeriods.push({ period: oldPeriods[indexOfNewPeriod], result });
-    }
-    prevIndexOfNewPeriod++;
-  }
-
-  if (prevIndexOfNewPeriod < oldPeriods.length)  {
-    log.warn("Manifest: Ending Periods not found in new when updating, removing");
-    const removed = oldPeriods.splice(prevIndexOfNewPeriod,
-                                      oldPeriods.length - prevIndexOfNewPeriod);
-    res.removedPeriods.push(...removed);
-  }
-  return res;
-}
-
-/** Object describing a Manifest update at the Periods level. */
-export interface IPeriodsUpdateResult {
-  /** Information on Periods that have been updated. */
-  updatedPeriods : Array<{
-    /** The concerned Period. */
-    period : Period;
-    /** The updates performed. */
-    result : IUpdatedPeriodResult;
-  }>;
-  /** Periods that have been added. */
-  addedPeriods : Period[];
-  /** Periods that have been removed. */
-  removedPeriods : Period[];
-}

package/src/manifest/utils.ts

@@ -1,60 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import isNullOrUndefined from "../utils/is_null_or_undefined";
-import Adaptation from "./adaptation";
-import Period from "./period";
-import Representation from "./representation";
-import { ISegment } from "./representation_index";
-
-/** All information needed to identify a given segment. */
-export interface IBufferedChunkInfos { adaptation : Adaptation;
-                                       period : Period;
-                                       representation : Representation;
-                                       segment : ISegment; }
-
-/**
- * Check if two contents are the same
- * @param {Object} content1
- * @param {Object} content2
- * @returns {boolean}
- */
-export function areSameContent(
-  content1: IBufferedChunkInfos,
-  content2: IBufferedChunkInfos
-): boolean {
-  return (content1.segment.id === content2.segment.id &&
-          content1.representation.uniqueId === content2.representation.uniqueId);
-}
-
-/**
- * Get string describing a given ISegment, useful for log functions.
- * @param {Object} content
- * @returns {string|null|undefined}
- */
-export function getLoggableSegmentId(
-  content : IBufferedChunkInfos | null | undefined
-) : string {
-  if (isNullOrUndefined(content)) {
-    return "";
-  }
-  const { period, adaptation, representation, segment } = content;
-  return `${adaptation.type} P: ${period.id} A: ${adaptation.id} ` +
-         `R: ${representation.id} S: ` +
-         (segment.isInit   ? "init" :
-          segment.complete ? `${segment.time}-${segment.duration}` :
-                             `${segment.time}`);
-}

package/src/minimal.ts

@@ -1,34 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * This file exports a MinimalPlayer class for which features can be lazy-loaded.
- *
- * This allows to import a "minimal" player with a small bundle size and then
- * import only features that is needed.
- */
-
-import isDebugModeEnabled from "./compat/is_debug_mode_enabled";
-import Player from "./core/api";
-import logger from "./log";
-
-if (isDebugModeEnabled()) {
-  logger.setLevel("DEBUG");
-} else if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
-  logger.setLevel(__LOGGER_LEVEL__.CURRENT_LEVEL);
-}
-
-export default Player;

package/src/parsers/README.md

@@ -1,12 +0,0 @@
-# Parsers ######################################################################
-
-This directory regroups "parsers", which translate a given format (either a
-Manifest format, a text track format, a media container etc.) into more
-exploitable properties for the rest of the RxPlayer.
-
-They are here grouped by purposes:
-  - `containers`: For media containers files, such as ISOBMFF, CMAF and WebM
-  - `images`: For thumbnails container files, such as BIF.
-  - `manifest`: For Manifest files. Like the DASH's MPD or Smooth's Manifest.
-  - `texttracks`: For text track formats, most often subtitles. For example:
-    WebVTT, TTML, SRT and so on.

package/src/parsers/containers/isobmff/constants.ts

@@ -1,24 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Maximum integer that can be stored on 32 bits.
- *
- * This can be used for example to know what is the maximum ISOBMFF box size
- * that can be stored on the first four bytes of a box. Any value higher than
- * that will need 8 bytes (64 bits) to be stored.
- */
-export const MAX_32_BIT_INT = Math.pow(2, 32) - 1;

package/src/parsers/containers/isobmff/create_box.ts

@@ -1,81 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  concat,
-  itobe4,
-  itobe8,
-} from "../../../utils/byte_parsing";
-import { strToUtf8 } from "../../../utils/string_parsing";
-import { MAX_32_BIT_INT } from "./constants";
-
-/**
- * Speed up string to bytes conversion by memorizing the result
- *
- * The keys here are ISOBMFF box names. The values are the corresponding
- * bytes conversion for putting as an ISOBMFF boxes.
- *
- * Used by the boxName method.
- * @type {Object}
- */
-const boxNamesMem : { [boxName: string]: Uint8Array } = {};
-
-/**
- * Convert the string name of an ISOBMFF box into the corresponding bytes.
- * Has a memorization mechanism to speed-up if you want to translate the
- * same string multiple times.
- * @param {string} str
- * @returns {Uint8Array}
- */
-function boxName(str : string) : Uint8Array {
-  if (boxNamesMem[str] != null) {
-    return boxNamesMem[str];
-  }
-
-  const nameInBytes = strToUtf8(str);
-  boxNamesMem[str] = nameInBytes;
-  return nameInBytes;
-}
-
-/**
- * Create a new ISOBMFF "box" with the given name.
- * @param {string} name - name of the box you want to create, must always
- * be 4 characters (uuid boxes not supported)
- * @param {Uint8Array} buff - content of the box
- * @returns {Uint8Array} - The entire ISOBMFF box (length+name+content)
- */
-function createBox(name : string, buff : Uint8Array) : Uint8Array {
-  const len = buff.length + 8;
-  return len <= MAX_32_BIT_INT ? concat(itobe4(len), boxName(name), buff) :
-                                 concat(itobe4(1), boxName(name), itobe8(len + 8), buff);
-}
-
-/**
- * @param {string} name
- * @param {Array.<Uint8Array>} children
- * @returns {Uint8Array}
- */
-function createBoxWithChildren(
-  name : string,
-  children : Uint8Array[]
-) : Uint8Array {
-  return createBox(name, concat(...children));
-}
-
-export {
-  createBox,
-  createBoxWithChildren,
-};

package/src/parsers/containers/isobmff/drm/index.ts

@@ -1,17 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export { getPlayReadyKIDFromPrivateData } from "./playready";

package/src/parsers/containers/isobmff/drm/playready.ts

@@ -1,45 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { base64ToBytes } from "../../../../utils/base64";
-import { le2toi } from "../../../../utils/byte_parsing";
-import {
-  bytesToHex,
-  guidToUuid,
-  utf16LEToStr,
-} from "../../../../utils/string_parsing";
-
-/**
- * Parse PlayReady privateData to get its Hexa-coded KeyID.
- * @param {Uint8Array} privateData
- * @returns {string}
- */
-export function getPlayReadyKIDFromPrivateData(
-  data: Uint8Array
-) : string {
-  const xmlLength = le2toi(data, 8);
-  const xml = utf16LEToStr(data.subarray(10, xmlLength + 10));
-  const doc = new DOMParser().parseFromString(xml, "application/xml");
-  const kidElement = doc.querySelector("KID");
-  if (kidElement === null) {
-    throw new Error("Cannot parse PlayReady private data: invalid XML");
-  }
-  const b64guidKid = kidElement.textContent === null ? "" :
-                                                       kidElement.textContent;
-
-  const uuidKid = guidToUuid(base64ToBytes(b64guidKid));
-  return bytesToHex(uuidKid).toLowerCase();
-}