rx-player 4.4.1 → 4.5.0-dev.2026012301

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

@@ -1,226 +0,0 @@
-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;
-    /** If `true` the content is loaded until its maximum position. */
-    fullyLoaded: boolean;
-    /**
-     * 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;
-    }): 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>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/commonjs/playback_observer/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/playback_observer/types.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/playback_observer/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,12 +0,0 @@
-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>;
-//# sourceMappingURL=generate_read_only_observer.d.ts.map

package/dist/commonjs/playback_observer/utils/generate_read_only_observer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate_read_only_observer.d.ts","sourceRoot":"","sources":["../../../../src/playback_observer/utils/generate_read_only_observer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAC7D,GAAG,EAAE,yBAAyB,CAAC,OAAO,CAAC,EACvC,SAAS,EAAE,CACT,cAAc,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACjD,kBAAkB,EAAE,kBAAkB,KACnC,wBAAwB,CAAC,KAAK,CAAC,EACpC,kBAAkB,EAAE,kBAAkB,GACrC,yBAAyB,CAAC,KAAK,CAAC,CA0ClC"}

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

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = generateReadOnlyObserver;
-/**
- * Create `IReadOnlyPlaybackObserver` from a source `IReadOnlyPlaybackObserver`
- * and a mapping function.
- * @param {Object} src
- * @param {Function} transform
- * @returns {Object}
- */
-function generateReadOnlyObserver(src, transform, cancellationSignal) {
-    var mappedRef = transform(src.getReference(), cancellationSignal);
-    return {
-        getCurrentTime: function () {
-            return src.getCurrentTime();
-        },
-        getReadyState: function () {
-            return src.getReadyState();
-        },
-        getPlaybackRate: function () {
-            return src.getPlaybackRate();
-        },
-        getIsPaused: function () {
-            return src.getIsPaused();
-        },
-        getReference: function () {
-            return mappedRef;
-        },
-        listen: function (cb, params) {
-            if (cancellationSignal.isCancelled() || params.clearSignal.isCancelled()) {
-                return;
-            }
-            mappedRef.onUpdate(cb, {
-                clearSignal: params.clearSignal,
-                emitCurrentValue: params.includeLastObservation,
-            });
-        },
-        deriveReadOnlyObserver: function (newTransformFn) {
-            return generateReadOnlyObserver(this, newTransformFn, cancellationSignal);
-        },
-    };
-}

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

@@ -1,99 +0,0 @@
-/**
- * Class facilitating the exploitation of what could be called the "playback
- * position" (the position at which we should currently be playing).
- *
- * In appearance a simple concept, it has in reality some gotchas that we wanted
- * to make more explicit.
- * As such, this class defines multiple methods to obtain an estimate of it,
- * each having its own pros and cons.
- *
- * @class ObservationPosition
- */
-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;
-}
-//# sourceMappingURL=observation_position.d.ts.map

package/dist/commonjs/playback_observer/utils/observation_position.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observation_position.d.ts","sourceRoot":"","sources":["../../../../src/playback_observer/utils/observation_position.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAmB;IACtC;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,CAAS;IACtB;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,CAAgB;gBACnB,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/C;;;;;;OAMG;IACI,SAAS,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAI3C;;;;;;;;;;;;;;;;OAgBG;IACI,SAAS,IAAI,MAAM;IAI1B;;;;;;;;;;;;;;;;;;OAkBG;IACI,SAAS,IAAI,MAAM;IAI1B;;;OAGG;IACI,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7C;;;;;;;;;;;;;;OAcG;IACI,wBAAwB,IAAI,OAAO;CAG3C"}

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

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Class facilitating the exploitation of what could be called the "playback
- * position" (the position at which we should currently be playing).
- *
- * In appearance a simple concept, it has in reality some gotchas that we wanted
- * to make more explicit.
- * As such, this class defines multiple methods to obtain an estimate of it,
- * each having its own pros and cons.
- *
- * @class ObservationPosition
- */
-var ObservationPosition = /** @class */ (function () {
-    function ObservationPosition(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>}
-     */
-    ObservationPosition.prototype.serialize = function () {
-        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}
-     */
-    ObservationPosition.prototype.getPolled = function () {
-        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}
-     */
-    ObservationPosition.prototype.getWanted = function () {
-        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
-     */
-    ObservationPosition.prototype.forceWantedPosition = function (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}
-     */
-    ObservationPosition.prototype.isAwaitingFuturePosition = function () {
-        return this._wanted !== null;
-    };
-    return ObservationPosition;
-}());
-exports.default = ObservationPosition;

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

@@ -1,85 +0,0 @@
-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;
-    /**
-     * Indicates whether the user agent believes it has enough buffered data to ensure
-     * uninterrupted playback for a meaningful period or needs more data.
-     * It also reflects whether the user agent can retrieve and buffer data in an
-     * energy-efficient manner while maintaining the desired memory usage.
-     * `true` indicates that the buffer is low, and more data should be buffered.
-     * `false` indicates that there is enough buffered data, and no additional data needs
-     *  to be buffered at this time.
-     */
-    canStream: boolean;
-    /** If `true` the content is loaded until its maximum position. */
-    fullyLoaded: boolean;
-}
-/** 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, params: {
-        includeLastObservation?: boolean | undefined;
-        clearSignal: CancellationSignal;
-    }): void;
-    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
-}
-//# sourceMappingURL=worker_playback_observer.d.ts.map

package/dist/commonjs/playback_observer/worker_playback_observer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_playback_observer.d.ts","sourceRoot":"","sources":["../../../src/playback_observer/worker_playback_observer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EACzB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,mBAAmB,MAAM,8BAA8B,CAAC;AAEpE,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,MAAM,EAAE,0BAA0B,CAAC;IACnC;;;OAGG;IACH,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;IAC9C,WAAW,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACvC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;OAQG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,2EAA2E;AAC3E,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;OAQG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;CAC9B;AAED,MAAM,CAAC,OAAO,OAAO,sBACnB,YAAW,yBAAyB,CAAC,0BAA0B,CAAC;IAEhE,OAAO,CAAC,IAAI,CAAuD;IACnE,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,cAAc,CAAkD;IACxE,OAAO,CAAC,UAAU,CAAS;gBAGzB,GAAG,EAAE,wBAAwB,CAAC,0BAA0B,CAAC,EACzD,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,CAAC,GAAG,EAAE,gCAAgC,KAAK,IAAI,EAC5D,kBAAkB,EAAE,kBAAkB;IAQjC,cAAc,IAAI,MAAM,GAAG,SAAS;IAIpC,aAAa,IAAI,MAAM,GAAG,SAAS;IAInC,WAAW,IAAI,OAAO,GAAG,SAAS;IAIlC,YAAY,IAAI,wBAAwB,CAAC,0BAA0B,CAAC;IAIpE,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAQ3C,eAAe,IAAI,MAAM,GAAG,SAAS;IAIrC,MAAM,CACX,EAAE,EAAE,CAAC,WAAW,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,IAAI,KAAK,IAAI,EAChF,MAAM,EAAE;QACN,sBAAsB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC7C,WAAW,EAAE,kBAAkB,CAAC;KACjC,GACA,IAAI;IAWA,sBAAsB,CAAC,KAAK,EACjC,SAAS,EAAE,CACT,cAAc,EAAE,wBAAwB,CAAC,0BAA0B,CAAC,EACpE,kBAAkB,EAAE,kBAAkB,KACnC,wBAAwB,CAAC,KAAK,CAAC,GACnC,yBAAyB,CAAC,KAAK,CAAC;CAGpC"}

package/dist/commonjs/playback_observer/worker_playback_observer.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var generate_read_only_observer_1 = require("./utils/generate_read_only_observer");
-var WorkerPlaybackObserver = /** @class */ (function () {
-    function WorkerPlaybackObserver(src, contentId, sendMessage, cancellationSignal) {
-        this._src = src;
-        this._contentId = contentId;
-        this._messageSender = sendMessage;
-        this._cancelSignal = cancellationSignal;
-    }
-    WorkerPlaybackObserver.prototype.getCurrentTime = function () {
-        return undefined;
-    };
-    WorkerPlaybackObserver.prototype.getReadyState = function () {
-        return undefined;
-    };
-    WorkerPlaybackObserver.prototype.getIsPaused = function () {
-        return undefined;
-    };
-    WorkerPlaybackObserver.prototype.getReference = function () {
-        return this._src;
-    };
-    WorkerPlaybackObserver.prototype.setPlaybackRate = function (playbackRate) {
-        this._messageSender({
-            type: "update-playback-rate" /* WorkerMessageType.UpdatePlaybackRate */,
-            contentId: this._contentId,
-            value: playbackRate,
-        });
-    };
-    WorkerPlaybackObserver.prototype.getPlaybackRate = function () {
-        return undefined;
-    };
-    WorkerPlaybackObserver.prototype.listen = function (cb, params) {
-        if (this._cancelSignal.isCancelled() || params.clearSignal.isCancelled()) {
-            return;
-        }
-        this._src.onUpdate(cb, {
-            clearSignal: params.clearSignal,
-            emitCurrentValue: params.includeLastObservation,
-        });
-    };
-    WorkerPlaybackObserver.prototype.deriveReadOnlyObserver = function (transform) {
-        return (0, generate_read_only_observer_1.default)(this, transform, this._cancelSignal);
-    };
-    return WorkerPlaybackObserver;
-}());
-exports.default = WorkerPlaybackObserver;