anchor.diff:                PackageRequirements = 
                   match package with
                   | Some(currentGroup,packageName) when groupName = currentGroup -> 
  -                    lockFile.Groups.[groupName].Resolution
  -                    |> createPackageRequirements [packageName]
  +                    lockFile.Groups
  +                    |> Map.filter (fun g _ -> g = groupName)
  +                    |> Seq.map (fun kv -> kv.Value.Resolution)
  +                    |> Seq.map (createPackageRequirements [packageName])
  +                    |> Seq.concat
  +                    |> List.ofSeq
                   | _ -> [] })
           |> resolve dependenciesFile
   
  -    let selectiveUpdate groupName package =        
  +    let selectiveUpdate (group : LockFileGroup) package =        
           let selectiveResolution : Map<GroupName,Resolved> = 
  -            dependenciesFile.Groups.[groupName].Packages
  +            dependenciesFile.Groups.[group.Name].Packages
               |> List.filter (fun p -> package = p.Name)
               |> Some
               |> resolve dependenciesFile
  
positive.code:                 |> Set.ofSeq
  
              let isDirectDependency package = 
                  dependenciesFile.GetDependenciesInGroup(groupName)
                  |> Map.exists (fun p _ -> p = package)
  
              let isTransitiveDependency package =
  
negative.code: 
          let resolution =    
              let resolvedPackages = 
                  (selectiveResolution |> Map.find group.Name).ResolvedPackages.GetModelOrFail()
                  |> merge group.Resolution
  
              let dependencies = 
                  resolvedPackages
  