rx-player 4.1.0 → 4.2.0-dev.2024080600

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

@@ -0,0 +1,209 @@
+"use strict";
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSegmentIntegrityChecks = addSegmentIntegrityChecks;
+exports.addManifestIntegrityChecks = addManifestIntegrityChecks;
+var errors_1 = require("../../errors");
+var global_scope_1 = require("../../utils/global_scope");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var task_canceller_1 = require("../../utils/task_canceller");
+var check_isobmff_integrity_1 = require("../utils/check_isobmff_integrity");
+var infer_segment_container_1 = require("../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}
+ */
+function addSegmentIntegrityChecks(segmentLoader) {
+    return function (url, context, loaderOptions, initialCancelSignal, callbacks) {
+        return new Promise(function (resolve, reject) {
+            var requestCanceller = new task_canceller_1.default();
+            var unlinkCanceller = requestCanceller.linkToSignal(initialCancelSignal);
+            requestCanceller.signal.register(reject);
+            segmentLoader(url, context, loaderOptions, requestCanceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (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(function (info) {
+                cleanUpCancellers();
+                if (requestCanceller.isUsed()) {
+                    return;
+                }
+                if (info.resultType === "segment-loaded") {
+                    try {
+                        throwOnIntegrityError(info.resultData.responseData);
+                    }
+                    catch (err) {
+                        reject(err);
+                        return;
+                    }
+                }
+                resolve(info);
+            }, function (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)) ||
+                (0, infer_segment_container_1.default)(context.type, context.mimeType) !== "mp4") {
+                return;
+            }
+            (0, check_isobmff_integrity_1.default)(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}
+ */
+function addManifestIntegrityChecks(manifestLoader) {
+    var _this = this;
+    return function (url, options, initialCancelSignal) { return __awaiter(_this, void 0, void 0, function () {
+        /**
+         * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+         * @param {*} data
+         */
+        function throwOnIntegrityError(data) {
+            if (typeof data === "string") {
+                var currOffset = data.length - 1;
+                var expectedStrings = ["</", "MPD", ">"];
+                for (var i = expectedStrings.length - 1; i >= 0; i--) {
+                    var currentExpectedStr = expectedStrings[i];
+                    while (isCharXmlWhiteSpace(data[currOffset])) {
+                        currOffset--;
+                    }
+                    for (var 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) {
+                var currOffset = data.byteLength - 1;
+                var dv = new DataView(data);
+                var expectedCharGroups = [[0x3c, 0x2f], [0x4d, 0x50, 0x44], [0x3e]];
+                for (var i = expectedCharGroups.length - 1; i >= 0; i--) {
+                    var currentExpectedCharGroup = expectedCharGroups[i];
+                    while (isUtf8XmlWhiteSpace(dv.getUint8(currOffset))) {
+                        currOffset--;
+                    }
+                    for (var 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 (!(0, is_null_or_undefined_1.default)(global_scope_1.default.Document) &&
+                data instanceof global_scope_1.default.Document) {
+                if (data.documentElement.nodeName !== "MPD") {
+                    throw new errors_1.OtherError("INTEGRITY_ERROR", "MPD does not end with </MPD>");
+                }
+            }
+        }
+        var res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, manifestLoader(url, options, initialCancelSignal)];
+                case 1:
+                    res = _a.sent();
+                    throwOnIntegrityError(res.responseData);
+                    return [2 /*return*/, res];
+            }
+        });
+    }); };
+}
+/**
+ * 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/commonjs/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/commonjs/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/commonjs/transports/dash/load_chunked_segment_data.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadChunkedSegmentData;
+var isobmff_1 = require("../../parsers/containers/isobmff");
+var byte_parsing_1 = require("../../utils/byte_parsing");
+var fetch_1 = require("../../utils/request/fetch");
+/**
+ * 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} 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}
+ */
+function loadChunkedSegmentData(url, requestOptions, callbacks, cancelSignal) {
+    return __awaiter(this, void 0, void 0, function () {
+        /**
+         * Called each time `fetch` has new data available.
+         * @param {Object} info
+         */
+        function onData(info) {
+            var chunk = new Uint8Array(info.chunk);
+            var concatenated = partialChunk !== null ? (0, byte_parsing_1.concat)(partialChunk, chunk) : chunk;
+            var res = (0, isobmff_1.extractCompleteChunks)(concatenated);
+            var completeChunks = res[0];
+            partialChunk = res[1];
+            if (completeChunks !== null) {
+                completeChunks.forEach(function (completedChunk) {
+                    callbacks.onNewChunk(completedChunk);
+                });
+                if (cancelSignal.isCancelled()) {
+                    return;
+                }
+            }
+            callbacks.onProgress({
+                duration: info.duration,
+                size: info.size,
+                totalSize: info.totalSize,
+            });
+            if (cancelSignal.isCancelled()) {
+                return;
+            }
+        }
+        var partialChunk, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    partialChunk = null;
+                    return [4 /*yield*/, (0, fetch_1.default)({
+                            url: url,
+                            headers: requestOptions.headers,
+                            onData: onData,
+                            timeout: requestOptions.timeout,
+                            connectionTimeout: requestOptions.connectionTimeout,
+                            cancelSignal: cancelSignal,
+                        })];
+                case 1:
+                    res = _a.sent();
+                    return [2 /*return*/, {
+                            resultType: "chunk-complete",
+                            resultData: res,
+                        }];
+            }
+        });
+    });
+}

package/dist/commonjs/transports/dash/manifest_parser.js

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateManifestParser;
 var config_1 = require("../../config");
 var errors_1 = require("../../errors");
 var features_1 = require("../../features");
@@ -189,7 +190,6 @@ function generateManifestParser(options) {
         }
     };
 }
-exports.default = generateManifestParser;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is

package/dist/commonjs/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/commonjs/transports/dash/pipelines.js

@@ -15,8 +15,10 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 var features_1 = require("../../features");
 var generate_manifest_loader_1 = require("../utils/generate_manifest_loader");
+var integrity_checks_1 = require("./integrity_checks");
 var manifest_parser_1 = require("./manifest_parser");
 var segment_loader_1 = require("./segment_loader");
 var segment_parser_1 = require("./segment_parser");
@@ -29,13 +31,14 @@ var text_parser_1 = require("./text_parser");
  * @returns {Object}
  */
 function default_1(options) {
-    var manifestLoader = (0, generate_manifest_loader_1.default)({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" : "arraybuffer");
+    var manifestLoader = (0, generate_manifest_loader_1.default)({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" : "arraybuffer", options.checkManifestIntegrity === true ? integrity_checks_1.addManifestIntegrityChecks : null);
     var manifestParser = (0, manifest_parser_1.default)(options);
     var segmentLoader = (0, segment_loader_1.default)(options);
     var audioVideoSegmentParser = (0, segment_parser_1.default)(options);
     var textTrackLoader = (0, text_loader_1.default)(options);
     var textTrackParser = (0, text_parser_1.default)(options);
     return {
+        transportName: "dash",
         manifest: { loadManifest: manifestLoader, parseManifest: manifestParser },
         audio: {
             loadSegment: segmentLoader,
@@ -48,7 +51,6 @@ function default_1(options) {
         text: { loadSegment: textTrackLoader, parseSegment: textTrackParser },
     };
 }
-exports.default = default_1;
 /**
  * Returns true if the DASH-WASM parser is either initialized or being
  * initialized.

package/dist/commonjs/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/commonjs/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/commonjs/transports/dash/segment_loader.js

@@ -14,20 +14,69 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.regularSegmentLoader = void 0;
+exports.regularSegmentLoader = regularSegmentLoader;
+exports.default = generateSegmentLoader;
 var errors_1 = require("../../errors");
 var request_1 = require("../../utils/request");
 var warn_once_1 = require("../../utils/warn_once");
+var add_query_string_1 = require("../utils/add_query_string");
 var byte_range_1 = require("../utils/byte_range");
 var infer_segment_container_1 = require("../utils/infer_segment_container");
-var add_segment_integrity_checks_to_loader_1 = require("./add_segment_integrity_checks_to_loader");
 var construct_segment_url_1 = require("./construct_segment_url");
 var init_segment_loader_1 = require("./init_segment_loader");
-var low_latency_segment_loader_1 = require("./low_latency_segment_loader");
+var integrity_checks_1 = require("./integrity_checks");
+var load_chunked_segment_data_1 = require("./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
@@ -35,32 +84,57 @@ var low_latency_segment_loader_1 = require("./low_latency_segment_loader");
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-function regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal) {
-    if (context.segment.isInit) {
-        return (0, init_segment_loader_1.default)(url, context.segment, options, cancelSignal, callbacks);
-    }
-    var containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
-    if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
-        if ((0, request_1.fetchIsSupported)()) {
-            return (0, low_latency_segment_loader_1.default)(url, context, options, callbacks, cancelSignal);
-        }
-        else {
-            (0, warn_once_1.default)("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 = context.segment;
-    return (0, request_1.default)({
-        url: url,
-        responseType: "arraybuffer",
-        headers: segment.range !== undefined ? { Range: (0, byte_range_1.default)(segment.range) } : undefined,
-        timeout: options.timeout,
-        connectionTimeout: options.connectionTimeout,
-        cancelSignal: cancelSignal,
-        onProgress: callbacks.onProgress,
-    }).then(function (data) { return ({ resultType: "segment-loaded", resultData: data }); });
+function regularSegmentLoader(initialUrl, context, lowLatencyMode, options, callbacks, cancelSignal) {
+    return __awaiter(this, void 0, void 0, function () {
+        var url, cmcdHeaders, segment, headers, containerType, data;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (context.segment.isInit) {
+                        return [2 /*return*/, (0, init_segment_loader_1.default)(initialUrl, context.segment, options, cancelSignal, callbacks)];
+                    }
+                    url = ((_a = options.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query"
+                        ? (0, add_query_string_1.default)(initialUrl, options.cmcdPayload.value)
+                        : initialUrl;
+                    cmcdHeaders = ((_b = options.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "headers" ? options.cmcdPayload.value : undefined;
+                    segment = context.segment;
+                    if (segment.range !== undefined) {
+                        headers = __assign(__assign({}, cmcdHeaders), { Range: (0, byte_range_1.default)(segment.range) });
+                    }
+                    else if (cmcdHeaders !== undefined) {
+                        headers = cmcdHeaders;
+                    }
+                    containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
+                    if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
+                        if ((0, request_1.fetchIsSupported)()) {
+                            return [2 /*return*/, (0, load_chunked_segment_data_1.default)(url, {
+                                    headers: headers,
+                                    timeout: options.timeout,
+                                    connectionTimeout: options.connectionTimeout,
+                                }, callbacks, cancelSignal)];
+                        }
+                        else {
+                            (0, warn_once_1.default)("DASH: Your browser does not have the fetch API. You will have " +
+                                "a higher chance of rebuffering when playing close to the live edge");
+                        }
+                    }
+                    return [4 /*yield*/, (0, request_1.default)({
+                            url: url,
+                            responseType: "arraybuffer",
+                            headers: headers,
+                            timeout: options.timeout,
+                            connectionTimeout: options.connectionTimeout,
+                            cancelSignal: cancelSignal,
+                            onProgress: callbacks.onProgress,
+                        })];
+                case 1:
+                    data = _c.sent();
+                    return [2 /*return*/, { resultType: "segment-loaded", resultData: data }];
+            }
+        });
+    });
 }
-exports.regularSegmentLoader = regularSegmentLoader;
 /**
  * @param {Object} config
  * @returns {Function}
@@ -69,7 +143,7 @@ function generateSegmentLoader(_a) {
     var lowLatencyMode = _a.lowLatencyMode, customSegmentLoader = _a.segmentLoader, checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity;
     return checkMediaSegmentIntegrity !== true
         ? segmentLoader
-        : (0, add_segment_integrity_checks_to_loader_1.default)(segmentLoader);
+        : (0, integrity_checks_1.addSegmentIntegrityChecks)(segmentLoader);
     /**
      * @param {Object|null} wantedCdn
      * @param {Object} context
@@ -165,6 +239,7 @@ function generateSegmentLoader(_a) {
                 byteRanges: byteRanges,
                 trackType: context.type,
                 url: url,
+                cmcdPayload: options.cmcdPayload,
             };
             var abort = customSegmentLoader(args, customCallbacks);
             cancelSignal.register(abortCustomLoader);
@@ -185,4 +260,3 @@ function generateSegmentLoader(_a) {
         });
     }
 }
-exports.default = generateSegmentLoader;

package/dist/commonjs/transports/dash/segment_parser.js

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateAudioVideoSegmentParser;
 var isobmff_1 = require("../../parsers/containers/isobmff");
 var utils_1 = require("../../parsers/containers/isobmff/utils");
 var matroska_1 = require("../../parsers/containers/matroska");
@@ -156,4 +157,3 @@ function generateAudioVideoSegmentParser(_a) {
         };
     };
 }
-exports.default = generateAudioVideoSegmentParser;