docs: def is_able_to_parse_detailed(self, desired_type: Type[Any], desired_ext: str, strict: bool) -> Tuple[bool, bool]:
          """
          Utility method to check if a parser is able to parse a given type, either in
          * strict mode (desired_type must be one of the supported ones, or the parser should be generic)
          * inference mode (non-strict) : desired_type may be a parent class of one the parser is able to produce
  
          :param desired_type: the type of the object that should be parsed,
          :param desired_ext: the file extension that should be parsed
          :param strict: a boolean indicating whether to evaluate in strict mode or not
          :return: a first boolean indicating if there was a match, and a second boolean indicating if that match was
          strict (None if no match)
          """
  
          # (1) first handle the easy joker+joker case
          if desired_ext is JOKER and desired_type is JOKER:
              return True, None
  
          # (2) if ext is not a joker we can quickly check if it is supported
          if desired_ext is not JOKER:
              check_var(desired_ext, var_types=str, var_name='desired_ext')
              if desired_ext not in self.supported_exts:
                  # ** no match on extension - no need to go further
                  return False, None
  
              # (3) if type=joker and ext is supported => easy
              if desired_type is JOKER:
                  # ** only extension match is required - ok.
                  return True, None
  
          # (4) at this point, ext is JOKER OR supported and type is not JOKER. Check type match
          check_var(desired_type, var_types=type, var_name='desired_type_of_output')
          check_var(strict, var_types=bool, var_name='strict')
  
          # -- first call custom checker if provided
          if self.is_able_to_parse_func is not None and not self.is_able_to_parse_func(strict, desired_type):
              return False, None
  
          # -- strict match : either the parser is able to parse Anything, or the type is in the list of supported types
          if self.is_generic() or (desired_type in self.supported_types):
              return True, True  # exact match
  
          # -- non-strict match : if the parser is able to parse a subclass of the desired type, it is ok
          elif (not strict) \
                  and any(issubclass(supported, desired_type) for supported in self.supported_types):
              return True, False  # approx match
  
          # -- no match at all
          else:
              return False, None