rx-player 4.4.1-dev.2025101500 → 4.4.1

package/dist/es2017/playback_observer/media_element_playback_observer.js

@@ -15,6 +15,7 @@
  */
 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";
@@ -56,34 +57,61 @@ 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, options) {
+    constructor(options) {
         this._internalSeeksIncoming = [];
-        this._mediaElement = mediaElement;
+        this._mediaElementRef = new SharedReference(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.
+     */
+    attachMediaElement(mediaElement) {
+        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.
@@ -102,24 +130,27 @@ export default class PlaybackObserver {
      * @returns {number}
      */
     getCurrentTime() {
-        return this._mediaElement.currentTime;
+        var _a, _b;
+        return ((_b = (_a = this._mediaElementRef.getValue()) === null || _a === void 0 ? void 0 : _a.currentTime) !== null && _b !== void 0 ? _b : this._observationRef.getValue().position.getPolled());
     }
     /**
      * Returns the current playback rate advertised by the `HTMLMediaElement`.
-     * @returns {number}
+     * @returns {number|undefined}
      */
     getPlaybackRate() {
-        return this._mediaElement.playbackRate;
+        var _a, _b;
+        return ((_b = (_a = this._mediaElementRef.getValue()) === null || _a === void 0 ? void 0 : _a.playbackRate) !== null && _b !== void 0 ? _b : this._observationRef.getValue().playbackRate);
     }
     /**
      * 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 {boolean}
+     * @returns {boolean|undefined}
      */
     getIsPaused() {
-        return this._mediaElement.paused;
+        var _a, _b;
+        return ((_b = (_a = this._mediaElementRef.getValue()) === null || _a === void 0 ? void 0 : _a.paused) !== null && _b !== void 0 ? _b : this._observationRef.getValue().paused);
     }
     /**
      * Prevent seeking operations from being performed from inside the
@@ -143,10 +174,13 @@ export default class PlaybackObserver {
     unblockSeeking() {
         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);
             }
         }
     }
@@ -193,30 +227,34 @@ export default class PlaybackObserver {
      * the user.
      */
     setCurrentTime(time, isInternal = true) {
-        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
      */
     setPlaybackRate(playbackRate) {
-        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}
      */
     getReadyState() {
-        return this._mediaElement.readyState;
+        var _a, _b;
+        return ((_b = (_a = this._mediaElementRef.getValue()) === null || _a === void 0 ? void 0 : _a.readyState) !== null && _b !== void 0 ? _b : this._observationRef.getValue().readyState);
     }
     /**
      * Returns an `IReadOnlySharedReference` storing the last playback observation
@@ -266,12 +304,12 @@ export default class PlaybackObserver {
     deriveReadOnlyObserver(transform) {
         return generateReadOnlyObserver(this, transform, this._canceller.signal);
     }
-    _actuallySetCurrentTime(time, isInternal) {
+    _actuallySetCurrentTime(mediaElement, time, isInternal) {
         log.info("media", "Actually seeking.", { time, isInternal });
         if (isInternal) {
             this._internalSeeksIncoming.push(time);
         }
-        this._mediaElement.currentTime = time;
+        mediaElement.currentTime = time;
     }
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
@@ -282,50 +320,29 @@ 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;
-        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 mediaElement = this._mediaElementRef.getValue();
+        if (mediaElement !== null) {
+            this._registerMediaElementEvents(mediaElement);
         }
-        const onInterval = () => {
-            this._generateObservationForEvent("timeupdate");
-        };
-        let intervalId = setInterval(onInterval, interval);
-        SCANNED_MEDIA_ELEMENTS_EVENTS.map((eventName) => {
-            const onMediaEvent = () => {
-                restartInterval();
-                this._generateObservationForEvent(eventName);
-            };
-            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);
-        }
     }
     _getCurrentObservation(event) {
         var _a, _b, _c, _d;
         /** Actual event emitted through an observation. */
         let tmpEvt = 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();
         /**
          * If `true`, there is a seek operation ongoing but it was done from the
@@ -335,7 +352,7 @@ export default class PlaybackObserver {
         /** If set, the position for which we plan to seek to as soon as possible. */
         let pendingPosition = (_b = (_a = this._pendingSeek) === null || _a === void 0 ? void 0 : _a.position) !== null && _b !== void 0 ? _b : 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.
@@ -466,6 +483,50 @@ export default class PlaybackObserver {
         }
         this._observationRef.setValue(newObservation);
     }
+    _restartInterval() {
+        const { SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE, } = config.getCurrent();
+        let interval;
+        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);
+    }
+    _registerMediaElementEvents(mediaElement) {
+        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);
+            });
+        });
+    }
+    _registerLoadedMetadataEvent(mediaElement) {
+        const loadedmetadataCb = this._onLoadedMetadataEvent.bind(this);
+        mediaElement.addEventListener("loadedmetadata", loadedmetadataCb);
+        this._canceller.signal.register(() => {
+            mediaElement.removeEventListener("loadedmetadata", loadedmetadataCb);
+        });
+    }
+    _onLoadedMetadataEvent() {
+        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);
+        }
+    }
 }
 /**
  * Returns the amount of time in seconds the buffer should have ahead of the
@@ -507,9 +568,28 @@ function hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLat
     }
     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() {
+    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) {
@@ -738,7 +818,7 @@ function prettyPrintBuffered(buffered, currentTime) {
  * @returns {Object}
  */
 function getInitialObservation(mediaElement) {
-    const mediaTimings = getMediaInfos(mediaElement);
+    const mediaTimings = mediaElement === null ? getEmptyMediaInfo() : getMediaInfos(mediaElement);
     return objectAssign(mediaTimings, {
         rebuffering: null,
         event: "init",

package/dist/{commonjs/playback_observer/core_playback_observer.d.ts → es2017/playback_observer/worker_playback_observer.d.ts}

@@ -1,11 +1,11 @@
-import type { IUpdatePlaybackRateCoreMessage } from "../core/types";
+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 ICorePlaybackObservation {
+export interface IWorkerPlaybackObservation {
     /**
      * Information on whether the media element was paused at the time of the
      * Observation.
@@ -64,22 +64,22 @@ export interface IPausedPlaybackObservation {
      */
     pending: boolean | undefined;
 }
-export default class CorePlaybackObserver implements IReadOnlyPlaybackObserver<ICorePlaybackObservation> {
+export default class WorkerPlaybackObserver implements IReadOnlyPlaybackObserver<IWorkerPlaybackObservation> {
     private _src;
     private _cancelSignal;
     private _messageSender;
     private _contentId;
-    constructor(src: IReadOnlySharedReference<ICorePlaybackObservation>, contentId: string, sendMessage: (msg: IUpdatePlaybackRateCoreMessage) => void, cancellationSignal: CancellationSignal);
+    constructor(src: IReadOnlySharedReference<IWorkerPlaybackObservation>, contentId: string, sendMessage: (msg: IUpdatePlaybackRateWorkerMessage) => void, cancellationSignal: CancellationSignal);
     getCurrentTime(): number | undefined;
     getReadyState(): number | undefined;
     getIsPaused(): boolean | undefined;
-    getReference(): IReadOnlySharedReference<ICorePlaybackObservation>;
+    getReference(): IReadOnlySharedReference<IWorkerPlaybackObservation>;
     setPlaybackRate(playbackRate: number): void;
     getPlaybackRate(): number | undefined;
-    listen(cb: (observation: ICorePlaybackObservation, stopListening: () => void) => void, params: {
+    listen(cb: (observation: IWorkerPlaybackObservation, stopListening: () => void) => void, params: {
         includeLastObservation?: boolean | undefined;
         clearSignal: CancellationSignal;
     }): void;
-    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<ICorePlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
 }
-//# sourceMappingURL=core_playback_observer.d.ts.map
+//# sourceMappingURL=worker_playback_observer.d.ts.map

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

@@ -0,0 +1 @@
+{"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/es2017/playback_observer/{core_playback_observer.js → worker_playback_observer.js}

@@ -1,5 +1,5 @@
 import generateReadOnlyObserver from "./utils/generate_read_only_observer";
-export default class CorePlaybackObserver {
+export default class WorkerPlaybackObserver {
     constructor(src, contentId, sendMessage, cancellationSignal) {
         this._src = src;
         this._contentId = contentId;
@@ -20,7 +20,7 @@ export default class CorePlaybackObserver {
     }
     setPlaybackRate(playbackRate) {
         this._messageSender({
-            type: "update-playback-rate" /* CoreMessageType.UpdatePlaybackRate */,
+            type: "update-playback-rate" /* WorkerMessageType.UpdatePlaybackRate */,
             contentId: this._contentId,
             value: playbackRate,
         });

package/dist/es2017/transports/smooth/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/smooth/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH,OAAO,KAAK,EAgBV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAUlB,MAAM,CAAC,OAAO,WAAW,gBAAgB,EAAE,iBAAiB,GAAG,mBAAmB,CA2XjF"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../../../../src/transports/smooth/pipelines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,OAAO,KAAK,EAgBV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAUlB,MAAM,CAAC,OAAO,WAAW,gBAAgB,EAAE,iBAAiB,GAAG,mBAAmB,CA+XjF"}

package/dist/es2017/transports/smooth/pipelines.js

@@ -17,8 +17,6 @@ import log from "../../log";
 import Manifest from "../../manifest/classes";
 import { getMDAT } from "../../parsers/containers/isobmff";
 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 addQueryString from "../utils/add_query_string";
@@ -42,7 +40,9 @@ export default function (transportOptions) {
             var _a;
             const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
             const { receivedTime: manifestReceivedTime, responseData } = manifestData;
-            const documentData = getManifestAsString(responseData);
+            const documentData = typeof responseData === "string"
+                ? new DOMParser().parseFromString(responseData, "text/xml")
+                : responseData; // TODO find a way to check if Document?
             const parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
             const manifest = new Manifest(parserResult, {
                 representationFilter: transportOptions.representationFilter,
@@ -334,25 +334,3 @@ export default function (transportOptions) {
         },
     };
 }
-/**
- * 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) {
-    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/dist/es2017/worker_entry_point.js

@@ -2,65 +2,5 @@
  * This file is the entry point of the worker part of the RxPlayer, only relied
  * on when running in a multithread mode.
  */
-import initializeCoreEntry from "./core/entry";
-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) => {
-    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, transferables) {
-    updateMessageFormat(msg);
-    if (msg.type !== "log" /* 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(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) {
-    if (msg.type === "manifest-ready" /* CoreMessageType.ManifestReady */ ||
-        msg.type === "manifest-update" /* CoreMessageType.ManifestUpdate */) {
-        if (msg.value.manifest instanceof Manifest) {
-            msg.value.manifest = msg.value.manifest.getMetadataSnapshot();
-            if (msg.type === "manifest-update" /* 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();