rx-player 4.0.0-dev.2023111400 → 4.0.0-dev.2023121900

package/src/public_types.ts

@@ -186,8 +186,35 @@ export interface IRepresentationFilterRepresentation {
   /** String identifying the Representation, unique per Adaptation. */
   id : string;
   bitrate? : number | undefined;
-  /** Codec used by the media segments of that Representation. */
-  codec? : string | undefined;
+  /**
+   * Codec(s) relied on by the media segments of that Representation.
+   *
+   * For the great majority of cases, this value will be set to either
+   * `undefined` (meaning the codec is unknown) or to an array with a
+   * single element which will be the actual codec relied on when the
+   * corresponding Representation will be played.
+   *
+   * However in some very rare scenarios, this value might be set to an array
+   * with multiple codecs, itself being a list of its candidate codecs from the
+   * most wanted to the most compatible.
+   * The conditions for this more complex format are very specific:
+   *
+   *   - It can only happen if the `representationFilter` callback is called in
+   *     an environment where it hasn't yet been possible for the RxPlayer to
+   *     check for codec support (mainly when running through the RxPlayer's
+   *     `MULTI_THREAD` feature in a browser without MSE-in-worker
+   *     capabilities).
+   *
+   *   - The corresponding Representation is compatible to a restrictive codec
+   *     yet also retro-compatible to a less restrictive one.
+   *
+   *     The main example being Dolby Vision Representations which are
+   *     retro-compatible to HDR10 HEVC codecs.
+   *     In that very specific case, we could have an array with two elements:
+   *       1. The Dolby Vision codec
+   *       2. The base HDR10 codec
+   */
+  codecs? : string[] | undefined;
   /**
    * This property makes the most sense for video Representations.
    * It defines the height of the video, in pixels.
@@ -255,10 +282,20 @@ export type IStartAtOption =
     percentage : number;
   } | {
     /**
-     * If set, we should begin at this position relative to the content's end,
-     * in seconds.
+     * If set, we should begin at this position relative to the content's maximum
+     * seekable position, in seconds.
      */
     fromLastPosition : number;
+  } | {
+    /**
+     * If set, we should begin at this position relative to the content's live
+     * edge if it makes sense, in seconds.
+     *
+     * If the live edge is unknown or if it does not make sense for the current
+     * content, that position is relative to the content's maximum position
+     * instead.
+     */
+    fromLivePosition : number;
   } | {
     /**
      * If set, we should begin at this position relative to the content's start,
@@ -267,40 +304,38 @@ export type IStartAtOption =
     fromFirstPosition : number;
   };
 
+export interface RequestRetryParameters {
+  /**
+   * The amount of time maximum we should retry a request before failing on Error.
+   * Set to `Infinity` for an infinite number of requests.
+   */
+  maxRetry? : number | undefined;
+  /**
+   * Amount of time, in milliseconds, after which a request should be
+   * aborted and optionally retried, depending on the maxRetry configuration.
+   *
+   * Setting it to `-1` allows to disable any timeout.
+   * `undefined` means that a default, large, timeout will be used instead.
+   */
+  timeout? : number | undefined;
+  /**
+   * Amount of time, in milliseconds, after which a request that hasn't receive
+   * the headers and status code should be aborted and optionnaly retried,
+   * depending on the maxRetry configuration.
+   */
+  connectionTimeout?: number | undefined;
+}
+
 /** Value for the `requestConfig` option of the `loadVideo` method. */
 export interface IRequestConfig {
-  manifest? : {
-    /**
-     * The amount of time maximum we should retry a Manifest or Manifest-related
-     * request before failing on Error.
-     * Set to `Infinity` for an infinite number of requests.
-     */
-    maxRetry? : number | undefined;
-    /**
-     * Amount of time, in milliseconds, after which a manifest request should be
-     * aborted and optionally retried, depending on the current configuration.
-     *
-     * Setting it to `-1` allows to disable any timeout.
-     * `undefined` means that a default, large, timeout will be used instead.
-     */
-    timeout? : number | undefined;
-  } | undefined;
-  segment? : {
-    /**
-     * The amount of time maximum we should retry a segment or segment-related
-     * request before failing on Error.
-     * Set to `Infinity` for an infinite number of requests.
-     */
-    maxRetry? : number | undefined;
-    /**
-     * Amount of time, in milliseconds, after which a segment request should be
-     * aborted and optionally retried, depending on the current configuration.
-     *
-     * Setting it to `-1` allows to disable any timeout.
-     * `undefined` means that a default, large, timeout will be used instead.
-     */
-    timeout? : number | undefined;
-  } | undefined;
+  /**
+   * Defines the retry parameters when requesting manifest
+   */
+  manifest? : RequestRetryParameters | undefined;
+  /**
+   * Defines the retry parameters when requesting a segment
+   */
+  segment? : RequestRetryParameters | undefined;
 }
 
 export type ISegmentLoader = (
@@ -949,20 +984,57 @@ export interface ILockedAudioRepresentationsSettings {
 }
 
 export interface IAudioTrackSetting {
+  /** `id` of the audio track you want to set. */
   trackId : string;
+  /**
+   * `id` of the Period for which you want that setting applied.
+   * Keeping it undefined means it will apply to the currently-playing Period.
+   */
   periodId? : string | undefined;
+  /**
+   * Behavior wanted when replacing an audio track / Adaptation by another.
+   * @see IAudioTrackSwitchingMode
+   *
+   * Keeping it undefined means that the RxPlayer will automatically select
+   * the most adapted choice.
+   */
   switchingMode? : IAudioTrackSwitchingMode | undefined;
+  /**
+   * Representations (a.k.a. qualities) you want to play in that new track.
+   * Keeping it undefined means that all compatible qualities may be played.
+   */
   lockedRepresentations? : string[] | undefined;
 }
 
 export interface IVideoTrackSetting {
+  /** `id` of the video track you want to set. */
   trackId : string;
+  /**
+   * `id` of the Period for which you want that setting applied.
+   * Keeping it undefined means it will apply to the currently-playing Period.
+   */
   periodId? : string | undefined;
+  /**
+   * Behavior wanted when replacing an video track / Adaptation by another.
+   * @see IVideoTrackSwitchingMode
+   *
+   * Keeping it undefined means that the RxPlayer will automatically select
+   * the most adapted choice.
+   */
   switchingMode? : IVideoTrackSwitchingMode | undefined;
+  /**
+   * Representations (a.k.a. qualities) you want to play in that new track.
+   * Keeping it undefined means that all compatible qualities may be played.
+   */
   lockedRepresentations? : string[] | undefined;
 }
 
 export interface ITextTrackSetting {
+  /** `id` of the text track you want to set. */
   trackId : string;
+  /**
+   * `id` of the Period for which you want that setting applied.
+   * Keeping it undefined means it will apply to the currently-playing Period.
+   */
   periodId? : string | undefined;
 }

package/src/transports/dash/init_segment_loader.ts

@@ -50,6 +50,7 @@ export default function initSegmentLoader(
     return request({ url,
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -61,6 +62,7 @@ export default function initSegmentLoader(
                      headers: { Range: byteRange(segment.range) },
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -74,6 +76,7 @@ export default function initSegmentLoader(
                                                   segment.indexRange[1] ]) },
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -84,12 +87,14 @@ export default function initSegmentLoader(
                                   headers: { Range: byteRange(segment.range) },
                                   responseType: "arraybuffer",
                                   timeout: options.timeout,
+                                  connectionTimeout: options.connectionTimeout,
                                   cancelSignal,
                                   onProgress: callbacks.onProgress });
   const indexRequest$ = request({ url,
                                   headers: { Range: byteRange(segment.indexRange) },
                                   responseType: "arraybuffer",
                                   timeout: options.timeout,
+                                  connectionTimeout: options.connectionTimeout,
                                   cancelSignal,
                                   onProgress: callbacks.onProgress });
 

package/src/transports/dash/manifest_parser.ts

@@ -151,14 +151,20 @@ export default function generateManifestParser(
       const externalResources = value.urls.map(resourceUrl => {
         return scheduleRequest(() => {
           const defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+          const defaultConnectionTimeout = config.getCurrent().DEFAULT_CONNECTION_TIMEOUT;
+
           return value.format === "string" ? request({ url: resourceUrl,
                                                        responseType: "text",
                                                        timeout: defaultTimeout,
+                                                       connectionTimeout:
+                                                        defaultConnectionTimeout,
                                                        cancelSignal }) :
 
                                              request({ url: resourceUrl,
                                                        responseType: "arraybuffer",
                                                        timeout: defaultTimeout,
+                                                       connectionTimeout:
+                                                        defaultConnectionTimeout,
                                                        cancelSignal });
         }).then((res) => {
           if (value.format === "string") {

package/src/transports/dash/segment_loader.ts

@@ -84,6 +84,7 @@ export function regularSegmentLoader(
                      { Range: byteRange(segment.range) } :
                      undefined,
                    timeout: options.timeout,
+                   connectionTimeout: options.connectionTimeout,
                    cancelSignal,
                    onProgress: callbacks.onProgress })
     .then((data) => ({ resultType: "segment-loaded",

package/src/transports/dash/text_loader.ts

@@ -99,6 +99,7 @@ export default function generateTextTrackLoader(
                          { Range: byteRange(range) } :
                          null,
                        timeout: options.timeout,
+                       connectionTimeout: options.connectionTimeout,
                        onProgress: callbacks.onProgress,
                        cancelSignal })
         .then((data) => ({ resultType: "segment-loaded",
@@ -111,6 +112,7 @@ export default function generateTextTrackLoader(
                        { Range: byteRange(range) } :
                        null,
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      onProgress: callbacks.onProgress,
                      cancelSignal })
       .then((data) => ({ resultType: "segment-loaded",

package/src/transports/metaplaylist/manifest_loader.ts

@@ -40,6 +40,7 @@ function regularManifestLoader(
   return request({ url,
                    responseType: "text",
                    timeout: loaderOptions.timeout,
+                   connectionTimeout: loaderOptions.connectionTimeout,
                    cancelSignal });
 }
 

package/src/transports/metaplaylist/pipelines.ts

@@ -177,7 +177,10 @@ export default function(options : ITransportOptions): ITransportPipelines {
              * Whether a ManifestLoader's timeout should be relied on here
              * is ambiguous.
              */
-            const manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+            const manOpts = {
+              timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+              connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+            };
             return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
           }
         });

package/src/transports/smooth/pipelines.ts

@@ -203,6 +203,7 @@ export default function(transportOptions : ITransportOptions) : ITransportPipeli
         return request({ url,
                          responseType: "text",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => ({ resultType: "segment-loaded" as const,
@@ -211,6 +212,7 @@ export default function(transportOptions : ITransportOptions) : ITransportPipeli
         return request({ url,
                          responseType: "arraybuffer",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => {

package/src/transports/smooth/segment_loader.ts

@@ -65,6 +65,7 @@ function regularSegmentLoader(
                    responseType: "arraybuffer",
                    headers,
                    timeout: loaderOptions.timeout,
+                   connectionTimeout: loaderOptions.connectionTimeout,
                    cancelSignal,
                    onProgress: callbacks.onProgress })
     .then((data) => {

package/src/transports/types.ts

@@ -169,6 +169,12 @@ export interface IManifestLoaderOptions {
    * `undefined` means that no timeout will be enforced.
    */
   timeout? : number | undefined;
+  /**
+   * Connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout? : number | undefined;
 }
 
 /** Functions allowing to load and parse segments of any type. */
@@ -217,6 +223,12 @@ export interface ISegmentLoaderOptions {
    * `undefined` means that no timeout will be enforced.
    */
   timeout? : number | undefined;
+  /**
+   * Connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout? : number | undefined;
 }
 
 /**

package/src/transports/utils/generate_manifest_loader.ts

@@ -57,16 +57,19 @@ function generateRegularManifestLoader(
         return request({ url,
                          responseType: "arraybuffer",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal });
       case "text":
         return request({ url,
                          responseType: "text",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal });
       case "document":
         return request({ url,
                          responseType: "document",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal });
       default:
         assertUnreachable(preferredType);

package/src/utils/request/fetch.ts

@@ -95,6 +95,12 @@ export interface IFetchOptions {
    * if not all data has been received yet.
    */
   timeout? : number | undefined;
+  /**
+   * Optional connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout? : number | undefined;
 }
 
 
@@ -128,7 +134,8 @@ export default function fetchRequest(
 
   log.debug("Fetch: Called with URL", options.url);
   let cancellation : CancellationError | null = null;
-  let timeouted = false;
+  let isTimedOut = false;
+  let isConnectionTimedOut = false;
   const sendingTime = getMonotonicTimeStamp();
   const abortController: AbortController | null =
     !isNullOrUndefined(_AbortController) ? new _AbortController() :
@@ -146,14 +153,28 @@ export default function fetchRequest(
     abortController.abort();
   }
 
-  let timeout : number | undefined;
+  let timeoutId : number | undefined;
   if (options.timeout !== undefined) {
-    timeout = setTimeout(() => {
-      timeouted = true;
+    timeoutId = setTimeout(() => {
+      isTimedOut = true;
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       abortFetch();
     }, options.timeout);
   }
 
+  let connectionTimeoutId: number | undefined;
+  if (options.connectionTimeout !== undefined) {
+    connectionTimeoutId = setTimeout(() => {
+      isConnectionTimedOut = true;
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      abortFetch();
+    }, options.connectionTimeout);
+  }
+
   const deregisterCancelLstnr = options.cancelSignal
     .register(function abortRequest(err : CancellationError) {
       cancellation = err;
@@ -170,8 +191,8 @@ export default function fetchRequest(
     options.url,
     fetchOpts
   ).then((response : Response) : Promise<IFetchedStreamComplete> => {
-    if (!isNullOrUndefined(timeout)) {
-      clearTimeout(timeout);
+    if (connectionTimeoutId !== undefined) {
+      clearTimeout(connectionTimeoutId);
     }
     if (response.status >= 300) {
       log.warn("Fetch: Request HTTP Error", response.status, response.url);
@@ -212,6 +233,9 @@ export default function fetchRequest(
         options.onData(dataInfo);
         return readBufferAndSendEvents();
       } else if (data.done) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
         deregisterCancelLstnr();
         const receivedTime = getMonotonicTimeStamp();
         const requestDuration = receivedTime - sendingTime;
@@ -229,8 +253,11 @@ export default function fetchRequest(
       throw cancellation;
     }
     deregisterCancelLstnr();
-    if (timeouted) {
-      log.warn("Fetch: Request timeouted.");
+    if (isTimedOut) {
+      log.warn("Fetch: Request timed out.");
+      throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
+    } else if (isConnectionTimedOut) {
+      log.warn("Fetch: Request connection timed out.");
       throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
     } else if (err instanceof RequestError) {
       throw err;

package/src/utils/request/xhr.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { RequestError } from "../../errors";
+import { NetworkErrorTypes, RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
 import getMonotonicTimeStamp from "../monotonic_timestamp";
@@ -30,14 +30,14 @@ const DEFAULT_RESPONSE_TYPE : XMLHttpRequestResponseType = "json";
  * Perform an HTTP request, according to the options given.
  *
  * Several errors can be rejected. Namely:
- *   - RequestErrorTypes.TIMEOUT_ERROR: the request timeouted (took too long to
- *     respond).
- *   - RequestErrorTypes.PARSE_ERROR: the browser APIs used to parse the
+ *   - NetworkErrorTypes.TIMEOUT: the request timed out (took too long)
+ *
+ *   - NetworkErrorTypes.PARSE_ERROR: the browser APIs used to parse the
  *                                    data failed.
- *   - RequestErrorTypes.ERROR_HTTP_CODE: the HTTP code at the time of reception
+ *   - NetworkErrorTypes.ERROR_HTTP_CODE: the HTTP code at the time of reception
  *                                        was not in the 200-299 (included)
  *                                        range.
- *   - RequestErrorTypes.ERROR_EVENT: The XHR had an error event before the
+ *   - NetworkErrorTypes.ERROR_EVENT: The XHR had an error event before the
  *                                    response could be fetched.
  * @param {Object} options
  * @returns {Promise.<Object>}
@@ -70,6 +70,7 @@ export default function request<T>(
     responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
                                                             options.responseType,
     timeout: options.timeout,
+    connectionTimeout: options.connectionTimeout,
   };
 
   return new Promise((resolve, reject) => {
@@ -77,7 +78,8 @@ export default function request<T>(
     const { url,
             headers,
             responseType,
-            timeout } = requestOptions;
+            timeout,
+            connectionTimeout } = requestOptions;
     const xhr = new XMLHttpRequest();
     xhr.open("GET", url, true);
 
@@ -93,9 +95,19 @@ export default function request<T>(
       // is more precise, it might also be more efficient.
       timeoutId = setTimeout(() => {
         clearCancellingProcess();
-        reject(new RequestError(url, xhr.status, "TIMEOUT"));
+        reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
       }, timeout + 3000);
     }
+    let connectionTimeoutId: undefined | number;
+    if (connectionTimeout !== undefined) {
+      connectionTimeoutId = setTimeout(() => {
+        clearCancellingProcess();
+        if (xhr.readyState !== XMLHttpRequest.DONE) {
+          xhr.abort();
+        }
+        reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
+      }, connectionTimeout);
+    }
 
     xhr.responseType = responseType;
 
@@ -120,7 +132,7 @@ export default function request<T>(
       deregisterCancellationListener = cancelSignal
         .register(function abortRequest(err : CancellationError) {
           clearCancellingProcess();
-          if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
+          if (xhr.readyState !== XMLHttpRequest.DONE) {
             xhr.abort();
           }
           reject(err);
@@ -133,14 +145,23 @@ export default function request<T>(
 
     xhr.onerror = function onXHRError() {
       clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "ERROR_EVENT"));
+      reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_EVENT));
     };
 
     xhr.ontimeout = function onXHRTimeout() {
       clearCancellingProcess();
-      reject(new RequestError(url, xhr.status, "TIMEOUT"));
+      reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
     };
 
+
+    if (connectionTimeout !== undefined) {
+      xhr.onreadystatechange = function clearConnectionTimeout() {
+        if (xhr.readyState >= XMLHttpRequest.HEADERS_RECEIVED) {
+          clearTimeout(connectionTimeoutId);
+        }
+      };
+    }
+
     if (onProgress !== undefined) {
       xhr.onprogress = function onXHRProgress(event) {
         const currentTime = getMonotonicTimeStamp();
@@ -154,7 +175,7 @@ export default function request<T>(
     }
 
     xhr.onload = function onXHRLoad(event : ProgressEvent) {
-      if (xhr.readyState === 4) {
+      if (xhr.readyState === XMLHttpRequest.DONE) {
         clearCancellingProcess();
         if (xhr.status >= 200 && xhr.status < 300) {
           const receivedTime = getMonotonicTimeStamp();
@@ -179,7 +200,7 @@ export default function request<T>(
           }
 
           if (isNullOrUndefined(responseData)) {
-            reject(new RequestError(url, xhr.status, "PARSE_ERROR"));
+            reject(new RequestError(url, xhr.status, NetworkErrorTypes.PARSE_ERROR));
             return;
           }
 
@@ -193,7 +214,7 @@ export default function request<T>(
                     responseData });
 
         } else {
-          reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
+          reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_HTTP_CODE));
         }
       }
     };
@@ -207,6 +228,10 @@ export default function request<T>(
       if (timeoutId !== undefined) {
         clearTimeout(timeoutId);
       }
+
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       if (deregisterCancellationListener !== null) {
         deregisterCancellationListener();
       }
@@ -241,6 +266,12 @@ export interface IRequestOptions<ResponseType> {
    * To not set or to set to `undefined` for disable.
    */
   timeout? : number | undefined;
+  /**
+   * Optional connection timeout, in milliseconds, after which the request is canceled
+   * if the responses headers has not being received.
+   * Do not set or set to "undefined" to disable it.
+   */
+  connectionTimeout? : number | undefined;
   /**
    * "Cancelation token" used to be able to cancel the request.
    * When this token is "cancelled", the request will be aborted and the Promise

package/dist/commonjs/parsers/manifest/utils/is_segment_still_available.d.ts

@@ -1,29 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { ISegment } from "../../../manifest";
-import { IIndexSegment } from "./index_helpers";
-/**
- * Returns true if a Segment returned by the corresponding index is still
- * considered available.
- * Returns false if it is not available anymore.
- * Returns undefined if we cannot know whether it is still available or not.
- * /!\ We do not check the mediaURLs of the segment.
- * @param {Object} segment
- * @param {Array.<Object>} timescale
- * @param {number} timeline
- * @returns {Boolean|undefined}
- */
-export default function isSegmentStillAvailable(segment: ISegment, timeline: IIndexSegment[], timescale: number, indexTimeOffset: number): boolean | undefined;