code: def wrap_many(self, *args, strict=False):
          
  
          for arg in args:
              is_elem = arg and isinstance(arg, DOMElement)
              is_elem_iter = (
                  not is_elem and arg and isinstance(arg, Iterable) and isinstance(iter(arg).__next__(), DOMElement)
              )
              if not (is_elem or is_elem_iter):
                  raise WrongArgsError(
                      self,
                      "Argument {} is not DOMElement nor iterable of DOMElements".format(
                          arg
                      ),
                  )
  
          wcopies = []
          failure = []
  
          def wrap_next(tag, idx):
              nonlocal wcopies, failure
              next_copy = self.__copy__()
              try:
                  return next_copy.wrap(tag)
              except TagError:
                  failure.append(idx)
                  return next_copy
  
          for arg_idx, arg in enumerate(args):
              if isinstance(arg, DOMElement):
                  wcopies.append(wrap_next(arg, (arg_idx, -1)))
              else:
                  iter_wcopies = []
                  for iter_idx, t in enumerate(arg):
                      iter_wcopies.append(wrap_next(t, (arg_idx, iter_idx)))
                  wcopies.append(type(arg)(iter_wcopies))
  
          if failure and strict:
              raise TagError(
                  self,
                  "Wrapping in a non empty Tag is forbidden, failed on arguments " +
                  ", ".join(
                      list(
                          map(
                              lambda idx: str(idx[0])
                              if idx[1] == -1
                              else "[{1}] of {0}".format(*idx),
                              failure,
                          )
                      )
                  ),
              )
          return wcopies
docs: Wraps different copies of this element inside all empty tags
          listed in params or param's (non-empty) iterators.
  
          Returns list of copies of this element wrapped inside args
          or None if not succeeded, in the same order and same structure,
          i.e. args = (Div(), (Div())) -> value = (A(...), (A(...)))
  
          If on some args it must raise TagError, it will only if strict is True,
          otherwise it will do nothing with them and return Nones on their positions