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

package/dist/_esm5.processed/transports/dash/extract_complete_chunks.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { be4toi } from "../../utils/byte_parsing";
-import findCompleteBox from "../utils/find_complete_box";
+Object.defineProperty(exports, "__esModule", { value: true });
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const find_complete_box_1 = require("../utils/find_complete_box");
 /**
  * Take a chunk of ISOBMFF data and extract complete `moof`+`mdat` subsegments
  * which are ready to be decoded.
@@ -23,37 +25,38 @@ import findCompleteBox from "../utils/find_complete_box";
  * @param {Uint8Array} buffer
  * @returns {Array}
  */
-export default function extractCompleteChunks(buffer) {
-    var _position = 0;
-    var chunks = [];
+function extractCompleteChunks(buffer) {
+    let _position = 0;
+    const chunks = [];
     while (_position < buffer.length) {
-        var currentBuffer = buffer.subarray(_position, Infinity);
-        var moofIndex = findCompleteBox(currentBuffer, 0x6D6F6F66 /* moof */);
+        const currentBuffer = buffer.subarray(_position, Infinity);
+        const moofIndex = (0, find_complete_box_1.default)(currentBuffer, 0x6D6F6F66 /* moof */);
         if (moofIndex < 0) {
             // no moof, not a segment.
             return [chunks, currentBuffer];
         }
-        var moofLen = be4toi(buffer, moofIndex + _position);
-        var moofEnd = _position + moofIndex + moofLen;
+        const moofLen = (0, byte_parsing_1.be4toi)(buffer, moofIndex + _position);
+        const moofEnd = _position + moofIndex + moofLen;
         if (moofEnd > buffer.length) {
             // not a complete moof segment
             return [chunks, currentBuffer];
         }
-        var mdatIndex = findCompleteBox(currentBuffer, 0x6D646174 /* mdat */);
+        const mdatIndex = (0, find_complete_box_1.default)(currentBuffer, 0x6D646174 /* mdat */);
         if (mdatIndex < 0) {
             // no mdat, not a segment.
             return [chunks, currentBuffer];
         }
-        var mdatLen = be4toi(buffer, mdatIndex + _position);
-        var mdatEnd = _position + mdatIndex + mdatLen;
+        const mdatLen = (0, byte_parsing_1.be4toi)(buffer, mdatIndex + _position);
+        const mdatEnd = _position + mdatIndex + mdatLen;
         if (mdatEnd > buffer.length) {
             // not a complete mdat segment
             return [chunks, currentBuffer];
         }
-        var maxEnd = Math.max(moofEnd, mdatEnd);
-        var chunk = buffer.subarray(_position, maxEnd);
+        const maxEnd = Math.max(moofEnd, mdatEnd);
+        const chunk = buffer.subarray(_position, maxEnd);
         chunks.push(chunk);
         _position = maxEnd;
     }
     return [chunks, null];
 }
+exports.default = extractCompleteChunks;

package/dist/_esm5.processed/transports/dash/get_events_out_of_emsgs.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { utf8ToStr } from "../../utils/string_parsing";
+Object.defineProperty(exports, "__esModule", { value: true });
+const string_parsing_1 = require("../../utils/string_parsing");
 /**
  * From an array of EMSGs with manifest validity scheme id,
  * tells if the manifest needs to be refreshed.
@@ -26,13 +28,13 @@ function manifestNeedsToBeRefreshed(emsgs, manifestPublishTime) {
     if (emsgs.length <= 0) {
         return false;
     }
-    var len = emsgs.length;
-    for (var i = 0; i < len; i++) {
-        var manifestRefreshEventFromEMSGs = emsgs[i];
-        var currentManifestPublishTime = manifestPublishTime;
-        var messageData = manifestRefreshEventFromEMSGs.messageData;
-        var strPublishTime = utf8ToStr(messageData);
-        var eventManifestPublishTime = Date.parse(strPublishTime);
+    const len = emsgs.length;
+    for (let i = 0; i < len; i++) {
+        const manifestRefreshEventFromEMSGs = emsgs[i];
+        const currentManifestPublishTime = manifestPublishTime;
+        const { messageData } = manifestRefreshEventFromEMSGs;
+        const strPublishTime = (0, string_parsing_1.utf8ToStr)(messageData);
+        const eventManifestPublishTime = Date.parse(strPublishTime);
         if (currentManifestPublishTime === undefined ||
             eventManifestPublishTime === undefined ||
             isNaN(eventManifestPublishTime) ||
@@ -58,12 +60,12 @@ function manifestNeedsToBeRefreshed(emsgs, manifestPublishTime) {
  * @param {undefined | number} manifestPublishTime
  * @returns {Object}
  */
-export default function getEventsOutOfEMSGs(parsedEMSGs, manifestPublishTime) {
+function getEventsOutOfEMSGs(parsedEMSGs, manifestPublishTime) {
     if (parsedEMSGs.length === 0) {
         return undefined;
     }
-    var _a = parsedEMSGs
-        .reduce(function (acc, val) {
+    const { manifestRefreshEventsFromEMSGs, EMSGs } = parsedEMSGs
+        .reduce((acc, val) => {
         // Scheme that signals manifest update
         if (val.schemeIdUri === "urn:mpeg:dash:event:2012" &&
             // TODO support value 2 and 3
@@ -81,12 +83,13 @@ export default function getEventsOutOfEMSGs(parsedEMSGs, manifestPublishTime) {
         }
         return acc;
     }, { manifestRefreshEventsFromEMSGs: undefined,
-        EMSGs: undefined }), manifestRefreshEventsFromEMSGs = _a.manifestRefreshEventsFromEMSGs, EMSGs = _a.EMSGs;
-    var inbandEvents = EMSGs === null || EMSGs === void 0 ? void 0 : EMSGs.map(function (evt) { return ({ type: "emsg",
-        value: evt }); });
-    var needsManifestRefresh = (manifestPublishTime === undefined ||
+        EMSGs: undefined });
+    const inbandEvents = EMSGs === null || EMSGs === void 0 ? void 0 : EMSGs.map((evt) => ({ type: "emsg",
+        value: evt }));
+    const needsManifestRefresh = (manifestPublishTime === undefined ||
         manifestRefreshEventsFromEMSGs === undefined) ?
         false :
         manifestNeedsToBeRefreshed(manifestRefreshEventsFromEMSGs, manifestPublishTime);
-    return { inbandEvents: inbandEvents, needsManifestRefresh: needsManifestRefresh };
+    return { inbandEvents, needsManifestRefresh };
 }
+exports.default = getEventsOutOfEMSGs;

package/dist/_esm5.processed/transports/dash/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import DASHPipelines from "./pipelines";
-export default DASHPipelines;
+const pipelines_1 = require("./pipelines");
+exports.default = pipelines_1.default;

package/dist/_esm5.processed/transports/dash/init_segment_loader.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat } from "../../utils/byte_parsing";
-import request from "../../utils/request";
-import byteRange from "../utils/byte_range";
+Object.defineProperty(exports, "__esModule", { value: true });
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const request_1 = require("../../utils/request");
+const byte_range_1 = require("../utils/byte_range");
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
@@ -25,44 +27,62 @@ import byteRange from "../utils/byte_range";
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export default function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
+function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     if (segment.range === undefined) {
-        return request({ url: url, responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+        return (0, request_1.default)({ url,
+            responseType: "arraybuffer",
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
     if (segment.indexRange === undefined) {
-        return request({ url: url, headers: { Range: byteRange(segment.range) },
+        return (0, request_1.default)({ url,
+            headers: { Range: (0, byte_range_1.default)(segment.range) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
     // range and indexRange are contiguous (99% of the cases)
     if (segment.range[1] + 1 === segment.indexRange[0]) {
-        return request({ url: url, headers: { Range: byteRange([segment.range[0],
+        return (0, request_1.default)({ url,
+            headers: { Range: (0, byte_range_1.default)([segment.range[0],
                     segment.indexRange[1]]) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
-    var rangeRequest$ = request({ url: url, headers: { Range: byteRange(segment.range) },
+    const rangeRequest$ = (0, request_1.default)({ url,
+        headers: { Range: (0, byte_range_1.default)(segment.range) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
-    var indexRequest$ = request({ url: url, headers: { Range: byteRange(segment.indexRange) },
+        timeout: options.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress });
+    const indexRequest$ = (0, request_1.default)({ url,
+        headers: { Range: (0, byte_range_1.default)(segment.indexRange) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        timeout: options.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress });
     return Promise.all([rangeRequest$, indexRequest$])
-        .then(function (_a) {
-        var initData = _a[0], indexData = _a[1];
-        var data = concat(new Uint8Array(initData.responseData), new Uint8Array(indexData.responseData));
-        var sendingTime = Math.min(initData.sendingTime, indexData.sendingTime);
-        var receivedTime = Math.max(initData.receivedTime, indexData.receivedTime);
+        .then(([initData, indexData]) => {
+        const data = (0, byte_parsing_1.concat)(new Uint8Array(initData.responseData), new Uint8Array(indexData.responseData));
+        const sendingTime = Math.min(initData.sendingTime, indexData.sendingTime);
+        const receivedTime = Math.max(initData.receivedTime, indexData.receivedTime);
         return { resultType: "segment-loaded",
-            resultData: { url: url, responseData: data,
+            resultData: { url,
+                responseData: data,
                 size: initData.size + indexData.size,
-                requestDuration: receivedTime - sendingTime, sendingTime: sendingTime, receivedTime: receivedTime } };
+                requestDuration: receivedTime - sendingTime,
+                sendingTime,
+                receivedTime } };
     });
 }
+exports.default = initSegmentLoader;

package/dist/_esm5.processed/transports/dash/low_latency_segment_loader.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat } from "../../utils/byte_parsing";
-import fetchRequest from "../../utils/request/fetch";
-import byteRange from "../utils/byte_range";
-import extractCompleteChunks from "./extract_complete_chunks";
+Object.defineProperty(exports, "__esModule", { value: true });
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const fetch_1 = require("../../utils/request/fetch");
+const byte_range_1 = require("../utils/byte_range");
+const extract_complete_chunks_1 = require("./extract_complete_chunks");
 /**
  * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
  *
@@ -29,23 +31,23 @@ import extractCompleteChunks from "./extract_complete_chunks";
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
-    var segment = content.segment;
-    var headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
+function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
+    const { segment } = content;
+    const headers = segment.range !== undefined ? { Range: (0, byte_range_1.default)(segment.range) } :
         undefined;
-    var partialChunk = null;
+    let partialChunk = null;
     /**
      * Called each time `fetch` has new data available.
      * @param {Object} info
      */
     function onData(info) {
-        var chunk = new Uint8Array(info.chunk);
-        var concatenated = partialChunk !== null ? concat(partialChunk, chunk) :
+        const chunk = new Uint8Array(info.chunk);
+        const concatenated = partialChunk !== null ? (0, byte_parsing_1.concat)(partialChunk, chunk) :
             chunk;
-        var res = extractCompleteChunks(concatenated);
-        var completeChunks = res[0];
+        const res = (0, extract_complete_chunks_1.default)(concatenated);
+        const completeChunks = res[0];
         partialChunk = res[1];
-        for (var i = 0; i < completeChunks.length; i++) {
+        for (let i = 0; i < completeChunks.length; i++) {
             callbacks.onNewChunk(completeChunks[i]);
             if (cancelSignal.isCancelled()) {
                 return;
@@ -58,7 +60,12 @@ export default function lowLatencySegmentLoader(url, content, options, callbacks
             return;
         }
     }
-    return fetchRequest({ url: url, headers: headers, onData: onData, timeout: options.timeout, cancelSignal: cancelSignal })
-        .then(function (res) { return ({ resultType: "chunk-complete",
-        resultData: res }); });
+    return (0, fetch_1.default)({ url,
+        headers,
+        onData,
+        timeout: options.timeout,
+        cancelSignal })
+        .then((res) => ({ resultType: "chunk-complete",
+        resultData: res }));
 }
+exports.default = lowLatencySegmentLoader;

package/dist/_esm5.processed/transports/dash/manifest_parser.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,60 +14,64 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import { formatError } from "../../errors";
-import features from "../../features";
-import log from "../../log";
-import Manifest from "../../manifest";
-import objectAssign from "../../utils/object_assign";
-import request from "../../utils/request";
-import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
-export default function generateManifestParser(options) {
-    var referenceDateTime = options.referenceDateTime;
-    var serverTimeOffset = options.serverSyncInfos !== undefined ?
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const features_1 = require("../../features");
+const log_1 = require("../../log");
+const manifest_1 = require("../../manifest");
+const object_assign_1 = require("../../utils/object_assign");
+const request_1 = require("../../utils/request");
+const string_parsing_1 = require("../../utils/string_parsing");
+function generateManifestParser(options) {
+    const { referenceDateTime } = options;
+    const serverTimeOffset = options.serverSyncInfos !== undefined ?
         options.serverSyncInfos.serverTimestamp - options.serverSyncInfos.clientTime :
         undefined;
     return function manifestParser(manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
         var _a;
-        var responseData = manifestData.responseData;
-        var argClockOffset = parserOptions.externalClockOffset;
-        var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
-        var externalClockOffset = serverTimeOffset !== null && serverTimeOffset !== void 0 ? serverTimeOffset : argClockOffset;
-        var unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
+        const { responseData } = manifestData;
+        const argClockOffset = parserOptions.externalClockOffset;
+        const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+        const externalClockOffset = serverTimeOffset !== null && serverTimeOffset !== void 0 ? serverTimeOffset : argClockOffset;
+        const unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
             parserOptions.previousManifest :
             null;
-        var dashParserOpts = { unsafelyBaseOnPreviousManifest: unsafelyBaseOnPreviousManifest, url: url, referenceDateTime: referenceDateTime, externalClockOffset: externalClockOffset };
-        var parsers = features.dashParsers;
+        const dashParserOpts = { unsafelyBaseOnPreviousManifest,
+            url,
+            referenceDateTime,
+            externalClockOffset };
+        const parsers = features_1.default.dashParsers;
         if (parsers.wasm === null ||
             parsers.wasm.status === "uninitialized" ||
             parsers.wasm.status === "failure") {
-            log.debug("DASH: WASM MPD Parser not initialized. Running JS one.");
+            log_1.default.debug("DASH: WASM MPD Parser not initialized. Running JS one.");
             return runDefaultJsParser();
         }
         else {
-            var manifestAB_1 = getManifestAsArrayBuffer(responseData);
-            if (!doesXmlSeemsUtf8Encoded(manifestAB_1)) {
-                log.info("DASH: MPD doesn't seem to be UTF-8-encoded. " +
+            const manifestAB = getManifestAsArrayBuffer(responseData);
+            if (!doesXmlSeemsUtf8Encoded(manifestAB)) {
+                log_1.default.info("DASH: MPD doesn't seem to be UTF-8-encoded. " +
                     "Running JS parser instead of the WASM one.");
                 return runDefaultJsParser();
             }
             if (parsers.wasm.status === "initialized") {
-                log.debug("DASH: Running WASM MPD Parser.");
-                var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
+                log_1.default.debug("DASH: Running WASM MPD Parser.");
+                const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
                 return processMpdParserResponse(parsed);
             }
             else {
-                log.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
-                var initProm = parsers.wasm.waitForInitialization()
-                    .catch(function () { });
-                return initProm.then(function () {
+                log_1.default.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
+                const initProm = parsers.wasm.waitForInitialization()
+                    .catch(() => { });
+                return initProm.then(() => {
                     if (parsers.wasm === null || parsers.wasm.status !== "initialized") {
-                        log.warn("DASH: WASM MPD parser initialization failed. " +
+                        log_1.default.warn("DASH: WASM MPD parser initialization failed. " +
                             "Running JS parser instead");
                         return runDefaultJsParser();
                     }
-                    log.debug("DASH: Running WASM MPD Parser.");
-                    var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
+                    log_1.default.debug("DASH: Running WASM MPD Parser.");
+                    const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
                     return processMpdParserResponse(parsed);
                 });
             }
@@ -81,8 +86,8 @@ export default function generateManifestParser(options) {
             if (parsers.js === null) {
                 throw new Error("No MPD parser is imported");
             }
-            var manifestDoc = getManifestAsDocument(responseData);
-            var parsedManifest = parsers.js(manifestDoc, dashParserOpts);
+            const manifestDoc = getManifestAsDocument(responseData);
+            const parsedManifest = parsers.js(manifestDoc, dashParserOpts);
             return processMpdParserResponse(parsedManifest);
         }
         /**
@@ -99,26 +104,28 @@ export default function generateManifestParser(options) {
                 if (cancelSignal.isCancelled()) {
                     return Promise.reject(cancelSignal.cancellationError);
                 }
-                var warnings = [];
-                var manifest = new Manifest(parserResponse.value.parsed, options, warnings);
-                return { manifest: manifest, url: url, warnings: warnings };
+                const warnings = [];
+                const manifest = new manifest_1.default(parserResponse.value.parsed, options, warnings);
+                return { manifest, url, warnings };
             }
-            var value = parserResponse.value;
-            var externalResources = value.urls.map(function (resourceUrl) {
-                return scheduleRequest(function () {
-                    var defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
-                    return value.format === "string" ? request({ url: resourceUrl,
+            const { value } = parserResponse;
+            const externalResources = value.urls.map(resourceUrl => {
+                return scheduleRequest(() => {
+                    const defaultTimeout = config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+                    return value.format === "string" ? (0, request_1.default)({ url: resourceUrl,
                         responseType: "text",
-                        timeout: defaultTimeout, cancelSignal: cancelSignal }) :
-                        request({ url: resourceUrl,
+                        timeout: defaultTimeout,
+                        cancelSignal }) :
+                        (0, request_1.default)({ url: resourceUrl,
                             responseType: "arraybuffer",
-                            timeout: defaultTimeout, cancelSignal: cancelSignal });
-                }).then(function (res) {
+                            timeout: defaultTimeout,
+                            cancelSignal });
+                }).then((res) => {
                     if (value.format === "string") {
                         if (typeof res.responseData !== "string") {
                             throw new Error("External DASH resources should have been a string");
                         }
-                        return objectAssign(res, {
+                        return (0, object_assign_1.default)(res, {
                             responseData: {
                                 success: true,
                                 data: res.responseData
@@ -129,29 +136,29 @@ export default function generateManifestParser(options) {
                         if (!(res.responseData instanceof ArrayBuffer)) {
                             throw new Error("External DASH resources should have been ArrayBuffers");
                         }
-                        return objectAssign(res, {
+                        return (0, object_assign_1.default)(res, {
                             responseData: {
                                 success: true,
                                 data: res.responseData
                             },
                         });
                     }
-                }, function (err) {
-                    var error = formatError(err, {
+                }, (err) => {
+                    const error = (0, errors_1.formatError)(err, {
                         defaultCode: "PIPELINE_PARSE_ERROR",
                         defaultReason: "An unknown error occured when parsing ressources.",
                     });
-                    return objectAssign({}, {
+                    return (0, object_assign_1.default)({}, {
                         size: undefined,
                         requestDuration: undefined,
                         responseData: {
                             success: false,
-                            error: error
+                            error
                         },
                     });
                 });
             });
-            return Promise.all(externalResources).then(function (loadedResources) {
+            return Promise.all(externalResources).then(loadedResources => {
                 if (value.format === "string") {
                     assertLoadedResourcesFormatString(loadedResources);
                     return processMpdParserResponse(value.continue(loadedResources));
@@ -164,6 +171,7 @@ export default function generateManifestParser(options) {
         }
     };
 }
+exports.default = generateManifestParser;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
@@ -176,8 +184,8 @@ function assertLoadedResourcesFormatString(loadedResources) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    loadedResources.forEach(function (loadedResource) {
-        var responseData = loadedResource.responseData;
+    loadedResources.forEach((loadedResource) => {
+        const { responseData } = loadedResource;
         if (responseData.success && typeof responseData.data === "string") {
             return;
         }
@@ -199,8 +207,8 @@ function assertLoadedResourcesFormatArrayBuffer(loadedResources) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    loadedResources.forEach(function (loadedResource) {
-        var responseData = loadedResource.responseData;
+    loadedResources.forEach((loadedResource) => {
+        const { responseData } = loadedResource;
         if (responseData.success && responseData.data instanceof ArrayBuffer) {
             return;
         }
@@ -221,7 +229,7 @@ function assertLoadedResourcesFormatArrayBuffer(loadedResources) {
 function getManifestAsDocument(manifestSrc) {
     if (manifestSrc instanceof ArrayBuffer) {
         return new DOMParser()
-            .parseFromString(utf8ToStr(new Uint8Array(manifestSrc)), "text/xml");
+            .parseFromString((0, string_parsing_1.utf8ToStr)(new Uint8Array(manifestSrc)), "text/xml");
     }
     else if (typeof manifestSrc === "string") {
         return new DOMParser().parseFromString(manifestSrc, "text/xml");
@@ -244,10 +252,10 @@ function getManifestAsArrayBuffer(manifestSrc) {
         return manifestSrc;
     }
     else if (typeof manifestSrc === "string") {
-        return strToUtf8(manifestSrc).buffer;
+        return (0, string_parsing_1.strToUtf8)(manifestSrc).buffer;
     }
     else if (manifestSrc instanceof Document) {
-        return strToUtf8(manifestSrc.documentElement.innerHTML).buffer;
+        return (0, string_parsing_1.strToUtf8)(manifestSrc.documentElement.innerHTML).buffer;
     }
     else {
         throw new Error("DASH Manifest Parser: Unrecognized Manifest format");
@@ -262,7 +270,7 @@ function getManifestAsArrayBuffer(manifestSrc) {
  * @returns {boolean}
  */
 function doesXmlSeemsUtf8Encoded(xmlData) {
-    var dv = new DataView(xmlData);
+    const dv = new DataView(xmlData);
     if (dv.getUint16(0) === 0xEFBB && dv.getUint8(2) === 0XBF) {
         // (UTF-8 BOM)
         return true;