diff --git a/src/de.rs b/src/de.rs
index 804bb96..46c2b9e 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,27 +1,21 @@
 //! Deserialize JSON data to a Rust data structure.
 
+use crate::error::{Error, ErrorCode, Result};
 use crate::lib::str::FromStr;
 use crate::lib::*;
-
-#[cfg(feature = "std")]
-use crate::io;
-
+use crate::number::Number;
+use crate::read::{self, Reference};
 use serde::de::{self, Expected, Unexpected};
 use serde::{forward_to_deserialize_any, serde_if_integer128};
 
-use crate::error::{Error, ErrorCode, Result};
-
-use crate::read::{self, Reference};
+#[cfg(feature = "arbitrary_precision")]
+use crate::number::NumberDeserializer;
 
 pub use crate::read::{Read, SliceRead, StrRead};
 
 #[cfg(feature = "std")]
 pub use crate::read::IoRead;
 
-use crate::number::Number;
-#[cfg(feature = "arbitrary_precision")]
-use crate::number::NumberDeserializer;
-
 //////////////////////////////////////////////////////////////////////////////
 
 /// A structure that deserializes JSON into Rust values.
@@ -70,7 +64,7 @@ where
 #[cfg(feature = "std")]
 impl<R> Deserializer<read::IoRead<R>>
 where
-    R: io::Read,
+    R: crate::io::Read,
 {
     /// Creates a JSON deserializer from an `io::Read`.
     ///
@@ -2295,7 +2289,7 @@ where
 #[cfg(feature = "std")]
 pub fn from_reader<R, T>(rdr: R) -> Result<T>
 where
-    R: io::Read,
+    R: crate::io::Read,
     T: de::DeserializeOwned,
 {
     from_trait(read::IoRead::new(rdr))
diff --git a/src/error.rs b/src/error.rs
index 7b26454..3d2822b 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,12 +1,9 @@
 //! When serializing or deserializing JSON goes wrong.
 
+use crate::io;
 use crate::lib::str::FromStr;
 use crate::lib::*;
-
-use crate::io;
-
-use serde::de;
-use serde::ser;
+use serde::{de, ser};
 
 /// This type represents all possible errors that can occur when serializing or
 /// deserializing JSON data.
diff --git a/src/lib.rs b/src/lib.rs
index de6ae77..5e66bb1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -349,11 +349,6 @@ mod lib {
         pub use std::*;
     }
 
-    pub use self::core::{char, str};
-    pub use self::core::{cmp, mem, num, slice};
-
-    pub use self::core::{borrow, iter, ops};
-
     pub use self::core::cell::{Cell, RefCell};
     pub use self::core::clone::{self, Clone};
     pub use self::core::convert::{self, From, Into};
@@ -362,6 +357,7 @@ mod lib {
     pub use self::core::hash::{self, Hash};
     pub use self::core::marker::{self, PhantomData};
     pub use self::core::result::{self, Result};
+    pub use self::core::{borrow, char, cmp, iter, mem, num, ops, slice, str};
 
     #[cfg(not(feature = "std"))]
     pub use alloc::borrow::{Cow, ToOwned};
diff --git a/src/map.rs b/src/map.rs
index cda2365..c9bfdc6 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -9,9 +9,7 @@
 use crate::lib::borrow::Borrow;
 use crate::lib::iter::FromIterator;
 use crate::lib::*;
-
 use crate::value::Value;
-
 use serde::{de, ser};
 
 #[cfg(feature = "preserve_order")]
diff --git a/src/number.rs b/src/number.rs
index 42f02c3..97a0db0 100644
--- a/src/number.rs
+++ b/src/number.rs
@@ -1,19 +1,16 @@
-use crate::lib::*;
-
+use crate::de::ParserNumber;
 use crate::error::Error;
+use crate::lib::*;
 use serde::de::{self, Unexpected, Visitor};
 use serde::{
     forward_to_deserialize_any, serde_if_integer128, Deserialize, Deserializer, Serialize,
     Serializer,
 };
 
-#[cfg(feature = "arbitrary_precision")]
-use serde::de::{IntoDeserializer, MapAccess};
-
-use crate::de::ParserNumber;
-
 #[cfg(feature = "arbitrary_precision")]
 use crate::error::ErrorCode;
+#[cfg(feature = "arbitrary_precision")]
+use serde::de::{IntoDeserializer, MapAccess};
 
 #[cfg(feature = "arbitrary_precision")]
 /// Not public API. Should be pub(crate).
diff --git a/src/raw.rs b/src/raw.rs
index 6b971c4..2d133ae 100644
--- a/src/raw.rs
+++ b/src/raw.rs
@@ -1,5 +1,5 @@
+use crate::error::Error;
 use crate::lib::*;
-
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{
     self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
@@ -8,8 +8,6 @@ use serde::de::{
 use serde::forward_to_deserialize_any;
 use serde::ser::{Serialize, SerializeStruct, Serializer};
 
-use crate::error::Error;
-
 /// Reference to a range of bytes encompassing a single valid JSON value in the
 /// input data.
 ///
diff --git a/src/read.rs b/src/read.rs
index 282f0de..ea93b35 100644
--- a/src/read.rs
+++ b/src/read.rs
@@ -1,21 +1,18 @@
+use crate::error::{Error, ErrorCode, Result};
 use crate::lib::ops::Deref;
 use crate::lib::*;
 
 #[cfg(feature = "std")]
 use crate::io;
-
-#[cfg(feature = "raw_value")]
-use serde::de::Visitor;
-
 #[cfg(feature = "std")]
 use crate::iter::LineColIterator;
 
-use crate::error::{Error, ErrorCode, Result};
-
 #[cfg(feature = "raw_value")]
 use crate::raw::BorrowedRawDeserializer;
 #[cfg(all(feature = "raw_value", feature = "std"))]
 use crate::raw::OwnedRawDeserializer;
+#[cfg(feature = "raw_value")]
+use serde::de::Visitor;
 
 /// Trait used by the deserializer for iterating over input. This is manually
 /// "specialized" for iterating over &[u8]. Once feature(specialization) is
diff --git a/src/ser.rs b/src/ser.rs
index d9e42c5..630b4cc 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,11 +1,9 @@
 //! Serialize a Rust data structure into JSON data.
 
+use crate::error::{Error, ErrorCode, Result};
+use crate::io;
 use crate::lib::num::FpCategory;
 use crate::lib::*;
-
-use crate::io;
-
-use crate::error::{Error, ErrorCode, Result};
 use serde::ser::{self, Impossible, Serialize};
 use serde::serde_if_integer128;
 
diff --git a/src/value/de.rs b/src/value/de.rs
index 656a630..f862d8d 100644
--- a/src/value/de.rs
+++ b/src/value/de.rs
@@ -1,17 +1,14 @@
+use crate::error::Error;
 use crate::lib::str::FromStr;
 use crate::lib::*;
-
-use serde::de::{
-    Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess,
-    Unexpected, VariantAccess, Visitor,
-};
-
-use crate::error::Error;
 use crate::map::Map;
 use crate::number::Number;
 use crate::value::Value;
-
-use serde::{de, forward_to_deserialize_any, serde_if_integer128};
+use serde::de::{
+    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
+    SeqAccess, Unexpected, VariantAccess, Visitor,
+};
+use serde::{forward_to_deserialize_any, serde_if_integer128};
 
 #[cfg(feature = "arbitrary_precision")]
 use crate::number::NumberFromString;
diff --git a/src/value/from.rs b/src/value/from.rs
index 07a6d32..93d3654 100644
--- a/src/value/from.rs
+++ b/src/value/from.rs
@@ -1,7 +1,6 @@
+use super::Value;
 use crate::lib::iter::FromIterator;
 use crate::lib::*;
-
-use super::Value;
 use crate::map::Map;
 use crate::number::Number;
 
diff --git a/src/value/index.rs b/src/value/index.rs
index b6d378a..bb19a08 100644
--- a/src/value/index.rs
+++ b/src/value/index.rs
@@ -1,6 +1,5 @@
-use crate::lib::*;
-
 use super::Value;
+use crate::lib::*;
 use crate::map::Map;
 
 /// A type that can be used to index into a `serde_json::Value`.
diff --git a/src/value/mod.rs b/src/value/mod.rs
index 5fd8049..a56b978 100644
--- a/src/value/mod.rs
+++ b/src/value/mod.rs
@@ -90,24 +90,20 @@
 //! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
 //! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
 
-use crate::lib::*;
-
+use self::ser::Serializer;
+use crate::error::Error;
 use crate::io;
-
+use crate::lib::*;
 use serde::de::DeserializeOwned;
 use serde::ser::Serialize;
 
-use crate::error::Error;
+pub use self::index::Index;
 pub use crate::map::Map;
 pub use crate::number::Number;
 
 #[cfg(feature = "raw_value")]
 pub use crate::raw::RawValue;
 
-pub use self::index::Index;
-
-use self::ser::Serializer;
-
 /// Represents any valid JSON value.
 ///
 /// See the `serde_json::value` module documentation for usage examples.
diff --git a/src/value/partial_eq.rs b/src/value/partial_eq.rs
index 3f0fa7c..354ea5a 100644
--- a/src/value/partial_eq.rs
+++ b/src/value/partial_eq.rs
@@ -1,6 +1,5 @@
-use crate::lib::*;
-
 use super::Value;
+use crate::lib::*;
 
 fn eq_i64(value: &Value, other: i64) -> bool {
     value.as_i64().map_or(false, |i| i == other)
diff --git a/src/value/ser.rs b/src/value/ser.rs
index 4ed756c..6b76b16 100644
--- a/src/value/ser.rs
+++ b/src/value/ser.rs
@@ -1,12 +1,9 @@
-use crate::lib::*;
-
-use serde::ser::Impossible;
-use serde::{self, Serialize};
-
 use crate::error::{Error, ErrorCode};
+use crate::lib::*;
 use crate::map::Map;
 use crate::number::Number;
 use crate::value::{to_value, Value};
+use serde::ser::{Impossible, Serialize};
 
 #[cfg(feature = "arbitrary_precision")]
 use serde::serde_if_integer128;
diff --git a/tests/test.rs b/tests/test.rs
index 5ecf385..e77df3d 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -7,6 +7,14 @@ trace_macros!(true);
 #[macro_use]
 mod macros;
 
+use serde::de::{self, IgnoredAny, IntoDeserializer};
+use serde::ser::{self, Serializer};
+use serde::{Deserialize, Serialize};
+use serde_bytes::{ByteBuf, Bytes};
+use serde_json::{
+    from_reader, from_slice, from_str, from_value, json, to_string, to_string_pretty, to_value,
+    to_vec, to_writer, Deserializer, Number, Value,
+};
 use std::collections::BTreeMap;
 use std::fmt::{self, Debug};
 use std::io;
@@ -18,17 +26,6 @@ use std::{f32, f64};
 use std::{i16, i32, i64, i8};
 use std::{u16, u32, u64, u8};
 
-use serde::de::{self, IgnoredAny, IntoDeserializer};
-use serde::ser::{self, Serializer};
-use serde::{Deserialize, Serialize};
-
-use serde_bytes::{ByteBuf, Bytes};
-
-use serde_json::{
-    from_reader, from_slice, from_str, from_value, json, to_string, to_string_pretty, to_value,
-    to_vec, to_writer, Deserializer, Number, Value,
-};
-
 macro_rules! treemap {
     () => {
         BTreeMap::new()