rx-player 4.4.1-dev.2025101500 → 4.4.1

package/src/playback_observer/media_element_playback_observer.ts

@@ -17,6 +17,7 @@
 import type { IMediaElement } from "../compat/browser_compatibility_types";
 import isSeekingApproximate from "../compat/is_seeking_approximate";
 import config from "../config";
+import ManualTimeRanges from "../core/segment_sinks/implementations/utils/manual_time_ranges";
 import log from "../log";
 import getMonotonicTimeStamp from "../utils/monotonic_timestamp";
 import noop from "../utils/noop";
@@ -68,9 +69,9 @@ const SCANNED_MEDIA_ELEMENTS_EVENTS = [
  */
 export default class PlaybackObserver {
   /** HTMLMediaElement which we want to observe. */
-  private _mediaElement: IMediaElement;
+  private _mediaElementRef: SharedReference<IMediaElement | null>;
 
-  /** If `true`, a `MediaSource` object is linked to `_mediaElement`. */
+  /** If `true`, a `MediaSource` object is linked to the `HTMLMediaElement`. */
   private _withMediaSource: boolean;
 
   /**
@@ -132,6 +133,8 @@ export default class PlaybackObserver {
    */
   private _expectedSeekingPosition: number | null;
 
+  private _observationIntervalId: ReturnType<typeof setInterval> | null;
+
   /**
    * If `true` seek operations asked through the
    * `MediaElementPlaybackObserver` will not be performed now but after the
@@ -143,36 +146,64 @@ export default class PlaybackObserver {
    * Create a new `PlaybackObserver`, which allows to produce new "playback
    * observations" on various media events and intervals.
    *
+   * Once a `PlaybackObserver` is created, you will want to "attach" the
+   * media element to it through the `attachMediaElement` method once that
+   * element is ready to play your content.
+   *
    * Note that creating a `PlaybackObserver` lead to the usage of resources,
    * such as event listeners which will only be freed once the `stop` method is
    * called.
-   * @param {HTMLMediaElement} mediaElement
    * @param {Object} options
    */
-  constructor(mediaElement: IMediaElement, options: IPlaybackObserverOptions) {
+  constructor(options: IPlaybackObserverOptions) {
     this._internalSeeksIncoming = [];
-    this._mediaElement = mediaElement;
+    this._mediaElementRef = new SharedReference<IMediaElement | null>(null);
     this._withMediaSource = options.withMediaSource;
     this._lowLatencyMode = options.lowLatencyMode;
     this._canceller = new TaskCanceller();
-    this._observationRef = this._createSharedReference();
     this._expectedSeekingPosition = null;
     this._pendingSeek = null;
     this._isSeekBlocked = false;
-
-    const onLoadedMetadata = () => {
-      if (this._pendingSeek !== null && !this._isSeekBlocked) {
-        const { position: positionToSeekTo, isInternal } = this._pendingSeek;
-        this._pendingSeek = null;
-        this._actuallySetCurrentTime(positionToSeekTo, isInternal);
-      }
-    };
-    mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
+    this._observationIntervalId = null;
+    this._observationRef = this._createSharedReference();
     this._canceller.signal.register(() => {
-      mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
+      this._mediaElementRef.finish();
     });
   }
 
+  /**
+   * "Link" the actual `HTMLMediaElement` to this `PlaybackObserver`.
+   *
+   * This is done in a step separate from the constructor to allow complex
+   * situations where you want to inialize the polling logic before the media
+   * element is ready to play your content (e.g. when pre-loading the next
+   * content).
+   *
+   * @param {HTMLMediaElement} mediaElement - The `HTMLMediaElement` on which
+   * the content plays.
+   */
+  public attachMediaElement(mediaElement: IMediaElement): void {
+    const prevMediaElement = this._mediaElementRef.getValue();
+    if (prevMediaElement !== null) {
+      throw new Error("A media element was already attached to this PlaybackObserver");
+    }
+    this._mediaElementRef.setValue(mediaElement);
+    if (this._canceller.isUsed()) {
+      return;
+    }
+
+    this._registerLoadedMetadataEvent(mediaElement);
+    this._restartInterval();
+    this._registerMediaElementEvents(mediaElement);
+    this._generateObservationForEvent("init");
+    if (this._canceller.isUsed()) {
+      return;
+    }
+    if (mediaElement.readyState >= 1) {
+      this._onLoadedMetadataEvent();
+    }
+  }
+
   /**
    * Stop the `PlaybackObserver` from emitting playback observations and free all
    * resources reserved to emitting them such as event listeners and intervals.
@@ -192,15 +223,21 @@ export default class PlaybackObserver {
    * @returns {number}
    */
   public getCurrentTime(): number {
-    return this._mediaElement.currentTime;
+    return (
+      this._mediaElementRef.getValue()?.currentTime ??
+      this._observationRef.getValue().position.getPolled()
+    );
   }
 
   /**
    * Returns the current playback rate advertised by the `HTMLMediaElement`.
-   * @returns {number}
+   * @returns {number|undefined}
    */
   public getPlaybackRate(): number {
-    return this._mediaElement.playbackRate;
+    return (
+      this._mediaElementRef.getValue()?.playbackRate ??
+      this._observationRef.getValue().playbackRate
+    );
   }
 
   /**
@@ -208,10 +245,12 @@ export default class PlaybackObserver {
    *
    * Use this instead of the same status emitted on an observation when you want
    * to be sure you're using the current value.
-   * @returns {boolean}
+   * @returns {boolean|undefined}
    */
   public getIsPaused(): boolean {
-    return this._mediaElement.paused;
+    return (
+      this._mediaElementRef.getValue()?.paused ?? this._observationRef.getValue().paused
+    );
   }
 
   /**
@@ -237,10 +276,15 @@ export default class PlaybackObserver {
   public unblockSeeking(): void {
     if (this._isSeekBlocked) {
       this._isSeekBlocked = false;
-      if (this._pendingSeek !== null && this._mediaElement.readyState >= 1) {
+      const mediaElement = this._mediaElementRef.getValue();
+      if (
+        mediaElement !== null &&
+        mediaElement.readyState >= 1 &&
+        this._pendingSeek !== null
+      ) {
         const { position: positionToSeekTo, isInternal } = this._pendingSeek;
         this._pendingSeek = null;
-        this._actuallySetCurrentTime(positionToSeekTo, isInternal);
+        this._actuallySetCurrentTime(mediaElement, positionToSeekTo, isInternal);
       }
     }
   }
@@ -290,31 +334,37 @@ export default class PlaybackObserver {
    * the user.
    */
   public setCurrentTime(time: number, isInternal: boolean = true): void {
-    if (!this._isSeekBlocked && this._mediaElement.readyState >= 1) {
-      this._actuallySetCurrentTime(time, isInternal);
+    const mediaElement = this._mediaElementRef.getValue();
+    if (mediaElement !== null && !this._isSeekBlocked && mediaElement.readyState >= 1) {
+      this._actuallySetCurrentTime(mediaElement, time, isInternal);
     } else {
       this._pendingSeek = { position: time, isInternal };
       this._internalSeeksIncoming = [];
-      if (!this._isSeekBlocked) {
-        this._generateObservationForEvent("manual");
-      }
+      this._generateObservationForEvent("manual");
     }
   }
 
   /**
-   * Update the playback rate of the `HTMLMediaElement`.
+   * Update the playback rate of the `HTMLmediaElement`.
    * @param {number} playbackRate
    */
   public setPlaybackRate(playbackRate: number): void {
-    this._mediaElement.playbackRate = playbackRate;
+    const mediaElement = this._mediaElementRef.getValue();
+    if (mediaElement === null) {
+      return;
+    }
+    mediaElement.playbackRate = playbackRate;
   }
 
   /**
-   * Returns the current `readyState` advertised by the `HTMLMediaElement`.
+   * Returns the current `readyState` advertised by the `HTMLmediaElement`.
    * @returns {number}
    */
   public getReadyState(): number {
-    return this._mediaElement.readyState;
+    return (
+      this._mediaElementRef.getValue()?.readyState ??
+      this._observationRef.getValue().readyState
+    );
   }
 
   /**
@@ -379,12 +429,16 @@ export default class PlaybackObserver {
     return generateReadOnlyObserver(this, transform, this._canceller.signal);
   }
 
-  private _actuallySetCurrentTime(time: number, isInternal: boolean): void {
+  private _actuallySetCurrentTime(
+    mediaElement: IMediaElement,
+    time: number,
+    isInternal: boolean,
+  ): void {
     log.info("media", "Actually seeking.", { time, isInternal });
     if (isInternal) {
       this._internalSeeksIncoming.push(time);
     }
-    this._mediaElement.currentTime = time;
+    mediaElement.currentTime = time;
   }
 
   /**
@@ -396,51 +450,25 @@ export default class PlaybackObserver {
     if (this._observationRef !== undefined) {
       return this._observationRef;
     }
-
-    const {
-      SAMPLING_INTERVAL_MEDIASOURCE,
-      SAMPLING_INTERVAL_LOW_LATENCY,
-      SAMPLING_INTERVAL_NO_MEDIASOURCE,
-    } = config.getCurrent();
     const returnedSharedReference = new SharedReference(
       this._getCurrentObservation("init"),
       this._canceller.signal,
     );
 
-    let interval: number;
-    if (this._lowLatencyMode) {
-      interval = SAMPLING_INTERVAL_LOW_LATENCY;
-    } else if (this._withMediaSource) {
-      interval = SAMPLING_INTERVAL_MEDIASOURCE;
-    } else {
-      interval = SAMPLING_INTERVAL_NO_MEDIASOURCE;
-    }
+    this._restartInterval();
 
-    const onInterval = () => {
-      this._generateObservationForEvent("timeupdate");
-    };
-    let intervalId = setInterval(onInterval, interval);
-    SCANNED_MEDIA_ELEMENTS_EVENTS.map((eventName) => {
-      const onMediaEvent = () => {
-        restartInterval();
-        this._generateObservationForEvent(eventName);
-      };
+    const mediaElement = this._mediaElementRef.getValue();
+    if (mediaElement !== null) {
+      this._registerMediaElementEvents(mediaElement);
+    }
 
-      this._mediaElement.addEventListener(eventName, onMediaEvent);
-      this._canceller.signal.register(() => {
-        this._mediaElement.removeEventListener(eventName, onMediaEvent);
-      });
-    });
     this._canceller.signal.register(() => {
-      clearInterval(intervalId);
+      if (this._observationIntervalId !== null) {
+        clearInterval(this._observationIntervalId);
+      }
       returnedSharedReference.finish();
     });
     return returnedSharedReference;
-
-    function restartInterval() {
-      clearInterval(intervalId);
-      intervalId = setInterval(onInterval, interval);
-    }
   }
 
   private _getCurrentObservation(
@@ -448,12 +476,13 @@ export default class PlaybackObserver {
   ): IPlaybackObservation {
     /** Actual event emitted through an observation. */
     let tmpEvt: IPlaybackObserverEventType = event;
+    const mediaElement = this._mediaElementRef.getValue();
 
     // NOTE: `this._observationRef` may be `undefined` because we might here be
     // called in the constructor when that property is not yet set.
     const previousObservation =
       this._observationRef === undefined
-        ? getInitialObservation(this._mediaElement)
+        ? getInitialObservation(mediaElement)
         : this._observationRef.getValue();
 
     /**
@@ -466,7 +495,8 @@ export default class PlaybackObserver {
     let pendingPosition: number | null = this._pendingSeek?.position ?? null;
 
     /** Initially-polled playback observation, before adjustments. */
-    const mediaTimings = getMediaInfos(this._mediaElement);
+    const mediaTimings =
+      mediaElement === null ? getEmptyMediaInfo() : getMediaInfos(mediaElement);
     const { buffered, readyState, position, seeking } = mediaTimings;
     if (tmpEvt === "seeking") {
       // We just began seeking.
@@ -622,6 +652,59 @@ export default class PlaybackObserver {
     }
     this._observationRef.setValue(newObservation);
   }
+
+  private _restartInterval() {
+    const {
+      SAMPLING_INTERVAL_MEDIASOURCE,
+      SAMPLING_INTERVAL_LOW_LATENCY,
+      SAMPLING_INTERVAL_NO_MEDIASOURCE,
+    } = config.getCurrent();
+    let interval: number;
+    if (this._lowLatencyMode) {
+      interval = SAMPLING_INTERVAL_LOW_LATENCY;
+    } else if (this._withMediaSource) {
+      interval = SAMPLING_INTERVAL_MEDIASOURCE;
+    } else {
+      interval = SAMPLING_INTERVAL_NO_MEDIASOURCE;
+    }
+    if (this._observationIntervalId !== null) {
+      clearInterval(this._observationIntervalId);
+    }
+    this._observationIntervalId = setInterval(
+      () => this._generateObservationForEvent("timeupdate"),
+      interval,
+    );
+  }
+
+  private _registerMediaElementEvents(mediaElement: IMediaElement): void {
+    SCANNED_MEDIA_ELEMENTS_EVENTS.map((eventName) => {
+      const onMediaEvent = () => {
+        this._restartInterval();
+        this._generateObservationForEvent(eventName);
+      };
+      mediaElement.addEventListener(eventName, onMediaEvent);
+      this._canceller.signal.register(() => {
+        mediaElement.removeEventListener(eventName, onMediaEvent);
+      });
+    });
+  }
+
+  private _registerLoadedMetadataEvent(mediaElement: IMediaElement): void {
+    const loadedmetadataCb = this._onLoadedMetadataEvent.bind(this);
+    mediaElement.addEventListener("loadedmetadata", loadedmetadataCb);
+    this._canceller.signal.register(() => {
+      mediaElement.removeEventListener("loadedmetadata", loadedmetadataCb);
+    });
+  }
+
+  private _onLoadedMetadataEvent(): void {
+    const mediaElement = this._mediaElementRef.getValue();
+    if (mediaElement !== null && this._pendingSeek !== null && !this._isSeekBlocked) {
+      const { position: positionToSeekTo, isInternal } = this._pendingSeek;
+      this._pendingSeek = null;
+      this._actuallySetCurrentTime(mediaElement, positionToSeekTo, isInternal);
+    }
+  }
 }
 
 /**
@@ -680,9 +763,29 @@ function hasLoadedUntilTheEnd(
   return currentRange !== null && duration - currentRange.end <= REBUFFERING_GAP[suffix];
 }
 
+/**
+ * Get polled media metrics for when the `HTMLMediaElement` is not yet "attached"
+ * to the `PlaybackObserver`.
+ *
+ * Those metrics actually corresponds to an idle media element.
+ * @returns {Object}
+ */
+function getEmptyMediaInfo(): IMediaInfos {
+  return {
+    buffered: new ManualTimeRanges(),
+    position: 0,
+    duration: NaN,
+    ended: false,
+    paused: true,
+    playbackRate: 1,
+    readyState: 0,
+    seeking: false,
+  };
+}
+
 /**
  * Get basic playback information.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLmediaElement} mediaElement
  * @returns {Object}
  */
 function getMediaInfos(mediaElement: IMediaElement): IMediaInfos {
@@ -985,8 +1088,9 @@ function prettyPrintBuffered(buffered: TimeRanges, currentTime: number): string
  * @param {HTMLMediaElement} mediaElement
  * @returns {Object}
  */
-function getInitialObservation(mediaElement: IMediaElement): IPlaybackObservation {
-  const mediaTimings = getMediaInfos(mediaElement);
+function getInitialObservation(mediaElement: IMediaElement | null): IPlaybackObservation {
+  const mediaTimings =
+    mediaElement === null ? getEmptyMediaInfo() : getMediaInfos(mediaElement);
   return objectAssign(mediaTimings, {
     rebuffering: null,
     event: "init" as const,

package/src/playback_observer/{core_playback_observer.ts → worker_playback_observer.ts}

@@ -1,5 +1,5 @@
-import type { IUpdatePlaybackRateCoreMessage } from "../core/types";
-import { CoreMessageType } from "../core/types";
+import type { IUpdatePlaybackRateWorkerMessage } from "../multithread_types";
+import { WorkerMessageType } from "../multithread_types";
 import type { ITrackType } from "../public_types";
 import type { IRange } from "../utils/ranges";
 import type { IReadOnlySharedReference } from "../utils/reference";
@@ -12,7 +12,7 @@ import type {
 import generateReadOnlyObserver from "./utils/generate_read_only_observer";
 import type ObservationPosition from "./utils/observation_position";
 
-export interface ICorePlaybackObservation {
+export interface IWorkerPlaybackObservation {
   /**
    * Information on whether the media element was paused at the time of the
    * Observation.
@@ -73,18 +73,18 @@ export interface IPausedPlaybackObservation {
   pending: boolean | undefined;
 }
 
-export default class CorePlaybackObserver
-  implements IReadOnlyPlaybackObserver<ICorePlaybackObservation>
+export default class WorkerPlaybackObserver
+  implements IReadOnlyPlaybackObserver<IWorkerPlaybackObservation>
 {
-  private _src: IReadOnlySharedReference<ICorePlaybackObservation>;
+  private _src: IReadOnlySharedReference<IWorkerPlaybackObservation>;
   private _cancelSignal: CancellationSignal;
-  private _messageSender: (msg: IUpdatePlaybackRateCoreMessage) => void;
+  private _messageSender: (msg: IUpdatePlaybackRateWorkerMessage) => void;
   private _contentId: string;
 
   constructor(
-    src: IReadOnlySharedReference<ICorePlaybackObservation>,
+    src: IReadOnlySharedReference<IWorkerPlaybackObservation>,
     contentId: string,
-    sendMessage: (msg: IUpdatePlaybackRateCoreMessage) => void,
+    sendMessage: (msg: IUpdatePlaybackRateWorkerMessage) => void,
     cancellationSignal: CancellationSignal,
   ) {
     this._src = src;
@@ -105,13 +105,13 @@ export default class CorePlaybackObserver
     return undefined;
   }
 
-  public getReference(): IReadOnlySharedReference<ICorePlaybackObservation> {
+  public getReference(): IReadOnlySharedReference<IWorkerPlaybackObservation> {
     return this._src;
   }
 
   public setPlaybackRate(playbackRate: number): void {
     this._messageSender({
-      type: CoreMessageType.UpdatePlaybackRate,
+      type: WorkerMessageType.UpdatePlaybackRate,
       contentId: this._contentId,
       value: playbackRate,
     });
@@ -122,7 +122,7 @@ export default class CorePlaybackObserver
   }
 
   public listen(
-    cb: (observation: ICorePlaybackObservation, stopListening: () => void) => void,
+    cb: (observation: IWorkerPlaybackObservation, stopListening: () => void) => void,
     params: {
       includeLastObservation?: boolean | undefined;
       clearSignal: CancellationSignal;
@@ -140,7 +140,7 @@ export default class CorePlaybackObserver
 
   public deriveReadOnlyObserver<TDest>(
     transform: (
-      observationRef: IReadOnlySharedReference<ICorePlaybackObservation>,
+      observationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>,
       cancellationSignal: CancellationSignal,
     ) => IReadOnlySharedReference<TDest>,
   ): IReadOnlyPlaybackObserver<TDest> {

package/src/transports/smooth/pipelines.ts

@@ -19,8 +19,6 @@ import Manifest from "../../manifest/classes";
 import { getMDAT } from "../../parsers/containers/isobmff";
 import type { ICdnMetadata } from "../../parsers/manifest";
 import createSmoothManifestParser from "../../parsers/manifest/smooth";
-import globalScope from "../../utils/global_scope";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import request from "../../utils/request";
 import { strToUtf8, utf8ToStr } from "../../utils/string_parsing";
 import type { CancellationSignal } from "../../utils/task_canceller";
@@ -71,7 +69,11 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
       const url = manifestData.url ?? parserOptions.originalUrl;
       const { receivedTime: manifestReceivedTime, responseData } = manifestData;
 
-      const documentData = getManifestAsString(responseData);
+      const documentData =
+        typeof responseData === "string"
+          ? new DOMParser().parseFromString(responseData, "text/xml")
+          : (responseData as Document); // TODO find a way to check if Document?
+
       const parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
 
       const manifest = new Manifest(parserResult, {
@@ -432,25 +434,3 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
     },
   };
 }
-
-/**
- * Try to convert a Manifest from an unknown format to a JS string format.
- *
- * Throws if the format cannot be converted.
- * @param {*} manifestSrc
- * @returns {Array.<Object | string>}
- */
-function getManifestAsString(manifestSrc: unknown): string {
-  if (manifestSrc instanceof ArrayBuffer) {
-    return utf8ToStr(new Uint8Array(manifestSrc));
-  } else if (typeof manifestSrc === "string") {
-    return manifestSrc;
-  } else if (
-    !isNullOrUndefined(globalScope.Document) &&
-    manifestSrc instanceof globalScope.Document
-  ) {
-    return manifestSrc.documentElement.outerHTML;
-  } else {
-    throw new Error("Smooth Manifest Parser: Unrecognized Manifest format");
-  }
-}

package/src/worker_entry_point.ts

@@ -3,74 +3,5 @@
  * on when running in a multithread mode.
  */
 
-import initializeCoreEntry from "./core/entry";
-import type { ICoreMessage } from "./core/types";
-import { CoreMessageType } from "./core/types";
-import log from "./experimental/tools/mediaCapabilitiesProber/log";
-import features from "./features";
-import Manifest from "./manifest/classes";
-import DashJsParser from "./parsers/manifest/dash/js-parser";
-import DashWasmParser from "./parsers/manifest/dash/wasm-parser";
-import createDashPipelines from "./transports/dash";
-import globalScope from "./utils/global_scope";
-
-// Initialize Manually a `DashWasmParser` and add the feature.
-// TODO allow worker-side feature-switching? Not sure how
-const dashWasmParser = new DashWasmParser();
-features.dashParsers.wasm = dashWasmParser;
-features.dashParsers.js = DashJsParser;
-features.transports.dash = createDashPipelines;
-
-globalScope.onmessageerror = (_msg: MessageEvent) => {
-  log.error("Core", "Error when receiving message from main thread.");
-};
-initializeCoreEntry((handler) => {
-  onmessage = handler;
-}, sendMessage);
-
-/**
- * Perform a `postMessage` to main thread with the given message.
- * Arguments follow the `postMessage` API.
- * @param {Object} msg
- * @param {Array.<Object>} [transferables]
- */
-function sendMessage(msg: ICoreMessage, transferables?: Transferable[]): void {
-  updateMessageFormat(msg);
-  if (msg.type !== CoreMessageType.LogMessage) {
-    log.debug("M<--C", "Sending message from worker", { name: msg.type });
-  }
-  if (transferables === undefined) {
-    postMessage(msg);
-  } else {
-    // TypeScript made a mistake here, and 2busy2fix
-    (postMessage as (msg: ICoreMessage, transferables: Transferable[]) => void)(
-      msg,
-      transferables,
-    );
-  }
-}
-
-/**
- * Ensure that we're sending data that can be serialized, as this is a
- * requirement for the `postMessage` browser API.
- *
- * If necessary, mutations are done in place.
- * @param {Object} msg
- */
-function updateMessageFormat(msg: ICoreMessage): void {
-  if (
-    msg.type === CoreMessageType.ManifestReady ||
-    msg.type === CoreMessageType.ManifestUpdate
-  ) {
-    if (msg.value.manifest instanceof Manifest) {
-      msg.value.manifest = msg.value.manifest.getMetadataSnapshot();
-      if (msg.type === CoreMessageType.ManifestUpdate) {
-        // Remove `periods` key to reduce cost of an unnecessary manifest
-        // clone.
-        msg.value.manifest.periods = [];
-      }
-    } else {
-      log.warn("Core", "the Manifest instance should be communicated to `sendMessage`.");
-    }
-  }
-}
+import initializeWorkerMain from "./core/main/worker";
+initializeWorkerMain();

package/dist/commonjs/core/entry/FreezeResolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FreezeResolver.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/FreezeResolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,iBAAiB,MAAM,kBAAkB,CAAC;AAiDtD;;;;;;GAMG;AACH,MAAM,WAAW,wCAAwC;IACvD,IAAI,EAAE,uBAAuB,CAAC;IAC9B,qCAAqC;IACrC,KAAK,EAAE,KAAK,CAAC;QACX,UAAU,EAAE,WAAW,CAAC;QACxB,MAAM,EAAE,OAAO,CAAC;QAChB,cAAc,EAAE,eAAe,CAAC;KACjC,CAAC,CAAC;CACJ;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE;QACL;;;WAGG;QACH,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,IAAI,CAAC;CACb;AAED,mEAAmE;AACnE,MAAM,MAAM,iBAAiB,GACzB,wCAAwC,GACxC,sBAAsB,GACtB,uBAAuB,CAAC;AAE5B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,qEAAqE;IACrE,OAAO,CAAC,kBAAkB,CAAoB;IAE9C,8EAA8E;IAC9E,OAAO,CAAC,gBAAgB,CAKtB;IAEF;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB,CAAgB;IAE1C;;;;OAIG;IACH,OAAO,CAAC,iBAAiB,CAKhB;IAET;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,uCAAuC,CAAgB;gBAEnD,iBAAiB,EAAE,iBAAiB;IAWhD;;;;;;;;;;;;OAYG;IACI,gBAAgB,CACrB,WAAW,EAAE,0BAA0B,GACtC,iBAAiB,GAAG,IAAI;IAqF3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,qCAAqC;IAwD7C;;;;;;;;;OASG;IACH,OAAO,CAAC,2BAA2B;IA0GnC;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;CA4C9B;AA4ED,2DAA2D;AAC3D,MAAM,WAAW,0BAA0B;IACzC,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,WAAW,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACvC;;;;;;OAMG;IACH,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC;;;;OAIG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,kEAAkE;IAClE,WAAW,EAAE,OAAO,CAAC;CACtB"}

package/dist/commonjs/core/entry/content_preparer.d.ts.map

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

package/dist/commonjs/core/entry/content_time_boundaries_observer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content_time_boundaries_observer.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/content_time_boundaries_observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,sCAAsC,EACtC,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EAEX,OAAO,EACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,YAAY,MAAM,2BAA2B,CAAC;AAMrD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,OAAO,6BAA8B,SAAQ,YAAY,CAAC,mCAAmC,CAAC;IAC1G,mFAAmF;IACnF,OAAO,CAAC,UAAU,CAAgB;IAElC,oDAAoD;IACpD,OAAO,CAAC,cAAc,CAAuC;IAE7D,2DAA2D;IAC3D,OAAO,CAAC,SAAS,CAAY;IAE7B,uEAAuE;IACvE,OAAO,CAAC,0BAA0B,CAA4B;IAE9D,kEAAkE;IAClE,OAAO,CAAC,eAAe,CAAgB;IAEvC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB,CAAgB;IAE5C;;;OAGG;gBAED,QAAQ,EAAE,SAAS,EACnB,gBAAgB,EAAE,yBAAyB,CAAC,sCAAsC,CAAC,EACnF,WAAW,EAAE,WAAW,EAAE;IA6D5B;;;;OAIG;IACI,oBAAoB,IAAI,0BAA0B;IAIzD;;;;;;;;;;;;OAYG;IACI,kBAAkB,CACvB,UAAU,EAAE,WAAW,EACvB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,WAAW,GAAG,IAAI,GAC7B,IAAI;IA+BP;;;;;;;;;OASG;IACI,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAI7E;;;;;;;;;OASG;IACI,eAAe,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAItE;;;;;;;;OAQG;IACI,4BAA4B,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAQlE;;;;;;;;;;OAUG;IACI,0BAA0B,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAQhE;;;OAGG;IACI,OAAO;IAKd,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,mBAAmB;IAkC3B,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,6BAA6B;IAYrC,OAAO,CAAC,iBAAiB;CAc1B;AAED,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;;;;OAUG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,mCAAmC;IAClD,mDAAmD;IACnD,OAAO,EAAE,YAAY,CAAC;IACtB,0DAA0D;IAC1D,YAAY,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,oBAAoB,EAAE,0BAA0B,CAAC;IACjD;;;;;;;;;OASG;IACH,WAAW,EAAE,IAAI,CAAC;IAClB;;;;;;;;;OASG;IACH,YAAY,EAAE,IAAI,CAAC;CACpB;AAgPD,MAAM,MAAM,uCAAuC,GAAG,IAAI,CACxD,sCAAsC,EACtC,UAAU,CACX,CAAC"}

package/dist/commonjs/core/entry/core_entry.d.ts

@@ -1,36 +0,0 @@
-import type { IMainThreadMessage } from "../../main_thread/types";
-import SharedReference from "../../utils/reference";
-import type { ICoreMessage, IResolutionInfo } from "../types";
-export type IMessageReceiverCallback = (evt: {
-    data: IMainThreadMessage;
-}) => void;
-/**
- * Initialize a `CoreEntry`, which is the part of the RxPlayer acting as an
- * entry point to all its "core" code.
- *
- * Its role is to receive and react to messages coming from "main thead", which
- * may include loading and playing a content, and to send back messages for the main
- * thread.
- * @param {Function} setMessageReceiver - Declares the function that will
- * receive messages coming from the "main thread" part of the RxPlayer logic.
- * @param {Function} sendMessage - Function allowing to send messages to the
- * "main thread" part of the RxPlayer logic.
- */
-export default function initializeCoreEntry(setMessageReceiver: (cb: IMessageReceiverCallback) => void, sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void): void;
-/**
- * Collection of so-called "references": values configuring playback that may
- * be updated at any time and that the CoreEntry should react on.
- */
-export interface ICoreReferences {
-    limitVideoResolution: SharedReference<IResolutionInfo>;
-    /** Max buffer size after the current position, in seconds (we GC further up). */
-    maxBufferAhead: SharedReference<number>;
-    /** Max buffer size before the current position, in seconds (we GC further down). */
-    maxBufferBehind: SharedReference<number>;
-    /** Buffer maximum size in kiloBytes at which we stop downloading */
-    maxVideoBufferSize: SharedReference<number>;
-    throttleVideoBitrate: SharedReference<number>;
-    /** Buffer "goal" at which we stop downloading new segments. */
-    wantedBufferAhead: SharedReference<number>;
-}
-//# sourceMappingURL=core_entry.d.ts.map

package/dist/commonjs/core/entry/core_entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core_entry.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/core_entry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,kBAAkB,EAGnB,MAAM,yBAAyB,CAAC;AAajC,OAAO,eAAe,MAAM,uBAAuB,CAAC;AAQpD,OAAO,KAAK,EACV,YAAY,EAEZ,eAAe,EAChB,MAAM,UAAU,CAAC;AAUlB,MAAM,MAAM,wBAAwB,GAAG,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,KAAK,IAAI,CAAC;AAEnF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,kBAAkB,EAAE,CAAC,EAAE,EAAE,wBAAwB,KAAK,IAAI,EAC1D,WAAW,EAAE,CAAC,GAAG,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,GACvE,IAAI,CA6YN;AA2vBD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,oBAAoB,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IACvD,iFAAiF;IACjF,cAAc,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IACxC,oFAAoF;IACpF,eAAe,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IACzC,oEAAoE;IACpE,kBAAkB,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC5C,oBAAoB,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC9C,+DAA+D;IAC/D,iBAAiB,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;CAC5C"}