Function write_buf

modules/llrt_buffer/src/buffer.rs:597–690

(
    this: &This<Object<'js>>,
    ctx: &Ctx<'js>,
    value: &Value<'js>,
    offset: &Opt<usize>,
    endian: Endian,
    kind: NumberKind,
)

            NumberKind::Int8 => &[(Endian::Little, "Int8", None)],
            NumberKind::UInt8 => &[(Endian::Little, "UInt8", Some("Uint8"))],
            NumberKind::Int16 => &[
                (Endian::Little, "Int16LE", None),
                (Endian::Big, "Int16BE", None),
            ],
            NumberKind::UInt16 => &[
                (Endian::Little, "UInt16LE", Some("Uint16LE")),
                (Endian::Big, "UInt16BE", Some("Uint16BE")),
            ],
            NumberKind::Int32 => &[
                (Endian::Little, "Int32LE", None),
                (Endian::Big, "Int32BE", None),
            ],
            NumberKind::UInt32 => &[
                (Endian::Little, "UInt32LE", Some("Uint32LE")),
                (Endian::Big, "UInt32BE", Some("Uint32BE")),
            ],
            NumberKind::Float32 => &[
                (Endian::Little, "FloatLE", None),
                (Endian::Big, "FloatBE", None),
            ],
            NumberKind::Float64 => &[
                (Endian::Little, "DoubleLE", None),
                (Endian::Big, "DoubleBE", None),
            ],
            NumberKind::BigInt => &[
                (Endian::Little, "BigInt64LE", None),
                (Endian::Big, "BigInt64BE", None),
            ],
            NumberKind::BigUInt => &[
                (Endian::Little, "BigUInt64LE", Some("BigUint64LE")),
                (Endian::Big, "BigUInt64BE", Some("BigUint64BE")),
            ],
        }
    }
}

iterable_enum!(
    NumberKind, Int8, UInt8, Int16, UInt16, Int32, UInt32, Float32, Float64, BigInt, BigUInt
);

#[allow(clippy::too_many_arguments)]
fn write_buf<'js>(
    this: &This<Object<'js>>,
    ctx: &Ctx<'js>,
    value: &Value<'js>,
    offset: &Opt<usize>,
    endian: Endian,
    kind: NumberKind,
) -> Result<usize> {
    let offset = offset.0.unwrap_or_default();

    // Extract and convert value
    let (byte_count, bytes) = match kind {
        NumberKind::BigInt => {
            let Some(bigint) = value.as_big_int() else {
                return Err(Exception::throw_type(ctx, "Expected BigInt"));
            };
            let (byte_count, val) = (8, bigint.clone().to_i64().or_throw(ctx)? as u64);