rx-player 3.26.2 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/init/initialize_media_source.d.ts

@@ -17,7 +17,7 @@ import { Observable } from "rxjs";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { IABRManagerArguments } from "../abr";
 import { PlaybackObserver } from "../api";
-import { IKeySystemOption } from "../eme";
+import { IKeySystemOption } from "../decrypt";
 import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher, SegmentFetcherCreator } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
 import { IInitialTimeOptions } from "./get_initial_time";
@@ -32,6 +32,8 @@ export interface IInitializeArguments {
     bufferOptions: {
         /** Buffer "goal" at which we stop downloading new segments. */
         wantedBufferAhead: IReadOnlySharedReference<number>;
+        /** Buffer maximum size in kiloBytes at which we stop downloading */
+        maxVideoBufferSize: IReadOnlySharedReference<number>;
         /** Max buffer size after the current position, in seconds (we GC further up). */
         maxBufferAhead: IReadOnlySharedReference<number>;
         /** Max buffer size before the current position, in seconds (we GC further down). */
@@ -67,7 +69,7 @@ export interface IInitializeArguments {
     /** Emit the playback rate (speed) set by the user. */
     speed: IReadOnlySharedReference<number>;
     /** The configured starting position. */
-    startAt?: IInitialTimeOptions;
+    startAt?: IInitialTimeOptions | undefined;
     /** Configuration specific to the text track. */
     textTrackOptions: ITextTrackSegmentBufferOptions;
 }
@@ -83,7 +85,7 @@ export interface IInitializeArguments {
  *
  *   - download the content's Manifest and handle its refresh logic
  *
- *   - Perform EME management if needed
+ *   - Perform decryption if needed
  *
  *   - ask for the choice of the wanted Adaptation through events (e.g. to
  *     choose a language)

package/dist/_esm5.processed/core/init/initialize_media_source.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, EMPTY, exhaustMap, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, mergeScan, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, tap, } from "rxjs";
+import { combineLatest as observableCombineLatest, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, } from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
@@ -22,15 +22,14 @@ import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import objectAssign from "../../utils/object_assign";
 import ABRManager from "../abr";
-import { getCurrentKeySystem, } from "../eme";
-import createEMEManager from "./create_eme_manager";
+import { getCurrentKeySystem, } from "../decrypt";
 import openMediaSource from "./create_media_source";
 import EVENTS from "./events_generators";
 import getInitialTime from "./get_initial_time";
+import linkDrmAndContent from "./link_drm_and_content";
 import createMediaSourceLoader from "./load_on_media_source";
 import manifestUpdateScheduler from "./manifest_update_scheduler";
 import throwOnMediaError from "./throw_on_media_error";
-var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
 /**
  * Begin content playback.
  *
@@ -43,7 +42,7 @@ var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DEL
  *
  *   - download the content's Manifest and handle its refresh logic
  *
- *   - Perform EME management if needed
+ *   - Perform decryption if needed
  *
  *   - ask for the choice of the wanted Adaptation through events (e.g. to
  *     choose a language)
@@ -74,20 +73,21 @@ export default function InitializeOnMediaSource(_a) {
      * The MediaSource will be closed when subscriptions are down to 0.
      */
     var openMediaSource$ = openMediaSource(mediaElement).pipe(shareReplay({ refCount: true }));
-    /** Send content protection data to the `EMEManager`. */
+    /** Send content protection initialization data. */
     var protectedSegments$ = new Subject();
-    /** Create `EMEManager`, an observable which will handle content DRM. */
-    var emeManager$ = createEMEManager(mediaElement, keySystems, protectedSegments$).pipe(
+    /** Initialize decryption capabilities and MediaSource. */
+    var drmEvents$ = linkDrmAndContent(mediaElement, keySystems, protectedSegments$, openMediaSource$)
+        .pipe(
     // Because multiple Observables here depend on this Observable as a source,
     // we prefer deferring Subscription until those Observables are themselves
     // all subscribed to.
-    // This is needed because `emeManager$` might send events synchronously
+    // This is needed because `drmEvents$` might send events synchronously
     // on subscription. In that case, it might communicate those events directly
     // after the first Subscription is done, making the next subscription miss
     // out on those events, even if that second subscription is done
     // synchronously after the first one.
     // By calling `deferSubscriptions`, we ensure that subscription to
-    // `emeManager$` effectively starts after a very short delay, thus
+    // `drmEvents$` effectively starts after a very short delay, thus
     // ensuring that no such race condition can occur.
     deferSubscriptions(), share());
     /**
@@ -95,53 +95,16 @@ export default function InitializeOnMediaSource(_a) {
      * through a throwing Observable.
      */
     var mediaError$ = throwOnMediaError(mediaElement);
-    /**
-     * Wait for the MediaKeys to have been created before opening the MediaSource,
-     * after that second step is done, ask the EMEManager to attach the MediaKeys.
-     * Steps are done in that specific order to avoid compatibility issues.
-     *
-     * This Observable will emit when ready both the MediaSource and useful
-     * DRM-specific information.
-     */
-    var prepareMediaSource$ = emeManager$.pipe(mergeScan(function (acc, evt) {
-        switch (evt.type) {
-            case "eme-disabled":
-            case "attached-media-keys":
-                return observableOf({ isEmeReady: true,
-                    drmSystemId: acc.drmSystemId });
-            case "created-media-keys":
-                var drmSystemId_1 = evt.value.initializationDataSystemId;
-                return openMediaSource$.pipe(mergeMap(function () {
-                    // Now that the MediaSource has been opened and linked to the media
-                    // element we can attach the MediaKeys instance to the latter.
-                    evt.value.canAttachMediaKeys.setValue(true);
-                    // If the `disableMediaKeysAttachmentLock` option has been set to
-                    // `true`, we should not wait until the MediaKeys instance has been
-                    // attached to start loading the content.
-                    // TODO we may want to keep keySystems option knowledge in the EME
-                    // code
-                    var shouldDisableLock = evt.value.options
-                        .disableMediaKeysAttachmentLock === true;
-                    return shouldDisableLock ? observableOf({ isEmeReady: true, drmSystemId: drmSystemId_1 }) :
-                        EMPTY;
-                }), startWith({ isEmeReady: false, drmSystemId: drmSystemId_1 }));
-            default:
-                return EMPTY;
-        }
-    }, { isEmeReady: false, drmSystemId: undefined }), filter(function (emitted) { return emitted.isEmeReady; }), take(1), exhaustMap(function (_a) {
-        var drmSystemId = _a.drmSystemId;
-        return openMediaSource$
-            .pipe(map(function (mediaSource) { return ({ mediaSource: mediaSource, drmSystemId: drmSystemId }); }));
-    }));
+    var mediaSourceReady$ = drmEvents$.pipe(filter(function (evt) {
+        return evt.type === "decryption-ready" || evt.type === "decryption-disabled";
+    }), map(function (e) { return e.value; }), take(1));
     /** Load and play the content asked. */
-    var loadContent$ = observableCombineLatest([manifest$,
-        prepareMediaSource$]).pipe(mergeMap(function (_a) {
-        var manifestEvt = _a[0], mediaSourceInfo = _a[1];
+    var loadContent$ = observableCombineLatest([manifest$, mediaSourceReady$]).pipe(mergeMap(function (_a) {
+        var manifestEvt = _a[0], _b = _a[1], drmSystemId = _b.drmSystemId, initialMediaSource = _b.mediaSource;
         if (manifestEvt.type === "warning") {
             return observableOf(manifestEvt);
         }
         var manifest = manifestEvt.manifest;
-        var initialMediaSource = mediaSourceInfo.mediaSource, drmSystemId = mediaSourceInfo.drmSystemId;
         log.debug("Init: Calculating initial time");
         var initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
         log.debug("Init: Initial time calculated:", initialTime);
@@ -162,22 +125,7 @@ export default function InitializeOnMediaSource(_a) {
         var manifestEvents$ = observableMerge(fromEvent(manifest, "manifestUpdate")
             .pipe(map(function () { return EVENTS.manifestUpdate(); })), fromEvent(manifest, "decipherabilityUpdate")
             .pipe(map(EVENTS.decipherabilityUpdate)));
-        var setUndecipherableRepresentations$ = emeManager$.pipe(tap(function (evt) {
-            if (evt.type === "keys-update") {
-                manifest.updateDeciperabilitiesBasedOnKeyIds(evt.value);
-            }
-            else if (evt.type === "blacklist-protection-data") {
-                log.info("Init: blacklisting Representations based on protection data.");
-                manifest.addUndecipherableProtectionData(evt.value);
-            }
-        }), 
-        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-        // first type parameter as `any` instead of the perfectly fine `unknown`,
-        // leading to linter issues, as it forbids the usage of `any`.
-        // This is why we're disabling the eslint rule.
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-        ignoreElements());
-        return observableMerge(manifestEvents$, manifestUpdate$, setUndecipherableRepresentations$, recursiveLoad$)
+        return observableMerge(manifestEvents$, manifestUpdate$, recursiveLoad$)
             .pipe(startWith(EVENTS.manifestReady(manifest)), finalize(function () { scheduleRefresh$.complete(); }));
         /**
          * Load the content defined by the Manifest in the mediaSource given at the
@@ -199,6 +147,7 @@ export default function InitializeOnMediaSource(_a) {
                             canUseUnsafeMode: true });
                         return null;
                     case "manifest-might-be-out-of-sync":
+                        var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.getCurrent().OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
                         scheduleRefresh$.next({
                             completeRefresh: true,
                             canUseUnsafeMode: false,
@@ -240,5 +189,5 @@ export default function InitializeOnMediaSource(_a) {
             return observableMerge(handleReloads$, currentLoad$);
         }
     }));
-    return observableMerge(loadContent$, mediaError$, emeManager$);
+    return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()));
 }

package/dist/_esm5.processed/core/init/link_drm_and_content.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { Observable } from "rxjs";
+import { IContentProtection, IKeySystemOption } from "../decrypt";
+import { IWarningEvent } from "./types";
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystems
+ * @param {Observable<Object>} contentProtections$
+ * @param {Promise} linkingMedia$
+ * @returns {Observable}
+ */
+export default function linkDrmAndContent<T>(mediaElement: HTMLMediaElement, keySystems: IKeySystemOption[], contentProtections$: Observable<IContentProtection>, linkingMedia$: Observable<T>): Observable<IContentDecryptorInitEvent<T>>;
+export declare type IContentDecryptorInitEvent<T> = IDecryptionDisabledEvent<T> | IDecryptionReadyEvent<T> | IWarningEvent;
+/**
+ * Event emitted after deciding that no decryption logic will be launched for
+ * the current content.
+ */
+export interface IDecryptionDisabledEvent<T> {
+    type: "decryption-disabled";
+    value: {
+        /**
+         * Identify the current DRM's system ID.
+         * Here `undefined` as no decryption capability has been added.
+         */
+        drmSystemId: undefined;
+        /** The value outputed by the `linkingMedia$` Observable. */
+        mediaSource: T;
+    };
+}
+/**
+ * Event emitted when decryption capabilities have started and content can
+ * begin to be pushed on the HTMLMediaElement.
+ */
+export interface IDecryptionReadyEvent<T> {
+    type: "decryption-ready";
+    value: {
+        /**
+         * Identify the current DRM's systemId as an hexadecimal string, so the
+         * RxPlayer may be able to (optionally) only send the corresponding
+         * encryption initialization data.
+         * `undefined` if unknown.
+         */
+        drmSystemId: string | undefined;
+        /** The value outputed by the `linkingMedia$` Observable. */
+        mediaSource: T;
+    };
+}

package/dist/_esm5.processed/core/init/link_drm_and_content.js

@@ -0,0 +1,94 @@
+/**
+ * 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 { map, merge as observableMerge, Observable, } from "rxjs";
+import { events, hasEMEAPIs, } from "../../compat/";
+import { EncryptedMediaError } from "../../errors";
+import features from "../../features";
+import log from "../../log";
+import { ContentDecryptorState, } from "../decrypt";
+var onEncrypted$ = events.onEncrypted$;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystems
+ * @param {Observable<Object>} contentProtections$
+ * @param {Promise} linkingMedia$
+ * @returns {Observable}
+ */
+export default function linkDrmAndContent(mediaElement, keySystems, contentProtections$, linkingMedia$) {
+    var encryptedEvents$ = observableMerge(onEncrypted$(mediaElement), contentProtections$);
+    if (features.ContentDecryptor == null) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Encrypted event but EME feature not activated");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "EME feature not activated.");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    if (keySystems.length === 0) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Ciphered media and no keySystem passed");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "Media is encrypted and no `keySystems` given");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    if (!hasEMEAPIs()) {
+        return observableMerge(encryptedEvents$.pipe(map(function () {
+            log.error("Init: Encrypted event but no EME API available");
+            throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", "Encryption APIs not found.");
+        })), linkingMedia$.pipe(map(function (mediaSource) { return ({
+            type: "decryption-disabled",
+            value: { drmSystemId: undefined, mediaSource: mediaSource },
+        }); })));
+    }
+    log.debug("Init: Creating ContentDecryptor");
+    var ContentDecryptor = features.ContentDecryptor;
+    return new Observable(function (obs) {
+        var contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+        var mediaSub;
+        contentDecryptor.addEventListener("stateChange", function (state) {
+            if (state === ContentDecryptorState.WaitingForAttachment) {
+                contentDecryptor.removeEventListener("stateChange");
+                mediaSub = linkingMedia$.subscribe(function (mediaSource) {
+                    contentDecryptor.addEventListener("stateChange", function (newState) {
+                        if (newState === ContentDecryptorState.ReadyForContent) {
+                            obs.next({ type: "decryption-ready",
+                                value: { drmSystemId: contentDecryptor.systemId, mediaSource: mediaSource } });
+                            contentDecryptor.removeEventListener("stateChange");
+                        }
+                    });
+                    contentDecryptor.attach();
+                });
+            }
+        });
+        contentDecryptor.addEventListener("error", function (e) {
+            obs.error(e);
+        });
+        contentDecryptor.addEventListener("warning", function (w) {
+            obs.next({ type: "warning", value: w });
+        });
+        var protectionDataSub = contentProtections$.subscribe(function (data) {
+            contentDecryptor.onInitializationData(data);
+        });
+        return function () {
+            protectionDataSub.unsubscribe();
+            mediaSub === null || mediaSub === void 0 ? void 0 : mediaSub.unsubscribe();
+            contentDecryptor.dispose();
+        };
+    });
+}

package/dist/_esm5.processed/core/init/manifest_update_scheduler.d.ts

@@ -24,9 +24,9 @@ export interface IManifestUpdateSchedulerArguments {
     /** Information about the initial load of the manifest */
     initialManifest: {
         manifest: Manifest;
-        sendingTime?: number;
-        receivedTime?: number;
-        parsingTime?: number;
+        sendingTime?: number | undefined;
+        receivedTime?: number | undefined;
+        parsingTime?: number | undefined;
     };
     /** Minimum interval to keep between Manifest updates */
     minimumManifestUpdateInterval: number;
@@ -47,7 +47,7 @@ export interface IManifestRefreshSchedulerEvent {
      * Optional wanted refresh delay, which is the minimum time you want to wait
      * before updating the Manifest
      */
-    delay?: number;
+    delay?: number | undefined;
     /**
      * Whether the parsing can be done in the more efficient "unsafeMode".
      * This mode is extremely fast but can lead to de-synchronisation with the

package/dist/_esm5.processed/core/init/manifest_update_scheduler.js

@@ -17,7 +17,6 @@ import { defer as observableDefer, EMPTY, from as observableFrom, map, merge as
 import config from "../../config";
 import log from "../../log";
 import throttle from "../../utils/rx-throttle";
-var FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY = config.FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE = config.MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE = config.MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE;
 /**
  * Refresh the Manifest at the right time.
  * @param {Object} manifestUpdateSchedulerArguments
@@ -56,6 +55,7 @@ export default function manifestUpdateScheduler(_a) {
         var totalUpdateTime = parsingTime !== undefined ?
             parsingTime + (updatingTime !== null && updatingTime !== void 0 ? updatingTime : 0) :
             undefined;
+        var _b = config.getCurrent(), MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE = _b.MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE, MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE = _b.MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE;
         /**
          * "unsafeMode" is a mode where we unlock advanced Manifest parsing
          * optimizations with the added risk to lose some information.
@@ -194,6 +194,7 @@ export default function manifestUpdateScheduler(_a) {
                     var message = e instanceof Error ? e.message :
                         "unknown error";
                     log.warn("MUS: Attempt to update Manifest failed: ".concat(message), "Re-downloading the Manifest fully");
+                    var FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY = config.getCurrent().FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY;
                     return startManualRefreshTimer(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, minimumManifestUpdateInterval, newSendingTime)
                         .pipe(mergeMap(function () {
                         return refreshManifest({ completeRefresh: true, unsafeMode: false });

package/dist/_esm5.processed/core/init/stall_avoider.js

@@ -20,7 +20,6 @@ import { MediaError } from "../../errors";
 import log from "../../log";
 import { getNextRangeGap } from "../../utils/ranges";
 import EVENTS from "../stream/events_generators";
-var BUFFER_DISCONTINUITY_THRESHOLD = config.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = config.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = config.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = config.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = config.UNFREEZING_DELTA_POSITION;
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
@@ -106,6 +105,7 @@ export default function StallAvoider(playbackObserver, manifest, lockedStream$,
     var stall$ = playbackObserver.observe(true).pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
         var observation = _a[0], discontinuitiesStore = _a[1];
         var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        var _b = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
         if (freezing !== null) {
             var now = performance.now();
             var referenceTimestamp = prevFreezingState === null ?

package/dist/_esm5.processed/core/init/stream_events_emitter/are_same_stream_events.d.ts

@@ -28,12 +28,12 @@
  * @returns {Boolean}
  */
 declare function areSameStreamEvents(evt1: {
-    id?: string;
+    id?: string | undefined;
     start: number;
-    end?: number;
+    end?: number | undefined;
 }, evt2: {
-    id?: string;
+    id?: string | undefined;
     start: number;
-    end?: number;
+    end?: number | undefined;
 }): boolean;
 export default areSameStreamEvents;

package/dist/_esm5.processed/core/init/stream_events_emitter/stream_events_emitter.js

@@ -17,7 +17,6 @@ import { combineLatest as observableCombineLatest, concat as observableConcat, d
 import config from "../../../config";
 import { fromEvent } from "../../../utils/event_emitter";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
-var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.STREAM_EVENT_EMITTER_POLL_INTERVAL;
 /**
  * Tells if a stream event has a duration
  * @param {Object} evt
@@ -109,6 +108,7 @@ function streamEventsEmitter(manifest, mediaElement, observation$) {
         if (!hasEvents) {
             return EMPTY;
         }
+        var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.getCurrent().STREAM_EVENT_EMITTER_POLL_INTERVAL;
         return observableCombineLatest([
             interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
             observation$,

package/dist/_esm5.processed/core/init/stream_events_emitter/types.d.ts

@@ -22,14 +22,14 @@ export interface IStreamEventData {
     };
 }
 export interface IStreamEventPayload {
-    id?: string;
+    id?: string | undefined;
     start: number;
     end: number;
     data: IStreamEventData;
     publicEvent: IPublicStreamEvent;
 }
 export interface INonFiniteStreamEventPayload {
-    id?: string;
+    id?: string | undefined;
     start: number;
     data: IStreamEventData;
     publicEvent: IPublicNonFiniteStreamEvent;

package/dist/_esm5.processed/core/init/types.d.ts

@@ -15,10 +15,8 @@
  */
 import { ICustomError } from "../../errors";
 import Manifest, { Adaptation, Period, Representation } from "../../manifest";
-import { IAttachedMediaKeysEvent, IBlacklistProtectionDataEvent, ICreatedMediaKeysEvent, IEncryptedEvent, IInitDataIgnoredEvent, IKeysUpdateEvent, INoUpdateEvent, ISessionMessageEvent, ISessionUpdatedEvent } from "../eme";
 import SegmentBuffersStore from "../segment_buffers";
 import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IInbandEventsEvent, INeedsBufferFlushEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh } from "../stream";
-import { IEMEDisabledEvent } from "./create_eme_manager";
 import { IStreamEventEvent, IStreamEventSkipEvent } from "./stream_events_emitter";
 /** Event sent after the Manifest has been loaded and parsed for the first time. */
 export interface IManifestReadyEvent {
@@ -91,6 +89,6 @@ export { IRepresentationChangeEvent };
 /** Events emitted by a `MediaSourceLoader`. */
 export declare type IMediaSourceLoaderEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | INeedsMediaSourceReload | INeedsBufferFlushEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | INeedsDecipherabilityFlush | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IEncryptionDataEncounteredEvent | IStreamManifestMightBeOutOfSync | IStreamNeedsManifestRefresh | IInbandEventsEvent;
 /** Every events emitted by the `Init` module. */
-export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | IDecipherabilityUpdateEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
+export declare type IInitEvent = IManifestReadyEvent | IManifestUpdateEvent | IReloadingMediaSourceEvent | IDecipherabilityUpdateEvent | IWarningEvent | IStalledEvent | IUnstalledEvent | ILoadedEvent | IStreamEventEvent | IStreamEventSkipEvent | IActivePeriodChangedEvent | IPeriodStreamClearedEvent | ICompletedStreamEvent | IPeriodStreamReadyEvent | IAdaptationChangeEvent | IBitrateEstimationChangeEvent | IRepresentationChangeEvent | IStreamEventAddedSegment<unknown> | IInbandEventsEvent;
 /** Events emitted by the `Init` module for directfile contents. */
-export declare type IDirectfileEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent | IEMEDisabledEvent | IEncryptedEvent | ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | ISessionMessageEvent | IKeysUpdateEvent | INoUpdateEvent | ISessionUpdatedEvent | IBlacklistProtectionDataEvent;
+export declare type IDirectfileEvent = IStalledEvent | IUnstalledEvent | ILoadedEvent | IWarningEvent;

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -39,7 +39,6 @@ import { toUint8Array } from "../../../../utils/byte_parsing";
 import hashBuffer from "../../../../utils/hash_buffer";
 import objectAssign from "../../../../utils/object_assign";
 import { SegmentBuffer, SegmentBufferOperation, } from "../types";
-var SOURCE_BUFFER_FLUSHING_INTERVAL = config.SOURCE_BUFFER_FLUSHING_INTERVAL;
 /**
  * Allows to push and remove new segments to a SourceBuffer in a FIFO queue (not
  * doing so can lead to browser Errors) while keeping an inventory of what has
@@ -69,6 +68,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         _this._pendingTask = null;
         _this._lastInitSegment = null;
         _this.codec = codec;
+        var SOURCE_BUFFER_FLUSHING_INTERVAL = config.getCurrent().SOURCE_BUFFER_FLUSHING_INTERVAL;
         // Some browsers (happened with firefox 66) sometimes "forget" to send us
         // `update` or `updateend` events.
         // In that case, we're completely unable to continue the queue here and

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.d.ts

@@ -124,9 +124,9 @@ export interface INativeTextTracksBufferSegmentData {
      * This is mostly needed for "sami" subtitles, to know which cues can / should
      * be parsed.
      */
-    language?: string;
+    language?: string | undefined;
     /** start time from which the segment apply, in seconds. */
-    start?: number;
+    start?: number | undefined;
     /** end time until which the segment apply, in seconds. */
-    end?: number;
+    end?: number | undefined;
 }

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -38,7 +38,6 @@ import parseTextTrackToElements from "./parsers";
 import TextTrackCuesStore from "./text_track_cues_store";
 import updateProportionalElements from "./update_proportional_elements";
 var onEnded$ = events.onEnded$, onSeeked$ = events.onSeeked$, onSeeking$ = events.onSeeking$;
-var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL, TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.TEXT_TRACK_SIZE_CHECKS_INTERVAL;
 /**
  * Generate the interval at which TextTrack HTML Cues should be refreshed.
  * @param {HTMLMediaElement} videoElement
@@ -48,6 +47,7 @@ function generateRefreshInterval(videoElement) {
     var seeking$ = onSeeking$(videoElement);
     var seeked$ = onSeeked$(videoElement);
     var ended$ = onEnded$(videoElement);
+    var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
     var manualRefresh$ = observableMerge(seeked$, ended$);
     var autoRefresh$ = observableInterval(MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL)
         .pipe(startWith(null));
@@ -113,6 +113,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
                 _this._disableCurrentCues();
                 return;
             }
+            var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
             // to spread the time error, we divide the regular chosen interval.
             var time = Math.max(_this._videoElement.currentTime +
                 (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2, 0);
@@ -315,6 +316,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var proportionalCues = this._currentCues
             .filter(function (cue) { return cue.resolution !== null; });
         if (proportionalCues.length > 0) {
+            var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
             // update propertionally-sized elements periodically
             onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL)
                 .pipe(takeUntil(this._clearSizeUpdates$), takeUntil(this._destroy$))