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

package/dist/commonjs/main_thread/decrypt/utils/server_certificate_store.js

@@ -0,0 +1,123 @@
+"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 });
+var hash_buffer_1 = require("../../../utils/hash_buffer");
+/**
+ * Keep track of server certificate which have been set for a MediaKeys.
+ * As it is impossible for a MediaKeys to have his server certificate reset
+ * or updated, we consider that once it has been set, it will remain set until
+ * the MediaKeys instance is killed.
+ *
+ * So, a WeakMap helps keeping a trace of which server certificate (identified
+ * with a unique hash) is set on a MediaKeys.
+ * `null` indicate that we don't know (and not `undefined`, because this is the
+ * default value for when a WeakMap has no value for a key) which server
+ * certificate is attached to a MediaKeys instance (most likely because related
+ * EME APIs failed or had an unexpected behavior).
+ */
+var serverCertificateHashesMap = new WeakMap();
+/** ServerCertificateStore */
+exports.default = {
+    /**
+     * Tells the ServerCertificateStore that you begin to call the APIs to set a
+     * ServerCertificate on `mediaKeys`.
+     *
+     * Calling this function is necessary due to how server certificate work
+     * currently in EME APIs:
+     * Because right now, it is impossible to tell if a MediaKeys instance has an
+     * attached ServerCertificate or not when the corresponding API fails or if it
+     * never answers, we prefer to announce through this function that the current
+     * server certificate attached to this MediaKeys is for now invalid.
+     * @param {MediaKeys | Object} mediaKeys
+     */
+    prepare: function (mediaKeys) {
+        serverCertificateHashesMap.set(mediaKeys, null);
+    },
+    /**
+     * Attach a new server certificate to a MediaKeys in the
+     * ServerCertificateStore.
+     *
+     * Only one server certificate should ever be attached to a MediaKeys
+     * instance and the `prepare` function should have been called before any
+     * action to update the server certificate took place (this function does not
+     * enforce either of those behaviors).
+     * @param {MediaKeys | Object} mediaKeys
+     * @param {ArrayBufferView | BufferSource} serverCertificate
+     */
+    set: function (mediaKeys, serverCertificate) {
+        var formattedServerCertificate = serverCertificate instanceof Uint8Array
+            ? serverCertificate
+            : new Uint8Array(serverCertificate instanceof ArrayBuffer
+                ? serverCertificate
+                : serverCertificate.buffer);
+        var hash = (0, hash_buffer_1.default)(formattedServerCertificate);
+        serverCertificateHashesMap.set(mediaKeys, {
+            hash: hash,
+            serverCertificate: formattedServerCertificate,
+        });
+    },
+    /**
+     * Returns `true` if the MediaKeys instance has an attached ServerCertificate.
+     * Returns `false` if it doesn't.
+     *
+     * Returns `undefined` if we cannot know, most likely because related EME APIs
+     * failed or had an unexpected behavior.
+     * @param {MediaKeys} mediaKeys
+     * @returns {Boolean|undefined}
+     */
+    hasOne: function (mediaKeys) {
+        var currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
+        if (currentServerCertificate === undefined) {
+            return false;
+        }
+        if (currentServerCertificate === null) {
+            return undefined;
+        }
+        return true;
+    },
+    /**
+     * Returns `true` if the given `mediaKeys` has `serverCertificate` attached to
+     * it.
+     * Returns `false` either if it doesn't of if we doesn't know if it does.
+     * @param {MediaKeys | Object} mediaKeys
+     * @param {ArrayBufferView | BufferSource} serverCertificate
+     * @returns {boolean}
+     */
+    has: function (mediaKeys, serverCertificate) {
+        var serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
+        if (serverCertificateHash === undefined || serverCertificateHash === null) {
+            return false;
+        }
+        var oldHash = serverCertificateHash.hash, oldServerCertificate = serverCertificateHash.serverCertificate;
+        var newServerCertificate = serverCertificate instanceof Uint8Array
+            ? serverCertificate
+            : new Uint8Array(serverCertificate instanceof ArrayBuffer
+                ? serverCertificate
+                : serverCertificate.buffer);
+        var newHash = (0, hash_buffer_1.default)(newServerCertificate);
+        if (newHash !== oldHash ||
+            oldServerCertificate.length !== newServerCertificate.length) {
+            return false;
+        }
+        for (var i = 0; i < oldServerCertificate.length; i++) {
+            if (oldServerCertificate[i] !== newServerCertificate[i]) {
+                return false;
+            }
+        }
+        return true;
+    },
+};

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

@@ -0,0 +1,116 @@
+/**
+ * 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.
+ */
+/**
+ * /!\ This file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type { IMediaElementPlaybackObserver } from "../../playback_observer";
+import type { IKeySystemOption } from "../../public_types";
+import type { IReadOnlySharedReference } from "../../utils/reference";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import { ContentInitializer } from "./types";
+import type { IInitialTimeOptions } from "./utils/get_initial_time";
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
+export default class DirectFileContentInitializer extends ContentInitializer {
+    /**
+     * Initial options given to the `DirectFileContentInitializer`.
+     */
+    private _settings;
+    /**
+     * Allows to abort and clean everything the `DirectFileContentInitializer` is
+     * doing.
+     */
+    private _initCanceller;
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
+    constructor(settings: IDirectFileOptions);
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
+    prepare(): void;
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
+    start(mediaElement: IMediaElement, playbackObserver: IMediaElementPlaybackObserver): void;
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
+    updateContentUrls(_urls: string[] | undefined, _refreshNow: boolean): void;
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    dispose(reason: string | undefined): void;
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
+    private _onFatalError;
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    private _seekAndPlay;
+}
+/**
+ * Set autoplay value on the mediaElement.
+ *
+ * @param {HTMLElement} mediaElement - The media element whose `autoplay`
+ * attribute will be modified.
+ * @param {CancellationSignal} cancellationSignal - The signal that, when triggered,
+ * restores the `autoplay` attribute to its original value.
+ */
+export declare function setAutoplay(mediaElement: IMediaElement, autoplay: boolean, cancellationSignal: CancellationSignal): void;
+/** Options used by the `DirectFileContentInitializer` */
+export interface IDirectFileOptions {
+    /** If `true` we will play right after the content is considered "loaded". */
+    autoPlay: boolean;
+    /**
+     * Encryption-related settings. Can be left as an empty array if the content
+     * isn't encrypted.
+     */
+    keySystems: IKeySystemOption[];
+    /** Communicate the playback rate wanted by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /** Optional initial position to start at. */
+    startAt?: IInitialTimeOptions | undefined;
+    /** URL that should be played. */
+    url: string;
+}
+//# sourceMappingURL=directfile_content_initializer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directfile_content_initializer.d.ts","sourceRoot":"","sources":["../../../../src/main_thread/init/directfile_content_initializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAI9E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAgB,MAAM,oBAAoB,CAAC;AAIzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAOpE;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,4BAA6B,SAAQ,kBAAkB;IAC1E;;OAEG;IACH,OAAO,CAAC,SAAS,CAAqB;IACtC;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAgB;IAEtC;;;OAGG;gBACS,QAAQ,EAAE,kBAAkB;IAMxC;;OAEG;IACI,OAAO,IAAI,IAAI;IAItB;;;;;;;OAOG;IACI,KAAK,CACV,YAAY,EAAE,aAAa,EAC3B,gBAAgB,EAAE,6BAA6B,GAC9C,IAAI;IA0FP;;;;OAIG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI;IAIjF;;;;;OAKG;IACI,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAIhD;;;OAGG;IACH,OAAO,CAAC,aAAa;IAKrB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;CA8CrB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,YAAY,EAAE,aAAa,EAC3B,QAAQ,EAAE,OAAO,EACjB,kBAAkB,EAAE,kBAAkB,QAiBvC;AA2ED,yDAAyD;AACzD,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,wDAAwD;IACxD,KAAK,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACxC,6CAA6C;IAC7C,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC1C,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;CACb"}

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

@@ -0,0 +1,301 @@
+"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.setAutoplay = setAutoplay;
+var clear_element_src_1 = require("../../compat/clear_element_src");
+var log_1 = require("../../log");
+var assert_1 = require("../../utils/assert");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var noop_1 = require("../../utils/noop");
+var task_canceller_1 = require("../../utils/task_canceller");
+var types_1 = require("./types");
+var get_loaded_reference_1 = require("./utils/get_loaded_reference");
+var initial_seek_and_play_1 = require("./utils/initial_seek_and_play");
+var initialize_content_decryption_1 = require("./utils/initialize_content_decryption");
+var rebuffering_controller_1 = require("./utils/rebuffering_controller");
+var throw_on_media_error_1 = require("./utils/throw_on_media_error");
+/**
+ * `ContentIntializer` which will load contents by putting their URL in the
+ * `src` attribute of the given HTMLMediaElement.
+ *
+ * Because such contents are mainly loaded by the browser, those (called
+ * "directfile" contents in the RxPlayer) needs a simpler logic in-JS when
+ * compared to a content that relies on the MSE API.
+ *
+ * @class DirectFileContentInitializer
+ */
+var DirectFileContentInitializer = /** @class */ (function (_super) {
+    __extends(DirectFileContentInitializer, _super);
+    /**
+     * Creates a new `DirectFileContentInitializer` linked to the given settings.
+     * @param {Object} settings
+     */
+    function DirectFileContentInitializer(settings) {
+        var _this = _super.call(this) || this;
+        _this._settings = settings;
+        _this._initCanceller = new task_canceller_1.default("Directfile Init");
+        return _this;
+    }
+    /**
+     * "Prepare" content so it can later be played by calling `start`.
+     */
+    DirectFileContentInitializer.prototype.prepare = function () {
+        return; // Directfile contents do not have any preparation
+    };
+    /**
+     * Start playback of the content linked to this `DirectFileContentInitializer`
+     * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
+     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
+     * content will be played.
+     * @param {Object} playbackObserver - Object regularly emitting playback
+     * information.
+     */
+    DirectFileContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
+        var _this = this;
+        var cancelSignal = this._initCanceller.signal;
+        var _a = this._settings, keySystems = _a.keySystems, speed = _a.speed, url = _a.url;
+        (0, clear_element_src_1.default)(mediaElement);
+        // Set the autoplay attribute on the mediaElement.
+        // On Apple devices, the native HLS player needs autoplay to be set
+        // in order to start buffering,which is required for our API's autoplay to work.
+        setAutoplay(mediaElement, this._settings.autoPlay, cancelSignal);
+        var drmInitRef = (0, initialize_content_decryption_1.default)(mediaElement, keySystems, {
+            onError: function (err) { return _this._onFatalError(err); },
+            onWarning: function (err) { return _this.trigger("warning", err); },
+            onBlackListProtectionData: noop_1.default,
+            onKeyIdsCompatibilityUpdate: noop_1.default,
+        }, cancelSignal).statusRef;
+        /** Translate errors coming from the media element into RxPlayer errors. */
+        (0, throw_on_media_error_1.default)(mediaElement, function (error) { return _this._onFatalError(error); }, cancelSignal);
+        /**
+         * Class trying to avoid various stalling situations, emitting "stalled"
+         * events when it cannot, as well as "unstalled" events when it get out of one.
+         */
+        var rebufferingController = new rebuffering_controller_1.default(playbackObserver, null, speed);
+        rebufferingController.addEventListener("stalled", function (evt) {
+            return _this.trigger("stalled", evt);
+        });
+        rebufferingController.addEventListener("unstalled", function () {
+            return _this.trigger("unstalled", null);
+        });
+        rebufferingController.addEventListener("warning", function (err) {
+            return _this.trigger("warning", err);
+        });
+        cancelSignal.register(function (err) {
+            rebufferingController.destroy(err.reason);
+        });
+        rebufferingController.start();
+        drmInitRef.onUpdate(function (evt, stopListeningToDrmUpdates) {
+            if (evt.initializationState.type === "uninitialized") {
+                return; // nothing done yet
+            }
+            stopListeningToDrmUpdates();
+            // Start everything! (Just put the URL in the element's src).
+            log_1.default.info("Init", "Setting URL to HTMLMediaElement", { url: url });
+            mediaElement.src = url;
+            cancelSignal.register(function () {
+                log_1.default.info("Init", "Removing directfile src from media element", {
+                    src: mediaElement.src,
+                });
+                (0, clear_element_src_1.default)(mediaElement);
+            });
+            if (evt.initializationState.type === "awaiting-media-link") {
+                evt.initializationState.value.isMediaLinked.setValue(true);
+                drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
+                    if (newDrmStatus.initializationState.type === "initialized") {
+                        stopListeningToDrmUpdatesAgain();
+                        _this._seekAndPlay(mediaElement, playbackObserver);
+                    }
+                }, { emitCurrentValue: true, clearSignal: cancelSignal });
+            }
+            else {
+                (0, assert_1.default)(evt.initializationState.type === "initialized");
+                _this._seekAndPlay(mediaElement, playbackObserver);
+            }
+        }, { emitCurrentValue: true, clearSignal: cancelSignal });
+    };
+    /**
+     * Update URL this `ContentIntializer` depends on.
+     * @param {Array.<string>|undefined} _urls
+     * @param {boolean} _refreshNow
+     */
+    DirectFileContentInitializer.prototype.updateContentUrls = function (_urls, _refreshNow) {
+        throw new Error("Cannot update content URL of directfile contents");
+    };
+    /**
+     * Stop content and free all resources linked to this `ContentIntializer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    DirectFileContentInitializer.prototype.dispose = function (reason) {
+        this._initCanceller.cancel(reason !== null && reason !== void 0 ? reason : "Directfile Init dispose");
+    };
+    /**
+     * Logic performed when a fatal error was triggered.
+     * @param {*} err - The fatal error in question.
+     */
+    DirectFileContentInitializer.prototype._onFatalError = function (err) {
+        this._initCanceller.cancel("Directfile Init err");
+        this.trigger("error", err);
+    };
+    /**
+     * Perform the initial seek (to begin playback at an initially-calculated
+     * position based on settings) and auto-play if needed when loaded.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    DirectFileContentInitializer.prototype._seekAndPlay = function (mediaElement, playbackObserver) {
+        var _this = this;
+        var cancelSignal = this._initCanceller.signal;
+        var _a = this._settings, autoPlay = _a.autoPlay, startAt = _a.startAt;
+        var initialTime = function () {
+            log_1.default.debug("Init", "Calculating initial time");
+            var initTime = getDirectFileInitialTime(mediaElement, startAt);
+            log_1.default.debug("Init", "Initial time calculated", { initialTime: initTime });
+            return initTime;
+        };
+        (0, initial_seek_and_play_1.default)({
+            mediaElement: mediaElement,
+            playbackObserver: playbackObserver,
+            startTime: initialTime,
+            mustAutoPlay: autoPlay,
+            onWarning: function (err) { return _this.trigger("warning", err); },
+            isDirectfile: true,
+        }, cancelSignal)
+            .autoPlayResult.then(function () {
+            return (0, get_loaded_reference_1.default)(playbackObserver, true, cancelSignal).onUpdate(function (isLoaded, stopListening) {
+                if (isLoaded) {
+                    stopListening();
+                    _this.trigger("loaded", {
+                        getSegmentSinkMetrics: null,
+                        getThumbnailData: function () {
+                            return Promise.reject(new Error("Thumbnail data not available with directfile contents"));
+                        },
+                    });
+                }
+            }, { emitCurrentValue: true, clearSignal: cancelSignal });
+        })
+            .catch(function (err) {
+            if (!cancelSignal.isCancelled()) {
+                _this._onFatalError(err);
+            }
+        });
+    };
+    return DirectFileContentInitializer;
+}(types_1.ContentInitializer));
+exports.default = DirectFileContentInitializer;
+/**
+ * Set autoplay value on the mediaElement.
+ *
+ * @param {HTMLElement} mediaElement - The media element whose `autoplay`
+ * attribute will be modified.
+ * @param {CancellationSignal} cancellationSignal - The signal that, when triggered,
+ * restores the `autoplay` attribute to its original value.
+ */
+function setAutoplay(mediaElement, autoplay, cancellationSignal) {
+    if (!autoplay) {
+        // If autoplay option is set to false, don't touch to `autoplay`
+        // videoElement attribute.
+        return;
+    }
+    var autoplayPreviousValue = mediaElement.autoplay;
+    mediaElement.autoplay = autoplay;
+    cancellationSignal.register(function () {
+        /**
+         * Restore the `autoplay` attribute to its previous value.
+         * This ensures that the media element's state is the same as it was before
+         * calling `RxPlayer.loadVideo` in the application.
+         */
+        mediaElement.autoplay = autoplayPreviousValue;
+    });
+}
+/**
+ * calculate initial time as a position in seconds.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object|undefined} [startAt]
+ * @returns {number}
+ */
+function getDirectFileInitialTime(mediaElement, startAt) {
+    if ((0, is_null_or_undefined_1.default)(startAt)) {
+        return 0;
+    }
+    if (!(0, is_null_or_undefined_1.default)(startAt.position)) {
+        return startAt.position;
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.wallClockTime)) {
+        return startAt.wallClockTime;
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.fromFirstPosition)) {
+        return startAt.fromFirstPosition;
+    }
+    var duration = mediaElement.duration;
+    if (typeof startAt.fromLastPosition === "number") {
+        if (!(0, is_null_or_undefined_1.default)(duration) && isFinite(duration)) {
+            return Math.max(0, duration + startAt.fromLastPosition);
+        }
+        if (mediaElement.seekable.length > 0) {
+            var lastSegmentEnd = mediaElement.seekable.end(mediaElement.seekable.length - 1);
+            if (isFinite(lastSegmentEnd)) {
+                return Math.max(0, lastSegmentEnd + startAt.fromLastPosition);
+            }
+        }
+        log_1.default.warn("Init", "startAt.fromLastPosition set but duration is not known, " +
+            "it may be too soon to seek");
+        return undefined;
+    }
+    else if (typeof startAt.fromLivePosition === "number") {
+        var livePosition = mediaElement.seekable.length > 0 ? mediaElement.seekable.end(0) : duration;
+        if ((0, is_null_or_undefined_1.default)(livePosition)) {
+            log_1.default.warn("Init", "startAt.fromLivePosition set but live position is not known, " +
+                "beginning at 0.");
+            return 0;
+        }
+        return Math.max(0, livePosition + startAt.fromLivePosition);
+    }
+    else if (!(0, is_null_or_undefined_1.default)(startAt.percentage)) {
+        if ((0, is_null_or_undefined_1.default)(duration) || !isFinite(duration)) {
+            log_1.default.warn("Init", "startAt.percentage set but duration is not known, " + "beginning at 0.");
+            return 0;
+        }
+        var percentage = startAt.percentage;
+        if (percentage >= 100) {
+            return duration;
+        }
+        else if (percentage <= 0) {
+            return 0;
+        }
+        var ratio = +percentage / 100;
+        return duration * ratio;
+    }
+    return 0;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+export type { IContentInitializerEvents, IAdaptationChangeEventPayload, IStallingSituation, } from "./types";
+export { ContentInitializer } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/main_thread/init/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EACV,yBAAyB,EACzB,6BAA6B,EAC7B,kBAAkB,GACnB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,20 @@
+"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.ContentInitializer = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "ContentInitializer", { enumerable: true, get: function () { return types_1.ContentInitializer; } });