rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/core/abr/representation_estimator.js

@@ -13,17 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, defer as observableDefer, merge as observableMerge, of as observableOf, } from "rxjs";
-import { filter, ignoreElements, map, startWith, switchMap, tap, withLatestFrom, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, defer as observableDefer, filter, ignoreElements, map, merge as observableMerge, of as observableOf, startWith, switchMap, tap, withLatestFrom, } from "rxjs";
 import log from "../../log";
 import { getLeftSizeOfRange } from "../../utils/ranges";
 import BufferBasedChooser from "./buffer_based_chooser";
-import filterByBitrate from "./filter_by_bitrate";
-import filterByWidth from "./filter_by_width";
+import GuessBasedChooser from "./guess_based_chooser";
+import LastEstimateStorage from "./last_estimate_storage";
 import NetworkAnalyzer from "./network_analyzer";
 import PendingRequestsStore from "./pending_requests_store";
 import RepresentationScoreCalculator from "./representation_score_calculator";
-import selectOptimalRepresentation from "./select_optimal_representation";
+import filterByBitrate from "./utils/filter_by_bitrate";
+import filterByWidth from "./utils/filter_by_width";
+import selectOptimalRepresentation from "./utils/select_optimal_representation";
 /**
  * Filter representations given through filters options.
  * @param {Array.<Representation>} representations
@@ -31,14 +32,14 @@ import selectOptimalRepresentation from "./select_optimal_representation";
  * @returns {Array.<Representation>}
  */
 function getFilteredRepresentations(representations, filters) {
-    var _representations = representations;
+    var filteredReps = representations;
     if (filters.bitrate != null) {
-        _representations = filterByBitrate(_representations, filters.bitrate);
+        filteredReps = filterByBitrate(filteredReps, filters.bitrate);
     }
     if (filters.width != null) {
-        _representations = filterByWidth(_representations, filters.width);
+        filteredReps = filterByWidth(filteredReps, filters.width);
     }
-    return _representations;
+    return filteredReps;
 }
 /**
  * Estimate regularly the current network bandwidth and the best Representation
@@ -53,7 +54,7 @@ function getFilteredRepresentations(representations, filters) {
  * @returns {Observable}
  */
 export default function RepresentationEstimator(_a) {
-    var bandwidthEstimator = _a.bandwidthEstimator, clock$ = _a.clock$, filters$ = _a.filters$, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate$ = _a.manualBitrate$, minAutoBitrate$ = _a.minAutoBitrate$, maxAutoBitrate$ = _a.maxAutoBitrate$, representations = _a.representations, streamEvents$ = _a.streamEvents$;
+    var bandwidthEstimator = _a.bandwidthEstimator, observation$ = _a.observation$, filters$ = _a.filters$, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate$ = _a.manualBitrate$, minAutoBitrate$ = _a.minAutoBitrate$, maxAutoBitrate$ = _a.maxAutoBitrate$, representations = _a.representations, streamEvents$ = _a.streamEvents$;
     var scoreCalculator = new RepresentationScoreCalculator();
     var networkAnalyzer = new NetworkAnalyzer(initialBitrate == null ? 0 :
         initialBitrate, lowLatencyMode);
@@ -63,15 +64,19 @@ export default function RepresentationEstimator(_a) {
      * @param {Object} value
      */
     function onMetric(value) {
-        var duration = value.duration, size = value.size, content = value.content;
+        var requestDuration = value.requestDuration, segmentDuration = value.segmentDuration, size = value.size, content = value.content;
         // calculate bandwidth
-        bandwidthEstimator.addSample(duration, size);
-        // calculate "maintainability score"
-        var segment = content.segment;
-        var requestDuration = duration / 1000;
-        var segmentDuration = segment.duration;
-        var representation = content.representation;
-        scoreCalculator.addSample(representation, requestDuration, segmentDuration);
+        bandwidthEstimator.addSample(requestDuration, size);
+        if (!content.segment.isInit) {
+            // calculate "maintainability score"
+            var segment = content.segment, representation = content.representation;
+            if (segmentDuration === undefined && !segment.complete) {
+                // We cannot know the real duration of the segment
+                return;
+            }
+            var segDur = segmentDuration !== null && segmentDuration !== void 0 ? segmentDuration : segment.duration;
+            scoreCalculator.addSample(representation, requestDuration / 1000, segDur);
+        }
     }
     var metrics$ = streamEvents$.pipe(filter(function (e) { return e.type === "metrics"; }), tap(function (_a) {
         var value = _a.value;
@@ -115,68 +120,122 @@ export default function RepresentationEstimator(_a) {
                 });
             }
             // -- AUTO mode --
-            var lastEstimatedBitrate;
-            var forceBandwidthMode = true;
+            /** Store the previous estimate made here. */
+            var prevEstimate = new LastEstimateStorage();
+            var allowBufferBasedEstimates = false;
+            var guessBasedChooser = new GuessBasedChooser(scoreCalculator, prevEstimate);
             // Emit each time a buffer-based estimation should be actualized (each
             // time a segment is added).
-            var bufferBasedClock$ = streamEvents$.pipe(filter(function (e) { return e.type === "added-segment"; }), withLatestFrom(clock$), map(function (_a) {
+            var bufferBasedobservation$ = streamEvents$.pipe(filter(function (e) { return e.type === "added-segment"; }), withLatestFrom(observation$), map(function (_a) {
                 var evtValue = _a[0].value, _b = _a[1], speed = _b.speed, position = _b.position;
                 var timeRanges = evtValue.buffered;
                 var bufferGap = getLeftSizeOfRange(timeRanges, position);
                 var representation = evtValue.content.representation;
-                var currentScore = scoreCalculator.getEstimate(representation);
+                var scoreData = scoreCalculator.getEstimate(representation);
+                var currentScore = scoreData === null || scoreData === void 0 ? void 0 : scoreData[0];
                 var currentBitrate = representation.bitrate;
                 return { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
             }));
             var bitrates = representations.map(function (r) { return r.bitrate; });
-            var bufferBasedEstimation$ = BufferBasedChooser(bufferBasedClock$, bitrates)
+            var bufferBasedEstimation$ = BufferBasedChooser(bufferBasedobservation$, bitrates)
                 .pipe(startWith(undefined));
-            return observableCombineLatest([clock$,
+            return observableCombineLatest([observation$,
                 minAutoBitrate$,
                 maxAutoBitrate$,
                 filters$,
                 bufferBasedEstimation$]).pipe(withLatestFrom(currentRepresentation$), map(function (_a) {
-                var _b = _a[0], clock = _b[0], minAutoBitrate = _b[1], maxAutoBitrate = _b[2], filters = _b[3], bufferBasedBitrate = _b[4], currentRepresentation = _a[1];
-                var _representations = getFilteredRepresentations(representations, filters);
+                var _b = _a[0], observation = _b[0], minAutoBitrate = _b[1], maxAutoBitrate = _b[2], filters = _b[3], bufferBasedBitrate = _b[4], currentRepresentation = _a[1];
+                var bufferGap = observation.bufferGap, liveGap = observation.liveGap;
+                var filteredReps = getFilteredRepresentations(representations, filters);
                 var requests = requestsStore.getRequests();
                 var _c = networkAnalyzer
-                    .getBandwidthEstimate(clock, bandwidthEstimator, currentRepresentation, requests, lastEstimatedBitrate), bandwidthEstimate = _c.bandwidthEstimate, bitrateChosen = _c.bitrateChosen;
-                lastEstimatedBitrate = bandwidthEstimate;
+                    .getBandwidthEstimate(observation, bandwidthEstimator, currentRepresentation, requests, prevEstimate.bandwidth), bandwidthEstimate = _c.bandwidthEstimate, bitrateChosen = _c.bitrateChosen;
                 var stableRepresentation = scoreCalculator.getLastStableRepresentation();
-                var knownStableBitrate = stableRepresentation == null ?
+                var knownStableBitrate = stableRepresentation === null ?
                     undefined :
-                    stableRepresentation.bitrate / (clock.speed > 0 ? clock.speed : 1);
-                var bufferGap = clock.bufferGap;
-                if (!forceBandwidthMode && bufferGap <= 5) {
-                    forceBandwidthMode = true;
+                    stableRepresentation.bitrate / (observation.speed > 0 ? observation.speed :
+                        1);
+                if (allowBufferBasedEstimates && bufferGap <= 5) {
+                    allowBufferBasedEstimates = false;
+                }
+                else if (!allowBufferBasedEstimates &&
+                    isFinite(bufferGap) &&
+                    bufferGap > 10) {
+                    allowBufferBasedEstimates = true;
                 }
-                else if (forceBandwidthMode && isFinite(bufferGap) && bufferGap > 10) {
-                    forceBandwidthMode = false;
+                /**
+                 * Representation chosen when considering only [pessimist] bandwidth
+                 * calculation.
+                 * This is a safe enough choice but might be lower than what the user
+                 * could actually profit from.
+                 */
+                var chosenRepFromBandwidth = selectOptimalRepresentation(filteredReps, bitrateChosen, minAutoBitrate, maxAutoBitrate);
+                var currentBestBitrate = chosenRepFromBandwidth.bitrate;
+                /**
+                 * Representation chosen when considering the current buffer size.
+                 * If defined, takes precedence over `chosenRepFromBandwidth`.
+                 *
+                 * This is a very safe choice, yet it is very slow and might not be
+                 * adapted to cases where a buffer cannot be build, such as live contents.
+                 *
+                 * `null` if this buffer size mode is not enabled or if we don't have a
+                 * choice from it yet.
+                 */
+                var chosenRepFromBufferSize = null;
+                if (allowBufferBasedEstimates &&
+                    bufferBasedBitrate !== undefined &&
+                    bufferBasedBitrate > currentBestBitrate) {
+                    chosenRepFromBufferSize = selectOptimalRepresentation(filteredReps, bufferBasedBitrate, minAutoBitrate, maxAutoBitrate);
+                    currentBestBitrate = chosenRepFromBufferSize.bitrate;
                 }
-                var chosenRepFromBandwidth = selectOptimalRepresentation(_representations, bitrateChosen, minAutoBitrate, maxAutoBitrate);
-                if (forceBandwidthMode) {
-                    log.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth);
+                /**
+                 * Representation chosen by the more adventurous `GuessBasedChooser`,
+                 * which iterates through Representations one by one until finding one
+                 * that cannot be "maintained".
+                 *
+                 * If defined, takes precedence over both `chosenRepFromBandwidth` and
+                 * `chosenRepFromBufferSize`.
+                 *
+                 * This is the riskiest choice (in terms of rebuffering chances) but is
+                 * only enabled when no other solution is adapted (for now, this just
+                 * applies for low-latency contents when playing close to the live
+                 * edge).
+                 *
+                 * `null` if not enabled or if there's currently no guess.
+                 */
+                var chosenRepFromGuessMode = null;
+                if (lowLatencyMode &&
+                    currentRepresentation !== null &&
+                    liveGap !== undefined &&
+                    liveGap < 40) {
+                    chosenRepFromGuessMode = guessBasedChooser.getGuess(representations, observation, currentRepresentation, currentBestBitrate, requests);
+                }
+                if (chosenRepFromGuessMode !== null &&
+                    chosenRepFromGuessMode.bitrate > currentBestBitrate) {
+                    log.debug("ABR: Choosing representation with guess-based estimation.", chosenRepFromGuessMode.bitrate, chosenRepFromGuessMode.id);
+                    prevEstimate.update(chosenRepFromGuessMode, bandwidthEstimate, 2 /* GuessBased */);
                     return { bitrate: bandwidthEstimate,
-                        representation: chosenRepFromBandwidth,
-                        urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentation, requests, clock),
+                        representation: chosenRepFromGuessMode,
+                        urgent: currentRepresentation === null ||
+                            chosenRepFromGuessMode.bitrate < currentRepresentation.bitrate,
                         manual: false, knownStableBitrate: knownStableBitrate };
                 }
-                if (bufferBasedBitrate == null ||
-                    chosenRepFromBandwidth.bitrate >= bufferBasedBitrate) {
-                    log.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth);
+                else if (chosenRepFromBufferSize !== null) {
+                    log.debug("ABR: Choosing representation with buffer-based estimation.", chosenRepFromBufferSize.bitrate, chosenRepFromBufferSize.id);
+                    prevEstimate.update(chosenRepFromBufferSize, bandwidthEstimate, 0 /* BufferBased */);
                     return { bitrate: bandwidthEstimate,
-                        representation: chosenRepFromBandwidth,
-                        urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentation, requests, clock),
+                        representation: chosenRepFromBufferSize,
+                        urgent: networkAnalyzer.isUrgent(chosenRepFromBufferSize.bitrate, currentRepresentation, requests, observation),
                         manual: false, knownStableBitrate: knownStableBitrate };
                 }
-                var chosenRepresentation = selectOptimalRepresentation(_representations, bufferBasedBitrate, minAutoBitrate, maxAutoBitrate);
-                if (bufferBasedBitrate <= maxAutoBitrate) {
-                    log.debug("ABR: Choosing representation with buffer based bitrate ceiling.", chosenRepresentation);
+                else {
+                    log.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth.bitrate, chosenRepFromBandwidth.id);
+                    prevEstimate.update(chosenRepFromBandwidth, bandwidthEstimate, 1 /* BandwidthBased */);
+                    return { bitrate: bandwidthEstimate,
+                        representation: chosenRepFromBandwidth,
+                        urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentation, requests, observation),
+                        manual: false, knownStableBitrate: knownStableBitrate };
                 }
-                return { bitrate: bandwidthEstimate,
-                    representation: chosenRepresentation,
-                    urgent: networkAnalyzer.isUrgent(bufferBasedBitrate, currentRepresentation, requests, clock),
-                    manual: false, knownStableBitrate: knownStableBitrate };
             }));
         }));
     });

package/dist/_esm5.processed/core/abr/representation_score_calculator.d.ts

@@ -62,7 +62,7 @@ export default class RepresentationScoreCalculator {
      * @param {Representation} representation
      * @returns {number|undefined}
      */
-    getEstimate(representation: Representation): number | undefined;
+    getEstimate(representation: Representation): [number, ScoreConfidenceLevel] | undefined;
     /**
      * Returns last Representation which had reached a score superior to 1.
      * This Representation is the last known one which could be maintained.
@@ -72,11 +72,8 @@ export default class RepresentationScoreCalculator {
      * @returns {Representation|null}
      */
     getLastStableRepresentation(): Representation | null;
-    /**
-     * Returns EWMA for the given Representation.
-     * null if no EWMA is currently stored for it.
-     * @param {Representation} representation
-     * @returns {EWMA|null}
-     */
-    private _getEWMA;
+}
+export declare const enum ScoreConfidenceLevel {
+    HIGH = 1,
+    LOW = 0
 }

package/dist/_esm5.processed/core/abr/representation_score_calculator.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import log from "../../log";
-import EWMA from "./ewma";
+import EWMA from "./utils/ewma";
 /**
  * Calculate the "maintainability score" of a given Representation:
  *   - A score higher than 1 means that the Representation can theorically
@@ -59,20 +59,24 @@ var RepresentationScoreCalculator = /** @class */ (function () {
      */
     RepresentationScoreCalculator.prototype.addSample = function (representation, requestDuration, segmentDuration) {
         var ratio = segmentDuration / requestDuration;
-        var oldEwma = this._getEWMA(representation);
+        var currentRep = this._currentRepresentationData;
         var currentEWMA;
-        if (oldEwma != null) {
-            currentEWMA = oldEwma;
-            oldEwma.addSample(requestDuration, ratio);
+        if (currentRep !== null && currentRep.representation.id === representation.id) {
+            currentEWMA = currentRep.ewma;
+            currentRep.ewma.addSample(requestDuration, ratio);
+            currentRep.loadedDuration += segmentDuration;
+            currentRep.loadedSegments++;
         }
         else {
             currentEWMA = new EWMA(5);
             currentEWMA.addSample(requestDuration, ratio);
-            this._currentRepresentationData = { representation: representation, ewma: currentEWMA };
+            this._currentRepresentationData = { representation: representation, ewma: currentEWMA,
+                loadedDuration: segmentDuration,
+                loadedSegments: 0 };
         }
         if (currentEWMA.getEstimate() > 1 &&
             this._lastRepresentationWithGoodScore !== representation) {
-            log.debug("ABR: New last stable representation", representation);
+            log.debug("ABR: New last stable representation", representation.bitrate);
             this._lastRepresentationWithGoodScore = representation;
         }
     };
@@ -83,10 +87,16 @@ var RepresentationScoreCalculator = /** @class */ (function () {
      * @returns {number|undefined}
      */
     RepresentationScoreCalculator.prototype.getEstimate = function (representation) {
-        var ewma = this._getEWMA(representation);
-        if (ewma != null) {
-            return ewma.getEstimate();
+        if (this._currentRepresentationData === null ||
+            this._currentRepresentationData.representation.id !== representation.id) {
+            return undefined;
         }
+        var _a = this._currentRepresentationData, ewma = _a.ewma, loadedSegments = _a.loadedSegments, loadedDuration = _a.loadedDuration;
+        var estimate = ewma.getEstimate();
+        var confidenceLevel = loadedSegments >= 5 &&
+            loadedDuration >= 10 ? 1 /* HIGH */ :
+            0 /* LOW */;
+        return [estimate, confidenceLevel];
     };
     /**
      * Returns last Representation which had reached a score superior to 1.
@@ -99,19 +109,6 @@ var RepresentationScoreCalculator = /** @class */ (function () {
     RepresentationScoreCalculator.prototype.getLastStableRepresentation = function () {
         return this._lastRepresentationWithGoodScore;
     };
-    /**
-     * Returns EWMA for the given Representation.
-     * null if no EWMA is currently stored for it.
-     * @param {Representation} representation
-     * @returns {EWMA|null}
-     */
-    RepresentationScoreCalculator.prototype._getEWMA = function (representation) {
-        if (this._currentRepresentationData != null &&
-            this._currentRepresentationData.representation.id === representation.id) {
-            return this._currentRepresentationData.ewma;
-        }
-        return null;
-    };
     return RepresentationScoreCalculator;
 }());
 export default RepresentationScoreCalculator;

package/dist/_esm5.processed/core/abr/{filter_by_bitrate.d.ts → utils/filter_by_bitrate.d.ts}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Representation } from "../../manifest";
+import { Representation } from "../../../manifest";
 /**
  * Get only representations lower or equal to a given bitrate.
  * If no representation is lower than the given bitrate, returns an array containing

package/dist/_esm5.processed/core/abr/{filter_by_bitrate.js → utils/filter_by_bitrate.js}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import arrayFindIndex from "../../utils/array_find_index";
+import arrayFindIndex from "../../../utils/array_find_index";
 /**
  * Get only representations lower or equal to a given bitrate.
  * If no representation is lower than the given bitrate, returns an array containing

package/dist/_esm5.processed/core/abr/{filter_by_width.d.ts → utils/filter_by_width.d.ts}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Representation } from "../../manifest";
+import { Representation } from "../../../manifest";
 /**
  * Filter representations based on their width:
  *   - the highest width considered will be the one linked to the first

package/dist/_esm5.processed/core/abr/{filter_by_width.js → utils/filter_by_width.js}

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import arrayFind from "../../utils/array_find";
-import takeFirstSet from "../../utils/take_first_set";
+import arrayFind from "../../../utils/array_find";
+import takeFirstSet from "../../../utils/take_first_set";
 /**
  * Filter representations based on their width:
  *   - the highest width considered will be the one linked to the first

package/dist/_esm5.processed/core/abr/{select_optimal_representation.d.ts → utils/select_optimal_representation.d.ts}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Representation } from "../../manifest";
+import { Representation } from "../../../manifest";
 /**
  * From the given array of Representations (sorted by bitrate order ascending),
  * returns the one corresponding to the given optimal, minimum and maximum

package/dist/_esm5.processed/core/abr/{select_optimal_representation.js → utils/select_optimal_representation.js}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import arrayFindIndex from "../../utils/array_find_index";
+import arrayFindIndex from "../../../utils/array_find_index";
 /**
  * From the given array of Representations (sorted by bitrate order ascending),
  * returns the one corresponding to the given optimal, minimum and maximum

package/dist/_esm5.processed/core/api/emit_seek_events.d.ts

@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IClockTick } from "./clock";
+import { IPlaybackObservation } from "./playback_observer";
 /**
  * Returns Observable which will emit:
  *   - `"seeking"` when we are seeking in the given mediaElement
- *   - `"seeked"` when a seek is considered as finished by the given clock$
+ *   - `"seeked"` when a seek is considered as finished by the given observation$
  *     Observable.
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Observable}
  */
-export default function emitSeekEvents(mediaElement: HTMLMediaElement | null, clock$: Observable<IClockTick>): Observable<"seeking" | "seeked">;
+export default function emitSeekEvents(mediaElement: HTMLMediaElement | null, observation$: Observable<IPlaybackObservation>): Observable<"seeking" | "seeked">;

package/dist/_esm5.processed/core/api/emit_seek_events.js

@@ -13,26 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, merge as observableMerge, } from "rxjs";
-import { filter, mapTo, startWith, switchMapTo, take, } from "rxjs/operators";
+import { defer as observableDefer, EMPTY, filter, map, merge as observableMerge, startWith, switchMap, take, } from "rxjs";
 /**
  * Returns Observable which will emit:
  *   - `"seeking"` when we are seeking in the given mediaElement
- *   - `"seeked"` when a seek is considered as finished by the given clock$
+ *   - `"seeked"` when a seek is considered as finished by the given observation$
  *     Observable.
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Observable}
  */
-export default function emitSeekEvents(mediaElement, clock$) {
+export default function emitSeekEvents(mediaElement, observation$) {
     return observableDefer(function () {
         if (mediaElement === null) {
             return EMPTY;
         }
-        var isSeeking$ = clock$.pipe(filter(function (tick) { return tick.event === "seeking"; }), mapTo("seeking"));
-        var hasSeeked$ = isSeeking$.pipe(switchMapTo(clock$.pipe(filter(function (tick) { return tick.event === "seeked"; }), mapTo("seeked"), take(1))));
-        var seekingEvents$ = observableMerge(isSeeking$, hasSeeked$);
-        return mediaElement.seeking ? seekingEvents$.pipe(startWith("seeking")) :
-            seekingEvents$;
+        var isSeeking$ = observation$.pipe(filter(function (observation) { return observation.event === "seeking"; }), map(function () { return "seeking"; }));
+        if (mediaElement.seeking) {
+            isSeeking$ = isSeeking$.pipe(startWith("seeking"));
+        }
+        var hasSeeked$ = isSeeking$.pipe(switchMap(function () {
+            return observation$.pipe(filter(function (observation) { return observation.event === "seeked"; }), map(function () { return "seeked"; }), take(1));
+        }));
+        return observableMerge(isSeeking$, hasSeeked$);
     });
 }

package/dist/_esm5.processed/core/api/index.d.ts

@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import PlaybackObserver from "./playback_observer";
 import Player from "./public_api";
 export { IStreamEvent, IStreamEventData, } from "./public_api";
-export { IClockMediaEventType, IFreezingStatus, IRebufferingStatus, } from "./clock";
+export { PlaybackObserver };
+export { IPlaybackObservation, IPlaybackObserverEventType, IReadOnlyPlaybackObserver, IFreezingStatus, IRebufferingStatus, } from "./playback_observer";
 export { IConstructorOptions, ILoadVideoOptions, ITransportOptions, IKeySystemOption, ISupplementaryTextTrackOption, ISupplementaryImageTrackOption, IDefaultAudioTrackOption, IDefaultTextTrackOption, INetworkConfigOption, IStartAtOption, } from "./option_utils";
 export { ITMAudioTrackListItem, ITMTextTrackListItem, ITMVideoTrackListItem, ITMAudioTrack, ITMTextTrack, ITMVideoTrack, IAudioTrackPreference, ITextTrackPreference, IVideoTrackPreference, } from "./track_choice_manager";
 export default Player;

package/dist/_esm5.processed/core/api/index.js

@@ -13,5 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import PlaybackObserver from "./playback_observer";
 import Player from "./public_api";
+export { PlaybackObserver };
 export default Player;

package/dist/_esm5.processed/core/api/option_utils.js

@@ -198,8 +198,8 @@ function parseConstructorOptions(options) {
         }
         else if (minVideoBitrate > maxVideoBitrate) {
             throw new Error("Invalid maxVideoBitrate parameter. Its value, \"" +
-                (maxVideoBitrate + "\", is inferior to the set minVideoBitrate, \"") +
-                (minVideoBitrate + "\""));
+                "".concat(maxVideoBitrate, "\", is inferior to the set minVideoBitrate, \"") +
+                "".concat(minVideoBitrate, "\""));
         }
     }
     if (isNullOrUndefined(options.maxAudioBitrate)) {
@@ -212,8 +212,8 @@ function parseConstructorOptions(options) {
         }
         else if (minAudioBitrate > maxAudioBitrate) {
             throw new Error("Invalid maxAudioBitrate parameter. Its value, \"" +
-                (maxAudioBitrate + "\", is inferior to the set minAudioBitrate, \"") +
-                (minAudioBitrate + "\""));
+                "".concat(maxAudioBitrate, "\", is inferior to the set minAudioBitrate, \"") +
+                "".concat(minAudioBitrate, "\""));
         }
     }
     var stopAtEnd = isNullOrUndefined(options.stopAtEnd) ? DEFAULT_STOP_AT_END :