rx-player 4.0.0-dev.2023120600 → 4.0.0-dev.2023121900

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

@@ -24,25 +24,110 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
 import { getMDAT } from "../../parsers/containers/isobmff";
-import createSmoothManifestParser from "../../parsers/manifest/smooth";
+import createSmoothManifestParser, { SmoothRepresentationIndex, } from "../../parsers/manifest/smooth";
 import request from "../../utils/request";
 import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
+import warnOnce from "../../utils/warn_once";
 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";
+import { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, } from "./utils";
+var WSX_REG = /\.wsx?(\?token=\S+)?/;
+/**
+ * @param {Object} adaptation
+ * @param {Object} dlSegment
+ * @param {Object} nextSegments
+ */
+function addNextSegments(adaptation, nextSegments, dlSegment) {
+    var _a;
+    log.debug("Smooth Parser: update segments information.");
+    var representations = adaptation.representations;
+    for (var i = 0; i < representations.length; i++) {
+        var representation = representations[i];
+        if (representation.index instanceof SmoothRepresentationIndex &&
+            ((_a = dlSegment === null || dlSegment === void 0 ? void 0 : dlSegment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothMediaSegment) !== undefined) {
+            representation.index.addNewSegments(nextSegments, dlSegment.privateInfos.smoothMediaSegment);
+        }
+        else {
+            log.warn("Smooth Parser: should only encounter SmoothRepresentationIndex");
+        }
+    }
+}
 export default function (transportOptions) {
     var smoothManifestParser = createSmoothManifestParser(transportOptions);
     var segmentLoader = generateSegmentLoader(transportOptions);
     var manifestLoaderOptions = { customManifestLoader: transportOptions.manifestLoader };
     var manifestLoader = generateManifestLoader(manifestLoaderOptions, "text");
     var manifestPipeline = {
+        // TODO (v4.x.x) Remove that function
+        resolveManifestUrl: function (url, cancelSignal) {
+            if (url === undefined) {
+                return Promise.resolve(undefined);
+            }
+            var resolving;
+            if (WSX_REG.test(url)) {
+                warnOnce("Giving WSX URL to loadVideo is deprecated." +
+                    " You should only give Manifest URLs.");
+                resolving = request({ url: replaceToken(url, ""),
+                    responseType: "document", cancelSignal: cancelSignal })
+                    .then(function (value) {
+                    var extractedURL = extractISML(value.responseData);
+                    if (extractedURL === null || extractedURL.length === 0) {
+                        throw new Error("Invalid ISML");
+                    }
+                    return extractedURL;
+                });
+            }
+            else {
+                resolving = Promise.resolve(url);
+            }
+            var token = extractToken(url);
+            return resolving.then(function (_url) {
+                return replaceToken(resolveManifest(_url), token);
+            });
+        },
         loadManifest: manifestLoader,
         parseManifest: function (manifestData, parserOptions) {
             var _a;
@@ -54,6 +139,8 @@ export default function (transportOptions) {
             var parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
             var manifest = new Manifest(parserResult, {
                 representationFilter: transportOptions.representationFilter,
+                supplementaryImageTracks: transportOptions.supplementaryImageTracks,
+                supplementaryTextTracks: transportOptions.supplementaryTextTracks,
             });
             return { manifest: manifest, url: url };
         },
@@ -66,26 +153,26 @@ export default function (transportOptions) {
         /**
          * Load a Smooth audio/video segment.
          * @param {Object|null} wantedCdn
-         * @param {Object} context
+         * @param {Object} content
          * @param {Object} loaderOptions
          * @param {Object} cancelSignal
          * @param {Object} callbacks
          * @returns {Promise}
          */
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            var url = constructSegmentUrl(wantedCdn, context.segment);
-            return segmentLoader(url, context, loaderOptions, cancelSignal, callbacks);
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
+            var url = constructSegmentUrl(wantedCdn, content.segment);
+            return segmentLoader(url, content, loaderOptions, cancelSignal, callbacks);
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
+        parseSegment: function (loadedSegment, content, initTimescale) {
             var _a, _b;
-            var segment = context.segment;
+            var segment = content.segment, adaptation = content.adaptation, manifest = content.manifest;
             var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             if (data === null) {
                 if (segment.isInit) {
                     return { segmentType: "init",
                         initializationData: null,
                         initializationDataSize: 0,
-                        protectionData: [],
+                        protectionDataUpdate: false,
                         initTimescale: undefined };
                 }
                 return { segmentType: "media",
@@ -93,7 +180,7 @@ export default function (transportOptions) {
                     chunkInfos: null,
                     chunkOffset: 0,
                     chunkSize: 0,
-                    protectionData: [],
+                    protectionDataUpdate: false,
                     appendWindow: [undefined, undefined] };
             }
             var responseBuffer = data instanceof Uint8Array ? data :
@@ -106,10 +193,10 @@ export default function (transportOptions) {
                     // smooth init segments are crafted by hand.
                     // Their timescale is the one from the manifest.
                     initTimescale: timescale,
-                    protectionData: [] };
+                    protectionDataUpdate: false };
             }
             var timingInfos = initTimescale !== undefined ?
-                extractTimingsInfos(responseBuffer, isChunked, initTimescale, segment, context.isLive) :
+                extractTimingsInfos(responseBuffer, isChunked, initTimescale, segment, manifest.isLive) :
                 null;
             if (timingInfos === null ||
                 timingInfos.chunkInfos === null ||
@@ -118,22 +205,24 @@ export default function (transportOptions) {
             }
             var nextSegments = timingInfos.nextSegments, chunkInfos = timingInfos.chunkInfos, scaledSegmentTime = timingInfos.scaledSegmentTime;
             var chunkData = patchSegment(responseBuffer, scaledSegmentTime);
-            var predictedSegments = nextSegments.length > 0 ? nextSegments :
-                undefined;
+            if (nextSegments.length > 0) {
+                addNextSegments(adaptation, nextSegments, segment);
+            }
             return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: 0,
                 chunkSize: chunkData.length,
-                protectionData: [], predictedSegments: predictedSegments, appendWindow: [undefined, undefined] };
+                protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
         },
     };
     var textTrackPipeline = {
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            var segment = context.segment;
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
+            var segment = content.segment, representation = content.representation;
             var url = constructSegmentUrl(wantedCdn, segment);
             if (segment.isInit || url === null) {
                 return Promise.resolve({ resultType: "segment-created",
                     resultData: null });
             }
-            var isMP4 = isMP4EmbeddedTrack(context.mimeType);
+            var isMP4 = isMP4EmbeddedTrack(representation);
             if (!isMP4) {
                 return request({ url: url, responseType: "text",
                     timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
@@ -149,23 +238,25 @@ export default function (transportOptions) {
                             resultData: data };
                     }
                     var dataU8 = new Uint8Array(data.responseData);
-                    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+                    checkISOBMFFIntegrity(dataU8, content.segment.isInit);
                     return { resultType: "segment-loaded",
                         resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
                 });
             }
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
+        parseSegment: function (loadedSegment, content, 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 manifest = content.manifest, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
+            var language = adaptation.language;
+            var isMP4 = isMP4EmbeddedTrack(representation);
+            var _b = representation.mimeType, mimeType = _b === void 0 ? "" : _b, _c = representation.codec, codec = _c === void 0 ? "" : _c;
             var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             var chunkSize;
             if (segment.isInit) { // text init segment has no use in HSS
                 return { segmentType: "init",
                     initializationData: null,
                     initializationDataSize: 0,
-                    protectionData: [],
+                    protectionDataUpdate: false,
                     initTimescale: undefined };
             }
             if (data === null) {
@@ -174,7 +265,7 @@ export default function (transportOptions) {
                     chunkInfos: null,
                     chunkOffset: 0,
                     chunkSize: 0,
-                    protectionData: [],
+                    protectionDataUpdate: false,
                     appendWindow: [undefined, undefined] };
             }
             var nextSegments;
@@ -194,7 +285,7 @@ export default function (transportOptions) {
                 }
                 chunkSize = chunkBytes.length;
                 var timingInfos = initTimescale !== undefined ?
-                    extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, context.isLive) :
+                    extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, manifest.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;
@@ -213,7 +304,7 @@ export default function (transportOptions) {
                         chunkInfos.time + chunkInfos.duration :
                         segment.end;
                 }
-                var lcCodec = codecs.toLowerCase();
+                var lcCodec = codec.toLowerCase();
                 if (mimeType === "application/ttml+xml+mp4" ||
                     lcCodec === "stpp" ||
                     lcCodec === "stpp.ttml.im1t") {
@@ -255,7 +346,7 @@ export default function (transportOptions) {
                         break;
                 }
                 if (_sdType === undefined) {
-                    var lcCodec = codecs.toLowerCase();
+                    var lcCodec = codec.toLowerCase();
                     if (lcCodec === "srt") {
                         _sdType = "srt";
                     }
@@ -265,19 +356,85 @@ export default function (transportOptions) {
                 }
                 _sdData = chunkString;
             }
-            var predictedSegments = Array.isArray(nextSegments) &&
-                nextSegments.length > 0 ? nextSegments :
-                undefined;
+            if (chunkInfos !== null &&
+                Array.isArray(nextSegments) && nextSegments.length > 0) {
+                addNextSegments(adaptation, nextSegments, segment);
+            }
             var 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: language }, chunkSize: chunkSize, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
+        },
+    };
+    var imageTrackPipeline = {
+        loadSegment: function (wantedCdn, content, loaderOptions, cancelSignal, callbacks) {
+            return __awaiter(this, void 0, void 0, function () {
+                var segment, url, data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            segment = content.segment;
+                            url = constructSegmentUrl(wantedCdn, segment);
+                            if (segment.isInit || url === null) {
+                                // image do not need an init segment. Passthrough directly to the parser
+                                return [2 /*return*/, { resultType: "segment-created",
+                                        resultData: null }];
+                            }
+                            return [4 /*yield*/, request({ url: url, responseType: "arraybuffer",
+                                    timeout: loaderOptions.timeout,
+                                    onProgress: callbacks.onProgress, cancelSignal: cancelSignal })];
+                        case 1:
+                            data = _a.sent();
+                            return [2 /*return*/, { resultType: "segment-loaded",
+                                    resultData: data }];
+                    }
+                });
+            });
+        },
+        parseSegment: function (loadedSegment, content, _initTimescale) {
+            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
+            if (content.segment.isInit) { // image init segment has no use
+                return { segmentType: "init",
+                    initializationData: null,
+                    initializationDataSize: 0,
+                    protectionDataUpdate: false,
+                    initTimescale: undefined };
+            }
+            if (isChunked) {
+                throw new Error("Image data should not be downloaded in chunks");
+            }
+            // TODO image Parsing should be more on the buffer side, no?
+            if (data === null || features.imageParser === null) {
+                return { segmentType: "media",
+                    chunkData: null,
+                    chunkInfos: null,
+                    chunkOffset: 0,
+                    chunkSize: 0,
+                    protectionDataUpdate: false,
+                    appendWindow: [undefined, undefined] };
+            }
+            var bifObject = features.imageParser(new Uint8Array(data));
+            var thumbsData = bifObject.thumbs;
+            return { segmentType: "media",
+                chunkData: { data: thumbsData,
+                    start: 0,
+                    end: Number.MAX_VALUE,
+                    timescale: 1,
+                    type: "bif" },
+                chunkInfos: { time: 0,
+                    duration: Number.MAX_VALUE },
+                chunkSize: undefined,
+                chunkOffset: 0,
+                protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
         },
     };
     return { manifest: manifestPipeline,
         audio: audioVideoPipeline,
         video: audioVideoPipeline,
-        text: textTrackPipeline };
+        text: textTrackPipeline,
+        image: imageTrackPipeline };
 }

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

@@ -23,5 +23,5 @@ import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegme
 declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, customSegmentLoader, }: {
     checkMediaSegmentIntegrity?: boolean | undefined;
     customSegmentLoader?: 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>>;
+}) => (url: string | null, content: ISegmentContext, loaderOptions: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array | ArrayBuffer | null>>;
 export default generateSegmentLoader;

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

@@ -29,33 +29,33 @@ import assert from "../../utils/assert";
 import request from "../../utils/request";
 import byteRange from "../utils/byte_range";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
-import isMP4EmbeddedTrack from "./is_mp4_embedded_track";
 import { createAudioInitSegment, createVideoInitSegment, } from "./isobmff";
+import { isMP4EmbeddedTrack } from "./utils";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
- * @param {Object} context
+ * @param {Object} content
  * @param {Object} loaderOptions
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @param {boolean} checkMediaSegmentIntegrity
  * @returns {Promise}
  */
-function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
+function regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
     var headers;
-    var range = context.segment.range;
+    var range = content.segment.range;
     if (Array.isArray(range)) {
         headers = { Range: byteRange(range) };
     }
     return request({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
         .then(function (data) {
-        var isMP4 = isMP4EmbeddedTrack(context.mimeType);
+        var isMP4 = isMP4EmbeddedTrack(content.representation);
         if (!isMP4 || checkMediaSegmentIntegrity !== true) {
             return { resultType: "segment-loaded",
                 resultData: data };
         }
         var dataU8 = new Uint8Array(data.responseData);
-        checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+        checkISOBMFFIntegrity(dataU8, content.segment.isInit);
         return { resultType: "segment-loaded",
             resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
     });
@@ -66,8 +66,8 @@ function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSign
  */
 var generateSegmentLoader = function (_a) {
     var checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity, customSegmentLoader = _a.customSegmentLoader;
-    return function (url, context, loaderOptions, cancelSignal, callbacks) {
-        var segment = context.segment;
+    return function (url, content, loaderOptions, cancelSignal, callbacks) {
+        var segment = content.segment, manifest = content.manifest, period = content.period, adaptation = content.adaptation, representation = content.representation;
         if (segment.isInit) {
             if (segment.privateInfos === undefined ||
                 segment.privateInfos.smoothInitSegment === undefined) {
@@ -75,19 +75,20 @@ var generateSegmentLoader = function (_a) {
             }
             var smoothInitPrivateInfos = segment.privateInfos.smoothInitSegment;
             var responseData = void 0;
-            var codecPrivateData = smoothInitPrivateInfos.codecPrivateData, timescale = smoothInitPrivateInfos.timescale, height = smoothInitPrivateInfos.height, width = smoothInitPrivateInfos.width, _a = smoothInitPrivateInfos.protection, protection = _a === void 0 ? { keyId: undefined,
+            var codecPrivateData = smoothInitPrivateInfos.codecPrivateData, timescale = smoothInitPrivateInfos.timescale, _a = smoothInitPrivateInfos.protection, protection = _a === void 0 ? { keyId: undefined,
                 keySystems: undefined } : _a;
             if (codecPrivateData === undefined) {
                 throw new Error("Smooth: no codec private data.");
             }
-            switch (context.type) {
+            switch (adaptation.type) {
                 case "video": {
-                    responseData = createVideoInitSegment(timescale, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0, 72, 72, 4, // vRes, hRes, nal
+                    var _b = representation.width, width = _b === void 0 ? 0 : _b, _c = representation.height, height = _c === void 0 ? 0 : _c;
+                    responseData = createVideoInitSegment(timescale, width, height, 72, 72, 4, // vRes, hRes, nal
                     codecPrivateData, protection.keyId);
                     break;
                 }
                 case "audio": {
-                    var _b = smoothInitPrivateInfos.channels, channels = _b === void 0 ? 0 : _b, _c = smoothInitPrivateInfos.bitsPerSample, bitsPerSample = _c === void 0 ? 0 : _c, _d = smoothInitPrivateInfos.packetSize, packetSize = _d === void 0 ? 0 : _d, _e = smoothInitPrivateInfos.samplingRate, samplingRate = _e === void 0 ? 0 : _e;
+                    var _d = smoothInitPrivateInfos.channels, channels = _d === void 0 ? 0 : _d, _e = smoothInitPrivateInfos.bitsPerSample, bitsPerSample = _e === void 0 ? 0 : _e, _f = smoothInitPrivateInfos.packetSize, packetSize = _f === void 0 ? 0 : _f, _g = smoothInitPrivateInfos.samplingRate, samplingRate = _g === void 0 ? 0 : _g;
                     responseData = createAudioInitSegment(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
                     break;
                 }
@@ -105,8 +106,10 @@ var generateSegmentLoader = function (_a) {
                 resultData: null });
         }
         else {
+            var args_1 = { adaptation: adaptation, manifest: manifest, period: period, representation: representation, segment: segment, transport: "smooth",
+                timeout: loaderOptions.timeout, url: url };
             if (typeof customSegmentLoader !== "function") {
-                return regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
+                return regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
             }
             return new Promise(function (res, rej) {
                 /** `true` when the custom segmentLoader should not be active anymore. */
@@ -121,7 +124,7 @@ var generateSegmentLoader = function (_a) {
                     }
                     hasFinished = true;
                     cancelSignal.deregister(abortCustomLoader);
-                    var isMP4 = isMP4EmbeddedTrack(context.mimeType);
+                    var isMP4 = isMP4EmbeddedTrack(content.representation);
                     if (!isMP4 || checkMediaSegmentIntegrity !== true) {
                         res({ resultType: "segment-loaded",
                             resultData: { responseData: _args.data,
@@ -130,7 +133,7 @@ var generateSegmentLoader = function (_a) {
                     }
                     var dataU8 = _args.data instanceof Uint8Array ? _args.data :
                         new Uint8Array(_args.data);
-                    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+                    checkISOBMFFIntegrity(dataU8, content.segment.isInit);
                     res({ resultType: "segment-loaded",
                         resultData: { responseData: dataU8,
                             size: _args.size,
@@ -141,7 +144,7 @@ var generateSegmentLoader = function (_a) {
                  * @param {*} err - The corresponding error encountered
                  */
                 var reject = function (err) {
-                    var _a, _b;
+                    var _a, _b, _c;
                     if (hasFinished || cancelSignal.isCancelled()) {
                         return;
                     }
@@ -151,7 +154,7 @@ var generateSegmentLoader = function (_a) {
                     var castedErr = err;
                     var message = (_a = castedErr === null || castedErr === void 0 ? void 0 : castedErr.message) !== null && _a !== void 0 ? _a : "Unknown error when fetching a Smooth segment through a " +
                         "custom segmentLoader.";
-                    var emittedErr = new CustomLoaderError(message, (_b = castedErr === null || castedErr === void 0 ? void 0 : castedErr.canRetry) !== null && _b !== void 0 ? _b : false, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
+                    var emittedErr = new CustomLoaderError(message, (_b = castedErr === null || castedErr === void 0 ? void 0 : castedErr.canRetry) !== null && _b !== void 0 ? _b : false, (_c = castedErr === null || castedErr === void 0 ? void 0 : castedErr.isOfflineError) !== null && _c !== void 0 ? _c : false, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
                     rej(emittedErr);
                 };
                 var progress = function (_args) {
@@ -168,20 +171,11 @@ var generateSegmentLoader = function (_a) {
                     }
                     hasFinished = true;
                     cancelSignal.deregister(abortCustomLoader);
-                    regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
+                    regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
                         .then(res, rej);
                 };
                 var customCallbacks = { reject: reject, resolve: resolve, fallback: fallback, progress: progress };
-                var byteRanges;
-                if (context.segment.range !== undefined) {
-                    byteRanges = [context.segment.range];
-                    if (context.segment.indexRange !== undefined) {
-                        byteRanges.push(context.segment.indexRange);
-                    }
-                }
-                var args = { isInit: context.segment.isInit,
-                    timeout: loaderOptions.timeout, byteRanges: byteRanges, type: context.type, url: url };
-                var abort = customSegmentLoader(args, customCallbacks);
+                var abort = customSegmentLoader(args_1, customCallbacks);
                 cancelSignal.register(abortCustomLoader);
                 /**
                  * The logic to run when the custom loader is cancelled while pending.

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

@@ -15,6 +15,31 @@
  */
 import { ISegment, Representation } from "../../manifest";
 import { ICdnMetadata } from "../../parsers/manifest";
+/**
+ * TODO Remove this logic completely from the player
+ * @param {Document} doc
+ * @returns {string|null}
+ */
+declare function extractISML(doc: Document): string | null;
+/**
+ * Returns string corresponding to the token contained in the url's querystring.
+ * Empty string if no token is found.
+ * @param {string} url
+ * @returns {string}
+ */
+declare function extractToken(url: string): string;
+/**
+ * Replace/Remove token from the url's querystring
+ * @param {string} url
+ * @param {string} [token]
+ * @returns {string}
+ */
+declare function replaceToken(url: string, token?: string): string;
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+declare function resolveManifest(url: string): string;
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
@@ -23,4 +48,4 @@ import { ICdnMetadata } from "../../parsers/manifest";
  */
 declare function isMP4EmbeddedTrack(representation: Representation): boolean;
 declare function constructSegmentUrl(wantedCdn: ICdnMetadata | null, segment: ISegment): string | null;
-export { constructSegmentUrl, isMP4EmbeddedTrack, };
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };

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

@@ -13,7 +13,61 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import isNonEmptyString from "../../utils/is_non_empty_string";
 import resolveURL from "../../utils/resolve_url";
+import warnOnce from "../../utils/warn_once";
+var ISM_REG = /(\.isml?)(\?token=\S+)?$/;
+var TOKEN_REG = /\?token=(\S+)/;
+/**
+ * TODO Remove this logic completely from the player
+ * @param {Document} doc
+ * @returns {string|null}
+ */
+function extractISML(doc) {
+    return doc.getElementsByTagName("media")[0].getAttribute("src");
+}
+/**
+ * Returns string corresponding to the token contained in the url's querystring.
+ * Empty string if no token is found.
+ * @param {string} url
+ * @returns {string}
+ */
+function extractToken(url) {
+    var tokenMatch = TOKEN_REG.exec(url);
+    if (tokenMatch !== null) {
+        var match = tokenMatch[1];
+        if (match !== undefined) {
+            return match;
+        }
+    }
+    return "";
+}
+/**
+ * Replace/Remove token from the url's querystring
+ * @param {string} url
+ * @param {string} [token]
+ * @returns {string}
+ */
+function replaceToken(url, token) {
+    if (isNonEmptyString(token)) {
+        return url.replace(TOKEN_REG, "?token=" + token);
+    }
+    else {
+        return url.replace(TOKEN_REG, "");
+    }
+}
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+function resolveManifest(url) {
+    if (ISM_REG.test(url)) {
+        warnOnce("Giving a isml URL to loadVideo is deprecated." +
+            " Please give the Manifest URL directly");
+        return url.replace(ISM_REG, "$1/manifest$2");
+    }
+    return url;
+}
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
@@ -29,4 +83,4 @@ function constructSegmentUrl(wantedCdn, segment) {
         segment.url === null ? wantedCdn.baseUrl :
             resolveURL(wantedCdn.baseUrl, segment.url);
 }
-export { constructSegmentUrl, isMP4EmbeddedTrack, };
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };