*
   * @param {Record<string, ?>} json
   *     JSON Object to unmarshal.
   *
   * @throws {InvalidArgumentError}
   *     When the value of the unhandledPromptBehavior capability is invalid.
   *
   * @returns {UserPromptHandler}
   *
   * @see https://w3c.github.io/webdriver/#dfn-deserialize-as-an-unhandled-prompt-behavior
   */
  static fromJSON(json) {
    let isStringValue = false;
    let value = json;
    if (typeof value === "string") {
      // A single specified prompt behavior or for WebDriver classic.
      value = { [FALLBACK_DEFAULT_PROMPT_TYPE]: value };
      isStringValue = true;
    }

    lazy.assert.object(
      value,
      lazy.pprint`Expected "unhandledPromptBehavior" to be an object, got ${value}`
    );

    const userPromptHandlerCapability = new Map();
    for (let [promptType, handler] of Object.entries(value)) {
      if (!isStringValue) {
        const validPromptTypes = Object.values(PromptTypes);
        lazy.assert.in(
          promptType,
          validPromptTypes,
          lazy.pprint`Expected "promptType" to be one of ${validPromptTypes}, got ${promptType}`
        );
      }

      const knownPromptHandlers = Object.values(PromptHandlers);
      lazy.assert.in(
        handler,
        knownPromptHandlers,
        lazy.pprint`Expected "handler" to be one of ${knownPromptHandlers}, got ${handler}`
      );

      let notify = false;
      switch (handler) {
        case PromptHandlers.AcceptAndNotify:
          handler = PromptHandlers.Accept;
          notify = true;
          break;
        case PromptHandlers.DismissAndNotify:
          handler = PromptHandlers.Dismiss;
          notify = true;
          break;
        case PromptHandlers.Ignore:
          notify = true;
          break;
      }

      const configuration = new PromptHandlerConfiguration(handler, notify);
      userPromptHandlerCapability.set(promptType, configuration);
    }
    const userPromptHandler = new UserPromptHandler();
    userPromptHandler.update(userPromptHandlerCapability);
    return userPromptHandler;
  }

  /**
   * Get the handler for the given prompt type.
   *
   * @param {string} promptType
   *     The prompt type to retrieve the handler for.
   *
   * @returns {PromptHandlerConfiguration}
   *
   * @see https://w3c.github.io/webdriver/#dfn-get-the-prompt-handler
   */
  getPromptHandler(promptType) {
    let handlers;

    if (this.#promptTypeToHandlerMap === null) {
      handlers = new Map();
    } else {
      handlers = this.#promptTypeToHandlerMap;
    }

    if (handlers.has(promptType)) {
      return handlers.get(promptType);
    }

    if (handlers.has(PromptTypes.Default)) {
      return handlers.get(PromptTypes.Default);
    }

    if (promptType === PromptTypes.BeforeUnload) {
      return new PromptHandlerConfiguration(PromptHandlers.Accept, false);
    }

    if (handlers.has(FALLBACK_DEFAULT_PROMPT_TYPE)) {
      return handlers.get(FALLBACK_DEFAULT_PROMPT_TYPE);
    }

    return new PromptHandlerConfiguration(PromptHandlers.Dismiss, true);
  }

  /**
   * Updates the prompt handler configuration for a given requested prompt
   * handler map.
   *
   * @param {Map} requestedPromptHandler
   *     The request prompt handler configuration map.
   *
   * @see https://w3c.github.io/webdriver/#dfn-update-the-user-prompt-handler
   */
  update(requestedPromptHandler) {
    if (this.#promptTypeToHandlerMap === null) {
      this.#promptTypeToHandlerMap = new Map();
    }

    for (const [promptType, handler] of requestedPromptHandler) {
      this.#promptTypeToHandlerMap.set(promptType, handler);
    }
  }

  /**
   * JSON serialization of the user prompt handler object.
   *
   * @returns {Record<string, ?>} json
   *
   * @see https://w3c.github.io/webdriver/#dfn-serialize-the-user-prompt-handler
   */
  toJSON() {
    if (this.#promptTypeToHandlerMap === null) {
      // Fallback to "dismiss and notify" if no handler is set
      return PromptHandlers.DismissAndNotify;
    }

    if (
      this.#promptTypeToHandlerMap.size === 1 &&
      this.#promptTypeToHandlerMap.has(FALLBACK_DEFAULT_PROMPT_TYPE)
    ) {
      return this.#promptTypeToHandlerMap
        .get(FALLBACK_DEFAULT_PROMPT_TYPE)
        .toJSON();
    }

    const serialized = {};
    for (const [key, value] of this.#promptTypeToHandlerMap.entries()) {
      serialized[key] = value.toJSON();
    }

    return serialized;
  }

  toString() {
    return "[object UserPromptHandler]";
  }
}
PK