repeat: until & consume
I have a chunked format I'm trying to parse, that for some chunks starts the body with multiple words of 0x11111111 for absolute data position alignment.

I started out using `repeat: until` directly in the body chunk type definition, but `repeat: until` also consumes the item breaking the condition, i.e. the word directly after the last 0x11111111.
It would be really useful to either be able to set `consume` (like for `terminator`) or to have a `repeat: while` that only consumes the matching items.

This would be ideal:
```ksy
aligned_chunk_body:
  seq:
    - id: aligment
      type: u4
      repeat: while
      repeat-while: _ == 0x11111111
    - id: real_chunk_field
      type: f4
    - id: more_real_chunk_fields
      type: u4
```

My current solution is as follows, but it makes the types more nested then necessary and more hackish then I would like:

```ksy
  # Helper type to handle chunk body padding
  chunk_padding:
    seq:
      - id: padding
        type: u4
        repeat: until
        repeat-until: _ != 0x11111111
    instances:
        length:
          value: (padding.size - 1) * 4

 aligned_chunk_body_wrapper:
    seq:
      - id: padding
        type: chunk_padding
    instances:
      aligned:
        pos: padding.length
        type: aligned_chunk_body

  aligned_chunk_body:
    seq:
    - id: real_chunk_field
      type: f4
    - id: more_real_chunk_fields
      type: u4
```

The `chunk_padding` type is there since there are multiple chunk bodies that use that alignment, and this way I thought it kept things a little cleaner. I'm sure there are ways to make it less code, my main problem with the current approach is that the "real" chunk bodies are hidden behind instances, which means I need to access them to verify that they parse okay, while in the proposed solution they would be parsed "inline" directly.