rx-player 3.33.4-dev.2024083000 → 3.33.4

package/dist/_esm5.processed/core/init/utils/create_stream_playback_observer.js

@@ -71,9 +71,11 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, _a, fn
                 duration: observation.duration,
                 paused: {
                     last: observation.paused,
-                    pending: initialPlayPerformed.getValue() ? undefined :
-                        !autoPlay === observation.paused ? undefined :
-                            !autoPlay,
+                    pending: initialPlayPerformed.getValue()
+                        ? undefined
+                        : !autoPlay === observation.paused
+                            ? undefined
+                            : !autoPlay,
                 },
                 readyState: observation.readyState,
                 speed: lastSpeed,

package/dist/_esm5.processed/core/init/utils/end_of_stream.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CancellationSignal } from "../../../utils/task_canceller";
+import type { CancellationSignal } from "../../../utils/task_canceller";
 /**
  * Trigger the `endOfStream` method of a MediaSource.
  *

package/dist/_esm5.processed/core/init/utils/get_initial_time.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest from "../../../manifest";
+import type Manifest from "../../../manifest";
 /**
  * All possible initial time options that can be set.
  *

package/dist/_esm5.processed/core/init/utils/get_initial_time.js

@@ -40,30 +40,27 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         }
         else if (!isNullOrUndefined(startAt.wallClockTime)) {
             log.debug("Init: using startAt.wallClockTime");
-            var ast = manifest.availabilityStartTime === undefined ?
-                0 :
-                manifest.availabilityStartTime;
+            var ast = manifest.availabilityStartTime === undefined ? 0 : manifest.availabilityStartTime;
             var position = startAt.wallClockTime - ast;
             return Math.max(Math.min(position, max), min);
         }
         else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
             log.debug("Init: using startAt.fromFirstPosition");
             var fromFirstPosition = startAt.fromFirstPosition;
-            return fromFirstPosition <= 0 ? min :
-                Math.min(max, min + fromFirstPosition);
+            return fromFirstPosition <= 0 ? min : Math.min(max, min + fromFirstPosition);
         }
         else if (!isNullOrUndefined(startAt.fromLastPosition)) {
             log.debug("Init: using startAt.fromLastPosition");
             var fromLastPosition = startAt.fromLastPosition;
-            return fromLastPosition >= 0 ? max :
-                Math.max(min, max + fromLastPosition);
+            return fromLastPosition >= 0 ? max : Math.max(min, max + fromLastPosition);
         }
         else if (!isNullOrUndefined(startAt.fromLivePosition)) {
             log.debug("Init: using startAt.fromLivePosition");
             var livePosition = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : max;
             var fromLivePosition = startAt.fromLivePosition;
-            return fromLivePosition >= 0 ? livePosition :
-                Math.max(min, livePosition + fromLivePosition);
+            return fromLivePosition >= 0
+                ? livePosition
+                : Math.max(min, livePosition + fromLivePosition);
         }
         else if (!isNullOrUndefined(startAt.percentage)) {
             log.debug("Init: using startAt.percentage");
@@ -93,15 +90,15 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         else {
             log.info("Init: clock offset found for a live content, " +
                 "checking if we can start close to it");
-            var ast = manifest.availabilityStartTime === undefined ?
-                0 :
-                manifest.availabilityStartTime;
+            var ast = manifest.availabilityStartTime === undefined ? 0 : manifest.availabilityStartTime;
             var clockRelativeLiveTime = (performance.now() + clockOffset) / 1000 - ast;
             liveTime = Math.min(maximumPosition, clockRelativeLiveTime);
         }
-        var diffFromLiveTime = suggestedPresentationDelay !== undefined ? suggestedPresentationDelay :
-            lowLatencyMode ? DEFAULT_LIVE_GAP.LOW_LATENCY :
-                DEFAULT_LIVE_GAP.DEFAULT;
+        var diffFromLiveTime = suggestedPresentationDelay !== undefined
+            ? suggestedPresentationDelay
+            : lowLatencyMode
+                ? DEFAULT_LIVE_GAP.LOW_LATENCY
+                : DEFAULT_LIVE_GAP.DEFAULT;
         log.debug("Init: ".concat(liveTime, " defined as the live time, applying a live gap") +
             " of ".concat(diffFromLiveTime));
         return Math.max(liveTime - diffFromLiveTime, minimumPosition);

package/dist/_esm5.processed/core/init/utils/get_loaded_reference.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../api";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../api";
 /**
  * Returns an `IReadOnlySharedReference` that switches to `true` once the
  * content is considered loaded (i.e. once it can begin to be played).

package/dist/_esm5.processed/core/init/utils/get_loaded_reference.js

@@ -47,8 +47,7 @@ export default function getLoadedReference(playbackObserver, mediaElement, isDir
                 return;
             }
         }
-        var minReadyState = shouldWaitForHaveEnoughData() ? 4 :
-            3;
+        var minReadyState = shouldWaitForHaveEnoughData() ? 4 : 3;
         if (observation.readyState >= minReadyState) {
             if (observation.currentRange !== null || observation.ended) {
                 if (!shouldValidateMetadata() || mediaElement.duration > 0) {

package/dist/_esm5.processed/core/init/utils/initial_seek_and_play.d.ts

@@ -13,25 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPlayerError } from "../../../public_types";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { PlaybackObserver } from "../../api";
+import type { IPlayerError } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { PlaybackObserver } from "../../api";
 /** Event emitted when trying to perform the initial `play`. */
 export type IInitialPlayEvent = 
 /** Autoplay is not enabled, but all required steps to do so are there. */
 {
     type: "skipped";
-} | 
+}
 /**
  * Tried to play, but autoplay is blocked by the browser.
  * A corresponding warning should have already been sent.
  */
-{
+ | {
     type: "autoplay-blocked";
-} | 
+}
 /** Autoplay was done with success. */
-{
+ | {
     type: "autoplay";
 };
 /** Object returned by `initialSeekAndPlay`. */
@@ -61,4 +61,4 @@ export interface IInitialSeekAndPlayObject {
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function performInitialSeekAndPlay(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver, startTime: number | (() => number), mustAutoPlay: boolean, onWarning: (err: IPlayerError) => void, isDirectfile: boolean, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;
+export default function performInitialSeekAndPlay(mediaElement: HTMLMediaElement, playbackObserver: PlaybackObserver, startTime: number | (() => number | undefined), mustAutoPlay: boolean, onWarning: (err: IPlayerError) => void, isDirectfile: boolean, cancelSignal: CancellationSignal): IInitialSeekAndPlayObject;

package/dist/_esm5.processed/core/init/utils/initial_seek_and_play.js

@@ -70,9 +70,45 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
         // non-Directfile contents, yet only through the `HTMLMediaElement` once a
         // a sufficient `readyState` has been reached for directfile contents.
         // So let's divide the two possibilities here.
-        var initialTime = typeof startTime === "function" ? startTime() :
-            startTime;
-        if (shouldPreventSeekingAt0Initially() && initialTime === 0) {
+        var initialTime = typeof startTime === "function" ? startTime() : startTime;
+        if (initialTime === undefined &&
+            isDirectfile &&
+            mediaElement.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
+            /**
+             * The starting position may not be known yet.
+             * Postpone the seek to a moment where the starting position should be known,
+             * assumely it's when readyState is greater or equal to HAVE_CURRENT_DATA (2).
+             * If the initiallySeekedTime is still `undefined` when the readyState is >= 2,
+             * let assume that the initiallySeekedTime will never be known and continue
+             * the logic without seeking.
+             */
+            playbackObserver.listen(function (obs, stopListening) {
+                if (obs.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+                    var observationInitialTime_1 = typeof startTime === "function" ? startTime() : startTime;
+                    if (observationInitialTime_1 === undefined) {
+                        initialSeekPerformed.setValue(true);
+                        initialSeekPerformed.finish();
+                    }
+                    else if (isDirectfile && isSafariMobile) {
+                        // On safari mobile (version 17.1.2) seeking too early cause the video
+                        // to never buffer media data. Using setTimeout 0 defers the seek
+                        // to a moment at which safari should be more able to handle a seek.
+                        setTimeout(function () {
+                            performInitialSeek(observationInitialTime_1);
+                        }, 0);
+                    }
+                    else {
+                        performInitialSeek(observationInitialTime_1);
+                    }
+                    stopListening();
+                }
+            });
+        }
+        else if (initialTime === undefined) {
+            initialSeekPerformed.setValue(true);
+            initialSeekPerformed.finish();
+        }
+        else if (shouldPreventSeekingAt0Initially() && initialTime === 0) {
             initialSeekPerformed.setValue(true);
             initialSeekPerformed.finish();
         }

package/dist/_esm5.processed/core/init/utils/initialize_content_decryption.d.ts

@@ -1,7 +1,8 @@
-import { IKeySystemOption, IPlayerError } from "../../../public_types";
-import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IContentProtection } from "../../decrypt";
+import type { IKeySystemOption, IPlayerError } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import SharedReference from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IContentProtection } from "../../decrypt";
 /**
  * Initialize content decryption capabilities on the given `HTMLMediaElement`.
  *
@@ -50,7 +51,7 @@ type IDecryptionInitializationState =
 {
     type: "uninitialized";
     value: null;
-} | 
+}
 /**
  * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
  * before continuing.
@@ -63,17 +64,17 @@ type IDecryptionInitializationState =
  * Note that the `"awaiting-media-link"` is an optional state. It can be
  * skipped to directly `"initialized"` instead.
  */
-{
+ | {
     type: "awaiting-media-link";
     value: {
         isMediaLinked: SharedReference<boolean>;
     };
-} | 
+}
 /**
  * The `MediaSource` or media url can be linked AND segments can be pushed to
  * the `HTMLMediaElement` on which decryption capabilities were wanted.
  */
-{
+ | {
     type: "initialized";
     value: null;
 };

package/dist/_esm5.processed/core/init/utils/initialize_content_decryption.js

@@ -3,7 +3,7 @@ import features from "../../../features";
 import log from "../../../log";
 import SharedReference from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
-import { ContentDecryptorState, } from "../../decrypt";
+import { ContentDecryptorState } from "../../decrypt";
 /**
  * Initialize content decryption capabilities on the given `HTMLMediaElement`.
  *
@@ -57,14 +57,16 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
                     }
                 }
             }, { clearSignal: decryptorCanceller.signal });
-            drmStatusRef.setValue({ initializationState: { type: "awaiting-media-link",
-                    value: { isMediaLinked: isMediaLinked } },
-                drmSystemId: contentDecryptor.systemId });
+            drmStatusRef.setValue({
+                initializationState: { type: "awaiting-media-link", value: { isMediaLinked: isMediaLinked } },
+                drmSystemId: contentDecryptor.systemId,
+            });
         }
         else if (state === ContentDecryptorState.ReadyForContent) {
-            drmStatusRef.setValue({ initializationState: { type: "initialized",
-                    value: null },
-                drmSystemId: contentDecryptor.systemId });
+            drmStatusRef.setValue({
+                initializationState: { type: "initialized", value: null },
+                drmSystemId: contentDecryptor.systemId,
+            });
             contentDecryptor.removeEventListener("stateChange");
         }
     });
@@ -87,7 +89,8 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
     return drmStatusRef;
     function createEmeDisabledReference(errMsg) {
         protectionRef.onUpdate(function (data, stopListening) {
-            if (data === null) { // initial value
+            if (data === null) {
+                // initial value
                 return;
             }
             stopListening();
@@ -96,7 +99,7 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
         }, { clearSignal: cancelSignal });
         var ref = new SharedReference({
             initializationState: { type: "initialized", value: null },
-            drmSystemId: undefined
+            drmSystemId: undefined,
         });
         ref.finish(); // We know that no new value will be triggered
         return ref;

package/dist/_esm5.processed/core/init/utils/media_source_duration_updater.js

@@ -63,8 +63,10 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
         /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
         var msOpenStatusCanceller = new TaskCanceller();
         msOpenStatusCanceller.linkToSignal(currentSignal);
-        isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
-            clearSignal: currentSignal });
+        isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, {
+            emitCurrentValue: true,
+            clearSignal: currentSignal,
+        });
         function onMediaSourceOpenedStatusChanged() {
             msOpenStatusCanceller.cancel();
             if (!isMediaSourceOpened.getValue()) {
@@ -115,9 +117,9 @@ export default MediaSourceDurationUpdater;
 function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
     var newDuration = duration;
     if (!isRealEndKnown) {
-        newDuration = hasIssuesWithHighMediaSourceDuration() ?
-            Infinity :
-            getMaximumLiveSeekablePosition(duration);
+        newDuration = hasIssuesWithHighMediaSourceDuration()
+            ? Infinity
+            : getMaximumLiveSeekablePosition(duration);
     }
     var maxBufferedEnd = 0;
     for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
@@ -163,8 +165,9 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
         var deltaToExpected = Math.abs(mediaSource.duration - newDuration);
         if (deltaToExpected >= 0.1) {
             var deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
-            return deltaToExpected < deltaToBefore ? "partial" /* MediaSourceDurationUpdateStatus.Partial */ :
-                "failed" /* MediaSourceDurationUpdateStatus.Failed */;
+            return deltaToExpected < deltaToBefore
+                ? "partial" /* MediaSourceDurationUpdateStatus.Partial */
+                : "failed" /* MediaSourceDurationUpdateStatus.Failed */;
         }
         return "success" /* MediaSourceDurationUpdateStatus.Success */;
     }

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.d.ts

@@ -13,13 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Period } from "../../../manifest";
-import { IPlayerError } from "../../../public_types";
+import type { Period } from "../../../manifest";
+import type Manifest from "../../../manifest";
+import type { IPlayerError } from "../../../public_types";
 import EventEmitter from "../../../utils/event_emitter";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { PlaybackObserver } from "../../api";
-import { IBufferType } from "../../segment_buffers";
-import { IStallingSituation } from "../types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { PlaybackObserver } from "../../api";
+import type { IBufferType } from "../../segment_buffers";
+import type { IStallingSituation } from "../types";
 /**
  * Monitor playback, trying to avoid stalling situation.
  * If stopping the player to build buffer is needed, temporarily set the

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.js

@@ -109,19 +109,20 @@ var RebufferingController = /** @class */ (function (_super) {
             if (!observation.seeking &&
                 isSeekingApproximate &&
                 ignoredStallTimeStamp === null &&
-                lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
+                lastSeekingPosition !== null &&
+                observation.position < lastSeekingPosition) {
                 log.debug("Init: the device appeared to have seeked back by itself.");
                 var now = performance.now();
                 ignoredStallTimeStamp = now;
             }
-            lastSeekingPosition = observation.seeking ?
-                Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) :
-                null;
+            lastSeekingPosition = observation.seeking
+                ? Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position)
+                : null;
             if (freezing !== null) {
                 var now = performance.now();
-                var referenceTimestamp = prevFreezingState === null ?
-                    freezing.timestamp :
-                    prevFreezingState.attemptTimestamp;
+                var referenceTimestamp = prevFreezingState === null
+                    ? freezing.timestamp
+                    : prevFreezingState.attemptTimestamp;
                 if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
                     log.warn("Init: trying to seek to un-freeze player");
                     _this._playbackObserver.setCurrentTime(_this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
@@ -148,8 +149,8 @@ var RebufferingController = /** @class */ (function (_super) {
                     // Return that we're stalled
                     var reason = void 0;
                     if (observation.seeking) {
-                        reason = observation.pendingInternalSeek !== null ? "internal-seek" :
-                            "seeking";
+                        reason =
+                            observation.pendingInternalSeek !== null ? "internal-seek" : "seeking";
                     }
                     else {
                         reason = "not-ready";
@@ -162,10 +163,9 @@ var RebufferingController = /** @class */ (function (_super) {
             }
             // We want to separate a stall situation when a seek is due to a seek done
             // internally by the player to when its due to a regular user seek.
-            var stalledReason = rebuffering.reason === "seeking" &&
-                observation.pendingInternalSeek !== null ?
-                "internal-seek" :
-                rebuffering.reason;
+            var stalledReason = rebuffering.reason === "seeking" && observation.pendingInternalSeek !== null
+                ? "internal-seek"
+                : rebuffering.reason;
             if (ignoredStallTimeStamp !== null) {
                 var now = performance.now();
                 if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
@@ -214,7 +214,7 @@ var RebufferingController = /** @class */ (function (_super) {
             var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
             if (_this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-                var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
+                var seekTo = freezePosition + nextBufferRangeGap + EPSILON;
                 if (_this._playbackObserver.getCurrentTime() < seekTo) {
                     log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
                     _this._playbackObserver.setCurrentTime(seekTo);
@@ -270,15 +270,14 @@ var RebufferingController = /** @class */ (function (_super) {
         var observation = this._playbackObserver.getReference().getValue();
         if (!observation.rebuffering ||
             observation.paused ||
-            this._speed.getValue() <= 0 || (bufferType !== "audio" &&
-            bufferType !== "video")) {
+            this._speed.getValue() <= 0 ||
+            (bufferType !== "audio" && bufferType !== "video")) {
             return;
         }
         var currPos = observation.position;
         var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
         var lockedPeriodStart = period.start;
-        if (currPos < lockedPeriodStart &&
-            Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
+        if (currPos < lockedPeriodStart && Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
             log.warn("Init: rebuffering because of a future locked stream.\n" +
                 "Trying to unlock by seeking to the next Period");
             this._playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
@@ -315,7 +314,7 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
             var _a = discontinuitiesStore[i], discontinuity = _a.discontinuity, position = _a.position;
             var start = discontinuity.start, end = discontinuity.end;
             var discontinuityLowerLimit = start !== null && start !== void 0 ? start : position;
-            if (stalledPosition >= (discontinuityLowerLimit - EPSILON)) {
+            if (stalledPosition >= discontinuityLowerLimit - EPSILON) {
                 if (end === null) {
                     var nextPeriod = manifest.getPeriodAfter(period);
                     if (nextPeriod !== null) {
@@ -325,16 +324,16 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
                         log.warn("Init: discontinuity at Period's end but no next Period");
                     }
                 }
-                else if (stalledPosition < (end + EPSILON)) {
+                else if (stalledPosition < end + EPSILON) {
                     discontinuityEnd = end + EPSILON;
                 }
             }
             if (discontinuityEnd !== undefined) {
                 log.info("Init: discontinuity found", stalledPosition, discontinuityEnd);
                 maxDiscontinuityEnd =
-                    maxDiscontinuityEnd !== null &&
-                        maxDiscontinuityEnd > discontinuityEnd ? maxDiscontinuityEnd :
-                        discontinuityEnd;
+                    maxDiscontinuityEnd !== null && maxDiscontinuityEnd > discontinuityEnd
+                        ? maxDiscontinuityEnd
+                        : discontinuityEnd;
             }
         }
     }
@@ -406,7 +405,8 @@ function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
  */
 function generateDiscontinuityError(stalledPosition, seekTo) {
     return new MediaError("DISCONTINUITY_ENCOUNTERED", "A discontinuity has been encountered at position " +
-        String(stalledPosition) + ", seeked at position " +
+        String(stalledPosition) +
+        ", seeked at position " +
         String(seekTo));
 }
 /**

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/are_same_stream_events.js

@@ -28,8 +28,6 @@
  * @returns {Boolean}
  */
 function areSameStreamEvents(evt1, evt2) {
-    return evt1.id === evt2.id &&
-        evt1.start === evt2.start &&
-        evt1.end === evt2.end;
+    return evt1.id === evt2.id && evt1.start === evt2.start && evt1.end === evt2.end;
 }
 export default areSameStreamEvents;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/index.d.ts

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import streamEventsEmitter from "./stream_events_emitter";
-export { IPublicNonFiniteStreamEvent, IPublicStreamEvent, } from "./types";
+export type { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./types";
 export default streamEventsEmitter;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/refresh_scheduled_events_list.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest from "../../../../manifest";
-import { INonFiniteStreamEventPayload, IStreamEventPayload } from "./types";
+import type Manifest from "../../../../manifest";
+import type { INonFiniteStreamEventPayload, IStreamEventPayload } from "./types";
 /**
  * Refresh local scheduled events list
  * @param {Array.<Object>} oldScheduledEvents

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/refresh_scheduled_events_list.js

@@ -47,16 +47,24 @@ function refreshScheduledEventsList(oldScheduledEvents, manifest) {
                 }
             }
             var element = data.value.element;
-            var actualData = { type: data.type,
-                value: __assign(__assign({}, data.value), { element: element }) };
+            var actualData = { type: data.type, value: __assign(__assign({}, data.value), { element: element }) };
             if (end === undefined) {
-                var newScheduledEvent = { start: start, id: id, data: actualData,
-                    publicEvent: { start: start, data: actualData } };
+                var newScheduledEvent = {
+                    start: start,
+                    id: id,
+                    data: actualData,
+                    publicEvent: { start: start, data: actualData },
+                };
                 scheduledEvents.push(newScheduledEvent);
             }
             else {
-                var newScheduledEvent = { start: start, end: end, id: id, data: actualData,
-                    publicEvent: { start: start, end: end, data: actualData } };
+                var newScheduledEvent = {
+                    start: start,
+                    end: end,
+                    id: id,
+                    data: actualData,
+                    publicEvent: { start: start, end: end, data: actualData },
+                };
                 scheduledEvents.push(newScheduledEvent);
             }
         });

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/stream_events_emitter.d.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest from "../../../../manifest";
+import type Manifest from "../../../../manifest";
 import EventEmitter from "../../../../utils/event_emitter";
-import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
-import { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./types";
+import type { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
+import type { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./types";
 interface IStreamEventsEmitterEvent {
     event: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
     eventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/stream_events_emitter.js

@@ -50,8 +50,7 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
         _this._playbackObserver = playbackObserver;
         _this._canceller = null;
         _this._scheduledEventsRef = new SharedReference([]);
-        _this._eventsBeingPlayed =
-            new WeakMap();
+        _this._eventsBeingPlayed = new WeakMap();
         return _this;
     }
     StreamEventsEmitter.prototype.start = function () {
@@ -94,8 +93,10 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
             };
             var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.getCurrent().STREAM_EVENT_EMITTER_POLL_INTERVAL;
             var intervalId = setInterval(checkStreamEvents, STREAM_EVENT_EMITTER_POLL_INTERVAL);
-            playbackObserver.listen(checkStreamEvents, { includeLastObservation: false,
-                clearSignal: cancelCurrentPolling.signal });
+            playbackObserver.listen(checkStreamEvents, {
+                includeLastObservation: false,
+                clearSignal: cancelCurrentPolling.signal,
+            });
             cancelCurrentPolling.signal.register(function () {
                 clearInterval(intervalId);
             });
@@ -127,34 +128,26 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
         for (var i = 0; i < scheduledEvents.length; i++) {
             var event_1 = scheduledEvents[i];
             var start = event_1.start;
-            var end = isFiniteStreamEvent(event_1) ? event_1.end :
-                undefined;
+            var end = isFiniteStreamEvent(event_1) ? event_1.end : undefined;
             var isBeingPlayed = this._eventsBeingPlayed.has(event_1);
             if (isBeingPlayed) {
-                if (start > currentTime ||
-                    (end !== undefined && currentTime >= end)) {
+                if (start > currentTime || (end !== undefined && currentTime >= end)) {
                     if (isFiniteStreamEvent(event_1)) {
                         eventsToExit.push(event_1.publicEvent);
                     }
                     this._eventsBeingPlayed.delete(event_1);
                 }
             }
-            else if (start <= currentTime &&
-                end !== undefined &&
-                currentTime < end) {
-                eventsToSend.push({ type: "stream-event",
-                    value: event_1.publicEvent });
+            else if (start <= currentTime && end !== undefined && currentTime < end) {
+                eventsToSend.push({ type: "stream-event", value: event_1.publicEvent });
                 this._eventsBeingPlayed.set(event_1, true);
             }
-            else if (previousTime < start &&
-                currentTime >= (end !== null && end !== void 0 ? end : start)) {
+            else if (previousTime < start && currentTime >= (end !== null && end !== void 0 ? end : start)) {
                 if (isSeeking) {
-                    eventsToSend.push({ type: "stream-event-skip",
-                        value: event_1.publicEvent });
+                    eventsToSend.push({ type: "stream-event-skip", value: event_1.publicEvent });
                 }
                 else {
-                    eventsToSend.push({ type: "stream-event",
-                        value: event_1.publicEvent });
+                    eventsToSend.push({ type: "stream-event", value: event_1.publicEvent });
                     if (isFiniteStreamEvent(event_1)) {
                         eventsToExit.push(event_1.publicEvent);
                     }

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/types.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IStreamEventData } from "../../../../public_types";
+import type { IStreamEventData } from "../../../../public_types";
 export interface IStreamEventPayload {
     id?: string | undefined;
     start: number;