Is it possible to store the current parse index only?
I have some `byte[]` containing various different types and don't necessarily know in which order those types are present in the stream. At least some of those types are encrypted and I need to decrypt them by copying the `byte[]` in whole and decrypt the individual encrypted types in place. If a type is encrypted is indicated using flags and because my overall result is the whole record of individual types unencrypted, I need to switch those flags to show unencrypted state.

The problem I have is to know the position of the bytes to change in the copied `byte[]`. In former versions I was able to calculate it depending on the available types in the stream, but that doesn't work anymore, as I get more and more types with different order than before etc.

Because I encounter the bytes I need during parsing from the front to the end, I thought of simply storing the current parse index in some instance. Yeah, it's not pretty safe, but the best solution I can think of currently. Is something like that supported? I could only think of the following workaround to implement that manually:

    seq:
      - id:   access_nr
        type: u1

      - id:   status
        type: fmt_oms_tpl_status

      - id:   calc_config_field_start_idx
        size: 0
        if:   config_field_start_idx

      - id:   config_field
        type: fmt_oms_tpl_config_field

    instances:
      config_field_start_idx:
        value: _io.pos

`config_field_start_idx` is executed always and only stores the current index, without actually parsing anything, so I don't need to reset things. But is there some easier way to achieve this I'm missing?

Thanks!