anchor.diff:      | UpdateAll
   
   /// Resolves all direct and transitive dependencies
  -let Resolve(groupName:GroupName, sources, getVersionsF, getPackageDetailsF, strategy, globalFrameworkRestrictions, (rootDependencies:PackageRequirement Set), updateMode : UpdateMode) =
  +let Resolve(groupName:GroupName, sources, getVersionsF, getPackageDetailsF, globalStrategyForTransitives, globalFrameworkRestrictions, (rootDependencies:PackageRequirement Set), updateMode : UpdateMode) =
       tracefn "Resolving packages for group %O:" groupName
       let lastConflictReported = ref DateTime.Now
   
  
positive.code:        
          match Map.tryFind currentRequirement.Name filteredVersions with
          | None ->
              let currentRequirements =
                  openRequirements
                  |> Set.filter (fun r -> currentRequirement.Name = r.Name)
  
              let resolverStrategy =
                  let combined =
                      (currentRequirements
                      |> List.ofSeq
                      |> List.filter (fun x -> x.Depth > 0)
                      |> List.sortBy (fun x -> x.Depth, x.ResolverStrategy <> strategy, x.ResolverStrategy <> Some ResolverStrategy.Max)
                      |> List.map (fun x -> x.ResolverStrategy)
                      |> List.fold (++) None)
                      ++ strategy
                      |> function | Some s -> s | None -> ResolverStrategy.Max
  
                  match updateMode with
                  | Install
                  | UpdateAll
                  | UpdateGroup _ ->
                      match currentRequirement.Parent.IsRootRequirement(), Set.count currentRequirements with
                      | true, 1 -> ResolverStrategy.Max
                      | _ -> combined
                  | UpdateFiltered (g, f) ->
                      match groupName = g && f.Match currentRequirement.Name with
                      | true -> ResolverStrategy.Max
                      | false -> combined
  
              // we didn't select a version yet so all versions are possible
              let isInRange mapF (ver,_) =
                  currentRequirements
                  |> Seq.forall (fun r -> (mapF r).VersionRequirement.IsInRange ver)
  
              let getSingleVersion v =
  
negative.code:         |> not)
      |> Set.union rest
  
  
  type Resolved = {
      ResolvedPackages : Resolution
      ResolvedSourceFiles : ModuleResolver.ResolvedSourceFile list }
  
  let getResolverStrategy globalStrategyForTransitives (allRequirementsOfCurrentPackage:Set<PackageRequirement>) (currentRequirement:PackageRequirement) =
      if currentRequirement.Parent.IsRootRequirement() && Set.count allRequirementsOfCurrentPackage = 1 then
          ResolverStrategy.Max
      else
          let combined =
              (allRequirementsOfCurrentPackage
                  |> List.ofSeq
                  |> List.filter (fun x -> x.Depth > 0)
                  |> List.sortBy (fun x -> x.Depth, x.ResolverStrategy <> globalStrategyForTransitives, x.ResolverStrategy <> Some ResolverStrategy.Max)
                  |> List.map (fun x -> x.ResolverStrategy)
                  |> List.fold (++) None)
                  ++ globalStrategyForTransitives
                      
          defaultArg combined ResolverStrategy.Max
  
  type UpdateMode =
      | UpdateGroup of GroupName
  