fn pub static new(size: Int) -> Block {
  Block(bytes: ByteArray.filled(with: 0, times: size), index: 0)
}

fn pub mut add_padding(size: Int, transform: fn) {
  let pad_to = @bytes.size - size

  if @index >= pad_to {
    @bytes.set(@index := @index + 1, 0x80)

    while @index < @bytes.size { @bytes.set(@index := @index + 1, 0) }

    transform.call
    @index = 0

    while @index < pad_to { @bytes.set(@index := @index + 1, 0) }
  } else {
    @bytes.set(@index := @index + 1, 0x80)

    while @index < pad_to { @bytes.set(@index := @index + 1, 0) }
  }
}

fn pub block_index -> Int {
  @index
}

fn pub get(index: Int) -> Int {
  @bytes.get(index)
}

fn pub read_i32_be(at: Int) -> Int {
  big.read_i32(@bytes, at)
}

fn pub read_i32_le(at: Int) -> Int {
  little.read_i32(@bytes, at)
}

fn pub read_i64_be(at: Int) -> Int {
  big.read_i64(@bytes, at)
}

fn pub mut set(index: Int, value: Int) {
  @bytes.set(index, value)
}

fn pub mut write_bytes(bytes: ref ByteArray, transform: fn) {
  let mut size = bytes.size
  let mut index = 0

  while size > 0 {
    @bytes.set(@index := @index + 1, bytes.get(index))

    if @index == @bytes.size {
      transform.call
      @index = 0
    }

    index += 1
    size -= 1
  }
}

fn pub mut write_size_be(size: Int, at: Int) {
  big.write_i64(size, into: @bytes, at: at)
}

fn pub mut write_size_le(size: Int, at: Int) {
  little.write_i64(size, into: @bytes, at: at)
}