rx-player 4.0.0 → 4.1.0-dev.2024031100

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

@@ -16,13 +16,13 @@
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
-import Manifest from "../../../manifest";
+import Manifest from "../../../manifest/classes";
 import EventEmitter from "../../../utils/event_emitter";
 import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import noop from "../../../utils/noop";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
-import { scheduleRequestPromise, } from "../utils/schedule_request";
+import { scheduleRequestPromise } from "../utils/schedule_request";
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest, as
  * well as automatically refreshing it.
@@ -82,8 +82,7 @@ export default class ManifestFetcher extends EventEmitter {
             manifestProm = this.parse(initialManifest, { previousManifest: null, unsafeMode: false }, undefined);
         }
         else {
-            manifestProm = this._fetchManifest(undefined)
-                .then((val) => {
+            manifestProm = this._fetchManifest(undefined).then((val) => {
                 return val.parse({ previousManifest: null, unsafeMode: false });
             });
         }
@@ -156,12 +155,12 @@ export default class ManifestFetcher extends EventEmitter {
          */
         function callLoaderWithRetries(manifestUrl) {
             const { loadManifest } = pipelines;
-            let requestTimeout = (settings.requestTimeout === undefined) ?
-                config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
-                settings.requestTimeout;
-            let connectionTimeout = (settings.connectionTimeout === undefined) ?
-                config.getCurrent().DEFAULT_CONNECTION_TIMEOUT :
-                settings.connectionTimeout;
+            let requestTimeout = settings.requestTimeout === undefined
+                ? config.getCurrent().DEFAULT_REQUEST_TIMEOUT
+                : settings.requestTimeout;
+            let connectionTimeout = settings.connectionTimeout === undefined
+                ? config.getCurrent().DEFAULT_CONNECTION_TIMEOUT
+                : settings.connectionTimeout;
             if (requestTimeout < 0) {
                 requestTimeout = undefined;
             }
@@ -188,9 +187,7 @@ export default class ManifestFetcher extends EventEmitter {
      * @returns {Promise}
      */
     parse(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.
@@ -211,10 +208,12 @@ export default class ManifestFetcher extends EventEmitter {
             this.trigger("warning", errorSelector(err));
         });
         const originalUrl = requestUrl !== null && requestUrl !== void 0 ? requestUrl : (_a = this._manifestUrls) === null || _a === void 0 ? void 0 : _a[0];
-        const opts = { externalClockOffset: parserOptions.externalClockOffset,
+        const opts = {
+            externalClockOffset: parserOptions.externalClockOffset,
             unsafeMode: parserOptions.unsafeMode,
             previousManifest: parserOptions.previousManifest,
-            originalUrl };
+            originalUrl,
+        };
         try {
             const res = this._pipelines.parseManifest(loaded, opts, onWarnings, cancelSignal, scheduleRequest);
             if (!isPromise(res)) {
@@ -272,10 +271,7 @@ export default class ManifestFetcher extends EventEmitter {
             onWarnings(warnings);
             const parsingTime = getMonotonicTimeStamp() - parsingTimeStart;
             log.info(`MF: Manifest parsed in ${parsingTime}ms`);
-            return { manifest,
-                sendingTime,
-                receivedTime,
-                parsingTime };
+            return { manifest, sendingTime, receivedTime, parsingTime };
         }
     }
     /**
@@ -285,17 +281,16 @@ export default class ManifestFetcher extends EventEmitter {
      * @returns {Object}
      */
     _getBackoffSetting(onRetry) {
-        const { DEFAULT_MAX_MANIFEST_REQUEST_RETRY, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
+        const { DEFAULT_MAX_MANIFEST_REQUEST_RETRY, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE, } = config.getCurrent();
         const { lowLatencyMode, maxRetry: ogRegular } = this._settings;
-        const baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            INITIAL_BACKOFF_DELAY_BASE.REGULAR;
-        const maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR;
+        const baseDelay = lowLatencyMode
+            ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : INITIAL_BACKOFF_DELAY_BASE.REGULAR;
+        const maxDelay = lowLatencyMode
+            ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY
+            : MAX_BACKOFF_DELAY_BASE.REGULAR;
         const maxRetry = ogRegular !== null && ogRegular !== void 0 ? ogRegular : DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
-        return { onRetry,
-            baseDelay,
-            maxDelay,
-            maxRetry };
+        return { onRetry, baseDelay, maxDelay, maxRetry };
     }
     /**
      * Performs Manifest refresh (recursively) when it judges it is time to do so.
@@ -303,15 +298,13 @@ export default class ManifestFetcher extends EventEmitter {
      * @param {Object} manifestRequestInfos - Various information linked to the
      * last Manifest loading and parsing operations.
      */
-    _recursivelyRefreshManifest(manifest, { sendingTime, parsingTime, updatingTime }) {
-        const { MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE } = config.getCurrent();
+    _recursivelyRefreshManifest(manifest, { sendingTime, parsingTime, updatingTime, }) {
+        const { MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE, } = config.getCurrent();
         /**
          * Total time taken to fully update the last Manifest, in milliseconds.
          * Note: this time also includes possible requests done by the parsers.
          */
-        const totalUpdateTime = parsingTime !== undefined ?
-            parsingTime + (updatingTime !== null && updatingTime !== void 0 ? updatingTime : 0) :
-            undefined;
+        const 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.
@@ -320,18 +313,19 @@ export default class ManifestFetcher extends EventEmitter {
          * 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.
          */
-        const 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;
+        let 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. */
-        const timeSinceRequest = sendingTime === undefined ?
-            0 :
-            getMonotonicTimeStamp() - sendingTime;
+        const timeSinceRequest = sendingTime === undefined ? 0 : getMonotonicTimeStamp() - sendingTime;
         /** Minimum update delay we should not go below, in milliseconds. */
-        const minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
-            timeSinceRequest, 0);
+        const minInterval = Math.max(this._settings.minimumManifestUpdateInterval - timeSinceRequest, 0);
         /**
          * Multiple refresh trigger are scheduled here, but only the first one should
          * be effectively considered.
@@ -345,14 +339,14 @@ export default class ManifestFetcher extends EventEmitter {
             const unsafeMode = canUseUnsafeMode && unsafeModeEnabled;
             // The value allows to set a delay relatively to the last Manifest refresh
             // (to avoid asking for it too often).
-            const timeSinceLastRefresh = sendingTime === undefined ?
-                0 :
-                getMonotonicTimeStamp() - sendingTime;
-            const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
-                timeSinceLastRefresh, 0);
+            const timeSinceLastRefresh = sendingTime === undefined ? 0 : getMonotonicTimeStamp() - sendingTime;
+            const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval - timeSinceLastRefresh, 0);
             const timeoutId = setTimeout(() => {
                 nextRefreshCanceller.cancel();
-                this._triggerNextManifestRefresh(manifest, { enablePartialRefresh, unsafeMode });
+                this._triggerNextManifestRefresh(manifest, {
+                    enablePartialRefresh,
+                    unsafeMode,
+                });
             }, Math.max((delay !== null && delay !== void 0 ? delay : 0) - timeSinceLastRefresh, _minInterval));
             nextRefreshCanceller.signal.register(() => {
                 clearTimeout(timeoutId);
@@ -364,8 +358,10 @@ export default class ManifestFetcher extends EventEmitter {
                 var _a;
                 (_a = manifest.expired) === null || _a === void 0 ? void 0 : _a.then(() => {
                     nextRefreshCanceller.cancel();
-                    this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: false,
-                        unsafeMode: unsafeModeEnabled });
+                    this._triggerNextManifestRefresh(manifest, {
+                        enablePartialRefresh: false,
+                        unsafeMode: unsafeModeEnabled,
+                    });
                 }, noop /* `expired` should not reject */);
             }, minInterval);
             nextRefreshCanceller.signal.register(() => {
@@ -418,8 +414,10 @@ export default class ManifestFetcher extends EventEmitter {
             }
             const timeoutId = setTimeout(() => {
                 nextRefreshCanceller.cancel();
-                this._triggerNextManifestRefresh(manifest, { enablePartialRefresh: false,
-                    unsafeMode: unsafeModeEnabled });
+                this._triggerNextManifestRefresh(manifest, {
+                    enablePartialRefresh: false,
+                    unsafeMode: unsafeModeEnabled,
+                });
             }, Math.max(actualRefreshInterval, minInterval));
             nextRefreshCanceller.signal.register(() => {
                 clearTimeout(timeoutId);
@@ -433,7 +431,7 @@ export default class ManifestFetcher extends EventEmitter {
      * @param {Object} manifest
      * @param {Object} refreshInformation
      */
-    _triggerNextManifestRefresh(manifest, { enablePartialRefresh, unsafeMode }) {
+    _triggerNextManifestRefresh(manifest, { enablePartialRefresh, unsafeMode, }) {
         const manifestUpdateUrl = manifest.updateUrl;
         let fullRefresh;
         let refreshURL;
@@ -444,18 +442,19 @@ export default class ManifestFetcher extends EventEmitter {
         }
         else {
             fullRefresh = !enablePartialRefresh || manifestUpdateUrl === undefined;
-            refreshURL = fullRefresh ? manifest.getUrls()[0] :
-                manifestUpdateUrl;
+            refreshURL = fullRefresh ? manifest.getUrls()[0] : manifestUpdateUrl;
         }
         const externalClockOffset = manifest.clockOffset;
         if (unsafeMode) {
             this._consecutiveUnsafeMode += 1;
-            log.info("Init: Refreshing the Manifest in \"unsafeMode\" for the " +
-                String(this._consecutiveUnsafeMode) + " consecutive time.");
+            log.info('Init: Refreshing the Manifest in "unsafeMode" for the ' +
+                String(this._consecutiveUnsafeMode) +
+                " consecutive time.");
         }
         else if (this._consecutiveUnsafeMode > 0) {
-            log.info("Init: Not parsing the Manifest in \"unsafeMode\" anymore after " +
-                String(this._consecutiveUnsafeMode) + " consecutive times.");
+            log.info('Init: Not parsing the Manifest in "unsafeMode" anymore after ' +
+                String(this._consecutiveUnsafeMode) +
+                " consecutive times.");
             this._consecutiveUnsafeMode = 0;
         }
         if (this._isRefreshPending) {
@@ -463,10 +462,12 @@ export default class ManifestFetcher extends EventEmitter {
         }
         this._isRefreshPending = true;
         this._fetchManifest(refreshURL)
-            .then(res => res.parse({ externalClockOffset,
+            .then((res) => res.parse({
+            externalClockOffset,
             previousManifest: manifest,
-            unsafeMode }))
-            .then(res => {
+            unsafeMode,
+        }))
+            .then((res) => {
             this._isRefreshPending = false;
             const { manifest: newManifest, sendingTime: newSendingTime, parsingTime } = res;
             const updateTimeStart = getMonotonicTimeStamp();
@@ -478,24 +479,21 @@ export default class ManifestFetcher extends EventEmitter {
                     manifest.update(newManifest);
                 }
                 catch (e) {
-                    const message = e instanceof Error ? e.message :
-                        "unknown error";
+                    const message = e instanceof Error ? e.message : "unknown error";
                     log.warn(`MUS: Attempt to update Manifest failed: ${message}`, "Re-downloading the Manifest fully");
                     const { FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY } = config.getCurrent();
                     // The value allows to set a delay relatively to the last Manifest refresh
                     // (to avoid asking for it too often).
-                    const timeSinceLastRefresh = newSendingTime === undefined ?
-                        0 :
-                        getMonotonicTimeStamp() - newSendingTime;
-                    const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
-                        timeSinceLastRefresh, 0);
+                    const timeSinceLastRefresh = newSendingTime === undefined ? 0 : getMonotonicTimeStamp() - newSendingTime;
+                    const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval - timeSinceLastRefresh, 0);
                     let unregisterCanceller = noop;
                     const timeoutId = setTimeout(() => {
                         unregisterCanceller();
-                        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 = this._canceller.signal.register(() => {
                         clearTimeout(timeoutId);
                     });
@@ -503,9 +501,11 @@ export default class ManifestFetcher extends EventEmitter {
                 }
             }
             const updatingTime = getMonotonicTimeStamp() - updateTimeStart;
-            this._recursivelyRefreshManifest(manifest, { sendingTime: newSendingTime,
+            this._recursivelyRefreshManifest(manifest, {
+                sendingTime: newSendingTime,
                 parsingTime,
-                updatingTime });
+                updatingTime,
+            });
         })
             .catch((err) => {
             this._isRefreshPending = false;

package/dist/es2017/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/es2017/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/es2017/core/fetchers/segment/initialization_segment_cache.js

@@ -35,7 +35,7 @@ class InitializationSegmentCache {
      * @param {Object} obj
      * @returns {*} response
      */
-    get({ representation, segment }) {
+    get({ representation, segment, }) {
         if (segment.isInit) {
             const value = this._cache.get(representation);
             if (value !== undefined) {

package/dist/es2017/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/es2017/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/es2017/core/fetchers/segment/segment_fetcher.js

@@ -16,13 +16,13 @@
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
-import { getLoggableSegmentId, } from "../../../manifest";
+import { getLoggableSegmentId } from "../../../manifest";
 import arrayIncludes from "../../../utils/array_includes";
 import idGenerator from "../../../utils/id_generator";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import getTimestamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
-import { CancellationError, } from "../../../utils/task_canceller";
+import { CancellationError } from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { scheduleRequestWithCdns } from "../utils/schedule_request";
 import InitializationSegmentCache from "./initialization_segment_cache";
@@ -53,20 +53,25 @@ const generateRequestID = idGenerator();
  * @returns {Function}
  */
 export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
+    let connectionTimeout;
+    if (options.connectionTimeout === undefined || options.connectionTimeout < 0) {
+        connectionTimeout = undefined;
+    }
+    else {
+        connectionTimeout = options.connectionTimeout;
+    }
     const 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,
     };
     /**
      * Cache audio and video initialization segments.
      * This allows to avoid doing too many requests for what are usually very
      * small files.
      */
-    const cache = arrayIncludes(["audio", "video"], bufferType) ?
-        new InitializationSegmentCache() :
-        undefined;
+    const cache = arrayIncludes(["audio", "video"], bufferType)
+        ? new InitializationSegmentCache()
+        : undefined;
     const { loadSegment, parseSegment } = pipeline;
     /**
      * Fetch a specific segment.
@@ -109,7 +114,8 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
         /** Set to `true` once network metrics have been sent. */
         let metricsSent = false;
         /** Segment context given to the transport pipelines. */
-        const context = { segment,
+        const context = {
+            segment,
             type: adaptation.type,
             language: adaptation.language,
             isLive: manifest.isLive,
@@ -117,7 +123,8 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
             periodEnd: period.end,
             mimeType: representation.mimeType,
             codecs: representation.codecs[0],
-            manifestPublishTime: manifest.publishTime };
+            manifestPublishTime: manifest.publishTime,
+        };
         const loaderCallbacks = {
             /**
              * Callback called when the segment loader has progress information on
@@ -130,11 +137,13 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                     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: getTimestamp(),
-                        id: requestId });
+                        id: requestId,
+                    });
                 }
             },
             /**
@@ -148,17 +157,18 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
             },
         };
         // Retrieve from cache if it exists
-        const cached = cache !== undefined ? cache.get(content) :
-            null;
+        const cached = cache !== undefined ? cache.get(content) : null;
         if (cached !== null) {
             log.debug("SF: Found wanted segment in cache", segmentIdString);
             fetcherCallbacks.onChunk(generateParserFunction(cached, false));
             return Promise.resolve();
         }
         log.debug("SF: Beginning request", segmentIdString);
-        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: getTimestamp(),
+        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
+            requestTimestamp: getTimestamp(),
             id: requestId,
-            content });
+            content,
+        });
         cancellationSignal.register(onCancellation);
         try {
             const res = await scheduleRequestWithCdns(content.representation.cdnMetadata, cdnPrioritizer, callLoaderWithUrl, objectAssign({ onRetry }, options), cancellationSignal);
@@ -231,20 +241,23 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                 try {
                     const 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 formatError(error, { defaultCode: "PIPELINE_PARSE_ERROR",
-                        defaultReason: "Unknown parsing error" });
+                    throw formatError(error, {
+                        defaultCode: "PIPELINE_PARSE_ERROR",
+                        defaultReason: "Unknown parsing error",
+                    });
                 }
             };
         }
@@ -268,7 +281,7 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                 requestInfo.size !== undefined &&
                 requestInfo.requestDuration !== undefined &&
                 parsedChunks.length > 0 &&
-                parsedChunks.every(isParsed => isParsed)) {
+                parsedChunks.every((isParsed) => isParsed)) {
                 metricsSent = true;
                 (_a = lifecycleCallbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
                     size: requestInfo.size,
@@ -285,15 +298,17 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
  * @param {Object}
  * @returns {Object}
  */
-export function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout }) {
-    const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE } = config.getCurrent();
-    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, };
+export function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout, connectionTimeout, }) {
+    const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE, } = config.getCurrent();
+    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,
+    };
 }

package/dist/es2017/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/es2017/core/fetchers/segment/segment_fetcher_creator.js

@@ -16,7 +16,7 @@
 import config from "../../../config";
 import CdnPrioritizer from "../cdn_prioritizer";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
-import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
+import createSegmentFetcher, { getSegmentFetcherOptions } from "./segment_fetcher";
 import TaskPrioritizer from "./task_prioritizer";
 /**
  * Interact with the transport pipelines to download segments with the right
@@ -33,8 +33,10 @@ export default class SegmentFetcherCreator {
         const { MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL } = config.getCurrent();
         this._transport = transport;
         this._prioritizer = new TaskPrioritizer({
-            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/es2017/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.