docs: def parse_targets(name=None,
                    pkgs=None,
                    sources=None,
                    saltenv='base',
                    normalize=True,
                    **kwargs):
      '''
      Parses the input to pkg.install and returns back the package(s) to be
      installed. Returns a list of packages, as well as a string noting whether
      the packages are to come from a repository or a binary package.
  
      CLI Example:
  
      .. code-block:: bash
  
          salt '*' pkg_resource.parse_targets
      '''
      if '__env__' in kwargs:
          # "env" is not supported; Use "saltenv".
          kwargs.pop('__env__')
  
      if __grains__['os'] == 'MacOS' and sources:
          log.warning('Parameter "sources" ignored on MacOS hosts.')
  
      version = kwargs.get('version')
  
      if pkgs and sources:
          log.error('Only one of "pkgs" and "sources" can be used.')
          return None, None
  
      elif 'advisory_ids' in kwargs:
          if pkgs:
              log.error('Cannot use "advisory_ids" and "pkgs" at the same time')
              return None, None
          elif kwargs['advisory_ids']:
              return kwargs['advisory_ids'], 'advisory'
          else:
              return [name], 'advisory'
  
      elif pkgs:
          if version is not None:
              log.warning('\'version\' argument will be ignored for multiple '
                          'package targets')
          pkgs = _repack_pkgs(pkgs, normalize=normalize)
          if not pkgs:
              return None, None
          else:
              return pkgs, 'repository'
  
      elif sources and __grains__['os'] != 'MacOS':
          if version is not None:
              log.warning('\'version\' argument will be ignored for multiple '
                          'package targets')
          sources = pack_sources(sources, normalize=normalize)
          if not sources:
              return None, None
  
          srcinfo = []
          for pkg_name, pkg_src in six.iteritems(sources):
              if __salt__['config.valid_fileproto'](pkg_src):
                  # Cache package from remote source (salt master, HTTP, FTP) and
                  # append the cached path.
                  srcinfo.append(__salt__['cp.cache_file'](pkg_src, saltenv))
              else:
                  # Package file local to the minion, just append the path to the
                  # package file.
                  if not os.path.isabs(pkg_src):
                      raise SaltInvocationError(
                          'Path {0} for package {1} is either not absolute or '
                          'an invalid protocol'.format(pkg_src, pkg_name)
                      )
                  srcinfo.append(pkg_src)
  
          return srcinfo, 'file'
  
      elif name:
          if normalize:
              _normalize_name = \
                  __salt__.get('pkg.normalize_name', lambda pkgname: pkgname)
              packed = dict([(_normalize_name(x), version) for x in name.split(',')])
          else:
              packed = dict([(x, version) for x in name.split(',')])
          return packed, 'repository'
  
      else:
          log.error('No package sources provided')
          return None, None