rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,53 +13,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
-import { mergeMap, scan, } from "rxjs/operators";
-import log from "../../log";
 import { concat } from "../../utils/byte_parsing";
 import fetchRequest from "../../utils/request/fetch";
 import byteRange from "../utils/byte_range";
 import extractCompleteChunks from "./extract_complete_chunks";
-export default function lowLatencySegmentLoader(url, args) {
-    var segment = args.segment;
+/**
+ * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
+ *
+ * This method is particularly adapted to low-latency streams.
+ *
+ * @param {string} url - URL of the segment to download.
+ * @param {Object} content - Context of the segment needed.
+ * @param {Object} callbacks
+ * @param {CancellationSignal} cancelSignal
+ * @returns {Promise}
+ */
+export default function lowLatencySegmentLoader(url, content, callbacks, cancelSignal) {
+    var segment = content.segment;
     var headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
         undefined;
-    return fetchRequest({ url: url, headers: headers })
-        .pipe(scan(function (acc, evt) {
-        if (evt.type === "data-complete") {
-            if (acc.partialChunk !== null) {
-                log.warn("DASH Pipelines: remaining chunk does not belong to any segment");
+    var partialChunk = null;
+    /**
+     * Called each time `fetch` has new data available.
+     * @param {Object} info
+     */
+    function onData(info) {
+        var chunk = new Uint8Array(info.chunk);
+        var concatenated = partialChunk !== null ? concat(partialChunk, chunk) :
+            chunk;
+        var res = extractCompleteChunks(concatenated);
+        var completeChunks = res[0];
+        partialChunk = res[1];
+        for (var i = 0; i < completeChunks.length; i++) {
+            callbacks.onNewChunk(completeChunks[i]);
+            if (cancelSignal.isCancelled) {
+                return;
             }
-            return { event: evt, completeChunks: [], partialChunk: null };
-        }
-        var data = new Uint8Array(evt.value.chunk);
-        var concatenated = acc.partialChunk !== null ? concat(acc.partialChunk, data) :
-            data;
-        var _a = extractCompleteChunks(concatenated), completeChunks = _a[0], partialChunk = _a[1];
-        return { event: evt, completeChunks: completeChunks, partialChunk: partialChunk };
-    }, { event: null, completeChunks: [], partialChunk: null }), mergeMap(function (evt) {
-        var emitted = [];
-        for (var i = 0; i < evt.completeChunks.length; i++) {
-            emitted.push({ type: "data-chunk",
-                value: { responseData: evt.completeChunks[i] } });
-        }
-        var event = evt.event;
-        if (event !== null && event.type === "data-chunk") {
-            var value = event.value;
-            emitted.push({ type: "progress",
-                value: { duration: value.duration,
-                    size: value.size,
-                    totalSize: value.totalSize } });
         }
-        else if (event !== null && event.type === "data-complete") {
-            var value = event.value;
-            emitted.push({ type: "data-chunk-complete",
-                value: { duration: value.duration,
-                    receivedTime: value.receivedTime,
-                    sendingTime: value.sendingTime,
-                    size: value.size,
-                    url: value.url } });
+        callbacks.onProgress({ duration: info.duration,
+            size: info.size,
+            totalSize: info.totalSize });
+        if (cancelSignal.isCancelled) {
+            return;
         }
-        return observableOf.apply(void 0, emitted);
-    }));
+    }
+    return fetchRequest({ url: url, headers: headers, onData: onData, cancelSignal: cancelSignal })
+        .then(function (res) { return ({ resultType: "chunk-complete",
+        resultData: res }); });
 }

package/dist/_esm5.processed/transports/dash/manifest_parser.d.ts

@@ -13,10 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { IManifestParserArguments, IManifestParserResponseEvent, IManifestParserWarningEvent, ITransportOptions } from "../types";
-/**
- * @param {Object} options
- * @returns {Function}
- */
-export default function generateManifestParser(options: ITransportOptions): (x: IManifestParserArguments) => Observable<IManifestParserWarningEvent | IManifestParserResponseEvent>;
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IManifestParserOptions, IManifestParserRequestScheduler, IManifestParserResult, IRequestedData, ITransportOptions } from "../types";
+export default function generateManifestParser(options: ITransportOptions): (manifestData: IRequestedData<unknown>, parserOptions: IManifestParserOptions, onWarnings: (warnings: Error[]) => void, cancelSignal: CancellationSignal, scheduleRequest: IManifestParserRequestScheduler) => IManifestParserResult | Promise<IManifestParserResult>;

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

@@ -13,38 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concat as observableConcat, from as observableFrom, of as observableOf, } from "rxjs";
-import { filter, map, mergeMap, } from "rxjs/operators";
+import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
 import objectAssign from "../../utils/object_assign";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
-import returnParsedManifest from "../utils/return_parsed_manifest";
-/**
- * @param {Object} options
- * @returns {Function}
- */
 export default function generateManifestParser(options) {
     var aggressiveMode = options.aggressiveMode, referenceDateTime = options.referenceDateTime;
     var serverTimeOffset = options.serverSyncInfos !== undefined ?
         options.serverSyncInfos.serverTimestamp - options.serverSyncInfos.clientTime :
         undefined;
-    return function manifestParser(args) {
+    return function manifestParser(manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
         var _a;
-        var response = args.response, scheduleRequest = args.scheduleRequest, loaderURL = args.url, argClockOffset = args.externalClockOffset;
-        var url = (_a = response.url) !== null && _a !== void 0 ? _a : loaderURL;
-        var responseData = response.responseData;
+        var responseData = manifestData.responseData;
+        var argClockOffset = parserOptions.externalClockOffset;
+        var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
         var optAggressiveMode = aggressiveMode === true;
         var externalClockOffset = serverTimeOffset !== null && serverTimeOffset !== void 0 ? serverTimeOffset : argClockOffset;
-        var unsafelyBaseOnPreviousManifest = args.unsafeMode ? args.previousManifest :
+        var unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
+            parserOptions.previousManifest :
             null;
-        var parserOpts = { aggressiveMode: optAggressiveMode,
-            unsafelyBaseOnPreviousManifest: unsafelyBaseOnPreviousManifest,
-            url: url,
-            referenceDateTime: referenceDateTime,
-            externalClockOffset: externalClockOffset };
+        var dashParserOpts = { aggressiveMode: optAggressiveMode, unsafelyBaseOnPreviousManifest: unsafelyBaseOnPreviousManifest, url: url, referenceDateTime: referenceDateTime, externalClockOffset: externalClockOffset };
         var parsers = features.dashParsers;
         if (parsers.wasm === null ||
             parsers.wasm.status === "uninitialized" ||
@@ -61,23 +53,23 @@ export default function generateManifestParser(options) {
             }
             if (parsers.wasm.status === "initialized") {
                 log.debug("DASH: Running WASM MPD Parser.");
-                var parsed = parsers.wasm.runWasmParser(manifestAB_1, parserOpts);
+                var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
                 return processMpdParserResponse(parsed);
             }
             else {
                 log.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
                 var initProm = parsers.wasm.waitForInitialization()
                     .catch(function () { });
-                return observableFrom(initProm).pipe(mergeMap(function () {
+                return initProm.then(function () {
                     if (parsers.wasm === null || parsers.wasm.status !== "initialized") {
                         log.warn("DASH: WASM MPD parser initialization failed. " +
                             "Running JS parser instead");
                         return runDefaultJsParser();
                     }
                     log.debug("DASH: Running WASM MPD Parser.");
-                    var parsed = parsers.wasm.runWasmParser(manifestAB_1, parserOpts);
+                    var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
                     return processMpdParserResponse(parsed);
-                }));
+                });
             }
         }
         /**
@@ -91,7 +83,7 @@ export default function generateManifestParser(options) {
                 throw new Error("No MPD parser is imported");
             }
             var manifestDoc = getManifestAsDocument(responseData);
-            var parsedManifest = parsers.js(manifestDoc, parserOpts);
+            var parsedManifest = parsers.js(manifestDoc, dashParserOpts);
             return processMpdParserResponse(parsedManifest);
         }
         /**
@@ -102,48 +94,119 @@ export default function generateManifestParser(options) {
          */
         function processMpdParserResponse(parserResponse) {
             if (parserResponse.type === "done") {
-                var _a = parserResponse.value, warnings = _a.warnings, parsed = _a.parsed;
-                var warningEvents = warnings.map(function (warning) { return ({ type: "warning",
-                    value: warning }); });
-                var manifest = new Manifest(parsed, options);
-                return observableConcat(observableOf.apply(void 0, warningEvents), returnParsedManifest(manifest, url));
+                if (parserResponse.value.warnings.length > 0) {
+                    onWarnings(parserResponse.value.warnings);
+                }
+                if (cancelSignal.isCancelled) {
+                    return PPromise.reject(cancelSignal.cancellationError);
+                }
+                var manifest = new Manifest(parserResponse.value.parsed, options);
+                return { manifest: manifest, url: url };
             }
             var value = parserResponse.value;
-            var externalResources$ = value.urls.map(function (resourceUrl) {
+            var externalResources = value.urls.map(function (resourceUrl) {
                 return scheduleRequest(function () {
-                    return request({
-                        url: resourceUrl,
-                        responseType: value.format === "string" ? "text" :
-                            "arraybuffer",
-                    }).pipe(filter(function (e) { return e.type === "data-loaded"; }), map(function (e) { return e.value; }));
-                });
-            });
-            return observableCombineLatest(externalResources$)
-                .pipe(mergeMap(function (loadedResources) {
-                if (value.format === "string") {
-                    var resources = loadedResources.map(function (resource) {
-                        if (typeof resource.responseData !== "string") {
+                    return value.format === "string" ? request({ url: resourceUrl,
+                        responseType: "text", cancelSignal: cancelSignal }) :
+                        request({ url: resourceUrl,
+                            responseType: "arraybuffer", cancelSignal: cancelSignal });
+                }).then(function (res) {
+                    if (value.format === "string") {
+                        if (typeof res.responseData !== "string") {
                             throw new Error("External DASH resources should have been a string");
                         }
-                        // Normally not needed but TypeScript is just dumb here
-                        return objectAssign(resource, { responseData: resource.responseData });
-                    });
-                    return processMpdParserResponse(value.continue(resources));
-                }
-                else {
-                    var resources = loadedResources.map(function (resource) {
-                        if (!(resource.responseData instanceof ArrayBuffer)) {
+                        return objectAssign(res, {
+                            responseData: {
+                                success: true,
+                                data: res.responseData
+                            },
+                        });
+                    }
+                    else {
+                        if (!(res.responseData instanceof ArrayBuffer)) {
                             throw new Error("External DASH resources should have been ArrayBuffers");
                         }
-                        // Normally not needed but TypeScript is just dumb here
-                        return objectAssign(resource, { responseData: resource.responseData });
+                        return objectAssign(res, {
+                            responseData: {
+                                success: true,
+                                data: res.responseData
+                            },
+                        });
+                    }
+                }, function (err) {
+                    var error = formatError(err, {
+                        defaultCode: "PIPELINE_PARSE_ERROR",
+                        defaultReason: "An unknown error occured when parsing ressources.",
                     });
-                    return processMpdParserResponse(value.continue(resources));
+                    return objectAssign({}, {
+                        size: undefined,
+                        requestDuration: undefined,
+                        responseData: {
+                            success: false,
+                            error: error
+                        },
+                    });
+                });
+            });
+            return PPromise.all(externalResources).then(function (loadedResources) {
+                if (value.format === "string") {
+                    assertLoadedResourcesFormatString(loadedResources);
+                    return processMpdParserResponse(value.continue(loadedResources));
                 }
-            }));
+                else {
+                    assertLoadedResourcesFormatArrayBuffer(loadedResources);
+                    return processMpdParserResponse(value.continue(loadedResources));
+                }
+            });
         }
     };
 }
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatString(loadedResources) {
+    if (0 /* CURRENT_ENV */ === 0 /* PRODUCTION */) {
+        return;
+    }
+    loadedResources.forEach(function (loadedResource) {
+        var responseData = loadedResource.responseData;
+        if (responseData.success && typeof responseData.data === "string") {
+            return;
+        }
+        else if (!responseData.success) {
+            return;
+        }
+        throw new Error("Invalid data given to the LoadedRessource");
+    });
+}
+/**
+ * Throw if the given input is not in the expected format.
+ * Allows to enforce runtime type-checking as compile-time type-checking here is
+ * difficult to enforce.
+ *
+ * @param loadedResource
+ * @returns
+ */
+function assertLoadedResourcesFormatArrayBuffer(loadedResources) {
+    if (0 /* CURRENT_ENV */ === 0 /* PRODUCTION */) {
+        return;
+    }
+    loadedResources.forEach(function (loadedResource) {
+        var responseData = loadedResource.responseData;
+        if (responseData.success && responseData.data instanceof ArrayBuffer) {
+            return;
+        }
+        else if (!responseData.success) {
+            return;
+        }
+        throw new Error("Invalid data given to the LoadedRessource");
+    });
+}
 /**
  * Try to convert a Manifest from an unknown format to a `Document` format.
  * Useful to exploit DOM-parsing APIs to quickly parse an XML Manifest.

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

@@ -35,16 +35,16 @@ export default function (options) {
     var audioVideoSegmentParser = generateAudioVideoSegmentParser(options);
     var textTrackLoader = generateTextTrackLoader(options);
     var textTrackParser = generateTextTrackParser(options);
-    return { manifest: { loader: manifestLoader,
-            parser: manifestParser },
-        audio: { loader: segmentLoader,
-            parser: audioVideoSegmentParser },
-        video: { loader: segmentLoader,
-            parser: audioVideoSegmentParser },
-        text: { loader: textTrackLoader,
-            parser: textTrackParser },
-        image: { loader: imageLoader,
-            parser: imageParser } };
+    return { manifest: { loadManifest: manifestLoader,
+            parseManifest: manifestParser },
+        audio: { loadSegment: segmentLoader,
+            parseSegment: audioVideoSegmentParser },
+        video: { loadSegment: segmentLoader,
+            parseSegment: audioVideoSegmentParser },
+        text: { loadSegment: textTrackLoader,
+            parseSegment: textTrackParser },
+        image: { loadSegment: imageLoader,
+            parseSegment: imageParser } };
 }
 /**
  * Returns true if the DASH-WASM parser is either initialized or being

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

@@ -13,13 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CustomSegmentLoader, ISegmentLoader } from "../types";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ICustomSegmentLoader, ILoadedAudioVideoSegmentFormat, ISegmentContext, ISegmentLoader, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
+/**
+ * Segment loader triggered if there was no custom-defined one in the API.
+ * @param {string} uri
+ * @param {Object} content
+ * @param {boolean} lowLatencyMode
+ * @param {Object} callbacks
+ * @param {Object} cancelSignal
+ * @returns {Promise}
+ */
+export declare function regularSegmentLoader(url: string, content: ISegmentContext, lowLatencyMode: boolean, callbacks: ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
  * @param {Object} config
  * @returns {Function}
  */
 export default function generateSegmentLoader({ lowLatencyMode, segmentLoader: customSegmentLoader, checkMediaSegmentIntegrity }: {
     lowLatencyMode: boolean;
-    segmentLoader?: CustomSegmentLoader;
-    checkMediaSegmentIntegrity?: boolean;
+    segmentLoader?: ICustomSegmentLoader | undefined;
+    checkMediaSegmentIntegrity?: boolean | undefined;
 }): ISegmentLoader<Uint8Array | ArrayBuffer | null>;

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

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, of as observableOf, } from "rxjs";
 import { CustomLoaderError } from "../../errors";
-import xhr, { fetchIsSupported, } from "../../utils/request";
+import PPromise from "../../utils/promise";
+import request, { fetchIsSupported, } from "../../utils/request";
 import warnOnce from "../../utils/warn_once";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -24,30 +24,34 @@ import initSegmentLoader from "./init_segment_loader";
 import lowLatencySegmentLoader from "./low_latency_segment_loader";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {Object} opt
- * @returns {Observable}
+ * @param {string} uri
+ * @param {Object} content
+ * @param {boolean} lowLatencyMode
+ * @param {Object} callbacks
+ * @param {Object} cancelSignal
+ * @returns {Promise}
  */
-function regularSegmentLoader(url, args, lowLatencyMode) {
-    if (args.segment.isInit) {
-        return initSegmentLoader(url, args);
+export function regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal) {
+    if (content.segment.isInit) {
+        return initSegmentLoader(url, content.segment, cancelSignal, callbacks);
     }
-    var containerType = inferSegmentContainer(args.adaptation.type, args.representation);
+    var containerType = inferSegmentContainer(content.adaptation.type, content.representation);
     if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
         if (fetchIsSupported()) {
-            return lowLatencySegmentLoader(url, args);
+            return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
         }
         else {
             warnOnce("DASH: Your browser does not have the fetch API. You will have " +
                 "a higher chance of rebuffering when playing close to the live edge");
         }
     }
-    var segment = args.segment;
-    return xhr({ url: url,
-        responseType: "arraybuffer",
-        sendProgressEvents: true,
+    var segment = content.segment;
+    return request({ url: url, responseType: "arraybuffer",
         headers: segment.range !== undefined ?
             { Range: byteRange(segment.range) } :
-            undefined });
+            undefined, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+        .then(function (data) { return ({ resultType: "segment-loaded",
+        resultData: data }); });
 }
 /**
  * @param {Object} config
@@ -61,38 +65,37 @@ export default function generateSegmentLoader(_a) {
      * @param {Object} content
      * @returns {Observable}
      */
-    function segmentLoader(content) {
-        var url = content.url;
+    function segmentLoader(url, content, cancelSignal, callbacks) {
         if (url == null) {
-            return observableOf({ type: "data-created",
-                value: { responseData: null } });
+            return PPromise.resolve({ resultType: "segment-created",
+                resultData: null });
         }
         if (lowLatencyMode || customSegmentLoader === undefined) {
-            return regularSegmentLoader(url, content, lowLatencyMode);
+            return regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal);
         }
         var args = { adaptation: content.adaptation,
             manifest: content.manifest,
             period: content.period,
             representation: content.representation,
             segment: content.segment,
-            transport: "dash",
-            url: url };
-        return new Observable(function (obs) {
+            transport: "dash", url: url };
+        return new PPromise(function (res, rej) {
+            /** `true` when the custom segmentLoader should not be active anymore. */
             var hasFinished = false;
-            var hasFallbacked = false;
             /**
              * Callback triggered when the custom segment loader has a response.
              * @param {Object} args
              */
             var resolve = function (_args) {
-                if (!hasFallbacked) {
-                    hasFinished = true;
-                    obs.next({ type: "data-loaded",
-                        value: { responseData: _args.data,
-                            size: _args.size,
-                            duration: _args.duration } });
-                    obs.complete();
+                if (hasFinished || cancelSignal.isCancelled) {
+                    return;
                 }
+                hasFinished = true;
+                cancelSignal.deregister(abortCustomLoader);
+                res({ resultType: "segment-loaded",
+                    resultData: { responseData: _args.data,
+                        size: _args.size,
+                        requestDuration: _args.duration } });
             };
             /**
              * Callback triggered when the custom segment loader fails
@@ -100,46 +103,56 @@ export default function generateSegmentLoader(_a) {
              */
             var reject = function (err) {
                 var _a, _b, _c;
-                if (err === void 0) { err = {}; }
-                if (!hasFallbacked) {
-                    hasFinished = true;
-                    // Format error and send it
-                    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 DASH 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, (_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);
-                    obs.error(emittedErr);
+                if (hasFinished || cancelSignal.isCancelled) {
+                    return;
                 }
+                hasFinished = true;
+                cancelSignal.deregister(abortCustomLoader);
+                // Format error and send it
+                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 DASH 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, (_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) {
-                if (!hasFallbacked) {
-                    obs.next({ type: "progress", value: { duration: _args.duration,
-                            size: _args.size,
-                            totalSize: _args.totalSize } });
+                if (hasFinished || cancelSignal.isCancelled) {
+                    return;
                 }
+                callbacks.onProgress({ duration: _args.duration,
+                    size: _args.size,
+                    totalSize: _args.totalSize });
             };
             /**
              * Callback triggered when the custom segment loader wants to fallback to
              * the "regular" implementation
              */
             var fallback = function () {
-                hasFallbacked = true;
-                var regular$ = regularSegmentLoader(url, content, lowLatencyMode);
-                // HACK What is TypeScript/RxJS doing here??????
-                /* eslint-disable import/no-deprecated */
-                /* eslint-disable @typescript-eslint/ban-ts-comment */
-                // @ts-ignore
-                regular$.subscribe(obs);
-                /* eslint-enable import/no-deprecated */
-                /* eslint-enable @typescript-eslint/ban-ts-comment */
+                if (hasFinished || cancelSignal.isCancelled) {
+                    return;
+                }
+                hasFinished = true;
+                cancelSignal.deregister(abortCustomLoader);
+                regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal)
+                    .then(res, rej);
             };
-            var callbacks = { reject: reject, resolve: resolve, progress: progress, fallback: fallback };
-            var abort = customSegmentLoader(args, callbacks);
-            return function () {
-                if (!hasFinished && !hasFallbacked && typeof abort === "function") {
+            var customCallbacks = { reject: reject, resolve: resolve, progress: progress, fallback: fallback };
+            var abort = customSegmentLoader(args, customCallbacks);
+            cancelSignal.register(abortCustomLoader);
+            /**
+             * The logic to run when the custom loader is cancelled while pending.
+             * @param {Error} err
+             */
+            function abortCustomLoader(err) {
+                if (hasFinished) {
+                    return;
+                }
+                hasFinished = true;
+                if (typeof abort === "function") {
                     abort();
                 }
-            };
+                rej(err);
+            }
         });
     }
 }

package/dist/_esm5.processed/transports/dash/segment_parser.d.ts

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { ISegmentParserArguments, ISegmentParserInitSegment, ISegmentParserSegment } from "../types";
+import { ISegmentParser } from "../types";
 /**
  * @param {Object} config
  * @returns {Function}
  */
 export default function generateAudioVideoSegmentParser({ __priv_patchLastSegmentInSidx }: {
-    __priv_patchLastSegmentInSidx?: boolean;
-}): ({ content, response, initTimescale }: ISegmentParserArguments<Uint8Array | ArrayBuffer | null>) => Observable<ISegmentParserInitSegment<Uint8Array | ArrayBuffer | null> | ISegmentParserSegment<Uint8Array | ArrayBuffer | null>>;
+    __priv_patchLastSegmentInSidx?: boolean | undefined;
+}): ISegmentParser<ArrayBuffer | Uint8Array | null, ArrayBuffer | Uint8Array | null>;