docs: def align(*objects, **kwargs):
      """align(*objects, join='inner', copy=True, indexes=None,
               exclude=frozenset())
  
      Given any number of Dataset and/or DataArray objects, returns new
      objects with aligned indexes and dimension sizes.
  
      Array from the aligned objects are suitable as input to mathematical
      operators, because along each dimension they have the same index and size.
  
      Missing values (if ``join != 'inner'``) are filled with NaN.
  
      Parameters
      ----------
      *objects : Dataset or DataArray
          Objects to align.
      join : {'outer', 'inner', 'left', 'right', 'exact'}, optional
          Method for joining the indexes of the passed objects along each
          dimension:
  
          - 'outer': use the union of object indexes
          - 'inner': use the intersection of object indexes
          - 'left': use indexes from the first object with each dimension
          - 'right': use indexes from the last object with each dimension
          - 'exact': instead of aligning, raise `ValueError` when indexes to be
            aligned are not equal
      copy : bool, optional
          If ``copy=True``, data in the return values is always copied. If
          ``copy=False`` and reindexing is unnecessary, or can be performed with
          only slice operations, then the output may share memory with the input.
          In either case, new xarray objects are always returned.
      exclude : sequence of str, optional
          Dimensions that must be excluded from alignment
      indexes : dict-like, optional
          Any indexes explicitly provided with the `indexes` argument should be
          used in preference to the aligned indexes.
  
      Returns
      -------
      aligned : same as *objects
          Tuple of objects with aligned coordinates.
  
      Raises
      ------
      ValueError
          If any dimensions without labels on the arguments have different sizes,
          or a different size than the size of the aligned dimension labels.
      """
      join = kwargs.pop('join', 'inner')
      copy = kwargs.pop('copy', True)
      indexes = kwargs.pop('indexes', None)
      exclude = kwargs.pop('exclude', _DEFAULT_EXCLUDE)
      if indexes is None:
          indexes = {}
      if kwargs:
          raise TypeError('align() got unexpected keyword arguments: %s'
                          % list(kwargs))
  
      if not indexes and len(objects) == 1:
          # fast path for the trivial case
          obj, = objects
          return (obj.copy(deep=copy),)
  
      all_indexes = defaultdict(list)
      unlabeled_dim_sizes = defaultdict(set)
      for obj in objects:
          for dim in obj.dims:
              if dim not in exclude:
                  try:
                      index = obj.indexes[dim]
                  except KeyError:
                      unlabeled_dim_sizes[dim].add(obj.sizes[dim])
                  else:
                      all_indexes[dim].append(index)
  
      # We don't reindex over dimensions with all equal indexes for two reasons:
      # - It's faster for the usual case (already aligned objects).
      # - It ensures it's possible to do operations that don't require alignment
      #   on indexes with duplicate values (which cannot be reindexed with
      #   pandas). This is useful, e.g., for overwriting such duplicate indexes.
      joiner = _get_joiner(join)
      joined_indexes = {}
      for dim, matching_indexes in all_indexes.items():
          if dim in indexes:
              index = utils.safe_cast_to_index(indexes[dim])
              if (any(not index.equals(other) for other in matching_indexes) or
                      dim in unlabeled_dim_sizes):
                  joined_indexes[dim] = index
          else:
              if (any(not matching_indexes[0].equals(other)
                      for other in matching_indexes[1:]) or
                      dim in unlabeled_dim_sizes):
                  if join == 'exact':
                      raise ValueError(
                          'indexes along dimension {!r} are not equal'
                          .format(dim))
                  index = joiner(matching_indexes)
                  joined_indexes[dim] = index
              else:
                  index = matching_indexes[0]
  
          if dim in unlabeled_dim_sizes:
              unlabeled_sizes = unlabeled_dim_sizes[dim]
              labeled_size = index.size
              if len(unlabeled_sizes | {labeled_size}) > 1:
                  raise ValueError(
                      'arguments without labels along dimension %r cannot be '
                      'aligned because they have different dimension size(s) %r '
                      'than the size of the aligned dimension labels: %r'
                      % (dim, unlabeled_sizes, labeled_size))
  
      for dim in unlabeled_dim_sizes:
          if dim not in all_indexes:
              sizes = unlabeled_dim_sizes[dim]
              if len(sizes) > 1:
                  raise ValueError(
                      'arguments without labels along dimension %r cannot be '
                      'aligned because they have different dimension sizes: %r'
                      % (dim, sizes))
  
      result = []
      for obj in objects:
          valid_indexers = {k: v for k, v in joined_indexes.items()
                            if k in obj.dims}
          if not valid_indexers:
              # fast path for no reindexing necessary
              new_obj = obj.copy(deep=copy)
          else:
              new_obj = obj.reindex(copy=copy, **valid_indexers)
          new_obj.encoding = obj.encoding
          result.append(new_obj)
  
      return tuple(result)