rx-player 4.1.0 → 4.2.0-dev.2024080600

package/dist/es2017/transports/dash/init_segment_loader.js

@@ -15,21 +15,29 @@
  */
 import { concat } from "../../utils/byte_parsing";
 import request from "../../utils/request";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 /**
  * Perform a request for an initialization segment, agnostic to the container.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} segment
  * @param {Object} options
  * @param {CancellationSignal} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export default function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
+export default function initSegmentLoader(initialUrl, segment, options, cancelSignal, callbacks) {
+    var _a, _b;
+    let url = initialUrl;
+    if (((_a = options.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query") {
+        url = addQueryString(url, options.cmcdPayload.value);
+    }
+    const cmcdHeaders = ((_b = options.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "headers" ? options.cmcdPayload.value : undefined;
     if (segment.range === undefined) {
         return request({
             url,
             responseType: "arraybuffer",
+            headers: cmcdHeaders,
             timeout: options.timeout,
             connectionTimeout: options.connectionTimeout,
             cancelSignal,
@@ -39,7 +47,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
     if (segment.indexRange === undefined) {
         return request({
             url,
-            headers: { Range: byteRange(segment.range) },
+            headers: Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(segment.range) }),
             responseType: "arraybuffer",
             timeout: options.timeout,
             connectionTimeout: options.connectionTimeout,
@@ -51,7 +59,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
     if (segment.range[1] + 1 === segment.indexRange[0]) {
         return request({
             url,
-            headers: { Range: byteRange([segment.range[0], segment.indexRange[1]]) },
+            headers: Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange([segment.range[0], segment.indexRange[1]]) }),
             responseType: "arraybuffer",
             timeout: options.timeout,
             connectionTimeout: options.connectionTimeout,
@@ -61,7 +69,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
     }
     const rangeRequest$ = request({
         url,
-        headers: { Range: byteRange(segment.range) },
+        headers: Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(segment.range) }),
         responseType: "arraybuffer",
         timeout: options.timeout,
         connectionTimeout: options.connectionTimeout,
@@ -70,7 +78,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
     });
     const indexRequest$ = request({
         url,
-        headers: { Range: byteRange(segment.indexRange) },
+        headers: Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(segment.indexRange) }),
         responseType: "arraybuffer",
         timeout: options.timeout,
         connectionTimeout: options.connectionTimeout,

package/dist/es2017/transports/dash/integrity_checks.d.ts

@@ -0,0 +1,18 @@
+import type { ISegmentLoader, ITransportManifestPipeline } from "../types";
+/**
+ * Add multiple checks on the response given by the `segmentLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} segmentLoader
+ * @returns {Function}
+ */
+export declare function addSegmentIntegrityChecks<T>(segmentLoader: ISegmentLoader<T>): ISegmentLoader<T>;
+/**
+ * Add multiple checks on the response given by the `manifestLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} manifestLoader
+ * @returns {Function}
+ */
+export declare function addManifestIntegrityChecks(manifestLoader: ITransportManifestPipeline["loadManifest"]): ITransportManifestPipeline["loadManifest"];
+//# sourceMappingURL=integrity_checks.d.ts.map

package/dist/es2017/transports/dash/integrity_checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrity_checks.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/integrity_checks.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAI3E;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,aAAa,EAAE,cAAc,CAAC,CAAC,CAAC,GAC/B,cAAc,CAAC,CAAC,CAAC,CAkEnB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,0BAA0B,CAAC,cAAc,CAAC,GACzD,0BAA0B,CAAC,cAAc,CAAC,CAsD5C"}

package/dist/es2017/transports/dash/integrity_checks.js

@@ -0,0 +1,150 @@
+import { OtherError } from "../../errors";
+import globalScope from "../../utils/global_scope";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import TaskCanceller from "../../utils/task_canceller";
+import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
+import inferSegmentContainer from "../utils/infer_segment_container";
+/**
+ * Add multiple checks on the response given by the `segmentLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} segmentLoader
+ * @returns {Function}
+ */
+export function addSegmentIntegrityChecks(segmentLoader) {
+    return (url, context, loaderOptions, initialCancelSignal, callbacks) => {
+        return new Promise((resolve, reject) => {
+            const requestCanceller = new TaskCanceller();
+            const unlinkCanceller = requestCanceller.linkToSignal(initialCancelSignal);
+            requestCanceller.signal.register(reject);
+            segmentLoader(url, context, loaderOptions, requestCanceller.signal, Object.assign(Object.assign({}, callbacks), { onNewChunk(data) {
+                    try {
+                        throwOnIntegrityError(data);
+                        callbacks.onNewChunk(data);
+                    }
+                    catch (err) {
+                        // Do not reject with a `CancellationError` after cancelling the request
+                        cleanUpCancellers();
+                        // Cancel the request
+                        requestCanceller.cancel();
+                        // Reject with thrown error
+                        reject(err);
+                    }
+                } })).then((info) => {
+                cleanUpCancellers();
+                if (requestCanceller.isUsed()) {
+                    return;
+                }
+                if (info.resultType === "segment-loaded") {
+                    try {
+                        throwOnIntegrityError(info.resultData.responseData);
+                    }
+                    catch (err) {
+                        reject(err);
+                        return;
+                    }
+                }
+                resolve(info);
+            }, (err) => {
+                cleanUpCancellers();
+                reject(err);
+            });
+            function cleanUpCancellers() {
+                requestCanceller.signal.deregister(reject);
+                unlinkCanceller();
+            }
+        });
+        /**
+         * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+         * @param {*} data
+         */
+        function throwOnIntegrityError(data) {
+            if ((!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array)) ||
+                inferSegmentContainer(context.type, context.mimeType) !== "mp4") {
+                return;
+            }
+            checkISOBMFFIntegrity(new Uint8Array(data), context.segment.isInit);
+        }
+    };
+}
+/**
+ * Add multiple checks on the response given by the `manifestLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} manifestLoader
+ * @returns {Function}
+ */
+export function addManifestIntegrityChecks(manifestLoader) {
+    return async (url, options, initialCancelSignal) => {
+        const res = await manifestLoader(url, options, initialCancelSignal);
+        throwOnIntegrityError(res.responseData);
+        return res;
+        /**
+         * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+         * @param {*} data
+         */
+        function throwOnIntegrityError(data) {
+            if (typeof data === "string") {
+                let currOffset = data.length - 1;
+                const expectedStrings = ["</", "MPD", ">"];
+                for (let i = expectedStrings.length - 1; i >= 0; i--) {
+                    const currentExpectedStr = expectedStrings[i];
+                    while (isCharXmlWhiteSpace(data[currOffset])) {
+                        currOffset--;
+                    }
+                    for (let j = currentExpectedStr.length - 1; j >= 0; j--) {
+                        if (data[currOffset] !== currentExpectedStr[j]) {
+                            throw new Error("INTEGRITY_ERROR MPD does not end with </MPD>");
+                        }
+                        else {
+                            currOffset--;
+                        }
+                    }
+                }
+            }
+            else if (data instanceof ArrayBuffer) {
+                let currOffset = data.byteLength - 1;
+                const dv = new DataView(data);
+                const expectedCharGroups = [[0x3c, 0x2f], [0x4d, 0x50, 0x44], [0x3e]];
+                for (let i = expectedCharGroups.length - 1; i >= 0; i--) {
+                    const currentExpectedCharGroup = expectedCharGroups[i];
+                    while (isUtf8XmlWhiteSpace(dv.getUint8(currOffset))) {
+                        currOffset--;
+                    }
+                    for (let j = currentExpectedCharGroup.length - 1; j >= 0; j--) {
+                        if (dv.getUint8(currOffset) !== currentExpectedCharGroup[j]) {
+                            throw new Error("INTEGRITY_ERROR MPD does not end with </MPD>");
+                        }
+                        else {
+                            currOffset--;
+                        }
+                    }
+                }
+            }
+            else if (!isNullOrUndefined(globalScope.Document) &&
+                data instanceof globalScope.Document) {
+                if (data.documentElement.nodeName !== "MPD") {
+                    throw new OtherError("INTEGRITY_ERROR", "MPD does not end with </MPD>");
+                }
+            }
+        }
+    };
+}
+/**
+ * Returns `true` if the character given can be considered as
+ * whitespace according to the XML spec.
+ * @param {string} char
+ * @returns {boolean}
+ */
+function isCharXmlWhiteSpace(char) {
+    return char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+/**
+ * Returns `true` if the character given can be considered as an ASCII
+ * whitespace according to the HTML spec.
+ * @param {string} char
+ * @returns {boolean}
+ */
+function isUtf8XmlWhiteSpace(char) {
+    return char === 0x20 || char === 0x9 || char === 0xd || char === 0xa;
+}

package/dist/es2017/transports/dash/{low_latency_segment_loader.d.ts → load_chunked_segment_data.d.ts}

@@ -14,18 +14,27 @@
  * limitations under the License.
  */
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultChunkedComplete } from "../types";
+import type { ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete } from "../types";
 /**
  * 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} options
+ * @param {Object} requestOptions
+ * @param {Object|undefined} requestOptions.headers - Headers for the
+ * low-latency request
+ * @param {number|undefined} requestOptions.timeout - Request timeout for the
+ * low-latency request.
+ * @param {number|undefined} requestOptions.connectionTimeout - HTTP connection
+ * timeout for the low-latency request.
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url: string, content: ISegmentContext, options: ISegmentLoaderOptions, callbacks: ISegmentLoaderCallbacks<Uint8Array>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultChunkedComplete>;
-//# sourceMappingURL=low_latency_segment_loader.d.ts.map
+export default function loadChunkedSegmentData(url: string, requestOptions: {
+    headers: Record<string, string> | undefined;
+    timeout: number | undefined;
+    connectionTimeout: number | undefined;
+}, callbacks: ISegmentLoaderCallbacks<Uint8Array>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultChunkedComplete>;
+//# sourceMappingURL=load_chunked_segment_data.d.ts.map

package/dist/es2017/transports/dash/load_chunked_segment_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load_chunked_segment_data.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/load_chunked_segment_data.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EACV,uBAAuB,EACvB,mCAAmC,EACpC,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAA8B,sBAAsB,CAClD,GAAG,EAAE,MAAM,EACX,cAAc,EAAE;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAC5C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC,EACD,SAAS,EAAE,uBAAuB,CAAC,UAAU,CAAC,EAC9C,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,mCAAmC,CAAC,CA2C9C"}

package/dist/es2017/transports/dash/{low_latency_segment_loader.js → load_chunked_segment_data.js}

@@ -16,22 +16,24 @@
 import { extractCompleteChunks } from "../../parsers/containers/isobmff";
 import { concat } from "../../utils/byte_parsing";
 import fetchRequest from "../../utils/request/fetch";
-import byteRange from "../utils/byte_range";
 /**
  * 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} options
+ * @param {Object} requestOptions
+ * @param {Object|undefined} requestOptions.headers - Headers for the
+ * low-latency request
+ * @param {number|undefined} requestOptions.timeout - Request timeout for the
+ * low-latency request.
+ * @param {number|undefined} requestOptions.connectionTimeout - HTTP connection
+ * timeout for the low-latency request.
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
-    const { segment } = content;
-    const headers = segment.range !== undefined ? { Range: byteRange(segment.range) } : undefined;
+export default async function loadChunkedSegmentData(url, requestOptions, callbacks, cancelSignal) {
     let partialChunk = null;
     /**
      * Called each time `fetch` has new data available.
@@ -60,15 +62,16 @@ export default function lowLatencySegmentLoader(url, content, options, callbacks
             return;
         }
     }
-    return fetchRequest({
+    const res = await fetchRequest({
         url,
-        headers,
+        headers: requestOptions.headers,
         onData,
-        timeout: options.timeout,
-        connectionTimeout: options.connectionTimeout,
+        timeout: requestOptions.timeout,
+        connectionTimeout: requestOptions.connectionTimeout,
         cancelSignal,
-    }).then((res) => ({
+    });
+    return {
         resultType: "chunk-complete",
         resultData: res,
-    }));
+    };
 }

package/dist/es2017/transports/dash/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAQvE;;;;;GAKG;AACH,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,CAwBxE"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AASvE;;;;;GAKG;AACH,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,CA0BxE"}

package/dist/es2017/transports/dash/pipelines.js

@@ -15,6 +15,7 @@
  */
 import features from "../../features";
 import generateManifestLoader from "../utils/generate_manifest_loader";
+import { addManifestIntegrityChecks } from "./integrity_checks";
 import generateManifestParser from "./manifest_parser";
 import generateSegmentLoader from "./segment_loader";
 import generateAudioVideoSegmentParser from "./segment_parser";
@@ -27,13 +28,14 @@ import generateTextTrackParser from "./text_parser";
  * @returns {Object}
  */
 export default function (options) {
-    const manifestLoader = generateManifestLoader({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" : "arraybuffer");
+    const manifestLoader = generateManifestLoader({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" : "arraybuffer", options.checkManifestIntegrity === true ? addManifestIntegrityChecks : null);
     const manifestParser = generateManifestParser(options);
     const segmentLoader = generateSegmentLoader(options);
     const audioVideoSegmentParser = generateAudioVideoSegmentParser(options);
     const textTrackLoader = generateTextTrackLoader(options);
     const textTrackParser = generateTextTrackParser(options);
     return {
+        transportName: "dash",
         manifest: { loadManifest: manifestLoader, parseManifest: manifestParser },
         audio: {
             loadSegment: segmentLoader,

package/dist/es2017/transports/dash/segment_loader.d.ts

@@ -18,7 +18,7 @@ import type { CancellationSignal } from "../../utils/task_canceller";
 import type { ILoadedAudioVideoSegmentFormat, ISegmentContext, ISegmentLoader, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} context
  * @param {boolean} lowLatencyMode
  * @param {Object} options
@@ -26,7 +26,7 @@ import type { ILoadedAudioVideoSegmentFormat, ISegmentContext, ISegmentLoader, I
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export declare function regularSegmentLoader(url: string, context: ISegmentContext, lowLatencyMode: boolean, options: ISegmentLoaderOptions, callbacks: ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
+export declare function regularSegmentLoader(initialUrl: string, context: ISegmentContext, lowLatencyMode: boolean, options: ISegmentLoaderOptions, callbacks: ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
  * @param {Object} config
  * @returns {Function}

package/dist/es2017/transports/dash/segment_loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/segment_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAExF,OAAO,KAAK,EACV,8BAA8B,EAC9B,eAAe,EACf,cAAc,EACd,uBAAuB,EACvB,qBAAqB,EACrB,mCAAmC,EACnC,kCAAkC,EAClC,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAQlB;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,eAAe,EACxB,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,uBAAuB,CAAC,8BAA8B,CAAC,EAClE,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CACN,iCAAiC,CAAC,8BAA8B,CAAC,GACjE,kCAAkC,CAAC,8BAA8B,CAAC,GAClE,mCAAmC,CACtC,CA4BA;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAC5C,cAAc,EACd,aAAa,EAAE,mBAAmB,EAClC,0BAA0B,GAC3B,EAAE;IACD,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACjD,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClD,GAAG,cAAc,CAAC,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC,CA0KlD"}
+{"version":3,"file":"segment_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/segment_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAExF,OAAO,KAAK,EACV,8BAA8B,EAC9B,eAAe,EACf,cAAc,EACd,uBAAuB,EACvB,qBAAqB,EACrB,mCAAmC,EACnC,kCAAkC,EAClC,iCAAiC,EAClC,MAAM,UAAU,CAAC;AASlB;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,EACxB,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,uBAAuB,CAAC,8BAA8B,CAAC,EAClE,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CACN,iCAAiC,CAAC,8BAA8B,CAAC,GACjE,kCAAkC,CAAC,8BAA8B,CAAC,GAClE,mCAAmC,CACtC,CA6DA;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAC5C,cAAc,EACd,aAAa,EAAE,mBAAmB,EAClC,0BAA0B,GAC3B,EAAE;IACD,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACjD,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClD,GAAG,cAAc,CAAC,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC,CA2KlD"}

package/dist/es2017/transports/dash/segment_loader.js

@@ -16,15 +16,16 @@
 import { CustomLoaderError } from "../../errors";
 import request, { fetchIsSupported } from "../../utils/request";
 import warnOnce from "../../utils/warn_once";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
-import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
 import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
-import lowLatencySegmentLoader from "./low_latency_segment_loader";
+import { addSegmentIntegrityChecks } from "./integrity_checks";
+import loadChunkedSegmentData from "./load_chunked_segment_data";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} context
  * @param {boolean} lowLatencyMode
  * @param {Object} options
@@ -32,30 +33,47 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export function regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal) {
+export async function regularSegmentLoader(initialUrl, context, lowLatencyMode, options, callbacks, cancelSignal) {
+    var _a, _b;
     if (context.segment.isInit) {
-        return initSegmentLoader(url, context.segment, options, cancelSignal, callbacks);
+        return initSegmentLoader(initialUrl, context.segment, options, cancelSignal, callbacks);
+    }
+    const url = ((_a = options.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query"
+        ? addQueryString(initialUrl, options.cmcdPayload.value)
+        : initialUrl;
+    const cmcdHeaders = ((_b = options.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "headers" ? options.cmcdPayload.value : undefined;
+    const { segment } = context;
+    let headers;
+    if (segment.range !== undefined) {
+        headers = Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(segment.range) });
+    }
+    else if (cmcdHeaders !== undefined) {
+        headers = cmcdHeaders;
     }
     const containerType = inferSegmentContainer(context.type, context.mimeType);
     if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
         if (fetchIsSupported()) {
-            return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+            return loadChunkedSegmentData(url, {
+                headers,
+                timeout: options.timeout,
+                connectionTimeout: options.connectionTimeout,
+            }, 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");
         }
     }
-    const { segment } = context;
-    return request({
+    const data = await request({
         url,
         responseType: "arraybuffer",
-        headers: segment.range !== undefined ? { Range: byteRange(segment.range) } : undefined,
+        headers,
         timeout: options.timeout,
         connectionTimeout: options.connectionTimeout,
         cancelSignal,
         onProgress: callbacks.onProgress,
-    }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+    });
+    return { resultType: "segment-loaded", resultData: data };
 }
 /**
  * @param {Object} config
@@ -160,6 +178,7 @@ export default function generateSegmentLoader({ lowLatencyMode, segmentLoader: c
                 byteRanges,
                 trackType: context.type,
                 url,
+                cmcdPayload: options.cmcdPayload,
             };
             const abort = customSegmentLoader(args, customCallbacks);
             cancelSignal.register(abortCustomLoader);

package/dist/es2017/transports/dash/text_loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/text_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAGV,cAAc,EAMf,MAAM,UAAU,CAAC;AAQlB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAC9C,cAAc,EACd,0BAA0B,GAC3B,EAAE;IACD,cAAc,EAAE,OAAO,CAAC;IACxB,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClD,GAAG,cAAc,CAAC,UAAU,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC,CA0E3D"}
+{"version":3,"file":"text_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/dash/text_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAGV,cAAc,EAMf,MAAM,UAAU,CAAC;AASlB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAC9C,cAAc,EACd,0BAA0B,GAC3B,EAAE;IACD,cAAc,EAAE,OAAO,CAAC;IACxB,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClD,GAAG,cAAc,CAAC,UAAU,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC,CAsG3D"}

package/dist/es2017/transports/dash/text_loader.js

@@ -15,12 +15,13 @@
  */
 import request, { fetchIsSupported } from "../../utils/request";
 import warnOnce from "../../utils/warn_once";
+import addQueryString from "../utils/add_query_string";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
-import addSegmentIntegrityChecks from "./add_segment_integrity_checks_to_loader";
 import constructSegmentUrl from "./construct_segment_url";
 import initSegmentLoader from "./init_segment_loader";
-import lowLatencySegmentLoader from "./low_latency_segment_loader";
+import { addSegmentIntegrityChecks } from "./integrity_checks";
+import loadChunkedSegmentData from "./load_chunked_segment_data";
 /**
  * Perform requests for "text" segments
  * @param {boolean} lowLatencyMode
@@ -38,49 +39,68 @@ export default function generateTextTrackLoader({ lowLatencyMode, checkMediaSegm
      * @param {Object} callbacks
      * @returns {Promise}
      */
-    function textTrackLoader(wantedCdn, context, options, cancelSignal, callbacks) {
+    async function textTrackLoader(wantedCdn, context, options, cancelSignal, callbacks) {
+        var _a, _b;
         const { segment } = context;
-        const { range } = segment;
-        const url = constructSegmentUrl(wantedCdn, segment);
-        if (url === null) {
+        const initialUrl = constructSegmentUrl(wantedCdn, segment);
+        if (initialUrl === null) {
             return Promise.resolve({
                 resultType: "segment-created",
                 resultData: null,
             });
         }
         if (segment.isInit) {
-            return initSegmentLoader(url, segment, options, cancelSignal, callbacks);
+            return initSegmentLoader(initialUrl, segment, options, cancelSignal, callbacks);
+        }
+        const url = ((_a = options.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query"
+            ? addQueryString(initialUrl, options.cmcdPayload.value)
+            : initialUrl;
+        const cmcdHeaders = ((_b = options.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "headers" ? options.cmcdPayload.value : undefined;
+        let headers;
+        if (segment.range !== undefined) {
+            headers = Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(segment.range) });
+        }
+        else if (cmcdHeaders !== undefined) {
+            headers = cmcdHeaders;
         }
         const containerType = inferSegmentContainer(context.type, context.mimeType);
         const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
         if (lowLatencyMode && seemsToBeMP4) {
             if (fetchIsSupported()) {
-                return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+                return loadChunkedSegmentData(url, {
+                    headers,
+                    timeout: options.timeout,
+                    connectionTimeout: options.connectionTimeout,
+                }, 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");
             }
         }
+        let data;
         if (seemsToBeMP4) {
-            return request({
+            data = await request({
                 url,
                 responseType: "arraybuffer",
-                headers: Array.isArray(range) ? { Range: byteRange(range) } : null,
+                headers,
+                timeout: options.timeout,
+                connectionTimeout: options.connectionTimeout,
+                onProgress: callbacks.onProgress,
+                cancelSignal,
+            });
+        }
+        else {
+            data = await request({
+                url,
+                responseType: "text",
+                headers,
                 timeout: options.timeout,
                 connectionTimeout: options.connectionTimeout,
                 onProgress: callbacks.onProgress,
                 cancelSignal,
-            }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+            });
         }
-        return request({
-            url,
-            responseType: "text",
-            headers: Array.isArray(range) ? { Range: byteRange(range) } : null,
-            timeout: options.timeout,
-            connectionTimeout: options.connectionTimeout,
-            onProgress: callbacks.onProgress,
-            cancelSignal,
-        }).then((data) => ({ resultType: "segment-loaded", resultData: data }));
+        return { resultType: "segment-loaded", resultData: data };
     }
 }

package/dist/es2017/transports/local/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/local/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAIV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAMlB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,gBAAgB,EAAE,iBAAiB,GAClC,mBAAmB,CAiDrB"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/local/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAIV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAMlB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,gBAAgB,EAAE,iBAAiB,GAClC,mBAAmB,CAkDrB"}

package/dist/es2017/transports/local/pipelines.js

@@ -62,6 +62,7 @@ export default function getLocalManifestPipelines(transportOptions) {
         parseSegment: textTrackParser,
     };
     return {
+        transportName: "local",
         manifest: manifestPipeline,
         audio: segmentPipeline,
         video: segmentPipeline,

package/dist/es2017/transports/metaplaylist/manifest_loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/metaplaylist/manifest_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AA0BvE;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,EAC7C,oBAAoB,GACrB,EAAE;IACD,oBAAoB,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CACpD,GAAG,CACF,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,aAAa,EAAE,sBAAsB,EACrC,YAAY,EAAE,kBAAkB,KAC7B,OAAO,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAIlD"}
+{"version":3,"file":"manifest_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/metaplaylist/manifest_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAqCvE;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,EAC7C,oBAAoB,GACrB,EAAE;IACD,oBAAoB,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CACpD,GAAG,CACF,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,aAAa,EAAE,sBAAsB,EACrC,YAAY,EAAE,kBAAkB,KAC7B,OAAO,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAIlD"}

package/dist/es2017/transports/metaplaylist/manifest_loader.js

@@ -14,19 +14,27 @@
  * limitations under the License.
  */
 import request from "../../utils/request";
+import addQueryString from "../utils/add_query_string";
 import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
- * @param {string} url
+ * @param {string} initialUrl
  * @param {Object} loaderOptions
  * @param {Object} cancelSignal
  */
-function regularManifestLoader(url, loaderOptions, cancelSignal) {
-    if (url === undefined) {
+function regularManifestLoader(initialUrl, loaderOptions, cancelSignal) {
+    var _a, _b;
+    if (initialUrl === undefined) {
         throw new Error("Cannot perform HTTP(s) request. URL not known");
     }
+    const url = ((_a = loaderOptions.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query"
+        ? addQueryString(initialUrl, loaderOptions.cmcdPayload.value)
+        : initialUrl;
     return request({
         url,
+        headers: ((_b = loaderOptions.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "headers"
+            ? loaderOptions.cmcdPayload.value
+            : undefined,
         responseType: "text",
         timeout: loaderOptions.timeout,
         connectionTimeout: loaderOptions.connectionTimeout,

package/dist/es2017/transports/metaplaylist/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/metaplaylist/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAiBV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAkElB,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,CA+RxE"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/metaplaylist/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAiBV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAkElB,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,CAiSxE"}