writeSplatHeaderLimit

pub fn writeSplatHeaderLimit(
    w: *Writer,
    header: []const u8,
    data: []const []const u8,
    splat: usize,
    limit: Limit,
) Error!usize {
    var remaining = @backingInt(limit);
    assert(data.len > 0);
    {
        const copy_len = @min(header.len, remaining);
        if (w.buffer.len - w.end < copy_len) return try writeSplatHeaderLimitFinish(w, header, data, splat, remaining);
        @memcpy(w.buffer[w.end..][0..copy_len], header[0..copy_len]);
        w.end += copy_len;
        remaining -= copy_len;
    }

    remaining_zero: {
        if (remaining == 0) break :remaining_zero;
        for (data[0 .. data.len - 1], 0..) |bytes, i| {
            const copy_len = @min(bytes.len, remaining);
            if (w.buffer.len - w.end < copy_len) {
                const n = try writeSplatHeaderLimitFinish(w, &.{}, data[i..], splat, remaining);
                return @backingInt(limit) - remaining + n;
            }
            @memcpy(w.buffer[w.end..][0..copy_len], bytes[0..copy_len]);
            w.end += copy_len;
            remaining -= copy_len;
        }

        if (remaining == 0) break :remaining_zero;
        const pattern = data[data.len - 1];
        for (0..splat) |i| {
            const copy_len = @min(pattern.len, remaining);
            if (w.buffer.len - w.end < copy_len) {
                const remaining_splat = splat - i;
                const n = try writeSplatHeaderLimitFinish(w, &.{}, data[data.len - 1 ..][0..1], remaining_splat, remaining);
                return @backingInt(limit) - remaining + n;
            }
            @memcpy(w.buffer[w.end..][0..copy_len], pattern[0..copy_len]);
            w.end += copy_len;
            remaining -= copy_len;
        }
    }

    return @backingInt(limit) - remaining;
}