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

package/dist/_esm5.processed/transports/smooth/isobmff/parse_tfrf.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,35 +14,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { getUuidContent } from "../../../parsers/containers/isobmff";
-import { be4toi, be8toi, } from "../../../utils/byte_parsing";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isobmff_1 = require("../../../parsers/containers/isobmff");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
 /**
  * @param {Uint8Array} traf
  * @returns {Array.<Object>}
  */
-export default function parseTfrf(traf) {
-    var tfrf = getUuidContent(traf, 0xD4807EF2, 0xCA394695, 0x8E5426CB, 0x9E46A79F);
+function parseTfrf(traf) {
+    const tfrf = (0, isobmff_1.getUuidContent)(traf, 0xD4807EF2, 0xCA394695, 0x8E5426CB, 0x9E46A79F);
     if (tfrf === undefined) {
         return [];
     }
-    var frags = [];
-    var version = tfrf[0];
-    var fragCount = tfrf[4];
-    for (var i = 0; i < fragCount; i++) {
-        var duration = void 0;
-        var time = void 0;
+    const frags = [];
+    const version = tfrf[0];
+    const fragCount = tfrf[4];
+    for (let i = 0; i < fragCount; i++) {
+        let duration;
+        let time;
         if (version === 1) {
-            time = be8toi(tfrf, i * 16 + 5);
-            duration = be8toi(tfrf, i * 16 + 5 + 8);
+            time = (0, byte_parsing_1.be8toi)(tfrf, i * 16 + 5);
+            duration = (0, byte_parsing_1.be8toi)(tfrf, i * 16 + 5 + 8);
         }
         else {
-            time = be4toi(tfrf, i * 8 + 5);
-            duration = be4toi(tfrf, i * 8 + 5 + 4);
+            time = (0, byte_parsing_1.be4toi)(tfrf, i * 8 + 5);
+            duration = (0, byte_parsing_1.be4toi)(tfrf, i * 8 + 5 + 4);
         }
         frags.push({
-            time: time,
-            duration: duration,
+            time,
+            duration,
         });
     }
     return frags;
 }
+exports.default = parseTfrf;

package/dist/_esm5.processed/transports/smooth/isobmff/parse_tfxd.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,19 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { getUuidContent } from "../../../parsers/containers/isobmff";
-import { be8toi } from "../../../utils/byte_parsing";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isobmff_1 = require("../../../parsers/containers/isobmff");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
 /**
  * @param {Uint8Array} traf
  * @returns {Object|undefined}
  */
-export default function parseTfxd(traf) {
-    var tfxd = getUuidContent(traf, 0x6D1D9B05, 0x42D544E6, 0x80E2141D, 0xAFF757B2);
+function parseTfxd(traf) {
+    const tfxd = (0, isobmff_1.getUuidContent)(traf, 0x6D1D9B05, 0x42D544E6, 0x80E2141D, 0xAFF757B2);
     if (tfxd === undefined) {
         return undefined;
     }
     return {
-        duration: be8toi(tfxd, 12),
-        time: be8toi(tfxd, 4),
+        duration: (0, byte_parsing_1.be8toi)(tfxd, 12),
+        time: (0, byte_parsing_1.be8toi)(tfxd, 4),
     };
 }
+exports.default = parseTfxd;

package/dist/_esm5.processed/transports/smooth/isobmff/patch_segment.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { canPatchISOBMFFSegment } from "../../../compat";
-import { createBoxWithChildren, getBox, getBoxContent, getBoxOffsets, getUuidContent, updateBoxLength, } from "../../../parsers/containers/isobmff";
-import { itobe4 } from "../../../utils/byte_parsing";
-import { createFreeBox, createTfdtBox, } from "./create_boxes";
-import createTrafBox from "./create_traf_box";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../compat");
+const isobmff_1 = require("../../../parsers/containers/isobmff");
+const byte_parsing_1 = require("../../../utils/byte_parsing");
+const create_boxes_1 = require("./create_boxes");
+const create_traf_box_1 = require("./create_traf_box");
 /**
  * Update ISOBMFF Segment downloaded in Smooth Streaming so it is playable on
  * the browser.
@@ -25,39 +27,39 @@ import createTrafBox from "./create_traf_box";
  * @param {Number} decodeTime
  * @return {Uint8Array}
  */
-export default function patchSegment(segment, decodeTime) {
-    var oldMoofOffsets = getBoxOffsets(segment, 0x6D6F6F66 /* moof */);
+function patchSegment(segment, decodeTime) {
+    const oldMoofOffsets = (0, isobmff_1.getBoxOffsets)(segment, 0x6D6F6F66 /* moof */);
     if (oldMoofOffsets === null) {
         throw new Error("Smooth: Invalid ISOBMFF given");
     }
-    var oldMoofContent = segment.subarray(oldMoofOffsets[1], oldMoofOffsets[2]);
-    var mfhdBox = getBox(oldMoofContent, 0x6D666864 /* mfhd */);
-    var trafContent = getBoxContent(oldMoofContent, 0x74726166 /* traf */);
+    const oldMoofContent = segment.subarray(oldMoofOffsets[1], oldMoofOffsets[2]);
+    const mfhdBox = (0, isobmff_1.getBox)(oldMoofContent, 0x6D666864 /* mfhd */);
+    const trafContent = (0, isobmff_1.getBoxContent)(oldMoofContent, 0x74726166 /* traf */);
     if (trafContent === null || mfhdBox === null) {
         throw new Error("Smooth: Invalid ISOBMFF given");
     }
-    var tfhdOffsets = getBoxOffsets(trafContent, 0x74666864 /* tfhd */);
-    var oldTrunOffsets = getBoxOffsets(trafContent, 0x7472756E /* trun */);
+    const tfhdOffsets = (0, isobmff_1.getBoxOffsets)(trafContent, 0x74666864 /* tfhd */);
+    const oldTrunOffsets = (0, isobmff_1.getBoxOffsets)(trafContent, 0x7472756E /* trun */);
     if (tfhdOffsets === null || oldTrunOffsets === null) {
         throw new Error("Smooth: Invalid ISOBMFF given");
     }
-    var tfhdBox = trafContent.subarray(tfhdOffsets[0], tfhdOffsets[2]);
-    var oldTrunBox = trafContent.subarray(oldTrunOffsets[0], oldTrunOffsets[2]);
+    const tfhdBox = trafContent.subarray(tfhdOffsets[0], tfhdOffsets[2]);
+    const oldTrunBox = trafContent.subarray(oldTrunOffsets[0], oldTrunOffsets[2]);
     // force trackId=1 since trackIds are not always reliable...
     tfhdBox.set([0, 0, 0, 1], tfhdOffsets[1] - tfhdOffsets[0] + 4 /* version + flags */);
-    var tfdtBox = createTfdtBox(decodeTime);
-    var newTrunBox = updateTrunDataOffset(oldTrunBox, oldTrunOffsets[1] - oldTrunOffsets[0]);
-    var sencContent = getUuidContent(trafContent, 0xA2394F52, 0x5A9B4F14, 0xA2446C42, 0x7C648DF4);
-    var newTrafBox = createTrafBox(tfhdBox, tfdtBox, newTrunBox, mfhdBox, sencContent);
-    var newMoof = createBoxWithChildren("moof", [mfhdBox, newTrafBox]);
-    var newMoofOffsets = getBoxOffsets(newMoof, 0x6D6F6F66 /* moof */);
-    var newTrafOffsets = getBoxOffsets(newTrafBox, 0x74726166 /* traf */);
-    var newTrunOffsets = getBoxOffsets(newTrunBox, 0x7472756E /* trun */);
+    const tfdtBox = (0, create_boxes_1.createTfdtBox)(decodeTime);
+    const newTrunBox = updateTrunDataOffset(oldTrunBox, oldTrunOffsets[1] - oldTrunOffsets[0]);
+    const sencContent = (0, isobmff_1.getUuidContent)(trafContent, 0xA2394F52, 0x5A9B4F14, 0xA2446C42, 0x7C648DF4);
+    const newTrafBox = (0, create_traf_box_1.default)(tfhdBox, tfdtBox, newTrunBox, mfhdBox, sencContent);
+    const newMoof = (0, isobmff_1.createBoxWithChildren)("moof", [mfhdBox, newTrafBox]);
+    const newMoofOffsets = (0, isobmff_1.getBoxOffsets)(newMoof, 0x6D6F6F66 /* moof */);
+    const newTrafOffsets = (0, isobmff_1.getBoxOffsets)(newTrafBox, 0x74726166 /* traf */);
+    const newTrunOffsets = (0, isobmff_1.getBoxOffsets)(newTrunBox, 0x7472756E /* trun */);
     if (newMoofOffsets === null || newTrafOffsets === null || newTrunOffsets === null) {
         throw new Error("Smooth: Invalid moof, trun or traf generation");
     }
     /** index of the `data_offset` property from the trun box in the whole "moof". */
-    var indexOfTrunDataOffsetInMoof = (newMoofOffsets[1] - newMoofOffsets[0]) +
+    const indexOfTrunDataOffsetInMoof = (newMoofOffsets[1] - newMoofOffsets[0]) +
         mfhdBox.length +
         /* new traf size + name */
         (newTrafOffsets[1] - newTrafOffsets[0]) +
@@ -66,36 +68,37 @@ export default function patchSegment(segment, decodeTime) {
         /* new trun size + name */
         (newTrunOffsets[1] - newTrunOffsets[0]) +
         8 /* trun version + flags + `sample_count` */;
-    var oldMoofLength = oldMoofOffsets[2] - oldMoofOffsets[0];
-    var newMoofSizeDiff = newMoof.length - oldMoofLength;
-    var oldMdatOffset = getBoxOffsets(segment, 0x6D646174 /* "mdat" */);
+    const oldMoofLength = oldMoofOffsets[2] - oldMoofOffsets[0];
+    const newMoofSizeDiff = newMoof.length - oldMoofLength;
+    const oldMdatOffset = (0, isobmff_1.getBoxOffsets)(segment, 0x6D646174 /* "mdat" */);
     if (oldMdatOffset === null) {
         throw new Error("Smooth: Invalid ISOBMFF given");
     }
-    if (canPatchISOBMFFSegment() && (newMoofSizeDiff === 0 || newMoofSizeDiff <= -8)) {
+    if ((0, compat_1.canPatchISOBMFFSegment)() && (newMoofSizeDiff === 0 || newMoofSizeDiff <= -8)) {
         // patch trun data_offset
-        var mdatContentOffset = oldMdatOffset[1];
-        newMoof.set(itobe4(mdatContentOffset), indexOfTrunDataOffsetInMoof);
+        const mdatContentOffset = oldMdatOffset[1];
+        newMoof.set((0, byte_parsing_1.itobe4)(mdatContentOffset), indexOfTrunDataOffsetInMoof);
         segment.set(newMoof, oldMoofOffsets[0]);
         // add "free" box for the remaining space
         if (newMoofSizeDiff <= -8) {
-            segment.set(createFreeBox(-newMoofSizeDiff), newMoof.length);
+            segment.set((0, create_boxes_1.createFreeBox)(-newMoofSizeDiff), newMoof.length);
         }
         return segment;
     }
     else {
         // patch trun data_offset
-        var mdatContentOffset = oldMdatOffset[1] + newMoofSizeDiff;
-        newMoof.set(itobe4(mdatContentOffset), indexOfTrunDataOffsetInMoof);
-        var newSegment = new Uint8Array(segment.length + newMoofSizeDiff);
-        var beforeMoof = segment.subarray(0, oldMoofOffsets[0]);
-        var afterMoof = segment.subarray(oldMoofOffsets[2], segment.length);
+        const mdatContentOffset = oldMdatOffset[1] + newMoofSizeDiff;
+        newMoof.set((0, byte_parsing_1.itobe4)(mdatContentOffset), indexOfTrunDataOffsetInMoof);
+        const newSegment = new Uint8Array(segment.length + newMoofSizeDiff);
+        const beforeMoof = segment.subarray(0, oldMoofOffsets[0]);
+        const afterMoof = segment.subarray(oldMoofOffsets[2], segment.length);
         newSegment.set(beforeMoof, 0);
         newSegment.set(newMoof, beforeMoof.length);
         newSegment.set(afterMoof, beforeMoof.length + newMoof.length);
         return newSegment;
     }
 }
+exports.default = patchSegment;
 /**
  * Update `trun` box given or create a new one from it to add a data offset
  * flag and the corresponding space to set a data offset.
@@ -110,12 +113,12 @@ export default function patchSegment(segment, decodeTime) {
  * @returns {Uint8Array}
  */
 function updateTrunDataOffset(oldTrunBox, initialDataOffset) {
-    var trunHasDataOffset = (oldTrunBox[initialDataOffset + 3 /* last flag */] & 0x01) > 0;
+    const trunHasDataOffset = (oldTrunBox[initialDataOffset + 3 /* last flag */] & 0x01) > 0;
     if (trunHasDataOffset) {
         return oldTrunBox;
     }
     // If no data_offset is present, we create another "trun" with one
-    var newTrunBox = new Uint8Array(oldTrunBox.length + 4);
+    const newTrunBox = new Uint8Array(oldTrunBox.length + 4);
     // copy size + name + version=1 + flags=3 + sample_count=4
     newTrunBox.set(oldTrunBox.subarray(0, initialDataOffset + 8), 0);
     // add data_offset flag
@@ -123,5 +126,5 @@ function updateTrunDataOffset(oldTrunBox, initialDataOffset) {
     newTrunBox.set([0, 0, 0, 0], initialDataOffset + 8); // add data offset
     // add the rest
     newTrunBox.set(oldTrunBox.subarray(initialDataOffset + 8, oldTrunBox.length), initialDataOffset + 12);
-    return updateBoxLength(newTrunBox); // update the trun box's length
+    return (0, isobmff_1.updateBoxLength)(newTrunBox); // update the trun box's length
 }

package/dist/_esm5.processed/transports/smooth/pipelines.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,57 +14,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import log from "../../log";
-import Manifest from "../../manifest";
-import { getMDAT } from "../../parsers/containers/isobmff";
-import createSmoothManifestParser from "../../parsers/manifest/smooth";
-import request from "../../utils/request";
-import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
-import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
-import generateManifestLoader from "../utils/generate_manifest_loader";
-import extractTimingsInfos from "./extract_timings_infos";
-import isMP4EmbeddedTrack from "./is_mp4_embedded_track";
-import { patchSegment } from "./isobmff";
-import generateSegmentLoader from "./segment_loader";
-import { constructSegmentUrl } from "./utils";
-export default function (transportOptions) {
-    var smoothManifestParser = createSmoothManifestParser(transportOptions);
-    var segmentLoader = generateSegmentLoader(transportOptions);
-    var manifestLoaderOptions = { customManifestLoader: transportOptions.manifestLoader };
-    var manifestLoader = generateManifestLoader(manifestLoaderOptions, "text");
-    var manifestPipeline = {
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../log");
+const manifest_1 = require("../../manifest");
+const isobmff_1 = require("../../parsers/containers/isobmff");
+const smooth_1 = require("../../parsers/manifest/smooth");
+const request_1 = require("../../utils/request");
+const string_parsing_1 = require("../../utils/string_parsing");
+const check_isobmff_integrity_1 = require("../utils/check_isobmff_integrity");
+const generate_manifest_loader_1 = require("../utils/generate_manifest_loader");
+const extract_timings_infos_1 = require("./extract_timings_infos");
+const is_mp4_embedded_track_1 = require("./is_mp4_embedded_track");
+const isobmff_2 = require("./isobmff");
+const segment_loader_1 = require("./segment_loader");
+const utils_1 = require("./utils");
+function default_1(transportOptions) {
+    const smoothManifestParser = (0, smooth_1.default)(transportOptions);
+    const segmentLoader = (0, segment_loader_1.default)(transportOptions);
+    const manifestLoaderOptions = { customManifestLoader: transportOptions.manifestLoader };
+    const manifestLoader = (0, generate_manifest_loader_1.default)(manifestLoaderOptions, "text");
+    const manifestPipeline = {
         loadManifest: manifestLoader,
-        parseManifest: function (manifestData, parserOptions) {
+        parseManifest(manifestData, parserOptions) {
             var _a;
-            var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
-            var manifestReceivedTime = manifestData.receivedTime, responseData = manifestData.responseData;
-            var documentData = typeof responseData === "string" ?
+            const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+            const { receivedTime: manifestReceivedTime, responseData } = manifestData;
+            const documentData = typeof responseData === "string" ?
                 new DOMParser().parseFromString(responseData, "text/xml") :
                 responseData; // TODO find a way to check if Document?
-            var parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
-            var warnings = [];
-            var manifest = new Manifest(parserResult, {
+            const parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
+            const warnings = [];
+            const manifest = new manifest_1.default(parserResult, {
                 representationFilter: transportOptions.representationFilter,
             }, warnings);
-            return { manifest: manifest, url: url, warnings: warnings };
+            return { manifest, url, warnings };
         },
     };
     /**
      * Export functions allowing to load and parse audio and video smooth
      * segments.
      */
-    var audioVideoPipeline = {
+    const audioVideoPipeline = {
         /**
          * Load a Smooth audio/video segment.
          * @param {Object|null} wantedCdn
@@ -73,14 +64,14 @@ export default function (transportOptions) {
          * @param {Object} callbacks
          * @returns {Promise}
          */
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            var url = constructSegmentUrl(wantedCdn, context.segment);
+        loadSegment(wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
+            const url = (0, utils_1.constructSegmentUrl)(wantedCdn, context.segment);
             return segmentLoader(url, context, loaderOptions, cancelSignal, callbacks);
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
+        parseSegment(loadedSegment, context, initTimescale) {
             var _a, _b;
-            var segment = context.segment;
-            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
+            const { segment } = context;
+            const { data, isChunked } = loadedSegment;
             if (data === null) {
                 if (segment.isInit) {
                     return { segmentType: "init",
@@ -97,10 +88,10 @@ export default function (transportOptions) {
                     protectionData: [],
                     appendWindow: [undefined, undefined] };
             }
-            var responseBuffer = data instanceof Uint8Array ? data :
+            const responseBuffer = data instanceof Uint8Array ? data :
                 new Uint8Array(data);
             if (segment.isInit) {
-                var timescale = (_b = (_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothInitSegment) === null || _b === void 0 ? void 0 : _b.timescale;
+                const timescale = (_b = (_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothInitSegment) === null || _b === void 0 ? void 0 : _b.timescale;
                 return { segmentType: "init",
                     initializationData: data,
                     initializationDataSize: data.byteLength,
@@ -109,59 +100,70 @@ export default function (transportOptions) {
                     initTimescale: timescale,
                     protectionData: [] };
             }
-            var timingInfos = initTimescale !== undefined ?
-                extractTimingsInfos(responseBuffer, isChunked, initTimescale, segment, context.isLive) :
+            const timingInfos = initTimescale !== undefined ?
+                (0, extract_timings_infos_1.default)(responseBuffer, isChunked, initTimescale, segment, context.isLive) :
                 null;
             if (timingInfos === null ||
                 timingInfos.chunkInfos === null ||
                 timingInfos.scaledSegmentTime === undefined) {
                 throw new Error("Smooth Segment without time information");
             }
-            var nextSegments = timingInfos.nextSegments, chunkInfos = timingInfos.chunkInfos, scaledSegmentTime = timingInfos.scaledSegmentTime;
-            var chunkData = patchSegment(responseBuffer, scaledSegmentTime);
-            var predictedSegments = nextSegments.length > 0 ? nextSegments :
+            const { nextSegments, chunkInfos, scaledSegmentTime } = timingInfos;
+            const chunkData = (0, isobmff_2.patchSegment)(responseBuffer, scaledSegmentTime);
+            const predictedSegments = nextSegments.length > 0 ? nextSegments :
                 undefined;
-            return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: 0,
+            return { segmentType: "media",
+                chunkData,
+                chunkInfos,
+                chunkOffset: 0,
                 chunkSize: chunkData.length,
-                protectionData: [], predictedSegments: predictedSegments, appendWindow: [undefined, undefined] };
+                protectionData: [],
+                predictedSegments,
+                appendWindow: [undefined, undefined] };
         },
     };
-    var textTrackPipeline = {
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            var segment = context.segment;
-            var url = constructSegmentUrl(wantedCdn, segment);
+    const textTrackPipeline = {
+        loadSegment(wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
+            const { segment } = context;
+            const url = (0, utils_1.constructSegmentUrl)(wantedCdn, segment);
             if (segment.isInit || url === null) {
                 return Promise.resolve({ resultType: "segment-created",
                     resultData: null });
             }
-            var isMP4 = isMP4EmbeddedTrack(context.mimeType);
+            const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
             if (!isMP4) {
-                return request({ url: url, responseType: "text",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-                    .then(function (data) { return ({ resultType: "segment-loaded",
-                    resultData: data }); });
+                return (0, request_1.default)({ url,
+                    responseType: "text",
+                    timeout: loaderOptions.timeout,
+                    cancelSignal,
+                    onProgress: callbacks.onProgress })
+                    .then((data) => ({ resultType: "segment-loaded",
+                    resultData: data }));
             }
             else {
-                return request({ url: url, responseType: "arraybuffer",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-                    .then(function (data) {
+                return (0, request_1.default)({ url,
+                    responseType: "arraybuffer",
+                    timeout: loaderOptions.timeout,
+                    cancelSignal,
+                    onProgress: callbacks.onProgress })
+                    .then((data) => {
                     if (transportOptions.checkMediaSegmentIntegrity !== true) {
                         return { resultType: "segment-loaded",
                             resultData: data };
                     }
-                    var dataU8 = new Uint8Array(data.responseData);
-                    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+                    const dataU8 = new Uint8Array(data.responseData);
+                    (0, check_isobmff_integrity_1.default)(dataU8, context.segment.isInit);
                     return { resultType: "segment-loaded",
-                        resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
+                        resultData: Object.assign(Object.assign({}, data), { responseData: dataU8 }) };
                 });
             }
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
+        parseSegment(loadedSegment, context, initTimescale) {
             var _a;
-            var segment = context.segment, language = context.language, _b = context.mimeType, mimeType = _b === void 0 ? "" : _b, _c = context.codecs, codecs = _c === void 0 ? "" : _c;
-            var isMP4 = isMP4EmbeddedTrack(context.mimeType);
-            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
-            var chunkSize;
+            const { segment, language, mimeType = "", codecs = "" } = context;
+            const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
+            const { data, isChunked } = loadedSegment;
+            let chunkSize;
             if (segment.isInit) { // text init segment has no use in HSS
                 return { segmentType: "init",
                     initializationData: null,
@@ -178,30 +180,30 @@ export default function (transportOptions) {
                     protectionData: [],
                     appendWindow: [undefined, undefined] };
             }
-            var nextSegments;
-            var chunkInfos = null;
-            var segmentStart;
-            var segmentEnd;
-            var _sdData;
-            var _sdType;
+            let nextSegments;
+            let chunkInfos = null;
+            let segmentStart;
+            let segmentEnd;
+            let _sdData;
+            let _sdType;
             if (isMP4) {
-                var chunkBytes = void 0;
+                let chunkBytes;
                 if (typeof data === "string") {
-                    chunkBytes = strToUtf8(data);
+                    chunkBytes = (0, string_parsing_1.strToUtf8)(data);
                 }
                 else {
                     chunkBytes = data instanceof Uint8Array ? data :
                         new Uint8Array(data);
                 }
                 chunkSize = chunkBytes.length;
-                var timingInfos = initTimescale !== undefined ?
-                    extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, context.isLive) :
+                const timingInfos = initTimescale !== undefined ?
+                    (0, extract_timings_infos_1.default)(chunkBytes, isChunked, initTimescale, segment, context.isLive) :
                     null;
                 nextSegments = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.nextSegments;
                 chunkInfos = (_a = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.chunkInfos) !== null && _a !== void 0 ? _a : null;
                 if (chunkInfos === null) {
                     if (isChunked) {
-                        log.warn("Smooth: Unavailable time data for current text track.");
+                        log_1.default.warn("Smooth: Unavailable time data for current text track.");
                     }
                     else {
                         segmentStart = segment.time;
@@ -214,7 +216,7 @@ export default function (transportOptions) {
                         chunkInfos.time + chunkInfos.duration :
                         segment.end;
                 }
-                var lcCodec = codecs.toLowerCase();
+                const lcCodec = codecs.toLowerCase();
                 if (mimeType === "application/ttml+xml+mp4" ||
                     lcCodec === "stpp" ||
                     lcCodec === "stpp.ttml.im1t") {
@@ -224,21 +226,21 @@ export default function (transportOptions) {
                     _sdType = "vtt";
                 }
                 else {
-                    throw new Error("could not find a text-track parser for the type ".concat(mimeType));
+                    throw new Error(`could not find a text-track parser for the type ${mimeType}`);
                 }
-                var mdat = getMDAT(chunkBytes);
+                const mdat = (0, isobmff_1.getMDAT)(chunkBytes);
                 _sdData = mdat === null ? "" :
-                    utf8ToStr(mdat);
+                    (0, string_parsing_1.utf8ToStr)(mdat);
             }
             else { // not MP4
                 segmentStart = segment.time;
                 segmentEnd = segment.end;
-                var chunkString = void 0;
+                let chunkString;
                 if (typeof data !== "string") {
-                    var bytesData = data instanceof Uint8Array ? data :
+                    const bytesData = data instanceof Uint8Array ? data :
                         new Uint8Array(data);
                     chunkSize = bytesData.length;
-                    chunkString = utf8ToStr(bytesData);
+                    chunkString = (0, string_parsing_1.utf8ToStr)(bytesData);
                 }
                 else {
                     chunkString = data;
@@ -256,25 +258,32 @@ export default function (transportOptions) {
                         break;
                 }
                 if (_sdType === undefined) {
-                    var lcCodec = codecs.toLowerCase();
+                    const lcCodec = codecs.toLowerCase();
                     if (lcCodec === "srt") {
                         _sdType = "srt";
                     }
                     else {
-                        throw new Error("could not find a text-track parser for the type ".concat(mimeType));
+                        throw new Error(`could not find a text-track parser for the type ${mimeType}`);
                     }
                 }
                 _sdData = chunkString;
             }
-            var predictedSegments = Array.isArray(nextSegments) &&
+            const predictedSegments = Array.isArray(nextSegments) &&
                 nextSegments.length > 0 ? nextSegments :
                 undefined;
-            var chunkOffset = segmentStart !== null && segmentStart !== void 0 ? segmentStart : 0;
+            const chunkOffset = segmentStart !== null && segmentStart !== void 0 ? segmentStart : 0;
             return { segmentType: "media",
                 chunkData: { type: _sdType,
                     data: _sdData,
                     start: segmentStart,
-                    end: segmentEnd, language: language }, chunkSize: chunkSize, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionData: [], predictedSegments: predictedSegments, appendWindow: [undefined, undefined] };
+                    end: segmentEnd,
+                    language },
+                chunkSize,
+                chunkInfos,
+                chunkOffset,
+                protectionData: [],
+                predictedSegments,
+                appendWindow: [undefined, undefined] };
         },
     };
     return { manifest: manifestPipeline,
@@ -282,3 +291,4 @@ export default function (transportOptions) {
         video: audioVideoPipeline,
         text: textTrackPipeline };
 }
+exports.default = default_1;

package/dist/_esm5.processed/transports/smooth/segment_loader.d.ts

@@ -20,8 +20,8 @@ import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegme
  * Defines the url for the request, load the right loader (custom/default
  * one).
  */
-declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, customSegmentLoader, }: {
+declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, segmentLoader, }: {
     checkMediaSegmentIntegrity?: boolean | undefined;
-    customSegmentLoader?: ICustomSegmentLoader | undefined;
+    segmentLoader?: ICustomSegmentLoader | undefined;
 }) => (url: string | null, context: ISegmentContext, loaderOptions: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array | ArrayBuffer | null>>;
 export default generateSegmentLoader;