module cbor

import math

// DecodeOpts tunes the decoder. Defaults are conservative: UTF-8 is
// validated, depth is capped to fend off stack-blow-up payloads, and
// duplicate map keys are tolerated (callers that need detection turn
// `deny_duplicate_keys` on).
pub struct DecodeOpts {
pub:
	max_depth            int = 256
	max_stream_bytes     int // 0 = unbounded for stream readers
	validate_utf8        bool = true
	deny_unknown_fields  bool // struct decode rejects unmapped keys
	deny_duplicate_keys  bool // Map decode rejects repeated keys
	allow_trailing_bytes bool // accept extra bytes after the top-level item
}

// Kind classifies the next item without consuming it. Useful to branch
// before committing to a typed read.
pub enum Kind {
	unsigned   // major type 0
	negative   // major type 1
	bytes      // major type 2 (definite or indefinite)
	text       // major type 3 (definite or indefinite)
	array_val  // major type 4 (definite or indefinite)
	map_val    // major type 5 (definite or indefinite)
	tag_val    // major type 6
	bool_val   // simple 20/21
	null_val   // simple 22
	undefined  // simple 23
	simple_val // other simple values
	float_val  // half/single/double
	break_code // 0xff outside a definite header
}

// Unpacker walks a CBOR byte slice. Operates non-allocating where
// possible; strings and bytes returned by `unpack_text` / `unpack_bytes`
// always own their storage so they outlive the input buffer.
pub struct Unpacker {
pub mut:
	data []u8
	pos  int
	opts DecodeOpts
}

// new_unpacker constructs an Unpacker over the given byte slice.
pub fn new_unpacker(data []u8, opts DecodeOpts) Unpacker {
	cap := if opts.max_depth > 0 {
		opts
	} else {
		DecodeOpts{
			...opts
			max_depth: 256
		}
	}
	return Unpacker{
		data: data
		pos:  0
		opts: cap
	}
}

// remaining returns the number of unread bytes.
@[inline]
pub fn (u &Unpacker) remaining() int {
	return u.data.len - u.pos
}

// done reports whether the unpacker has consumed every byte.
@[inline]
pub fn (u &Unpacker) done() bool {
	return u.pos >= u.data.len
}

// --------------------------------------------------------------------
// Low-level byte reads
// --------------------------------------------------------------------

@[direct_array_access; inline]
fn (mut u Unpacker) read_byte() !u8 {
	if u.pos >= u.data.len {
		return eof_at(u.pos)
	}
	b := u.data[u.pos]
	u.pos++
	return b
}

@[direct_array_access; inline]
fn (u &Unpacker) peek_byte() !u8 {
	if u.pos >= u.data.len {
		return eof_at(u.pos)
	}
	return u.data[u.pos]
}

@[direct_array_access; inline]
fn (mut u Unpacker) read_be_u16() !u16 {
	if u.pos + 2 > u.data.len {
		return eof_needing(u.pos, 2, u.data.len - u.pos)
	}
	v := u16(u.data[u.pos]) << 8 | u16(u.data[u.pos + 1])
	u.pos += 2
	return v
}

@[direct_array_access; inline]
fn (mut u Unpacker) read_be_u32() !u32 {
	if u.pos + 4 > u.data.len {
		return eof_needing(u.pos, 4, u.data.len - u.pos)
	}
	v := u32(u.data[u.pos]) << 24 | u32(u.data[u.pos + 1]) << 16 | u32(u.data[u.pos + 2]) << 8 | u32(u.data[
		u.pos + 3])
	u.pos += 4
	return v
}

@[direct_array_access; inline]
fn (mut u Unpacker) read_be_u64() !u64 {
	if u.pos + 8 > u.data.len {
		return eof_needing(u.pos, 8, u.data.len - u.pos)
	}
	v := u64(u.data[u.pos]) << 56 | u64(u.data[u.pos + 1]) << 48 | u64(u.data[u.pos + 2]) << 40 | u64(u.data[
		u.pos + 3]) << 32 | u64(u.data[u.pos + 4]) << 24 | u64(u.data[u.pos + 5]) << 16 | u64(u.data[
		u.pos + 6]) << 8 | u64(u.data[u.pos + 7])
	u.pos += 8
	return v
}

// read_arg reads the additional-info argument for the given initial
// byte. Returns -1 to signal indefinite-length (info == 31) for major
// types that allow it; the caller decides whether that's legal.
fn (mut u Unpacker) read_arg(info u8) !u64 {
	match info {
		0...23 { return u64(info) }
		24 { return u64(u.read_byte()!) }
		25 { return u64(u.read_be_u16()!) }
		26 { return u64(u.read_be_u32()!) }
		27 { return u.read_be_u64()! }
		else { return malformed(u.pos - 1, 'reserved additional info ${info}') }
	}
}

// --------------------------------------------------------------------
// Public peek
// --------------------------------------------------------------------

// peek_kind classifies the next item without consuming any input.
pub fn (u &Unpacker) peek_kind() !Kind {
	if u.pos >= u.data.len {
		return eof_at(u.pos)
	}
	b := u.data[u.pos]
	major := b >> 5
	info := b & 0x1f
	match major {
		0 {
			return .unsigned
		}
		1 {
			return .negative
		}
		2 {
			return .bytes
		}
		3 {
			return .text
		}
		4 {
			return .array_val
		}
		5 {
			return .map_val
		}
		6 {
			return .tag_val
		}
		else {
			match info {
				20, 21 { return .bool_val }
				22 { return .null_val }
				23 { return .undefined }
				25, 26, 27 { return .float_val }
				31 { return .break_code }
				else { return .simple_val }
			}
		}
	}
}

// --------------------------------------------------------------------
// High-level typed reads
// --------------------------------------------------------------------

// unpack_uint reads a non-negative integer (major type 0). Errors on
// negatives, floats, or other major types. Position is rolled back on
// any error so callers can branch on `peek_kind` and try a different
// read (same convention as `unpack_bool` / `unpack_text`).
pub fn (mut u Unpacker) unpack_uint() !u64 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 0 {
		u.pos = start
		return type_mismatch(start, 'unsigned', b)
	}
	return u.read_arg(b & 0x1f) or {
		u.pos = start
		return err
	}
}

// unpack_int reads any CBOR integer (major type 0 or 1) into i64. Errors
// when the magnitude exceeds i64 range; use `unpack_int_full` to pull
// values as u64 with a separate sign flag.
pub fn (mut u Unpacker) unpack_int() !i64 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	arg := u.read_arg(b & 0x1f)!
	if major == 0 {
		if arg > u64(max_i64) {
			u.pos = start
			return int_range(start, 'i64', arg.str())
		}
		return i64(arg)
	}
	if major == 1 {
		// Represented integer = -1 - arg.
		if arg > u64(max_i64) {
			u.pos = start
			return int_range(start, 'i64', '-1 - ${arg}')
		}
		return -1 - i64(arg)
	}
	u.pos = start
	return type_mismatch(start, 'integer', b)
}

// unpack_int_full returns (negative, magnitude). For unsigned values
// negative=false and magnitude is the raw u64. For negative values
// negative=true and magnitude is the encoded argument (the integer
// itself is `-1 - magnitude`).
pub fn (mut u Unpacker) unpack_int_full() !(bool, u64) {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	arg := u.read_arg(b & 0x1f)!
	if major == 0 {
		return false, arg
	}
	if major == 1 {
		return true, arg
	}
	u.pos = start
	return type_mismatch(start, 'integer', b)
}

// unpack_bool reads a CBOR boolean (simple 20/21). Position is rolled
// back on a type mismatch so callers can branch on `peek_kind` and try
// a different read.
pub fn (mut u Unpacker) unpack_bool() !bool {
	start := u.pos
	b := u.read_byte()!
	if b == 0xf4 {
		return false
	}
	if b == 0xf5 {
		return true
	}
	u.pos = start
	return type_mismatch(start, 'bool', b)
}

// unpack_null consumes a CBOR null (0xf6) or errors with type mismatch.
// Position is rolled back on mismatch (same convention as unpack_bool).
pub fn (mut u Unpacker) unpack_null() ! {
	start := u.pos
	b := u.read_byte()!
	if b != 0xf6 {
		u.pos = start
		return type_mismatch(start, 'null', b)
	}
}

// unpack_float reads a CBOR float of any width (half/single/double) and
// returns it as f64.
pub fn (mut u Unpacker) unpack_float() !f64 {
	start := u.pos
	b := u.read_byte()!
	match b {
		0xf9 {
			h := u.read_be_u16()!
			return half_to_f64(h)
		}
		0xfa {
			bits := u.read_be_u32()!
			return f64(math.f32_from_bits(bits))
		}
		0xfb {
			bits := u.read_be_u64()!
			return math.f64_from_bits(bits)
		}
		else {
			u.pos = start
			return type_mismatch(start, 'float', b)
		}
	}
}

// unpack_simple reads a simple value (0..255). Bool/null/undefined are
// also simple values; this method returns the raw u8.
pub fn (mut u Unpacker) unpack_simple() !u8 {
	start := u.pos
	b := u.read_byte()!
	if b >= 0xe0 && b <= 0xf3 {
		return b & 0x1f
	}
	match b {
		0xf4 {
			return 20
		}
		0xf5 {
			return 21
		}
		0xf6 {
			return 22
		}
		0xf7 {
			return 23
		}
		0xf8 {
			v := u.read_byte()!
			if v < 32 {
				u.pos = start
				return malformed(start, 'simple value < 32 must use 1-byte form')
			}
			return v
		}
		else {
			u.pos = start
			return type_mismatch(start, 'simple', b)
		}
	}
}

// unpack_text reads a definite or indefinite-length text string. The
// returned string owns its bytes (it's a clone of the input slice).
// UTF-8 validation runs unless `DecodeOpts.validate_utf8` is false.
pub fn (mut u Unpacker) unpack_text() !string {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 3 {
		u.pos = start
		return type_mismatch(start, 'text', b)
	}
	info := b & 0x1f
	if info == 31 {
		return u.read_indef_text()!
	}
	size := u.read_arg(info)!
	return u.read_text_chunk(size)!
}

// read_text_chunk consumes `size` bytes as a UTF-8 text fragment. The
// argument is u64 because CBOR allows lengths up to 2^64-1 in the wire
// format; the function rejects any length that the host can't represent
// or that exceeds the available payload, so neither the bounds check
// nor the slice can panic on adversarial input.
@[direct_array_access]
fn (mut u Unpacker) read_text_chunk(size u64) !string {
	if size > u64(u.data.len - u.pos) {
		return eof_oversized(u.pos, size, u.data.len - u.pos)
	}
	size_int := int(size)
	bytes_start := u.pos
	u.pos += size_int
	if u.opts.validate_utf8 && !utf8_validate_slice(u.data, bytes_start, size_int) {
		return InvalidUtf8Error{
			pos: bytes_start
		}
	}
	return u.data[bytes_start..u.pos].bytestr()
}

fn (mut u Unpacker) read_indef_text() !string {
	mut acc := strings_builder_new()
	for {
		b := u.read_byte()!
		if b == 0xff {
			break
		}
		major := b >> 5
		info := b & 0x1f
		if major != 3 || info == 31 {
			return malformed(u.pos - 1,
				'indefinite-length text chunk must be a definite-length text string')
		}
		size := u.read_arg(info)!
		s := u.read_text_chunk(size)!
		acc.write_string(s)
	}
	return acc.str()
}

// unpack_bytes reads a definite or indefinite-length byte string. The
// returned slice is a clone, safe to retain after the unpacker is freed.
pub fn (mut u Unpacker) unpack_bytes() ![]u8 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 2 {
		u.pos = start
		return type_mismatch(start, 'bytes', b)
	}
	info := b & 0x1f
	if info == 31 {
		return u.read_indef_bytes()!
	}
	size := u.read_arg(info)!
	return u.read_bytes_chunk(size)!
}

// read_bytes_chunk consumes `size` bytes as a byte string fragment.
// See read_text_chunk for why size is u64.
@[direct_array_access]
fn (mut u Unpacker) read_bytes_chunk(size u64) ![]u8 {
	if size > u64(u.data.len - u.pos) {
		return eof_oversized(u.pos, size, u.data.len - u.pos)
	}
	size_int := int(size)
	out := u.data[u.pos..u.pos + size_int].clone()
	u.pos += size_int
	return out
}

fn (mut u Unpacker) read_indef_bytes() ![]u8 {
	mut acc := []u8{cap: 64}
	for {
		b := u.read_byte()!
		if b == 0xff {
			break
		}
		major := b >> 5
		info := b & 0x1f
		if major != 2 || info == 31 {
			return malformed(u.pos - 1,
				'indefinite-length bytes chunk must be a definite-length byte string')
		}
		size := u.read_arg(info)!
		acc << u.read_bytes_chunk(size)!
	}
	return acc
}

// unpack_array_header reads the prefix of an array. Returns the count
// for definite-length arrays, or -1 for indefinite-length arrays (the
// caller then loops until peek_kind() == .break_code and consumes the
// break with `expect_break`).
pub fn (mut u Unpacker) unpack_array_header() !i64 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 4 {
		u.pos = start
		return type_mismatch(start, 'array', b)
	}
	info := b & 0x1f
	if info == 31 {
		return -1
	}
	arg := u.read_arg(info)!
	if arg > u64(max_i64) {
		u.pos = start
		return int_range(start, 'i64', arg.str())
	}
	return i64(arg)
}

// unpack_map_header reads the prefix of a map. Returns pair count or -1
// for indefinite-length maps.
pub fn (mut u Unpacker) unpack_map_header() !i64 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 5 {
		u.pos = start
		return type_mismatch(start, 'map', b)
	}
	info := b & 0x1f
	if info == 31 {
		return -1
	}
	arg := u.read_arg(info)!
	if arg > u64(max_i64) {
		u.pos = start
		return int_range(start, 'i64', arg.str())
	}
	return i64(arg)
}

// unpack_tag reads a tag header and returns the tag number. The caller
// must follow up by reading the tag content. Position is rolled back
// on any error so callers can branch on `peek_kind` and try a different
// read.
pub fn (mut u Unpacker) unpack_tag() !u64 {
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	if major != 6 {
		u.pos = start
		return type_mismatch(start, 'tag', b)
	}
	return u.read_arg(b & 0x1f) or {
		u.pos = start
		return err
	}
}

// peek_break reports whether the next byte is the break stop code.
@[inline]
pub fn (u &Unpacker) peek_break() bool {
	return u.pos < u.data.len && u.data[u.pos] == 0xff
}

// consume_break advances past a break stop code if one is at the
// cursor, returning true. Useful for the indef-length loop pattern:
// `for { if u.consume_break() { break } ... }`.
@[inline]
fn (mut u Unpacker) consume_break() bool {
	if u.peek_break() {
		u.pos++
		return true
	}
	return false
}

// check_container_len rejects a definite-length array or map header
// whose item count can't fit a host `int` or whose minimum byte cost
// (1 byte/item for arrays, 2 bytes/pair for maps) already exceeds the
// remaining payload. Callers use the `int(n)` cast safely after.
//
// Comparison uses `remaining / bytes_per_item` rather than
// `n * bytes_per_item` so the multiplication can't overflow at
// n ≈ i64::max.
@[inline]
fn (u &Unpacker) check_container_len(start int, n u64, bytes_per_item int, kind string) ! {
	if n > u64(max_i64) || i64(n) > i64(u.data.len - u.pos) / i64(bytes_per_item) {
		return malformed(start, '${kind} length ${n} exceeds remaining input')
	}
}

// expect_break consumes a single 0xff break code; errors otherwise.
pub fn (mut u Unpacker) expect_break() ! {
	b := u.read_byte()!
	if b != 0xff {
		return malformed(u.pos - 1, 'expected break code, got 0x${b:02x}')
	}
}

// --------------------------------------------------------------------
// Skip
// --------------------------------------------------------------------

// skip_value advances past one complete CBOR value without allocating.
// Honours the depth cap so adversarial deeply-nested input cannot blow
// the stack.
pub fn (mut u Unpacker) skip_value() ! {
	u.skip_inner(0)!
}

fn (mut u Unpacker) skip_inner(depth int) ! {
	if depth > u.opts.max_depth {
		return MaxDepthError{
			pos:       u.pos
			max_depth: u.opts.max_depth
		}
	}
	b := u.read_byte()!
	major := b >> 5
	info := b & 0x1f
	match major {
		0, 1 {
			u.read_arg(info)!
		}
		2, 3 {
			if info == 31 {
				// RFC 8949 §3.2.3: each chunk MUST be a definite-length
				// string of the same major type — no nested indefinite,
				// no cross-type chunks. Mirror unpack_text/unpack_bytes.
				for {
					if u.consume_break() {
						break
					}
					cb := u.read_byte()!
					cmajor := cb >> 5
					cinfo := cb & 0x1f
					if cmajor != major || cinfo == 31 {
						return malformed(u.pos - 1,
							'indefinite-length string chunk must be a definite-length string of the same major type')
					}
					csize := u.read_arg(cinfo)!
					if csize > u64(u.data.len - u.pos) {
						return eof_oversized(u.pos, csize, u.data.len - u.pos)
					}
					u.pos += int(csize)
				}
			} else {
				size := u.read_arg(info)!
				if size > u64(u.data.len - u.pos) {
					return eof_oversized(u.pos, size, u.data.len - u.pos)
				}
				u.pos += int(size)
			}
		}
		4 {
			if info == 31 {
				for {
					if u.consume_break() {
						break
					}
					u.skip_inner(depth + 1)!
				}
			} else {
				n := u.read_arg(info)!
				u.check_container_len(u.pos - 1, n, 1, 'array')!
				for _ in 0 .. n {
					u.skip_inner(depth + 1)!
				}
			}
		}
		5 {
			if info == 31 {
				for {
					if u.consume_break() {
						break
					}
					u.skip_inner(depth + 1)! // key
					u.skip_inner(depth + 1)! // value
				}
			} else {
				n := u.read_arg(info)!
				u.check_container_len(u.pos - 1, n, 2, 'map')!
				for _ in 0 .. n {
					u.skip_inner(depth + 1)!
					u.skip_inner(depth + 1)!
				}
			}
		}
		6 {
			u.read_arg(info)!
			u.skip_inner(depth + 1)!
		}
		else {
			// Major type 7 (floats / simple).
			match info {
				0...23 {} // simple values 0..23 inline
				24 {
					// Per RFC 8949 §3.3, a simple value < 32 must use the
					// inline form (info 0..23) — the 1-byte form is only
					// well-formed for 32..255. unpack_simple already enforces
					// this; skip_value must too, otherwise malformed CBOR
					// slips through RawMessage / Unmarshaler / unknown-field
					// skipping and lands in downstream consumers.
					sv := u.read_byte()!
					if sv < 32 {
						return malformed(u.pos - 1, 'simple value < 32 must use 1-byte form')
					}
				}
				25 {
					u.pos += 2
				} // half
				26 {
					u.pos += 4
				} // single
				27 {
					u.pos += 8
				} // double
				31 {
					return malformed(u.pos - 1, 'unexpected break stop code')
				}
				else {
					return malformed(u.pos - 1, 'reserved additional info ${info}')
				}
			}

			if u.pos > u.data.len {
				return eof_at(u.data.len)
			}
		}
	}
}

// --------------------------------------------------------------------
// Value tree decoder
// --------------------------------------------------------------------

// unpack_value materialises one CBOR data item as a Value.
pub fn (mut u Unpacker) unpack_value() !Value {
	return u.unpack_value_inner(0)!
}

fn (mut u Unpacker) unpack_value_inner(depth int) !Value {
	if depth > u.opts.max_depth {
		return MaxDepthError{
			pos:       u.pos
			max_depth: u.opts.max_depth
		}
	}
	start := u.pos
	b := u.read_byte()!
	major := b >> 5
	info := b & 0x1f
	match major {
		0 {
			arg := u.read_arg(info)!
			return IntNum{
				negative:  false
				magnitude: arg
			}
		}
		1 {
			arg := u.read_arg(info)!
			return IntNum{
				negative:  true
				magnitude: arg
			}
		}
		2 {
			u.pos = start
			data := u.unpack_bytes()!
			return Bytes{
				data: data
			}
		}
		3 {
			u.pos = start
			s := u.unpack_text()!
			return Text{
				value: s
			}
		}
		4 {
			if info == 31 {
				mut elements := []Value{cap: 4}
				for {
					if u.consume_break() {
						break
					}
					elements << u.unpack_value_inner(depth + 1)!
				}
				return Array{
					elements: elements
				}
			}
			n := u.read_arg(info)!
			u.check_container_len(start, n, 1, 'array')!
			mut elements := []Value{cap: int(n)}
			for _ in 0 .. n {
				elements << u.unpack_value_inner(depth + 1)!
			}
			return Array{
				elements: elements
			}
		}
		5 {
			// Dedup tracking hashes the raw on-wire bytes of each key (per
			// RFC 8949 §5.6 "encoded data items are equal iff their byte
			// representations match") in a V map → O(1) lookup vs the
			// previous O(n) linear scan, so adversarial inputs with
			// thousands of distinct keys decode in linear time. Built
			// only when the option is set.
			mut seen := map[string]bool{}
			if info == 31 {
				mut pairs := []MapPair{cap: 4}
				for {
					if u.consume_break() {
						break
					}
					key_start := u.pos
					key := u.unpack_value_inner(depth + 1)!
					if u.opts.deny_duplicate_keys {
						k := u.data[key_start..u.pos].bytestr()
						if k in seen {
							return malformed(key_start, 'duplicate map key')
						}
						seen[k] = true
					}
					val := u.unpack_value_inner(depth + 1)!
					pairs << MapPair{
						key:   key
						value: val
					}
				}
				return Map{
					pairs: pairs
				}
			}
			n := u.read_arg(info)!
			u.check_container_len(start, n, 2, 'map')!
			mut pairs := []MapPair{cap: int(n)}
			for _ in 0 .. n {
				key_start := u.pos
				key := u.unpack_value_inner(depth + 1)!
				if u.opts.deny_duplicate_keys {
					k := u.data[key_start..u.pos].bytestr()
					if k in seen {
						return malformed(key_start, 'duplicate map key')
					}
					seen[k] = true
				}
				val := u.unpack_value_inner(depth + 1)!
				pairs << MapPair{
					key:   key
					value: val
				}
			}
			return Map{
				pairs: pairs
			}
		}
		6 {
			number := u.read_arg(info)!
			content := u.unpack_value_inner(depth + 1)!
			// Native validation per RFC 8949 §3.4.1: tag 0 wraps an RFC 3339
			// text string; tag 1 wraps a numeric value (int or float).
			// QCBOR does the same — accepting wrong content types here would
			// allow well-formed-but-invalid payloads through.
			if number == 0 && content !is Text {
				return malformed(u.pos, 'tag 0 (date/time) must wrap a text string')
			}
			if number == 1 && content !is IntNum && content !is FloatNum {
				return malformed(u.pos, 'tag 1 (epoch) must wrap a number')
			}
			return Tag{
				number:      number
				content_box: [content]
			}
		}
		else {
			match info {
				20 {
					return Bool{
						value: false
					}
				}
				21 {
					return Bool{
						value: true
					}
				}
				22 {
					return Null{}
				}
				23 {
					return Undefined{}
				}
				24 {
					v := u.read_byte()!
					if v < 32 {
						u.pos = start
						return malformed(start, 'simple value < 32 must use 1-byte form')
					}
					return Simple{
						value: v
					}
				}
				25 {
					h := u.read_be_u16()!
					return FloatNum{
						value: half_to_f64(h)
						bits:  .half
					}
				}
				26 {
					bits := u.read_be_u32()!
					return FloatNum{
						value: f64(math.f32_from_bits(bits))
						bits:  .single
					}
				}
				27 {
					bits := u.read_be_u64()!
					return FloatNum{
						value: math.f64_from_bits(bits)
						bits:  .double
					}
				}
				31 {
					u.pos = start
					return malformed(start, 'unexpected break stop code')
				}
				else {
					if info <= 19 {
						return Simple{
							value: info
						}
					}
					u.pos = start
					return malformed(start, 'reserved additional info ${info}')
				}
			}
		}
	}
}

// strings_builder_new is a small alias to keep the import surface tight
// (we only need the strings module for indefinite-length text accumulation).
@[inline]
fn strings_builder_new() StringsBuilder {
	return StringsBuilder{
		buf: []u8{cap: 32}
	}
}

struct StringsBuilder {
mut:
	buf []u8
}

@[inline]
fn (mut b StringsBuilder) write_string(s string) {
	if s == '' {
		return
	}
	unsafe { b.buf.push_many(s.str, s.len) }
}

@[inline]
fn (mut b StringsBuilder) str() string {
	return b.buf.bytestr()
}