rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,27 +14,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import features from "../../features";
-import generateManifestLoader from "../utils/generate_manifest_loader";
-import generateManifestParser from "./manifest_parser";
-import generateSegmentLoader from "./segment_loader";
-import generateAudioVideoSegmentParser from "./segment_parser";
-import generateTextTrackLoader from "./text_loader";
-import generateTextTrackParser from "./text_parser";
+Object.defineProperty(exports, "__esModule", { value: true });
+const features_1 = require("../../features");
+const generate_manifest_loader_1 = require("../utils/generate_manifest_loader");
+const manifest_parser_1 = require("./manifest_parser");
+const segment_loader_1 = require("./segment_loader");
+const segment_parser_1 = require("./segment_parser");
+const text_loader_1 = require("./text_loader");
+const text_parser_1 = require("./text_parser");
 /**
  * Returns pipelines used for DASH streaming.
  * @param {Object} options
  * implementation. Used for each generated http request.
  * @returns {Object}
  */
-export default function (options) {
-    var manifestLoader = generateManifestLoader({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" :
+function default_1(options) {
+    const manifestLoader = (0, generate_manifest_loader_1.default)({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" :
         "arraybuffer");
-    var manifestParser = generateManifestParser(options);
-    var segmentLoader = generateSegmentLoader(options);
-    var audioVideoSegmentParser = generateAudioVideoSegmentParser(options);
-    var textTrackLoader = generateTextTrackLoader(options);
-    var textTrackParser = generateTextTrackParser(options);
+    const manifestParser = (0, manifest_parser_1.default)(options);
+    const segmentLoader = (0, segment_loader_1.default)(options);
+    const audioVideoSegmentParser = (0, segment_parser_1.default)(options);
+    const textTrackLoader = (0, text_loader_1.default)(options);
+    const textTrackParser = (0, text_parser_1.default)(options);
     return { manifest: { loadManifest: manifestLoader,
             parseManifest: manifestParser },
         audio: { loadSegment: segmentLoader,
@@ -43,13 +45,14 @@ export default function (options) {
         text: { loadSegment: textTrackLoader,
             parseSegment: textTrackParser } };
 }
+exports.default = default_1;
 /**
  * Returns true if the DASH-WASM parser is either initialized or being
  * initialized.
  * @returns {boolean}
  */
 function mightUseDashWasmFeature() {
-    return features.dashParsers.wasm !== null &&
-        (features.dashParsers.wasm.status === "initialized" ||
-            features.dashParsers.wasm.status === "initializing");
+    return features_1.default.dashParsers.wasm !== null &&
+        (features_1.default.dashParsers.wasm.status === "initialized" ||
+            features_1.default.dashParsers.wasm.status === "initializing");
 }

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,15 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CustomLoaderError } from "../../errors";
-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";
-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";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regularSegmentLoader = void 0;
+const errors_1 = require("../../errors");
+const request_1 = require("../../utils/request");
+const warn_once_1 = require("../../utils/warn_once");
+const byte_range_1 = require("../utils/byte_range");
+const infer_segment_container_1 = require("../utils/infer_segment_container");
+const add_segment_integrity_checks_to_loader_1 = require("./add_segment_integrity_checks_to_loader");
+const construct_segment_url_1 = require("./construct_segment_url");
+const init_segment_loader_1 = require("./init_segment_loader");
+const low_latency_segment_loader_1 = require("./low_latency_segment_loader");
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
@@ -32,37 +35,40 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export function regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal) {
+function regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal) {
     if (context.segment.isInit) {
-        return initSegmentLoader(url, context.segment, options, cancelSignal, callbacks);
+        return (0, init_segment_loader_1.default)(url, context.segment, options, cancelSignal, callbacks);
     }
-    var containerType = inferSegmentContainer(context.type, context.mimeType);
+    const containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
     if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
-        if (fetchIsSupported()) {
-            return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+        if ((0, request_1.fetchIsSupported)()) {
+            return (0, low_latency_segment_loader_1.default)(url, context, options, callbacks, cancelSignal);
         }
         else {
-            warnOnce("DASH: Your browser does not have the fetch API. You will have " +
+            (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 request({ url: url, responseType: "arraybuffer",
+    const { segment } = context;
+    return (0, request_1.default)({ url,
+        responseType: "arraybuffer",
         headers: segment.range !== undefined ?
-            { Range: byteRange(segment.range) } :
+            { Range: (0, byte_range_1.default)(segment.range) } :
             undefined,
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-        .then(function (data) { return ({ resultType: "segment-loaded",
-        resultData: data }); });
+        timeout: options.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress })
+        .then((data) => ({ resultType: "segment-loaded",
+        resultData: data }));
 }
+exports.regularSegmentLoader = regularSegmentLoader;
 /**
  * @param {Object} config
  * @returns {Function}
  */
-export default function generateSegmentLoader(_a) {
-    var lowLatencyMode = _a.lowLatencyMode, customSegmentLoader = _a.segmentLoader, checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity;
+function generateSegmentLoader({ lowLatencyMode, segmentLoader: customSegmentLoader, checkMediaSegmentIntegrity }) {
     return checkMediaSegmentIntegrity !== true ? segmentLoader :
-        addSegmentIntegrityChecks(segmentLoader);
+        (0, add_segment_integrity_checks_to_loader_1.default)(segmentLoader);
     /**
      * @param {Object|null} wantedCdn
      * @param {Object} context
@@ -72,7 +78,7 @@ export default function generateSegmentLoader(_a) {
      * @returns {Promise.<Object>}
      */
     function segmentLoader(wantedCdn, context, options, cancelSignal, callbacks) {
-        var url = constructSegmentUrl(wantedCdn, context.segment);
+        const url = (0, construct_segment_url_1.default)(wantedCdn, context.segment);
         if (url == null) {
             return Promise.resolve({ resultType: "segment-created",
                 resultData: null });
@@ -80,14 +86,14 @@ export default function generateSegmentLoader(_a) {
         if (lowLatencyMode || customSegmentLoader === undefined) {
             return regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal);
         }
-        return new Promise(function (res, rej) {
+        return new Promise((res, rej) => {
             /** `true` when the custom segmentLoader should not be active anymore. */
-            var hasFinished = false;
+            let hasFinished = false;
             /**
              * Callback triggered when the custom segment loader has a response.
              * @param {Object} _args
              */
-            var resolve = function (_args) {
+            const resolve = (_args) => {
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
@@ -102,7 +108,7 @@ export default function generateSegmentLoader(_a) {
              * Callback triggered when the custom segment loader fails
              * @param {*} err - The corresponding error encountered
              */
-            var reject = function (err) {
+            const reject = (err) => {
                 var _a, _b;
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
@@ -110,13 +116,13 @@ export default function generateSegmentLoader(_a) {
                 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 " +
+                const castedErr = err;
+                const 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, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
+                const emittedErr = new errors_1.CustomLoaderError(message, (_b = castedErr === null || castedErr === void 0 ? void 0 : castedErr.canRetry) !== null && _b !== void 0 ? _b : false, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
                 rej(emittedErr);
             };
-            var progress = function (_args) {
+            const progress = (_args) => {
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
@@ -128,7 +134,7 @@ export default function generateSegmentLoader(_a) {
              * Callback triggered when the custom segment loader wants to fallback to
              * the "regular" implementation
              */
-            var fallback = function () {
+            const fallback = () => {
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
@@ -137,17 +143,20 @@ export default function generateSegmentLoader(_a) {
                 regularSegmentLoader(url, context, lowLatencyMode, options, callbacks, cancelSignal)
                     .then(res, rej);
             };
-            var customCallbacks = { reject: reject, resolve: resolve, progress: progress, fallback: fallback };
-            var byteRanges;
+            const customCallbacks = { reject, resolve, progress, fallback };
+            let byteRanges;
             if (context.segment.range !== undefined) {
                 byteRanges = [context.segment.range];
                 if (context.segment.indexRange !== undefined) {
                     byteRanges.push(context.segment.indexRange);
                 }
             }
-            var args = { isInit: context.segment.isInit,
-                timeout: options.timeout, byteRanges: byteRanges, trackType: context.type, url: url };
-            var abort = customSegmentLoader(args, customCallbacks);
+            const args = { isInit: context.segment.isInit,
+                timeout: options.timeout,
+                byteRanges,
+                trackType: context.type,
+                url };
+            const abort = customSegmentLoader(args, customCallbacks);
             cancelSignal.register(abortCustomLoader);
             /**
              * The logic to run when the custom loader is cancelled while pending.
@@ -166,3 +175,4 @@ export default function generateSegmentLoader(_a) {
         });
     }
 }
+exports.default = generateSegmentLoader;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,25 +14,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { getMDHDTimescale, getSegmentsFromSidx, takePSSHOut, } from "../../parsers/containers/isobmff";
-import { getKeyIdFromInitSegment, parseEmsgBoxes, } from "../../parsers/containers/isobmff/utils";
-import { getSegmentsFromCues, getTimeCodeScale, } from "../../parsers/containers/matroska";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import takeFirstSet from "../../utils/take_first_set";
-import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
-import inferSegmentContainer from "../utils/infer_segment_container";
-import getEventsOutOfEMSGs from "./get_events_out_of_emsgs";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isobmff_1 = require("../../parsers/containers/isobmff");
+const utils_1 = require("../../parsers/containers/isobmff/utils");
+const matroska_1 = require("../../parsers/containers/matroska");
+const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+const take_first_set_1 = require("../../utils/take_first_set");
+const get_isobmff_timing_infos_1 = require("../utils/get_isobmff_timing_infos");
+const infer_segment_container_1 = require("../utils/infer_segment_container");
+const get_events_out_of_emsgs_1 = require("./get_events_out_of_emsgs");
 /**
  * @param {Object} config
  * @returns {Function}
  */
-export default function generateAudioVideoSegmentParser(_a) {
-    var __priv_patchLastSegmentInSidx = _a.__priv_patchLastSegmentInSidx;
+function generateAudioVideoSegmentParser({ __priv_patchLastSegmentInSidx }) {
     return function audioVideoSegmentParser(loadedSegment, context, initTimescale) {
         var _a;
-        var segment = context.segment, periodStart = context.periodStart, periodEnd = context.periodEnd;
-        var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
-        var appendWindow = [periodStart, periodEnd];
+        const { segment, periodStart, periodEnd } = context;
+        const { data, isChunked } = loadedSegment;
+        const appendWindow = [periodStart, periodEnd];
         if (data === null) {
             if (segment.isInit) {
                 return { segmentType: "init",
@@ -45,55 +46,70 @@ export default function generateAudioVideoSegmentParser(_a) {
                 chunkSize: 0,
                 chunkInfos: null,
                 chunkOffset: 0,
-                protectionData: [], appendWindow: appendWindow };
+                protectionData: [],
+                appendWindow };
         }
-        var chunkData = data instanceof Uint8Array ? data :
+        const chunkData = data instanceof Uint8Array ? data :
             new Uint8Array(data);
-        var containerType = inferSegmentContainer(context.type, context.mimeType);
+        const containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
         // TODO take a look to check if this is an ISOBMFF/webm?
-        var seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
-        var protectionData = [];
+        const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
+        const protectionData = [];
         if (seemsToBeMP4) {
-            var psshInfo = takePSSHOut(chunkData);
-            var keyId = void 0;
+            const psshInfo = (0, isobmff_1.takePSSHOut)(chunkData);
+            let keyId;
             if (segment.isInit) {
-                keyId = (_a = getKeyIdFromInitSegment(chunkData)) !== null && _a !== void 0 ? _a : undefined;
+                keyId = (_a = (0, utils_1.getKeyIdFromInitSegment)(chunkData)) !== null && _a !== void 0 ? _a : undefined;
             }
             if (psshInfo.length > 0 || keyId !== undefined) {
-                protectionData.push({ initDataType: "cenc", keyId: keyId, initData: psshInfo });
+                protectionData.push({ initDataType: "cenc", keyId, initData: psshInfo });
             }
         }
         if (!segment.isInit) {
-            var chunkInfos = seemsToBeMP4 ? getISOBMFFTimingInfos(chunkData, isChunked, segment, initTimescale) :
+            const chunkInfos = seemsToBeMP4 ? (0, get_isobmff_timing_infos_1.default)(chunkData, isChunked, segment, initTimescale) :
                 null; // TODO extract time info from webm
-            var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
+            const chunkOffset = (0, take_first_set_1.default)(segment.timestampOffset, 0);
             if (seemsToBeMP4) {
-                var parsedEMSGs = parseEmsgBoxes(chunkData);
+                const parsedEMSGs = (0, utils_1.parseEmsgBoxes)(chunkData);
                 if (parsedEMSGs !== undefined) {
-                    var whitelistedEMSGs = parsedEMSGs.filter(function (evt) {
+                    const whitelistedEMSGs = parsedEMSGs.filter((evt) => {
                         if (segment.privateInfos === undefined ||
                             segment.privateInfos.isEMSGWhitelisted === undefined) {
                             return false;
                         }
                         return segment.privateInfos.isEMSGWhitelisted(evt);
                     });
-                    var events = getEventsOutOfEMSGs(whitelistedEMSGs, context.manifestPublishTime);
+                    const events = (0, get_events_out_of_emsgs_1.default)(whitelistedEMSGs, context.manifestPublishTime);
                     if (events !== undefined) {
-                        var needsManifestRefresh = events.needsManifestRefresh, inbandEvents = events.inbandEvents;
-                        return { segmentType: "media", chunkData: chunkData, chunkSize: chunkData.length, chunkInfos: chunkInfos, chunkOffset: chunkOffset, appendWindow: appendWindow, inbandEvents: inbandEvents, protectionData: protectionData, needsManifestRefresh: needsManifestRefresh };
+                        const { needsManifestRefresh, inbandEvents } = events;
+                        return { segmentType: "media",
+                            chunkData,
+                            chunkSize: chunkData.length,
+                            chunkInfos,
+                            chunkOffset,
+                            appendWindow,
+                            inbandEvents,
+                            protectionData,
+                            needsManifestRefresh };
                     }
                 }
             }
-            return { segmentType: "media", chunkData: chunkData, chunkSize: chunkData.length, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionData: protectionData, appendWindow: appendWindow };
+            return { segmentType: "media",
+                chunkData,
+                chunkSize: chunkData.length,
+                chunkInfos,
+                chunkOffset,
+                protectionData,
+                appendWindow };
         }
         // we're handling an initialization segment
-        var indexRange = segment.indexRange;
-        var segmentList;
+        const { indexRange } = segment;
+        let segmentList;
         if (containerType === "webm") {
-            segmentList = getSegmentsFromCues(chunkData, 0);
+            segmentList = (0, matroska_1.getSegmentsFromCues)(chunkData, 0);
         }
         else if (seemsToBeMP4) {
-            segmentList = getSegmentsFromSidx(chunkData, Array.isArray(indexRange) ?
+            segmentList = (0, isobmff_1.getSegmentsFromSidx)(chunkData, Array.isArray(indexRange) ?
                 indexRange[0] :
                 0);
             // This is a very specific handling for streams we know have a very
@@ -106,20 +122,23 @@ export default function generateAudioVideoSegmentParser(_a) {
             if (__priv_patchLastSegmentInSidx === true &&
                 segmentList !== null &&
                 segmentList.length > 0) {
-                var lastSegment = segmentList[segmentList.length - 1];
+                const lastSegment = segmentList[segmentList.length - 1];
                 if (Array.isArray(lastSegment.range)) {
                     lastSegment.range[1] = Infinity;
                 }
             }
         }
-        var timescale = seemsToBeMP4 ? getMDHDTimescale(chunkData) :
-            containerType === "webm" ? getTimeCodeScale(chunkData, 0) :
+        const timescale = seemsToBeMP4 ? (0, isobmff_1.getMDHDTimescale)(chunkData) :
+            containerType === "webm" ? (0, matroska_1.getTimeCodeScale)(chunkData, 0) :
                 undefined;
-        var parsedTimescale = isNullOrUndefined(timescale) ? undefined :
+        const parsedTimescale = (0, is_null_or_undefined_1.default)(timescale) ? undefined :
             timescale;
         return { segmentType: "init",
             initializationData: chunkData,
-            initializationDataSize: chunkData.length, protectionData: protectionData, initTimescale: parsedTimescale,
+            initializationDataSize: chunkData.length,
+            protectionData,
+            initTimescale: parsedTimescale,
             segmentList: segmentList !== null && segmentList !== void 0 ? segmentList : undefined };
     };
 }
+exports.default = generateAudioVideoSegmentParser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,23 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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";
-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";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("../../utils/request");
+const warn_once_1 = require("../../utils/warn_once");
+const byte_range_1 = require("../utils/byte_range");
+const infer_segment_container_1 = require("../utils/infer_segment_container");
+const add_segment_integrity_checks_to_loader_1 = require("./add_segment_integrity_checks_to_loader");
+const construct_segment_url_1 = require("./construct_segment_url");
+const init_segment_loader_1 = require("./init_segment_loader");
+const low_latency_segment_loader_1 = require("./low_latency_segment_loader");
 /**
  * Perform requests for "text" segments
  * @param {boolean} lowLatencyMode
  * @returns {Function}
  */
-export default function generateTextTrackLoader(_a) {
-    var lowLatencyMode = _a.lowLatencyMode, checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity;
+function generateTextTrackLoader({ lowLatencyMode, checkMediaSegmentIntegrity }) {
     return checkMediaSegmentIntegrity !== true ? textTrackLoader :
-        addSegmentIntegrityChecks(textTrackLoader);
+        (0, add_segment_integrity_checks_to_loader_1.default)(textTrackLoader);
     /**
      * @param {Object|null} wantedCdn
      * @param {Object} context
@@ -39,44 +40,49 @@ export default function generateTextTrackLoader(_a) {
      * @returns {Promise}
      */
     function textTrackLoader(wantedCdn, context, options, cancelSignal, callbacks) {
-        var segment = context.segment;
-        var range = segment.range;
-        var url = constructSegmentUrl(wantedCdn, segment);
+        const { segment } = context;
+        const { range } = segment;
+        const url = (0, construct_segment_url_1.default)(wantedCdn, segment);
         if (url === null) {
             return Promise.resolve({ resultType: "segment-created",
                 resultData: null });
         }
         if (segment.isInit) {
-            return initSegmentLoader(url, segment, options, cancelSignal, callbacks);
+            return (0, init_segment_loader_1.default)(url, segment, options, cancelSignal, callbacks);
         }
-        var containerType = inferSegmentContainer(context.type, context.mimeType);
-        var seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
+        const containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
+        const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
         if (lowLatencyMode && seemsToBeMP4) {
-            if (fetchIsSupported()) {
-                return lowLatencySegmentLoader(url, context, options, callbacks, cancelSignal);
+            if ((0, request_1.fetchIsSupported)()) {
+                return (0, low_latency_segment_loader_1.default)(url, context, options, callbacks, cancelSignal);
             }
             else {
-                warnOnce("DASH: Your browser does not have the fetch API. You will have " +
+                (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");
             }
         }
         if (seemsToBeMP4) {
-            return request({ url: url, responseType: "arraybuffer",
+            return (0, request_1.default)({ url,
+                responseType: "arraybuffer",
                 headers: Array.isArray(range) ?
-                    { Range: byteRange(range) } :
+                    { Range: (0, byte_range_1.default)(range) } :
                     null,
                 timeout: options.timeout,
-                onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
-                .then(function (data) { return ({ resultType: "segment-loaded",
-                resultData: data }); });
+                onProgress: callbacks.onProgress,
+                cancelSignal })
+                .then((data) => ({ resultType: "segment-loaded",
+                resultData: data }));
         }
-        return request({ url: url, responseType: "text",
+        return (0, request_1.default)({ url,
+            responseType: "text",
             headers: Array.isArray(range) ?
-                { Range: byteRange(range) } :
+                { Range: (0, byte_range_1.default)(range) } :
                 null,
             timeout: options.timeout,
-            onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+            onProgress: callbacks.onProgress,
+            cancelSignal })
+            .then((data) => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
 }
+exports.default = generateTextTrackLoader;