rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/main_thread/init/types.d.ts

@@ -0,0 +1,240 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type { ISegmentSinkMetrics } from "../../core/segment_sinks/segment_sinks_store";
+import type { IBufferType, IAdaptationChoice, IInbandEvent } from "../../core/types";
+import type { IPeriodsUpdateResult, IAdaptationMetadata, IManifestMetadata, IPeriodMetadata, IRepresentationMetadata, IDecipherabilityStatusChangedElement } from "../../manifest";
+import type { IMediaElementPlaybackObserver } from "../../playback_observer";
+import type { IPlayerError } from "../../public_types";
+import type { IThumbnailResponse } from "../../transports";
+import EventEmitter from "../../utils/event_emitter";
+import type SharedReference from "../../utils/reference";
+import type { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./utils/stream_events_emitter";
+/**
+ * Class allowing to start playing a content on an `HTMLMediaElement`.
+ *
+ * The actual constructor arguments depend on the `ContentInitializer` defined,
+ * but should reflect all potential configuration wanted relative to this
+ * content's playback.
+ *
+ * Various events may be emitted by a `ContentInitializer`. However, no event
+ * should be emitted before `prepare` or `start` is called and no event should
+ * be emitted after `dispose` is called.
+ */
+export declare abstract class ContentInitializer extends EventEmitter<IContentInitializerEvents> {
+    /**
+     * Prepare the content linked to this `ContentInitializer` in the background,
+     * without actually trying to play it.
+     *
+     * This method may be used for optimization reasons, for example to prepare a
+     * future content without interrupting the previous one playing on a given
+     * `HTMLMediaElement`.
+     */
+    abstract prepare(): void;
+    /**
+     * Actually starts playing the content linked to this `ContentInitializer` on
+     * the given `mediaElement`.
+     *
+     * Only a single call to `start` is expected to be performed on each
+     * `ContentInitializer`.
+     *
+     * A call to `prepare` may or may not have been performed before calling
+     * `start`. If it was, it may or may not have yet finished the preparation
+     * phase before `start` is called (the `ContentInitializer` should stay
+     * resilient in both scenarios).
+     *
+     * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which the
+     * content will play. This is given to `start` (and not sooner) to ensure
+     * that no prior step influence the `HTMLMediaElement`, on which a previous
+     * content could have been playing until then.
+     *
+     * If a content was already playing on that `HTMLMediaElement`, it will be
+     * stopped.
+     * @param {Object} playbackObserver - Interface allowing to poll playback
+     * information on what's playing on the `HTMLMediaElement` at regular
+     * intervals.
+     */
+    abstract start(mediaElement: IMediaElement, playbackObserver: IMediaElementPlaybackObserver): void;
+    /**
+     * Update URL of the content currently being played (e.g. DASH's MPD).
+     * @param {Array.<string>|undefined} urls - URLs to reach that content /
+     * Manifest from the most prioritized URL to the least prioritized URL.
+     * @param {boolean} refreshNow - If `true` the resource in question (e.g.
+     * DASH's MPD) will be refreshed immediately.
+     */
+    abstract updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void;
+    /**
+     * Stop playing the content linked to this `ContentInitializer` on the
+     * `HTMLMediaElement` linked to it and dispose of every resources taken while
+     * trying to do so.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * disposal. Might be used for debugging matters, especially for debug log
+     * inspection.
+     */
+    abstract dispose(reason: string | undefined): void;
+}
+/** Every events emitted by a `ContentInitializer`. */
+export interface IContentInitializerEvents {
+    /** Event sent when a minor happened. */
+    warning: IPlayerError;
+    /** A fatal error occured, leading to the current content being stopped. */
+    error: unknown;
+    /** Event sent after the Manifest has been loaded and parsed for the first time. */
+    manifestReady: IManifestMetadata;
+    /** Event sent after the Manifest has been updated. */
+    manifestUpdate: IPeriodsUpdateResult;
+    /**
+     * The codecs support for some tracks may have changed.
+     */
+    codecSupportUpdate: null;
+    /**
+     * Event sent after the decipherability status of at least one Representation
+     * in the Manifest has been updated.
+     */
+    decipherabilityUpdate: IDecipherabilityStatusChangedElement[];
+    /**
+     * Event sent when we're starting attach a new MediaSource to the media element
+     * (after removing the previous one).
+     */
+    reloadingMediaSource: {
+        /** The position we're reloading at, in seconds. */
+        position: number;
+        /**
+         * If `true`, we'll play directly after finishing the reloading operation.
+         * If `false`, we'll be paused after it.
+         */
+        autoPlay: boolean;
+    };
+    /** Event sent after the player stalled. */
+    stalled: IStallingSituation;
+    /** Event sent when the player goes out of a stalling situation. */
+    unstalled: null;
+    /**
+     * Event sent just as the content is considered as "loaded".
+     * From this point on, the user can reliably play/pause/resume the stream.
+     */
+    loaded: {
+        getSegmentSinkMetrics: null | (() => Promise<ISegmentSinkMetrics | undefined>);
+        /**
+         * Fetch the thumbnail data of the given Period for the corresponding time.
+         * If there's no thumbnail for that Period or if the request fails, reject
+         * the Promise with a given reason.
+         * @param {number} time
+         */
+        getThumbnailData: (periodId: string, thumbnailTrackId: string, time: number) => Promise<IThumbnailResponse>;
+    };
+    /** Event emitted when a stream event is encountered. */
+    streamEvent: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+    streamEventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+    /** Emitted when a new `Period` is currently playing. */
+    activePeriodChanged: {
+        /** The Period we're now playing. */
+        period: IPeriodMetadata;
+    };
+    /**
+     * A new `PeriodStream` is ready to start but needs an Adaptation (i.e. track)
+     * to be chosen first.
+     */
+    periodStreamReady: {
+        /** The type of buffer linked to the `PeriodStream` we want to create. */
+        type: IBufferType;
+        /** The `Period` linked to the `PeriodStream` we have created. */
+        period: IPeriodMetadata;
+        /**
+         * The Reference through which any Adaptation (i.e. track) choice should be
+         * emitted for that `PeriodStream`.
+         *
+         * The `PeriodStream` will not do anything until this Reference has emitted
+         * at least one to give its initial choice.
+         * You can send `null` through it to tell this `PeriodStream` that you don't
+         * want any `Adaptation`.
+         * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
+         * yourself.
+         */
+        adaptationRef: SharedReference<IAdaptationChoice | null | undefined>;
+    };
+    /**
+     * A `PeriodStream` has been removed.
+     * This event can be used for clean-up purposes. For example, you are free to
+     * remove from scope the shared reference that you used to choose a track for
+     * that `PeriodStream`.
+     */
+    periodStreamCleared: {
+        /**
+         * The type of buffer linked to the `PeriodStream` we just removed.
+         *
+         * The combination of this and `Period` should give you enough information
+         * about which `PeriodStream` has been removed.
+         */
+        type: IBufferType;
+        /**
+         * The `id` property of the `Period` linked to the `PeriodStream` we just
+         * removed.
+         *
+         * The combination of this and `Period` should give you enough information
+         * about which `PeriodStream` has been removed.
+         */
+        periodId: string;
+    };
+    /** Emitted when a new `Adaptation` is being considered. */
+    adaptationChange: IAdaptationChangeEventPayload;
+    /** Emitted as new bitrate estimates are done. */
+    bitrateEstimateChange: {
+        /** The type of buffer for which the estimation is done. */
+        type: IBufferType;
+        /**
+         * The bitrate estimate, in bits per seconds. `undefined` when no bitrate
+         * estimate is currently available.
+         */
+        bitrate: number | undefined;
+    };
+    /** Emitted when a new `Representation` is being considered. */
+    representationChange: {
+        /** The type of buffer linked to that `RepresentationStream`. */
+        type: IBufferType;
+        /** The `Period` linked to the `RepresentationStream` we're creating. */
+        period: IPeriodMetadata;
+        /**
+         * The `Representation` linked to the `RepresentationStream` we're creating.
+         * `null` when we're choosing no Representation at all.
+         */
+        representation: IRepresentationMetadata | null;
+    };
+    /**
+     * Event emitted when one or multiple inband events (i.e. events inside a
+     * given segment) have been encountered.
+     */
+    inbandEvents: IInbandEvent[];
+}
+export interface IAdaptationChangeEventPayload {
+    /** The type of buffer for which the Representation is changing. */
+    type: IBufferType;
+    /** The `Period` linked to the `RepresentationStream` we're creating. */
+    period: IPeriodMetadata;
+    /**
+     * The `Adaptation` linked to the `AdaptationStream` we're creating.
+     * `null` when we're choosing no Adaptation at all.
+     */
+    adaptation: IAdaptationMetadata | null;
+}
+export type IStallingSituation = "seeking" | "not-ready" | "internal-seek" | "buffering" | "freezing";
+export type ITextDisplayerOptions = {
+    textTrackMode?: "native";
+} | {
+    textTrackMode: "html";
+    textTrackElement: HTMLElement;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/commonjs/main_thread/init/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/main_thread/init/types.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/main_thread/init/types.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentInitializer = void 0;
+var event_emitter_1 = require("../../utils/event_emitter");
+/**
+ * Class allowing to start playing a content on an `HTMLMediaElement`.
+ *
+ * The actual constructor arguments depend on the `ContentInitializer` defined,
+ * but should reflect all potential configuration wanted relative to this
+ * content's playback.
+ *
+ * Various events may be emitted by a `ContentInitializer`. However, no event
+ * should be emitted before `prepare` or `start` is called and no event should
+ * be emitted after `dispose` is called.
+ */
+var ContentInitializer = /** @class */ (function (_super) {
+    __extends(ContentInitializer, _super);
+    function ContentInitializer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return ContentInitializer;
+}(event_emitter_1.default));
+exports.ContentInitializer = ContentInitializer;

package/dist/commonjs/main_thread/init/utils/create_core_playback_observer.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IPausedPlaybackObservation } from "../../../core/types";
+import type { IManifestMetadata } from "../../../manifest";
+import type { IMediaSourceInterface } from "../../../mse";
+import type { IPlaybackObservation, IReadOnlyPlaybackObserver, IMediaElementPlaybackObserver, ObservationPosition, IRebufferingStatus, IFreezingStatus } from "../../../playback_observer";
+import type { ITrackType } from "../../../public_types";
+import type { IRange } from "../../../utils/ranges";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { ITextDisplayer } from "../../text_displayer";
+/** Arguments needed to create the core's version of the PlaybackObserver. */
+export interface ICorePlaybackObserverArguments {
+    /** If true, the player will auto-play when `initialPlayPerformed` becomes `true`. */
+    autoPlay: boolean;
+    /** Manifest of the content being played */
+    manifest: IManifestMetadata;
+    /** Becomes `true` after the initial play has been taken care of. */
+    initialPlayPerformed: IReadOnlySharedReference<boolean>;
+    /** The last speed requested by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /**
+     * Used abstraction to implement text track displaying.
+     *
+     * `null` if text tracks are disabled
+     */
+    textDisplayer: ITextDisplayer | null;
+    /** Used abstraction for MSE API. */
+    mediaSource: IMediaSourceInterface | null;
+}
+export interface ICorePlaybackObservation {
+    /**
+     * Information on whether the media element was paused at the time of the
+     * Observation.
+     */
+    paused: IPausedPlaybackObservation;
+    /**
+     * Information on the current media position in seconds at the time of the
+     * Observation.
+     */
+    position: ObservationPosition;
+    /** `duration` property of the HTMLMediaElement. */
+    duration: number;
+    /** `readyState` property of the HTMLMediaElement. */
+    readyState: number;
+    /** Target playback rate at which we want to play the content. */
+    speed: number;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
+    /**
+     * Ranges of buffered data per type of media.
+     * `null` if no buffer exists for that type of media.
+     */
+    buffered: Record<ITrackType, IRange[] | null>;
+    rebuffering: IRebufferingStatus | null;
+    freezing: IFreezingStatus | null;
+    bufferGap: number | undefined;
+    /**
+     * Indicates whether the user agent believes it has enough buffered data to ensure
+     * uninterrupted playback for a meaningful period or needs more data.
+     * It also reflects whether the user agent can retrieve and buffer data in an
+     * energy-efficient manner while maintaining the desired memory usage.
+     * `true` indicates that the buffer is low, and more data should be buffered.
+     * `false` indicates that there is enough buffered data, and no additional data needs
+     *  to be buffered at this time.
+     */
+    canStream: boolean;
+    /** If `true` the content is loaded until its maximum position. */
+    fullyLoaded: boolean;
+}
+/**
+ * Create PlaybackObserver for the core part of the code.
+ * @param {Object} srcPlaybackObserver - Base `PlaybackObserver` from which we
+ * will derive information.
+ * @param {Object} context - Various information linked to the current content
+ * being played.
+ * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
+ * @returns {Object}
+ */
+export default function createCorePlaybackObserver(srcPlaybackObserver: IMediaElementPlaybackObserver, { autoPlay, initialPlayPerformed, manifest, mediaSource, speed, textDisplayer, }: ICorePlaybackObserverArguments, fnCancelSignal: CancellationSignal): IReadOnlyPlaybackObserver<ICorePlaybackObservation>;
+export declare function updateWantedPositionIfAfterManifest(observation: IPlaybackObservation, manifest: IManifestMetadata): void;
+export declare function getPendingPaused(initialPlayPerformed: IReadOnlySharedReference<boolean>, autoPlay: boolean): boolean | undefined;
+//# sourceMappingURL=create_core_playback_observer.d.ts.map

package/dist/commonjs/main_thread/init/utils/create_core_playback_observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_core_playback_observer.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/init/utils/create_core_playback_observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EACV,oBAAoB,EACpB,yBAAyB,EACzB,6BAA6B,EAC7B,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAExE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,6EAA6E;AAC7E,MAAM,WAAW,8BAA8B;IAC7C,qFAAqF;IACrF,QAAQ,EAAE,OAAO,CAAC;IAClB,2CAA2C;IAC3C,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,oEAAoE;IACpE,oBAAoB,EAAE,wBAAwB,CAAC,OAAO,CAAC,CAAC;IACxD,4CAA4C;IAC5C,KAAK,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACxC;;;;OAIG;IACH,aAAa,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,oCAAoC;IACpC,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,MAAM,EAAE,0BAA0B,CAAC;IACnC;;;OAGG;IACH,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;IAC9C,WAAW,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACvC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;OAQG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAChD,mBAAmB,EAAE,6BAA6B,EAClD,EACE,QAAQ,EACR,oBAAoB,EACpB,QAAQ,EACR,WAAW,EACX,KAAK,EACL,aAAa,GACd,EAAE,8BAA8B,EACjC,cAAc,EAAE,kBAAkB,GACjC,yBAAyB,CAAC,wBAAwB,CAAC,CAgErD;AAED,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,oBAAoB,EACjC,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAyBN;AAED,wBAAgB,gBAAgB,CAC9B,oBAAoB,EAAE,wBAAwB,CAAC,OAAO,CAAC,EACvD,QAAQ,EAAE,OAAO,GAChB,OAAO,GAAG,SAAS,CAErB"}

package/dist/commonjs/main_thread/init/utils/create_core_playback_observer.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createCorePlaybackObserver;
+exports.updateWantedPositionIfAfterManifest = updateWantedPositionIfAfterManifest;
+exports.getPendingPaused = getPendingPaused;
+// TODO: move that file somewhere else
+var get_buffered_data_per_media_buffer_1 = require("../../../core/entry/get_buffered_data_per_media_buffer");
+var manifest_1 = require("../../../manifest");
+var reference_1 = require("../../../utils/reference");
+var task_canceller_1 = require("../../../utils/task_canceller");
+/**
+ * Create PlaybackObserver for the core part of the code.
+ * @param {Object} srcPlaybackObserver - Base `PlaybackObserver` from which we
+ * will derive information.
+ * @param {Object} context - Various information linked to the current content
+ * being played.
+ * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
+ * @returns {Object}
+ */
+function createCorePlaybackObserver(srcPlaybackObserver, _a, fnCancelSignal) {
+    var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, manifest = _a.manifest, mediaSource = _a.mediaSource, speed = _a.speed, textDisplayer = _a.textDisplayer;
+    return srcPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, parentObserverCancelSignal) {
+        var canceller = new task_canceller_1.default("Core PlaybackObserver");
+        canceller.linkToSignal(parentObserverCancelSignal);
+        canceller.linkToSignal(fnCancelSignal);
+        var newRef = new reference_1.default(constructCorePlaybackObservation(), canceller.signal);
+        // TODO there might be subtle unexpected behavior here as updating the
+        // speed will send observation which may be outdated at the time it is sent
+        speed.onUpdate(emitCorePlaybackObservation, {
+            clearSignal: canceller.signal,
+            emitCurrentValue: false,
+        });
+        observationRef.onUpdate(emitCorePlaybackObservation, {
+            clearSignal: canceller.signal,
+            emitCurrentValue: false,
+        });
+        // TODO there might be subtle unexpected behavior here as listening to mediaSource
+        // event will send observation which may be outdated at the time it is sent
+        mediaSource === null || mediaSource === void 0 ? void 0 : mediaSource.addEventListener("streamingChanged", function () {
+            emitCorePlaybackObservation();
+        }, canceller.signal);
+        return newRef;
+        function constructCorePlaybackObservation() {
+            var _a;
+            var observation = observationRef.getValue();
+            var lastSpeed = speed.getValue();
+            updateWantedPositionIfAfterManifest(observation, manifest);
+            return {
+                // TODO more exact according to the current Adaptation chosen?
+                maximumPosition: (0, manifest_1.getMaximumSafePosition)(manifest),
+                bufferGap: observation.bufferGap,
+                position: observation.position,
+                buffered: (0, get_buffered_data_per_media_buffer_1.default)(mediaSource, textDisplayer),
+                duration: observation.duration,
+                rebuffering: observation.rebuffering,
+                freezing: observation.freezing,
+                paused: {
+                    last: observation.paused,
+                    pending: getPendingPaused(initialPlayPerformed, autoPlay),
+                },
+                readyState: observation.readyState,
+                speed: lastSpeed,
+                canStream: (_a = mediaSource === null || mediaSource === void 0 ? void 0 : mediaSource.streaming) !== null && _a !== void 0 ? _a : true,
+                fullyLoaded: observation.fullyLoaded,
+            };
+        }
+        function emitCorePlaybackObservation() {
+            newRef.setValue(constructCorePlaybackObservation());
+        }
+    });
+}
+function updateWantedPositionIfAfterManifest(observation, manifest) {
+    if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+        // HACK: When the position is actually further than the maximum
+        // position for a finished content, we actually want to be loading
+        // the last segment before ending.
+        // 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];
+        if (lastPeriod !== undefined && lastPeriod.end !== undefined) {
+            var wantedPosition = observation.position.getWanted();
+            if (wantedPosition >= lastPeriod.start && wantedPosition >= lastPeriod.end - 1) {
+                // We're after the end of the last Period, check if `buffered`
+                // indicates that the last segment is probably not loaded, in which
+                // case act as if we want to load one second before the end.
+                var buffered = observation.buffered;
+                if (buffered.length === 0 ||
+                    buffered.end(buffered.length - 1) < observation.duration - 1) {
+                    observation.position.forceWantedPosition(lastPeriod.end - 1);
+                }
+            }
+        }
+    }
+}
+function getPendingPaused(initialPlayPerformed, autoPlay) {
+    return initialPlayPerformed.getValue() ? undefined : !autoPlay;
+}

package/dist/commonjs/main_thread/init/utils/get_initial_time.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IManifestMetadata } from "../../../manifest";
+/**
+ * All possible initial time options that can be set.
+ *
+ * Written this way (with many type possibilities) on purpose to avoid issues
+ * if the application using the RxPlayer gives undocumented values such as
+ * `null`.
+ *
+ * TODO we shouldn't be that robust, at least not outside the API code, because
+ * if we begin to be that liberal here, where should we end?
+ * We may instead either want to progressively remove tolerance on the wrong
+ * type being given or be better to enforce type-compliancy in the API code.
+ */
+export interface IInitialTimeOptions {
+    /** If set, we should begin at this position, in seconds. */
+    position?: number | null | undefined;
+    /** If set, we should begin at this unix timestamp, in seconds. */
+    wallClockTime?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the content's start,
+     * in seconds.
+     */
+    fromFirstPosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the content's maximum
+     * seekable position, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
+     */
+    fromLastPosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the content's live
+     * edge if it makes sense, in seconds.
+     *
+     * It should consequently in most cases be a negative value.
+     *
+     * If the live edge is unknown or if it does not make sense for the current
+     * content, that position is relative to the content's maximum position
+     * instead.
+     */
+    fromLivePosition?: number | null | undefined;
+    /**
+     * If set, we should begin at this position relative to the whole duration of
+     * the content, in percentage.
+     */
+    percentage?: number | null | undefined;
+}
+/**
+ * Returns the calculated initial time for the content described by the given
+ * Manifest:
+ *   1. if a start time is defined by user, calculate starting time from the
+ *      manifest information
+ *   2. else if the media is live, use the live edge and suggested delays from
+ *      it
+ *   3. else returns the minimum time announced in the manifest
+ * @param {Manifest} manifest
+ * @param {boolean} lowLatencyMode
+ * @param {Object} startAt
+ * @returns {Number}
+ */
+export default function getInitialTime(manifest: IManifestMetadata, lowLatencyMode: boolean, startAt?: IInitialTimeOptions): number;
+//# sourceMappingURL=get_initial_time.d.ts.map

package/dist/commonjs/main_thread/init/utils/get_initial_time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_initial_time.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/init/utils/get_initial_time.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAS3D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9C;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,OAAO,EACvB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CA0HR"}