rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/playback_observer/types.d.ts

@@ -0,0 +1,223 @@
+import type { IReadOnlySharedReference } from "../utils/reference";
+import type { CancellationSignal } from "../utils/task_canceller";
+import type ObservationPosition from "./utils/observation_position";
+/** "Event" that triggered the playback observation. */
+export type IPlaybackObserverEventType = 
+/** First playback observation automatically emitted. */
+"init"
+/** Observation manually forced by the PlaybackObserver. */
+ | "manual"
+/** Regularly emitted playback observation when no event happened in a long time. */
+ | "timeupdate"
+/** On the HTML5 event with the same name */
+ | "canplay"
+/** On the HTML5 event with the same name */
+ | "ended"
+/** On the HTML5 event with the same name */
+ | "canplaythrough"
+/** On the HTML5 event with the same name */
+ | "play"
+/** On the HTML5 event with the same name */
+ | "pause"
+/** On the HTML5 event with the same name */
+ | "seeking"
+/** On the HTML5 event with the same name */
+ | "seeked"
+/** On the HTML5 event with the same name */
+ | "stalled"
+/** On the HTML5 event with the same name */
+ | "loadedmetadata"
+/** On the HTML5 event with the same name */
+ | "ratechange"
+/** An internal seek happens */
+ | "internal-seeking";
+/** Information recuperated on the media element on each playback observation. */
+export interface IMediaInfos {
+    /** Value of `buffered` (buffered ranges) for the media element. */
+    buffered: TimeRanges;
+    /**
+     * `currentTime` (position) set on the media element at the time of the
+     * PlaybackObserver's measure.
+     */
+    position: number;
+    /** Current `duration` set on the media element. */
+    duration: number;
+    /** Current `ended` set on the media element. */
+    ended: boolean;
+    /** Current `paused` set on the media element. */
+    paused: boolean;
+    /** Current `playbackRate` set on the media element. */
+    playbackRate: number;
+    /** Current `readyState` value on the media element. */
+    readyState: number;
+    /** Current `seeking` value on the mediaElement. */
+    seeking: boolean;
+}
+/** Categorize a pending seek operation. */
+export declare const enum SeekingState {
+    /** We're not currently seeking. */
+    None = 0,
+    /**
+     * We're currently seeking due to an internal logic of the RxPlayer (e.g.
+     * discontinuity skipping).
+     */
+    Internal = 1,
+    /** We're currently seeking due to a regular seek wanted by the application. */
+    External = 2
+}
+/**
+ * Describes when the player is "rebuffering" and what event started that
+ * status.
+ * "Rebuffering" is a status where the player has not enough buffer ahead to
+ * play reliably.
+ * The RxPlayer should pause playback when a playback observation indicates the
+ * rebuffering status.
+ */
+export interface IRebufferingStatus {
+    /** What started the player to rebuffer. */
+    reason: "seeking" | "not-ready" | "buffering";
+    /**
+     * Monotonically-raising timestamp at the time the rebuffering happened on the
+     * main thread.
+     */
+    timestamp: number;
+    /**
+     * Position, in seconds, at which data is awaited.
+     * If `null` the player is rebuffering but not because it is awaiting future data.
+     * If `undefined`, that position is unknown.
+     */
+    position: number | null | undefined;
+}
+/**
+ * Describes when the player is "frozen".
+ * This status is reserved for when the player is stuck at the same position for
+ * an unknown reason.
+ */
+export interface IFreezingStatus {
+    /**
+     * Monotonically-raising timestamp at the time the freezing started to be
+     * detected.
+     */
+    timestamp: number;
+}
+/** Information emitted on each playback observation. */
+export interface IPlaybackObservation extends Omit<IMediaInfos, "position" | "seeking"> {
+    /** Event that triggered this playback observation. */
+    event: IPlaybackObserverEventType;
+    /** Current seeking state. */
+    seeking: SeekingState;
+    /**
+     * Information on the current position being played, the position for which
+     * media is wanted etc.
+     */
+    position: ObservationPosition;
+    /**
+     * Set if the player is short on audio and/or video media data and is a such,
+     * rebuffering.
+     * `null` if not.
+     */
+    rebuffering: IRebufferingStatus | null;
+    /**
+     * Set if the player is frozen, that is, stuck in place for unknown reason.
+     * Note that this reason can be a valid one, such as a necessary license not
+     * being obtained yet.
+     *
+     * `null` if the player is not frozen.
+     */
+    freezing: IFreezingStatus | null;
+    /**
+     * Gap between `currentTime` and the next position with un-buffered data.
+     * `Infinity` if we don't have buffered data right now.
+     * `undefined` if we cannot determine the buffer gap.
+     */
+    bufferGap: number | undefined;
+    /**
+     * The buffered range we are currently playing.
+     * `null` if no range is currently available.
+     * `undefined` if we cannot tell which range is currently available.
+     */
+    currentRange: {
+        start: number;
+        end: number;
+    } | null | undefined;
+}
+/**
+ * Interface providing a generic and read-only version of a `PlaybackObserver`.
+ *
+ * This interface allows to provide regular and specific playback information
+ * without allowing any effect on playback like seeking.
+ *
+ * This can be very useful to give specific playback information to modules you
+ * don't want to be able to update playback.
+ *
+ * Note that a `PlaybackObserver` is compatible and can thus be upcasted to a
+ * `IReadOnlyPlaybackObserver` to "remove" its right to update playback.
+ */
+export interface IReadOnlyPlaybackObserver<TObservationType> {
+    /**
+     * Get the current playing position, in seconds.
+     * Returns `undefined` when this cannot be known, such as when the playback
+     * observer is running in a WebWorker.
+     * @returns {number|undefined}
+     */
+    getCurrentTime(): number | undefined;
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * Returns `undefined` when this cannot be known, such as when the playback
+     * observer is running in a WebWorker.
+     * @returns {number|undefined}
+     */
+    getPlaybackRate(): number | undefined;
+    /**
+     * Get the HTMLMediaElement's current `readyState`.
+     * Returns `undefined` when this cannot be known, such as when the playback
+     * observer is running in a WebWorker.
+     * @returns {number|undefined}
+     */
+    getReadyState(): number | undefined;
+    /**
+     * Returns the current `paused` status advertised by the `HTMLMediaElement`.
+     *
+     * Use this instead of the same status emitted on an observation when you want
+     * to be sure you're using the current value.
+     *
+     * Returns `undefined` when this cannot be known, such as when the playback
+     * observer is running in a WebWorker.
+     * @returns {boolean|undefined}
+     */
+    getIsPaused(): boolean | undefined;
+    /**
+     * Returns an `IReadOnlySharedReference` storing the last playback observation
+     * produced by the `IReadOnlyPlaybackObserver` and updated each time a new one
+     * is produced.
+     *
+     * This value can then be for example listened to to be notified of future
+     * playback observations.
+     *
+     * @returns {Object}
+     */
+    getReference(): IReadOnlySharedReference<TObservationType>;
+    /**
+     * Register a callback so it regularly receives playback observations.
+     * @param {Function} cb
+     * @param {Object} options - Configuration options:
+     *   - `includeLastObservation`: If set to `true` the last observation will
+     *     be first emitted synchronously.
+     *   - `clearSignal`: If set, the callback will be unregistered when this
+     *     CancellationSignal emits.
+     * @returns {Function} - Allows to easily unregister the callback
+     */
+    listen(cb: (observation: TObservationType, stopListening: () => void) => void, options?: {
+        includeLastObservation?: boolean | undefined;
+        clearSignal?: CancellationSignal | undefined;
+    }): void;
+    /**
+     * Generate a new `IReadOnlyPlaybackObserver` from this one.
+     *
+     * As argument, this method takes a function which will allow to produce
+     * the new set of properties to be present on each observation.
+     * @param {Function} transform
+     * @returns {Object}
+     */
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<TObservationType>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
+}

package/dist/es2017/playback_observer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2017/playback_observer/utils/generate_read_only_observer.d.ts

@@ -0,0 +1,11 @@
+import type { IReadOnlySharedReference } from "../../utils/reference";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import type { IReadOnlyPlaybackObserver } from "../types";
+/**
+ * Create `IReadOnlyPlaybackObserver` from a source `IReadOnlyPlaybackObserver`
+ * and a mapping function.
+ * @param {Object} src
+ * @param {Function} transform
+ * @returns {Object}
+ */
+export default function generateReadOnlyObserver<TSource, TDest>(src: IReadOnlyPlaybackObserver<TSource>, transform: (observationRef: IReadOnlySharedReference<TSource>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>, cancellationSignal: CancellationSignal): IReadOnlyPlaybackObserver<TDest>;

package/dist/es2017/playback_observer/utils/generate_read_only_observer.js

@@ -0,0 +1,41 @@
+/**
+ * Create `IReadOnlyPlaybackObserver` from a source `IReadOnlyPlaybackObserver`
+ * and a mapping function.
+ * @param {Object} src
+ * @param {Function} transform
+ * @returns {Object}
+ */
+export default function generateReadOnlyObserver(src, transform, cancellationSignal) {
+    const mappedRef = transform(src.getReference(), cancellationSignal);
+    return {
+        getCurrentTime() {
+            return src.getCurrentTime();
+        },
+        getReadyState() {
+            return src.getReadyState();
+        },
+        getPlaybackRate() {
+            return src.getPlaybackRate();
+        },
+        getIsPaused() {
+            return src.getIsPaused();
+        },
+        getReference() {
+            return mappedRef;
+        },
+        listen(cb, options) {
+            var _a;
+            if (cancellationSignal.isCancelled() ||
+                ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled()) === true) {
+                return;
+            }
+            mappedRef.onUpdate(cb, {
+                clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal,
+                emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
+            });
+        },
+        deriveReadOnlyObserver(newTransformFn) {
+            return generateReadOnlyObserver(this, newTransformFn, cancellationSignal);
+        },
+    };
+}

package/dist/es2017/playback_observer/utils/observation_position.d.ts

@@ -0,0 +1,87 @@
+export default class ObservationPosition {
+    /**
+     * Known position at the time the Observation was emitted, in seconds.
+     *
+     * Note that it might have changed since. If you want truly precize
+     * information, you should recuperate it from the HTMLMediaElement directly
+     * through another mean.
+     */
+    private _last;
+    /**
+     * Actually wanted position in seconds that is not yet reached.
+     *
+     * This might for example be set to the initial position when the content is
+     * loading (and thus potentially at a `0` position) but which will be seeked
+     * to a given position once possible. It may also be the position of a seek
+     * that has not been properly accounted for by the current device.
+     */
+    private _wanted;
+    constructor(last: number, wanted: number | null);
+    /**
+     * Obtain arguments allowing to instanciate the same ObservationPosition.
+     *
+     * This can be used to create a new `ObservationPosition` across JS realms,
+     * generally to communicate its data between the main thread and a WebWorker.
+     * @returns {Array.<number>}
+     */
+    serialize(): [number, number | null];
+    /**
+     * Returns the playback position actually observed on the media element at
+     * the time the playback observation was made.
+     *
+     * Note that it may be different than the position for which media data is
+     * wanted in rare scenarios where the goal position is not yet set on the
+     * media element.
+     *
+     * You should use this value when you want to obtain the actual position set
+     * on the media element for browser compatibility purposes. Note that this
+     * position was calculated at observation time, it might thus not be
+     * up-to-date if what you want is milliseconds-accuracy.
+     *
+     * If what you want is the actual position which the player is intended to
+     * play, you should rely on `getWanted` instead`.
+     * @returns {number}
+     */
+    getPolled(): number;
+    /**
+     * Returns the position which the player should consider to load media data
+     * at the time the observation was made.
+     *
+     * It can be different than the value returned by `getPolled` in rare
+     * scenarios:
+     *
+     *   - When the initial position has not been set yet.
+     *
+     *   - When the current device do not let the RxPlayer peform precize seeks,
+     *     usually for perfomance reasons by seeking to a previous IDR frame
+     *     instead (for now only Tizen may be like this), in which case we
+     *     prefer to generally rely on the position wanted by the player (this
+     *     e.g. prevents issues where the RxPlayer logic and the device are
+     *     seeking back and forth in a loop).
+     *
+     *   - When a wanted position has been "forced" (@see forceWantedPosition).
+     * @returns {number}
+     */
+    getWanted(): number;
+    /**
+     * Method to call if you want to overwrite the currently wanted position.
+     * @param {number} pos
+     */
+    forceWantedPosition(pos: number): void;
+    /**
+     * Returns `true` when the position wanted returned by `getWanted` and the
+     * actual position returned by `getPolled` may be different, meaning that
+     * we're currently not at the position we want to reach.
+     *
+     * This is a relatively rare situation which only happens when either the
+     * initial seek has not yet been performed. on specific targets where the
+     * seeking behavior is a little broken (@see getWanted) or when the wanted
+     * position has been forced (@see forceWantedPosition).
+     *
+     * In those situations, you might temporarily refrain from acting upon the
+     * actual current media position, as it may change soon.
+     *
+     * @returns {boolean}
+     */
+    isAwaitingFuturePosition(): boolean;
+}

package/dist/es2017/playback_observer/utils/observation_position.js

@@ -0,0 +1,84 @@
+export default class ObservationPosition {
+    constructor(last, wanted) {
+        this._last = last;
+        this._wanted = wanted;
+    }
+    /**
+     * Obtain arguments allowing to instanciate the same ObservationPosition.
+     *
+     * This can be used to create a new `ObservationPosition` across JS realms,
+     * generally to communicate its data between the main thread and a WebWorker.
+     * @returns {Array.<number>}
+     */
+    serialize() {
+        return [this._last, this._wanted];
+    }
+    /**
+     * Returns the playback position actually observed on the media element at
+     * the time the playback observation was made.
+     *
+     * Note that it may be different than the position for which media data is
+     * wanted in rare scenarios where the goal position is not yet set on the
+     * media element.
+     *
+     * You should use this value when you want to obtain the actual position set
+     * on the media element for browser compatibility purposes. Note that this
+     * position was calculated at observation time, it might thus not be
+     * up-to-date if what you want is milliseconds-accuracy.
+     *
+     * If what you want is the actual position which the player is intended to
+     * play, you should rely on `getWanted` instead`.
+     * @returns {number}
+     */
+    getPolled() {
+        return this._last;
+    }
+    /**
+     * Returns the position which the player should consider to load media data
+     * at the time the observation was made.
+     *
+     * It can be different than the value returned by `getPolled` in rare
+     * scenarios:
+     *
+     *   - When the initial position has not been set yet.
+     *
+     *   - When the current device do not let the RxPlayer peform precize seeks,
+     *     usually for perfomance reasons by seeking to a previous IDR frame
+     *     instead (for now only Tizen may be like this), in which case we
+     *     prefer to generally rely on the position wanted by the player (this
+     *     e.g. prevents issues where the RxPlayer logic and the device are
+     *     seeking back and forth in a loop).
+     *
+     *   - When a wanted position has been "forced" (@see forceWantedPosition).
+     * @returns {number}
+     */
+    getWanted() {
+        var _a;
+        return (_a = this._wanted) !== null && _a !== void 0 ? _a : this._last;
+    }
+    /**
+     * Method to call if you want to overwrite the currently wanted position.
+     * @param {number} pos
+     */
+    forceWantedPosition(pos) {
+        this._wanted = pos;
+    }
+    /**
+     * Returns `true` when the position wanted returned by `getWanted` and the
+     * actual position returned by `getPolled` may be different, meaning that
+     * we're currently not at the position we want to reach.
+     *
+     * This is a relatively rare situation which only happens when either the
+     * initial seek has not yet been performed. on specific targets where the
+     * seeking behavior is a little broken (@see getWanted) or when the wanted
+     * position has been forced (@see forceWantedPosition).
+     *
+     * In those situations, you might temporarily refrain from acting upon the
+     * actual current media position, as it may change soon.
+     *
+     * @returns {boolean}
+     */
+    isAwaitingFuturePosition() {
+        return this._wanted !== null;
+    }
+}

package/dist/es2017/playback_observer/worker_playback_observer.d.ts

@@ -0,0 +1,72 @@
+import type { IUpdatePlaybackRateWorkerMessage } from "../multithread_types";
+import type { ITrackType } from "../public_types";
+import type { IRange } from "../utils/ranges";
+import type { IReadOnlySharedReference } from "../utils/reference";
+import type { CancellationSignal } from "../utils/task_canceller";
+import type { IFreezingStatus, IReadOnlyPlaybackObserver, IRebufferingStatus } from "./types";
+import type ObservationPosition from "./utils/observation_position";
+export interface IWorkerPlaybackObservation {
+    /**
+     * Information on whether the media element was paused at the time of the
+     * Observation.
+     */
+    paused: IPausedPlaybackObservation;
+    /**
+     * Information on the current media position in seconds at the time of the
+     * Observation.
+     */
+    position: ObservationPosition;
+    /** `duration` property of the HTMLMediaElement. */
+    duration: number;
+    /** `readyState` property of the HTMLMediaElement. */
+    readyState: number;
+    /** Target playback rate at which we want to play the content. */
+    speed: number;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
+    /**
+     * Ranges of buffered data per type of media.
+     * `null` if no buffer exists for that type of media.
+     */
+    buffered: Record<ITrackType, IRange[] | null>;
+    rebuffering: IRebufferingStatus | null;
+    freezing: IFreezingStatus | null;
+    bufferGap: number | undefined;
+}
+/** Pause-related information linked to an emitted Playback observation. */
+export interface IPausedPlaybackObservation {
+    /**
+     * Known paused state at the time the Observation was emitted.
+     *
+     * `true` indicating that the HTMLMediaElement was in a paused state.
+     *
+     * Note that it might have changed since. If you want truly precize
+     * information, you should recuperate it from the HTMLMediaElement directly
+     * through another mean.
+     */
+    last: boolean;
+    /**
+     * Actually wanted paused state not yet reached.
+     * This might for example be set to `false` when the content is currently
+     * loading (and thus paused) but with autoPlay enabled.
+     */
+    pending: boolean | undefined;
+}
+export default class WorkerPlaybackObserver implements IReadOnlyPlaybackObserver<IWorkerPlaybackObservation> {
+    private _src;
+    private _cancelSignal;
+    private _messageSender;
+    private _contentId;
+    constructor(src: IReadOnlySharedReference<IWorkerPlaybackObservation>, contentId: string, sendMessage: (msg: IUpdatePlaybackRateWorkerMessage) => void, cancellationSignal: CancellationSignal);
+    getCurrentTime(): number | undefined;
+    getReadyState(): number | undefined;
+    getIsPaused(): boolean | undefined;
+    getReference(): IReadOnlySharedReference<IWorkerPlaybackObservation>;
+    setPlaybackRate(playbackRate: number): void;
+    getPlaybackRate(): number | undefined;
+    listen(cb: (observation: IWorkerPlaybackObservation, stopListening: () => void) => void, options?: {
+        includeLastObservation?: boolean | undefined;
+        clearSignal?: CancellationSignal | undefined;
+    }): void;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
+}

package/dist/es2017/playback_observer/worker_playback_observer.js

@@ -0,0 +1,45 @@
+import generateReadOnlyObserver from "./utils/generate_read_only_observer";
+export default class WorkerPlaybackObserver {
+    constructor(src, contentId, sendMessage, cancellationSignal) {
+        this._src = src;
+        this._contentId = contentId;
+        this._messageSender = sendMessage;
+        this._cancelSignal = cancellationSignal;
+    }
+    getCurrentTime() {
+        return undefined;
+    }
+    getReadyState() {
+        return undefined;
+    }
+    getIsPaused() {
+        return undefined;
+    }
+    getReference() {
+        return this._src;
+    }
+    setPlaybackRate(playbackRate) {
+        this._messageSender({
+            type: "update-playback-rate" /* WorkerMessageType.UpdatePlaybackRate */,
+            contentId: this._contentId,
+            value: playbackRate,
+        });
+    }
+    getPlaybackRate() {
+        return undefined;
+    }
+    listen(cb, options) {
+        var _a;
+        if (this._cancelSignal.isCancelled() ||
+            ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled()) === true) {
+            return;
+        }
+        this._src.onUpdate(cb, {
+            clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal,
+            emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
+        });
+    }
+    deriveReadOnlyObserver(transform) {
+        return generateReadOnlyObserver(this, transform, this._cancelSignal);
+    }
+}

package/dist/es2017/public_types.d.ts

@@ -2,12 +2,12 @@
  * This file defines and exports types we want to expose to library users.
  * Those types are considered as part of the API.
  */
-import { IPreferredEmeApiType } from "./compat/eme";
-import { IPersistentSessionInfoV0, IPersistentSessionInfoV1, IPersistentSessionInfoV2, IPersistentSessionInfoV3, IPersistentSessionInfoV4 } from "./core/decrypt";
-import { EncryptedMediaError, MediaError, NetworkError, OtherError } from "./errors";
-import Manifest, { ITaggedTrack } from "./manifest";
-import { ILocalManifest } from "./parsers/manifest/local";
-import { IMetaPlaylist } from "./parsers/manifest/metaplaylist/metaplaylist_parser";
+import type { IPreferredEmeApiType } from "./compat/eme";
+import type { EncryptedMediaError, MediaError, NetworkError, OtherError } from "./errors";
+import type { IPersistentSessionInfoV0, IPersistentSessionInfoV1, IPersistentSessionInfoV2, IPersistentSessionInfoV3, IPersistentSessionInfoV4 } from "./main_thread/decrypt";
+import type { IManifest, ITaggedTrack } from "./manifest";
+import type { ILocalManifest } from "./parsers/manifest/local";
+import type { IMetaPlaylist } from "./parsers/manifest/metaplaylist/metaplaylist_parser";
 export { ITaggedTrack as IMediaErrorTrackContext };
 export { IPreferredEmeApiType };
 /** `mode` option for the `loadVideo` method */
@@ -15,7 +15,7 @@ export type IRxPlayerMode = "auto" | "main" | "multithread";
 /** Argument of the `attachWorker` method. */
 export interface IWorkerSettings {
     workerUrl: string | Blob;
-    dashWasmUrl: string | ArrayBuffer;
+    dashWasmUrl?: string | ArrayBuffer | undefined;
 }
 /** Every options that can be given to the RxPlayer's constructor. */
 export interface IConstructorOptions {
@@ -126,7 +126,7 @@ export interface IServerSyncInfos {
     clientTime: number;
 }
 /** Format of a loaded Manifest before parsing. */
-export type IInitialManifest = Document | string | ArrayBuffer | IMetaPlaylist | ILocalManifest | Manifest;
+export type IInitialManifest = Document | string | ArrayBuffer | IMetaPlaylist | ILocalManifest | IManifest;
 /** Type for the `representationFilter` API. */
 export type IRepresentationFilter = (representation: IRepresentationFilterRepresentation, context: IRepresentationContext) => boolean;
 /** Representation object given to the `representationFilter` API. */
@@ -297,7 +297,8 @@ context: ISegmentLoaderContext, callbacks: {
         size: number;
         totalSize?: number | undefined;
     }) => void;
-}) => (() => void) | void;
+}) => // returns either the aborting callback or nothing
+(() => void) | void;
 /** Context given to a segment loader. */
 export interface ISegmentLoaderContext {
     /** URL where the segment should be loaded. */
@@ -355,7 +356,8 @@ info: IManifestLoaderInfo, callbacks: {
     }) => void;
     reject: (err?: Error) => void;
     fallback: () => void;
-}) => (() => void) | void;
+}) => // returns either the aborting callback or nothing
+(() => void) | void;
 export interface IManifestLoaderInfo {
     url: string | undefined;
     timeout: number | undefined;
@@ -816,12 +818,7 @@ export interface IBrokenRepresentationsLockContext {
 export interface ITrackUpdateEventPayload {
     period: IPeriod;
     trackType: ITrackType;
-    reason: "missing" | // Missing from Manifest update
-    "manual" | // Manually and explicitely updated
-    "trickmode-enabled" | // Video trickmode tracks being enabled
-    "trickmode-disabled" | // Video trickmode tracks being disabled
-    "no-playable-representation" | // Previous track had no playable Representation
-    string;
+    reason: "missing" | "manual" | "trickmode-enabled" | "trickmode-disabled" | "no-playable-representation" | string;
 }
 export interface IRepresentationListUpdateContext {
     period: IPeriod;

package/dist/es2017/public_types.js

@@ -2,5 +2,4 @@
  * This file defines and exports types we want to expose to library users.
  * Those types are considered as part of the API.
  */
-;
 export {};

package/dist/es2017/tools/TextTrackRenderer/text_track_renderer.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IFeature } from "../../features";
+import type { IFeature } from "../../features";
 /** Argument for the `setTextTrack` method. */
 export interface ISetTextTrackArguments {
     /** The text track content. Should be a string in the format indicated by `type`. */
@@ -47,7 +47,7 @@ export default class TextTrackRenderer {
      * @param {HTMLElement} opt.textTrackElement - The HTML element which will
      * contain the text tracks.
      */
-    constructor({ videoElement, textTrackElement }: {
+    constructor({ videoElement, textTrackElement, }: {
         videoElement: HTMLMediaElement;
         textTrackElement: HTMLElement;
     });