rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/parsers/manifest/smooth/create_parser.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,33 +14,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../log";
-import { SUPPORTED_ADAPTATIONS_TYPE } from "../../../manifest";
-import arrayIncludes from "../../../utils/array_includes";
-import assert from "../../../utils/assert";
-import { concat, itobe4, } from "../../../utils/byte_parsing";
-import isNonEmptyString from "../../../utils/is_non_empty_string";
-import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
-import objectAssign from "../../../utils/object_assign";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
-import { hexToBytes } from "../../../utils/string_parsing";
-import takeFirstSet from "../../../utils/take_first_set";
-import { createBox } from "../../containers/isobmff";
-import checkManifestIDs from "../utils/check_manifest_ids";
-import { getAudioCodecs, getVideoCodecs, } from "./get_codecs";
-import parseCNodes from "./parse_C_nodes";
-import parseProtectionNode from "./parse_protection_node";
-import RepresentationIndex from "./representation_index";
-import SharedSmoothSegmentTimeline from "./shared_smooth_segment_timeline";
-import parseBoolean from "./utils/parseBoolean";
-import reduceChildren from "./utils/reduceChildren";
-import { replaceRepresentationSmoothTokens } from "./utils/tokens";
-var DEFAULT_MIME_TYPES = {
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../log");
+const manifest_1 = require("../../../manifest");
+const array_includes_1 = require("../../../utils/array_includes");
+const assert_1 = require("../../../utils/assert");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+const object_assign_1 = require("../../../utils/object_assign");
+const resolve_url_1 = require("../../../utils/resolve_url");
+const string_parsing_1 = require("../../../utils/string_parsing");
+const take_first_set_1 = require("../../../utils/take_first_set");
+const isobmff_1 = require("../../containers/isobmff");
+const check_manifest_ids_1 = require("../utils/check_manifest_ids");
+const get_codecs_1 = require("./get_codecs");
+const parse_C_nodes_1 = require("./parse_C_nodes");
+const parse_protection_node_1 = require("./parse_protection_node");
+const representation_index_1 = require("./representation_index");
+const shared_smooth_segment_timeline_1 = require("./shared_smooth_segment_timeline");
+const parseBoolean_1 = require("./utils/parseBoolean");
+const reduceChildren_1 = require("./utils/reduceChildren");
+const tokens_1 = require("./utils/tokens");
+const DEFAULT_MIME_TYPES = {
     audio: "audio/mp4",
     video: "video/mp4",
     text: "application/ttml+xml",
 };
-var MIME_TYPES = {
+const MIME_TYPES = {
     AACL: "audio/mp4",
     AVC1: "video/mp4",
     H264: "video/mp4",
@@ -50,16 +52,15 @@ var MIME_TYPES = {
  * @param {Object|undefined} parserOptions
  * @returns {Function}
  */
-function createSmoothStreamingParser(parserOptions) {
-    if (parserOptions === void 0) { parserOptions = {}; }
-    var referenceDateTime = parserOptions.referenceDateTime === undefined ?
+function createSmoothStreamingParser(parserOptions = {}) {
+    const referenceDateTime = parserOptions.referenceDateTime === undefined ?
         Date.UTC(1970, 0, 1, 0, 0, 0, 0) / 1000 :
         parserOptions.referenceDateTime;
-    var minRepresentationBitrate = parserOptions.minRepresentationBitrate === undefined ?
+    const minRepresentationBitrate = parserOptions.minRepresentationBitrate === undefined ?
         0 :
         parserOptions.minRepresentationBitrate;
-    var serverSyncInfos = parserOptions.serverSyncInfos;
-    var serverTimeOffset = serverSyncInfos !== undefined ?
+    const { serverSyncInfos } = parserOptions;
+    const serverTimeOffset = serverSyncInfos !== undefined ?
         serverSyncInfos.serverTimestamp - serverSyncInfos.clientTime :
         undefined;
     /**
@@ -68,14 +69,14 @@ function createSmoothStreamingParser(parserOptions) {
      * @return {Object}
      */
     function parseQualityLevel(q, streamType) {
-        var customAttributes = reduceChildren(q, function (acc, qName, qNode) {
+        const customAttributes = (0, reduceChildren_1.default)(q, (acc, qName, qNode) => {
             if (qName === "CustomAttributes") {
-                acc.push.apply(acc, reduceChildren(qNode, function (cAttrs, cName, cNode) {
+                acc.push(...(0, reduceChildren_1.default)(qNode, (cAttrs, cName, cNode) => {
                     if (cName === "Attribute") {
-                        var name_1 = cNode.getAttribute("Name");
-                        var value = cNode.getAttribute("Value");
-                        if (name_1 !== null && value !== null) {
-                            cAttrs.push(name_1 + "=" + value);
+                        const name = cNode.getAttribute("Name");
+                        const value = cNode.getAttribute("Value");
+                        if (name !== null && value !== null) {
+                            cAttrs.push(name + "=" + value);
                         }
                     }
                     return cAttrs;
@@ -88,38 +89,38 @@ function createSmoothStreamingParser(parserOptions) {
          * @returns {string|undefined}
          */
         function getAttribute(name) {
-            var attr = q.getAttribute(name);
+            const attr = q.getAttribute(name);
             return attr == null ? undefined : attr;
         }
         switch (streamType) {
             case "audio": {
-                var audiotag = getAttribute("AudioTag");
-                var bitsPerSample = getAttribute("BitsPerSample");
-                var channels = getAttribute("Channels");
-                var codecPrivateData = getAttribute("CodecPrivateData");
-                var fourCC = getAttribute("FourCC");
-                var packetSize = getAttribute("PacketSize");
-                var samplingRate = getAttribute("SamplingRate");
-                var bitrateAttr = getAttribute("Bitrate");
-                var bitrate = bitrateAttr === undefined ? 0 :
+                const audiotag = getAttribute("AudioTag");
+                const bitsPerSample = getAttribute("BitsPerSample");
+                const channels = getAttribute("Channels");
+                const codecPrivateData = getAttribute("CodecPrivateData");
+                const fourCC = getAttribute("FourCC");
+                const packetSize = getAttribute("PacketSize");
+                const samplingRate = getAttribute("SamplingRate");
+                const bitrateAttr = getAttribute("Bitrate");
+                const bitrate = bitrateAttr === undefined ? 0 :
                     isNaN(parseInt(bitrateAttr, 10)) ? 0 :
                         parseInt(bitrateAttr, 10);
                 if ((fourCC !== undefined &&
                     MIME_TYPES[fourCC] === undefined) ||
                     codecPrivateData === undefined) {
-                    log.warn("Smooth parser: Unsupported audio codec. Ignoring quality level.");
+                    log_1.default.warn("Smooth parser: Unsupported audio codec. Ignoring quality level.");
                     return null;
                 }
-                var codecs = getAudioCodecs(codecPrivateData, fourCC);
+                const codecs = (0, get_codecs_1.getAudioCodecs)(codecPrivateData, fourCC);
                 return {
                     audiotag: audiotag !== undefined ? parseInt(audiotag, 10) : audiotag,
-                    bitrate: bitrate,
+                    bitrate,
                     bitsPerSample: bitsPerSample !== undefined ?
                         parseInt(bitsPerSample, 10) : bitsPerSample,
                     channels: channels !== undefined ? parseInt(channels, 10) : channels,
-                    codecPrivateData: codecPrivateData,
-                    codecs: codecs,
-                    customAttributes: customAttributes,
+                    codecPrivateData,
+                    codecs,
+                    customAttributes,
                     mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] : fourCC,
                     packetSize: packetSize !== undefined ?
                         parseInt(packetSize, 10) :
@@ -130,44 +131,46 @@ function createSmoothStreamingParser(parserOptions) {
                 };
             }
             case "video": {
-                var codecPrivateData = getAttribute("CodecPrivateData");
-                var fourCC = getAttribute("FourCC");
-                var width = getAttribute("MaxWidth");
-                var height = getAttribute("MaxHeight");
-                var bitrateAttr = getAttribute("Bitrate");
-                var bitrate = bitrateAttr === undefined ? 0 :
+                const codecPrivateData = getAttribute("CodecPrivateData");
+                const fourCC = getAttribute("FourCC");
+                const width = getAttribute("MaxWidth");
+                const height = getAttribute("MaxHeight");
+                const bitrateAttr = getAttribute("Bitrate");
+                const bitrate = bitrateAttr === undefined ? 0 :
                     isNaN(parseInt(bitrateAttr, 10)) ? 0 :
                         parseInt(bitrateAttr, 10);
                 if ((fourCC !== undefined &&
                     MIME_TYPES[fourCC] === undefined) ||
                     codecPrivateData === undefined) {
-                    log.warn("Smooth parser: Unsupported video codec. Ignoring quality level.");
+                    log_1.default.warn("Smooth parser: Unsupported video codec. Ignoring quality level.");
                     return null;
                 }
-                var codecs = getVideoCodecs(codecPrivateData);
+                const codecs = (0, get_codecs_1.getVideoCodecs)(codecPrivateData);
                 return {
-                    bitrate: bitrate,
-                    customAttributes: customAttributes,
+                    bitrate,
+                    customAttributes,
                     mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] : fourCC,
-                    codecPrivateData: codecPrivateData,
-                    codecs: codecs,
+                    codecPrivateData,
+                    codecs,
                     width: width !== undefined ? parseInt(width, 10) : undefined,
                     height: height !== undefined ? parseInt(height, 10) : undefined,
                 };
             }
             case "text": {
-                var codecPrivateData = getAttribute("CodecPrivateData");
-                var fourCC = getAttribute("FourCC");
-                var bitrateAttr = getAttribute("Bitrate");
-                var bitrate = bitrateAttr === undefined ? 0 :
+                const codecPrivateData = getAttribute("CodecPrivateData");
+                const fourCC = getAttribute("FourCC");
+                const bitrateAttr = getAttribute("Bitrate");
+                const bitrate = bitrateAttr === undefined ? 0 :
                     isNaN(parseInt(bitrateAttr, 10)) ? 0 :
                         parseInt(bitrateAttr, 10);
-                return { bitrate: bitrate, customAttributes: customAttributes, mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] :
+                return { bitrate,
+                    customAttributes,
+                    mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] :
                         fourCC,
-                    codecPrivateData: takeFirstSet(codecPrivateData, "") };
+                    codecPrivateData: (0, take_first_set_1.default)(codecPrivateData, "") };
             }
             default:
-                log.error("Smooth Parser: Unrecognized StreamIndex type: " + streamType);
+                log_1.default.error("Smooth Parser: Unrecognized StreamIndex type: " + streamType);
                 return null;
         }
     }
@@ -180,31 +183,31 @@ function createSmoothStreamingParser(parserOptions) {
      * @returns {Object}
      */
     function parseAdaptation(args) {
-        var root = args.root, timescale = args.timescale, baseUrl = args.baseUrl, protections = args.protections, timeShiftBufferDepth = args.timeShiftBufferDepth, manifestReceivedTime = args.manifestReceivedTime, isLive = args.isLive;
-        var timescaleAttr = root.getAttribute("Timescale");
-        var _timescale = timescaleAttr === null ? timescale :
+        const { root, timescale, baseUrl, protections, timeShiftBufferDepth, manifestReceivedTime, isLive } = args;
+        const timescaleAttr = root.getAttribute("Timescale");
+        const _timescale = timescaleAttr === null ? timescale :
             isNaN(+timescaleAttr) ? timescale :
                 +timescaleAttr;
-        var typeAttribute = root.getAttribute("Type");
+        const typeAttribute = root.getAttribute("Type");
         if (typeAttribute === null) {
             throw new Error("StreamIndex without type.");
         }
-        if (!arrayIncludes(SUPPORTED_ADAPTATIONS_TYPE, typeAttribute)) {
-            log.warn("Smooth Parser: Unrecognized adaptation type:", typeAttribute);
+        if (!(0, array_includes_1.default)(manifest_1.SUPPORTED_ADAPTATIONS_TYPE, typeAttribute)) {
+            log_1.default.warn("Smooth Parser: Unrecognized adaptation type:", typeAttribute);
         }
-        var adaptationType = typeAttribute;
-        var subType = root.getAttribute("Subtype");
-        var language = root.getAttribute("Language");
-        var UrlAttr = root.getAttribute("Url");
-        var UrlPathWithTokens = UrlAttr === null ? "" :
+        const adaptationType = typeAttribute;
+        const subType = root.getAttribute("Subtype");
+        const language = root.getAttribute("Language");
+        const UrlAttr = root.getAttribute("Url");
+        const UrlPathWithTokens = UrlAttr === null ? "" :
             UrlAttr;
         if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(UrlPathWithTokens !== "");
+            (0, assert_1.default)(UrlPathWithTokens !== "");
         }
-        var _a = reduceChildren(root, function (res, _name, node) {
+        const { qualityLevels, cNodes } = (0, reduceChildren_1.default)(root, (res, _name, node) => {
             switch (_name) {
                 case "QualityLevel":
-                    var qualityLevel = parseQualityLevel(node, adaptationType);
+                    const qualityLevel = parseQualityLevel(node, adaptationType);
                     if (qualityLevel === null) {
                         return res;
                     }
@@ -219,26 +222,26 @@ function createSmoothStreamingParser(parserOptions) {
                     break;
             }
             return res;
-        }, { qualityLevels: [], cNodes: [] }), qualityLevels = _a.qualityLevels, cNodes = _a.cNodes;
-        var sharedSmoothTimeline = new SharedSmoothSegmentTimeline({
-            timeline: parseCNodes(cNodes),
+        }, { qualityLevels: [], cNodes: [] });
+        const sharedSmoothTimeline = new shared_smooth_segment_timeline_1.default({
+            timeline: (0, parse_C_nodes_1.default)(cNodes),
             timescale: _timescale,
-            timeShiftBufferDepth: timeShiftBufferDepth,
-            manifestReceivedTime: manifestReceivedTime,
+            timeShiftBufferDepth,
+            manifestReceivedTime,
         });
         // we assume that all qualityLevels have the same
         // codec and mimeType
-        assert(qualityLevels.length !== 0, "Adaptation should have at least one playable representation.");
-        var adaptationID = adaptationType +
-            (isNonEmptyString(language) ? ("_" + language) :
+        (0, assert_1.default)(qualityLevels.length !== 0, "Adaptation should have at least one playable representation.");
+        const adaptationID = adaptationType +
+            ((0, is_non_empty_string_1.default)(language) ? ("_" + language) :
                 "");
-        var representations = qualityLevels.map(function (qualityLevel) {
-            var media = replaceRepresentationSmoothTokens(UrlPathWithTokens, qualityLevel.bitrate, qualityLevel.customAttributes);
-            var mimeType = isNonEmptyString(qualityLevel.mimeType) ?
+        const representations = qualityLevels.map((qualityLevel) => {
+            const media = (0, tokens_1.replaceRepresentationSmoothTokens)(UrlPathWithTokens, qualityLevel.bitrate, qualityLevel.customAttributes);
+            const mimeType = (0, is_non_empty_string_1.default)(qualityLevel.mimeType) ?
                 qualityLevel.mimeType :
                 DEFAULT_MIME_TYPES[adaptationType];
-            var codecs = qualityLevel.codecs;
-            var id = adaptationID + "_" +
+            const codecs = qualityLevel.codecs;
+            const id = adaptationID + "_" +
                 (adaptationType != null ? adaptationType + "-" :
                     "") +
                 (mimeType != null ? mimeType + "-" :
@@ -246,18 +249,19 @@ function createSmoothStreamingParser(parserOptions) {
                 (codecs != null ? codecs + "-" :
                     "") +
                 String(qualityLevel.bitrate);
-            var keyIDs = [];
-            var firstProtection;
+            const keyIDs = [];
+            let firstProtection;
             if (protections.length > 0) {
                 firstProtection = protections[0];
-                protections.forEach(function (protection) {
-                    var keyId = protection.keyId;
-                    protection.keySystems.forEach(function (keySystem) {
-                        keyIDs.push({ keyId: keyId, systemId: keySystem.systemId });
+                protections.forEach((protection) => {
+                    const keyId = protection.keyId;
+                    protection.keySystems.forEach((keySystem) => {
+                        keyIDs.push({ keyId,
+                            systemId: keySystem.systemId });
                     });
                 });
             }
-            var segmentPrivateInfos = { bitsPerSample: qualityLevel.bitsPerSample,
+            const segmentPrivateInfos = { bitsPerSample: qualityLevel.bitsPerSample,
                 channels: qualityLevel.channels,
                 codecPrivateData: qualityLevel.codecPrivateData,
                 packetSize: qualityLevel.packetSize,
@@ -269,23 +273,29 @@ function createSmoothStreamingParser(parserOptions) {
                 protection: firstProtection != null ? {
                     keyId: firstProtection.keyId,
                 } : undefined };
-            var reprIndex = new RepresentationIndex({ isLive: isLive, sharedSmoothTimeline: sharedSmoothTimeline, media: media, segmentPrivateInfos: segmentPrivateInfos });
-            var representation = objectAssign({}, qualityLevel, { index: reprIndex,
+            const reprIndex = new representation_index_1.default({ isLive,
+                sharedSmoothTimeline,
+                media,
+                segmentPrivateInfos });
+            const representation = (0, object_assign_1.default)({}, qualityLevel, { index: reprIndex,
                 cdnMetadata: [
-                    { baseUrl: baseUrl },
-                ], mimeType: mimeType, codecs: codecs, id: id });
+                    { baseUrl },
+                ],
+                mimeType,
+                codecs,
+                id });
             if (keyIDs.length > 0 || firstProtection !== undefined) {
-                var initDataValues = firstProtection === undefined ?
+                const initDataValues = firstProtection === undefined ?
                     [] :
-                    firstProtection.keySystems.map(function (keySystemData) {
-                        var systemId = keySystemData.systemId, privateData = keySystemData.privateData;
-                        var cleanedSystemId = systemId.replace(/-/g, "");
-                        var pssh = createPSSHBox(cleanedSystemId, privateData);
+                    firstProtection.keySystems.map((keySystemData) => {
+                        const { systemId, privateData } = keySystemData;
+                        const cleanedSystemId = systemId.replace(/-/g, "");
+                        const pssh = createPSSHBox(cleanedSystemId, privateData);
                         return { systemId: cleanedSystemId, data: pssh };
                     });
                 if (initDataValues.length > 0) {
-                    var initData = [{ type: "cenc", values: initDataValues }];
-                    representation.contentProtections = { keyIds: keyIDs, initData: initData };
+                    const initData = [{ type: "cenc", values: initDataValues }];
+                    representation.contentProtections = { keyIds: keyIDs, initData };
                 }
                 else {
                     representation.contentProtections = { keyIds: keyIDs, initData: [] };
@@ -297,8 +307,10 @@ function createSmoothStreamingParser(parserOptions) {
         if (subType === "ADVT") {
             return null;
         }
-        var parsedAdaptation = { id: adaptationID,
-            type: adaptationType, representations: representations, language: language == null ?
+        const parsedAdaptation = { id: adaptationID,
+            type: adaptationType,
+            representations,
+            language: language == null ?
                 undefined :
                 language };
         if (adaptationType === "text" && subType === "DESC") {
@@ -307,29 +319,29 @@ function createSmoothStreamingParser(parserOptions) {
         return parsedAdaptation;
     }
     function parseFromDocument(doc, url, manifestReceivedTime) {
-        var baseUrl = "";
+        let baseUrl = "";
         if (url !== undefined) {
-            var filenameIdx = getFilenameIndexInUrl(url);
+            const filenameIdx = (0, resolve_url_1.getFilenameIndexInUrl)(url);
             baseUrl = url.substring(0, filenameIdx);
         }
-        var root = doc.documentElement;
+        const root = doc.documentElement;
         if (root == null || root.nodeName !== "SmoothStreamingMedia") {
             throw new Error("document root should be SmoothStreamingMedia");
         }
-        var majorVersionAttr = root.getAttribute("MajorVersion");
-        var minorVersionAttr = root.getAttribute("MinorVersion");
+        const majorVersionAttr = root.getAttribute("MajorVersion");
+        const minorVersionAttr = root.getAttribute("MinorVersion");
         if (majorVersionAttr === null || minorVersionAttr === null ||
             !/^[2]-[0-2]$/.test(majorVersionAttr + "-" + minorVersionAttr)) {
             throw new Error("Version should be 2.0, 2.1 or 2.2");
         }
-        var timescaleAttr = root.getAttribute("Timescale");
-        var timescale = !isNonEmptyString(timescaleAttr) ? 10000000 :
+        const timescaleAttr = root.getAttribute("Timescale");
+        const timescale = !(0, is_non_empty_string_1.default)(timescaleAttr) ? 10000000 :
             isNaN(+timescaleAttr) ? 10000000 :
                 +timescaleAttr;
-        var _a = reduceChildren(root, function (res, name, node) {
+        const { protections, adaptationNodes, } = (0, reduceChildren_1.default)(root, (res, name, node) => {
             switch (name) {
                 case "Protection": {
-                    res.protections.push(parseProtectionNode(node, parserOptions.keySystems));
+                    res.protections.push((0, parse_protection_node_1.default)(node, parserOptions.keySystems));
                     break;
                 }
                 case "StreamIndex":
@@ -340,26 +352,32 @@ function createSmoothStreamingParser(parserOptions) {
         }, {
             adaptationNodes: [],
             protections: [],
-        }), protections = _a.protections, adaptationNodes = _a.adaptationNodes;
-        var initialAdaptations = {};
-        var isLive = parseBoolean(root.getAttribute("IsLive"));
-        var timeShiftBufferDepth;
+        });
+        const initialAdaptations = {};
+        const isLive = (0, parseBoolean_1.default)(root.getAttribute("IsLive"));
+        let timeShiftBufferDepth;
         if (isLive) {
-            var dvrWindowLength = root.getAttribute("DVRWindowLength");
+            const dvrWindowLength = root.getAttribute("DVRWindowLength");
             if (dvrWindowLength != null &&
                 !isNaN(+dvrWindowLength) &&
                 +dvrWindowLength !== 0) {
                 timeShiftBufferDepth = +dvrWindowLength / timescale;
             }
         }
-        var adaptations = adaptationNodes
-            .reduce(function (acc, node) {
-            var adaptation = parseAdaptation({ root: node, baseUrl: baseUrl, timescale: timescale, protections: protections, isLive: isLive, timeShiftBufferDepth: timeShiftBufferDepth, manifestReceivedTime: manifestReceivedTime });
+        const adaptations = adaptationNodes
+            .reduce((acc, node) => {
+            const adaptation = parseAdaptation({ root: node,
+                baseUrl,
+                timescale,
+                protections,
+                isLive,
+                timeShiftBufferDepth,
+                manifestReceivedTime });
             if (adaptation === null) {
                 return acc;
             }
-            var type = adaptation.type;
-            var adaps = acc[type];
+            const type = adaptation.type;
+            const adaps = acc[type];
             if (adaps === undefined) {
                 acc[type] = [adaptation];
             }
@@ -368,31 +386,31 @@ function createSmoothStreamingParser(parserOptions) {
             }
             return acc;
         }, initialAdaptations);
-        var suggestedPresentationDelay;
-        var availabilityStartTime;
-        var minimumTime;
-        var timeshiftDepth = null;
-        var maximumTimeData;
-        var firstVideoAdaptation = adaptations.video !== undefined ?
+        let suggestedPresentationDelay;
+        let availabilityStartTime;
+        let minimumTime;
+        let timeshiftDepth = null;
+        let maximumTimeData;
+        const firstVideoAdaptation = adaptations.video !== undefined ?
             adaptations.video[0] :
             undefined;
-        var firstAudioAdaptation = adaptations.audio !== undefined ?
+        const firstAudioAdaptation = adaptations.audio !== undefined ?
             adaptations.audio[0] :
             undefined;
         /** Minimum time that can be reached regardless of the StreamIndex chosen. */
-        var safeMinimumTime;
+        let safeMinimumTime;
         /** Maximum time that can be reached regardless of the StreamIndex chosen. */
-        var safeMaximumTime;
+        let safeMaximumTime;
         /** Maximum time that can be reached in absolute on the content. */
-        var unsafeMaximumTime;
+        let unsafeMaximumTime;
         if (firstVideoAdaptation !== undefined || firstAudioAdaptation !== undefined) {
-            var firstTimeReferences = [];
-            var lastTimeReferences = [];
+            const firstTimeReferences = [];
+            const lastTimeReferences = [];
             if (firstVideoAdaptation !== undefined) {
-                var firstVideoRepresentation = firstVideoAdaptation.representations[0];
+                const firstVideoRepresentation = firstVideoAdaptation.representations[0];
                 if (firstVideoRepresentation !== undefined) {
-                    var firstVideoTimeReference = firstVideoRepresentation.index.getFirstAvailablePosition();
-                    var lastVideoTimeReference = firstVideoRepresentation.index.getLastAvailablePosition();
+                    const firstVideoTimeReference = firstVideoRepresentation.index.getFirstAvailablePosition();
+                    const lastVideoTimeReference = firstVideoRepresentation.index.getLastAvailablePosition();
                     if (firstVideoTimeReference != null) {
                         firstTimeReferences.push(firstVideoTimeReference);
                     }
@@ -402,10 +420,10 @@ function createSmoothStreamingParser(parserOptions) {
                 }
             }
             if (firstAudioAdaptation !== undefined) {
-                var firstAudioRepresentation = firstAudioAdaptation.representations[0];
+                const firstAudioRepresentation = firstAudioAdaptation.representations[0];
                 if (firstAudioRepresentation !== undefined) {
-                    var firstAudioTimeReference = firstAudioRepresentation.index.getFirstAvailablePosition();
-                    var lastAudioTimeReference = firstAudioRepresentation.index.getLastAvailablePosition();
+                    const firstAudioTimeReference = firstAudioRepresentation.index.getFirstAvailablePosition();
+                    const lastAudioTimeReference = firstAudioRepresentation.index.getLastAvailablePosition();
                     if (firstAudioTimeReference != null) {
                         firstTimeReferences.push(firstAudioTimeReference);
                     }
@@ -415,64 +433,70 @@ function createSmoothStreamingParser(parserOptions) {
                 }
             }
             if (firstTimeReferences.length > 0) {
-                safeMinimumTime = Math.max.apply(Math, firstTimeReferences);
+                safeMinimumTime = Math.max(...firstTimeReferences);
             }
             if (lastTimeReferences.length > 0) {
-                safeMaximumTime = Math.min.apply(Math, lastTimeReferences);
-                unsafeMaximumTime = Math.max.apply(Math, lastTimeReferences);
+                safeMaximumTime = Math.min(...lastTimeReferences);
+                unsafeMaximumTime = Math.max(...lastTimeReferences);
             }
         }
-        var manifestDuration = root.getAttribute("Duration");
-        var duration = (manifestDuration !== null && +manifestDuration !== 0) ?
+        const manifestDuration = root.getAttribute("Duration");
+        const duration = (manifestDuration !== null && +manifestDuration !== 0) ?
             (+manifestDuration / timescale) : undefined;
         if (isLive) {
             suggestedPresentationDelay = parserOptions.suggestedPresentationDelay;
             availabilityStartTime = referenceDateTime;
             minimumTime = safeMinimumTime !== null && safeMinimumTime !== void 0 ? safeMinimumTime : availabilityStartTime;
-            var livePosition = unsafeMaximumTime;
+            let livePosition = unsafeMaximumTime;
             if (livePosition === undefined) {
                 livePosition = (Date.now() / 1000 - availabilityStartTime);
             }
-            var maximumSafePosition = safeMaximumTime;
+            let maximumSafePosition = safeMaximumTime;
             if (maximumSafePosition === undefined) {
                 maximumSafePosition = livePosition;
             }
-            maximumTimeData = { isLinear: true, maximumSafePosition: maximumSafePosition, livePosition: livePosition, time: getMonotonicTimeStamp() };
+            maximumTimeData = { isLinear: true,
+                maximumSafePosition,
+                livePosition,
+                time: (0, monotonic_timestamp_1.default)() };
             timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
         }
         else {
             minimumTime = safeMinimumTime !== null && safeMinimumTime !== void 0 ? safeMinimumTime : 0;
-            var maximumTime = safeMaximumTime !== undefined ? safeMaximumTime :
+            const maximumTime = safeMaximumTime !== undefined ? safeMaximumTime :
                 duration !== undefined ? minimumTime + duration :
                     Infinity;
             maximumTimeData = { isLinear: false,
                 maximumSafePosition: maximumTime,
                 livePosition: undefined,
-                time: getMonotonicTimeStamp() };
+                time: (0, monotonic_timestamp_1.default)() };
         }
-        var periodStart = isLive ? 0 :
+        const periodStart = isLive ? 0 :
             minimumTime;
-        var periodEnd = isLive ? undefined :
+        const periodEnd = isLive ? undefined :
             maximumTimeData.maximumSafePosition;
-        var manifest = {
+        const manifest = {
             availabilityStartTime: availabilityStartTime === undefined ?
                 0 :
                 availabilityStartTime,
             clockOffset: serverTimeOffset,
-            isLive: isLive,
+            isLive,
             isDynamic: isLive,
             isLastPeriodKnown: true,
-            timeBounds: { minimumSafePosition: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
-            periods: [{ adaptations: adaptations, duration: periodEnd !== undefined ?
+            timeBounds: { minimumSafePosition: minimumTime,
+                timeshiftDepth,
+                maximumTimeData },
+            periods: [{ adaptations,
+                    duration: periodEnd !== undefined ?
                         periodEnd - periodStart : duration,
                     end: periodEnd,
                     id: "gen-smooth-period-0",
                     start: periodStart }],
-            suggestedPresentationDelay: suggestedPresentationDelay,
+            suggestedPresentationDelay,
             transportType: "smooth",
             uris: url == null ? [] : [url],
         };
-        checkManifestIDs(manifest);
+        (0, check_manifest_ids_1.default)(manifest);
         return manifest;
     }
     return parseFromDocument;
@@ -487,9 +511,9 @@ function createPSSHBox(systemId, privateData) {
     if (systemId.length !== 32) {
         throw new Error("HSS: wrong system id length");
     }
-    var version = 0;
-    return createBox("pssh", concat([version, 0, 0, 0], hexToBytes(systemId), 
+    const version = 0;
+    return (0, isobmff_1.createBox)("pssh", (0, byte_parsing_1.concat)([version, 0, 0, 0], (0, string_parsing_1.hexToBytes)(systemId), 
     /** To put there KIDs if it exists (necessitate PSSH v1) */
-    itobe4(privateData.length), privateData));
+    (0, byte_parsing_1.itobe4)(privateData.length), privateData));
 }
-export default createSmoothStreamingParser;
+exports.default = createSmoothStreamingParser;