Thanks for this!

I would like to have an opinion from @MrDiver, but, instead of making a new function, what I would do is modify the original color_gradient to always return a list of length length_of_output, because it's the most consistent option:

• IMO, if length_of_output=0, then color_gradient should return an empty list [], not one color (as it originally did) nor a list containing a single color (as this PR is currently proposing). A list of length 0 is the most expected and intuitive result for something which asks for something of length_of_output=0.
• According to all the uses of color_gradient around the source code, its returned value is always expected to be a list of colors, because the result is always iterated over immediately after, either via a for loop, a map, or direct indexing.

There are also some small changes I would like to propose regarding color_gradient:

• Handle better the case where there are 0 reference_colors, because it currently crashes with an IndexError.
• Broaden the type of reference_colors from Sequence to Iterable by avoiding the indexing and length calculation of reference_colors.

def color_gradient(
    reference_colors: Iterable[ParsableManimColor],
    length_of_output: int,
) -> list[ManimColor]:
    if length_of_output == 0:
        return []

    parsed_colors = [ManimColor(color) for color in reference_colors]
    # (delete this comment) Now we can get the length of parsed_colors instead of reference_colors!
    num_colors = len(parsed_colors)
    if num_colors == 0:
        raise ValueError("Expected 1 or more reference colors. Got 0 colors.")
    if num_colors == 1:
        return parsed_colors * length_of_output

	rgbs = [color.to_rgb() for color in parsed_colors]

    # (delete this comment) Now comes the rest, but replace len(rgbs) with num_colors
    alphas = np.linspace(0, num_colors - 1), length_of_output)
    floors = alphas.astype("int")
    alphas_mod1 = alphas % 1
    # End edge case
    alphas_mod1[-1] = 1
    floors[-1] = num_colors - 2
    return [
        rgb_to_color((rgbs[i] * (1 - alpha)) + (rgbs[i + 1] * alpha))
        for i, alpha in zip(floors, alphas_mod1)
    ]
    

Finally, there are some small requests I would like to do regarding some changes in the code:

Thanks!