docs: def massTimeContinuityGroups(arrays, mKey, tKey, mLimit, tLimit):
      """ #TODO docstring
  
      :param arrays: a dictionary containing ``numpy.arrays``, must be sorted
          according to the "mKey" (mass key) value.
      :param mKey: "arrays" key that contains the mass ``numpy.array``
      :param tKey: "arrays" key that contains the time ``numpy.array``
      :param mLimit: maximal mass difference for separating continuity groups
      :param tLimit: maximal time difference for separating continuity groups
  
      :returns: a list containing array positions of continuous groups."""
      arrayPositions = numpy.array(range(listvalues(arrays)[0].size))
  
      finalGroupPositions = list()
      for start, end in continuityGrouping(arrays[mKey], mLimit):
          if start == end:
              finalGroupPositions.append(arrayPositions[start:end+1])
              continue
  
          #Perform time continuity grouping on the mass continuity groups
          preSelectionT = arrays[tKey][start:end+1]
          preSelectionM = arrays[mKey][start:end+1]
          preSelectionPositions = arrayPositions[start:end+1]
          _sort = numpy.argsort(preSelectionT)
          preGroups = continuityGrouping(preSelectionT[_sort], tLimit)
  
          #Perform a second round of mass continuity grouping
          finalGroupPrePos = list()
          for _start, _end in preGroups:
              preGroupPos = sorted(_sort[_start:_end+1])
              secGroups = continuityGrouping(preSelectionM[preGroupPos], mLimit)
              for fStart, fEnd in secGroups:
                  finalGroupPrePos.append(preGroupPos[fStart:fEnd+1])
  
          #Add the final group positions
          for _pos in finalGroupPrePos:
              finalGroupPositions.append(preSelectionPositions[_pos])
  
      return finalGroupPositions