rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/main_thread/decrypt/utils/serializable_bytes.d.ts

@@ -1,45 +0,0 @@
-/**
- * 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.
- */
-/** Wrap byte-based data and allow serialization of it into base64. */
-export default class SerializableBytes {
-    /**
-     * The data itself. Named `initData` for legacy reasons (cannot be changed
-     * because it has an impact on saved persistent session information.
-     */
-    initData: Uint8Array;
-    /**
-     * Create a new `SerializableBytes`, wrapping the initialization data
-     * given and allowing serialization into base64.
-     * @param {Uint8Array} initData
-     */
-    constructor(initData: Uint8Array);
-    /**
-     * Convert it to base64.
-     * `toJSON` is specially interpreted by JavaScript engines to be able to rely
-     * on it when calling `JSON.stringify` on it or any of its parent objects:
-     * https://tc39.es/ecma262/#sec-serializejsonproperty
-     * @returns {string}
-     */
-    toJSON(): string;
-    /**
-     * Decode a base64 sequence representing an initialization data back to an
-     * Uint8Array.
-     * @param {string}
-     * @returns {Uint8Array}
-     */
-    static decode(base64: string): Uint8Array;
-}
-//# sourceMappingURL=serializable_bytes.d.ts.map

package/dist/es2017/main_thread/decrypt/utils/serializable_bytes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializable_bytes.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/decrypt/utils/serializable_bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,sEAAsE;AACtE,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC;;;OAGG;IACI,QAAQ,EAAE,UAAU,CAAC;IAE5B;;;;OAIG;gBACS,QAAQ,EAAE,UAAU;IAIhC;;;;;;OAMG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;CAG1C"}

package/dist/es2017/main_thread/decrypt/utils/serializable_bytes.js

@@ -1,46 +0,0 @@
-/**
- * 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 { base64ToBytes, bytesToBase64 } from "../../../utils/base64";
-/** Wrap byte-based data and allow serialization of it into base64. */
-export default class SerializableBytes {
-    /**
-     * Create a new `SerializableBytes`, wrapping the initialization data
-     * given and allowing serialization into base64.
-     * @param {Uint8Array} initData
-     */
-    constructor(initData) {
-        this.initData = initData;
-    }
-    /**
-     * Convert it to base64.
-     * `toJSON` is specially interpreted by JavaScript engines to be able to rely
-     * on it when calling `JSON.stringify` on it or any of its parent objects:
-     * https://tc39.es/ecma262/#sec-serializejsonproperty
-     * @returns {string}
-     */
-    toJSON() {
-        return bytesToBase64(this.initData);
-    }
-    /**
-     * Decode a base64 sequence representing an initialization data back to an
-     * Uint8Array.
-     * @param {string}
-     * @returns {Uint8Array}
-     */
-    static decode(base64) {
-        return base64ToBytes(base64);
-    }
-}

package/dist/es2017/main_thread/decrypt/utils/server_certificate_store.d.ts

@@ -1,65 +0,0 @@
-/**
- * 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 { IMediaKeys } from "../../../compat/browser_compatibility_types";
-/** ServerCertificateStore */
-declare const _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(mediaKeys: IMediaKeys): void;
-    /**
-     * 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(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): void;
-    /**
-     * 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(mediaKeys: IMediaKeys): boolean | undefined;
-    /**
-     * 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(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): boolean;
-};
-export default _default;
-//# sourceMappingURL=server_certificate_store.d.ts.map

package/dist/es2017/main_thread/decrypt/utils/server_certificate_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server_certificate_store.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/decrypt/utils/server_certificate_store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6CAA6C,CAAC;AAqB9E,6BAA6B;;IAE3B;;;;;;;;;;;OAWG;uBACgB,UAAU,GAAG,IAAI;IAIpC;;;;;;;;;;OAUG;mBACY,UAAU,qBAAqB,eAAe,GAAG,YAAY,GAAG,IAAI;IAgBnF;;;;;;;;OAQG;sBACe,UAAU,GAAG,OAAO,GAAG,SAAS;IAWlD;;;;;;;OAOG;mBACY,UAAU,qBAAqB,eAAe,GAAG,YAAY,GAAG,OAAO;;AAxExF,wBAqGE"}

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

@@ -1,121 +0,0 @@
-/**
- * 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 hashBuffer from "../../../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).
- */
-const serverCertificateHashesMap = new WeakMap();
-/** ServerCertificateStore */
-export 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(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(mediaKeys, serverCertificate) {
-        const formattedServerCertificate = serverCertificate instanceof Uint8Array
-            ? serverCertificate
-            : new Uint8Array(serverCertificate instanceof ArrayBuffer
-                ? serverCertificate
-                : serverCertificate.buffer);
-        const hash = hashBuffer(formattedServerCertificate);
-        serverCertificateHashesMap.set(mediaKeys, {
-            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(mediaKeys) {
-        const 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(mediaKeys, serverCertificate) {
-        const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
-        if (serverCertificateHash === undefined || serverCertificateHash === null) {
-            return false;
-        }
-        const { hash: oldHash, serverCertificate: oldServerCertificate } = serverCertificateHash;
-        const newServerCertificate = serverCertificate instanceof Uint8Array
-            ? serverCertificate
-            : new Uint8Array(serverCertificate instanceof ArrayBuffer
-                ? serverCertificate
-                : serverCertificate.buffer);
-        const newHash = hashBuffer(newServerCertificate);
-        if (newHash !== oldHash ||
-            oldServerCertificate.length !== newServerCertificate.length) {
-            return false;
-        }
-        for (let i = 0; i < oldServerCertificate.length; i++) {
-            if (oldServerCertificate[i] !== newServerCertificate[i]) {
-                return false;
-            }
-        }
-        return true;
-    },
-};

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

@@ -1,113 +0,0 @@
-/**
- * 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`.
-     */
-    dispose(): 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/es2017/main_thread/init/directfile_content_initializer.d.ts.map

@@ -1 +0,0 @@
-{"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;;OAEG;IACI,OAAO,IAAI,IAAI;IAItB;;;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/es2017/main_thread/init/directfile_content_initializer.js

@@ -1,264 +0,0 @@
-/**
- * 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 clearElementSrc from "../../compat/clear_element_src";
-import log from "../../log";
-import assert from "../../utils/assert";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import noop from "../../utils/noop";
-import TaskCanceller from "../../utils/task_canceller";
-import { ContentInitializer } from "./types";
-import getLoadedReference from "./utils/get_loaded_reference";
-import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
-import initializeContentDecryption from "./utils/initialize_content_decryption";
-import RebufferingController from "./utils/rebuffering_controller";
-import listenToMediaError from "./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
- */
-export default class DirectFileContentInitializer extends ContentInitializer {
-    /**
-     * Creates a new `DirectFileContentInitializer` linked to the given settings.
-     * @param {Object} settings
-     */
-    constructor(settings) {
-        super();
-        this._settings = settings;
-        this._initCanceller = new TaskCanceller();
-    }
-    /**
-     * "Prepare" content so it can later be played by calling `start`.
-     */
-    prepare() {
-        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.
-     */
-    start(mediaElement, playbackObserver) {
-        const cancelSignal = this._initCanceller.signal;
-        const { keySystems, speed, url } = this._settings;
-        clearElementSrc(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);
-        const { statusRef: drmInitRef } = initializeContentDecryption(mediaElement, keySystems, {
-            onError: (err) => this._onFatalError(err),
-            onWarning: (err) => this.trigger("warning", err),
-            onBlackListProtectionData: noop,
-            onKeyIdsCompatibilityUpdate: noop,
-        }, cancelSignal);
-        /** Translate errors coming from the media element into RxPlayer errors. */
-        listenToMediaError(mediaElement, (error) => 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.
-         */
-        const rebufferingController = new RebufferingController(playbackObserver, null, speed);
-        rebufferingController.addEventListener("stalled", (evt) => this.trigger("stalled", evt));
-        rebufferingController.addEventListener("unstalled", () => this.trigger("unstalled", null));
-        rebufferingController.addEventListener("warning", (err) => this.trigger("warning", err));
-        cancelSignal.register(() => {
-            rebufferingController.destroy();
-        });
-        rebufferingController.start();
-        drmInitRef.onUpdate((evt, stopListeningToDrmUpdates) => {
-            if (evt.initializationState.type === "uninitialized") {
-                return; // nothing done yet
-            }
-            stopListeningToDrmUpdates();
-            // Start everything! (Just put the URL in the element's src).
-            log.info("Init", "Setting URL to HTMLMediaElement", { url });
-            mediaElement.src = url;
-            cancelSignal.register(() => {
-                log.info("Init", "Removing directfile src from media element", {
-                    src: mediaElement.src,
-                });
-                clearElementSrc(mediaElement);
-            });
-            if (evt.initializationState.type === "awaiting-media-link") {
-                evt.initializationState.value.isMediaLinked.setValue(true);
-                drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
-                    if (newDrmStatus.initializationState.type === "initialized") {
-                        stopListeningToDrmUpdatesAgain();
-                        this._seekAndPlay(mediaElement, playbackObserver);
-                    }
-                }, { emitCurrentValue: true, clearSignal: cancelSignal });
-            }
-            else {
-                assert(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
-     */
-    updateContentUrls(_urls, _refreshNow) {
-        throw new Error("Cannot update content URL of directfile contents");
-    }
-    /**
-     * Stop content and free all resources linked to this `ContentIntializer`.
-     */
-    dispose() {
-        this._initCanceller.cancel();
-    }
-    /**
-     * Logic performed when a fatal error was triggered.
-     * @param {*} err - The fatal error in question.
-     */
-    _onFatalError(err) {
-        this._initCanceller.cancel();
-        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
-     */
-    _seekAndPlay(mediaElement, playbackObserver) {
-        const cancelSignal = this._initCanceller.signal;
-        const { autoPlay, startAt } = this._settings;
-        const initialTime = () => {
-            log.debug("Init", "Calculating initial time");
-            const initTime = getDirectFileInitialTime(mediaElement, startAt);
-            log.debug("Init", "Initial time calculated", { initialTime: initTime });
-            return initTime;
-        };
-        performInitialSeekAndPlay({
-            mediaElement,
-            playbackObserver,
-            startTime: initialTime,
-            mustAutoPlay: autoPlay,
-            onWarning: (err) => this.trigger("warning", err),
-            isDirectfile: true,
-        }, cancelSignal)
-            .autoPlayResult.then(() => getLoadedReference(playbackObserver, true, cancelSignal).onUpdate((isLoaded, stopListening) => {
-            if (isLoaded) {
-                stopListening();
-                this.trigger("loaded", {
-                    getSegmentSinkMetrics: null,
-                    getThumbnailData: () => Promise.reject(new Error("Thumbnail data not available with directfile contents")),
-                });
-            }
-        }, { emitCurrentValue: true, clearSignal: cancelSignal }))
-            .catch((err) => {
-            if (!cancelSignal.isCancelled()) {
-                this._onFatalError(err);
-            }
-        });
-    }
-}
-/**
- * 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 function setAutoplay(mediaElement, autoplay, cancellationSignal) {
-    if (!autoplay) {
-        // If autoplay option is set to false, don't touch to `autoplay`
-        // videoElement attribute.
-        return;
-    }
-    const autoplayPreviousValue = mediaElement.autoplay;
-    mediaElement.autoplay = autoplay;
-    cancellationSignal.register(() => {
-        /**
-         * 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 (isNullOrUndefined(startAt)) {
-        return 0;
-    }
-    if (!isNullOrUndefined(startAt.position)) {
-        return startAt.position;
-    }
-    else if (!isNullOrUndefined(startAt.wallClockTime)) {
-        return startAt.wallClockTime;
-    }
-    else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
-        return startAt.fromFirstPosition;
-    }
-    const duration = mediaElement.duration;
-    if (typeof startAt.fromLastPosition === "number") {
-        if (!isNullOrUndefined(duration) && isFinite(duration)) {
-            return Math.max(0, duration + startAt.fromLastPosition);
-        }
-        if (mediaElement.seekable.length > 0) {
-            const lastSegmentEnd = mediaElement.seekable.end(mediaElement.seekable.length - 1);
-            if (isFinite(lastSegmentEnd)) {
-                return Math.max(0, lastSegmentEnd + startAt.fromLastPosition);
-            }
-        }
-        log.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") {
-        const livePosition = mediaElement.seekable.length > 0 ? mediaElement.seekable.end(0) : duration;
-        if (isNullOrUndefined(livePosition)) {
-            log.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 (!isNullOrUndefined(startAt.percentage)) {
-        if (isNullOrUndefined(duration) || !isFinite(duration)) {
-            log.warn("Init", "startAt.percentage set but duration is not known, " + "beginning at 0.");
-            return 0;
-        }
-        const { percentage } = startAt;
-        if (percentage >= 100) {
-            return duration;
-        }
-        else if (percentage <= 0) {
-            return 0;
-        }
-        const ratio = +percentage / 100;
-        return duration * ratio;
-    }
-    return 0;
-}