docs: def parse_cookie(header, charset="utf-8", errors="replace", cls=None):
      """Parse a cookie.  Either from a string or WSGI environ.
  
      Per default encoding errors are ignored.  If you want a different behavior
      you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
      :exc:`HTTPUnicodeError` is raised.
  
      .. versionchanged:: 0.5
         This function now returns a :class:`TypeConversionDict` instead of a
         regular dict.  The `cls` parameter was added.
  
      :param header: the header to be used to parse the cookie.  Alternatively
                     this can be a WSGI environment.
      :param charset: the charset for the cookie values.
      :param errors: the error behavior for the charset decoding.
      :param cls: an optional dict class to use.  If this is not specified
                         or `None` the default :class:`TypeConversionDict` is
                         used.
      """
      if isinstance(header, dict):
          header = header.get("HTTP_COOKIE", "")
      elif header is None:
          header = ""
  
      # If the value is an unicode string it's mangled through latin1.  This
      # is done because on PEP 3333 on Python 3 all headers are assumed latin1
      # which however is incorrect for cookies, which are sent in page encoding.
      # As a result we
      if isinstance(header, text_type):
          header = header.encode("latin1", "replace")
  
      if cls is None:
          cls = TypeConversionDict
  
      def _parse_pairs():
          for key, val in _cookie_parse_impl(header):
              key = to_unicode(key, charset, errors, allow_none_charset=True)
              if not key:
                  continue
              val = to_unicode(val, charset, errors, allow_none_charset=True)
              yield try_coerce_native(key), val
  
      return cls(_parse_pairs())