chunkedReadEndless

fn chunkedReadEndless(
    reader: *Reader,
    w: *Writer,
    limit: std.Io.Limit,
    chunk_len_ptr: *RemainingChunkLen,
) (BodyError || std.Io.Reader.StreamError)!usize {
    const in = reader.in;
    len: switch (chunk_len_ptr.*) {
        .head => {
            var cp: ChunkParser = .init;
            while (true) {
                const i = cp.feed(in.buffered());
                switch (cp.state) {
                    .invalid => return error.HttpChunkInvalid,
                    .data => {
                        in.toss(i);
                        break;
                    },
                    else => {
                        in.toss(i);
                        try in.fillMore();
                        continue;
                    },
                }
            }
            if (cp.chunk_len == 0) return parseTrailers(reader, 0);
            const n = try in.stream(w, limit.min(.limited64(cp.chunk_len)));
            chunk_len_ptr.* = .init(cp.chunk_len + 2 - n);
            return n;
        },
        .n => {
            if ((try in.peekByte()) != '\n') return error.HttpChunkInvalid;
            in.toss(1);
            continue :len .head;
        },
        .rn => {
            const rn = try in.peekArray(2);
            if (rn[0] != '\r' or rn[1] != '\n') return error.HttpChunkInvalid;
            in.toss(2);
            continue :len .head;
        },
        else => |remaining_chunk_len| {
            const n = try in.stream(w, limit.min(.limited64(@intFromEnum(remaining_chunk_len) - 2)));
            chunk_len_ptr.* = .init(@intFromEnum(remaining_chunk_len) - n);
            return n;
        },
    }
}