rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/commonjs/core/fetchers/manifest/manifest_fetcher.js

@@ -80,7 +80,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../config");
 var errors_1 = require("../../../errors");
 var log_1 = require("../../../log");
-var manifest_1 = require("../../../manifest");
+var classes_1 = require("../../../manifest/classes");
 var event_emitter_1 = require("../../../utils/event_emitter");
 var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
 var noop_1 = require("../../../utils/noop");
@@ -142,15 +142,14 @@ var ManifestFetcher = /** @class */ (function (_super) {
         this._isStarted = true;
         var manifestProm;
         var initialManifest = this._settings.initialManifest;
-        if (initialManifest instanceof manifest_1.default) {
+        if (initialManifest instanceof classes_1.default) {
             manifestProm = Promise.resolve({ manifest: initialManifest });
         }
         else if (initialManifest !== undefined) {
             manifestProm = this.parse(initialManifest, { previousManifest: null, unsafeMode: false }, undefined);
         }
         else {
-            manifestProm = this._fetchManifest(undefined)
-                .then(function (val) {
+            manifestProm = this._fetchManifest(undefined).then(function (val) {
                 return val.parse({ previousManifest: null, unsafeMode: false });
             });
         }
@@ -205,22 +204,24 @@ var ManifestFetcher = /** @class */ (function (_super) {
              */
             function callLoaderWithRetries(manifestUrl) {
                 var loadManifest = pipelines.loadManifest;
-                var requestTimeout = (settings.requestTimeout === undefined) ?
-                    config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT :
-                    settings.requestTimeout;
-                var connectionTimeout = (settings.connectionTimeout === undefined) ?
-                    config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT :
-                    settings.connectionTimeout;
+                var requestTimeout = settings.requestTimeout === undefined
+                    ? config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT
+                    : settings.requestTimeout;
+                var connectionTimeout = settings.connectionTimeout === undefined
+                    ? config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT
+                    : settings.connectionTimeout;
                 if (requestTimeout < 0) {
                     requestTimeout = undefined;
                 }
                 if (connectionTimeout < 0) {
                     connectionTimeout = undefined;
                 }
-                var callLoader = function () { return loadManifest(manifestUrl, {
-                    timeout: requestTimeout,
-                    connectionTimeout: connectionTimeout,
-                }, cancelSignal); };
+                var callLoader = function () {
+                    return loadManifest(manifestUrl, {
+                        timeout: requestTimeout,
+                        connectionTimeout: connectionTimeout,
+                    }, cancelSignal);
+                };
                 return (0, schedule_request_1.scheduleRequestPromise)(callLoader, backoffSettings, cancelSignal);
             }
             var cancelSignal, settings, pipelines, requestUrl, backoffSettings, response_1, err_1;
@@ -267,9 +268,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
      * @returns {Promise}
      */
     ManifestFetcher.prototype.parse = function (manifest, parserOptions, originalUrl) {
-        return this._parseLoadedManifest({ responseData: manifest,
-            size: undefined,
-            requestDuration: undefined }, parserOptions, originalUrl);
+        return this._parseLoadedManifest({ responseData: manifest, size: undefined, requestDuration: undefined }, parserOptions, originalUrl);
     };
     /**
      * Parse a Manifest.
@@ -359,9 +358,12 @@ var ManifestFetcher = /** @class */ (function (_super) {
                             _this.trigger("warning", (0, error_selector_1.default)(err));
                         });
                         originalUrl = requestUrl !== null && requestUrl !== void 0 ? requestUrl : (_a = this._manifestUrls) === null || _a === void 0 ? void 0 : _a[0];
-                        opts = { externalClockOffset: parserOptions.externalClockOffset,
+                        opts = {
+                            externalClockOffset: parserOptions.externalClockOffset,
                             unsafeMode: parserOptions.unsafeMode,
-                            previousManifest: parserOptions.previousManifest, originalUrl: originalUrl };
+                            previousManifest: parserOptions.previousManifest,
+                            originalUrl: originalUrl,
+                        };
                         _c.label = 1;
                     case 1:
                         _c.trys.push([1, 5, , 6]);
@@ -394,10 +396,12 @@ var ManifestFetcher = /** @class */ (function (_super) {
     ManifestFetcher.prototype._getBackoffSetting = function (onRetry) {
         var _a = config_1.default.getCurrent(), DEFAULT_MAX_MANIFEST_REQUEST_RETRY = _a.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, INITIAL_BACKOFF_DELAY_BASE = _a.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _a.MAX_BACKOFF_DELAY_BASE;
         var _b = this._settings, lowLatencyMode = _b.lowLatencyMode, ogRegular = _b.maxRetry;
-        var baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            INITIAL_BACKOFF_DELAY_BASE.REGULAR;
-        var maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR;
+        var baseDelay = lowLatencyMode
+            ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : INITIAL_BACKOFF_DELAY_BASE.REGULAR;
+        var maxDelay = lowLatencyMode
+            ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : MAX_BACKOFF_DELAY_BASE.REGULAR;
         var maxRetry = ogRegular !== null && ogRegular !== void 0 ? ogRegular : DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
         return { onRetry: onRetry, baseDelay: baseDelay, maxDelay: maxDelay, maxRetry: maxRetry };
     };
@@ -415,9 +419,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
          * Total time taken to fully update the last Manifest, in milliseconds.
          * Note: this time also includes possible requests done by the parsers.
          */
-        var totalUpdateTime = parsingTime !== undefined ?
-            parsingTime + (updatingTime !== null && updatingTime !== void 0 ? updatingTime : 0) :
-            undefined;
+        var totalUpdateTime = parsingTime !== undefined ? parsingTime + (updatingTime !== null && updatingTime !== void 0 ? updatingTime : 0) : undefined;
         /**
          * "unsafeMode" is a mode where we unlock advanced Manifest parsing
          * optimizations with the added risk to lose some information.
@@ -426,18 +428,19 @@ var ManifestFetcher = /** @class */ (function (_super) {
          * Only perform parsing in `unsafeMode` when the last full parsing took a
          * lot of time and do not go higher than the maximum consecutive time.
          */
-        var unsafeModeEnabled = this._consecutiveUnsafeMode > 0 ?
-            this._consecutiveUnsafeMode < MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE :
-            totalUpdateTime !== undefined ?
-                (totalUpdateTime >= MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE) :
-                false;
+        var unsafeModeEnabled = false;
+        if (this._consecutiveUnsafeMode > 0) {
+            unsafeModeEnabled =
+                this._consecutiveUnsafeMode < MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE;
+        }
+        else if (totalUpdateTime !== undefined) {
+            unsafeModeEnabled =
+                totalUpdateTime >= MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE;
+        }
         /** Time elapsed since the beginning of the Manifest request, in milliseconds. */
-        var timeSinceRequest = sendingTime === undefined ?
-            0 :
-            (0, monotonic_timestamp_1.default)() - sendingTime;
+        var timeSinceRequest = sendingTime === undefined ? 0 : (0, monotonic_timestamp_1.default)() - sendingTime;
         /** Minimum update delay we should not go below, in milliseconds. */
-        var minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
-            timeSinceRequest, 0);
+        var minInterval = Math.max(this._settings.minimumManifestUpdateInterval - timeSinceRequest, 0);
         /**
          * Multiple refresh trigger are scheduled here, but only the first one should
          * be effectively considered.
@@ -451,14 +454,14 @@ var ManifestFetcher = /** @class */ (function (_super) {
             var unsafeMode = canUseUnsafeMode && unsafeModeEnabled;
             // The value allows to set a delay relatively to the last Manifest refresh
             // (to avoid asking for it too often).
-            var timeSinceLastRefresh = sendingTime === undefined ?
-                0 :
-                (0, monotonic_timestamp_1.default)() - sendingTime;
-            var _minInterval = Math.max(_this._settings.minimumManifestUpdateInterval -
-                timeSinceLastRefresh, 0);
+            var timeSinceLastRefresh = sendingTime === undefined ? 0 : (0, monotonic_timestamp_1.default)() - sendingTime;
+            var _minInterval = Math.max(_this._settings.minimumManifestUpdateInterval - timeSinceLastRefresh, 0);
             var timeoutId = setTimeout(function () {
                 nextRefreshCanceller.cancel();
-                _this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: enablePartialRefresh, unsafeMode: unsafeMode });
+                _this._triggerNextManifestRefresh(manifest, {
+                    enablePartialRefresh: enablePartialRefresh,
+                    unsafeMode: unsafeMode,
+                });
             }, Math.max((delay !== null && delay !== void 0 ? delay : 0) - timeSinceLastRefresh, _minInterval));
             nextRefreshCanceller.signal.register(function () {
                 clearTimeout(timeoutId);
@@ -470,8 +473,10 @@ var ManifestFetcher = /** @class */ (function (_super) {
                 var _a;
                 (_a = manifest.expired) === null || _a === void 0 ? void 0 : _a.then(function () {
                     nextRefreshCanceller.cancel();
-                    _this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: false,
-                        unsafeMode: unsafeModeEnabled });
+                    _this._triggerNextManifestRefresh(manifest, {
+                        enablePartialRefresh: false,
+                        unsafeMode: unsafeModeEnabled,
+                    });
                 }, noop_1.default /* `expired` should not reject */);
             }, minInterval);
             nextRefreshCanceller.signal.register(function () {
@@ -524,8 +529,10 @@ var ManifestFetcher = /** @class */ (function (_super) {
             }
             var timeoutId_2 = setTimeout(function () {
                 nextRefreshCanceller.cancel();
-                _this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: false,
-                    unsafeMode: unsafeModeEnabled });
+                _this._triggerNextManifestRefresh(manifest, {
+                    enablePartialRefresh: false,
+                    unsafeMode: unsafeModeEnabled,
+                });
             }, Math.max(actualRefreshInterval, minInterval));
             nextRefreshCanceller.signal.register(function () {
                 clearTimeout(timeoutId_2);
@@ -552,18 +559,19 @@ var ManifestFetcher = /** @class */ (function (_super) {
         }
         else {
             fullRefresh = !enablePartialRefresh || manifestUpdateUrl === undefined;
-            refreshURL = fullRefresh ? manifest.getUrls()[0] :
-                manifestUpdateUrl;
+            refreshURL = fullRefresh ? manifest.getUrls()[0] : manifestUpdateUrl;
         }
         var externalClockOffset = manifest.clockOffset;
         if (unsafeMode) {
             this._consecutiveUnsafeMode += 1;
-            log_1.default.info("Init: Refreshing the Manifest in \"unsafeMode\" for the " +
-                String(this._consecutiveUnsafeMode) + " consecutive time.");
+            log_1.default.info('Init: Refreshing the Manifest in "unsafeMode" for the ' +
+                String(this._consecutiveUnsafeMode) +
+                " consecutive time.");
         }
         else if (this._consecutiveUnsafeMode > 0) {
-            log_1.default.info("Init: Not parsing the Manifest in \"unsafeMode\" anymore after " +
-                String(this._consecutiveUnsafeMode) + " consecutive times.");
+            log_1.default.info('Init: Not parsing the Manifest in "unsafeMode" anymore after ' +
+                String(this._consecutiveUnsafeMode) +
+                " consecutive times.");
             this._consecutiveUnsafeMode = 0;
         }
         if (this._isRefreshPending) {
@@ -571,7 +579,13 @@ var ManifestFetcher = /** @class */ (function (_super) {
         }
         this._isRefreshPending = true;
         this._fetchManifest(refreshURL)
-            .then(function (res) { return res.parse({ externalClockOffset: externalClockOffset, previousManifest: manifest, unsafeMode: unsafeMode }); })
+            .then(function (res) {
+            return res.parse({
+                externalClockOffset: externalClockOffset,
+                previousManifest: manifest,
+                unsafeMode: unsafeMode,
+            });
+        })
             .then(function (res) {
             _this._isRefreshPending = false;
             var newManifest = res.manifest, newSendingTime = res.sendingTime, parsingTime = res.parsingTime;
@@ -584,24 +598,21 @@ var ManifestFetcher = /** @class */ (function (_super) {
                     manifest.update(newManifest);
                 }
                 catch (e) {
-                    var message = e instanceof Error ? e.message :
-                        "unknown error";
+                    var message = e instanceof Error ? e.message : "unknown error";
                     log_1.default.warn("MUS: Attempt to update Manifest failed: ".concat(message), "Re-downloading the Manifest fully");
                     var FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY = config_1.default.getCurrent().FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY;
                     // The value allows to set a delay relatively to the last Manifest refresh
                     // (to avoid asking for it too often).
-                    var timeSinceLastRefresh = newSendingTime === undefined ?
-                        0 :
-                        (0, monotonic_timestamp_1.default)() - newSendingTime;
-                    var _minInterval = Math.max(_this._settings.minimumManifestUpdateInterval -
-                        timeSinceLastRefresh, 0);
+                    var timeSinceLastRefresh = newSendingTime === undefined ? 0 : (0, monotonic_timestamp_1.default)() - newSendingTime;
+                    var _minInterval = Math.max(_this._settings.minimumManifestUpdateInterval - timeSinceLastRefresh, 0);
                     var unregisterCanceller_1 = noop_1.default;
                     var timeoutId_3 = setTimeout(function () {
                         unregisterCanceller_1();
-                        _this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: false,
-                            unsafeMode: false });
-                    }, Math.max(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY -
-                        timeSinceLastRefresh, _minInterval));
+                        _this._triggerNextManifestRefresh(manifest, {
+                            enablePartialRefresh: false,
+                            unsafeMode: false,
+                        });
+                    }, Math.max(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY - timeSinceLastRefresh, _minInterval));
                     unregisterCanceller_1 = _this._canceller.signal.register(function () {
                         clearTimeout(timeoutId_3);
                     });
@@ -609,7 +620,11 @@ var ManifestFetcher = /** @class */ (function (_super) {
                 }
             }
             var updatingTime = (0, monotonic_timestamp_1.default)() - updateTimeStart;
-            _this._recursivelyRefreshManifest(manifest, { sendingTime: newSendingTime, parsingTime: parsingTime, updatingTime: updatingTime });
+            _this._recursivelyRefreshManifest(manifest, {
+                sendingTime: newSendingTime,
+                parsingTime: parsingTime,
+                updatingTime: updatingTime,
+            });
         })
             .catch(function (err) {
             _this._isRefreshPending = false;

package/dist/commonjs/core/fetchers/segment/index.d.ts

@@ -16,4 +16,4 @@
 import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
 import SegmentFetcherCreator, { ISegmentFetcherCreatorBackoffOptions } from "./segment_fetcher_creator";
 export default SegmentFetcherCreator;
-export { IPrioritizedSegmentFetcher, ISegmentFetcherCreatorBackoffOptions, };
+export { IPrioritizedSegmentFetcher, ISegmentFetcherCreatorBackoffOptions };

package/dist/commonjs/core/fetchers/segment/initialization_segment_cache.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ISegment, Representation } from "../../../manifest";
+import type { ISegment, IRepresentation } from "../../../manifest";
 /**
  * Caching object used to cache initialization segments.
  * This allow to have a faster representation switch and faster seeking.
@@ -27,15 +27,15 @@ declare class InitializationSegmentCache<T> {
      * @param {*} response
      */
     add({ representation, segment }: {
-        representation: Representation;
+        representation: IRepresentation;
         segment: ISegment;
     }, response: T): void;
     /**
      * @param {Object} obj
      * @returns {*} response
      */
-    get({ representation, segment }: {
-        representation: Representation;
+    get({ representation, segment, }: {
+        representation: IRepresentation;
         segment: ISegment;
     }): T | null;
 }

package/dist/commonjs/core/fetchers/segment/prioritized_segment_fetcher.d.ts

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { ISegmentFetcher, ISegmentFetcherCallbacks, ISegmentLoaderContent } from "./segment_fetcher";
-import TaskPrioritizer, { ITaskPrioritizerCallbacks } from "./task_prioritizer";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { ISegmentFetcher, ISegmentFetcherCallbacks, ISegmentLoaderContent } from "./segment_fetcher";
+import type { ITaskPrioritizerCallbacks } from "./task_prioritizer";
+import type TaskPrioritizer from "./task_prioritizer";
 /**
  * This function basically put in relation:
  *   - an `ISegmentFetcher`, which will be used to perform the segment requests

package/dist/commonjs/core/fetchers/segment/segment_fetcher.d.ts

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { IPlayerError } from "../../../public_types";
-import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegmentPipeline } from "../../../transports";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IMetricsCallbackPayload, IRequestBeginCallbackPayload, IRequestEndCallbackPayload, IRequestProgressCallbackPayload } from "../../adaptive";
-import { IBufferType } from "../../segment_buffers";
-import CdnPrioritizer from "../cdn_prioritizer";
+import type { IManifest, IAdaptation, ISegment, IPeriod, IRepresentation } from "../../../manifest";
+import type { IPlayerError } from "../../../public_types";
+import type { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegmentPipeline } from "../../../transports";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IMetricsCallbackPayload, IRequestBeginCallbackPayload, IRequestEndCallbackPayload, IRequestProgressCallbackPayload } from "../../adaptive";
+import type { IBufferType } from "../../segment_sinks";
+import type CdnPrioritizer from "../cdn_prioritizer";
 /**
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
  * segments.
@@ -84,10 +84,10 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
 }
 /** Content used by the segment loader as a context to load a new segment. */
 export interface ISegmentLoaderContent {
-    manifest: Manifest;
-    period: Period;
-    adaptation: Adaptation;
-    representation: Representation;
+    manifest: IManifest;
+    period: IPeriod;
+    adaptation: IAdaptation;
+    representation: IRepresentation;
     segment: ISegment;
 }
 /**
@@ -147,7 +147,7 @@ export interface ISegmentFetcherOptions {
  * @param {Object}
  * @returns {Object}
  */
-export declare function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout }: {
+export declare function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout, }: {
     maxRetry?: number | undefined;
     requestTimeout?: number | undefined;
     connectionTimeout?: number | undefined;

package/dist/commonjs/core/fetchers/segment/segment_fetcher.js

@@ -92,20 +92,25 @@ var generateRequestID = (0, id_generator_1.default)();
  * @returns {Function}
  */
 function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
+    var connectionTimeout;
+    if (options.connectionTimeout === undefined || options.connectionTimeout < 0) {
+        connectionTimeout = undefined;
+    }
+    else {
+        connectionTimeout = options.connectionTimeout;
+    }
     var requestOptions = {
-        timeout: options.requestTimeout < 0 ? undefined :
-            options.requestTimeout,
-        connectionTimeout: options.connectionTimeout === undefined ? undefined :
-            options.connectionTimeout < 0 ? undefined : options.connectionTimeout,
+        timeout: options.requestTimeout < 0 ? undefined : options.requestTimeout,
+        connectionTimeout: connectionTimeout,
     };
     /**
      * Cache audio and video initialization segments.
      * This allows to avoid doing too many requests for what are usually very
      * small files.
      */
-    var cache = (0, array_includes_1.default)(["audio", "video"], bufferType) ?
-        new initialization_segment_cache_1.default() :
-        undefined;
+    var cache = (0, array_includes_1.default)(["audio", "video"], bufferType)
+        ? new initialization_segment_cache_1.default()
+        : undefined;
     var loadSegment = pipeline.loadSegment, parseSegment = pipeline.parseSegment;
     /**
      * Fetch a specific segment.
@@ -148,20 +153,23 @@ function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCal
                     try {
                         var parsed = parseSegment(loaded, context, initTimescale);
                         if (!parsedChunks[parsedChunkId]) {
-                            segmentDurationAcc = segmentDurationAcc !== undefined &&
-                                parsed.segmentType === "media" &&
-                                parsed.chunkInfos !== null &&
-                                parsed.chunkInfos.duration !== undefined ?
-                                segmentDurationAcc + parsed.chunkInfos.duration :
-                                undefined;
+                            segmentDurationAcc =
+                                segmentDurationAcc !== undefined &&
+                                    parsed.segmentType === "media" &&
+                                    parsed.chunkInfos !== null &&
+                                    parsed.chunkInfos.duration !== undefined
+                                    ? segmentDurationAcc + parsed.chunkInfos.duration
+                                    : undefined;
                             parsedChunks[parsedChunkId] = true;
                             sendNetworkMetricsIfAvailable();
                         }
                         return parsed;
                     }
                     catch (error) {
-                        throw (0, errors_1.formatError)(error, { defaultCode: "PIPELINE_PARSE_ERROR",
-                            defaultReason: "Unknown parsing error" });
+                        throw (0, errors_1.formatError)(error, {
+                            defaultCode: "PIPELINE_PARSE_ERROR",
+                            defaultReason: "Unknown parsing error",
+                        });
                     }
                 };
             }
@@ -205,14 +213,17 @@ function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCal
                         parsedChunks = [];
                         segmentDurationAcc = 0;
                         metricsSent = false;
-                        context = { segment: segment, type: adaptation.type,
+                        context = {
+                            segment: segment,
+                            type: adaptation.type,
                             language: adaptation.language,
                             isLive: manifest.isLive,
                             periodStart: period.start,
                             periodEnd: period.end,
                             mimeType: representation.mimeType,
                             codecs: representation.codecs[0],
-                            manifestPublishTime: manifest.publishTime };
+                            manifestPublishTime: manifest.publishTime,
+                        };
                         loaderCallbacks = {
                             /**
                              * Callback called when the segment loader has progress information on
@@ -225,11 +236,13 @@ function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCal
                                     return; // request already termminated
                                 }
                                 if (info.totalSize !== undefined && info.size < info.totalSize) {
-                                    (_a = lifecycleCallbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { duration: info.duration,
+                                    (_a = lifecycleCallbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
+                                        duration: info.duration,
                                         size: info.size,
                                         totalSize: info.totalSize,
                                         timestamp: (0, monotonic_timestamp_1.default)(),
-                                        id: requestId });
+                                        id: requestId,
+                                    });
                                 }
                             },
                             /**
@@ -242,16 +255,18 @@ function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCal
                                 fetcherCallbacks.onChunk(generateParserFunction(chunkData, true));
                             },
                         };
-                        cached = cache !== undefined ? cache.get(content) :
-                            null;
+                        cached = cache !== undefined ? cache.get(content) : null;
                         if (cached !== null) {
                             log_1.default.debug("SF: Found wanted segment in cache", segmentIdString);
                             fetcherCallbacks.onChunk(generateParserFunction(cached, false));
                             return [2 /*return*/, Promise.resolve()];
                         }
                         log_1.default.debug("SF: Beginning request", segmentIdString);
-                        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: (0, monotonic_timestamp_1.default)(),
-                            id: requestId, content: content });
+                        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
+                            requestTimestamp: (0, monotonic_timestamp_1.default)(),
+                            id: requestId,
+                            content: content,
+                        });
                         cancellationSignal.register(onCancellation);
                         _d.label = 1;
                     case 1:
@@ -312,14 +327,16 @@ exports.default = createSegmentFetcher;
 function getSegmentFetcherOptions(_a) {
     var maxRetry = _a.maxRetry, lowLatencyMode = _a.lowLatencyMode, requestTimeout = _a.requestTimeout, connectionTimeout = _a.connectionTimeout;
     var _b = config_1.default.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT = _b.DEFAULT_REQUEST_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT = _b.DEFAULT_CONNECTION_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
-    return { maxRetry: maxRetry !== null && maxRetry !== void 0 ? maxRetry : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
-        baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            INITIAL_BACKOFF_DELAY_BASE.REGULAR,
-        maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR,
-        requestTimeout: (requestTimeout === undefined) ? DEFAULT_REQUEST_TIMEOUT :
-            requestTimeout,
-        connectionTimeout: (connectionTimeout === undefined) ?
-            DEFAULT_CONNECTION_TIMEOUT : connectionTimeout, };
+    return {
+        maxRetry: maxRetry !== null && maxRetry !== void 0 ? maxRetry : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
+        baseDelay: lowLatencyMode
+            ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : INITIAL_BACKOFF_DELAY_BASE.REGULAR,
+        maxDelay: lowLatencyMode
+            ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : MAX_BACKOFF_DELAY_BASE.REGULAR,
+        requestTimeout: requestTimeout === undefined ? DEFAULT_REQUEST_TIMEOUT : requestTimeout,
+        connectionTimeout: connectionTimeout === undefined ? DEFAULT_CONNECTION_TIMEOUT : connectionTimeout,
+    };
 }
 exports.getSegmentFetcherOptions = getSegmentFetcherOptions;

package/dist/commonjs/core/fetchers/segment/segment_fetcher_creator.d.ts

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ITransportPipelines } from "../../../transports";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IBufferType } from "../../segment_buffers";
-import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
-import { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
+import type { ITransportPipelines } from "../../../transports";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IBufferType } from "../../segment_sinks";
+import type { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
+import type { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.

package/dist/commonjs/core/fetchers/segment/segment_fetcher_creator.js

@@ -35,8 +35,10 @@ var SegmentFetcherCreator = /** @class */ (function () {
         var _a = config_1.default.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
         this._transport = transport;
         this._prioritizer = new task_prioritizer_1.default({
-            prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,
-                low: MIN_CANCELABLE_PRIORITY },
+            prioritySteps: {
+                high: MAX_HIGH_PRIORITY_LEVEL,
+                low: MIN_CANCELABLE_PRIORITY,
+            },
         });
         this._cdnPrioritizer = cdnPrioritizer;
         this._backoffOptions = options;

package/dist/commonjs/core/fetchers/segment/task_prioritizer.d.ts

@@ -1,4 +1,4 @@
-import { CancellationSignal } from "../../../utils/task_canceller";
+import type { CancellationSignal } from "../../../utils/task_canceller";
 export default class TaskPrioritizer<T> {
     /**
      * Priority of the most prioritary task currently running.