anchor.diff:                  |> Set.ofSeq
   
               let isDirectDependency package = 
  -                dependenciesFile.GetDependenciesInGroup(groupName)
  +                dependenciesFile.GetDependenciesInGroup(group.Name)
                   |> Map.exists (fun p _ -> p = package)
   
               let isTransitiveDependency package =
  
positive.code:             |> Map.filter (fun p _ -> isDirectDependency p || isTransitiveDependency p)
  
          { ResolvedPackages = Resolution.Ok resolution
            ResolvedSourceFiles = lockFile.Groups.[groupName].RemoteFiles }
  
      let resolution =
          match UpdateMode.Mode updateAll package with
  
negative.code:               PackageRequirements = 
                  match package with
                  | Some(currentGroup,packageName) when groupName = currentGroup -> 
                      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 (group : LockFileGroup) package =        
          let selectiveResolution : Map<GroupName,Resolved> = 
              dependenciesFile.Groups.[group.Name].Packages
              |> List.filter (fun p -> package = p.Name)
              |> Some
              |> resolve dependenciesFile
  