docs: def bind_to_environ(self, environ, server_name=None, subdomain=None):
          """Like :meth:`bind` but you can pass it an WSGI environment and it
          will fetch the information from that dictionary.  Note that because of
          limitations in the protocol there is no way to get the current
          subdomain and real `server_name` from the environment.  If you don't
          provide it, Werkzeug will use `SERVER_NAME` and `SERVER_PORT` (or
          `HTTP_HOST` if provided) as used `server_name` with disabled subdomain
          feature.
  
          If `subdomain` is `None` but an environment and a server name is
          provided it will calculate the current subdomain automatically.
          Example: `server_name` is ``'example.com'`` and the `SERVER_NAME`
          in the wsgi `environ` is ``'staging.dev.example.com'`` the calculated
          subdomain will be ``'staging.dev'``.
  
          If the object passed as environ has an environ attribute, the value of
          this attribute is used instead.  This allows you to pass request
          objects.  Additionally `PATH_INFO` added as a default of the
          :class:`MapAdapter` so that you don't have to pass the path info to
          the match method.
  
          .. versionchanged:: 0.5
              previously this method accepted a bogus `calculate_subdomain`
              parameter that did not have any effect.  It was removed because
              of that.
  
          .. versionchanged:: 0.8
             This will no longer raise a ValueError when an unexpected server
             name was passed.
  
          :param environ: a WSGI environment.
          :param server_name: an optional server name hint (see above).
          :param subdomain: optionally the current subdomain (see above).
          """
          environ = _get_environ(environ)
  
          wsgi_server_name = get_host(environ).lower()
  
          if server_name is None:
              server_name = wsgi_server_name
          else:
              server_name = server_name.lower()
  
          if subdomain is None and not self.host_matching:
              cur_server_name = wsgi_server_name.split(".")
              real_server_name = server_name.split(".")
              offset = -len(real_server_name)
              if cur_server_name[offset:] != real_server_name:
                  # This can happen even with valid configs if the server was
                  # accesssed directly by IP address under some situations.
                  # Instead of raising an exception like in Werkzeug 0.7 or
                  # earlier we go by an invalid subdomain which will result
                  # in a 404 error on matching.
                  subdomain = "<invalid>"
              else:
                  subdomain = ".".join(filter(None, cur_server_name[:offset]))
  
          def _get_wsgi_string(name):
              val = environ.get(name)
              if val is not None:
                  return wsgi_decoding_dance(val, self.charset)
  
          script_name = _get_wsgi_string("SCRIPT_NAME")
          path_info = _get_wsgi_string("PATH_INFO")
          query_args = _get_wsgi_string("QUERY_STRING")
          return Map.bind(
              self,
              server_name,
              script_name,
              subdomain,
              environ["wsgi.url_scheme"],
              environ["REQUEST_METHOD"],
              path_info,
              query_args=query_args,
          )