rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/transports/local/segment_parser.js

@@ -13,31 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
 import { getMDHDTimescale, takePSSHOut, } from "../../parsers/containers/isobmff";
 import { getTimeCodeScale } from "../../parsers/containers/matroska";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import takeFirstSet from "../../utils/take_first_set";
 import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
 import inferSegmentContainer from "../utils/infer_segment_container";
-export default function segmentParser(_a) {
-    var content = _a.content, response = _a.response, initTimescale = _a.initTimescale;
+export default function segmentParser(loadedSegment, content, initTimescale) {
     var period = content.period, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
-    var data = response.data;
+    var data = loadedSegment.data;
     var appendWindow = [period.start, period.end];
     if (data === null) {
         if (segment.isInit) {
-            return observableOf({ type: "parsed-init-segment",
-                value: { initializationData: null,
-                    protectionDataUpdate: false,
-                    initTimescale: undefined } });
+            return { segmentType: "init",
+                initializationData: null,
+                protectionDataUpdate: false,
+                initTimescale: undefined };
         }
-        return observableOf({ type: "parsed-segment",
-            value: { chunkData: null,
-                chunkInfos: null,
-                chunkOffset: 0,
-                appendWindow: appendWindow,
-                protectionDataUpdate: false } });
+        return { segmentType: "media",
+            chunkData: null,
+            chunkInfos: null,
+            chunkOffset: 0,
+            protectionDataUpdate: false, appendWindow: appendWindow };
     }
     var chunkData = new Uint8Array(data);
     var containerType = inferSegmentContainer(adaptation.type, representation);
@@ -54,20 +50,12 @@ export default function segmentParser(_a) {
         var timescale = containerType === "webm" ? getTimeCodeScale(chunkData, 0) :
             // assume ISOBMFF-compliance
             getMDHDTimescale(chunkData);
-        return observableOf({ type: "parsed-init-segment",
-            value: { initializationData: chunkData,
-                initTimescale: isNullOrUndefined(timescale) ?
-                    undefined :
-                    timescale,
-                protectionDataUpdate: protectionDataUpdate } });
+        return { segmentType: "init",
+            initializationData: chunkData,
+            initTimescale: timescale !== null && timescale !== void 0 ? timescale : undefined, protectionDataUpdate: protectionDataUpdate };
     }
     var chunkInfos = seemsToBeMP4 ? getISOBMFFTimingInfos(chunkData, false, segment, initTimescale) :
         null; // TODO extract time info from webm
     var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
-    return observableOf({ type: "parsed-segment",
-        value: { chunkData: chunkData,
-            chunkInfos: chunkInfos,
-            chunkOffset: chunkOffset,
-            appendWindow: appendWindow,
-            protectionDataUpdate: false } });
+    return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false, appendWindow: appendWindow };
 }

package/dist/_esm5.processed/transports/local/text_parser.d.ts

@@ -13,11 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { ISegmentParserArguments, ISegmentParserInitSegment, ISegmentParserSegment, ITextTrackSegmentData } from "../types";
+import { ILoadedTextSegmentFormat, ISegmentContext, ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ITextTrackSegmentData } from "../types";
 /**
  * Parse TextTrack data.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * @param {Object} loadedSegment
+ * @param {Object} content
+ * @param {number | undefined} initTimescale
+ * @returns {Object}
  */
-export default function textTrackParser({ response, content, initTimescale }: ISegmentParserArguments<Uint8Array | ArrayBuffer | string | null>): Observable<ISegmentParserInitSegment<null> | ISegmentParserSegment<ITextTrackSegmentData>>;
+export default function textTrackParser(loadedSegment: {
+    data: ILoadedTextSegmentFormat;
+    isChunked: boolean;
+}, content: ISegmentContext, initTimescale: number | undefined): ISegmentParserParsedInitChunk<null> | ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>;

package/dist/_esm5.processed/transports/local/text_parser.js

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
 import { getMDHDTimescale } from "../../parsers/containers/isobmff";
 import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
 import takeFirstSet from "../../utils/take_first_set";
@@ -22,48 +21,55 @@ import inferSegmentContainer from "../utils/infer_segment_container";
 import { getISOBMFFEmbeddedTextTrackData, getPlainTextTrackData, } from "../utils/parse_text_track";
 /**
  * Parse TextTrack data when it is embedded in an ISOBMFF file.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} content - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @param {number|undefined} initTimescale - `timescale` value - encountered
+ * in this linked initialization segment (if it exists) - that may also apply
+ * to that segment if no new timescale is defined in it.
+ * Can be `undefined` if no timescale was defined, if it is not known, or if
+ * no linked initialization segment was yet parsed.
+ * @returns {Object}
  */
-function parseISOBMFFEmbeddedTextTrack(_a) {
-    var response = _a.response, content = _a.content, initTimescale = _a.initTimescale;
+function parseISOBMFFEmbeddedTextTrack(data, isChunked, content, initTimescale) {
     var period = content.period, segment = content.segment;
-    var data = response.data, isChunked = response.isChunked;
     var chunkBytes = typeof data === "string" ? strToUtf8(data) :
         data instanceof Uint8Array ? data :
             new Uint8Array(data);
     if (segment.isInit) {
         var mdhdTimescale = getMDHDTimescale(chunkBytes);
-        return observableOf({ type: "parsed-init-segment",
-            value: { initializationData: null,
-                initTimescale: mdhdTimescale,
-                protectionDataUpdate: false } });
+        return { segmentType: "init",
+            initializationData: null,
+            initTimescale: mdhdTimescale,
+            protectionDataUpdate: false };
     }
     var chunkInfos = getISOBMFFTimingInfos(chunkBytes, isChunked, segment, initTimescale);
     var chunkData = getISOBMFFEmbeddedTextTrackData(content, chunkBytes, chunkInfos, isChunked);
     var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
-    return observableOf({ type: "parsed-segment",
-        value: { chunkData: chunkData,
-            chunkInfos: chunkInfos,
-            chunkOffset: chunkOffset,
-            appendWindow: [period.start, period.end],
-            protectionDataUpdate: false } });
+    return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false,
+        appendWindow: [period.start, period.end] };
 }
 /**
- * Parse TextTrack data in plain text form.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * Parse TextTrack data when it is in plain text form.
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} content - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @returns {Object}
  */
-function parsePlainTextTrack(_a) {
-    var response = _a.response, content = _a.content;
+function parsePlainTextTrack(data, isChunked, content) {
     var period = content.period, segment = content.segment;
     if (segment.isInit) {
-        return observableOf({ type: "parsed-init-segment",
-            value: { initializationData: null,
-                initTimescale: undefined,
-                protectionDataUpdate: false } });
+        return { segmentType: "init",
+            initializationData: null,
+            initTimescale: undefined,
+            protectionDataUpdate: false };
     }
-    var data = response.data, isChunked = response.isChunked;
     var textTrackData;
     if (typeof data !== "string") {
         var bytesData = data instanceof Uint8Array ? data :
@@ -75,36 +81,33 @@ function parsePlainTextTrack(_a) {
     }
     var chunkData = getPlainTextTrackData(content, textTrackData, isChunked);
     var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
-    return observableOf({ type: "parsed-segment",
-        value: { chunkData: chunkData,
-            chunkInfos: null,
-            chunkOffset: chunkOffset,
-            appendWindow: [period.start, period.end],
-            protectionDataUpdate: false } });
+    return { segmentType: "media", chunkData: chunkData, chunkInfos: null, chunkOffset: chunkOffset, protectionDataUpdate: false,
+        appendWindow: [period.start, period.end] };
 }
 /**
  * Parse TextTrack data.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * @param {Object} loadedSegment
+ * @param {Object} content
+ * @param {number | undefined} initTimescale
+ * @returns {Object}
  */
-export default function textTrackParser(_a) {
-    var response = _a.response, content = _a.content, initTimescale = _a.initTimescale;
+export default function textTrackParser(loadedSegment, content, initTimescale) {
+    var _a;
     var period = content.period, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
-    var data = response.data, isChunked = response.isChunked;
-    if (data === null) { // No data, just return empty infos
+    var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
+    if (data === null) {
+        // No data, just return an empty placeholder object
         if (segment.isInit) {
-            return observableOf({ type: "parsed-init-segment",
-                value: { initializationData: null,
-                    protectionDataUpdate: false,
-                    initTimescale: undefined } });
+            return { segmentType: "init",
+                initializationData: null,
+                protectionDataUpdate: false,
+                initTimescale: undefined };
         }
-        var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
-        return observableOf({ type: "parsed-segment",
-            value: { chunkData: null,
-                chunkInfos: null,
-                chunkOffset: chunkOffset,
-                appendWindow: [period.start, period.end],
-                protectionDataUpdate: false } });
+        var chunkOffset = (_a = segment.timestampOffset) !== null && _a !== void 0 ? _a : 0;
+        return { segmentType: "media",
+            chunkData: null,
+            chunkInfos: null, chunkOffset: chunkOffset, protectionDataUpdate: false,
+            appendWindow: [period.start, period.end] };
     }
     var containerType = inferSegmentContainer(adaptation.type, representation);
     // TODO take a look to check if this is an ISOBMFF/webm when undefined?
@@ -113,11 +116,9 @@ export default function textTrackParser(_a) {
         throw new Error("Text tracks with a WEBM container are not yet handled.");
     }
     else if (containerType === "mp4") {
-        return parseISOBMFFEmbeddedTextTrack({ response: { data: data, isChunked: isChunked },
-            content: content,
-            initTimescale: initTimescale });
+        return parseISOBMFFEmbeddedTextTrack(data, isChunked, content, initTimescale);
     }
     else {
-        return parsePlainTextTrack({ response: { data: data, isChunked: isChunked }, content: content });
+        return parsePlainTextTrack(data, isChunked, content);
     }
 }

package/dist/_esm5.processed/transports/metaplaylist/manifest_loader.d.ts

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { CustomManifestLoader, IManifestLoaderArguments, IManifestLoaderEvent } from "../types";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ICustomManifestLoader, ILoadedManifestFormat, IRequestedData } from "../types";
 /**
  * Generate a manifest loader for the application
  * @param {Function} [customManifestLoader]
  * @returns {Function}
  */
-export default function generateManifestLoader(options: {
-    customManifestLoader?: CustomManifestLoader;
-}): (args: IManifestLoaderArguments) => Observable<IManifestLoaderEvent>;
+export default function generateManifestLoader({ customManifestLoader }: {
+    customManifestLoader?: ICustomManifestLoader | undefined;
+}): (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

package/dist/_esm5.processed/transports/metaplaylist/manifest_loader.js

@@ -19,22 +19,20 @@ import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
  * Manifest loader triggered if there was no custom-defined one in the API.
  * @param {string} url
  */
-function regularManifestLoader(_a) {
-    var url = _a.url;
+function regularManifestLoader(url, cancelSignal) {
     if (url === undefined) {
         throw new Error("Cannot perform HTTP(s) request. URL not known");
     }
-    return request({ url: url, responseType: "text" });
+    return request({ url: url, responseType: "text", cancelSignal: cancelSignal });
 }
 /**
  * Generate a manifest loader for the application
  * @param {Function} [customManifestLoader]
  * @returns {Function}
  */
-export default function generateManifestLoader(options) {
-    var customManifestLoader = options.customManifestLoader;
-    if (typeof customManifestLoader !== "function") {
-        return regularManifestLoader;
-    }
-    return callCustomManifestLoader(customManifestLoader, regularManifestLoader);
+export default function generateManifestLoader(_a) {
+    var customManifestLoader = _a.customManifestLoader;
+    return typeof customManifestLoader !== "function" ?
+        regularManifestLoader :
+        callCustomManifestLoader(customManifestLoader, regularManifestLoader);
 }

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

@@ -13,19 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+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 { combineLatest, merge as observableMerge, of as observableOf, } from "rxjs";
-import { filter, map, mergeMap, share, } from "rxjs/operators";
 import features from "../../features";
 import Manifest from "../../manifest";
 import parseMetaPlaylist from "../../parsers/manifest/metaplaylist";
-import deferSubscriptions from "../../utils/defer_subscriptions";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import objectAssign from "../../utils/object_assign";
+import PPromise from "../../utils/promise";
 import generateManifestLoader from "./manifest_loader";
 /**
  * Get base - real - content from an offseted metaplaylist content.
@@ -40,34 +44,7 @@ function getOriginalContent(segment) {
     }
     var _b = segment.privateInfos.metaplaylistInfos.baseContent, manifest = _b.manifest, period = _b.period, adaptation = _b.adaptation, representation = _b.representation;
     var originalSegment = segment.privateInfos.metaplaylistInfos.originalSegment;
-    return { manifest: manifest,
-        period: period,
-        adaptation: adaptation,
-        representation: representation,
-        segment: originalSegment };
-}
-/**
- * Prepare any wrapped segment loader's arguments.
- * @param {Object} segment
- * @param {number} offset
- * @returns {Object}
- */
-function getLoaderArguments(segment, url) {
-    var content = getOriginalContent(segment);
-    return objectAssign({ url: url }, content);
-}
-/**
- * Prepare any wrapped segment parser's arguments.
- * @param {Object} arguments
- * @param {Object} segment
- * @param {number} offset
- * @returns {Object}
- */
-function getParserArguments(_a, segment) {
-    var initTimescale = _a.initTimescale, response = _a.response;
-    return { initTimescale: initTimescale,
-        response: response,
-        content: getOriginalContent(segment) };
+    return { manifest: manifest, period: period, adaptation: adaptation, representation: representation, segment: originalSegment };
 }
 /**
  * @param {Object} transports
@@ -82,7 +59,7 @@ function getTransportPipelines(transports, transportName, options) {
     }
     var feature = features.transports[transportName];
     if (feature === undefined) {
-        throw new Error("MetaPlaylist: Unknown transport " + transportName + ".");
+        throw new Error("MetaPlaylist: Unknown transport ".concat(transportName, "."));
     }
     var transport = feature(options);
     transports[transportName] = transport;
@@ -110,51 +87,34 @@ export default function (options) {
         supplementaryTextTracks: [],
         supplementaryImageTracks: [] });
     var manifestPipeline = {
-        loader: manifestLoader,
-        parser: function (_a) {
-            var response = _a.response, loaderURL = _a.url, previousManifest = _a.previousManifest, scheduleRequest = _a.scheduleRequest, unsafeMode = _a.unsafeMode, externalClockOffset = _a.externalClockOffset;
-            var url = response.url === undefined ? loaderURL :
-                response.url;
-            var responseData = response.responseData;
-            var parserOptions = { url: url,
-                serverSyncInfos: options.serverSyncInfos };
-            return handleParsedResult(parseMetaPlaylist(responseData, parserOptions));
+        loadManifest: manifestLoader,
+        parseManifest: function (manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
+            var _a;
+            var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+            var responseData = manifestData.responseData;
+            var mplParserOptions = { url: url, serverSyncInfos: options.serverSyncInfos };
+            var parsed = parseMetaPlaylist(responseData, mplParserOptions);
+            return handleParsedResult(parsed);
             function handleParsedResult(parsedResult) {
                 if (parsedResult.type === "done") {
                     var manifest = new Manifest(parsedResult.value, options);
-                    return observableOf({ type: "parsed",
-                        value: { manifest: manifest } });
+                    return PPromise.resolve({ manifest: manifest });
                 }
-                var loaders$ = parsedResult.value.ressources.map(function (ressource) {
-                    var transport = getTransportPipelines(transports, ressource.transportType, otherTransportOptions);
-                    var request$ = scheduleRequest(function () {
-                        return transport.manifest.loader({ url: ressource.url }).pipe(filter(function (e) {
-                            return e.type === "data-loaded";
-                        }), map(function (e) { return e.value; }));
+                var parsedValue = parsedResult.value;
+                var loaderProms = parsedValue.ressources.map(function (resource) {
+                    var transport = getTransportPipelines(transports, resource.transportType, otherTransportOptions);
+                    return scheduleRequest(loadSubManifest)
+                        .then(function (data) {
+                        return transport.manifest.parseManifest(data, __assign(__assign({}, parserOptions), { originalUrl: resource.url }), onWarnings, cancelSignal, scheduleRequest);
                     });
-                    return request$.pipe(mergeMap(function (responseValue) {
-                        return transport.manifest.parser({ response: responseValue,
-                            url: ressource.url,
-                            scheduleRequest: scheduleRequest,
-                            previousManifest: previousManifest,
-                            unsafeMode: unsafeMode,
-                            externalClockOffset: externalClockOffset });
-                    })).pipe(deferSubscriptions(), share());
+                    function loadSubManifest() {
+                        return transport.manifest.loadManifest(resource.url, cancelSignal);
+                    }
                 });
-                var warnings$ = loaders$.map(function (loader) {
-                    return loader.pipe(filter(function (evt) {
-                        return evt.type === "warning";
-                    }));
+                return PPromise.all(loaderProms).then(function (parsedReqs) {
+                    var loadedRessources = parsedReqs.map(function (e) { return e.manifest; });
+                    return handleParsedResult(parsedResult.value.continue(loadedRessources));
                 });
-                var responses$ = loaders$.map(function (loader) {
-                    return loader.pipe(filter(function (evt) {
-                        return evt.type === "parsed";
-                    }));
-                });
-                return observableMerge.apply(void 0, __spreadArray([combineLatest(responses$).pipe(mergeMap(function (evt) {
-                        var loadedRessources = evt.map(function (e) { return e.value.manifest; });
-                        return handleParsedResult(parsedResult.value.continue(loadedRessources));
-                    }))], warnings$));
             }
         },
     };
@@ -205,99 +165,83 @@ export default function (options) {
             appendWindow: [offsetedWindowStart, offsetedWindowEnd] };
     }
     var audioPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, url = _a.url;
+        loadSegment: function (url, content, cancelToken, callbacks) {
+            var segment = content.segment;
             var audio = getTransportPipelinesFromSegment(segment).audio;
-            return audio.loader(getLoaderArguments(segment, url));
+            var ogContent = getOriginalContent(segment);
+            return audio.loadSegment(url, ogContent, cancelToken, callbacks);
         },
-        parser: function (args) {
-            var content = args.content;
+        parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
             var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
             var audio = getTransportPipelinesFromSegment(segment).audio;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return audio.parser(getParserArguments(args, segment))
-                .pipe(map(function (res) {
-                if (res.type === "parsed-init-segment") {
-                    return res;
-                }
-                var timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return objectAssign({ type: "parsed-segment",
-                    value: objectAssign({}, res.value, timeInfos) });
-            }));
+            var ogContent = getOriginalContent(segment);
+            var parsed = audio.parseSegment(loadedSegment, ogContent, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return objectAssign({}, parsed, timeInfos);
         },
     };
     var videoPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, url = _a.url;
+        loadSegment: function (url, content, cancelToken, callbacks) {
+            var segment = content.segment;
             var video = getTransportPipelinesFromSegment(segment).video;
-            return video.loader(getLoaderArguments(segment, url));
+            var ogContent = getOriginalContent(segment);
+            return video.loadSegment(url, ogContent, cancelToken, callbacks);
         },
-        parser: function (args) {
-            var content = args.content;
+        parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
             var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
             var video = getTransportPipelinesFromSegment(segment).video;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return video.parser(getParserArguments(args, segment))
-                .pipe(map(function (res) {
-                if (res.type === "parsed-init-segment") {
-                    return res;
-                }
-                var timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return objectAssign({ type: "parsed-segment",
-                    value: objectAssign({}, res.value, timeInfos) });
-            }));
+            var ogContent = getOriginalContent(segment);
+            var parsed = video.parseSegment(loadedSegment, ogContent, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return objectAssign({}, parsed, timeInfos);
         },
     };
     var textTrackPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, url = _a.url;
+        loadSegment: function (url, content, cancelToken, callbacks) {
+            var segment = content.segment;
             var text = getTransportPipelinesFromSegment(segment).text;
-            return text.loader(getLoaderArguments(segment, url));
+            var ogContent = getOriginalContent(segment);
+            return text.loadSegment(url, ogContent, cancelToken, callbacks);
         },
-        parser: function (args) {
-            var content = args.content;
+        parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
             var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
             var text = getTransportPipelinesFromSegment(segment).text;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return text.parser(getParserArguments(args, segment))
-                .pipe(map(function (res) {
-                if (res.type === "parsed-init-segment") {
-                    return res;
-                }
-                var timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return objectAssign({ type: "parsed-segment",
-                    value: objectAssign({}, res.value, timeInfos) });
-            }));
+            var ogContent = getOriginalContent(segment);
+            var parsed = text.parseSegment(loadedSegment, ogContent, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return objectAssign({}, parsed, timeInfos);
         },
     };
     var imageTrackPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, url = _a.url;
+        loadSegment: function (url, content, cancelToken, callbacks) {
+            var segment = content.segment;
             var image = getTransportPipelinesFromSegment(segment).image;
-            return image.loader(getLoaderArguments(segment, url));
+            var ogContent = getOriginalContent(segment);
+            return image.loadSegment(url, ogContent, cancelToken, callbacks);
         },
-        parser: function (args) {
-            var content = args.content;
+        parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
             var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
             var image = getTransportPipelinesFromSegment(segment).image;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return image.parser(getParserArguments(args, segment))
-                .pipe(map(function (res) {
-                if (res.type === "parsed-init-segment") {
-                    return res;
-                }
-                var timeInfos = offsetTimeInfos(contentStart, contentEnd, res.value);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return objectAssign({ type: "parsed-segment",
-                    value: objectAssign({}, res.value, timeInfos) });
-            }));
+            var ogContent = getOriginalContent(segment);
+            var parsed = image.parseSegment(loadedSegment, ogContent, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return objectAssign({}, parsed, timeInfos);
         },
     };
     return { manifest: manifestPipeline,

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

@@ -50,13 +50,10 @@ export default function extractTimingsInfos(data, isChunked, initTimescale, segm
     if (tfxdSegment !== undefined) {
         chunkInfos = { time: tfxdSegment.time / initTimescale,
             duration: tfxdSegment.duration / initTimescale };
-        return { nextSegments: nextSegments,
-            chunkInfos: chunkInfos,
-            scaledSegmentTime: tfxdSegment.time };
+        return { nextSegments: nextSegments, chunkInfos: chunkInfos, scaledSegmentTime: tfxdSegment.time };
     }
-    if (isChunked) {
-        return { nextSegments: nextSegments,
-            chunkInfos: null,
+    if (isChunked || !segment.complete) {
+        return { nextSegments: nextSegments, chunkInfos: null,
             scaledSegmentTime: undefined };
     }
     var segmentDuration = segment.duration * initTimescale;

package/dist/_esm5.processed/transports/smooth/isobmff/create_video_init_segment.d.ts

@@ -23,10 +23,7 @@
  * @param {Number} vRes
  * @param {Number} nalLength (1, 2 or 4)
  * @param {string} codecPrivateData
- * @param {Uint8Array} keyId - hex string representing the key Id,
- * 32 chars. eg. a800dbed49c12c4cb8e0b25643844b9b
- * @param {Array.<Object>} [pssList] - List of dict, example:
- * {systemId: "DEADBEEF", codecPrivateData: "DEAFBEEF}
+ * @param {Uint8Array} [keyId]
  * @returns {Uint8Array}
  */
 export default function createVideoInitSegment(timescale: number, width: number, height: number, hRes: number, vRes: number, nalLength: number, codecPrivateData: string, keyId?: Uint8Array): Uint8Array;