rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,24 +14,14 @@
  * 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);
-};
-import { CustomLoaderError } from "../../errors";
-import assert from "../../utils/assert";
-import request from "../../utils/request";
-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";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const assert_1 = require("../../utils/assert");
+const request_1 = require("../../utils/request");
+const byte_range_1 = require("../utils/byte_range");
+const check_isobmff_integrity_1 = require("../utils/check_isobmff_integrity");
+const is_mp4_embedded_track_1 = require("./is_mp4_embedded_track");
+const isobmff_1 = require("./isobmff");
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
@@ -42,163 +33,168 @@ import { createAudioInitSegment, createVideoInitSegment, } from "./isobmff";
  * @returns {Promise}
  */
 function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
-    var headers;
-    var range = context.segment.range;
+    let headers;
+    const range = context.segment.range;
     if (Array.isArray(range)) {
-        headers = { Range: byteRange(range) };
+        headers = { Range: (0, byte_range_1.default)(range) };
     }
-    return request({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-        .then(function (data) {
-        var isMP4 = isMP4EmbeddedTrack(context.mimeType);
+    return (0, request_1.default)({ url,
+        responseType: "arraybuffer",
+        headers,
+        timeout: loaderOptions.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress })
+        .then((data) => {
+        const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
         if (!isMP4 || checkMediaSegmentIntegrity !== true) {
             return { resultType: "segment-loaded",
                 resultData: data };
         }
-        var dataU8 = new Uint8Array(data.responseData);
-        checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+        const dataU8 = new Uint8Array(data.responseData);
+        (0, check_isobmff_integrity_1.default)(dataU8, context.segment.isInit);
         return { resultType: "segment-loaded",
-            resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
+            resultData: Object.assign(Object.assign({}, data), { responseData: dataU8 }) };
     });
 }
 /**
  * Defines the url for the request, load the right loader (custom/default
  * one).
  */
-var generateSegmentLoader = function (_a) {
-    var checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity, customSegmentLoader = _a.customSegmentLoader;
-    return function (url, context, loaderOptions, cancelSignal, callbacks) {
-        var segment = context.segment;
-        if (segment.isInit) {
-            if (segment.privateInfos === undefined ||
-                segment.privateInfos.smoothInitSegment === undefined) {
-                throw new Error("Smooth: Invalid segment format");
+const generateSegmentLoader = ({ checkMediaSegmentIntegrity, customSegmentLoader, }) => (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 = (0, isobmff_1.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;
             }
-            var smoothInitPrivateInfos = segment.privateInfos.smoothInitSegment;
-            var responseData = void 0;
-            var codecPrivateData = smoothInitPrivateInfos.codecPrivateData, timescale = smoothInitPrivateInfos.timescale, height = smoothInitPrivateInfos.height, width = smoothInitPrivateInfos.width, _a = smoothInitPrivateInfos.protection, protection = _a === void 0 ? { keyId: undefined,
-                keySystems: undefined } : _a;
-            if (codecPrivateData === undefined) {
-                throw new Error("Smooth: no codec private data.");
+            case "audio": {
+                const { channels = 0, bitsPerSample = 0, packetSize = 0, samplingRate = 0 } = smoothInitPrivateInfos;
+                responseData = (0, isobmff_1.createAudioInitSegment)(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
+                break;
             }
-            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": {
-                    var _b = smoothInitPrivateInfos.channels, channels = _b === void 0 ? 0 : _b, _c = smoothInitPrivateInfos.bitsPerSample, bitsPerSample = _c === void 0 ? 0 : _c, _d = smoothInitPrivateInfos.packetSize, packetSize = _d === void 0 ? 0 : _d, _e = smoothInitPrivateInfos.samplingRate, samplingRate = _e === void 0 ? 0 : _e;
-                    responseData = createAudioInitSegment(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
-                    break;
+            default:
+                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                    (0, assert_1.default)(false, "responseData should have been set");
                 }
-                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 });
+                responseData = new Uint8Array(0);
         }
-        else if (url === null) {
-            return Promise.resolve({ resultType: "segment-created",
-                resultData: null });
+        return Promise.resolve({ resultType: "segment-created",
+            resultData: responseData });
+    }
+    else if (url === null) {
+        return Promise.resolve({ resultType: "segment-created",
+            resultData: null });
+    }
+    else {
+        if (typeof customSegmentLoader !== "function") {
+            return regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
         }
-        else {
-            if (typeof customSegmentLoader !== "function") {
-                return regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
-            }
-            return new Promise(function (res, rej) {
-                /** `true` when the custom segmentLoader should not be active anymore. */
-                var hasFinished = false;
-                /**
-                 * Callback triggered when the custom segment loader has a response.
-                 * @param {Object} args
-                 */
-                var resolve = function (_args) {
-                    if (hasFinished || cancelSignal.isCancelled()) {
-                        return;
-                    }
-                    hasFinished = true;
-                    cancelSignal.deregister(abortCustomLoader);
-                    var isMP4 = isMP4EmbeddedTrack(context.mimeType);
-                    if (!isMP4 || checkMediaSegmentIntegrity !== true) {
-                        res({ resultType: "segment-loaded",
-                            resultData: { responseData: _args.data,
-                                size: _args.size,
-                                requestDuration: _args.duration } });
-                    }
-                    var dataU8 = _args.data instanceof Uint8Array ? _args.data :
-                        new Uint8Array(_args.data);
-                    checkISOBMFFIntegrity(dataU8, context.segment.isInit);
+        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);
+                const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
+                if (!isMP4 || checkMediaSegmentIntegrity !== true) {
                     res({ resultType: "segment-loaded",
-                        resultData: { responseData: dataU8,
+                        resultData: { responseData: _args.data,
                             size: _args.size,
                             requestDuration: _args.duration } });
-                };
-                /**
-                 * Callback triggered when the custom segment loader fails
-                 * @param {*} err - The corresponding error encountered
-                 */
-                var reject = function (err) {
-                    var _a, _b;
-                    if (hasFinished || cancelSignal.isCancelled()) {
-                        return;
-                    }
-                    hasFinished = true;
-                    cancelSignal.deregister(abortCustomLoader);
-                    // Format error and send it
-                    var castedErr = err;
-                    var message = (_a = castedErr === null || castedErr === void 0 ? void 0 : castedErr.message) !== null && _a !== void 0 ? _a : "Unknown error when fetching a Smooth 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);
-                    rej(emittedErr);
-                };
-                var progress = function (_args) {
-                    if (hasFinished || cancelSignal.isCancelled()) {
-                        return;
-                    }
-                    callbacks.onProgress({ duration: _args.duration,
+                }
+                const dataU8 = _args.data instanceof Uint8Array ? _args.data :
+                    new Uint8Array(_args.data);
+                (0, check_isobmff_integrity_1.default)(dataU8, context.segment.isInit);
+                res({ resultType: "segment-loaded",
+                    resultData: { responseData: dataU8,
                         size: _args.size,
-                        totalSize: _args.totalSize });
-                };
-                var fallback = function () {
-                    if (hasFinished || cancelSignal.isCancelled()) {
-                        return;
-                    }
-                    hasFinished = true;
-                    cancelSignal.deregister(abortCustomLoader);
-                    regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
-                        .then(res, rej);
-                };
-                var customCallbacks = { reject: reject, resolve: resolve, fallback: fallback, progress: progress };
-                var byteRanges;
-                if (context.segment.range !== undefined) {
-                    byteRanges = [context.segment.range];
-                    if (context.segment.indexRange !== undefined) {
-                        byteRanges.push(context.segment.indexRange);
-                    }
+                        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;
                 }
-                var args = { isInit: context.segment.isInit,
-                    timeout: loaderOptions.timeout, byteRanges: byteRanges, trackType: context.type, url: url };
-                var abort = customSegmentLoader(args, customCallbacks);
-                cancelSignal.register(abortCustomLoader);
-                /**
-                 * The logic to run when the custom loader is cancelled while pending.
-                 * @param {Error} err
-                 */
-                function abortCustomLoader(err) {
-                    if (hasFinished) {
-                        return;
-                    }
-                    hasFinished = true;
-                    if (!hasFinished && typeof abort === "function") {
-                        abort();
-                    }
-                    rej(err);
+                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 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);
+            };
+            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 };
+            const abort = customSegmentLoader(args, customCallbacks);
+            cancelSignal.register(abortCustomLoader);
+            /**
+             * The logic to run when the custom loader is cancelled while pending.
+             * @param {Error} err
+             */
+            function abortCustomLoader(err) {
+                if (hasFinished) {
+                    return;
+                }
+                hasFinished = true;
+                if (!hasFinished && typeof abort === "function") {
+                    abort();
+                }
+                rej(err);
+            }
+        });
+    }
 };
-export default generateSegmentLoader;
+exports.default = generateSegmentLoader;

package/dist/_esm5.processed/transports/smooth/utils.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import resolveURL from "../../utils/resolve_url";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMP4EmbeddedTrack = exports.constructSegmentUrl = void 0;
+const resolve_url_1 = require("../../utils/resolve_url");
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
@@ -24,9 +27,10 @@ function isMP4EmbeddedTrack(representation) {
     return typeof representation.mimeType === "string" &&
         representation.mimeType.indexOf("mp4") >= 0;
 }
+exports.isMP4EmbeddedTrack = isMP4EmbeddedTrack;
 function constructSegmentUrl(wantedCdn, segment) {
     return wantedCdn === null ? null :
         segment.url === null ? wantedCdn.baseUrl :
-            resolveURL(wantedCdn.baseUrl, segment.url);
+            (0, resolve_url_1.default)(wantedCdn.baseUrl, segment.url);
 }
-export { constructSegmentUrl, isMP4EmbeddedTrack, };
+exports.constructSegmentUrl = constructSegmentUrl;

package/dist/_esm5.processed/transports/types.d.ts

@@ -16,7 +16,7 @@
 import { IInbandEvent } from "../core/stream";
 import Manifest, { ISegment } from "../manifest";
 import { ICdnMetadata } from "../parsers/manifest";
-import { ITrackType, ILoadedManifestFormat, IManifestLoader, IRepresentationFilter, ISegmentLoader as ICustomSegmentLoader, IServerSyncInfos } from "../public_types";
+import { ITrackType, ILoadedManifestFormat, IManifestLoader, IRepresentationFilter, ISegmentLoader as ICustomSegmentLoader, IServerSyncInfos, IPlayerError } from "../public_types";
 import TaskCanceller, { CancellationSignal } from "../utils/task_canceller";
 /**
  * Interface returned by any transport implementation.
@@ -214,8 +214,8 @@ initTimescale: number | undefined) =>
 ISegmentParserParsedInitChunk<TParsedSegmentDataFormat> | ISegmentParserParsedMediaChunk<TParsedSegmentDataFormat>;
 export interface IManifestParserOptions {
     /**
-     * If set, offset to add to `performance.now()` to obtain the current
-     * server's time.
+     * If set, offset to add to the used monotonically-raising timestamp (common
+     * to the RxPlayer's code), to obtain the current server's time.
      */
     externalClockOffset: number | undefined;
     /** Original URL used for the full version of the Manifest. */
@@ -283,6 +283,11 @@ export type IManifestParserRequestScheduler = (performRequest: () => Promise<IRe
 export interface IManifestParserResult {
     /** The parsed Manifest Object itself. */
     manifest: Manifest;
+    /**
+     * Minor issues seen while constructing the Manifest object.
+     * Empty if no issue was seen.
+     */
+    warnings: IPlayerError[];
     /**
      * "Real" URL (post-redirection) at which the Manifest can be refreshed.
      *
@@ -479,13 +484,15 @@ export interface IChunkCompleteInformation {
      */
     url?: string | undefined;
     /**
-     * Time at which the request began in terms of `performance.now`.
+     * Time at which the request began in terms of the monotonically-raising
+     * timestamp used by the RxPlayer.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the first request made.
      */
     sendingTime?: number | undefined;
     /**
-     * Time at which the request ended in terms of `performance.now`.
+     * Time at which the request ended in terms of the monotonically-raising
+     * timestamp used by the RxPlayer.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the last request to end.
      */
@@ -665,13 +672,15 @@ export interface IRequestedData<T> {
      */
     url?: string | undefined;
     /**
-     * Time at which the request began in terms of `performance.now`.
+     * Time at which the request began in terms of the monotonically-raising
+     * timestamp used by the RxPlayer.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the first request made.
      */
     sendingTime?: number | undefined;
     /**
-     * Time at which the request ended in terms of `performance.now`.
+     * Time at which the request ended in terms of the monotonically-raising
+     * timestamp used by the RxPlayer.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the last request to end.
      */
@@ -683,10 +692,10 @@ export interface ITransportOptions {
     checkMediaSegmentIntegrity?: boolean | undefined;
     lowLatencyMode: boolean;
     manifestLoader?: IManifestLoader | undefined;
-    manifestUpdateUrl?: string | undefined;
     referenceDateTime?: number | undefined;
     representationFilter?: IRepresentationFilter | undefined;
     segmentLoader?: ICustomSegmentLoader | undefined;
     serverSyncInfos?: IServerSyncInfos | undefined;
+    __priv_manifestUpdateUrl?: string | undefined;
     __priv_patchLastSegmentInSidx?: boolean | undefined;
 }

package/dist/_esm5.processed/transports/types.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/_esm5.processed/transports/utils/byte_range.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,13 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Returns text-formatted byteRange (`bytes=$start-$end?)`
  * @param {Array.<string|Number>} arr
  * @returns {string}
  */
-export default function byteRange(_a) {
-    var start = _a[0], end = _a[1];
-    return end === Infinity ? "bytes=".concat(start, "-") :
-        "bytes=".concat(start, "-").concat(end);
+function byteRange([start, end]) {
+    return end === Infinity ? `bytes=${start}-` :
+        `bytes=${start}-${end}`;
 }
+exports.default = byteRange;

package/dist/_esm5.processed/transports/utils/call_custom_manifest_loader.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,37 +14,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CustomLoaderError } from "../../errors";
-export default function callCustomManifestLoader(customManifestLoader, fallbackManifestLoader) {
-    return function (url, loaderOptions, cancelSignal) {
-        return new Promise(function (res, rej) {
-            var timeAPIsDelta = Date.now() - performance.now();
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+function callCustomManifestLoader(customManifestLoader, fallbackManifestLoader) {
+    return (url, loaderOptions, cancelSignal) => {
+        return new Promise((res, rej) => {
+            const timeAPIsDelta = Date.now() - (0, monotonic_timestamp_1.default)();
             /** `true` when the custom segmentLoader should not be active anymore. */
-            var hasFinished = false;
+            let hasFinished = false;
             /**
              * Callback triggered when the custom manifest loader has a response.
              * @param {Object} args
              */
-            var resolve = function (_args) {
+            const resolve = (_args) => {
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
                 hasFinished = true;
                 cancelSignal.deregister(abortCustomLoader);
-                var receivedTime = _args.receivingTime !== undefined ? _args.receivingTime - timeAPIsDelta :
+                const receivedTime = _args.receivingTime !== undefined ? _args.receivingTime - timeAPIsDelta :
                     undefined;
-                var sendingTime = _args.sendingTime !== undefined ? _args.sendingTime - timeAPIsDelta :
+                const sendingTime = _args.sendingTime !== undefined ? _args.sendingTime - timeAPIsDelta :
                     undefined;
                 res({ responseData: _args.data,
                     size: _args.size,
                     requestDuration: _args.duration,
-                    url: _args.url, receivedTime: receivedTime, sendingTime: sendingTime });
+                    url: _args.url,
+                    receivedTime, sendingTime });
             };
             /**
              * Callback triggered when the custom manifest loader fails
              * @param {*} err - The corresponding error encountered
              */
-            var reject = function (err) {
+            const reject = (err) => {
                 var _a, _b;
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
@@ -51,17 +55,17 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
                 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 the Manifest 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 the Manifest through a " +
                     "custom manifestLoader.";
-                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);
             };
             /**
              * Callback triggered when the custom manifest loader wants to fallback to
              * the "regular" implementation
              */
-            var fallback = function () {
+            const fallback = () => {
                 if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
@@ -69,8 +73,9 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
                 cancelSignal.deregister(abortCustomLoader);
                 fallbackManifestLoader(url, loaderOptions, cancelSignal).then(res, rej);
             };
-            var callbacks = { reject: reject, resolve: resolve, fallback: fallback };
-            var abort = customManifestLoader({ url: url, timeout: loaderOptions.timeout }, callbacks);
+            const callbacks = { reject, resolve, fallback };
+            const abort = customManifestLoader({ url,
+                timeout: loaderOptions.timeout }, callbacks);
             cancelSignal.register(abortCustomLoader);
             /**
              * The logic to run when the custom loader is cancelled while pending.
@@ -89,3 +94,4 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
         });
     };
 }
+exports.default = callCustomManifestLoader;

package/dist/_esm5.processed/transports/utils/check_isobmff_integrity.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { OtherError } from "../../errors";
-import findCompleteBox from "./find_complete_box";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const find_complete_box_1 = require("./find_complete_box");
 /**
  * Check if an ISOBMFF segment has all the right box needed to be decoded.
  * Throw if that's not the case.
@@ -22,25 +24,26 @@ import findCompleteBox from "./find_complete_box";
  * @param {boolean} isInitSegment - `true` if this is an initialization segment,
  * `false` otherwise.
  */
-export default function checkISOBMFFIntegrity(buffer, isInitSegment) {
+function checkISOBMFFIntegrity(buffer, isInitSegment) {
     if (isInitSegment) {
-        var ftypIndex = findCompleteBox(buffer, 0x66747970 /* ftyp */);
+        const ftypIndex = (0, find_complete_box_1.default)(buffer, 0x66747970 /* ftyp */);
         if (ftypIndex < 0) {
-            throw new OtherError("INTEGRITY_ERROR", "Incomplete `ftyp` box");
+            throw new errors_1.OtherError("INTEGRITY_ERROR", "Incomplete `ftyp` box");
         }
-        var moovIndex = findCompleteBox(buffer, 0x6D6F6F76 /* moov */);
+        const moovIndex = (0, find_complete_box_1.default)(buffer, 0x6D6F6F76 /* moov */);
         if (moovIndex < 0) {
-            throw new OtherError("INTEGRITY_ERROR", "Incomplete `moov` box");
+            throw new errors_1.OtherError("INTEGRITY_ERROR", "Incomplete `moov` box");
         }
     }
     else {
-        var moofIndex = findCompleteBox(buffer, 0x6D6F6F66 /* moof */);
+        const moofIndex = (0, find_complete_box_1.default)(buffer, 0x6D6F6F66 /* moof */);
         if (moofIndex < 0) {
-            throw new OtherError("INTEGRITY_ERROR", "Incomplete `moof` box");
+            throw new errors_1.OtherError("INTEGRITY_ERROR", "Incomplete `moof` box");
         }
-        var mdatIndex = findCompleteBox(buffer, 0x6D646174 /* mdat */);
+        const mdatIndex = (0, find_complete_box_1.default)(buffer, 0x6D646174 /* mdat */);
         if (mdatIndex < 0) {
-            throw new OtherError("INTEGRITY_ERROR", "Incomplete `mdat` box");
+            throw new errors_1.OtherError("INTEGRITY_ERROR", "Incomplete `mdat` box");
         }
     }
 }
+exports.default = checkISOBMFFIntegrity;