rx-player 3.33.0 → 3.33.1

package/src/core/decrypt/__tests__/__global__/utils.ts

@@ -1,491 +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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable no-restricted-properties */
-
-import {
-  IEmeApiImplementation,
-  IEncryptedEventData,
-} from "../../../../compat/eme";
-import {
-  base64ToBytes,
-  bytesToBase64,
-} from "../../../../utils/base64";
-import EventEmitter from "../../../../utils/event_emitter";
-import flatMap from "../../../../utils/flat_map";
-import {
-  strToUtf8,
-  utf8ToStr,
-} from "../../../../utils/string_parsing";
-import { CancellationSignal } from "../../../../utils/task_canceller";
-
-/** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultKSConfig = [
-  {
-    audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                         { contentType: "audio/webm;codecs=opus" } ],
-    distinctiveIdentifier: "optional" as const,
-    initDataTypes: ["cenc"] as const,
-    persistentState: "optional" as const,
-    sessionTypes: ["temporary"] as const,
-    videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                         { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                         { contentType: "video/webm;codecs=\"vp8\"" } ],
-  },
-  {
-    audioCapabilities: undefined,
-    distinctiveIdentifier: "optional" as const,
-    initDataTypes: ["cenc"] as const,
-    persistentState: "optional" as const,
-    sessionTypes: ["temporary"] as const,
-    videoCapabilities: undefined,
-  },
-];
-
-/**
- * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
- * configuration used by the RxPlayer.
- */
-export const defaultPRRecommendationKSConfig = [
-  {
-    audioCapabilities: [ { robustness: "3000",
-                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                         { robustness: "3000",
-                           contentType: "audio/webm;codecs=opus" },
-                         { robustness: "2000",
-                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                         { robustness: "2000",
-                           contentType: "audio/webm;codecs=opus" } ],
-    distinctiveIdentifier: "optional" as const,
-    initDataTypes: ["cenc"] as const,
-    persistentState: "optional" as const,
-    sessionTypes: ["temporary"] as const,
-    videoCapabilities: [ { robustness: "3000",
-                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                         { robustness: "3000",
-                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                         { robustness: "3000",
-                           contentType: "video/webm;codecs=\"vp8\"" },
-                         { robustness: "2000",
-                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                         { robustness: "2000",
-                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                         { robustness: "2000",
-                           contentType: "video/webm;codecs=\"vp8\"" } ],
-  },
-  {
-    audioCapabilities: undefined,
-    distinctiveIdentifier: "optional" as const,
-    initDataTypes: ["cenc"] as const,
-    persistentState: "optional" as const,
-    sessionTypes: ["temporary"] as const,
-    videoCapabilities: undefined,
-  },
-];
-
-/** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultWidevineConfig = (() => {
-  const ROBUSTNESSES = [ "HW_SECURE_ALL",
-                         "HW_SECURE_DECODE",
-                         "HW_SECURE_CRYPTO",
-                         "SW_SECURE_DECODE",
-                         "SW_SECURE_CRYPTO" ];
-  const videoCapabilities = flatMap(ROBUSTNESSES, robustness => {
-    return [{ contentType: "video/mp4;codecs=\"avc1.4d401e\"",
-              robustness },
-            { contentType: "video/mp4;codecs=\"avc1.42e01e\"",
-              robustness },
-            { contentType: "video/webm;codecs=\"vp8\"",
-              robustness } ];
-  });
-  const audioCapabilities = flatMap(ROBUSTNESSES, robustness => {
-    return [{ contentType: "audio/mp4;codecs=\"mp4a.40.2\"",
-              robustness },
-            { contentType: "audio/webm;codecs=opus",
-              robustness } ];
-  });
-  return [
-    { ...defaultKSConfig[0],  audioCapabilities, videoCapabilities },
-    defaultKSConfig[1],
-  ];
-})();
-
-/**
- * Custom implementation of an EME-compliant MediaKeyStatusMap.
- * @class MediaKeyStatusMapImpl
- */
-export class MediaKeyStatusMapImpl {
-  public get size() : number {
-    return this._map.size;
-  }
-
-  private _map : Map<ArrayBuffer, MediaKeyStatus>;
-  constructor() {
-    this._map = new Map();
-  }
-
-  public get(keyId: BufferSource): MediaKeyStatus | undefined {
-    const keyIdAB = keyId instanceof ArrayBuffer ? keyId :
-                                                   keyId.buffer;
-    return this._map.get(keyIdAB);
-  }
-
-  public has(keyId: BufferSource): boolean {
-    const keyIdAB = keyId instanceof ArrayBuffer ? keyId :
-                                                   keyId.buffer;
-    return this._map.has(keyIdAB);
-  }
-
-  public forEach(
-    callbackfn: (
-      value: MediaKeyStatus,
-      key: BufferSource,
-      parent: MediaKeyStatusMapImpl
-    ) => void,
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    thisArg?: unknown
-  ): void {
-    this._map.forEach((value, key) => callbackfn.bind(thisArg, value, key, this));
-  }
-
-  public _setKeyStatus(keyId : BufferSource, value : MediaKeyStatus | undefined) : void {
-    const keyIdAB = keyId instanceof ArrayBuffer ? keyId :
-                                                   keyId.buffer;
-    if (value === undefined) {
-      this._map.delete(keyIdAB);
-    } else {
-      this._map.set(keyIdAB, value);
-    }
-  }
-}
-
-/**
- * Custom implementation of an EME-compliant MediaKeySession.
- * @class MediaKeySessionImpl
- */
-export class MediaKeySessionImpl extends EventEmitter<Record<string, unknown>> {
-  public readonly closed : Promise<void>;
-  public readonly expiration: number;
-  public readonly keyStatuses : MediaKeyStatusMapImpl;
-  public readonly sessionId: string;
-  public onkeystatuseschange: ((this: MediaKeySessionImpl, ev: Event) => unknown) | null;
-  public onmessage: (
-    (this: MediaKeySessionImpl, ev: MediaKeyMessageEvent) => unknown
-  ) | null;
-
-  private _currentKeyId : number;
-  private _close? : () => void;
-  constructor() {
-    super();
-    this._currentKeyId = 0;
-    this.expiration = Number.MAX_VALUE;
-    this.keyStatuses = new MediaKeyStatusMapImpl();
-
-    this.closed = new Promise((res) => {
-      this._close = res;
-    });
-
-    this.onkeystatuseschange = null;
-    this.onmessage = null;
-    this.sessionId = "";
-  }
-
-  public close() : Promise<void> {
-    if (this._close !== undefined) {
-      this._close();
-    }
-    return Promise.resolve();
-  }
-
-  public generateRequest(initDataType: string, initData: BufferSource) : Promise<void> {
-    const msg = formatFakeChallengeFromInitData(initData, initDataType);
-    setTimeout(() => {
-      const event : MediaKeyMessageEvent =
-        Object.assign(new CustomEvent("message"),
-                      { message: msg.buffer,
-                        messageType: "license-request" as const });
-
-      this.trigger("message", event);
-      if (this.onmessage !== null && this.onmessage !== undefined) {
-        this.onmessage(event);
-      }
-    }, 5);
-    return Promise.resolve();
-  }
-
-  public load(_sessionId: string): Promise<boolean> {
-    throw new Error("Not implemented yet");
-  }
-
-  public remove(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  public update(_response: BufferSource): Promise<void> {
-    this.keyStatuses._setKeyStatus(new Uint8Array([0, 1, 2, this._currentKeyId++]),
-                                   "usable");
-    const event = new CustomEvent("keystatuseschange");
-    setTimeout(() => {
-      this.trigger("keyStatusesChange", event);
-      if (this.onkeystatuseschange !== null && this.onkeystatuseschange !== undefined) {
-        this.onkeystatuseschange(event);
-      }
-    }, 50);
-    return Promise.resolve();
-  }
-}
-
-/**
- * Custom implementation of an EME-compliant MediaKeys.
- * @class MediaKeysImpl
- */
-export class MediaKeysImpl {
-  createSession(_sessionType? : MediaKeySessionType) : MediaKeySessionImpl {
-    return new MediaKeySessionImpl();
-  }
-
-  setServerCertificate(_serverCertificate : BufferSource) : Promise<true> {
-    return Promise.resolve(true);
-  }
-}
-
-/**
- * Custom implementation of an EME-compliant MediaKeySystemAccess.
- * @class MediaKeySystemAccessImpl
- */
-export class MediaKeySystemAccessImpl {
-  public readonly keySystem : string;
-  private readonly _config : MediaKeySystemConfiguration[];
-  constructor(keySystem : string, config : MediaKeySystemConfiguration[]) {
-    this.keySystem = keySystem;
-    this._config = config;
-  }
-  createMediaKeys() : Promise<MediaKeysImpl> {
-    return Promise.resolve(new MediaKeysImpl());
-  }
-  getConfiguration() : MediaKeySystemConfiguration[] {
-    return this._config;
-  }
-}
-
-export function requestMediaKeySystemAccessImpl(
-  keySystem : string,
-  config : MediaKeySystemConfiguration[]
-) : Promise<MediaKeySystemAccessImpl> {
-  return Promise.resolve(new MediaKeySystemAccessImpl(keySystem, config));
-}
-
-class MockedDecryptorEventEmitter extends EventEmitter<{
-  encrypted : { elt : HTMLMediaElement; value : unknown };
-  keymessage : { session : MediaKeySessionImpl; value : unknown };
-  keyerror : { session : MediaKeySessionImpl; value : unknown };
-  keystatuseschange : { session : MediaKeySessionImpl; value : unknown };
-}> {
-  public triggerEncrypted(elt : HTMLMediaElement, value : unknown) {
-    this.trigger("encrypted", { elt, value });
-  }
-  public triggerKeyError(session : MediaKeySessionImpl, value : unknown) {
-    this.trigger("keyerror", { session, value });
-  }
-  public triggerKeyStatusesChange(session : MediaKeySessionImpl, value : unknown) {
-    this.trigger("keystatuseschange", { session, value });
-  }
-  public triggerKeyMessage(session : MediaKeySessionImpl, value : unknown) {
-    this.trigger("keymessage", { session, value });
-  }
-}
-
-/**
- * Mock functions coming from the compat directory.
- */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function mockCompat(exportedFunctions : Record<string, jest.Mock | null> = {}) {
-  const ee = new MockedDecryptorEventEmitter();
-  const onEncrypted = exportedFunctions.onEncrypted ?? jest.fn((
-    elt : HTMLMediaElement,
-    fn : (x : unknown) => void,
-    signal : CancellationSignal
-  ) => {
-    elt.addEventListener("encrypted", fn);
-    signal.register(() => {
-      elt.removeEventListener("encrypted", fn);
-    });
-    ee.addEventListener("encrypted", (evt) => {
-      if (evt.elt === elt) {
-        fn(evt.value);
-      }
-    }, signal);
-  });
-  const mockEvents : Record<string, jest.Mock> = {
-    onKeyMessage: jest.fn((
-      elt : MediaKeySessionImpl,
-      fn : (x : unknown) => void,
-      signal : CancellationSignal
-    ) => {
-      elt.addEventListener("message", fn, signal);
-      ee.addEventListener("keymessage", (evt) => {
-        if (evt.session === elt) {
-          fn(evt.value);
-        }
-      }, signal);
-    }),
-    onKeyError: jest.fn((
-      elt : MediaKeySessionImpl,
-      fn : (x : unknown) => void,
-      signal : CancellationSignal
-    ) => {
-      elt.addEventListener("error", fn, signal);
-      ee.addEventListener("keyerror", (evt) => {
-        if (evt.session === elt) {
-          fn(evt.value);
-        }
-      }, signal);
-    }),
-    onKeyStatusesChange: jest.fn((
-      elt : MediaKeySessionImpl,
-      fn : (x : unknown) => void,
-      signal : CancellationSignal
-    ) => {
-      elt.addEventListener("keystatuseschange", fn, signal);
-      ee.addEventListener("keystatuseschange", (evt) => {
-        if (evt.session === elt) {
-          fn(evt.value);
-        }
-      }, signal);
-    }),
-  };
-
-  const mockRmksa = exportedFunctions.requestMediaKeySystemAccess ??
-                    jest.fn(requestMediaKeySystemAccessImpl);
-  const mockSetMediaKeys = exportedFunctions.setMediaKeys ??
-                           jest.fn(() => Promise.resolve());
-  const mockGenerateKeyRequest =  jest.fn((
-    mks : MediaKeySessionImpl,
-    initializationDataType,
-    initializationData
-  ) => {
-    return mks.generateRequest(initializationDataType,
-                               initializationData);
-  });
-
-  const mockGetInitData = jest.fn((encryptedEvent : IEncryptedEventData) => {
-    return encryptedEvent;
-  });
-
-  jest.mock("../../../../compat", () => (
-    { events: mockEvents,
-      shouldRenewMediaKeySystemAccess: jest.fn(() => false),
-      shouldWaitForEncryptedBeforeAttachment: jest.fn(() => false),
-      canReuseMediaKeys: jest.fn(() => true),
-      ...exportedFunctions }));
-
-  const emeImplementation = {
-    onEncrypted,
-    requestMediaKeySystemAccess: mockRmksa,
-    setMediaKeys: mockSetMediaKeys,
-  } as unknown as IEmeApiImplementation;
-
-  jest.mock("../../../../compat/eme", () => (
-    { __esModule: true as const,
-      default: emeImplementation,
-      getInitData: mockGetInitData,
-      generateKeyRequest: mockGenerateKeyRequest,
-      ...exportedFunctions }));
-
-  return { mockEvents,
-           eventTriggers: {
-             triggerEncrypted(elt : HTMLMediaElement, value : unknown) {
-               ee.triggerEncrypted(elt, value);
-             },
-             triggerKeyMessage(session : MediaKeySessionImpl, value : unknown) {
-               ee.triggerKeyMessage(session, value);
-             },
-             triggerKeyError(session : MediaKeySessionImpl, value : unknown) {
-               ee.triggerKeyError(session, value);
-             },
-             triggerKeyStatusesChange(session : MediaKeySessionImpl, value : unknown) {
-               ee.triggerKeyStatusesChange(session, value);
-             },
-           },
-           mockRequestMediaKeySystemAccess: mockRmksa,
-           mockGetInitData,
-           mockSetMediaKeys,
-           mockGenerateKeyRequest };
-}
-
-/**
- * Check that the ContentDecryptor, when called with those arguments, throws.
- * If that's the case, resolve with the corresponding error.
- * Else, reject.
- * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystemsConfigs
- * @param {Array} keySystemsConfigs
- * @returns {Promise}
- */
-export function testContentDecryptorError(
-  ContentDecryptor : any,
-  mediaElement : HTMLMediaElement,
-  keySystemsConfigs : unknown[]
-) : Promise<unknown> {
-  return new Promise((res, rej) => {
-    const contentDecryptor = new ContentDecryptor(mediaElement, keySystemsConfigs);
-    contentDecryptor.addEventListener("error", (error: any) => {
-      res(error);
-    });
-    setTimeout(() => {
-      rej(new Error("Timeout exceeded"));
-    }, 10);
-  });
-}
-
-/**
- * Does the reverse operation than what `formatFakeChallengeFromInitData` does:
- * Retrieve initialization data from a fake challenge done in our tests
- * @param {Uint8Array} challenge
- * @returns {Object}
- */
-export function extrackInfoFromFakeChallenge(
-  challenge : Uint8Array
-) : { initData : Uint8Array; initDataType : string } {
-  const licenseData = JSON.stringify(utf8ToStr(challenge));
-  const initData = base64ToBytes(licenseData[1]);
-  return { initData, initDataType: licenseData[0] };
-}
-
-/**
- * @param {BufferSource} initData
- * @param {string} initDataType
- * @returns {Uint8Array}
- */
-export function formatFakeChallengeFromInitData(
-  initData : BufferSource,
-  initDataType : string
-) : Uint8Array {
-  const initDataAB = initData instanceof ArrayBuffer ? initData :
-                                                       initData.buffer;
-  const objChallenge = [initDataType, bytesToBase64(new Uint8Array(initDataAB))];
-  return strToUtf8(JSON.stringify(objChallenge));
-}

package/src/core/decrypt/attach_media_keys.ts

@@ -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 eme, {
-  ICustomMediaKeys,
-  ICustomMediaKeySystemAccess,
-  IEmeApiImplementation,
-} from "../../compat/eme";
-import log from "../../log";
-import { IKeySystemOption } from "../../public_types";
-import { CancellationSignal } from "../../utils/task_canceller";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
-
-/**
- * Dispose of the MediaKeys instance attached to the given media element, if
- * one.
- * @param {Object} mediaElement
- * @returns {Promise}
- */
-export function disableMediaKeys(
-  mediaElement : HTMLMediaElement
-): Promise<unknown> {
-  MediaKeysInfosStore.setState(mediaElement, null);
-  return eme.setMediaKeys(mediaElement, null)
-    .then(() => {
-      log.info("DRM: MediaKeys disabled with success");
-    })
-    .catch((err) => {
-      log.error(
-        "DRM: Could not disable MediaKeys",
-        err instanceof Error ? err : "Unknown Error"
-      );
-    });
-}
-
-/**
- * Attach MediaKeys and its associated state to an HTMLMediaElement.
- *
- * /!\ Mutates heavily MediaKeysInfosStore
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} mediaKeysInfos
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-export default async function attachMediaKeys(
-  mediaElement : HTMLMediaElement,
-  { emeImplementation,
-    keySystemOptions,
-    loadedSessionsStore,
-    mediaKeySystemAccess,
-    mediaKeys } : IMediaKeysState,
-  cancelSignal : CancellationSignal
-) : Promise<void> {
-  const previousState = MediaKeysInfosStore.getState(mediaElement);
-  const closeAllSessions = previousState !== null &&
-                           previousState.loadedSessionsStore !== loadedSessionsStore ?
-                             previousState.loadedSessionsStore.closeAllSessions() :
-                             Promise.resolve();
-
-  await closeAllSessions;
-
-  // If this task has been cancelled while we were closing previous sessions,
-  // stop now (and thus avoid setting the new media keys);
-  if (cancelSignal.isCancelled()) {
-    throw cancelSignal.cancellationError;
-  }
-
-  MediaKeysInfosStore.setState(mediaElement, { emeImplementation,
-                                               keySystemOptions,
-                                               mediaKeySystemAccess,
-                                               mediaKeys,
-                                               loadedSessionsStore });
-  if (mediaElement.mediaKeys === mediaKeys) {
-    return ;
-  }
-  log.info("DRM: Attaching MediaKeys to the media element");
-  emeImplementation.setMediaKeys(mediaElement, mediaKeys)
-    .then(() => {
-      log.info("DRM: MediaKeys attached with success");
-    })
-    .catch((err) => {
-      log.error(
-        "DRM: Could not set MediaKeys",
-        err instanceof Error ? err : "Unknown Error"
-      );
-    });
-}
-
-/** MediaKeys and associated state attached to a media element. */
-export interface IMediaKeysState {
-  /** Options set when the MediaKeys has been attached. */
-  keySystemOptions : IKeySystemOption;
-  /** LoadedSessionsStore associated to the MediaKeys instance. */
-  loadedSessionsStore : LoadedSessionsStore;
-  /** The MediaKeySystemAccess allowing to create MediaKeys instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess |
-                        ICustomMediaKeySystemAccess;
-  /** The MediaKeys instance to attach to the media element. */
-  mediaKeys : MediaKeys |
-              ICustomMediaKeys;
-  /**
-   * The chosen EME implementation abstraction linked to `mediaKeys`.
-   * Different EME implementation might for example be used while debugging or
-   * work-arounding EME-linked device issues.
-   */
-  emeImplementation : IEmeApiImplementation;
-}

package/src/core/decrypt/clear_on_stop.ts

@@ -1,47 +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 { shouldUnsetMediaKeys } from "../../compat/";
-import log from "../../log";
-import disposeDecryptionResources from "./dispose_decryption_resources";
-import MediaKeysInfosStore from "./utils/media_keys_infos_store";
-
-/**
- * Clear DRM-related resources that should be cleared when the current content
- * stops its playback.
- * @param {HTMLMediaElement} mediaElement
- * @returns {Promise}
- */
-export default function clearOnStop(
-  mediaElement : HTMLMediaElement
-) : Promise<unknown> {
-  log.info("DRM: Clearing-up DRM session.");
-  if (shouldUnsetMediaKeys()) {
-    log.info("DRM: disposing current MediaKeys.");
-    return disposeDecryptionResources(mediaElement);
-  }
-
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
-  if (currentState !== null &&
-      currentState.keySystemOptions.closeSessionsOnStop === true)
-  {
-    log.info("DRM: closing all current sessions.");
-    return currentState.loadedSessionsStore.closeAllSessions();
-  }
-  log.info("DRM: Nothing to clear. Returning right away. No state =",
-           currentState === null);
-  return Promise.resolve();
-}