rx-player 4.4.1 → 4.5.0-dev.2026012301

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

@@ -1,336 +0,0 @@
-/**
- * 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.
- */
-import log from "../../log";
-import Manifest from "../../manifest/classes";
-import { getMDAT } from "../../parsers/containers/isobmff";
-import createSmoothManifestParser from "../../parsers/manifest/smooth";
-import request from "../../utils/request";
-import { strToUtf8, utf8ToStr } from "../../utils/string_parsing";
-import addQueryString from "../utils/add_query_string";
-import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
-import generateManifestLoader from "../utils/generate_manifest_loader";
-import extractTimingsInfos from "./extract_timings_infos";
-import isMP4EmbeddedTrack from "./is_mp4_embedded_track";
-import { patchSegment } from "./isobmff";
-import generateSegmentLoader from "./segment_loader";
-import { constructSegmentUrl } from "./utils";
-export default function (transportOptions) {
-    const smoothManifestParser = createSmoothManifestParser(transportOptions);
-    const segmentLoader = generateSegmentLoader(transportOptions);
-    const manifestLoaderOptions = {
-        customManifestLoader: transportOptions.manifestLoader,
-    };
-    const manifestLoader = generateManifestLoader(manifestLoaderOptions, "text", null);
-    const manifestPipeline = {
-        loadManifest: manifestLoader,
-        parseManifest(manifestData, parserOptions) {
-            var _a;
-            const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
-            const { receivedTime: manifestReceivedTime, responseData } = manifestData;
-            const documentData = typeof responseData === "string"
-                ? new DOMParser().parseFromString(responseData, "text/xml")
-                : responseData; // TODO find a way to check if Document?
-            const parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
-            const manifest = new Manifest(parserResult, {
-                representationFilter: transportOptions.representationFilter,
-            });
-            return { manifest, url };
-        },
-    };
-    /**
-     * Export functions allowing to load and parse audio and video smooth
-     * segments.
-     */
-    const audioVideoPipeline = {
-        /**
-         * Load a Smooth audio/video segment.
-         * @param {Object|null} wantedCdn
-         * @param {Object} context
-         * @param {Object} loaderOptions
-         * @param {Object} cancelSignal
-         * @param {Object} callbacks
-         * @returns {Promise}
-         */
-        loadSegment(wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            const url = constructSegmentUrl(wantedCdn, context.segment);
-            return segmentLoader(url, context, loaderOptions, cancelSignal, callbacks);
-        },
-        parseSegment(loadedSegment, context, initTimescale) {
-            var _a, _b;
-            const { segment } = context;
-            const { data, isChunked } = loadedSegment;
-            if (data === null) {
-                if (segment.isInit) {
-                    return {
-                        segmentType: "init",
-                        initializationData: null,
-                        initializationDataSize: 0,
-                        protectionData: [],
-                        initTimescale: undefined,
-                    };
-                }
-                return {
-                    segmentType: "media",
-                    chunkData: null,
-                    chunkInfos: null,
-                    chunkOffset: 0,
-                    chunkSize: 0,
-                    protectionData: [],
-                    appendWindow: [undefined, undefined],
-                };
-            }
-            const responseBuffer = data instanceof Uint8Array ? data : new Uint8Array(data);
-            if (segment.isInit) {
-                const timescale = (_b = (_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothInitSegment) === null || _b === void 0 ? void 0 : _b.timescale;
-                return {
-                    segmentType: "init",
-                    initializationData: data,
-                    initializationDataSize: data.byteLength,
-                    // smooth init segments are crafted by hand.
-                    // Their timescale is the one from the manifest.
-                    initTimescale: timescale,
-                    protectionData: [],
-                };
-            }
-            const timingInfos = initTimescale !== undefined
-                ? extractTimingsInfos(responseBuffer, isChunked, initTimescale, segment, context.isLive)
-                : null;
-            if (timingInfos === null ||
-                timingInfos.chunkInfos === null ||
-                timingInfos.scaledSegmentTime === undefined) {
-                throw new Error("Smooth Segment without time information");
-            }
-            const { nextSegments, chunkInfos, scaledSegmentTime } = timingInfos;
-            const chunkData = patchSegment(responseBuffer, scaledSegmentTime);
-            const predictedSegments = nextSegments.length > 0 ? nextSegments : undefined;
-            return {
-                segmentType: "media",
-                chunkData,
-                chunkInfos,
-                chunkOffset: 0,
-                chunkSize: chunkData.length,
-                protectionData: [],
-                predictedSegments,
-                appendWindow: [undefined, undefined],
-            };
-        },
-    };
-    const textTrackPipeline = {
-        loadSegment(wantedCdn, context, loaderOptions, cancelSignal, callbacks) {
-            var _a, _b, _c, _d;
-            const { segment } = context;
-            const url = constructSegmentUrl(wantedCdn, segment);
-            if (segment.isInit || url === null) {
-                return Promise.resolve({
-                    resultType: "segment-created",
-                    resultData: null,
-                });
-            }
-            const isMP4 = isMP4EmbeddedTrack(context.mimeType);
-            if (!isMP4) {
-                return request({
-                    url: ((_a = loaderOptions.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "query"
-                        ? addQueryString(url, loaderOptions.cmcdPayload.value)
-                        : 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,
-                    cancelSignal,
-                    onProgress: callbacks.onProgress,
-                }).then((data) => ({
-                    resultType: "segment-loaded",
-                    resultData: data,
-                }));
-            }
-            else {
-                return request({
-                    url: ((_c = loaderOptions.cmcdPayload) === null || _c === void 0 ? void 0 : _c.type) === "query"
-                        ? addQueryString(url, loaderOptions.cmcdPayload.value)
-                        : url,
-                    headers: ((_d = loaderOptions.cmcdPayload) === null || _d === void 0 ? void 0 : _d.type) === "headers"
-                        ? loaderOptions.cmcdPayload.value
-                        : undefined,
-                    responseType: "arraybuffer",
-                    timeout: loaderOptions.timeout,
-                    connectionTimeout: loaderOptions.connectionTimeout,
-                    cancelSignal,
-                    onProgress: callbacks.onProgress,
-                }).then((data) => {
-                    if (transportOptions.checkMediaSegmentIntegrity !== true) {
-                        return { resultType: "segment-loaded", resultData: data };
-                    }
-                    const dataU8 = new Uint8Array(data.responseData);
-                    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
-                    return {
-                        resultType: "segment-loaded",
-                        resultData: Object.assign(Object.assign({}, data), { responseData: dataU8 }),
-                    };
-                });
-            }
-        },
-        parseSegment(loadedSegment, context, initTimescale) {
-            var _a;
-            const { segment, language, mimeType = "", codecs = "" } = context;
-            const isMP4 = isMP4EmbeddedTrack(context.mimeType);
-            const { data, isChunked } = loadedSegment;
-            let chunkSize;
-            if (segment.isInit) {
-                // text init segment has no use in HSS
-                return {
-                    segmentType: "init",
-                    initializationData: null,
-                    initializationDataSize: 0,
-                    protectionData: [],
-                    initTimescale: undefined,
-                };
-            }
-            if (data === null) {
-                return {
-                    segmentType: "media",
-                    chunkData: null,
-                    chunkInfos: null,
-                    chunkOffset: 0,
-                    chunkSize: 0,
-                    protectionData: [],
-                    appendWindow: [undefined, undefined],
-                };
-            }
-            let nextSegments;
-            let chunkInfos = null;
-            let segmentStart;
-            let segmentEnd;
-            let _sdData;
-            let _sdType;
-            if (isMP4) {
-                let chunkBytes;
-                if (typeof data === "string") {
-                    chunkBytes = strToUtf8(data);
-                }
-                else {
-                    chunkBytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-                }
-                chunkSize = chunkBytes.length;
-                const timingInfos = initTimescale !== undefined
-                    ? extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, context.isLive)
-                    : null;
-                nextSegments = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.nextSegments;
-                chunkInfos = (_a = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.chunkInfos) !== null && _a !== void 0 ? _a : null;
-                if (chunkInfos === null) {
-                    if (isChunked) {
-                        log.warn("smooth", "Unavailable time data for current text track.");
-                    }
-                    else {
-                        segmentStart = segment.time;
-                        segmentEnd = segment.end;
-                    }
-                }
-                else {
-                    segmentStart = chunkInfos.time;
-                    segmentEnd =
-                        chunkInfos.duration !== undefined
-                            ? chunkInfos.time + chunkInfos.duration
-                            : segment.end;
-                }
-                const lcCodec = codecs.toLowerCase();
-                if (mimeType === "application/ttml+xml+mp4" ||
-                    lcCodec === "stpp" ||
-                    lcCodec === "stpp.ttml" ||
-                    lcCodec === "stpp.ttml.im1t") {
-                    _sdType = "ttml";
-                }
-                else if (lcCodec === "wvtt") {
-                    _sdType = "vtt";
-                }
-                else {
-                    throw new Error(`could not find a text-track parser for the type ${mimeType}`);
-                }
-                const mdat = getMDAT(chunkBytes);
-                _sdData = mdat === null ? "" : utf8ToStr(mdat);
-            }
-            else {
-                // not MP4
-                segmentStart = segment.time;
-                segmentEnd = segment.end;
-                let chunkString;
-                if (typeof data !== "string") {
-                    const bytesData = data instanceof Uint8Array ? data : new Uint8Array(data);
-                    chunkSize = bytesData.length;
-                    chunkString = utf8ToStr(bytesData);
-                }
-                else {
-                    chunkString = data;
-                }
-                switch (mimeType) {
-                    case "application/x-sami":
-                    case "application/smil": // TODO SMIL should be its own format, no?
-                        _sdType = "sami";
-                        break;
-                    case "application/ttml+xml":
-                        _sdType = "ttml";
-                        break;
-                    case "text/vtt":
-                        _sdType = "vtt";
-                        break;
-                }
-                if (_sdType === undefined) {
-                    const lcCodec = codecs.toLowerCase();
-                    if (lcCodec === "srt") {
-                        _sdType = "srt";
-                    }
-                    else {
-                        throw new Error(`could not find a text-track parser for the type ${mimeType}`);
-                    }
-                }
-                _sdData = chunkString;
-            }
-            const predictedSegments = Array.isArray(nextSegments) && nextSegments.length > 0 ? nextSegments : undefined;
-            const chunkOffset = segmentStart !== null && segmentStart !== void 0 ? segmentStart : 0;
-            return {
-                segmentType: "media",
-                chunkData: {
-                    type: _sdType,
-                    data: _sdData,
-                    start: segmentStart,
-                    end: segmentEnd,
-                    initTimescale: initTimescale !== null && initTimescale !== void 0 ? initTimescale : null,
-                    language,
-                },
-                chunkSize,
-                chunkInfos,
-                chunkOffset,
-                protectionData: [],
-                predictedSegments,
-                appendWindow: [undefined, undefined],
-            };
-        },
-    };
-    return {
-        transportName: "smooth",
-        manifest: manifestPipeline,
-        audio: audioVideoPipeline,
-        video: audioVideoPipeline,
-        text: textTrackPipeline,
-        thumbnails: {
-            loadThumbnail: () => Promise.reject(new Error("Thumbnail tracks aren't implemented with smooth")),
-            parseThumbnail: () => {
-                throw new Error("Thumbnail tracks aren't implemented with smooth");
-            },
-        },
-    };
-}

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

@@ -1,28 +0,0 @@
-/**
- * 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.
- */
-import type { ISegmentLoader as ICustomSegmentLoader } from "../../public_types";
-import type { CancellationSignal } from "../../utils/task_canceller";
-import type { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
-/**
- * Defines the url for the request, load the right loader (custom/default
- * one).
- */
-declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, segmentLoader, }: {
-    checkMediaSegmentIntegrity?: boolean | undefined;
-    segmentLoader?: ICustomSegmentLoader | undefined;
-}) => (url: string | null, context: ISegmentContext, loaderOptions: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array<ArrayBuffer> | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array<ArrayBuffer> | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array<ArrayBuffer> | ArrayBuffer | null>>;
-export default generateSegmentLoader;
-//# sourceMappingURL=segment_loader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"segment_loader.d.ts","sourceRoot":"","sources":["../../../../src/transports/smooth/segment_loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAGjF,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACxF,OAAO,KAAK,EACV,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,kCAAkC,EAClC,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAqElB;;;GAGG;AACH,QAAA,MAAM,qBAAqB,GACxB,gDAGE;IACD,0BAA0B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACjD,aAAa,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;CAClD,MAEC,KAAK,MAAM,GAAG,IAAI,EAClB,SAAS,eAAe,EACxB,eAAe,qBAAqB,EACpC,cAAc,kBAAkB,EAChC,WAAW,uBAAuB,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,KAC/E,OAAO,CACN,iCAAiC,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,GAC/E,kCAAkC,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CA2OnF,CAAC;AAEJ,eAAe,qBAAqB,CAAC"}

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

@@ -1,238 +0,0 @@
-/**
- * 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.
- */
-import { CustomLoaderError } from "../../errors";
-import assert from "../../utils/assert";
-import request from "../../utils/request";
-import addQueryString from "../utils/add_query_string";
-import byteRange from "../utils/byte_range";
-import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
-import isMP4EmbeddedTrack from "./is_mp4_embedded_track";
-import { createAudioInitSegment, createVideoInitSegment } from "./isobmff";
-/**
- * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} initialUrl
- * @param {Object} context
- * @param {Object} loaderOptions
- * @param {Object} callbacks
- * @param {Object} cancelSignal
- * @param {boolean} checkMediaSegmentIntegrity
- * @returns {Promise}
- */
-async function regularSegmentLoader(initialUrl, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
-    var _a, _b;
-    const cmcdHeaders = ((_a = loaderOptions.cmcdPayload) === null || _a === void 0 ? void 0 : _a.type) === "headers"
-        ? loaderOptions.cmcdPayload.value
-        : undefined;
-    const range = context.segment.range;
-    let headers;
-    if (Array.isArray(range)) {
-        headers = Object.assign(Object.assign({}, cmcdHeaders), { Range: byteRange(range) });
-    }
-    else if (cmcdHeaders !== undefined) {
-        headers = cmcdHeaders;
-    }
-    const url = ((_b = loaderOptions.cmcdPayload) === null || _b === void 0 ? void 0 : _b.type) === "query"
-        ? addQueryString(initialUrl, loaderOptions.cmcdPayload.value)
-        : initialUrl;
-    const data = await request({
-        url,
-        responseType: "arraybuffer",
-        headers,
-        timeout: loaderOptions.timeout,
-        connectionTimeout: loaderOptions.connectionTimeout,
-        cancelSignal,
-        onProgress: callbacks.onProgress,
-    });
-    const isMP4 = isMP4EmbeddedTrack(context.mimeType);
-    if (!isMP4 || checkMediaSegmentIntegrity !== true) {
-        return { resultType: "segment-loaded", resultData: data };
-    }
-    const dataU8 = new Uint8Array(data.responseData);
-    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
-    return {
-        resultType: "segment-loaded",
-        resultData: Object.assign(Object.assign({}, data), { responseData: dataU8 }),
-    };
-}
-/**
- * Defines the url for the request, load the right loader (custom/default
- * one).
- */
-const generateSegmentLoader = ({ checkMediaSegmentIntegrity, segmentLoader, }) => (url, context, loaderOptions, cancelSignal, callbacks) => {
-    const { segment } = context;
-    if (segment.isInit) {
-        if (segment.privateInfos === undefined ||
-            segment.privateInfos.smoothInitSegment === undefined) {
-            throw new Error("Smooth: Invalid segment format");
-        }
-        const smoothInitPrivateInfos = segment.privateInfos.smoothInitSegment;
-        let responseData;
-        const { codecPrivateData, timescale, height, width, protection = { keyId: undefined, keySystems: undefined }, } = smoothInitPrivateInfos;
-        if (codecPrivateData === undefined) {
-            throw new Error("Smooth: no codec private data.");
-        }
-        switch (context.type) {
-            case "video": {
-                responseData = createVideoInitSegment(timescale, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0, 72, 72, 4, // vRes, hRes, nal
-                codecPrivateData, protection.keyId);
-                break;
-            }
-            case "audio": {
-                const { channels = 0, bitsPerSample = 0, packetSize = 0, samplingRate = 0, } = smoothInitPrivateInfos;
-                responseData = createAudioInitSegment(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
-                break;
-            }
-            default:
-                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    assert(false, "responseData should have been set");
-                }
-                responseData = new Uint8Array(0);
-        }
-        return Promise.resolve({
-            resultType: "segment-created",
-            resultData: responseData,
-        });
-    }
-    else if (url === null) {
-        return Promise.resolve({
-            resultType: "segment-created",
-            resultData: null,
-        });
-    }
-    else {
-        if (typeof segmentLoader !== "function") {
-            return regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
-        }
-        return new Promise((res, rej) => {
-            /** `true` when the custom segmentLoader should not be active anymore. */
-            let hasFinished = false;
-            /**
-             * Callback triggered when the custom segment loader has a response.
-             * @param {Object} _args
-             */
-            const resolve = (_args) => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                let data;
-                if (_args.data instanceof Uint8Array) {
-                    if (_args.data.buffer instanceof ArrayBuffer) {
-                        // Typescript is not so smart here for now
-                        data = _args.data;
-                    }
-                    else {
-                        data = _args.data.slice();
-                    }
-                }
-                else {
-                    data = _args.data;
-                }
-                const isMP4 = isMP4EmbeddedTrack(context.mimeType);
-                if (!isMP4 || checkMediaSegmentIntegrity !== true) {
-                    res({
-                        resultType: "segment-loaded",
-                        resultData: {
-                            responseData: data,
-                            size: _args.size,
-                            requestDuration: _args.duration,
-                        },
-                    });
-                }
-                const dataU8 = data instanceof Uint8Array ? data : new Uint8Array(data);
-                checkISOBMFFIntegrity(dataU8, context.segment.isInit);
-                res({
-                    resultType: "segment-loaded",
-                    resultData: {
-                        responseData: dataU8,
-                        size: _args.size,
-                        requestDuration: _args.duration,
-                    },
-                });
-            };
-            /**
-             * Callback triggered when the custom segment loader fails
-             * @param {*} err - The corresponding error encountered
-             */
-            const reject = (err) => {
-                var _a, _b;
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                // Format error and send it
-                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 Smooth segment through a " +
-                    "custom segmentLoader.";
-                const 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);
-                rej(emittedErr);
-            };
-            const progress = (_args) => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                callbacks.onProgress({
-                    duration: _args.duration,
-                    size: _args.size,
-                    totalSize: _args.totalSize,
-                });
-            };
-            const fallback = () => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity).then(res, rej);
-            };
-            const customCallbacks = { reject, resolve, fallback, progress };
-            let byteRanges;
-            if (context.segment.range !== undefined) {
-                byteRanges = [context.segment.range];
-                if (context.segment.indexRange !== undefined) {
-                    byteRanges.push(context.segment.indexRange);
-                }
-            }
-            const args = {
-                isInit: context.segment.isInit,
-                timeout: loaderOptions.timeout,
-                byteRanges,
-                trackType: context.type,
-                url,
-                cmcdPayload: loaderOptions.cmcdPayload,
-            };
-            const abort = segmentLoader(args, customCallbacks);
-            cancelSignal.register(abortCustomLoader);
-            /**
-             * The logic to run when the custom loader is cancelled while pending.
-             * @param {Error} err
-             */
-            function abortCustomLoader(err) {
-                if (hasFinished) {
-                    return;
-                }
-                hasFinished = true;
-                if (!hasFinished && typeof abort === "function") {
-                    abort();
-                }
-                rej(err);
-            }
-        });
-    }
-};
-export default generateSegmentLoader;

package/dist/es2017/transports/smooth/utils.d.ts

@@ -1,27 +0,0 @@
-/**
- * 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.
- */
-import type { ISegment, IRepresentation } from "../../manifest";
-import type { ICdnMetadata } from "../../parsers/manifest";
-/**
- * Returns `true` if the given Representation refers to segments in an MP4
- * container
- * @param {Representation} representation
- * @returns {Boolean}
- */
-declare function isMP4EmbeddedTrack(representation: IRepresentation): boolean;
-declare function constructSegmentUrl(wantedCdn: ICdnMetadata | null, segment: ISegment): string | null;
-export { constructSegmentUrl, isMP4EmbeddedTrack };
-//# sourceMappingURL=utils.d.ts.map

package/dist/es2017/transports/smooth/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/transports/smooth/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG3D;;;;;GAKG;AACH,iBAAS,kBAAkB,CAAC,cAAc,EAAE,eAAe,GAAG,OAAO,CAKpE;AAED,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,YAAY,GAAG,IAAI,EAC9B,OAAO,EAAE,QAAQ,GAChB,MAAM,GAAG,IAAI,CAQf;AAED,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/es2017/transports/smooth/utils.js

@@ -1,36 +0,0 @@
-/**
- * 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.
- */
-import { resolveURL } from "../../utils/url-utils";
-/**
- * Returns `true` if the given Representation refers to segments in an MP4
- * container
- * @param {Representation} representation
- * @returns {Boolean}
- */
-function isMP4EmbeddedTrack(representation) {
-    return (typeof representation.mimeType === "string" &&
-        representation.mimeType.indexOf("mp4") >= 0);
-}
-function constructSegmentUrl(wantedCdn, segment) {
-    if (wantedCdn === null) {
-        return null;
-    }
-    if (segment.url === null) {
-        return wantedCdn.baseUrl;
-    }
-    return resolveURL(wantedCdn.baseUrl, segment.url);
-}
-export { constructSegmentUrl, isMP4EmbeddedTrack };