Simple non-recursive merge sort implementation in Kotlin

MergeSort.kt

fun <T : Comparable<T>> mergeSort(input: Array<T>) {
    mergeSort(input, naturalOrder())
}

fun <T> mergeSort(input: Array<T>, comparator: Comparator<T>) {
    if (input.size < 2) return
    val tempSpace = input.copyOf()

    for (windowSize in generateSequence(1) { it * 2 }.takeWhile { it < input.size }) {
        for (segment in 0 until input.size / windowSize step 2) {
            val leftStart = segment * windowSize
            val leftEnd = (leftStart + windowSize).coerceAtMost(input.size)
            val rightStart = leftEnd
            val rightEnd = (rightStart + windowSize).coerceAtMost(input.size)
            if (rightStart == rightEnd) break

            var leftIndex = leftStart
            var rightIndex = rightStart
            var resultIndex = 0
            while (leftIndex < leftEnd && rightIndex < rightEnd) {
                val comparisonResult = comparator.compare(input[leftIndex], input[rightIndex])
                when {
                    comparisonResult <= 0 -> tempSpace[resultIndex++] = input[leftIndex++]
                    else -> tempSpace[resultIndex++] = input[rightIndex++]
                }
            }
            while (leftIndex < leftEnd) {
                tempSpace[resultIndex++] = input[leftIndex++]
            }
            while (rightIndex < rightEnd) {
                tempSpace[resultIndex++] = input[rightIndex++]
            }
            tempSpace.copyInto(input, leftStart, endIndex = resultIndex)
        }
    }
}