anchor.diff:          let lockFileSource = kv.Value.Source
           match dependenciesFile.Groups |> Map.tryFind (fst kv.Key) with
           | None -> kv.Key, (kv.Value.Version, lockFileSource)
  -        | Some group -> 
  +        | Some group ->
               match group.Sources |> List.tryFind (fun s -> s.Url = lockFileSource.Url) with
               | Some s -> kv.Key, (kv.Value.Version, s)
               | None -> kv.Key, (kv.Value.Version, kv.Value.Source))
  
positive.code:                             [RestrictionsChanged]
                          else
                              [SettingsChanged]
                  
              else []
  
          let requirementOk =
  
negative.code:         match dependenciesFile.Groups |> Map.tryFind groupName with
          | None -> Set.empty
          | Some depsGroup ->
              let lockFileGroup = lockFile.Groups |> Map.tryFind groupName
              depsGroup.Packages
              |> Seq.map (fun d ->
                  let name = d.Name
                  name,
                  match lockFileGroup with
                  | None -> [GroupNotFoundInLockFile]
                  | Some group ->
                      match group.TryFind name with
                      | Some lockFilePackage ->
                          let dependenciesFilePackage = { d with Settings = d.Settings + depsGroup.Options.Settings }
                          getChanges groupName transitives
                              { dependenciesFilePackage with Settings = dependenciesFilePackage.Settings + depsGroup.Options.Settings }
                              lockFilePackage
                      | _ -> [PackageNotFoundInLockFile])
              |> Seq.filter (fun (_, changes) -> changes.Length > 0)
              |> Seq.map (fun (p, changes) -> groupName, p, changes)
              |> Set.ofSeq
  
      let modified groupName transitives =
          let directMap =
              match dependenciesFile.Groups |> Map.tryFind groupName with
              | None -> Map.empty
  