rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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 { createSharedReference, } 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 { createSharedReference, } 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 = createSharedReference(false, cancelSignal);
-    var initialPlayPerformed = createSharedReference(false, cancelSignal);
+    const initialSeekPerformed = new reference_1.default(false, cancelSignal);
+    const initialPlayPerformed = new reference_1.default(false, cancelSignal);
     mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-    if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-        onLoadedMetadata();
-    }
-    var deregisterCancellation = cancelSignal.register(function (err) {
+    const deregisterCancellation = cancelSignal.register((err) => {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
         rejectAutoPlay(err);
     });
-    return { autoPlayResult: autoPlayResult, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed };
+    if (mediaElement.readyState >= browser_compatibility_types_1.READY_STATES.HAVE_METADATA) {
+        onLoadedMetadata();
+    }
+    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;

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

@@ -1,5 +1,5 @@
 import { IKeySystemOption, IPlayerError } from "../../../public_types";
-import { IReadOnlySharedReference, ISharedReference } from "../../../utils/reference";
+import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
 import { CancellationSignal } from "../../../utils/task_canceller";
 import { IContentProtection } from "../../decrypt";
 /**
@@ -55,7 +55,7 @@ type IDecryptionInitializationState =
  * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
  * before continuing.
  * Once it has been linked with success (e.g. the `MediaSource` has "opened"),
- * the `isMediaLinked` `ISharedReference` should be set to `true`.
+ * the `isMediaLinked` `SharedReference` should be set to `true`.
  *
  * In the `MediaSource` case, you should wait until the `"initialized"`
  * state before pushing segment.
@@ -66,7 +66,7 @@ type IDecryptionInitializationState =
 {
     type: "awaiting-media-link";
     value: {
-        isMediaLinked: ISharedReference<boolean>;
+        isMediaLinked: SharedReference<boolean>;
     };
 } | 
 /**

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

@@ -1,9 +1,11 @@
-import { hasEMEAPIs } from "../../../compat";
-import { EncryptedMediaError } from "../../../errors";
-import log from "../../../log";
-import createSharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
-import ContentDecryptor, { ContentDecryptorState, } from "../../decrypt";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
+const features_1 = require("../../../features");
+const log_1 = require("../../../log");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const decrypt_1 = require("../../decrypt");
 /**
  * Initialize content decryption capabilities on the given `HTMLMediaElement`.
  *
@@ -27,86 +29,79 @@ import ContentDecryptor, { ContentDecryptorState, } from "../../decrypt";
  * @returns {Object} - Reference emitting the current status regarding DRM
  * initialization.
  */
-export default function initializeContentDecryption(mediaElement, keySystems, protectionRef, callbacks, cancelSignal) {
+function initializeContentDecryption(mediaElement, keySystems, protectionRef, callbacks, cancelSignal) {
     if (keySystems.length === 0) {
-        protectionRef.onUpdate(function (data, stopListening) {
-            if (data === null) { // initial value
-                return;
-            }
-            stopListening();
-            log.error("Init: Encrypted event but EME feature not activated");
-            var err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "EME feature not activated.");
-            callbacks.onError(err);
-        }, { clearSignal: cancelSignal });
-        var ref = createSharedReference({
-            initializationState: { type: "initialized", value: null },
-            drmSystemId: undefined
-        });
-        ref.finish(); // We know that no new value will be triggered
-        return ref;
+        return createEmeDisabledReference("No `keySystems` option given.");
     }
-    else if (!hasEMEAPIs()) {
-        protectionRef.onUpdate(function (data, stopListening) {
-            if (data === null) { // initial value
-                return;
-            }
-            stopListening();
-            log.error("Init: Encrypted event but no EME API available");
-            var err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "Encryption APIs not found.");
-            callbacks.onError(err);
-        }, { clearSignal: cancelSignal });
-        var ref = createSharedReference({
-            initializationState: { type: "initialized", value: null },
-            drmSystemId: undefined
-        });
-        ref.finish(); // We know that no new value will be triggered
-        return ref;
+    else if (features_1.default.decrypt === null) {
+        return createEmeDisabledReference("EME feature not activated.");
     }
-    var decryptorCanceller = new TaskCanceller();
+    const decryptorCanceller = new task_canceller_1.default();
     decryptorCanceller.linkToSignal(cancelSignal);
-    var drmStatusRef = createSharedReference({
+    const drmStatusRef = new reference_1.default({
         initializationState: { type: "uninitialized", value: null },
         drmSystemId: undefined,
     }, cancelSignal);
-    log.debug("Init: Creating ContentDecryptor");
-    var contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
-    contentDecryptor.addEventListener("stateChange", function (state) {
-        if (state === ContentDecryptorState.WaitingForAttachment) {
-            var isMediaLinked = createSharedReference(false);
-            isMediaLinked.onUpdate(function (isAttached, stopListening) {
+    const ContentDecryptor = features_1.default.decrypt;
+    if (!ContentDecryptor.hasEmeApis()) {
+        return createEmeDisabledReference("EME API not available on the current page.");
+    }
+    log_1.default.debug("Init: Creating ContentDecryptor");
+    const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+    contentDecryptor.addEventListener("stateChange", (state) => {
+        if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
+            const isMediaLinked = new reference_1.default(false);
+            isMediaLinked.onUpdate((isAttached, stopListening) => {
                 if (isAttached) {
                     stopListening();
-                    if (state === ContentDecryptorState.WaitingForAttachment) {
+                    if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
                         contentDecryptor.attach();
                     }
                 }
             }, { clearSignal: decryptorCanceller.signal });
             drmStatusRef.setValue({ initializationState: { type: "awaiting-media-link",
-                    value: { isMediaLinked: isMediaLinked } },
+                    value: { isMediaLinked } },
                 drmSystemId: contentDecryptor.systemId });
         }
-        else if (state === ContentDecryptorState.ReadyForContent) {
+        else if (state === decrypt_1.ContentDecryptorState.ReadyForContent) {
             drmStatusRef.setValue({ initializationState: { type: "initialized",
                     value: null },
                 drmSystemId: contentDecryptor.systemId });
             contentDecryptor.removeEventListener("stateChange");
         }
     });
-    contentDecryptor.addEventListener("error", function (error) {
+    contentDecryptor.addEventListener("error", (error) => {
         decryptorCanceller.cancel();
         callbacks.onError(error);
     });
-    contentDecryptor.addEventListener("warning", function (error) {
+    contentDecryptor.addEventListener("warning", (error) => {
         callbacks.onWarning(error);
     });
-    protectionRef.onUpdate(function (data) {
+    protectionRef.onUpdate((data) => {
         if (data === null) {
             return;
         }
         contentDecryptor.onInitializationData(data);
     }, { clearSignal: decryptorCanceller.signal });
-    decryptorCanceller.signal.register(function () {
+    decryptorCanceller.signal.register(() => {
         contentDecryptor.dispose();
     });
     return drmStatusRef;
+    function createEmeDisabledReference(errMsg) {
+        protectionRef.onUpdate((data, stopListening) => {
+            if (data === null) { // initial value
+                return;
+            }
+            stopListening();
+            const err = new errors_1.EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+            callbacks.onError(err);
+        }, { clearSignal: cancelSignal });
+        const ref = new reference_1.default({
+            initializationState: { type: "initialized", value: null },
+            drmSystemId: undefined
+        });
+        ref.finish(); // We know that no new value will be triggered
+        return ref;
+    }
 }
+exports.default = initializeContentDecryption;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,26 +14,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { onSourceOpen, onSourceEnded, onSourceClose, } from "../../../compat/event_listeners";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_listeners_1 = require("../../../compat/event_listeners");
 /* eslint-disable-next-line max-len */
-import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
-import log from "../../../log";
-import createSharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
+const has_issues_with_high_media_source_duration_1 = require("../../../compat/has_issues_with_high_media_source_duration");
+const log_1 = require("../../../log");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
 /** Number of seconds in a regular year. */
-var YEAR_IN_SECONDS = 365 * 24 * 3600;
+const YEAR_IN_SECONDS = 365 * 24 * 3600;
 /**
  * Keep the MediaSource's `duration` attribute up-to-date with the duration of
  * the content played on it.
  * @class MediaSourceDurationUpdater
  */
-var MediaSourceDurationUpdater = /** @class */ (function () {
+class MediaSourceDurationUpdater {
     /**
      * Create a new `MediaSourceDurationUpdater`,
      * @param {MediaSource} mediaSource - The MediaSource on which the content is
      * played.
      */
-    function MediaSourceDurationUpdater(mediaSource) {
+    constructor(mediaSource) {
         this._mediaSource = mediaSource;
         this._currentMediaSourceDurationUpdateCanceller = null;
     }
@@ -52,16 +54,16 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
      * side-effects of having a too low duration (such as the impossibility to
      * seek over that value).
      */
-    MediaSourceDurationUpdater.prototype.updateDuration = function (newDuration, isRealEndKnown) {
+    updateDuration(newDuration, isRealEndKnown) {
         if (this._currentMediaSourceDurationUpdateCanceller !== null) {
             this._currentMediaSourceDurationUpdateCanceller.cancel();
         }
-        this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
-        var mediaSource = this._mediaSource;
-        var currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
-        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        this._currentMediaSourceDurationUpdateCanceller = new task_canceller_1.default();
+        const mediaSource = this._mediaSource;
+        const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        const isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
         /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
-        var msOpenStatusCanceller = new TaskCanceller();
+        let msOpenStatusCanceller = new task_canceller_1.default();
         msOpenStatusCanceller.linkToSignal(currentSignal);
         isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
             clearSignal: currentSignal });
@@ -70,15 +72,15 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
             if (!isMediaSourceOpened.getValue()) {
                 return;
             }
-            msOpenStatusCanceller = new TaskCanceller();
+            msOpenStatusCanceller = new task_canceller_1.default();
             msOpenStatusCanceller.linkToSignal(currentSignal);
-            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
+            const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
             /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-            var sourceBuffersUpdatingCanceller = new TaskCanceller();
+            let sourceBuffersUpdatingCanceller = new task_canceller_1.default();
             sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
-            return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
+            return areSourceBuffersUpdating.onUpdate((areUpdating) => {
                 sourceBuffersUpdatingCanceller.cancel();
-                sourceBuffersUpdatingCanceller = new TaskCanceller();
+                sourceBuffersUpdatingCanceller = new task_canceller_1.default();
                 sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
                 if (areUpdating) {
                     return;
@@ -86,19 +88,18 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
                 recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
             }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
         }
-    };
+    }
     /**
      * Abort the last duration-setting operation and free its resources.
      */
-    MediaSourceDurationUpdater.prototype.stopUpdating = function () {
+    stopUpdating() {
         if (this._currentMediaSourceDurationUpdateCanceller !== null) {
             this._currentMediaSourceDurationUpdateCanceller.cancel();
             this._currentMediaSourceDurationUpdateCanceller = null;
         }
-    };
-    return MediaSourceDurationUpdater;
-}());
-export default MediaSourceDurationUpdater;
+    }
+}
+exports.default = MediaSourceDurationUpdater;
 /**
  * Checks that duration can be updated on the MediaSource, and then
  * sets it.
@@ -113,16 +114,16 @@ export default MediaSourceDurationUpdater;
  * @returns {string}
  */
 function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
-    var newDuration = duration;
+    let newDuration = duration;
     if (!isRealEndKnown) {
-        newDuration = hasIssuesWithHighMediaSourceDuration() ?
+        newDuration = (0, has_issues_with_high_media_source_duration_1.default)() ?
             Infinity :
             getMaximumLiveSeekablePosition(duration);
     }
-    var maxBufferedEnd = 0;
-    for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
-        var sourceBuffer = mediaSource.sourceBuffers[i];
-        var sbBufferedLen = sourceBuffer.buffered.length;
+    let maxBufferedEnd = 0;
+    for (let i = 0; i < mediaSource.sourceBuffers.length; i++) {
+        const sourceBuffer = mediaSource.sourceBuffers[i];
+        const sbBufferedLen = sourceBuffer.buffered.length;
         if (sbBufferedLen > 0) {
             maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
         }
@@ -135,32 +136,34 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
         // Keep the duration that was set at that time as a security.
         if (maxBufferedEnd < mediaSource.duration) {
             try {
-                log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+                log_1.default.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
                 mediaSource.duration = maxBufferedEnd;
             }
             catch (err) {
-                log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+                log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
                 return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
             }
         }
         return "partial" /* MediaSourceDurationUpdateStatus.Partial */;
     }
     else {
-        var oldDuration = mediaSource.duration;
+        const oldDuration = mediaSource.duration;
         try {
-            log.info("Init: Updating duration", newDuration);
+            log_1.default.info("Init: Updating duration", newDuration);
             mediaSource.duration = newDuration;
             if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
-                mediaSource.setLiveSeekableRange(0, getMaximumLiveSeekablePosition(duration));
+                const maxSeekable = getMaximumLiveSeekablePosition(duration);
+                log_1.default.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
+                mediaSource.setLiveSeekableRange(0, maxSeekable);
             }
         }
         catch (err) {
-            log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+            log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
             return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
         }
-        var deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+        const deltaToExpected = Math.abs(mediaSource.duration - newDuration);
         if (deltaToExpected >= 0.1) {
-            var deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+            const deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
             return deltaToExpected < deltaToBefore ? "partial" /* MediaSourceDurationUpdateStatus.Partial */ :
                 "failed" /* MediaSourceDurationUpdateStatus.Failed */;
         }
@@ -168,7 +171,7 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
     }
 }
 /**
- * Returns an `ISharedReference` wrapping a boolean that tells if all the
+ * Returns a `SharedReference` wrapping a boolean that tells if all the
  * SourceBuffers ended all pending updates.
  * @param {SourceBufferList} sourceBuffers
  * @param {Object} cancelSignal
@@ -176,28 +179,25 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
  */
 function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
     if (sourceBuffers.length === 0) {
-        var notOpenedRef = createSharedReference(false);
+        const notOpenedRef = new reference_1.default(false);
         notOpenedRef.finish();
         return notOpenedRef;
     }
-    var areUpdatingRef = createSharedReference(false, cancelSignal);
+    const areUpdatingRef = new reference_1.default(false, cancelSignal);
     reCheck();
-    var _loop_1 = function (i) {
-        var sourceBuffer = sourceBuffers[i];
+    for (let i = 0; i < sourceBuffers.length; i++) {
+        const sourceBuffer = sourceBuffers[i];
         sourceBuffer.addEventListener("updatestart", reCheck);
         sourceBuffer.addEventListener("update", reCheck);
-        cancelSignal.register(function () {
+        cancelSignal.register(() => {
             sourceBuffer.removeEventListener("updatestart", reCheck);
             sourceBuffer.removeEventListener("update", reCheck);
         });
-    };
-    for (var i = 0; i < sourceBuffers.length; i++) {
-        _loop_1(i);
     }
     return areUpdatingRef;
     function reCheck() {
-        for (var i = 0; i < sourceBuffers.length; i++) {
-            var sourceBuffer = sourceBuffers[i];
+        for (let i = 0; i < sourceBuffers.length; i++) {
+            const sourceBuffer = sourceBuffers[i];
             if (sourceBuffer.updating) {
                 areUpdatingRef.setValueIfChanged(true);
                 return;
@@ -207,21 +207,24 @@ function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
     }
 }
 /**
- * Returns an `ISharedReference` wrapping a boolean that tells if the media
+ * Returns a `SharedReference` wrapping a boolean that tells if the media
  * source is opened or not.
  * @param {MediaSource} mediaSource
  * @param {Object} cancelSignal
  * @returns {Object}
  */
 function createMediaSourceOpenReference(mediaSource, cancelSignal) {
-    var isMediaSourceOpen = createSharedReference(mediaSource.readyState === "open", cancelSignal);
-    onSourceOpen(mediaSource, function () {
+    const isMediaSourceOpen = new reference_1.default(mediaSource.readyState === "open", cancelSignal);
+    (0, event_listeners_1.onSourceOpen)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource open in duration updater");
         isMediaSourceOpen.setValueIfChanged(true);
     }, cancelSignal);
-    onSourceEnded(mediaSource, function () {
+    (0, event_listeners_1.onSourceEnded)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource ended in duration updater");
         isMediaSourceOpen.setValueIfChanged(false);
     }, cancelSignal);
-    onSourceClose(mediaSource, function () {
+    (0, event_listeners_1.onSourceClose)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource close in duration updater");
         isMediaSourceOpen.setValueIfChanged(false);
     }, cancelSignal);
     return isMediaSourceOpen;
@@ -238,15 +241,15 @@ function createMediaSourceOpenReference(mediaSource, cancelSignal) {
  * @param {Object} cancelSignal
  */
 function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
-    var res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
+    const res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
     if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
         return;
     }
-    var timeoutId = setTimeout(function () {
+    const timeoutId = setTimeout(() => {
         unregisterClear();
         recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
     }, 2000);
-    var unregisterClear = cancelSignal.register(function () {
+    const unregisterClear = cancelSignal.register(() => {
         clearTimeout(timeoutId);
     });
 }

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

@@ -42,9 +42,9 @@ export default class RebufferingController extends EventEmitter<IRebufferingCont
     private _discontinuitiesStore;
     private _canceller;
     /**
-     * If set to something else than `null`, this is the DOMHighResTimestamp as
-     * outputed by `performance.now()` when playback begin to seem to not start
-     * despite having decipherable data in the buffer(s).
+     * If set to something else than `null`, this is the monotonically-raising
+     * timestamp when playback begin to seem to not start despite having
+     * decipherable data in the buffer(s).
      *
      * If enough time in that condition is spent, special considerations are
      * taken at which point `_currentFreezeTimestamp` is reset to `null`.