rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { clearElementSrc, events, MediaSource_, } from "../../../compat";
-import { MediaError } from "../../../errors";
-import log from "../../../log";
-import createCancellablePromise from "../../../utils/create_cancellable_promise";
-import isNonEmptyString from "../../../utils/is_non_empty_string";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetMediaSource = void 0;
+const compat_1 = require("../../../compat");
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const create_cancellable_promise_1 = require("../../../utils/create_cancellable_promise");
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
 /**
  * Dispose of ressources taken by the MediaSource:
  *   - Clear the MediaSource' SourceBuffers
@@ -27,39 +30,40 @@ import isNonEmptyString from "../../../utils/is_non_empty_string";
  * @param {MediaSource|null} mediaSource
  * @param {string|null} mediaSourceURL
  */
-export function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
+function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
     if (mediaSource !== null && mediaSource.readyState !== "closed") {
-        var readyState = mediaSource.readyState, sourceBuffers = mediaSource.sourceBuffers;
-        for (var i = sourceBuffers.length - 1; i >= 0; i--) {
-            var sourceBuffer = sourceBuffers[i];
+        const { readyState, sourceBuffers } = mediaSource;
+        for (let i = sourceBuffers.length - 1; i >= 0; i--) {
+            const sourceBuffer = sourceBuffers[i];
             try {
                 if (readyState === "open") {
-                    log.info("Init: Aborting SourceBuffer before removing");
+                    log_1.default.info("Init: Aborting SourceBuffer before removing");
                     sourceBuffer.abort();
                 }
-                log.info("Init: Removing SourceBuffer from mediaSource");
+                log_1.default.info("Init: Removing SourceBuffer from mediaSource");
                 mediaSource.removeSourceBuffer(sourceBuffer);
             }
             catch (e) {
-                log.warn("Init: Error while disposing SourceBuffer", e instanceof Error ? e : "");
+                log_1.default.warn("Init: Error while disposing SourceBuffer", e instanceof Error ? e : "");
             }
         }
         if (sourceBuffers.length > 0) {
-            log.warn("Init: Not all SourceBuffers could have been removed.");
+            log_1.default.warn("Init: Not all SourceBuffers could have been removed.");
         }
     }
-    log.info("Init: Clearing HTMLMediaElement's src");
-    clearElementSrc(mediaElement);
+    log_1.default.info("Init: Clearing HTMLMediaElement's src");
+    (0, compat_1.clearElementSrc)(mediaElement);
     if (mediaSourceURL !== null) {
         try {
-            log.debug("Init: Revoking previous URL");
+            log_1.default.debug("Init: Revoking previous URL");
             URL.revokeObjectURL(mediaSourceURL);
         }
         catch (e) {
-            log.warn("Init: Error while revoking the media source URL", e instanceof Error ? e : "");
+            log_1.default.warn("Init: Error while revoking the media source URL", e instanceof Error ? e : "");
         }
     }
 }
+exports.resetMediaSource = resetMediaSource;
 /**
  * Create a MediaSource instance and attach it to the given mediaElement element's
  * src attribute.
@@ -74,19 +78,19 @@ export function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
  * @returns {MediaSource}
  */
 function createMediaSource(mediaElement, unlinkSignal) {
-    if (MediaSource_ == null) {
-        throw new MediaError("MEDIA_SOURCE_NOT_SUPPORTED", "No MediaSource Object was found in the current browser.");
+    if (compat_1.MediaSource_ == null) {
+        throw new errors_1.MediaError("MEDIA_SOURCE_NOT_SUPPORTED", "No MediaSource Object was found in the current browser.");
     }
     // make sure the media has been correctly reset
-    var oldSrc = isNonEmptyString(mediaElement.src) ? mediaElement.src :
+    const oldSrc = (0, is_non_empty_string_1.default)(mediaElement.src) ? mediaElement.src :
         null;
     resetMediaSource(mediaElement, null, oldSrc);
-    log.info("Init: Creating MediaSource");
-    var mediaSource = new MediaSource_();
-    var objectURL = URL.createObjectURL(mediaSource);
-    log.info("Init: Attaching MediaSource URL to the media element", objectURL);
+    log_1.default.info("Init: Creating MediaSource");
+    const mediaSource = new compat_1.MediaSource_();
+    const objectURL = URL.createObjectURL(mediaSource);
+    log_1.default.info("Init: Attaching MediaSource URL to the media element", objectURL);
     mediaElement.src = objectURL;
-    unlinkSignal.register(function () {
+    unlinkSignal.register(() => {
         resetMediaSource(mediaElement, mediaSource, objectURL);
     });
     return mediaSource;
@@ -101,12 +105,13 @@ function createMediaSource(mediaElement, unlinkSignal) {
  * @param {Object} unlinkSignal
  * @returns {Promise}
  */
-export default function openMediaSource(mediaElement, unlinkSignal) {
-    return createCancellablePromise(unlinkSignal, function (resolve) {
-        var mediaSource = createMediaSource(mediaElement, unlinkSignal);
-        events.onSourceOpen(mediaSource, function () {
-            log.info("Init: MediaSource opened");
+function openMediaSource(mediaElement, unlinkSignal) {
+    return (0, create_cancellable_promise_1.default)(unlinkSignal, (resolve) => {
+        const mediaSource = createMediaSource(mediaElement, unlinkSignal);
+        compat_1.events.onSourceOpen(mediaSource, () => {
+            log_1.default.info("Init: MediaSource opened");
             resolve(mediaSource);
         }, unlinkSignal);
     });
 }
+exports.default = openMediaSource;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
 /**
  * Create PlaybackObserver for the `Stream` part of the code.
  * @param {Object} srcPlaybackObserver - Base `PlaybackObserver` from which we
@@ -24,13 +26,12 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
  * @returns {Object}
  */
-export default function createStreamPlaybackObserver(srcPlaybackObserver, _a, fnCancelSignal) {
-    var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, initialSeekPerformed = _a.initialSeekPerformed, manifest = _a.manifest, speed = _a.speed, startTime = _a.startTime;
+function createStreamPlaybackObserver(srcPlaybackObserver, { autoPlay, initialPlayPerformed, initialSeekPerformed, manifest, speed, startTime }, fnCancelSignal) {
     return srcPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, parentObserverCancelSignal) {
-        var canceller = new TaskCanceller();
+        const canceller = new task_canceller_1.default();
         canceller.linkToSignal(parentObserverCancelSignal);
         canceller.linkToSignal(fnCancelSignal);
-        var newRef = new SharedReference(constructStreamPlaybackObservation(), canceller.signal);
+        const newRef = new reference_1.default(constructStreamPlaybackObservation(), canceller.signal);
         speed.onUpdate(emitStreamPlaybackObservation, {
             clearSignal: canceller.signal,
             emitCurrentValue: false,
@@ -41,9 +42,9 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, _a, fn
         });
         return newRef;
         function constructStreamPlaybackObservation() {
-            var observation = observationRef.getValue();
-            var lastSpeed = speed.getValue();
-            var pendingPosition;
+            const observation = observationRef.getValue();
+            const lastSpeed = speed.getValue();
+            let pendingPosition;
             if (!initialSeekPerformed.getValue()) {
                 pendingPosition = startTime;
             }
@@ -54,7 +55,7 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, _a, fn
                 // For now, this behavior is implicitely forced by making as if we
                 // want to seek one second before the period's end (despite never
                 // doing it).
-                var lastPeriod = manifest.periods[manifest.periods.length - 1];
+                const lastPeriod = manifest.periods[manifest.periods.length - 1];
                 if (lastPeriod !== undefined &&
                     lastPeriod.end !== undefined &&
                     observation.position > lastPeriod.end) {
@@ -84,3 +85,4 @@ export default function createStreamPlaybackObserver(srcPlaybackObserver, _a, fn
         }
     });
 }
+exports.default = createStreamPlaybackObserver;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,21 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { events } from "../../../compat";
-import log from "../../../log";
-import TaskCanceller from "../../../utils/task_canceller";
-var onRemoveSourceBuffers = events.onRemoveSourceBuffers, onSourceOpen = events.onSourceOpen, onSourceBufferUpdate = events.onSourceBufferUpdate;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maintainEndOfStream = void 0;
+const compat_1 = require("../../../compat");
+const log_1 = require("../../../log");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const { onRemoveSourceBuffers, onSourceOpen, onSourceBufferUpdate } = compat_1.events;
 /**
  * Get "updating" SourceBuffers from a SourceBufferList.
  * @param {SourceBufferList} sourceBuffers
  * @returns {Array.<SourceBuffer>}
  */
 function getUpdatingSourceBuffers(sourceBuffers) {
-    var updatingSourceBuffers = [];
-    for (var i = 0; i < sourceBuffers.length; i++) {
-        var SourceBuffer_1 = sourceBuffers[i];
-        if (SourceBuffer_1.updating) {
-            updatingSourceBuffers.push(SourceBuffer_1);
+    const updatingSourceBuffers = [];
+    for (let i = 0; i < sourceBuffers.length; i++) {
+        const SourceBuffer = sourceBuffers[i];
+        if (SourceBuffer.updating) {
+            updatingSourceBuffers.push(SourceBuffer);
         }
     }
     return updatingSourceBuffers;
@@ -41,49 +44,50 @@ function getUpdatingSourceBuffers(sourceBuffers) {
  * @param {MediaSource} mediaSource
  * @param {Object} cancelSignal
  */
-export default function triggerEndOfStream(mediaSource, cancelSignal) {
-    log.debug("Init: Trying to call endOfStream");
+function triggerEndOfStream(mediaSource, cancelSignal) {
+    log_1.default.debug("Init: Trying to call endOfStream");
     if (mediaSource.readyState !== "open") {
-        log.debug("Init: MediaSource not open, cancel endOfStream");
+        log_1.default.debug("Init: MediaSource not open, cancel endOfStream");
         return;
     }
-    var sourceBuffers = mediaSource.sourceBuffers;
-    var updatingSourceBuffers = getUpdatingSourceBuffers(sourceBuffers);
+    const { sourceBuffers } = mediaSource;
+    const updatingSourceBuffers = getUpdatingSourceBuffers(sourceBuffers);
     if (updatingSourceBuffers.length === 0) {
-        log.info("Init: Triggering end of stream");
+        log_1.default.info("Init: Triggering end of stream");
         mediaSource.endOfStream();
         return;
     }
-    log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
-    var innerCanceller = new TaskCanceller();
+    log_1.default.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
+    const innerCanceller = new task_canceller_1.default();
     innerCanceller.linkToSignal(cancelSignal);
-    for (var _i = 0, updatingSourceBuffers_1 = updatingSourceBuffers; _i < updatingSourceBuffers_1.length; _i++) {
-        var sourceBuffer = updatingSourceBuffers_1[_i];
-        onSourceBufferUpdate(sourceBuffer, function () {
+    for (const sourceBuffer of updatingSourceBuffers) {
+        onSourceBufferUpdate(sourceBuffer, () => {
             innerCanceller.cancel();
             triggerEndOfStream(mediaSource, cancelSignal);
         }, innerCanceller.signal);
     }
-    onRemoveSourceBuffers(sourceBuffers, function () {
+    onRemoveSourceBuffers(sourceBuffers, () => {
         innerCanceller.cancel();
         triggerEndOfStream(mediaSource, cancelSignal);
     }, innerCanceller.signal);
 }
+exports.default = triggerEndOfStream;
 /**
  * Trigger the `endOfStream` method of a MediaSource each times it opens.
  * @see triggerEndOfStream
  * @param {MediaSource} mediaSource
  * @param {Object} cancelSignal
  */
-export function maintainEndOfStream(mediaSource, cancelSignal) {
-    var endOfStreamCanceller = new TaskCanceller();
+function maintainEndOfStream(mediaSource, cancelSignal) {
+    let endOfStreamCanceller = new task_canceller_1.default();
     endOfStreamCanceller.linkToSignal(cancelSignal);
-    onSourceOpen(mediaSource, function () {
-        log.debug("Init: MediaSource re-opened while end-of-stream is active");
+    onSourceOpen(mediaSource, () => {
+        log_1.default.debug("Init: MediaSource re-opened while end-of-stream is active");
         endOfStreamCanceller.cancel();
-        endOfStreamCanceller = new TaskCanceller();
+        endOfStreamCanceller = new task_canceller_1.default();
         endOfStreamCanceller.linkToSignal(cancelSignal);
         triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
     }, cancelSignal);
     triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
 }
+exports.maintainEndOfStream = maintainEndOfStream;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../config";
-import log from "../../../log";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../config");
+const log_1 = require("../../../log");
+const is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
 /**
  * Returns the calculated initial time for the content described by the given
  * Manifest:
@@ -30,81 +32,82 @@ import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
  * @param {Object} startAt
  * @returns {Number}
  */
-export default function getInitialTime(manifest, lowLatencyMode, startAt) {
-    if (!isNullOrUndefined(startAt)) {
-        var min = manifest.getMinimumSafePosition();
-        var max = void 0;
+function getInitialTime(manifest, lowLatencyMode, startAt) {
+    if (!(0, is_null_or_undefined_1.default)(startAt)) {
+        const min = manifest.getMinimumSafePosition();
+        let max;
         if (manifest.isLive) {
             max = manifest.getLivePosition();
         }
         if (max === undefined) {
             max = manifest.getMaximumSafePosition();
         }
-        if (!isNullOrUndefined(startAt.position)) {
-            log.debug("Init: using startAt.minimumPosition");
+        if (!(0, is_null_or_undefined_1.default)(startAt.position)) {
+            log_1.default.debug("Init: using startAt.minimumPosition");
             return Math.max(Math.min(startAt.position, max), min);
         }
-        else if (!isNullOrUndefined(startAt.wallClockTime)) {
-            log.debug("Init: using startAt.wallClockTime");
-            var ast = manifest.availabilityStartTime === undefined ?
+        else if (!(0, is_null_or_undefined_1.default)(startAt.wallClockTime)) {
+            log_1.default.debug("Init: using startAt.wallClockTime");
+            const ast = manifest.availabilityStartTime === undefined ?
                 0 :
                 manifest.availabilityStartTime;
-            var position = startAt.wallClockTime - ast;
+            const 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;
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromFirstPosition)) {
+            log_1.default.debug("Init: using startAt.fromFirstPosition");
+            const { fromFirstPosition } = startAt;
             return fromFirstPosition <= 0 ? min :
                 Math.min(max, min + fromFirstPosition);
         }
-        else if (!isNullOrUndefined(startAt.fromLastPosition)) {
-            log.debug("Init: using startAt.fromLastPosition");
-            var fromLastPosition = startAt.fromLastPosition;
+        else if (!(0, is_null_or_undefined_1.default)(startAt.fromLastPosition)) {
+            log_1.default.debug("Init: using startAt.fromLastPosition");
+            const { fromLastPosition } = startAt;
             return fromLastPosition >= 0 ? max :
                 Math.max(min, max + fromLastPosition);
         }
-        else if (!isNullOrUndefined(startAt.percentage)) {
-            log.debug("Init: using startAt.percentage");
-            var percentage = startAt.percentage;
+        else if (!(0, is_null_or_undefined_1.default)(startAt.percentage)) {
+            log_1.default.debug("Init: using startAt.percentage");
+            const { percentage } = startAt;
             if (percentage > 100) {
                 return max;
             }
             else if (percentage < 0) {
                 return min;
             }
-            var ratio = +percentage / 100;
-            var extent = max - min;
+            const ratio = +percentage / 100;
+            const extent = max - min;
             return min + extent * ratio;
         }
     }
-    var minimumPosition = manifest.getMinimumSafePosition();
+    const minimumPosition = manifest.getMinimumSafePosition();
     if (manifest.isLive) {
-        var suggestedPresentationDelay = manifest.suggestedPresentationDelay, clockOffset = manifest.clockOffset;
-        var maximumPosition = manifest.getMaximumSafePosition();
-        var liveTime = void 0;
-        var DEFAULT_LIVE_GAP = config.getCurrent().DEFAULT_LIVE_GAP;
+        const { suggestedPresentationDelay, clockOffset } = manifest;
+        const maximumPosition = manifest.getMaximumSafePosition();
+        let liveTime;
+        const { DEFAULT_LIVE_GAP } = config_1.default.getCurrent();
         if (clockOffset === undefined) {
-            log.info("Init: no clock offset found for a live content, " +
+            log_1.default.info("Init: no clock offset found for a live content, " +
                 "starting close to maximum available position");
             liveTime = maximumPosition;
         }
         else {
-            log.info("Init: clock offset found for a live content, " +
+            log_1.default.info("Init: clock offset found for a live content, " +
                 "checking if we can start close to it");
-            var ast = manifest.availabilityStartTime === undefined ?
+            const ast = manifest.availabilityStartTime === undefined ?
                 0 :
                 manifest.availabilityStartTime;
-            var clockRelativeLiveTime = (getMonotonicTimeStamp() + clockOffset) / 1000 - ast;
+            const clockRelativeLiveTime = ((0, monotonic_timestamp_1.default)() + clockOffset) / 1000 - ast;
             liveTime = Math.min(maximumPosition, clockRelativeLiveTime);
         }
-        var diffFromLiveTime = suggestedPresentationDelay !== undefined ? suggestedPresentationDelay :
+        const 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));
+        log_1.default.debug(`Init: ${liveTime} defined as the live time, applying a live gap` +
+            ` of ${diffFromLiveTime}`);
         return Math.max(liveTime - diffFromLiveTime, minimumPosition);
     }
-    log.info("Init: starting at the minimum available position:", minimumPosition);
+    log_1.default.info("Init: starting at the minimum available position:", minimumPosition);
     return minimumPosition;
 }
+exports.default = getInitialTime;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { shouldValidateMetadata, shouldWaitForDataBeforeLoaded, shouldWaitForHaveEnoughData, } from "../../../compat";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../compat");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
 /**
  * Returns an `IReadOnlySharedReference` that switches to `true` once the
  * content is considered loaded (i.e. once it can begin to be played).
@@ -25,27 +27,27 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function getLoadedReference(playbackObserver, mediaElement, isDirectfile, cancelSignal) {
-    var listenCanceller = new TaskCanceller();
+function getLoadedReference(playbackObserver, mediaElement, isDirectfile, cancelSignal) {
+    const listenCanceller = new task_canceller_1.default();
     listenCanceller.linkToSignal(cancelSignal);
-    var isLoaded = new SharedReference(false, listenCanceller.signal);
-    playbackObserver.listen(function (observation) {
+    const isLoaded = new reference_1.default(false, listenCanceller.signal);
+    playbackObserver.listen((observation) => {
         if (observation.rebuffering !== null ||
             observation.freezing !== null ||
             observation.readyState === 0) {
             return;
         }
-        if (!shouldWaitForDataBeforeLoaded(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
+        if (!(0, compat_1.shouldWaitForDataBeforeLoaded)(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
             if (mediaElement.duration > 0) {
                 isLoaded.setValue(true);
                 listenCanceller.cancel();
                 return;
             }
         }
-        var minReadyState = shouldWaitForHaveEnoughData() ? 4 :
+        const minReadyState = (0, compat_1.shouldWaitForHaveEnoughData)() ? 4 :
             3;
         if (observation.readyState >= minReadyState && observation.currentRange !== null) {
-            if (!shouldValidateMetadata() || mediaElement.duration > 0) {
+            if (!(0, compat_1.shouldValidateMetadata)() || mediaElement.duration > 0) {
                 isLoaded.setValue(true);
                 listenCanceller.cancel();
                 return;
@@ -54,3 +56,4 @@ export default function getLoadedReference(playbackObserver, mediaElement, isDir
     }, { includeLastObservation: true, clearSignal: listenCanceller.signal });
     return isLoaded;
 }
+exports.default = getLoadedReference;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { shouldValidateMetadata } from "../../../compat";
-import { READY_STATES } from "../../../compat/browser_compatibility_types";
-import { MediaError } from "../../../errors";
-import log from "../../../log";
-import SharedReference from "../../../utils/reference";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../compat");
+const browser_compatibility_types_1 = require("../../../compat/browser_compatibility_types");
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const reference_1 = require("../../../utils/reference");
 /**
  * Seek as soon as possible at the initially wanted position and play if
  * autoPlay is wanted.
@@ -29,41 +31,41 @@ import SharedReference from "../../../utils/reference";
  * @param {Object} cancelSignal
  * @returns {Object}
  */
-export default function performInitialSeekAndPlay(mediaElement, playbackObserver, startTime, mustAutoPlay, onWarning, cancelSignal) {
-    var resolveAutoPlay;
-    var rejectAutoPlay;
-    var autoPlayResult = new Promise(function (res, rej) {
+function performInitialSeekAndPlay(mediaElement, playbackObserver, startTime, mustAutoPlay, onWarning, cancelSignal) {
+    let resolveAutoPlay;
+    let rejectAutoPlay;
+    const autoPlayResult = new Promise((res, rej) => {
         resolveAutoPlay = res;
         rejectAutoPlay = rej;
     });
-    var initialSeekPerformed = new SharedReference(false, cancelSignal);
-    var initialPlayPerformed = new SharedReference(false, cancelSignal);
+    const initialSeekPerformed = new reference_1.default(false, cancelSignal);
+    const initialPlayPerformed = new reference_1.default(false, cancelSignal);
     mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-    var deregisterCancellation = cancelSignal.register(function (err) {
+    const deregisterCancellation = cancelSignal.register((err) => {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
         rejectAutoPlay(err);
     });
-    if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
+    if (mediaElement.readyState >= browser_compatibility_types_1.READY_STATES.HAVE_METADATA) {
         onLoadedMetadata();
     }
-    return { autoPlayResult: autoPlayResult, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed };
+    return { autoPlayResult, initialPlayPerformed, initialSeekPerformed };
     function onLoadedMetadata() {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-        var initialTime = typeof startTime === "function" ? startTime() :
+        const initialTime = typeof startTime === "function" ? startTime() :
             startTime;
-        log.info("Init: Set initial time", initialTime);
+        log_1.default.info("Init: Set initial time", initialTime);
         playbackObserver.setCurrentTime(initialTime);
         initialSeekPerformed.setValue(true);
         initialSeekPerformed.finish();
-        if (shouldValidateMetadata() && mediaElement.duration === 0) {
-            var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
+        if ((0, compat_1.shouldValidateMetadata)() && mediaElement.duration === 0) {
+            const error = new errors_1.MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
                 "falsely announced having loaded the content.");
             onWarning(error);
         }
         if (cancelSignal.isCancelled()) {
             return;
         }
-        playbackObserver.listen(function (observation, stopListening) {
+        playbackObserver.listen((observation, stopListening) => {
             if (!observation.seeking &&
                 observation.rebuffering === null &&
                 observation.readyState >= 1) {
@@ -74,10 +76,10 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
     }
     function onPlayable() {
         var _a;
-        log.info("Init: Can begin to play content");
+        log_1.default.info("Init: Can begin to play content");
         if (!mustAutoPlay) {
             if (mediaElement.autoplay) {
-                log.warn("Init: autoplay is enabled on HTML media element. " +
+                log_1.default.warn("Init: autoplay is enabled on HTML media element. " +
                     "Media will play as soon as possible.");
             }
             initialPlayPerformed.setValue(true);
@@ -85,7 +87,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             deregisterCancellation();
             return resolveAutoPlay({ type: "skipped" });
         }
-        var playResult;
+        let playResult;
         try {
             playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
         }
@@ -94,7 +96,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             return rejectAutoPlay(playError);
         }
         playResult
-            .then(function () {
+            .then(() => {
             if (cancelSignal.isCancelled()) {
                 return;
             }
@@ -103,16 +105,16 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             deregisterCancellation();
             return resolveAutoPlay({ type: "autoplay" });
         })
-            .catch(function (playError) {
+            .catch((playError) => {
             deregisterCancellation();
             if (cancelSignal.isCancelled()) {
                 return;
             }
             if (playError instanceof Error && playError.name === "NotAllowedError") {
                 // auto-play was probably prevented.
-                log.warn("Init: Media element can't play." +
+                log_1.default.warn("Init: Media element can't play." +
                     " It may be due to browser auto-play policies.");
-                var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
+                const error = new errors_1.MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
                     "your browser does not allow it.");
                 onWarning(error);
                 if (cancelSignal.isCancelled()) {
@@ -126,3 +128,4 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
         });
     }
 }
+exports.default = performInitialSeekAndPlay;