Deleted vendor folder

author: Valentin Popov <valentin@popov.link> 2024-07-19 15:37:58 +0300
committer: Valentin Popov <valentin@popov.link> 2024-07-19 15:37:58 +0300
commit: a990de90fe41456a23e58bd087d2f107d321f3a1 (patch)
tree: 15afc392522a9e85dc3332235e311b7d39352ea9 /vendor/serde_json
parent: 3d48cd3f81164bbfc1a755dc1d4a9a02f98c8ddd (diff)
download: fparkan-a990de90fe41456a23e58bd087d2f107d321f3a1.tar.xz
fparkan-a990de90fe41456a23e58bd087d2f107d321f3a1.zip
86 files changed, 0 insertions, 23237 deletions
diff --git a/vendor/serde_json/.cargo-checksum.json b/vendor/serde_json/.cargo-checksum.json
deleted file mode 100644
index 36f593c..0000000
--- a/vendor/serde_json/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"CONTRIBUTING.md":"f5270cafba66223a7b51ffc0d286075a17bb7cd88762fc80d333d3102629f4d8","Cargo.toml":"3358bd99822678548763c9039a9cf770df1e2f6f0c424a26103be8ccfa8da1e5","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"e49066294ebbeca4e71e5cb8f2e43b5f7a41cd0b47eeb1bad7b24d3c136bd8c0","build.rs":"9fa36e0b1bb7026b449a20986ae2f60b3046bcbcf3bf22b5c0e372eb892eaf57","src/de.rs":"02b550b12e941f9cedfc36b5c127ec27dbc4b54d3de2fae75b7adcc08333551f","src/error.rs":"c8998e8595127d712c2d2c85f6fc69d59f9fcb567009631b5b029669542dcc75","src/features_check/error.rs":"d7359f864afbfe105a38abea9f563dc423036ebc4c956a5695a4beef144dc7ec","src/features_check/mod.rs":"2209f8d5c46b50c8a3b8dc22338dcaf0135d192e8b05d2f456cbe6a73104e958","src/io/core.rs":"60ba28f67a9acaecf8964b611efba416b13f9f2bae4befc329fdf0e037293802","src/io/mod.rs":"fd1ed5080495cab21117f6f7d3c2c9e3687cad0c69a0cd087b08a145a9e672da","src/iter.rs":"f832c469cd7999d26ba9b76baa69b257a212a7edb3dfdf9b1d1bb35e8da85fa9","src/lexical/algorithm.rs":"bd6106e5d8875c9ff1c1d57256b459a4f0992d14a0df1a5fffcd3d3cbdccee8c","src/lexical/bhcomp.rs":"b7c68d74c0055eb67ec2c1bcf27bbc28bef8f1bbc43db8eb94ba69892230add6","src/lexical/bignum.rs":"4230cde10dc8eae456a713cf90ec4e48dff4b1d0c542621ce7f00f39ade2645e","src/lexical/cached.rs":"0e127398691f8042c19cde209e7f4b0161f0f3150342430145929f711e6fdac8","src/lexical/cached_float80.rs":"0f8f74a22cb7d871322a9893bffd0255ca10bf9dffd13afb2462dd3d7f51805f","src/lexical/digit.rs":"9502805adbc3da059131d1fac0a802e17065b36cd7472606b3af24e3241d5cb8","src/lexical/errors.rs":"3d9f6de6245533bcb101dfd718cfed61d59dc293f6768cedae28aa13ace164f5","src/lexical/exponent.rs":"387e945b97dc7ba48a7091c50d228a0dde3a1c4145703d4ab9c31191a91693b0","src/lexical/float.rs":"fe356213c92a049f4bef2f58bc0e3a26866ca06b8c1d74d0f961c5b883852cad","src/lexical/large_powers.rs":"34537f5c701afce1ec2a1fd3c14950381b2e27c9ad74f002c91f3708e8da9ca5","src/lexical/large_powers32.rs":"d533037c6141e6671102aee490c9cdeaba81e667ddca781b2b99db2c455e4a1a","src/lexical/large_powers64.rs":"745dd7c0cbe499eec027ef586248881011d9df20c7efab7929c1807b59886ba1","src/lexical/math.rs":"240804aa030849495fa03a83a0ee8539d5a5c8639b825f2d69d27b7567b06fb3","src/lexical/mod.rs":"4b4c5228779c0f135a4cb018700e3bcd495da48b74421a86f6b8b304acdef924","src/lexical/num.rs":"cf705c62612e31d704f43d94a633ea1243c6befad7ef5792e2e881a7fd21e809","src/lexical/parse.rs":"c2bfac4c70a19938ced61e991f4ec606764887cf12bac1a0978b5b5318a56aac","src/lexical/rounding.rs":"697207248ba17b7f4965aedb11d276261ada5b06d9c6265d8fd6246664ff6e3c","src/lexical/shift.rs":"bc1ed053dd63d45ac9c35302f18de9f00d94027f28af4ab749c9248439de832a","src/lexical/small_powers.rs":"4608dd218b8002435db7e1ec79d2d0fef5f47ae257b93353326d52ecc80cccda","src/lib.rs":"6f676346aaffdbf85cefe82f74b0f4f419cffcc526a496cf47fb3b4e54433bfa","src/macros.rs":"516f69976f433bcc5e48c32b3e29c2e0ab7b549810827d7a9c59171cdf11c1e2","src/map.rs":"5a96fa857e54a04fdca5e3ae93dd44a56fc8acdd71dd2c57a75cef495f7eb8b2","src/number.rs":"464e576953bc3d3df228d88890dd2fe4da123479f5756e03e06c7f7633959156","src/raw.rs":"4183bd3e8b7c97605ec5bab4e7fbdb2a09e00bdc53984fbe2066674510ea74ae","src/read.rs":"6b5b6689f5728f9d2e73a1f6216a811ceb77315174334b44513199898e316f37","src/ser.rs":"ee5b6cb04c2ff7058b52cb5d0383218f484505ce0896e5c7fd5076bd9d90952e","src/value/de.rs":"69d88d0ba8a8fea15964e0c95968e53ab308b143176537bfa6368432a682a65c","src/value/from.rs":"add9687e35db3962729d986c8aa54785cadeb07b8b7121cd4075e3a37ecc73a1","src/value/index.rs":"1a0d59629ae16d6553686de8d7152abd470153f67f9a1b69741e480ba491cd67","src/value/mod.rs":"c1b08509df5ae1ffb5c5e148ac29791923c92eb9957935683739a95bef0007e9","src/value/partial_eq.rs":"655fd0bf3ab1d6669444a55ab849f43bb333032de8ca8f1ee95e1068da43ee22","src/value/ser.rs":"6b065423acf88d875d30608d61210a372507c7242d6525e5ef66077296ba32f1","tests/compiletest.rs":"022a8e400ef813d7ea1875b944549cee5125f6a995dc33e93b48cba3e1b57bd1","tests/debug.rs":"a8451217c1e127ad6e653ef11e0513525ee350e1e37dd575758a8ee9301b28fb","tests/lexical.rs":"8ee6e617ef62a090de49ac2a930130a6913ab5316100781543c7788f89ef99c2","tests/lexical/algorithm.rs":"da378df9ee24bfa033968d5c94e91b58e52c39bf6c825dec51c3eb7250cc5874","tests/lexical/exponent.rs":"26ea92abc654a6a88a8281552bca2f76ea1fa4c17d66a1dd6defe14f7d89b666","tests/lexical/float.rs":"0440f2d85c993bcccd925096d7f4136bf624ffd66b3c7ee565d158390685eb11","tests/lexical/math.rs":"4874be2103be5fbe8b8015354414df271ffa00fd815546fc077f15fb4d7a5a37","tests/lexical/num.rs":"6e650c40de85ed72ac06b6bf1487ba161f3824e26d827df6cfdf2bbdb8d05a05","tests/lexical/parse.rs":"a11f09bb003a3a024548008cf78bf76526ed71b00077d1989f45eb8cebc93b9c","tests/lexical/rounding.rs":"6c56e39ba534616c1b2146e8efa6eb57aed322e683bf23183cd32a61fae6447e","tests/macros/mod.rs":"93aa1d54af20bc2c55b6ae8db73c1414cda2626eb9fa7bd57b9d613a3c6e6a19","tests/map.rs":"89f604c5788bcb8dc82c82e252dc0da47257986e353c09d14e4ef3e58c455f2d","tests/regression.rs":"86731134bfb9bb693d9a4fc62393027de80a8bf031109ea6c7ea475b1ebdde8d","tests/regression/issue1004.rs":"38d7e3b6c515b881078ebd21ca8063d2ca105cd319695d29538f879e37f091b5","tests/regression/issue520.rs":"d146be3472db902b48127d65fe83aa9f698143aca9074c83cd1a9d5dd28e3ec3","tests/regression/issue795.rs":"582e2e7c68113f05a4b1d2cb556a2df7cc77f2ce8164a32c5cc58ae68abb60ec","tests/regression/issue845.rs":"66eb0eeabb744adaad42fd8e2638de22b458a04ec33863e2683b60eb3d500297","tests/regression/issue953.rs":"b2cddc761f5ca6639900c173765a8a5868528a896924e5e925db2696469208f7","tests/stream.rs":"c7d91014538ecd8f495b196d40e999ab2745f2e69fa2ff9e52521605dc6ce856","tests/test.rs":"8a71e5ab13f016642b6f90d7fc935ed1399f2c4d74f1d6de0b64c0ca7fe7aa59","tests/ui/missing_colon.rs":"d07e0c34d98eb43465f0a0310f2c0b5d5b0d26d243b352a1c6bbe6ad3b27eda9","tests/ui/missing_colon.stderr":"3732fd8f4e57b84efc07170cda5f9c5b2b17c707e23c1659222b5a46f652a8d8","tests/ui/missing_comma.rs":"b8a9662f99c3e6dd2b6417892c37640578ce91d3a8365bf10c1f686a3227aa87","tests/ui/missing_comma.stderr":"eae626cf93c97abd105066e624ca4e8cb096784413b9d2564cf9414a8492bc4d","tests/ui/missing_value.rs":"bca25d67127fb88e7c191c7b03af5a4ce8a9abb630f3d2e6a6c1e77e213dc9a4","tests/ui/missing_value.stderr":"b0df8add5cf74e5df30eedd3ca347e4862c04a01c54d802ff45392f2032065b1","tests/ui/not_found.rs":"d0a7adb309879ff65aee115b52cc33d36f4bad353cf97c4effc34a6128c2bee3","tests/ui/not_found.stderr":"359b751c0c21fab6d460daef4d5f73a265f7769c9b578f98ea3cb6cbf2387643","tests/ui/parse_expr.rs":"32e6d51f528db3d1ab0ed1e24765b865be393565c26f77413c5aa39d601ac563","tests/ui/parse_expr.stderr":"4fcd0a014fbce31c9266bab8527d6e6b6806a0e21d9e0275ce713137856073ce","tests/ui/parse_key.rs":"18829b2af320d5cf8a0a5cd3aaf84c7e92cc874651c30e45a3acafb76c2d8b93","tests/ui/parse_key.stderr":"20cf0d2898749f3c36780fc065f5049ee809e74cb6f0ef776f43f45e01596ee3","tests/ui/unexpected_after_array_element.rs":"a343fc3104431720bdfcf330bcc3cfcd98c8dec3e951133b495242478b0b7eb3","tests/ui/unexpected_after_array_element.stderr":"8df615998fa3057bb9ed865981a35cdbb771625337048f0ad3fba7734e607adf","tests/ui/unexpected_after_map_entry.rs":"6e3bd2def435ca610e346bbc75cdbaf61963eb2ef1885bb5f76781ba1fac37ef","tests/ui/unexpected_after_map_entry.stderr":"b1985c89075ab48b2158bd1705ed766d37854b3d4620ab257cc8bc319d224f17","tests/ui/unexpected_colon.rs":"a313cff3fed4be4c33f1eda5d0c5c98147fb835a56d36470d9f367352c1d61ef","tests/ui/unexpected_colon.stderr":"b2288742fa6a4a7eb65d2ae899bcfed8795b57bd04958da227d60928a8df26c5","tests/ui/unexpected_comma.rs":"55a8b684bde1ce905837cce719fd457d8898b61cebc27e5b420d05cb6be97256","tests/ui/unexpected_comma.stderr":"4c103ca63ff15e2ca659242cc0eae0612bf050e7580da62f1cf50de8082aa7dc"},"package":"176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4"}
-\ No newline at end of file
diff --git a/vendor/serde_json/CONTRIBUTING.md b/vendor/serde_json/CONTRIBUTING.md
deleted file mode 100644
index 26e1578..0000000
--- a/vendor/serde_json/CONTRIBUTING.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Contributing to Serde
-
-Serde welcomes contribution from everyone in the form of suggestions, bug
-reports, pull requests, and feedback. This document gives some guidance if you
-are thinking of helping us.
-
-## Submitting bug reports and feature requests
-
-Serde development is spread across lots of repositories. In general, prefer to
-open issues against the main [serde-rs/serde] repository unless the topic is
-clearly specific to JSON.
-
-[serde-rs/serde]: https://github.com/serde-rs/serde
-
-When reporting a bug or asking for help, please include enough details so that
-the people helping you can reproduce the behavior you are seeing. For some tips
-on how to approach this, read about how to produce a [Minimal, Complete, and
-Verifiable example].
-
-[Minimal, Complete, and Verifiable example]: https://stackoverflow.com/help/mcve
-
-When making a feature request, please make it clear what problem you intend to
-solve with the feature, any ideas for how Serde could support solving that
-problem, any possible alternatives, and any disadvantages.
-
-## Running the test suite
-
-We encourage you to check that the test suite passes locally before submitting a
-pull request with your changes. If anything does not pass, typically it will be
-easier to iterate and fix it locally than waiting for the CI servers to run
-tests for you.
-
-The test suite requires a nightly compiler.
-
-```sh
-# Run the full test suite, including doc test and compile-tests
-cargo test
-```
-
-## Conduct
-
-In all Serde-related forums, we follow the [Rust Code of Conduct]. For
-escalation or moderation issues please contact Erick (erick.tryzelaar@gmail.com)
-instead of the Rust moderation team.
-
-[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct
diff --git a/vendor/serde_json/Cargo.toml b/vendor/serde_json/Cargo.toml
deleted file mode 100644
index ca24434..0000000
--- a/vendor/serde_json/Cargo.toml
+++ /dev/null
@@ -1,109 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-rust-version = "1.56"
-name = "serde_json"
-version = "1.0.111"
-authors = [
-    "Erick Tryzelaar <erick.tryzelaar@gmail.com>",
-    "David Tolnay <dtolnay@gmail.com>",
-]
-description = "A JSON serialization file format"
-documentation = "https://docs.rs/serde_json"
-readme = "README.md"
-keywords = [
-    "json",
-    "serde",
-    "serialization",
-]
-categories = [
-    "encoding",
-    "parser-implementations",
-    "no-std",
-]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/serde-rs/json"
-
-[package.metadata.docs.rs]
-features = [
-    "raw_value",
-    "unbounded_depth",
-]
-rustdoc-args = [
-    "--cfg",
-    "docsrs",
-    "--generate-link-to-definition",
-]
-targets = ["x86_64-unknown-linux-gnu"]
-
-[package.metadata.playground]
-features = ["raw_value"]
-
-[lib]
-doc-scrape-examples = false
-
-[dependencies.indexmap]
-version = "2"
-optional = true
-
-[dependencies.itoa]
-version = "1.0"
-
-[dependencies.ryu]
-version = "1.0"
-
-[dependencies.serde]
-version = "1.0.194"
-default-features = false
-
-[dev-dependencies.automod]
-version = "1.0.11"
-
-[dev-dependencies.indoc]
-version = "2.0.2"
-
-[dev-dependencies.ref-cast]
-version = "1.0.18"
-
-[dev-dependencies.rustversion]
-version = "1.0.13"
-
-[dev-dependencies.serde]
-version = "1.0.194"
-features = ["derive"]
-
-[dev-dependencies.serde_bytes]
-version = "0.11.10"
-
-[dev-dependencies.serde_derive]
-version = "1.0.166"
-
-[dev-dependencies.serde_stacker]
-version = "0.1.8"
-
-[dev-dependencies.trybuild]
-version = "1.0.81"
-features = ["diff"]
-
-[features]
-alloc = ["serde/alloc"]
-arbitrary_precision = []
-default = ["std"]
-float_roundtrip = []
-preserve_order = [
-    "indexmap",
-    "std",
-]
-raw_value = []
-std = ["serde/std"]
-unbounded_depth = []
diff --git a/vendor/serde_json/LICENSE-APACHE b/vendor/serde_json/LICENSE-APACHE
deleted file mode 100644
index 1b5ec8b..0000000
--- a/vendor/serde_json/LICENSE-APACHE
+++ /dev/null
@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
diff --git a/vendor/serde_json/LICENSE-MIT b/vendor/serde_json/LICENSE-MIT
deleted file mode 100644
index 31aa793..0000000
--- a/vendor/serde_json/LICENSE-MIT
+++ /dev/null
@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/serde_json/README.md b/vendor/serde_json/README.md
deleted file mode 100644
index a3ba288..0000000
--- a/vendor/serde_json/README.md
+++ /dev/null
@@ -1,390 +0,0 @@
-# Serde JSON &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![Rustc Version 1.36+]][rustc]
-
-[Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/json/ci.yml?branch=master
-[actions]: https://github.com/serde-rs/json/actions?query=branch%3Amaster
-[Latest Version]: https://img.shields.io/crates/v/serde_json.svg
-[crates.io]: https://crates.io/crates/serde\_json
-[Rustc Version 1.36+]: https://img.shields.io/badge/rustc-1.36+-lightgray.svg
-[rustc]: https://blog.rust-lang.org/2019/07/04/Rust-1.36.0.html
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-```toml
-[dependencies]
-serde_json = "1.0"
-```
-
-You may be looking for:
-
-- [JSON API documentation](https://docs.rs/serde_json)
-- [Serde API documentation](https://docs.rs/serde)
-- [Detailed documentation about Serde](https://serde.rs/)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Release notes](https://github.com/serde-rs/json/releases)
-
-JSON is a ubiquitous open-standard format that uses human-readable text to
-transmit data objects consisting of key-value pairs.
-
-```json
-{
-    "name": "John Doe",
-    "age": 43,
-    "address": {
-        "street": "10 Downing Street",
-        "city": "London"
-    },
-    "phones": [
-        "+44 1234567",
-        "+44 2345678"
-    ]
-}
-```
-
-There are three common ways that you might find yourself needing to work with
-JSON data in Rust.
-
- - **As text data.** An unprocessed string of JSON data that you receive on an
-   HTTP endpoint, read from a file, or prepare to send to a remote server.
- - **As an untyped or loosely typed representation.** Maybe you want to check
-   that some JSON data is valid before passing it on, but without knowing the
-   structure of what it contains. Or you want to do very basic manipulations
-   like insert a key in a particular spot.
- - **As a strongly typed Rust data structure.** When you expect all or most of
-   your data to conform to a particular structure and want to get real work done
-   without JSON's loosey-goosey nature tripping you up.
-
-Serde JSON provides efficient, flexible, safe ways of converting data between
-each of these representations.
-
-## Operating on untyped JSON values
-
-Any valid JSON data can be manipulated in the following recursive enum
-representation. This data structure is [`serde_json::Value`][value].
-
-```rust
-enum Value {
-    Null,
-    Bool(bool),
-    Number(Number),
-    String(String),
-    Array(Vec<Value>),
-    Object(Map<String, Value>),
-}
-```
-
-A string of JSON data can be parsed into a `serde_json::Value` by the
-[`serde_json::from_str`][from_str] function. There is also
-[`from_slice`][from_slice] for parsing from a byte slice &\[u8\] and
-[`from_reader`][from_reader] for parsing from any `io::Read` like a File or a
-TCP stream.
-
-<div align="right">
-<a href="https://play.rust-lang.org/?edition=2018&gist=d69d8e3156d4bb81c4461b60b772ab72" target="_blank">
-<img align="center" width="85" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/runtab.png">
-</a>
-</div>
-
-```rust
-use serde_json::{Result, Value};
-
-fn untyped_example() -> Result<()> {
-    // Some JSON input data as a &str. Maybe this comes from the user.
-    let data = r#"
-        {
-            "name": "John Doe",
-            "age": 43,
-            "phones": [
-                "+44 1234567",
-                "+44 2345678"
-            ]
-        }"#;
-
-    // Parse the string of data into serde_json::Value.
-    let v: Value = serde_json::from_str(data)?;
-
-    // Access parts of the data by indexing with square brackets.
-    println!("Please call {} at the number {}", v["name"], v["phones"][0]);
-
-    Ok(())
-}
-```
-
-The result of square bracket indexing like `v["name"]` is a borrow of the data
-at that index, so the type is `&Value`. A JSON map can be indexed with string
-keys, while a JSON array can be indexed with integer keys. If the type of the
-data is not right for the type with which it is being indexed, or if a map does
-not contain the key being indexed, or if the index into a vector is out of
-bounds, the returned element is `Value::Null`.
-
-When a `Value` is printed, it is printed as a JSON string. So in the code above,
-the output looks like `Please call "John Doe" at the number "+44 1234567"`. The
-quotation marks appear because `v["name"]` is a `&Value` containing a JSON
-string and its JSON representation is `"John Doe"`. Printing as a plain string
-without quotation marks involves converting from a JSON string to a Rust string
-with [`as_str()`] or avoiding the use of `Value` as described in the following
-section.
-
-[`as_str()`]: https://docs.rs/serde_json/1/serde_json/enum.Value.html#method.as_str
-
-The `Value` representation is sufficient for very basic tasks but can be tedious
-to work with for anything more significant. Error handling is verbose to
-implement correctly, for example imagine trying to detect the presence of
-unrecognized fields in the input data. The compiler is powerless to help you
-when you make a mistake, for example imagine typoing `v["name"]` as `v["nmae"]`
-in one of the dozens of places it is used in your code.
-
-## Parsing JSON as strongly typed data structures
-
-Serde provides a powerful way of mapping JSON data into Rust data structures
-largely automatically.
-
-<div align="right">
-<a href="https://play.rust-lang.org/?edition=2018&gist=15cfab66d38ff8a15a9cf1d8d897ac68" target="_blank">
-<img align="center" width="85" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/runtab.png">
-</a>
-</div>
-
-```rust
-use serde::{Deserialize, Serialize};
-use serde_json::Result;
-
-#[derive(Serialize, Deserialize)]
-struct Person {
-    name: String,
-    age: u8,
-    phones: Vec<String>,
-}
-
-fn typed_example() -> Result<()> {
-    // Some JSON input data as a &str. Maybe this comes from the user.
-    let data = r#"
-        {
-            "name": "John Doe",
-            "age": 43,
-            "phones": [
-                "+44 1234567",
-                "+44 2345678"
-            ]
-        }"#;
-
-    // Parse the string of data into a Person object. This is exactly the
-    // same function as the one that produced serde_json::Value above, but
-    // now we are asking it for a Person as output.
-    let p: Person = serde_json::from_str(data)?;
-
-    // Do things just like with any other Rust data structure.
-    println!("Please call {} at the number {}", p.name, p.phones[0]);
-
-    Ok(())
-}
-```
-
-This is the same `serde_json::from_str` function as before, but this time we
-assign the return value to a variable of type `Person` so Serde will
-automatically interpret the input data as a `Person` and produce informative
-error messages if the layout does not conform to what a `Person` is expected to
-look like.
-
-Any type that implements Serde's `Deserialize` trait can be deserialized this
-way. This includes built-in Rust standard library types like `Vec<T>` and
-`HashMap<K, V>`, as well as any structs or enums annotated with
-`#[derive(Deserialize)]`.
-
-Once we have `p` of type `Person`, our IDE and the Rust compiler can help us use
-it correctly like they do for any other Rust code. The IDE can autocomplete
-field names to prevent typos, which was impossible in the `serde_json::Value`
-representation. And the Rust compiler can check that when we write
-`p.phones[0]`, then `p.phones` is guaranteed to be a `Vec<String>` so indexing
-into it makes sense and produces a `String`.
-
-The necessary setup for using Serde's derive macros is explained on the *[Using
-derive]* page of the Serde site.
-
-[Using derive]: https://serde.rs/derive.html
-
-## Constructing JSON values
-
-Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
-objects with very natural JSON syntax.
-
-<div align="right">
-<a href="https://play.rust-lang.org/?edition=2018&gist=6ccafad431d72b62e77cc34c8e879b24" target="_blank">
-<img align="center" width="85" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/runtab.png">
-</a>
-</div>
-
-```rust
-use serde_json::json;
-
-fn main() {
-    // The type of `john` is `serde_json::Value`
-    let john = json!({
-        "name": "John Doe",
-        "age": 43,
-        "phones": [
-            "+44 1234567",
-            "+44 2345678"
-        ]
-    });
-
-    println!("first phone number: {}", john["phones"][0]);
-
-    // Convert to a string of JSON and print it out
-    println!("{}", john.to_string());
-}
-```
-
-The `Value::to_string()` function converts a `serde_json::Value` into a `String`
-of JSON text.
-
-One neat thing about the `json!` macro is that variables and expressions can be
-interpolated directly into the JSON value as you are building it. Serde will
-check at compile time that the value you are interpolating is able to be
-represented as JSON.
-
-<div align="right">
-<a href="https://play.rust-lang.org/?edition=2018&gist=f9101a6e61dfc9e02c6a67f315ed24f2" target="_blank">
-<img align="center" width="85" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/runtab.png">
-</a>
-</div>
-
-```rust
-let full_name = "John Doe";
-let age_last_year = 42;
-
-// The type of `john` is `serde_json::Value`
-let john = json!({
-    "name": full_name,
-    "age": age_last_year + 1,
-    "phones": [
-        format!("+44 {}", random_phone())
-    ]
-});
-```
-
-This is amazingly convenient, but we have the problem we had before with
-`Value`: the IDE and Rust compiler cannot help us if we get it wrong. Serde JSON
-provides a better way of serializing strongly-typed data structures into JSON
-text.
-
-## Creating JSON by serializing data structures
-
-A data structure can be converted to a JSON string by
-[`serde_json::to_string`][to_string]. There is also
-[`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
-[`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
-such as a File or a TCP stream.
-
-<div align="right">
-<a href="https://play.rust-lang.org/?edition=2018&gist=3472242a08ed2ff88a944f2a2283b0ee" target="_blank">
-<img align="center" width="85" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/runtab.png">
-</a>
-</div>
-
-```rust
-use serde::{Deserialize, Serialize};
-use serde_json::Result;
-
-#[derive(Serialize, Deserialize)]
-struct Address {
-    street: String,
-    city: String,
-}
-
-fn print_an_address() -> Result<()> {
-    // Some data structure.
-    let address = Address {
-        street: "10 Downing Street".to_owned(),
-        city: "London".to_owned(),
-    };
-
-    // Serialize it to a JSON string.
-    let j = serde_json::to_string(&address)?;
-
-    // Print, write to a file, or send to an HTTP server.
-    println!("{}", j);
-
-    Ok(())
-}
-```
-
-Any type that implements Serde's `Serialize` trait can be serialized this way.
-This includes built-in Rust standard library types like `Vec<T>` and `HashMap<K,
-V>`, as well as any structs or enums annotated with `#[derive(Serialize)]`.
-
-## Performance
-
-It is fast. You should expect in the ballpark of 500 to 1000 megabytes per
-second deserialization and 600 to 900 megabytes per second serialization,
-depending on the characteristics of your data. This is competitive with the
-fastest C and C++ JSON libraries or even 30% faster for many use cases.
-Benchmarks live in the [serde-rs/json-benchmark] repo.
-
-[serde-rs/json-benchmark]: https://github.com/serde-rs/json-benchmark
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries, so any place that
-Rustaceans congregate will be able to help you out. For chat, consider trying
-the [#rust-questions] or [#rust-beginners] channels of the unofficial community
-Discord (invite: <https://discord.gg/rust-lang-community>), the [#rust-usage] or
-[#beginners] channels of the official Rust Project Discord (invite:
-<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
-asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
-[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
-[Discourse forum][discourse]. It's acceptable to file a support issue in this
-repo, but they tend not to get as many eyes as any of the above and may get
-closed without a response after some time.
-
-[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
-[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
-
-## No-std support
-
-As long as there is a memory allocator, it is possible to use serde_json without
-the rest of the Rust standard library. Disable the default "std" feature and
-enable the "alloc" feature:
-
-```toml
-[dependencies]
-serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
-```
-
-For JSON support in Serde without a memory allocator, please see the
-[`serde-json-core`] crate.
-
-[`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core
-
-[value]: https://docs.rs/serde_json/1/serde_json/value/enum.Value.html
-[from_str]: https://docs.rs/serde_json/1/serde_json/de/fn.from_str.html
-[from_slice]: https://docs.rs/serde_json/1/serde_json/de/fn.from_slice.html
-[from_reader]: https://docs.rs/serde_json/1/serde_json/de/fn.from_reader.html
-[to_string]: https://docs.rs/serde_json/1/serde_json/ser/fn.to_string.html
-[to_vec]: https://docs.rs/serde_json/1/serde_json/ser/fn.to_vec.html
-[to_writer]: https://docs.rs/serde_json/1/serde_json/ser/fn.to_writer.html
-[macro]: https://docs.rs/serde_json/1/serde_json/macro.json.html
-
-<br>
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
-</sub>
diff --git a/vendor/serde_json/build.rs b/vendor/serde_json/build.rs
deleted file mode 100644
index dd09e62..0000000
--- a/vendor/serde_json/build.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use std::env;
-
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    // Decide ideal limb width for arithmetic in the float parser. Refer to
-    // src/lexical/math.rs for where this has an effect.
-    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    match target_arch.as_str() {
-        "aarch64" | "mips64" | "powerpc64" | "x86_64" | "loongarch64" => {
-            println!("cargo:rustc-cfg=limb_width_64");
-        }
-        _ => {
-            println!("cargo:rustc-cfg=limb_width_32");
-        }
-    }
-}
diff --git a/vendor/serde_json/src/de.rs b/vendor/serde_json/src/de.rs
deleted file mode 100644
index 7154f84..0000000
--- a/vendor/serde_json/src/de.rs
+++ /dev/null
@@ -1,2679 +0,0 @@
-//! Deserialize JSON data to a Rust data structure.
-
-use crate::error::{Error, ErrorCode, Result};
-#[cfg(feature = "float_roundtrip")]
-use crate::lexical;
-use crate::number::Number;
-use crate::read::{self, Fused, Reference};
-use alloc::string::String;
-use alloc::vec::Vec;
-#[cfg(feature = "float_roundtrip")]
-use core::iter;
-use core::iter::FusedIterator;
-use core::marker::PhantomData;
-use core::result;
-use core::str::FromStr;
-use serde::de::{self, Expected, Unexpected};
-use serde::forward_to_deserialize_any;
-
-#[cfg(feature = "arbitrary_precision")]
-use crate::number::NumberDeserializer;
-
-pub use crate::read::{Read, SliceRead, StrRead};
-
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub use crate::read::IoRead;
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// A structure that deserializes JSON into Rust values.
-pub struct Deserializer<R> {
-    read: R,
-    scratch: Vec<u8>,
-    remaining_depth: u8,
-    #[cfg(feature = "float_roundtrip")]
-    single_precision: bool,
-    #[cfg(feature = "unbounded_depth")]
-    disable_recursion_limit: bool,
-}
-
-impl<'de, R> Deserializer<R>
-where
-    R: read::Read<'de>,
-{
-    /// Create a JSON deserializer from one of the possible serde_json input
-    /// sources.
-    ///
-    /// Typically it is more convenient to use one of these methods instead:
-    ///
-    ///   - Deserializer::from_str
-    ///   - Deserializer::from_slice
-    ///   - Deserializer::from_reader
-    pub fn new(read: R) -> Self {
-        Deserializer {
-            read,
-            scratch: Vec::new(),
-            remaining_depth: 128,
-            #[cfg(feature = "float_roundtrip")]
-            single_precision: false,
-            #[cfg(feature = "unbounded_depth")]
-            disable_recursion_limit: false,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<R> Deserializer<read::IoRead<R>>
-where
-    R: crate::io::Read,
-{
-    /// Creates a JSON deserializer from an `io::Read`.
-    ///
-    /// Reader-based deserializers do not support deserializing borrowed types
-    /// like `&str`, since the `std::io::Read` trait has no non-copying methods
-    /// -- everything it does involves copying bytes out of the data source.
-    pub fn from_reader(reader: R) -> Self {
-        Deserializer::new(read::IoRead::new(reader))
-    }
-}
-
-impl<'a> Deserializer<read::SliceRead<'a>> {
-    /// Creates a JSON deserializer from a `&[u8]`.
-    pub fn from_slice(bytes: &'a [u8]) -> Self {
-        Deserializer::new(read::SliceRead::new(bytes))
-    }
-}
-
-impl<'a> Deserializer<read::StrRead<'a>> {
-    /// Creates a JSON deserializer from a `&str`.
-    pub fn from_str(s: &'a str) -> Self {
-        Deserializer::new(read::StrRead::new(s))
-    }
-}
-
-macro_rules! overflow {
-    ($a:ident * 10 + $b:ident, $c:expr) => {
-        match $c {
-            c => $a >= c / 10 && ($a > c / 10 || $b > c % 10),
-        }
-    };
-}
-
-pub(crate) enum ParserNumber {
-    F64(f64),
-    U64(u64),
-    I64(i64),
-    #[cfg(feature = "arbitrary_precision")]
-    String(String),
-}
-
-impl ParserNumber {
-    fn visit<'de, V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self {
-            ParserNumber::F64(x) => visitor.visit_f64(x),
-            ParserNumber::U64(x) => visitor.visit_u64(x),
-            ParserNumber::I64(x) => visitor.visit_i64(x),
-            #[cfg(feature = "arbitrary_precision")]
-            ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }),
-        }
-    }
-
-    fn invalid_type(self, exp: &dyn Expected) -> Error {
-        match self {
-            ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp),
-            ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp),
-            ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp),
-            #[cfg(feature = "arbitrary_precision")]
-            ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp),
-        }
-    }
-}
-
-impl<'de, R: Read<'de>> Deserializer<R> {
-    /// The `Deserializer::end` method should be called after a value has been fully deserialized.
-    /// This allows the `Deserializer` to validate that the input stream is at the end or that it
-    /// only has trailing whitespace.
-    pub fn end(&mut self) -> Result<()> {
-        match tri!(self.parse_whitespace()) {
-            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
-            None => Ok(()),
-        }
-    }
-
-    /// Turn a JSON deserializer into an iterator over values of type T.
-    pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
-    where
-        T: de::Deserialize<'de>,
-    {
-        // This cannot be an implementation of std::iter::IntoIterator because
-        // we need the caller to choose what T is.
-        let offset = self.read.byte_offset();
-        StreamDeserializer {
-            de: self,
-            offset,
-            failed: false,
-            output: PhantomData,
-            lifetime: PhantomData,
-        }
-    }
-
-    /// Parse arbitrarily deep JSON structures without any consideration for
-    /// overflowing the stack.
-    ///
-    /// You will want to provide some other way to protect against stack
-    /// overflows, such as by wrapping your Deserializer in the dynamically
-    /// growing stack adapter provided by the serde_stacker crate. Additionally
-    /// you will need to be careful around other recursive operations on the
-    /// parsed result which may overflow the stack after deserialization has
-    /// completed, including, but not limited to, Display and Debug and Drop
-    /// impls.
-    ///
-    /// *This method is only available if serde_json is built with the
-    /// `"unbounded_depth"` feature.*
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde::Deserialize;
-    /// use serde_json::Value;
-    ///
-    /// fn main() {
-    ///     let mut json = String::new();
-    ///     for _ in 0..10000 {
-    ///         json = format!("[{}]", json);
-    ///     }
-    ///
-    ///     let mut deserializer = serde_json::Deserializer::from_str(&json);
-    ///     deserializer.disable_recursion_limit();
-    ///     let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
-    ///     let value = Value::deserialize(deserializer).unwrap();
-    ///
-    ///     carefully_drop_nested_arrays(value);
-    /// }
-    ///
-    /// fn carefully_drop_nested_arrays(value: Value) {
-    ///     let mut stack = vec![value];
-    ///     while let Some(value) = stack.pop() {
-    ///         if let Value::Array(array) = value {
-    ///             stack.extend(array);
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    #[cfg(feature = "unbounded_depth")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "unbounded_depth")))]
-    pub fn disable_recursion_limit(&mut self) {
-        self.disable_recursion_limit = true;
-    }
-
-    pub(crate) fn peek(&mut self) -> Result<Option<u8>> {
-        self.read.peek()
-    }
-
-    fn peek_or_null(&mut self) -> Result<u8> {
-        Ok(tri!(self.peek()).unwrap_or(b'\x00'))
-    }
-
-    fn eat_char(&mut self) {
-        self.read.discard();
-    }
-
-    fn next_char(&mut self) -> Result<Option<u8>> {
-        self.read.next()
-    }
-
-    fn next_char_or_null(&mut self) -> Result<u8> {
-        Ok(tri!(self.next_char()).unwrap_or(b'\x00'))
-    }
-
-    /// Error caused by a byte from next_char().
-    #[cold]
-    fn error(&self, reason: ErrorCode) -> Error {
-        let position = self.read.position();
-        Error::syntax(reason, position.line, position.column)
-    }
-
-    /// Error caused by a byte from peek().
-    #[cold]
-    fn peek_error(&self, reason: ErrorCode) -> Error {
-        let position = self.read.peek_position();
-        Error::syntax(reason, position.line, position.column)
-    }
-
-    /// Returns the first non-whitespace byte without consuming it, or `None` if
-    /// EOF is encountered.
-    fn parse_whitespace(&mut self) -> Result<Option<u8>> {
-        loop {
-            match tri!(self.peek()) {
-                Some(b' ' | b'\n' | b'\t' | b'\r') => {
-                    self.eat_char();
-                }
-                other => {
-                    return Ok(other);
-                }
-            }
-        }
-    }
-
-    #[cold]
-    fn peek_invalid_type(&mut self, exp: &dyn Expected) -> Error {
-        let err = match self.peek_or_null().unwrap_or(b'\x00') {
-            b'n' => {
-                self.eat_char();
-                if let Err(err) = self.parse_ident(b"ull") {
-                    return err;
-                }
-                de::Error::invalid_type(Unexpected::Unit, exp)
-            }
-            b't' => {
-                self.eat_char();
-                if let Err(err) = self.parse_ident(b"rue") {
-                    return err;
-                }
-                de::Error::invalid_type(Unexpected::Bool(true), exp)
-            }
-            b'f' => {
-                self.eat_char();
-                if let Err(err) = self.parse_ident(b"alse") {
-                    return err;
-                }
-                de::Error::invalid_type(Unexpected::Bool(false), exp)
-            }
-            b'-' => {
-                self.eat_char();
-                match self.parse_any_number(false) {
-                    Ok(n) => n.invalid_type(exp),
-                    Err(err) => return err,
-                }
-            }
-            b'0'..=b'9' => match self.parse_any_number(true) {
-                Ok(n) => n.invalid_type(exp),
-                Err(err) => return err,
-            },
-            b'"' => {
-                self.eat_char();
-                self.scratch.clear();
-                match self.read.parse_str(&mut self.scratch) {
-                    Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp),
-                    Err(err) => return err,
-                }
-            }
-            b'[' => de::Error::invalid_type(Unexpected::Seq, exp),
-            b'{' => de::Error::invalid_type(Unexpected::Map, exp),
-            _ => self.peek_error(ErrorCode::ExpectedSomeValue),
-        };
-
-        self.fix_position(err)
-    }
-
-    pub(crate) fn deserialize_number<'any, V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'any>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'-' => {
-                self.eat_char();
-                tri!(self.parse_integer(false)).visit(visitor)
-            }
-            b'0'..=b'9' => tri!(self.parse_integer(true)).visit(visitor),
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    pub(crate) fn do_deserialize_f32<'any, V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'any>,
-    {
-        self.single_precision = true;
-        let val = self.deserialize_number(visitor);
-        self.single_precision = false;
-        val
-    }
-
-    pub(crate) fn do_deserialize_i128<'any, V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'any>,
-    {
-        let mut buf = String::new();
-
-        match tri!(self.parse_whitespace()) {
-            Some(b'-') => {
-                self.eat_char();
-                buf.push('-');
-            }
-            Some(_) => {}
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        tri!(self.scan_integer128(&mut buf));
-
-        let value = match buf.parse() {
-            Ok(int) => visitor.visit_i128(int),
-            Err(_) => {
-                return Err(self.error(ErrorCode::NumberOutOfRange));
-            }
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    pub(crate) fn do_deserialize_u128<'any, V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'any>,
-    {
-        match tri!(self.parse_whitespace()) {
-            Some(b'-') => {
-                return Err(self.peek_error(ErrorCode::NumberOutOfRange));
-            }
-            Some(_) => {}
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        }
-
-        let mut buf = String::new();
-        tri!(self.scan_integer128(&mut buf));
-
-        let value = match buf.parse() {
-            Ok(int) => visitor.visit_u128(int),
-            Err(_) => {
-                return Err(self.error(ErrorCode::NumberOutOfRange));
-            }
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
-        match tri!(self.next_char_or_null()) {
-            b'0' => {
-                buf.push('0');
-                // There can be only one leading '0'.
-                match tri!(self.peek_or_null()) {
-                    b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
-                    _ => Ok(()),
-                }
-            }
-            c @ b'1'..=b'9' => {
-                buf.push(c as char);
-                while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-                    self.eat_char();
-                    buf.push(c as char);
-                }
-                Ok(())
-            }
-            _ => Err(self.error(ErrorCode::InvalidNumber)),
-        }
-    }
-
-    #[cold]
-    fn fix_position(&self, err: Error) -> Error {
-        err.fix_position(move |code| self.error(code))
-    }
-
-    fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
-        for expected in ident {
-            match tri!(self.next_char()) {
-                None => {
-                    return Err(self.error(ErrorCode::EofWhileParsingValue));
-                }
-                Some(next) => {
-                    if next != *expected {
-                        return Err(self.error(ErrorCode::ExpectedSomeIdent));
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
-        let next = match tri!(self.next_char()) {
-            Some(b) => b,
-            None => {
-                return Err(self.error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        match next {
-            b'0' => {
-                // There can be only one leading '0'.
-                match tri!(self.peek_or_null()) {
-                    b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
-                    _ => self.parse_number(positive, 0),
-                }
-            }
-            c @ b'1'..=b'9' => {
-                let mut significand = (c - b'0') as u64;
-
-                loop {
-                    match tri!(self.peek_or_null()) {
-                        c @ b'0'..=b'9' => {
-                            let digit = (c - b'0') as u64;
-
-                            // We need to be careful with overflow. If we can,
-                            // try to keep the number as a `u64` until we grow
-                            // too large. At that point, switch to parsing the
-                            // value as a `f64`.
-                            if overflow!(significand * 10 + digit, u64::max_value()) {
-                                return Ok(ParserNumber::F64(tri!(
-                                    self.parse_long_integer(positive, significand),
-                                )));
-                            }
-
-                            self.eat_char();
-                            significand = significand * 10 + digit;
-                        }
-                        _ => {
-                            return self.parse_number(positive, significand);
-                        }
-                    }
-                }
-            }
-            _ => Err(self.error(ErrorCode::InvalidNumber)),
-        }
-    }
-
-    fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
-        Ok(match tri!(self.peek_or_null()) {
-            b'.' => ParserNumber::F64(tri!(self.parse_decimal(positive, significand, 0))),
-            b'e' | b'E' => ParserNumber::F64(tri!(self.parse_exponent(positive, significand, 0))),
-            _ => {
-                if positive {
-                    ParserNumber::U64(significand)
-                } else {
-                    let neg = (significand as i64).wrapping_neg();
-
-                    // Convert into a float if we underflow, or on `-0`.
-                    if neg >= 0 {
-                        ParserNumber::F64(-(significand as f64))
-                    } else {
-                        ParserNumber::I64(neg)
-                    }
-                }
-            }
-        })
-    }
-
-    fn parse_decimal(
-        &mut self,
-        positive: bool,
-        mut significand: u64,
-        exponent_before_decimal_point: i32,
-    ) -> Result<f64> {
-        self.eat_char();
-
-        let mut exponent_after_decimal_point = 0;
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            let digit = (c - b'0') as u64;
-
-            if overflow!(significand * 10 + digit, u64::max_value()) {
-                let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
-                return self.parse_decimal_overflow(positive, significand, exponent);
-            }
-
-            self.eat_char();
-            significand = significand * 10 + digit;
-            exponent_after_decimal_point -= 1;
-        }
-
-        // Error if there is not at least one digit after the decimal point.
-        if exponent_after_decimal_point == 0 {
-            match tri!(self.peek()) {
-                Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
-                None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
-            }
-        }
-
-        let exponent = exponent_before_decimal_point + exponent_after_decimal_point;
-        match tri!(self.peek_or_null()) {
-            b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
-            _ => self.f64_from_parts(positive, significand, exponent),
-        }
-    }
-
-    fn parse_exponent(
-        &mut self,
-        positive: bool,
-        significand: u64,
-        starting_exp: i32,
-    ) -> Result<f64> {
-        self.eat_char();
-
-        let positive_exp = match tri!(self.peek_or_null()) {
-            b'+' => {
-                self.eat_char();
-                true
-            }
-            b'-' => {
-                self.eat_char();
-                false
-            }
-            _ => true,
-        };
-
-        let next = match tri!(self.next_char()) {
-            Some(b) => b,
-            None => {
-                return Err(self.error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        // Make sure a digit follows the exponent place.
-        let mut exp = match next {
-            c @ b'0'..=b'9' => (c - b'0') as i32,
-            _ => {
-                return Err(self.error(ErrorCode::InvalidNumber));
-            }
-        };
-
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-            let digit = (c - b'0') as i32;
-
-            if overflow!(exp * 10 + digit, i32::max_value()) {
-                let zero_significand = significand == 0;
-                return self.parse_exponent_overflow(positive, zero_significand, positive_exp);
-            }
-
-            exp = exp * 10 + digit;
-        }
-
-        let final_exp = if positive_exp {
-            starting_exp.saturating_add(exp)
-        } else {
-            starting_exp.saturating_sub(exp)
-        };
-
-        self.f64_from_parts(positive, significand, final_exp)
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    fn f64_from_parts(&mut self, positive: bool, significand: u64, exponent: i32) -> Result<f64> {
-        let f = if self.single_precision {
-            lexical::parse_concise_float::<f32>(significand, exponent) as f64
-        } else {
-            lexical::parse_concise_float::<f64>(significand, exponent)
-        };
-
-        if f.is_infinite() {
-            Err(self.error(ErrorCode::NumberOutOfRange))
-        } else {
-            Ok(if positive { f } else { -f })
-        }
-    }
-
-    #[cfg(not(feature = "float_roundtrip"))]
-    fn f64_from_parts(
-        &mut self,
-        positive: bool,
-        significand: u64,
-        mut exponent: i32,
-    ) -> Result<f64> {
-        let mut f = significand as f64;
-        loop {
-            match POW10.get(exponent.wrapping_abs() as usize) {
-                Some(&pow) => {
-                    if exponent >= 0 {
-                        f *= pow;
-                        if f.is_infinite() {
-                            return Err(self.error(ErrorCode::NumberOutOfRange));
-                        }
-                    } else {
-                        f /= pow;
-                    }
-                    break;
-                }
-                None => {
-                    if f == 0.0 {
-                        break;
-                    }
-                    if exponent >= 0 {
-                        return Err(self.error(ErrorCode::NumberOutOfRange));
-                    }
-                    f /= 1e308;
-                    exponent += 308;
-                }
-            }
-        }
-        Ok(if positive { f } else { -f })
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    #[cold]
-    #[inline(never)]
-    fn parse_long_integer(&mut self, positive: bool, partial_significand: u64) -> Result<f64> {
-        // To deserialize floats we'll first push the integer and fraction
-        // parts, both as byte strings, into the scratch buffer and then feed
-        // both slices to lexical's parser. For example if the input is
-        // `12.34e5` we'll push b"1234" into scratch and then pass b"12" and
-        // b"34" to lexical. `integer_end` will be used to track where to split
-        // the scratch buffer.
-        //
-        // Note that lexical expects the integer part to contain *no* leading
-        // zeroes and the fraction part to contain *no* trailing zeroes. The
-        // first requirement is already handled by the integer parsing logic.
-        // The second requirement will be enforced just before passing the
-        // slices to lexical in f64_long_from_parts.
-        self.scratch.clear();
-        self.scratch
-            .extend_from_slice(itoa::Buffer::new().format(partial_significand).as_bytes());
-
-        loop {
-            match tri!(self.peek_or_null()) {
-                c @ b'0'..=b'9' => {
-                    self.scratch.push(c);
-                    self.eat_char();
-                }
-                b'.' => {
-                    self.eat_char();
-                    return self.parse_long_decimal(positive, self.scratch.len());
-                }
-                b'e' | b'E' => {
-                    return self.parse_long_exponent(positive, self.scratch.len());
-                }
-                _ => {
-                    return self.f64_long_from_parts(positive, self.scratch.len(), 0);
-                }
-            }
-        }
-    }
-
-    #[cfg(not(feature = "float_roundtrip"))]
-    #[cold]
-    #[inline(never)]
-    fn parse_long_integer(&mut self, positive: bool, significand: u64) -> Result<f64> {
-        let mut exponent = 0;
-        loop {
-            match tri!(self.peek_or_null()) {
-                b'0'..=b'9' => {
-                    self.eat_char();
-                    // This could overflow... if your integer is gigabytes long.
-                    // Ignore that possibility.
-                    exponent += 1;
-                }
-                b'.' => {
-                    return self.parse_decimal(positive, significand, exponent);
-                }
-                b'e' | b'E' => {
-                    return self.parse_exponent(positive, significand, exponent);
-                }
-                _ => {
-                    return self.f64_from_parts(positive, significand, exponent);
-                }
-            }
-        }
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    #[cold]
-    fn parse_long_decimal(&mut self, positive: bool, integer_end: usize) -> Result<f64> {
-        let mut at_least_one_digit = integer_end < self.scratch.len();
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.scratch.push(c);
-            self.eat_char();
-            at_least_one_digit = true;
-        }
-
-        if !at_least_one_digit {
-            match tri!(self.peek()) {
-                Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
-                None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
-            }
-        }
-
-        match tri!(self.peek_or_null()) {
-            b'e' | b'E' => self.parse_long_exponent(positive, integer_end),
-            _ => self.f64_long_from_parts(positive, integer_end, 0),
-        }
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    fn parse_long_exponent(&mut self, positive: bool, integer_end: usize) -> Result<f64> {
-        self.eat_char();
-
-        let positive_exp = match tri!(self.peek_or_null()) {
-            b'+' => {
-                self.eat_char();
-                true
-            }
-            b'-' => {
-                self.eat_char();
-                false
-            }
-            _ => true,
-        };
-
-        let next = match tri!(self.next_char()) {
-            Some(b) => b,
-            None => {
-                return Err(self.error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        // Make sure a digit follows the exponent place.
-        let mut exp = match next {
-            c @ b'0'..=b'9' => (c - b'0') as i32,
-            _ => {
-                return Err(self.error(ErrorCode::InvalidNumber));
-            }
-        };
-
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-            let digit = (c - b'0') as i32;
-
-            if overflow!(exp * 10 + digit, i32::max_value()) {
-                let zero_significand = self.scratch.iter().all(|&digit| digit == b'0');
-                return self.parse_exponent_overflow(positive, zero_significand, positive_exp);
-            }
-
-            exp = exp * 10 + digit;
-        }
-
-        let final_exp = if positive_exp { exp } else { -exp };
-
-        self.f64_long_from_parts(positive, integer_end, final_exp)
-    }
-
-    // This cold code should not be inlined into the middle of the hot
-    // decimal-parsing loop above.
-    #[cfg(feature = "float_roundtrip")]
-    #[cold]
-    #[inline(never)]
-    fn parse_decimal_overflow(
-        &mut self,
-        positive: bool,
-        significand: u64,
-        exponent: i32,
-    ) -> Result<f64> {
-        let mut buffer = itoa::Buffer::new();
-        let significand = buffer.format(significand);
-        let fraction_digits = -exponent as usize;
-        self.scratch.clear();
-        if let Some(zeros) = fraction_digits.checked_sub(significand.len() + 1) {
-            self.scratch.extend(iter::repeat(b'0').take(zeros + 1));
-        }
-        self.scratch.extend_from_slice(significand.as_bytes());
-        let integer_end = self.scratch.len() - fraction_digits;
-        self.parse_long_decimal(positive, integer_end)
-    }
-
-    #[cfg(not(feature = "float_roundtrip"))]
-    #[cold]
-    #[inline(never)]
-    fn parse_decimal_overflow(
-        &mut self,
-        positive: bool,
-        significand: u64,
-        exponent: i32,
-    ) -> Result<f64> {
-        // The next multiply/add would overflow, so just ignore all further
-        // digits.
-        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-        }
-
-        match tri!(self.peek_or_null()) {
-            b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
-            _ => self.f64_from_parts(positive, significand, exponent),
-        }
-    }
-
-    // This cold code should not be inlined into the middle of the hot
-    // exponent-parsing loop above.
-    #[cold]
-    #[inline(never)]
-    fn parse_exponent_overflow(
-        &mut self,
-        positive: bool,
-        zero_significand: bool,
-        positive_exp: bool,
-    ) -> Result<f64> {
-        // Error instead of +/- infinity.
-        if !zero_significand && positive_exp {
-            return Err(self.error(ErrorCode::NumberOutOfRange));
-        }
-
-        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-        }
-        Ok(if positive { 0.0 } else { -0.0 })
-    }
-
-    #[cfg(feature = "float_roundtrip")]
-    fn f64_long_from_parts(
-        &mut self,
-        positive: bool,
-        integer_end: usize,
-        exponent: i32,
-    ) -> Result<f64> {
-        let integer = &self.scratch[..integer_end];
-        let fraction = &self.scratch[integer_end..];
-
-        let f = if self.single_precision {
-            lexical::parse_truncated_float::<f32>(integer, fraction, exponent) as f64
-        } else {
-            lexical::parse_truncated_float::<f64>(integer, fraction, exponent)
-        };
-
-        if f.is_infinite() {
-            Err(self.error(ErrorCode::NumberOutOfRange))
-        } else {
-            Ok(if positive { f } else { -f })
-        }
-    }
-
-    fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
-        let peek = match tri!(self.peek()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'-' => {
-                self.eat_char();
-                self.parse_any_number(false)
-            }
-            b'0'..=b'9' => self.parse_any_number(true),
-            _ => Err(self.peek_error(ErrorCode::InvalidNumber)),
-        };
-
-        let value = match tri!(self.peek()) {
-            Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
-            None => value,
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            // The de::Error impl creates errors with unknown line and column.
-            // Fill in the position here by looking at the current index in the
-            // input. There is no way to tell whether this should call `error`
-            // or `peek_error` so pick the one that seems correct more often.
-            // Worst case, the position is off by one character.
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    #[cfg(not(feature = "arbitrary_precision"))]
-    fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
-        self.parse_integer(positive)
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
-        let mut buf = String::with_capacity(16);
-        if !positive {
-            buf.push('-');
-        }
-        tri!(self.scan_integer(&mut buf));
-        if positive {
-            if let Ok(unsigned) = buf.parse() {
-                return Ok(ParserNumber::U64(unsigned));
-            }
-        } else {
-            if let Ok(signed) = buf.parse() {
-                return Ok(ParserNumber::I64(signed));
-            }
-        }
-        Ok(ParserNumber::String(buf))
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn scan_or_eof(&mut self, buf: &mut String) -> Result<u8> {
-        match tri!(self.next_char()) {
-            Some(b) => {
-                buf.push(b as char);
-                Ok(b)
-            }
-            None => Err(self.error(ErrorCode::EofWhileParsingValue)),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
-        match tri!(self.scan_or_eof(buf)) {
-            b'0' => {
-                // There can be only one leading '0'.
-                match tri!(self.peek_or_null()) {
-                    b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
-                    _ => self.scan_number(buf),
-                }
-            }
-            b'1'..=b'9' => loop {
-                match tri!(self.peek_or_null()) {
-                    c @ b'0'..=b'9' => {
-                        self.eat_char();
-                        buf.push(c as char);
-                    }
-                    _ => {
-                        return self.scan_number(buf);
-                    }
-                }
-            },
-            _ => Err(self.error(ErrorCode::InvalidNumber)),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn scan_number(&mut self, buf: &mut String) -> Result<()> {
-        match tri!(self.peek_or_null()) {
-            b'.' => self.scan_decimal(buf),
-            e @ (b'e' | b'E') => self.scan_exponent(e as char, buf),
-            _ => Ok(()),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn scan_decimal(&mut self, buf: &mut String) -> Result<()> {
-        self.eat_char();
-        buf.push('.');
-
-        let mut at_least_one_digit = false;
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-            buf.push(c as char);
-            at_least_one_digit = true;
-        }
-
-        if !at_least_one_digit {
-            match tri!(self.peek()) {
-                Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)),
-                None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
-            }
-        }
-
-        match tri!(self.peek_or_null()) {
-            e @ (b'e' | b'E') => self.scan_exponent(e as char, buf),
-            _ => Ok(()),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn scan_exponent(&mut self, e: char, buf: &mut String) -> Result<()> {
-        self.eat_char();
-        buf.push(e);
-
-        match tri!(self.peek_or_null()) {
-            b'+' => {
-                self.eat_char();
-                buf.push('+');
-            }
-            b'-' => {
-                self.eat_char();
-                buf.push('-');
-            }
-            _ => {}
-        }
-
-        // Make sure a digit follows the exponent place.
-        match tri!(self.scan_or_eof(buf)) {
-            b'0'..=b'9' => {}
-            _ => {
-                return Err(self.error(ErrorCode::InvalidNumber));
-            }
-        }
-
-        while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-            buf.push(c as char);
-        }
-
-        Ok(())
-    }
-
-    fn parse_object_colon(&mut self) -> Result<()> {
-        match tri!(self.parse_whitespace()) {
-            Some(b':') => {
-                self.eat_char();
-                Ok(())
-            }
-            Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
-            None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
-        }
-    }
-
-    fn end_seq(&mut self) -> Result<()> {
-        match tri!(self.parse_whitespace()) {
-            Some(b']') => {
-                self.eat_char();
-                Ok(())
-            }
-            Some(b',') => {
-                self.eat_char();
-                match self.parse_whitespace() {
-                    Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)),
-                    _ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
-                }
-            }
-            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
-            None => Err(self.peek_error(ErrorCode::EofWhileParsingList)),
-        }
-    }
-
-    fn end_map(&mut self) -> Result<()> {
-        match tri!(self.parse_whitespace()) {
-            Some(b'}') => {
-                self.eat_char();
-                Ok(())
-            }
-            Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
-            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
-            None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
-        }
-    }
-
-    fn ignore_value(&mut self) -> Result<()> {
-        self.scratch.clear();
-        let mut enclosing = None;
-
-        loop {
-            let peek = match tri!(self.parse_whitespace()) {
-                Some(b) => b,
-                None => {
-                    return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-                }
-            };
-
-            let frame = match peek {
-                b'n' => {
-                    self.eat_char();
-                    tri!(self.parse_ident(b"ull"));
-                    None
-                }
-                b't' => {
-                    self.eat_char();
-                    tri!(self.parse_ident(b"rue"));
-                    None
-                }
-                b'f' => {
-                    self.eat_char();
-                    tri!(self.parse_ident(b"alse"));
-                    None
-                }
-                b'-' => {
-                    self.eat_char();
-                    tri!(self.ignore_integer());
-                    None
-                }
-                b'0'..=b'9' => {
-                    tri!(self.ignore_integer());
-                    None
-                }
-                b'"' => {
-                    self.eat_char();
-                    tri!(self.read.ignore_str());
-                    None
-                }
-                frame @ (b'[' | b'{') => {
-                    self.scratch.extend(enclosing.take());
-                    self.eat_char();
-                    Some(frame)
-                }
-                _ => return Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
-            };
-
-            let (mut accept_comma, mut frame) = match frame {
-                Some(frame) => (false, frame),
-                None => match enclosing.take() {
-                    Some(frame) => (true, frame),
-                    None => match self.scratch.pop() {
-                        Some(frame) => (true, frame),
-                        None => return Ok(()),
-                    },
-                },
-            };
-
-            loop {
-                match tri!(self.parse_whitespace()) {
-                    Some(b',') if accept_comma => {
-                        self.eat_char();
-                        break;
-                    }
-                    Some(b']') if frame == b'[' => {}
-                    Some(b'}') if frame == b'{' => {}
-                    Some(_) => {
-                        if accept_comma {
-                            return Err(self.peek_error(match frame {
-                                b'[' => ErrorCode::ExpectedListCommaOrEnd,
-                                b'{' => ErrorCode::ExpectedObjectCommaOrEnd,
-                                _ => unreachable!(),
-                            }));
-                        } else {
-                            break;
-                        }
-                    }
-                    None => {
-                        return Err(self.peek_error(match frame {
-                            b'[' => ErrorCode::EofWhileParsingList,
-                            b'{' => ErrorCode::EofWhileParsingObject,
-                            _ => unreachable!(),
-                        }));
-                    }
-                }
-
-                self.eat_char();
-                frame = match self.scratch.pop() {
-                    Some(frame) => frame,
-                    None => return Ok(()),
-                };
-                accept_comma = true;
-            }
-
-            if frame == b'{' {
-                match tri!(self.parse_whitespace()) {
-                    Some(b'"') => self.eat_char(),
-                    Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
-                    None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
-                }
-                tri!(self.read.ignore_str());
-                match tri!(self.parse_whitespace()) {
-                    Some(b':') => self.eat_char(),
-                    Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
-                    None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
-                }
-            }
-
-            enclosing = Some(frame);
-        }
-    }
-
-    fn ignore_integer(&mut self) -> Result<()> {
-        match tri!(self.next_char_or_null()) {
-            b'0' => {
-                // There can be only one leading '0'.
-                if let b'0'..=b'9' = tri!(self.peek_or_null()) {
-                    return Err(self.peek_error(ErrorCode::InvalidNumber));
-                }
-            }
-            b'1'..=b'9' => {
-                while let b'0'..=b'9' = tri!(self.peek_or_null()) {
-                    self.eat_char();
-                }
-            }
-            _ => {
-                return Err(self.error(ErrorCode::InvalidNumber));
-            }
-        }
-
-        match tri!(self.peek_or_null()) {
-            b'.' => self.ignore_decimal(),
-            b'e' | b'E' => self.ignore_exponent(),
-            _ => Ok(()),
-        }
-    }
-
-    fn ignore_decimal(&mut self) -> Result<()> {
-        self.eat_char();
-
-        let mut at_least_one_digit = false;
-        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-            at_least_one_digit = true;
-        }
-
-        if !at_least_one_digit {
-            return Err(self.peek_error(ErrorCode::InvalidNumber));
-        }
-
-        match tri!(self.peek_or_null()) {
-            b'e' | b'E' => self.ignore_exponent(),
-            _ => Ok(()),
-        }
-    }
-
-    fn ignore_exponent(&mut self) -> Result<()> {
-        self.eat_char();
-
-        match tri!(self.peek_or_null()) {
-            b'+' | b'-' => self.eat_char(),
-            _ => {}
-        }
-
-        // Make sure a digit follows the exponent place.
-        match tri!(self.next_char_or_null()) {
-            b'0'..=b'9' => {}
-            _ => {
-                return Err(self.error(ErrorCode::InvalidNumber));
-            }
-        }
-
-        while let b'0'..=b'9' = tri!(self.peek_or_null()) {
-            self.eat_char();
-        }
-
-        Ok(())
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn deserialize_raw_value<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        tri!(self.parse_whitespace());
-        self.read.begin_raw_buffering();
-        tri!(self.ignore_value());
-        self.read.end_raw_buffering(visitor)
-    }
-}
-
-impl FromStr for Number {
-    type Err = Error;
-
-    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-        Deserializer::from_str(s)
-            .parse_any_signed_number()
-            .map(Into::into)
-    }
-}
-
-#[cfg(not(feature = "float_roundtrip"))]
-static POW10: [f64; 309] = [
-    1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, //
-    1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, //
-    1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, //
-    1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, //
-    1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049, //
-    1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059, //
-    1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069, //
-    1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079, //
-    1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089, //
-    1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099, //
-    1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, //
-    1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, //
-    1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, //
-    1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, //
-    1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, //
-    1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, //
-    1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169, //
-    1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179, //
-    1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189, //
-    1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199, //
-    1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209, //
-    1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219, //
-    1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, //
-    1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, //
-    1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, //
-    1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, //
-    1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269, //
-    1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279, //
-    1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289, //
-    1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299, //
-    1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308,
-];
-
-macro_rules! deserialize_number {
-    ($method:ident) => {
-        deserialize_number!($method, deserialize_number);
-    };
-
-    ($method:ident, $using:ident) => {
-        fn $method<V>(self, visitor: V) -> Result<V::Value>
-        where
-            V: de::Visitor<'de>,
-        {
-            self.$using(visitor)
-        }
-    };
-}
-
-#[cfg(not(feature = "unbounded_depth"))]
-macro_rules! if_checking_recursion_limit {
-    ($($body:tt)*) => {
-        $($body)*
-    };
-}
-
-#[cfg(feature = "unbounded_depth")]
-macro_rules! if_checking_recursion_limit {
-    ($this:ident $($body:tt)*) => {
-        if !$this.disable_recursion_limit {
-            $this $($body)*
-        }
-    };
-}
-
-macro_rules! check_recursion {
-    ($this:ident $($body:tt)*) => {
-        if_checking_recursion_limit! {
-            $this.remaining_depth -= 1;
-            if $this.remaining_depth == 0 {
-                return Err($this.peek_error(ErrorCode::RecursionLimitExceeded));
-            }
-        }
-
-        $this $($body)*
-
-        if_checking_recursion_limit! {
-            $this.remaining_depth += 1;
-        }
-    };
-}
-
-impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
-    type Error = Error;
-
-    #[inline]
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'n' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"ull"));
-                visitor.visit_unit()
-            }
-            b't' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"rue"));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"alse"));
-                visitor.visit_bool(false)
-            }
-            b'-' => {
-                self.eat_char();
-                tri!(self.parse_any_number(false)).visit(visitor)
-            }
-            b'0'..=b'9' => tri!(self.parse_any_number(true)).visit(visitor),
-            b'"' => {
-                self.eat_char();
-                self.scratch.clear();
-                match tri!(self.read.parse_str(&mut self.scratch)) {
-                    Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
-                    Reference::Copied(s) => visitor.visit_str(s),
-                }
-            }
-            b'[' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_seq(SeqAccess::new(self));
-                }
-
-                match (ret, self.end_seq()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            b'{' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_map(MapAccess::new(self));
-                }
-
-                match (ret, self.end_map()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            // The de::Error impl creates errors with unknown line and column.
-            // Fill in the position here by looking at the current index in the
-            // input. There is no way to tell whether this should call `error`
-            // or `peek_error` so pick the one that seems correct more often.
-            // Worst case, the position is off by one character.
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b't' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"rue"));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"alse"));
-                visitor.visit_bool(false)
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    deserialize_number!(deserialize_i8);
-    deserialize_number!(deserialize_i16);
-    deserialize_number!(deserialize_i32);
-    deserialize_number!(deserialize_i64);
-    deserialize_number!(deserialize_u8);
-    deserialize_number!(deserialize_u16);
-    deserialize_number!(deserialize_u32);
-    deserialize_number!(deserialize_u64);
-    #[cfg(not(feature = "float_roundtrip"))]
-    deserialize_number!(deserialize_f32);
-    deserialize_number!(deserialize_f64);
-
-    #[cfg(feature = "float_roundtrip")]
-    deserialize_number!(deserialize_f32, do_deserialize_f32);
-    deserialize_number!(deserialize_i128, do_deserialize_i128);
-    deserialize_number!(deserialize_u128, do_deserialize_u128);
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'"' => {
-                self.eat_char();
-                self.scratch.clear();
-                match tri!(self.read.parse_str(&mut self.scratch)) {
-                    Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
-                    Reference::Copied(s) => visitor.visit_str(s),
-                }
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    /// Parses a JSON string as bytes. Note that this function does not check
-    /// whether the bytes represent a valid UTF-8 string.
-    ///
-    /// The relevant part of the JSON specification is Section 8.2 of [RFC
-    /// 7159]:
-    ///
-    /// > When all the strings represented in a JSON text are composed entirely
-    /// > of Unicode characters (however escaped), then that JSON text is
-    /// > interoperable in the sense that all software implementations that
-    /// > parse it will agree on the contents of names and of string values in
-    /// > objects and arrays.
-    /// >
-    /// > However, the ABNF in this specification allows member names and string
-    /// > values to contain bit sequences that cannot encode Unicode characters;
-    /// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances
-    /// > of this have been observed, for example, when a library truncates a
-    /// > UTF-16 string without checking whether the truncation split a
-    /// > surrogate pair.  The behavior of software that receives JSON texts
-    /// > containing such values is unpredictable; for example, implementations
-    /// > might return different values for the length of a string value or even
-    /// > suffer fatal runtime exceptions.
-    ///
-    /// [RFC 7159]: https://tools.ietf.org/html/rfc7159
-    ///
-    /// The behavior of serde_json is specified to fail on non-UTF-8 strings
-    /// when deserializing into Rust UTF-8 string types such as String, and
-    /// succeed with non-UTF-8 bytes when deserializing using this method.
-    ///
-    /// Escape sequences are processed as usual, and for `\uXXXX` escapes it is
-    /// still checked if the hex number represents a valid Unicode code point.
-    ///
-    /// # Examples
-    ///
-    /// You can use this to parse JSON strings containing invalid UTF-8 bytes,
-    /// or unpaired surrogates.
-    ///
-    /// ```
-    /// use serde_bytes::ByteBuf;
-    ///
-    /// fn look_at_bytes() -> Result<(), serde_json::Error> {
-    ///     let json_data = b"\"some bytes: \xe5\x00\xe5\"";
-    ///     let bytes: ByteBuf = serde_json::from_slice(json_data)?;
-    ///
-    ///     assert_eq!(b'\xe5', bytes[12]);
-    ///     assert_eq!(b'\0', bytes[13]);
-    ///     assert_eq!(b'\xe5', bytes[14]);
-    ///
-    ///     Ok(())
-    /// }
-    /// #
-    /// # look_at_bytes().unwrap();
-    /// ```
-    ///
-    /// Backslash escape sequences like `\n` are still interpreted and required
-    /// to be valid. `\u` escape sequences are required to represent a valid
-    /// Unicode code point or lone surrogate.
-    ///
-    /// ```
-    /// use serde_bytes::ByteBuf;
-    ///
-    /// fn look_at_bytes() -> Result<(), serde_json::Error> {
-    ///     let json_data = b"\"lone surrogate: \\uD801\"";
-    ///     let bytes: ByteBuf = serde_json::from_slice(json_data)?;
-    ///     let expected = b"lone surrogate: \xED\xA0\x81";
-    ///     assert_eq!(expected, bytes.as_slice());
-    ///     Ok(())
-    /// }
-    /// #
-    /// # look_at_bytes();
-    /// ```
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'"' => {
-                self.eat_char();
-                self.scratch.clear();
-                match tri!(self.read.parse_str_raw(&mut self.scratch)) {
-                    Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
-                    Reference::Copied(b) => visitor.visit_bytes(b),
-                }
-            }
-            b'[' => self.deserialize_seq(visitor),
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    #[inline]
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_bytes(visitor)
-    }
-
-    /// Parses a `null` as a None, and any other values as a `Some(...)`.
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        match tri!(self.parse_whitespace()) {
-            Some(b'n') => {
-                self.eat_char();
-                tri!(self.parse_ident(b"ull"));
-                visitor.visit_none()
-            }
-            _ => visitor.visit_some(self),
-        }
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'n' => {
-                self.eat_char();
-                tri!(self.parse_ident(b"ull"));
-                visitor.visit_unit()
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_unit(visitor)
-    }
-
-    /// Parses a newtype struct as the underlying value.
-    #[inline]
-    fn deserialize_newtype_struct<V>(self, name: &str, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return self.deserialize_raw_value(visitor);
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'[' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_seq(SeqAccess::new(self));
-                }
-
-                match (ret, self.end_seq()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'{' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_map(MapAccess::new(self));
-                }
-
-                match (ret, self.end_map()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        let peek = match tri!(self.parse_whitespace()) {
-            Some(b) => b,
-            None => {
-                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b'[' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_seq(SeqAccess::new(self));
-                }
-
-                match (ret, self.end_seq()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            b'{' => {
-                check_recursion! {
-                    self.eat_char();
-                    let ret = visitor.visit_map(MapAccess::new(self));
-                }
-
-                match (ret, self.end_map()) {
-                    (Ok(ret), Ok(())) => Ok(ret),
-                    (Err(err), _) | (_, Err(err)) => Err(err),
-                }
-            }
-            _ => Err(self.peek_invalid_type(&visitor)),
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.fix_position(err)),
-        }
-    }
-
-    /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
-    /// value, a `[..]`, or a `{..}`.
-    #[inline]
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        match tri!(self.parse_whitespace()) {
-            Some(b'{') => {
-                check_recursion! {
-                    self.eat_char();
-                    let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
-                }
-
-                match tri!(self.parse_whitespace()) {
-                    Some(b'}') => {
-                        self.eat_char();
-                        Ok(value)
-                    }
-                    Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
-                    None => Err(self.error(ErrorCode::EofWhileParsingObject)),
-                }
-            }
-            Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
-            Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
-            None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
-        }
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        tri!(self.ignore_value());
-        visitor.visit_unit()
-    }
-}
-
-struct SeqAccess<'a, R: 'a> {
-    de: &'a mut Deserializer<R>,
-    first: bool,
-}
-
-impl<'a, R: 'a> SeqAccess<'a, R> {
-    fn new(de: &'a mut Deserializer<R>) -> Self {
-        SeqAccess { de, first: true }
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let peek = match tri!(self.de.parse_whitespace()) {
-            Some(b']') => {
-                return Ok(None);
-            }
-            Some(b',') if !self.first => {
-                self.de.eat_char();
-                tri!(self.de.parse_whitespace())
-            }
-            Some(b) => {
-                if self.first {
-                    self.first = false;
-                    Some(b)
-                } else {
-                    return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
-                }
-            }
-            None => {
-                return Err(self.de.peek_error(ErrorCode::EofWhileParsingList));
-            }
-        };
-
-        match peek {
-            Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
-            Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
-            None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
-        }
-    }
-}
-
-struct MapAccess<'a, R: 'a> {
-    de: &'a mut Deserializer<R>,
-    first: bool,
-}
-
-impl<'a, R: 'a> MapAccess<'a, R> {
-    fn new(de: &'a mut Deserializer<R>) -> Self {
-        MapAccess { de, first: true }
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        let peek = match tri!(self.de.parse_whitespace()) {
-            Some(b'}') => {
-                return Ok(None);
-            }
-            Some(b',') if !self.first => {
-                self.de.eat_char();
-                tri!(self.de.parse_whitespace())
-            }
-            Some(b) => {
-                if self.first {
-                    self.first = false;
-                    Some(b)
-                } else {
-                    return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
-                }
-            }
-            None => {
-                return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
-            }
-        };
-
-        match peek {
-            Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
-            Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
-            Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
-            None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
-        }
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        tri!(self.de.parse_object_colon());
-
-        seed.deserialize(&mut *self.de)
-    }
-}
-
-struct VariantAccess<'a, R: 'a> {
-    de: &'a mut Deserializer<R>,
-}
-
-impl<'a, R: 'a> VariantAccess<'a, R> {
-    fn new(de: &'a mut Deserializer<R>) -> Self {
-        VariantAccess { de }
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
-    type Error = Error;
-    type Variant = Self;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        let val = tri!(seed.deserialize(&mut *self.de));
-        tri!(self.de.parse_object_colon());
-        Ok((val, self))
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<()> {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self.de)
-    }
-
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        de::Deserializer::deserialize_seq(self.de, visitor)
-    }
-
-    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        de::Deserializer::deserialize_struct(self.de, "", fields, visitor)
-    }
-}
-
-struct UnitVariantAccess<'a, R: 'a> {
-    de: &'a mut Deserializer<R>,
-}
-
-impl<'a, R: 'a> UnitVariantAccess<'a, R> {
-    fn new(de: &'a mut Deserializer<R>) -> Self {
-        UnitVariantAccess { de }
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> {
-    type Error = Error;
-    type Variant = Self;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        let variant = tri!(seed.deserialize(&mut *self.de));
-        Ok((variant, self))
-    }
-}
-
-impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<()> {
-        Ok(())
-    }
-
-    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"newtype variant",
-        ))
-    }
-
-    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"tuple variant",
-        ))
-    }
-
-    fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"struct variant",
-        ))
-    }
-}
-
-/// Only deserialize from this after peeking a '"' byte! Otherwise it may
-/// deserialize invalid JSON successfully.
-struct MapKey<'a, R: 'a> {
-    de: &'a mut Deserializer<R>,
-}
-
-macro_rules! deserialize_numeric_key {
-    ($method:ident) => {
-        fn $method<V>(self, visitor: V) -> Result<V::Value>
-        where
-            V: de::Visitor<'de>,
-        {
-            self.deserialize_number(visitor)
-        }
-    };
-
-    ($method:ident, $delegate:ident) => {
-        fn $method<V>(self, visitor: V) -> Result<V::Value>
-        where
-            V: de::Visitor<'de>,
-        {
-            self.de.eat_char();
-
-            match tri!(self.de.peek()) {
-                Some(b'0'..=b'9' | b'-') => {}
-                _ => return Err(self.de.error(ErrorCode::ExpectedNumericKey)),
-            }
-
-            let value = tri!(self.de.$delegate(visitor));
-
-            match tri!(self.de.peek()) {
-                Some(b'"') => self.de.eat_char(),
-                _ => return Err(self.de.peek_error(ErrorCode::ExpectedDoubleQuote)),
-            }
-
-            Ok(value)
-        }
-    };
-}
-
-impl<'de, 'a, R> MapKey<'a, R>
-where
-    R: Read<'de>,
-{
-    deserialize_numeric_key!(deserialize_number, deserialize_number);
-}
-
-impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R>
-where
-    R: Read<'de>,
-{
-    type Error = Error;
-
-    #[inline]
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.de.eat_char();
-        self.de.scratch.clear();
-        match tri!(self.de.read.parse_str(&mut self.de.scratch)) {
-            Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
-            Reference::Copied(s) => visitor.visit_str(s),
-        }
-    }
-
-    deserialize_numeric_key!(deserialize_i8);
-    deserialize_numeric_key!(deserialize_i16);
-    deserialize_numeric_key!(deserialize_i32);
-    deserialize_numeric_key!(deserialize_i64);
-    deserialize_numeric_key!(deserialize_i128, deserialize_i128);
-    deserialize_numeric_key!(deserialize_u8);
-    deserialize_numeric_key!(deserialize_u16);
-    deserialize_numeric_key!(deserialize_u32);
-    deserialize_numeric_key!(deserialize_u64);
-    deserialize_numeric_key!(deserialize_u128, deserialize_u128);
-    #[cfg(not(feature = "float_roundtrip"))]
-    deserialize_numeric_key!(deserialize_f32);
-    #[cfg(feature = "float_roundtrip")]
-    deserialize_numeric_key!(deserialize_f32, deserialize_f32);
-    deserialize_numeric_key!(deserialize_f64);
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.de.eat_char();
-
-        let peek = match tri!(self.de.next_char()) {
-            Some(b) => b,
-            None => {
-                return Err(self.de.peek_error(ErrorCode::EofWhileParsingValue));
-            }
-        };
-
-        let value = match peek {
-            b't' => {
-                tri!(self.de.parse_ident(b"rue\""));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                tri!(self.de.parse_ident(b"alse\""));
-                visitor.visit_bool(false)
-            }
-            _ => {
-                self.de.scratch.clear();
-                let s = tri!(self.de.read.parse_str(&mut self.de.scratch));
-                Err(de::Error::invalid_type(Unexpected::Str(&s), &visitor))
-            }
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(err) => Err(self.de.fix_position(err)),
-        }
-    }
-
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        // Map keys cannot be null.
-        visitor.visit_some(self)
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return self.de.deserialize_raw_value(visitor);
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    #[inline]
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.de.deserialize_enum(name, variants, visitor)
-    }
-
-    #[inline]
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.de.deserialize_bytes(visitor)
-    }
-
-    #[inline]
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.de.deserialize_bytes(visitor)
-    }
-
-    forward_to_deserialize_any! {
-        char str string unit unit_struct seq tuple tuple_struct map struct
-        identifier ignored_any
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// Iterator that deserializes a stream into multiple JSON values.
-///
-/// A stream deserializer can be created from any JSON deserializer using the
-/// `Deserializer::into_iter` method.
-///
-/// The data can consist of any JSON value. Values need to be a self-delineating value e.g.
-/// arrays, objects, or strings, or be followed by whitespace or a self-delineating value.
-///
-/// ```
-/// use serde_json::{Deserializer, Value};
-///
-/// fn main() {
-///     let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{}  [0, 1, 2]";
-///
-///     let stream = Deserializer::from_str(data).into_iter::<Value>();
-///
-///     for value in stream {
-///         println!("{}", value.unwrap());
-///     }
-/// }
-/// ```
-pub struct StreamDeserializer<'de, R, T> {
-    de: Deserializer<R>,
-    offset: usize,
-    failed: bool,
-    output: PhantomData<T>,
-    lifetime: PhantomData<&'de ()>,
-}
-
-impl<'de, R, T> StreamDeserializer<'de, R, T>
-where
-    R: read::Read<'de>,
-    T: de::Deserialize<'de>,
-{
-    /// Create a JSON stream deserializer from one of the possible serde_json
-    /// input sources.
-    ///
-    /// Typically it is more convenient to use one of these methods instead:
-    ///
-    ///   - Deserializer::from_str(...).into_iter()
-    ///   - Deserializer::from_slice(...).into_iter()
-    ///   - Deserializer::from_reader(...).into_iter()
-    pub fn new(read: R) -> Self {
-        let offset = read.byte_offset();
-        StreamDeserializer {
-            de: Deserializer::new(read),
-            offset,
-            failed: false,
-            output: PhantomData,
-            lifetime: PhantomData,
-        }
-    }
-
-    /// Returns the number of bytes so far deserialized into a successful `T`.
-    ///
-    /// If a stream deserializer returns an EOF error, new data can be joined to
-    /// `old_data[stream.byte_offset()..]` to try again.
-    ///
-    /// ```
-    /// let data = b"[0] [1] [";
-    ///
-    /// let de = serde_json::Deserializer::from_slice(data);
-    /// let mut stream = de.into_iter::<Vec<i32>>();
-    /// assert_eq!(0, stream.byte_offset());
-    ///
-    /// println!("{:?}", stream.next()); // [0]
-    /// assert_eq!(3, stream.byte_offset());
-    ///
-    /// println!("{:?}", stream.next()); // [1]
-    /// assert_eq!(7, stream.byte_offset());
-    ///
-    /// println!("{:?}", stream.next()); // error
-    /// assert_eq!(8, stream.byte_offset());
-    ///
-    /// // If err.is_eof(), can join the remaining data to new data and continue.
-    /// let remaining = &data[stream.byte_offset()..];
-    /// ```
-    ///
-    /// *Note:* In the future this method may be changed to return the number of
-    /// bytes so far deserialized into a successful T *or* syntactically valid
-    /// JSON skipped over due to a type error. See [serde-rs/json#70] for an
-    /// example illustrating this.
-    ///
-    /// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70
-    pub fn byte_offset(&self) -> usize {
-        self.offset
-    }
-
-    fn peek_end_of_value(&mut self) -> Result<()> {
-        match tri!(self.de.peek()) {
-            Some(b' ' | b'\n' | b'\t' | b'\r' | b'"' | b'[' | b']' | b'{' | b'}' | b',' | b':')
-            | None => Ok(()),
-            Some(_) => {
-                let position = self.de.read.peek_position();
-                Err(Error::syntax(
-                    ErrorCode::TrailingCharacters,
-                    position.line,
-                    position.column,
-                ))
-            }
-        }
-    }
-}
-
-impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
-where
-    R: Read<'de>,
-    T: de::Deserialize<'de>,
-{
-    type Item = Result<T>;
-
-    fn next(&mut self) -> Option<Result<T>> {
-        if R::should_early_return_if_failed && self.failed {
-            return None;
-        }
-
-        // skip whitespaces, if any
-        // this helps with trailing whitespaces, since whitespaces between
-        // values are handled for us.
-        match self.de.parse_whitespace() {
-            Ok(None) => {
-                self.offset = self.de.read.byte_offset();
-                None
-            }
-            Ok(Some(b)) => {
-                // If the value does not have a clear way to show the end of the value
-                // (like numbers, null, true etc.) we have to look for whitespace or
-                // the beginning of a self-delineated value.
-                let self_delineated_value = match b {
-                    b'[' | b'"' | b'{' => true,
-                    _ => false,
-                };
-                self.offset = self.de.read.byte_offset();
-                let result = de::Deserialize::deserialize(&mut self.de);
-
-                Some(match result {
-                    Ok(value) => {
-                        self.offset = self.de.read.byte_offset();
-                        if self_delineated_value {
-                            Ok(value)
-                        } else {
-                            self.peek_end_of_value().map(|()| value)
-                        }
-                    }
-                    Err(e) => {
-                        self.de.read.set_failed(&mut self.failed);
-                        Err(e)
-                    }
-                })
-            }
-            Err(e) => {
-                self.de.read.set_failed(&mut self.failed);
-                Some(Err(e))
-            }
-        }
-    }
-}
-
-impl<'de, R, T> FusedIterator for StreamDeserializer<'de, R, T>
-where
-    R: Read<'de> + Fused,
-    T: de::Deserialize<'de>,
-{
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-fn from_trait<'de, R, T>(read: R) -> Result<T>
-where
-    R: Read<'de>,
-    T: de::Deserialize<'de>,
-{
-    let mut de = Deserializer::new(read);
-    let value = tri!(de::Deserialize::deserialize(&mut de));
-
-    // Make sure the whole stream has been consumed.
-    tri!(de.end());
-    Ok(value)
-}
-
-/// Deserialize an instance of type `T` from an I/O stream of JSON.
-///
-/// The content of the I/O stream is deserialized directly from the stream
-/// without being buffered in memory by serde_json.
-///
-/// When reading from a source against which short reads are not efficient, such
-/// as a [`File`], you will want to apply your own buffering because serde_json
-/// will not buffer the input. See [`std::io::BufReader`].
-///
-/// It is expected that the input stream ends after the deserialized object.
-/// If the stream does not end, such as in the case of a persistent socket connection,
-/// this function will not return. It is possible instead to deserialize from a prefix of an input
-/// stream without looking for EOF by managing your own [`Deserializer`].
-///
-/// Note that counter to intuition, this function is usually slower than
-/// reading a file completely into memory and then applying [`from_str`]
-/// or [`from_slice`] on it. See [issue #160].
-///
-/// [`File`]: https://doc.rust-lang.org/std/fs/struct.File.html
-/// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html
-/// [`from_str`]: ./fn.from_str.html
-/// [`from_slice`]: ./fn.from_slice.html
-/// [issue #160]: https://github.com/serde-rs/json/issues/160
-///
-/// # Example
-///
-/// Reading the contents of a file.
-///
-/// ```
-/// use serde::Deserialize;
-///
-/// use std::error::Error;
-/// use std::fs::File;
-/// use std::io::BufReader;
-/// use std::path::Path;
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> {
-///     // Open the file in read-only mode with buffer.
-///     let file = File::open(path)?;
-///     let reader = BufReader::new(file);
-///
-///     // Read the JSON contents of the file as an instance of `User`.
-///     let u = serde_json::from_reader(reader)?;
-///
-///     // Return the `User`.
-///     Ok(u)
-/// }
-///
-/// fn main() {
-/// # }
-/// # fn fake_main() {
-///     let u = read_user_from_file("test.json").unwrap();
-///     println!("{:#?}", u);
-/// }
-/// ```
-///
-/// Reading from a persistent socket connection.
-///
-/// ```
-/// use serde::Deserialize;
-///
-/// use std::error::Error;
-/// use std::net::{TcpListener, TcpStream};
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn read_user_from_stream(tcp_stream: TcpStream) -> Result<User, Box<dyn Error>> {
-///     let mut de = serde_json::Deserializer::from_reader(tcp_stream);
-///     let u = User::deserialize(&mut de)?;
-///
-///     Ok(u)
-/// }
-///
-/// fn main() {
-/// # }
-/// # fn fake_main() {
-///     let listener = TcpListener::bind("127.0.0.1:4000").unwrap();
-///
-///     for stream in listener.incoming() {
-///         println!("{:#?}", read_user_from_stream(stream.unwrap()));
-///     }
-/// }
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if the structure of the input does not match the
-/// structure expected by `T`, for example if `T` is a struct type but the input
-/// contains something other than a JSON map. It can also fail if the structure
-/// is correct but `T`'s implementation of `Deserialize` decides that something
-/// is wrong with the data, for example required struct fields are missing from
-/// the JSON map or some number is too big to fit in the expected primitive
-/// type.
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub fn from_reader<R, T>(rdr: R) -> Result<T>
-where
-    R: crate::io::Read,
-    T: de::DeserializeOwned,
-{
-    from_trait(read::IoRead::new(rdr))
-}
-
-/// Deserialize an instance of type `T` from bytes of JSON text.
-///
-/// # Example
-///
-/// ```
-/// use serde::Deserialize;
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn main() {
-///     // The type of `j` is `&[u8]`
-///     let j = b"
-///         {
-///             \"fingerprint\": \"0xF9BA143B95FF6D82\",
-///             \"location\": \"Menlo Park, CA\"
-///         }";
-///
-///     let u: User = serde_json::from_slice(j).unwrap();
-///     println!("{:#?}", u);
-/// }
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if the structure of the input does not match the
-/// structure expected by `T`, for example if `T` is a struct type but the input
-/// contains something other than a JSON map. It can also fail if the structure
-/// is correct but `T`'s implementation of `Deserialize` decides that something
-/// is wrong with the data, for example required struct fields are missing from
-/// the JSON map or some number is too big to fit in the expected primitive
-/// type.
-pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
-where
-    T: de::Deserialize<'a>,
-{
-    from_trait(read::SliceRead::new(v))
-}
-
-/// Deserialize an instance of type `T` from a string of JSON text.
-///
-/// # Example
-///
-/// ```
-/// use serde::Deserialize;
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn main() {
-///     // The type of `j` is `&str`
-///     let j = "
-///         {
-///             \"fingerprint\": \"0xF9BA143B95FF6D82\",
-///             \"location\": \"Menlo Park, CA\"
-///         }";
-///
-///     let u: User = serde_json::from_str(j).unwrap();
-///     println!("{:#?}", u);
-/// }
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if the structure of the input does not match the
-/// structure expected by `T`, for example if `T` is a struct type but the input
-/// contains something other than a JSON map. It can also fail if the structure
-/// is correct but `T`'s implementation of `Deserialize` decides that something
-/// is wrong with the data, for example required struct fields are missing from
-/// the JSON map or some number is too big to fit in the expected primitive
-/// type.
-pub fn from_str<'a, T>(s: &'a str) -> Result<T>
-where
-    T: de::Deserialize<'a>,
-{
-    from_trait(read::StrRead::new(s))
-}
diff --git a/vendor/serde_json/src/error.rs b/vendor/serde_json/src/error.rs
deleted file mode 100644
index 03555eb..0000000
--- a/vendor/serde_json/src/error.rs
+++ /dev/null
@@ -1,516 +0,0 @@
-//! When serializing or deserializing JSON goes wrong.
-
-use crate::io;
-use alloc::boxed::Box;
-use alloc::string::{String, ToString};
-use core::fmt::{self, Debug, Display};
-use core::result;
-use core::str::FromStr;
-use serde::{de, ser};
-#[cfg(feature = "std")]
-use std::error;
-#[cfg(feature = "std")]
-use std::io::ErrorKind;
-
-/// This type represents all possible errors that can occur when serializing or
-/// deserializing JSON data.
-pub struct Error {
-    /// This `Box` allows us to keep the size of `Error` as small as possible. A
-    /// larger `Error` type was substantially slower due to all the functions
-    /// that pass around `Result<T, Error>`.
-    err: Box<ErrorImpl>,
-}
-
-/// Alias for a `Result` with the error type `serde_json::Error`.
-pub type Result<T> = result::Result<T, Error>;
-
-impl Error {
-    /// One-based line number at which the error was detected.
-    ///
-    /// Characters in the first line of the input (before the first newline
-    /// character) are in line 1.
-    pub fn line(&self) -> usize {
-        self.err.line
-    }
-
-    /// One-based column number at which the error was detected.
-    ///
-    /// The first character in the input and any characters immediately
-    /// following a newline character are in column 1.
-    ///
-    /// Note that errors may occur in column 0, for example if a read from an
-    /// I/O stream fails immediately following a previously read newline
-    /// character.
-    pub fn column(&self) -> usize {
-        self.err.column
-    }
-
-    /// Categorizes the cause of this error.
-    ///
-    /// - `Category::Io` - failure to read or write bytes on an I/O stream
-    /// - `Category::Syntax` - input that is not syntactically valid JSON
-    /// - `Category::Data` - input data that is semantically incorrect
-    /// - `Category::Eof` - unexpected end of the input data
-    pub fn classify(&self) -> Category {
-        match self.err.code {
-            ErrorCode::Message(_) => Category::Data,
-            ErrorCode::Io(_) => Category::Io,
-            ErrorCode::EofWhileParsingList
-            | ErrorCode::EofWhileParsingObject
-            | ErrorCode::EofWhileParsingString
-            | ErrorCode::EofWhileParsingValue => Category::Eof,
-            ErrorCode::ExpectedColon
-            | ErrorCode::ExpectedListCommaOrEnd
-            | ErrorCode::ExpectedObjectCommaOrEnd
-            | ErrorCode::ExpectedSomeIdent
-            | ErrorCode::ExpectedSomeValue
-            | ErrorCode::ExpectedDoubleQuote
-            | ErrorCode::InvalidEscape
-            | ErrorCode::InvalidNumber
-            | ErrorCode::NumberOutOfRange
-            | ErrorCode::InvalidUnicodeCodePoint
-            | ErrorCode::ControlCharacterWhileParsingString
-            | ErrorCode::KeyMustBeAString
-            | ErrorCode::ExpectedNumericKey
-            | ErrorCode::FloatKeyMustBeFinite
-            | ErrorCode::LoneLeadingSurrogateInHexEscape
-            | ErrorCode::TrailingComma
-            | ErrorCode::TrailingCharacters
-            | ErrorCode::UnexpectedEndOfHexEscape
-            | ErrorCode::RecursionLimitExceeded => Category::Syntax,
-        }
-    }
-
-    /// Returns true if this error was caused by a failure to read or write
-    /// bytes on an I/O stream.
-    pub fn is_io(&self) -> bool {
-        self.classify() == Category::Io
-    }
-
-    /// Returns true if this error was caused by input that was not
-    /// syntactically valid JSON.
-    pub fn is_syntax(&self) -> bool {
-        self.classify() == Category::Syntax
-    }
-
-    /// Returns true if this error was caused by input data that was
-    /// semantically incorrect.
-    ///
-    /// For example, JSON containing a number is semantically incorrect when the
-    /// type being deserialized into holds a String.
-    pub fn is_data(&self) -> bool {
-        self.classify() == Category::Data
-    }
-
-    /// Returns true if this error was caused by prematurely reaching the end of
-    /// the input data.
-    ///
-    /// Callers that process streaming input may be interested in retrying the
-    /// deserialization once more data is available.
-    pub fn is_eof(&self) -> bool {
-        self.classify() == Category::Eof
-    }
-
-    /// The kind reported by the underlying standard library I/O error, if this
-    /// error was caused by a failure to read or write bytes on an I/O stream.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use serde_json::Value;
-    /// use std::io::{self, ErrorKind, Read};
-    /// use std::process;
-    ///
-    /// struct ReaderThatWillTimeOut<'a>(&'a [u8]);
-    ///
-    /// impl<'a> Read for ReaderThatWillTimeOut<'a> {
-    ///     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-    ///         if self.0.is_empty() {
-    ///             Err(io::Error::new(ErrorKind::TimedOut, "timed out"))
-    ///         } else {
-    ///             self.0.read(buf)
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// fn main() {
-    ///     let reader = ReaderThatWillTimeOut(br#" {"k": "#);
-    ///
-    ///     let _: Value = match serde_json::from_reader(reader) {
-    ///         Ok(value) => value,
-    ///         Err(error) => {
-    ///             if error.io_error_kind() == Some(ErrorKind::TimedOut) {
-    ///                 // Maybe this application needs to retry certain kinds of errors.
-    ///
-    ///                 # return;
-    ///             } else {
-    ///                 eprintln!("error: {}", error);
-    ///                 process::exit(1);
-    ///             }
-    ///         }
-    ///     };
-    /// }
-    /// ```
-    #[cfg(feature = "std")]
-    pub fn io_error_kind(&self) -> Option<ErrorKind> {
-        if let ErrorCode::Io(io_error) = &self.err.code {
-            Some(io_error.kind())
-        } else {
-            None
-        }
-    }
-}
-
-/// Categorizes the cause of a `serde_json::Error`.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Category {
-    /// The error was caused by a failure to read or write bytes on an I/O
-    /// stream.
-    Io,
-
-    /// The error was caused by input that was not syntactically valid JSON.
-    Syntax,
-
-    /// The error was caused by input data that was semantically incorrect.
-    ///
-    /// For example, JSON containing a number is semantically incorrect when the
-    /// type being deserialized into holds a String.
-    Data,
-
-    /// The error was caused by prematurely reaching the end of the input data.
-    ///
-    /// Callers that process streaming input may be interested in retrying the
-    /// deserialization once more data is available.
-    Eof,
-}
-
-#[cfg(feature = "std")]
-#[allow(clippy::fallible_impl_from)]
-impl From<Error> for io::Error {
-    /// Convert a `serde_json::Error` into an `io::Error`.
-    ///
-    /// JSON syntax and data errors are turned into `InvalidData` I/O errors.
-    /// EOF errors are turned into `UnexpectedEof` I/O errors.
-    ///
-    /// ```
-    /// use std::io;
-    ///
-    /// enum MyError {
-    ///     Io(io::Error),
-    ///     Json(serde_json::Error),
-    /// }
-    ///
-    /// impl From<serde_json::Error> for MyError {
-    ///     fn from(err: serde_json::Error) -> MyError {
-    ///         use serde_json::error::Category;
-    ///         match err.classify() {
-    ///             Category::Io => {
-    ///                 MyError::Io(err.into())
-    ///             }
-    ///             Category::Syntax | Category::Data | Category::Eof => {
-    ///                 MyError::Json(err)
-    ///             }
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn from(j: Error) -> Self {
-        if let ErrorCode::Io(err) = j.err.code {
-            err
-        } else {
-            match j.classify() {
-                Category::Io => unreachable!(),
-                Category::Syntax | Category::Data => io::Error::new(ErrorKind::InvalidData, j),
-                Category::Eof => io::Error::new(ErrorKind::UnexpectedEof, j),
-            }
-        }
-    }
-}
-
-struct ErrorImpl {
-    code: ErrorCode,
-    line: usize,
-    column: usize,
-}
-
-pub(crate) enum ErrorCode {
-    /// Catchall for syntax error messages
-    Message(Box<str>),
-
-    /// Some I/O error occurred while serializing or deserializing.
-    Io(io::Error),
-
-    /// EOF while parsing a list.
-    EofWhileParsingList,
-
-    /// EOF while parsing an object.
-    EofWhileParsingObject,
-
-    /// EOF while parsing a string.
-    EofWhileParsingString,
-
-    /// EOF while parsing a JSON value.
-    EofWhileParsingValue,
-
-    /// Expected this character to be a `':'`.
-    ExpectedColon,
-
-    /// Expected this character to be either a `','` or a `']'`.
-    ExpectedListCommaOrEnd,
-
-    /// Expected this character to be either a `','` or a `'}'`.
-    ExpectedObjectCommaOrEnd,
-
-    /// Expected to parse either a `true`, `false`, or a `null`.
-    ExpectedSomeIdent,
-
-    /// Expected this character to start a JSON value.
-    ExpectedSomeValue,
-
-    /// Expected this character to be a `"`.
-    ExpectedDoubleQuote,
-
-    /// Invalid hex escape code.
-    InvalidEscape,
-
-    /// Invalid number.
-    InvalidNumber,
-
-    /// Number is bigger than the maximum value of its type.
-    NumberOutOfRange,
-
-    /// Invalid unicode code point.
-    InvalidUnicodeCodePoint,
-
-    /// Control character found while parsing a string.
-    ControlCharacterWhileParsingString,
-
-    /// Object key is not a string.
-    KeyMustBeAString,
-
-    /// Contents of key were supposed to be a number.
-    ExpectedNumericKey,
-
-    /// Object key is a non-finite float value.
-    FloatKeyMustBeFinite,
-
-    /// Lone leading surrogate in hex escape.
-    LoneLeadingSurrogateInHexEscape,
-
-    /// JSON has a comma after the last value in an array or map.
-    TrailingComma,
-
-    /// JSON has non-whitespace trailing characters after the value.
-    TrailingCharacters,
-
-    /// Unexpected end of hex escape.
-    UnexpectedEndOfHexEscape,
-
-    /// Encountered nesting of JSON maps and arrays more than 128 layers deep.
-    RecursionLimitExceeded,
-}
-
-impl Error {
-    #[cold]
-    pub(crate) fn syntax(code: ErrorCode, line: usize, column: usize) -> Self {
-        Error {
-            err: Box::new(ErrorImpl { code, line, column }),
-        }
-    }
-
-    // Not public API. Should be pub(crate).
-    //
-    // Update `eager_json` crate when this function changes.
-    #[doc(hidden)]
-    #[cold]
-    pub fn io(error: io::Error) -> Self {
-        Error {
-            err: Box::new(ErrorImpl {
-                code: ErrorCode::Io(error),
-                line: 0,
-                column: 0,
-            }),
-        }
-    }
-
-    #[cold]
-    pub(crate) fn fix_position<F>(self, f: F) -> Self
-    where
-        F: FnOnce(ErrorCode) -> Error,
-    {
-        if self.err.line == 0 {
-            f(self.err.code)
-        } else {
-            self
-        }
-    }
-}
-
-impl Display for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ErrorCode::Message(msg) => f.write_str(msg),
-            ErrorCode::Io(err) => Display::fmt(err, f),
-            ErrorCode::EofWhileParsingList => f.write_str("EOF while parsing a list"),
-            ErrorCode::EofWhileParsingObject => f.write_str("EOF while parsing an object"),
-            ErrorCode::EofWhileParsingString => f.write_str("EOF while parsing a string"),
-            ErrorCode::EofWhileParsingValue => f.write_str("EOF while parsing a value"),
-            ErrorCode::ExpectedColon => f.write_str("expected `:`"),
-            ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"),
-            ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"),
-            ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"),
-            ErrorCode::ExpectedSomeValue => f.write_str("expected value"),
-            ErrorCode::ExpectedDoubleQuote => f.write_str("expected `\"`"),
-            ErrorCode::InvalidEscape => f.write_str("invalid escape"),
-            ErrorCode::InvalidNumber => f.write_str("invalid number"),
-            ErrorCode::NumberOutOfRange => f.write_str("number out of range"),
-            ErrorCode::InvalidUnicodeCodePoint => f.write_str("invalid unicode code point"),
-            ErrorCode::ControlCharacterWhileParsingString => {
-                f.write_str("control character (\\u0000-\\u001F) found while parsing a string")
-            }
-            ErrorCode::KeyMustBeAString => f.write_str("key must be a string"),
-            ErrorCode::ExpectedNumericKey => {
-                f.write_str("invalid value: expected key to be a number in quotes")
-            }
-            ErrorCode::FloatKeyMustBeFinite => {
-                f.write_str("float key must be finite (got NaN or +/-inf)")
-            }
-            ErrorCode::LoneLeadingSurrogateInHexEscape => {
-                f.write_str("lone leading surrogate in hex escape")
-            }
-            ErrorCode::TrailingComma => f.write_str("trailing comma"),
-            ErrorCode::TrailingCharacters => f.write_str("trailing characters"),
-            ErrorCode::UnexpectedEndOfHexEscape => f.write_str("unexpected end of hex escape"),
-            ErrorCode::RecursionLimitExceeded => f.write_str("recursion limit exceeded"),
-        }
-    }
-}
-
-impl serde::de::StdError for Error {
-    #[cfg(feature = "std")]
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        match &self.err.code {
-            ErrorCode::Io(err) => err.source(),
-            _ => None,
-        }
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&*self.err, f)
-    }
-}
-
-impl Display for ErrorImpl {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.line == 0 {
-            Display::fmt(&self.code, f)
-        } else {
-            write!(
-                f,
-                "{} at line {} column {}",
-                self.code, self.line, self.column
-            )
-        }
-    }
-}
-
-// Remove two layers of verbosity from the debug representation. Humans often
-// end up seeing this representation because it is what unwrap() shows.
-impl Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Error({:?}, line: {}, column: {})",
-            self.err.code.to_string(),
-            self.err.line,
-            self.err.column
-        )
-    }
-}
-
-impl de::Error for Error {
-    #[cold]
-    fn custom<T: Display>(msg: T) -> Error {
-        make_error(msg.to_string())
-    }
-
-    #[cold]
-    fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
-        if let de::Unexpected::Unit = unexp {
-            Error::custom(format_args!("invalid type: null, expected {}", exp))
-        } else {
-            Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
-        }
-    }
-}
-
-impl ser::Error for Error {
-    #[cold]
-    fn custom<T: Display>(msg: T) -> Error {
-        make_error(msg.to_string())
-    }
-}
-
-// Parse our own error message that looks like "{} at line {} column {}" to work
-// around erased-serde round-tripping the error through de::Error::custom.
-fn make_error(mut msg: String) -> Error {
-    let (line, column) = parse_line_col(&mut msg).unwrap_or((0, 0));
-    Error {
-        err: Box::new(ErrorImpl {
-            code: ErrorCode::Message(msg.into_boxed_str()),
-            line,
-            column,
-        }),
-    }
-}
-
-fn parse_line_col(msg: &mut String) -> Option<(usize, usize)> {
-    let start_of_suffix = match msg.rfind(" at line ") {
-        Some(index) => index,
-        None => return None,
-    };
-
-    // Find start and end of line number.
-    let start_of_line = start_of_suffix + " at line ".len();
-    let mut end_of_line = start_of_line;
-    while starts_with_digit(&msg[end_of_line..]) {
-        end_of_line += 1;
-    }
-
-    if !msg[end_of_line..].starts_with(" column ") {
-        return None;
-    }
-
-    // Find start and end of column number.
-    let start_of_column = end_of_line + " column ".len();
-    let mut end_of_column = start_of_column;
-    while starts_with_digit(&msg[end_of_column..]) {
-        end_of_column += 1;
-    }
-
-    if end_of_column < msg.len() {
-        return None;
-    }
-
-    // Parse numbers.
-    let line = match usize::from_str(&msg[start_of_line..end_of_line]) {
-        Ok(line) => line,
-        Err(_) => return None,
-    };
-    let column = match usize::from_str(&msg[start_of_column..end_of_column]) {
-        Ok(column) => column,
-        Err(_) => return None,
-    };
-
-    msg.truncate(start_of_suffix);
-    Some((line, column))
-}
-
-fn starts_with_digit(slice: &str) -> bool {
-    match slice.as_bytes().first() {
-        None => false,
-        Some(&byte) => byte >= b'0' && byte <= b'9',
-    }
-}
diff --git a/vendor/serde_json/src/features_check/error.rs b/vendor/serde_json/src/features_check/error.rs
deleted file mode 100644
index 22e5823..0000000
--- a/vendor/serde_json/src/features_check/error.rs
+++ /dev/null
@@ -1 +0,0 @@
-"serde_json requires that either `std` (default) or `alloc` feature is enabled"
diff --git a/vendor/serde_json/src/features_check/mod.rs b/vendor/serde_json/src/features_check/mod.rs
deleted file mode 100644
index d12032c..0000000
--- a/vendor/serde_json/src/features_check/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//! Shows a user-friendly compiler error on incompatible selected features.
-
-#[allow(unused_macros)]
-macro_rules! hide_from_rustfmt {
-    ($mod:item) => {
-        $mod
-    };
-}
-
-#[cfg(not(any(feature = "std", feature = "alloc")))]
-hide_from_rustfmt! {
-    mod error;
-}
diff --git a/vendor/serde_json/src/io/core.rs b/vendor/serde_json/src/io/core.rs
deleted file mode 100644
index 54c8ddf..0000000
--- a/vendor/serde_json/src/io/core.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! Reimplements core logic and types from `std::io` in an `alloc`-friendly
-//! fashion.
-
-use alloc::vec::Vec;
-use core::fmt::{self, Display};
-use core::result;
-
-pub enum ErrorKind {
-    Other,
-}
-
-// I/O errors can never occur in no-std mode. All our no-std I/O implementations
-// are infallible.
-pub struct Error;
-
-impl Display for Error {
-    fn fmt(&self, _formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        unreachable!()
-    }
-}
-
-impl Error {
-    pub(crate) fn new(_kind: ErrorKind, _error: &'static str) -> Error {
-        Error
-    }
-}
-
-pub type Result<T> = result::Result<T, Error>;
-
-pub trait Write {
-    fn write(&mut self, buf: &[u8]) -> Result<usize>;
-
-    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
-        // All our Write impls in no_std mode always write the whole buffer in
-        // one call infallibly.
-        let result = self.write(buf);
-        debug_assert!(result.is_ok());
-        debug_assert_eq!(result.unwrap_or(0), buf.len());
-        Ok(())
-    }
-
-    fn flush(&mut self) -> Result<()>;
-}
-
-impl<W: Write> Write for &mut W {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        (*self).write(buf)
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
-        (*self).write_all(buf)
-    }
-
-    #[inline]
-    fn flush(&mut self) -> Result<()> {
-        (*self).flush()
-    }
-}
-
-impl Write for Vec<u8> {
-    #[inline]
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        self.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-
-    #[inline]
-    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
-        self.extend_from_slice(buf);
-        Ok(())
-    }
-
-    #[inline]
-    fn flush(&mut self) -> Result<()> {
-        Ok(())
-    }
-}
diff --git a/vendor/serde_json/src/io/mod.rs b/vendor/serde_json/src/io/mod.rs
deleted file mode 100644
index 9dee4a0..0000000
--- a/vendor/serde_json/src/io/mod.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! A tiny, `no_std`-friendly facade around `std::io`.
-//! Reexports types from `std` when available; otherwise reimplements and
-//! provides some of the core logic.
-//!
-//! The main reason that `std::io` hasn't found itself reexported as part of
-//! the `core` crate is the `std::io::{Read, Write}` traits' reliance on
-//! `std::io::Error`, which may contain internally a heap-allocated `Box<Error>`
-//! and/or now relying on OS-specific `std::backtrace::Backtrace`.
-
-pub use self::imp::{Error, ErrorKind, Result, Write};
-
-#[cfg(not(feature = "std"))]
-#[path = "core.rs"]
-mod imp;
-
-#[cfg(feature = "std")]
-use std::io as imp;
-
-#[cfg(feature = "std")]
-pub use std::io::{Bytes, Read};
diff --git a/vendor/serde_json/src/iter.rs b/vendor/serde_json/src/iter.rs
deleted file mode 100644
index 9792916..0000000
--- a/vendor/serde_json/src/iter.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use crate::io;
-
-pub struct LineColIterator<I> {
-    iter: I,
-
-    /// Index of the current line. Characters in the first line of the input
-    /// (before the first newline character) are in line 1.
-    line: usize,
-
-    /// Index of the current column. The first character in the input and any
-    /// characters immediately following a newline character are in column 1.
-    /// The column is 0 immediately after a newline character has been read.
-    col: usize,
-
-    /// Byte offset of the start of the current line. This is the sum of lengths
-    /// of all previous lines. Keeping track of things this way allows efficient
-    /// computation of the current line, column, and byte offset while only
-    /// updating one of the counters in `next()` in the common case.
-    start_of_line: usize,
-}
-
-impl<I> LineColIterator<I>
-where
-    I: Iterator<Item = io::Result<u8>>,
-{
-    pub fn new(iter: I) -> LineColIterator<I> {
-        LineColIterator {
-            iter,
-            line: 1,
-            col: 0,
-            start_of_line: 0,
-        }
-    }
-
-    pub fn line(&self) -> usize {
-        self.line
-    }
-
-    pub fn col(&self) -> usize {
-        self.col
-    }
-
-    pub fn byte_offset(&self) -> usize {
-        self.start_of_line + self.col
-    }
-}
-
-impl<I> Iterator for LineColIterator<I>
-where
-    I: Iterator<Item = io::Result<u8>>,
-{
-    type Item = io::Result<u8>;
-
-    fn next(&mut self) -> Option<io::Result<u8>> {
-        match self.iter.next() {
-            None => None,
-            Some(Ok(b'\n')) => {
-                self.start_of_line += self.col + 1;
-                self.line += 1;
-                self.col = 0;
-                Some(Ok(b'\n'))
-            }
-            Some(Ok(c)) => {
-                self.col += 1;
-                Some(Ok(c))
-            }
-            Some(Err(e)) => Some(Err(e)),
-        }
-    }
-}
diff --git a/vendor/serde_json/src/lexical/algorithm.rs b/vendor/serde_json/src/lexical/algorithm.rs
deleted file mode 100644
index eaa5e7e..0000000
--- a/vendor/serde_json/src/lexical/algorithm.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Algorithms to efficiently convert strings to floats.
-
-use super::bhcomp::*;
-use super::cached::*;
-use super::errors::*;
-use super::float::ExtendedFloat;
-use super::num::*;
-use super::small_powers::*;
-
-// FAST
-// ----
-
-/// Convert mantissa to exact value for a non-base2 power.
-///
-/// Returns the resulting float and if the value can be represented exactly.
-pub(crate) fn fast_path<F>(mantissa: u64, exponent: i32) -> Option<F>
-where
-    F: Float,
-{
-    // `mantissa >> (F::MANTISSA_SIZE+1) != 0` effectively checks if the
-    // value has a no bits above the hidden bit, which is what we want.
-    let (min_exp, max_exp) = F::exponent_limit();
-    let shift_exp = F::mantissa_limit();
-    let mantissa_size = F::MANTISSA_SIZE + 1;
-    if mantissa == 0 {
-        Some(F::ZERO)
-    } else if mantissa >> mantissa_size != 0 {
-        // Would require truncation of the mantissa.
-        None
-    } else if exponent == 0 {
-        // 0 exponent, same as value, exact representation.
-        let float = F::as_cast(mantissa);
-        Some(float)
-    } else if exponent >= min_exp && exponent <= max_exp {
-        // Value can be exactly represented, return the value.
-        // Do not use powi, since powi can incrementally introduce
-        // error.
-        let float = F::as_cast(mantissa);
-        Some(float.pow10(exponent))
-    } else if exponent >= 0 && exponent <= max_exp + shift_exp {
-        // Check to see if we have a disguised fast-path, where the
-        // number of digits in the mantissa is very small, but and
-        // so digits can be shifted from the exponent to the mantissa.
-        // https://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
-        let small_powers = POW10_64;
-        let shift = exponent - max_exp;
-        let power = small_powers[shift as usize];
-
-        // Compute the product of the power, if it overflows,
-        // prematurely return early, otherwise, if we didn't overshoot,
-        // we can get an exact value.
-        let value = match mantissa.checked_mul(power) {
-            None => return None,
-            Some(value) => value,
-        };
-        if value >> mantissa_size != 0 {
-            None
-        } else {
-            // Use powi, since it's correct, and faster on
-            // the fast-path.
-            let float = F::as_cast(value);
-            Some(float.pow10(max_exp))
-        }
-    } else {
-        // Cannot be exactly represented, exponent too small or too big,
-        // would require truncation.
-        None
-    }
-}
-
-// MODERATE
-// --------
-
-/// Multiply the floating-point by the exponent.
-///
-/// Multiply by pre-calculated powers of the base, modify the extended-
-/// float, and return if new value and if the value can be represented
-/// accurately.
-fn multiply_exponent_extended<F>(fp: &mut ExtendedFloat, exponent: i32, truncated: bool) -> bool
-where
-    F: Float,
-{
-    let powers = ExtendedFloat::get_powers();
-    let exponent = exponent.saturating_add(powers.bias);
-    let small_index = exponent % powers.step;
-    let large_index = exponent / powers.step;
-    if exponent < 0 {
-        // Guaranteed underflow (assign 0).
-        fp.mant = 0;
-        true
-    } else if large_index as usize >= powers.large.len() {
-        // Overflow (assign infinity)
-        fp.mant = 1 << 63;
-        fp.exp = 0x7FF;
-        true
-    } else {
-        // Within the valid exponent range, multiply by the large and small
-        // exponents and return the resulting value.
-
-        // Track errors to as a factor of unit in last-precision.
-        let mut errors: u32 = 0;
-        if truncated {
-            errors += u64::error_halfscale();
-        }
-
-        // Multiply by the small power.
-        // Check if we can directly multiply by an integer, if not,
-        // use extended-precision multiplication.
-        match fp
-            .mant
-            .overflowing_mul(powers.get_small_int(small_index as usize))
-        {
-            // Overflow, multiplication unsuccessful, go slow path.
-            (_, true) => {
-                fp.normalize();
-                fp.imul(&powers.get_small(small_index as usize));
-                errors += u64::error_halfscale();
-            }
-            // No overflow, multiplication successful.
-            (mant, false) => {
-                fp.mant = mant;
-                fp.normalize();
-            }
-        }
-
-        // Multiply by the large power
-        fp.imul(&powers.get_large(large_index as usize));
-        if errors > 0 {
-            errors += 1;
-        }
-        errors += u64::error_halfscale();
-
-        // Normalize the floating point (and the errors).
-        let shift = fp.normalize();
-        errors <<= shift;
-
-        u64::error_is_accurate::<F>(errors, fp)
-    }
-}
-
-/// Create a precise native float using an intermediate extended-precision float.
-///
-/// Return the float approximation and if the value can be accurately
-/// represented with mantissa bits of precision.
-#[inline]
-pub(crate) fn moderate_path<F>(
-    mantissa: u64,
-    exponent: i32,
-    truncated: bool,
-) -> (ExtendedFloat, bool)
-where
-    F: Float,
-{
-    let mut fp = ExtendedFloat {
-        mant: mantissa,
-        exp: 0,
-    };
-    let valid = multiply_exponent_extended::<F>(&mut fp, exponent, truncated);
-    (fp, valid)
-}
-
-// FALLBACK
-// --------
-
-/// Fallback path when the fast path does not work.
-///
-/// Uses the moderate path, if applicable, otherwise, uses the slow path
-/// as required.
-pub(crate) fn fallback_path<F>(
-    integer: &[u8],
-    fraction: &[u8],
-    mantissa: u64,
-    exponent: i32,
-    mantissa_exponent: i32,
-    truncated: bool,
-) -> F
-where
-    F: Float,
-{
-    // Moderate path (use an extended 80-bit representation).
-    let (fp, valid) = moderate_path::<F>(mantissa, mantissa_exponent, truncated);
-    if valid {
-        return fp.into_float::<F>();
-    }
-
-    // Slow path, fast path didn't work.
-    let b = fp.into_downward_float::<F>();
-    if b.is_special() {
-        // We have a non-finite number, we get to leave early.
-        b
-    } else {
-        bhcomp(b, integer, fraction, exponent)
-    }
-}
diff --git a/vendor/serde_json/src/lexical/bhcomp.rs b/vendor/serde_json/src/lexical/bhcomp.rs
deleted file mode 100644
index 1f2a7bb..0000000
--- a/vendor/serde_json/src/lexical/bhcomp.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Compare the mantissa to the halfway representation of the float.
-//!
-//! Compares the actual significant digits of the mantissa to the
-//! theoretical digits from `b+h`, scaled into the proper range.
-
-use super::bignum::*;
-use super::digit::*;
-use super::exponent::*;
-use super::float::*;
-use super::math::*;
-use super::num::*;
-use super::rounding::*;
-use core::{cmp, mem};
-
-// MANTISSA
-
-/// Parse the full mantissa into a big integer.
-///
-/// Max digits is the maximum number of digits plus one.
-fn parse_mantissa<F>(integer: &[u8], fraction: &[u8]) -> Bigint
-where
-    F: Float,
-{
-    // Main loop
-    let small_powers = POW10_LIMB;
-    let step = small_powers.len() - 2;
-    let max_digits = F::MAX_DIGITS - 1;
-    let mut counter = 0;
-    let mut value: Limb = 0;
-    let mut i: usize = 0;
-    let mut result = Bigint::default();
-
-    // Iteratively process all the data in the mantissa.
-    for &digit in integer.iter().chain(fraction) {
-        // We've parsed the max digits using small values, add to bignum
-        if counter == step {
-            result.imul_small(small_powers[counter]);
-            result.iadd_small(value);
-            counter = 0;
-            value = 0;
-        }
-
-        value *= 10;
-        value += as_limb(to_digit(digit).unwrap());
-
-        i += 1;
-        counter += 1;
-        if i == max_digits {
-            break;
-        }
-    }
-
-    // We will always have a remainder, as long as we entered the loop
-    // once, or counter % step is 0.
-    if counter != 0 {
-        result.imul_small(small_powers[counter]);
-        result.iadd_small(value);
-    }
-
-    // If we have any remaining digits after the last value, we need
-    // to add a 1 after the rest of the array, it doesn't matter where,
-    // just move it up. This is good for the worst-possible float
-    // representation. We also need to return an index.
-    // Since we already trimmed trailing zeros, we know there has
-    // to be a non-zero digit if there are any left.
-    if i < integer.len() + fraction.len() {
-        result.imul_small(10);
-        result.iadd_small(1);
-    }
-
-    result
-}
-
-// FLOAT OPS
-
-/// Calculate `b` from a a representation of `b` as a float.
-#[inline]
-pub(super) fn b_extended<F: Float>(f: F) -> ExtendedFloat {
-    ExtendedFloat::from_float(f)
-}
-
-/// Calculate `b+h` from a a representation of `b` as a float.
-#[inline]
-pub(super) fn bh_extended<F: Float>(f: F) -> ExtendedFloat {
-    // None of these can overflow.
-    let b = b_extended(f);
-    ExtendedFloat {
-        mant: (b.mant << 1) + 1,
-        exp: b.exp - 1,
-    }
-}
-
-// ROUNDING
-
-/// Custom round-nearest, tie-event algorithm for bhcomp.
-#[inline]
-fn round_nearest_tie_even(fp: &mut ExtendedFloat, shift: i32, is_truncated: bool) {
-    let (mut is_above, mut is_halfway) = round_nearest(fp, shift);
-    if is_halfway && is_truncated {
-        is_above = true;
-        is_halfway = false;
-    }
-    tie_even(fp, is_above, is_halfway);
-}
-
-// BHCOMP
-
-/// Calculate the mantissa for a big integer with a positive exponent.
-fn large_atof<F>(mantissa: Bigint, exponent: i32) -> F
-where
-    F: Float,
-{
-    let bits = mem::size_of::<u64>() * 8;
-
-    // Simple, we just need to multiply by the power of the radix.
-    // Now, we can calculate the mantissa and the exponent from this.
-    // The binary exponent is the binary exponent for the mantissa
-    // shifted to the hidden bit.
-    let mut bigmant = mantissa;
-    bigmant.imul_pow10(exponent as u32);
-
-    // Get the exact representation of the float from the big integer.
-    let (mant, is_truncated) = bigmant.hi64();
-    let exp = bigmant.bit_length() as i32 - bits as i32;
-    let mut fp = ExtendedFloat { mant, exp };
-    fp.round_to_native::<F, _>(|fp, shift| round_nearest_tie_even(fp, shift, is_truncated));
-    into_float(fp)
-}
-
-/// Calculate the mantissa for a big integer with a negative exponent.
-///
-/// This invokes the comparison with `b+h`.
-fn small_atof<F>(mantissa: Bigint, exponent: i32, f: F) -> F
-where
-    F: Float,
-{
-    // Get the significant digits and radix exponent for the real digits.
-    let mut real_digits = mantissa;
-    let real_exp = exponent;
-    debug_assert!(real_exp < 0);
-
-    // Get the significant digits and the binary exponent for `b+h`.
-    let theor = bh_extended(f);
-    let mut theor_digits = Bigint::from_u64(theor.mant);
-    let theor_exp = theor.exp;
-
-    // We need to scale the real digits and `b+h` digits to be the same
-    // order. We currently have `real_exp`, in `radix`, that needs to be
-    // shifted to `theor_digits` (since it is negative), and `theor_exp`
-    // to either `theor_digits` or `real_digits` as a power of 2 (since it
-    // may be positive or negative). Try to remove as many powers of 2
-    // as possible. All values are relative to `theor_digits`, that is,
-    // reflect the power you need to multiply `theor_digits` by.
-
-    // Can remove a power-of-two, since the radix is 10.
-    // Both are on opposite-sides of equation, can factor out a
-    // power of two.
-    //
-    // Example: 10^-10, 2^-10   -> ( 0, 10, 0)
-    // Example: 10^-10, 2^-15   -> (-5, 10, 0)
-    // Example: 10^-10, 2^-5    -> ( 5, 10, 0)
-    // Example: 10^-10, 2^5 -> (15, 10, 0)
-    let binary_exp = theor_exp - real_exp;
-    let halfradix_exp = -real_exp;
-    let radix_exp = 0;
-
-    // Carry out our multiplication.
-    if halfradix_exp != 0 {
-        theor_digits.imul_pow5(halfradix_exp as u32);
-    }
-    if radix_exp != 0 {
-        theor_digits.imul_pow10(radix_exp as u32);
-    }
-    if binary_exp > 0 {
-        theor_digits.imul_pow2(binary_exp as u32);
-    } else if binary_exp < 0 {
-        real_digits.imul_pow2(-binary_exp as u32);
-    }
-
-    // Compare real digits to theoretical digits and round the float.
-    match real_digits.compare(&theor_digits) {
-        cmp::Ordering::Greater => f.next_positive(),
-        cmp::Ordering::Less => f,
-        cmp::Ordering::Equal => f.round_positive_even(),
-    }
-}
-
-/// Calculate the exact value of the float.
-///
-/// Note: fraction must not have trailing zeros.
-pub(crate) fn bhcomp<F>(b: F, integer: &[u8], mut fraction: &[u8], exponent: i32) -> F
-where
-    F: Float,
-{
-    // Calculate the number of integer digits and use that to determine
-    // where the significant digits start in the fraction.
-    let integer_digits = integer.len();
-    let fraction_digits = fraction.len();
-    let digits_start = if integer_digits == 0 {
-        let start = fraction.iter().take_while(|&x| *x == b'0').count();
-        fraction = &fraction[start..];
-        start
-    } else {
-        0
-    };
-    let sci_exp = scientific_exponent(exponent, integer_digits, digits_start);
-    let count = F::MAX_DIGITS.min(integer_digits + fraction_digits - digits_start);
-    let scaled_exponent = sci_exp + 1 - count as i32;
-
-    let mantissa = parse_mantissa::<F>(integer, fraction);
-    if scaled_exponent >= 0 {
-        large_atof(mantissa, scaled_exponent)
-    } else {
-        small_atof(mantissa, scaled_exponent, b)
-    }
-}
diff --git a/vendor/serde_json/src/lexical/bignum.rs b/vendor/serde_json/src/lexical/bignum.rs
deleted file mode 100644
index f9551f5..0000000
--- a/vendor/serde_json/src/lexical/bignum.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Big integer type definition.
-
-use super::math::*;
-use alloc::vec::Vec;
-
-/// Storage for a big integer type.
-#[derive(Clone, PartialEq, Eq)]
-pub(crate) struct Bigint {
-    /// Internal storage for the Bigint, in little-endian order.
-    pub(crate) data: Vec<Limb>,
-}
-
-impl Default for Bigint {
-    fn default() -> Self {
-        Bigint {
-            data: Vec::with_capacity(20),
-        }
-    }
-}
-
-impl Math for Bigint {
-    #[inline]
-    fn data(&self) -> &Vec<Limb> {
-        &self.data
-    }
-
-    #[inline]
-    fn data_mut(&mut self) -> &mut Vec<Limb> {
-        &mut self.data
-    }
-}
diff --git a/vendor/serde_json/src/lexical/cached.rs b/vendor/serde_json/src/lexical/cached.rs
deleted file mode 100644
index ef5a9fe..0000000
--- a/vendor/serde_json/src/lexical/cached.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Cached powers trait for extended-precision floats.
-
-use super::cached_float80;
-use super::float::ExtendedFloat;
-
-// POWERS
-
-/// Precalculated powers that uses two-separate arrays for memory-efficiency.
-#[doc(hidden)]
-pub(crate) struct ExtendedFloatArray {
-    // Pre-calculated mantissa for the powers.
-    pub mant: &'static [u64],
-    // Pre-calculated binary exponents for the powers.
-    pub exp: &'static [i32],
-}
-
-/// Allow indexing of values without bounds checking
-impl ExtendedFloatArray {
-    #[inline]
-    pub fn get_extended_float(&self, index: usize) -> ExtendedFloat {
-        let mant = self.mant[index];
-        let exp = self.exp[index];
-        ExtendedFloat { mant, exp }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.mant.len()
-    }
-}
-
-// MODERATE PATH POWERS
-
-/// Precalculated powers of base N for the moderate path.
-#[doc(hidden)]
-pub(crate) struct ModeratePathPowers {
-    // Pre-calculated small powers.
-    pub small: ExtendedFloatArray,
-    // Pre-calculated large powers.
-    pub large: ExtendedFloatArray,
-    /// Pre-calculated small powers as 64-bit integers
-    pub small_int: &'static [u64],
-    // Step between large powers and number of small powers.
-    pub step: i32,
-    // Exponent bias for the large powers.
-    pub bias: i32,
-}
-
-/// Allow indexing of values without bounds checking
-impl ModeratePathPowers {
-    #[inline]
-    pub fn get_small(&self, index: usize) -> ExtendedFloat {
-        self.small.get_extended_float(index)
-    }
-
-    #[inline]
-    pub fn get_large(&self, index: usize) -> ExtendedFloat {
-        self.large.get_extended_float(index)
-    }
-
-    #[inline]
-    pub fn get_small_int(&self, index: usize) -> u64 {
-        self.small_int[index]
-    }
-}
-
-// CACHED EXTENDED POWERS
-
-/// Cached powers as a trait for a floating-point type.
-pub(crate) trait ModeratePathCache {
-    /// Get cached powers.
-    fn get_powers() -> &'static ModeratePathPowers;
-}
-
-impl ModeratePathCache for ExtendedFloat {
-    #[inline]
-    fn get_powers() -> &'static ModeratePathPowers {
-        cached_float80::get_powers()
-    }
-}
diff --git a/vendor/serde_json/src/lexical/cached_float80.rs b/vendor/serde_json/src/lexical/cached_float80.rs
deleted file mode 100644
index 9beda3d..0000000
--- a/vendor/serde_json/src/lexical/cached_float80.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Cached exponents for basen values with 80-bit extended floats.
-//!
-//! Exact versions of base**n as an extended-precision float, with both
-//! large and small powers. Use the large powers to minimize the amount
-//! of compounded error.
-//!
-//! These values were calculated using Python, using the arbitrary-precision
-//! integer to calculate exact extended-representation of each value.
-//! These values are all normalized.
-
-use super::cached::{ExtendedFloatArray, ModeratePathPowers};
-
-// LOW-LEVEL
-// ---------
-
-// BASE10
-
-const BASE10_SMALL_MANTISSA: [u64; 10] = [
-    9223372036854775808,  // 10^0
-    11529215046068469760, // 10^1
-    14411518807585587200, // 10^2
-    18014398509481984000, // 10^3
-    11258999068426240000, // 10^4
-    14073748835532800000, // 10^5
-    17592186044416000000, // 10^6
-    10995116277760000000, // 10^7
-    13743895347200000000, // 10^8
-    17179869184000000000, // 10^9
-];
-const BASE10_SMALL_EXPONENT: [i32; 10] = [
-    -63, // 10^0
-    -60, // 10^1
-    -57, // 10^2
-    -54, // 10^3
-    -50, // 10^4
-    -47, // 10^5
-    -44, // 10^6
-    -40, // 10^7
-    -37, // 10^8
-    -34, // 10^9
-];
-const BASE10_LARGE_MANTISSA: [u64; 66] = [
-    11555125961253852697, // 10^-350
-    13451937075301367670, // 10^-340
-    15660115838168849784, // 10^-330
-    18230774251475056848, // 10^-320
-    10611707258198326947, // 10^-310
-    12353653155963782858, // 10^-300
-    14381545078898527261, // 10^-290
-    16742321987285426889, // 10^-280
-    9745314011399999080,  // 10^-270
-    11345038669416679861, // 10^-260
-    13207363278391631158, // 10^-250
-    15375394465392026070, // 10^-240
-    17899314949046850752, // 10^-230
-    10418772551374772303, // 10^-220
-    12129047596099288555, // 10^-210
-    14120069793541087484, // 10^-200
-    16437924692338667210, // 10^-190
-    9568131466127621947,  // 10^-180
-    11138771039116687545, // 10^-170
-    12967236152753102995, // 10^-160
-    15095849699286165408, // 10^-150
-    17573882009934360870, // 10^-140
-    10229345649675443343, // 10^-130
-    11908525658859223294, // 10^-120
-    13863348470604074297, // 10^-110
-    16139061738043178685, // 10^-100
-    9394170331095332911,  // 10^-90
-    10936253623915059621, // 10^-80
-    12731474852090538039, // 10^-70
-    14821387422376473014, // 10^-60
-    17254365866976409468, // 10^-50
-    10043362776618689222, // 10^-40
-    11692013098647223345, // 10^-30
-    13611294676837538538, // 10^-20
-    15845632502852867518, // 10^-10
-    9223372036854775808,  // 10^0
-    10737418240000000000, // 10^10
-    12500000000000000000, // 10^20
-    14551915228366851806, // 10^30
-    16940658945086006781, // 10^40
-    9860761315262647567,  // 10^50
-    11479437019748901445, // 10^60
-    13363823550460978230, // 10^70
-    15557538194652854267, // 10^80
-    18111358157653424735, // 10^90
-    10542197943230523224, // 10^100
-    12272733663244316382, // 10^110
-    14287342391028437277, // 10^120
-    16632655625031838749, // 10^130
-    9681479787123295682,  // 10^140
-    11270725851789228247, // 10^150
-    13120851772591970218, // 10^160
-    15274681817498023410, // 10^170
-    17782069995880619867, // 10^180
-    10350527006597618960, // 10^190
-    12049599325514420588, // 10^200
-    14027579833653779454, // 10^210
-    16330252207878254650, // 10^220
-    9505457831475799117,  // 10^230
-    11065809325636130661, // 10^240
-    12882297539194266616, // 10^250
-    14996968138956309548, // 10^260
-    17458768723248864463, // 10^270
-    10162340898095201970, // 10^280
-    11830521861667747109, // 10^290
-    13772540099066387756, // 10^300
-];
-const BASE10_LARGE_EXPONENT: [i32; 66] = [
-    -1226, // 10^-350
-    -1193, // 10^-340
-    -1160, // 10^-330
-    -1127, // 10^-320
-    -1093, // 10^-310
-    -1060, // 10^-300
-    -1027, // 10^-290
-    -994,  // 10^-280
-    -960,  // 10^-270
-    -927,  // 10^-260
-    -894,  // 10^-250
-    -861,  // 10^-240
-    -828,  // 10^-230
-    -794,  // 10^-220
-    -761,  // 10^-210
-    -728,  // 10^-200
-    -695,  // 10^-190
-    -661,  // 10^-180
-    -628,  // 10^-170
-    -595,  // 10^-160
-    -562,  // 10^-150
-    -529,  // 10^-140
-    -495,  // 10^-130
-    -462,  // 10^-120
-    -429,  // 10^-110
-    -396,  // 10^-100
-    -362,  // 10^-90
-    -329,  // 10^-80
-    -296,  // 10^-70
-    -263,  // 10^-60
-    -230,  // 10^-50
-    -196,  // 10^-40
-    -163,  // 10^-30
-    -130,  // 10^-20
-    -97,   // 10^-10
-    -63,   // 10^0
-    -30,   // 10^10
-    3,     // 10^20
-    36,    // 10^30
-    69,    // 10^40
-    103,   // 10^50
-    136,   // 10^60
-    169,   // 10^70
-    202,   // 10^80
-    235,   // 10^90
-    269,   // 10^100
-    302,   // 10^110
-    335,   // 10^120
-    368,   // 10^130
-    402,   // 10^140
-    435,   // 10^150
-    468,   // 10^160
-    501,   // 10^170
-    534,   // 10^180
-    568,   // 10^190
-    601,   // 10^200
-    634,   // 10^210
-    667,   // 10^220
-    701,   // 10^230
-    734,   // 10^240
-    767,   // 10^250
-    800,   // 10^260
-    833,   // 10^270
-    867,   // 10^280
-    900,   // 10^290
-    933,   // 10^300
-];
-const BASE10_SMALL_INT_POWERS: [u64; 10] = [
-    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
-];
-const BASE10_STEP: i32 = 10;
-const BASE10_BIAS: i32 = 350;
-
-// HIGH LEVEL
-// ----------
-
-const BASE10_POWERS: ModeratePathPowers = ModeratePathPowers {
-    small: ExtendedFloatArray {
-        mant: &BASE10_SMALL_MANTISSA,
-        exp: &BASE10_SMALL_EXPONENT,
-    },
-    large: ExtendedFloatArray {
-        mant: &BASE10_LARGE_MANTISSA,
-        exp: &BASE10_LARGE_EXPONENT,
-    },
-    small_int: &BASE10_SMALL_INT_POWERS,
-    step: BASE10_STEP,
-    bias: BASE10_BIAS,
-};
-
-/// Get powers from base.
-pub(crate) fn get_powers() -> &'static ModeratePathPowers {
-    &BASE10_POWERS
-}
diff --git a/vendor/serde_json/src/lexical/digit.rs b/vendor/serde_json/src/lexical/digit.rs
deleted file mode 100644
index 3d150a1..0000000
--- a/vendor/serde_json/src/lexical/digit.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Helpers to convert and add digits from characters.
-
-// Convert u8 to digit.
-#[inline]
-pub(crate) fn to_digit(c: u8) -> Option<u32> {
-    (c as char).to_digit(10)
-}
-
-// Add digit to mantissa.
-#[inline]
-pub(crate) fn add_digit(value: u64, digit: u32) -> Option<u64> {
-    match value.checked_mul(10) {
-        None => None,
-        Some(n) => n.checked_add(digit as u64),
-    }
-}
diff --git a/vendor/serde_json/src/lexical/errors.rs b/vendor/serde_json/src/lexical/errors.rs
deleted file mode 100644
index f4f41cd..0000000
--- a/vendor/serde_json/src/lexical/errors.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Estimate the error in an 80-bit approximation of a float.
-//!
-//! This estimates the error in a floating-point representation.
-//!
-//! This implementation is loosely based off the Golang implementation,
-//! found here: <https://golang.org/src/strconv/atof.go>
-
-use super::float::*;
-use super::num::*;
-use super::rounding::*;
-
-pub(crate) trait FloatErrors {
-    /// Get the full error scale.
-    fn error_scale() -> u32;
-    /// Get the half error scale.
-    fn error_halfscale() -> u32;
-    /// Determine if the number of errors is tolerable for float precision.
-    fn error_is_accurate<F: Float>(count: u32, fp: &ExtendedFloat) -> bool;
-}
-
-/// Check if the error is accurate with a round-nearest rounding scheme.
-#[inline]
-fn nearest_error_is_accurate(errors: u64, fp: &ExtendedFloat, extrabits: u64) -> bool {
-    // Round-to-nearest, need to use the halfway point.
-    if extrabits == 65 {
-        // Underflow, we have a shift larger than the mantissa.
-        // Representation is valid **only** if the value is close enough
-        // overflow to the next bit within errors. If it overflows,
-        // the representation is **not** valid.
-        !fp.mant.overflowing_add(errors).1
-    } else {
-        let mask: u64 = lower_n_mask(extrabits);
-        let extra: u64 = fp.mant & mask;
-
-        // Round-to-nearest, need to check if we're close to halfway.
-        // IE, b10100 | 100000, where `|` signifies the truncation point.
-        let halfway: u64 = lower_n_halfway(extrabits);
-        let cmp1 = halfway.wrapping_sub(errors) < extra;
-        let cmp2 = extra < halfway.wrapping_add(errors);
-
-        // If both comparisons are true, we have significant rounding error,
-        // and the value cannot be exactly represented. Otherwise, the
-        // representation is valid.
-        !(cmp1 && cmp2)
-    }
-}
-
-impl FloatErrors for u64 {
-    #[inline]
-    fn error_scale() -> u32 {
-        8
-    }
-
-    #[inline]
-    fn error_halfscale() -> u32 {
-        u64::error_scale() / 2
-    }
-
-    #[inline]
-    fn error_is_accurate<F: Float>(count: u32, fp: &ExtendedFloat) -> bool {
-        // Determine if extended-precision float is a good approximation.
-        // If the error has affected too many units, the float will be
-        // inaccurate, or if the representation is too close to halfway
-        // that any operations could affect this halfway representation.
-        // See the documentation for dtoa for more information.
-        let bias = -(F::EXPONENT_BIAS - F::MANTISSA_SIZE);
-        let denormal_exp = bias - 63;
-        // This is always a valid u32, since (denormal_exp - fp.exp)
-        // will always be positive and the significand size is {23, 52}.
-        let extrabits = if fp.exp <= denormal_exp {
-            64 - F::MANTISSA_SIZE + denormal_exp - fp.exp
-        } else {
-            63 - F::MANTISSA_SIZE
-        };
-
-        // Our logic is as follows: we want to determine if the actual
-        // mantissa and the errors during calculation differ significantly
-        // from the rounding point. The rounding point for round-nearest
-        // is the halfway point, IE, this when the truncated bits start
-        // with b1000..., while the rounding point for the round-toward
-        // is when the truncated bits are equal to 0.
-        // To do so, we can check whether the rounding point +/- the error
-        // are >/< the actual lower n bits.
-        //
-        // For whether we need to use signed or unsigned types for this
-        // analysis, see this example, using u8 rather than u64 to simplify
-        // things.
-        //
-        // # Comparisons
-        //      cmp1 = (halfway - errors) < extra
-        //      cmp1 = extra < (halfway + errors)
-        //
-        // # Large Extrabits, Low Errors
-        //
-        //      extrabits = 8
-        //      halfway          =  0b10000000
-        //      extra            =  0b10000010
-        //      errors           =  0b00000100
-        //      halfway - errors =  0b01111100
-        //      halfway + errors =  0b10000100
-        //
-        //      Unsigned:
-        //          halfway - errors = 124
-        //          halfway + errors = 132
-        //          extra            = 130
-        //          cmp1             = true
-        //          cmp2             = true
-        //      Signed:
-        //          halfway - errors = 124
-        //          halfway + errors = -124
-        //          extra            = -126
-        //          cmp1             = false
-        //          cmp2             = true
-        //
-        // # Conclusion
-        //
-        // Since errors will always be small, and since we want to detect
-        // if the representation is accurate, we need to use an **unsigned**
-        // type for comparisons.
-
-        let extrabits = extrabits as u64;
-        let errors = count as u64;
-        if extrabits > 65 {
-            // Underflow, we have a literal 0.
-            return true;
-        }
-
-        nearest_error_is_accurate(errors, fp, extrabits)
-    }
-}
diff --git a/vendor/serde_json/src/lexical/exponent.rs b/vendor/serde_json/src/lexical/exponent.rs
deleted file mode 100644
index 6fc5197..0000000
--- a/vendor/serde_json/src/lexical/exponent.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Utilities to calculate exponents.
-
-/// Convert usize into i32 without overflow.
-///
-/// This is needed to ensure when adjusting the exponent relative to
-/// the mantissa we do not overflow for comically-long exponents.
-#[inline]
-fn into_i32(value: usize) -> i32 {
-    if value > i32::max_value() as usize {
-        i32::max_value()
-    } else {
-        value as i32
-    }
-}
-
-// EXPONENT CALCULATION
-
-// Calculate the scientific notation exponent without overflow.
-//
-// For example, 0.1 would be -1, and 10 would be 1 in base 10.
-#[inline]
-pub(crate) fn scientific_exponent(
-    exponent: i32,
-    integer_digits: usize,
-    fraction_start: usize,
-) -> i32 {
-    if integer_digits == 0 {
-        let fraction_start = into_i32(fraction_start);
-        exponent.saturating_sub(fraction_start).saturating_sub(1)
-    } else {
-        let integer_shift = into_i32(integer_digits - 1);
-        exponent.saturating_add(integer_shift)
-    }
-}
-
-// Calculate the mantissa exponent without overflow.
-//
-// Remove the number of digits that contributed to the mantissa past
-// the dot, and add the number of truncated digits from the mantissa,
-// to calculate the scaling factor for the mantissa from a raw exponent.
-#[inline]
-pub(crate) fn mantissa_exponent(exponent: i32, fraction_digits: usize, truncated: usize) -> i32 {
-    if fraction_digits > truncated {
-        exponent.saturating_sub(into_i32(fraction_digits - truncated))
-    } else {
-        exponent.saturating_add(into_i32(truncated - fraction_digits))
-    }
-}
diff --git a/vendor/serde_json/src/lexical/float.rs b/vendor/serde_json/src/lexical/float.rs
deleted file mode 100644
index 2d434a2..0000000
--- a/vendor/serde_json/src/lexical/float.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-// FLOAT TYPE
-
-use super::num::*;
-use super::rounding::*;
-use super::shift::*;
-
-/// Extended precision floating-point type.
-///
-/// Private implementation, exposed only for testing purposes.
-#[doc(hidden)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) struct ExtendedFloat {
-    /// Mantissa for the extended-precision float.
-    pub mant: u64,
-    /// Binary exponent for the extended-precision float.
-    pub exp: i32,
-}
-
-impl ExtendedFloat {
-    // PROPERTIES
-
-    // OPERATIONS
-
-    /// Multiply two normalized extended-precision floats, as if by `a*b`.
-    ///
-    /// The precision is maximal when the numbers are normalized, however,
-    /// decent precision will occur as long as both values have high bits
-    /// set. The result is not normalized.
-    ///
-    /// Algorithm:
-    ///     1. Non-signed multiplication of mantissas (requires 2x as many bits as input).
-    ///     2. Normalization of the result (not done here).
-    ///     3. Addition of exponents.
-    pub(crate) fn mul(&self, b: &ExtendedFloat) -> ExtendedFloat {
-        // Logic check, values must be decently normalized prior to multiplication.
-        debug_assert!((self.mant & u64::HIMASK != 0) && (b.mant & u64::HIMASK != 0));
-
-        // Extract high-and-low masks.
-        let ah = self.mant >> u64::HALF;
-        let al = self.mant & u64::LOMASK;
-        let bh = b.mant >> u64::HALF;
-        let bl = b.mant & u64::LOMASK;
-
-        // Get our products
-        let ah_bl = ah * bl;
-        let al_bh = al * bh;
-        let al_bl = al * bl;
-        let ah_bh = ah * bh;
-
-        let mut tmp = (ah_bl & u64::LOMASK) + (al_bh & u64::LOMASK) + (al_bl >> u64::HALF);
-        // round up
-        tmp += 1 << (u64::HALF - 1);
-
-        ExtendedFloat {
-            mant: ah_bh + (ah_bl >> u64::HALF) + (al_bh >> u64::HALF) + (tmp >> u64::HALF),
-            exp: self.exp + b.exp + u64::FULL,
-        }
-    }
-
-    /// Multiply in-place, as if by `a*b`.
-    ///
-    /// The result is not normalized.
-    #[inline]
-    pub(crate) fn imul(&mut self, b: &ExtendedFloat) {
-        *self = self.mul(b);
-    }
-
-    // NORMALIZE
-
-    /// Normalize float-point number.
-    ///
-    /// Shift the mantissa so the number of leading zeros is 0, or the value
-    /// itself is 0.
-    ///
-    /// Get the number of bytes shifted.
-    #[inline]
-    pub(crate) fn normalize(&mut self) -> u32 {
-        // Note:
-        // Using the cltz intrinsic via leading_zeros is way faster (~10x)
-        // than shifting 1-bit at a time, via while loop, and also way
-        // faster (~2x) than an unrolled loop that checks at 32, 16, 4,
-        // 2, and 1 bit.
-        //
-        // Using a modulus of pow2 (which will get optimized to a bitwise
-        // and with 0x3F or faster) is slightly slower than an if/then,
-        // however, removing the if/then will likely optimize more branched
-        // code as it removes conditional logic.
-
-        // Calculate the number of leading zeros, and then zero-out
-        // any overflowing bits, to avoid shl overflow when self.mant == 0.
-        let shift = if self.mant == 0 {
-            0
-        } else {
-            self.mant.leading_zeros()
-        };
-        shl(self, shift as i32);
-        shift
-    }
-
-    // ROUND
-
-    /// Lossy round float-point number to native mantissa boundaries.
-    #[inline]
-    pub(crate) fn round_to_native<F, Algorithm>(&mut self, algorithm: Algorithm)
-    where
-        F: Float,
-        Algorithm: FnOnce(&mut ExtendedFloat, i32),
-    {
-        round_to_native::<F, _>(self, algorithm);
-    }
-
-    // FROM
-
-    /// Create extended float from native float.
-    #[inline]
-    pub fn from_float<F: Float>(f: F) -> ExtendedFloat {
-        from_float(f)
-    }
-
-    // INTO
-
-    /// Convert into default-rounded, lower-precision native float.
-    #[inline]
-    pub(crate) fn into_float<F: Float>(mut self) -> F {
-        self.round_to_native::<F, _>(round_nearest_tie_even);
-        into_float(self)
-    }
-
-    /// Convert into downward-rounded, lower-precision native float.
-    #[inline]
-    pub(crate) fn into_downward_float<F: Float>(mut self) -> F {
-        self.round_to_native::<F, _>(round_downward);
-        into_float(self)
-    }
-}
-
-// FROM FLOAT
-
-// Import ExtendedFloat from native float.
-#[inline]
-pub(crate) fn from_float<F>(f: F) -> ExtendedFloat
-where
-    F: Float,
-{
-    ExtendedFloat {
-        mant: u64::as_cast(f.mantissa()),
-        exp: f.exponent(),
-    }
-}
-
-// INTO FLOAT
-
-// Export extended-precision float to native float.
-//
-// The extended-precision float must be in native float representation,
-// with overflow/underflow appropriately handled.
-#[inline]
-pub(crate) fn into_float<F>(fp: ExtendedFloat) -> F
-where
-    F: Float,
-{
-    // Export floating-point number.
-    if fp.mant == 0 || fp.exp < F::DENORMAL_EXPONENT {
-        // sub-denormal, underflow
-        F::ZERO
-    } else if fp.exp >= F::MAX_EXPONENT {
-        // overflow
-        F::from_bits(F::INFINITY_BITS)
-    } else {
-        // calculate the exp and fraction bits, and return a float from bits.
-        let exp: u64;
-        if (fp.exp == F::DENORMAL_EXPONENT) && (fp.mant & F::HIDDEN_BIT_MASK.as_u64()) == 0 {
-            exp = 0;
-        } else {
-            exp = (fp.exp + F::EXPONENT_BIAS) as u64;
-        }
-        let exp = exp << F::MANTISSA_SIZE;
-        let mant = fp.mant & F::MANTISSA_MASK.as_u64();
-        F::from_bits(F::Unsigned::as_cast(mant | exp))
-    }
-}
diff --git a/vendor/serde_json/src/lexical/large_powers.rs b/vendor/serde_json/src/lexical/large_powers.rs
deleted file mode 100644
index c63ce1c..0000000
--- a/vendor/serde_json/src/lexical/large_powers.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Precalculated large powers for limbs.
-
-#[cfg(limb_width_32)]
-pub(crate) use super::large_powers32::*;
-
-#[cfg(limb_width_64)]
-pub(crate) use super::large_powers64::*;
diff --git a/vendor/serde_json/src/lexical/large_powers32.rs b/vendor/serde_json/src/lexical/large_powers32.rs
deleted file mode 100644
index 7991197..0000000
--- a/vendor/serde_json/src/lexical/large_powers32.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Precalculated large powers for 32-bit limbs.
-
-/// Large powers (&[u32]) for base5 operations.
-const POW5_1: [u32; 1] = [5];
-const POW5_2: [u32; 1] = [25];
-const POW5_3: [u32; 1] = [625];
-const POW5_4: [u32; 1] = [390625];
-const POW5_5: [u32; 2] = [2264035265, 35];
-const POW5_6: [u32; 3] = [2242703233, 762134875, 1262];
-const POW5_7: [u32; 5] = [3211403009, 1849224548, 3668416493, 3913284084, 1593091];
-const POW5_8: [u32; 10] = [
-    781532673, 64985353, 253049085, 594863151, 3553621484, 3288652808, 3167596762, 2788392729,
-    3911132675, 590,
-];
-const POW5_9: [u32; 19] = [
-    2553183233, 3201533787, 3638140786, 303378311, 1809731782, 3477761648, 3583367183, 649228654,
-    2915460784, 487929380, 1011012442, 1677677582, 3428152256, 1710878487, 1438394610, 2161952759,
-    4100910556, 1608314830, 349175,
-];
-const POW5_10: [u32; 38] = [
-    4234999809, 2012377703, 2408924892, 1570150255, 3090844311, 3273530073, 1187251475, 2498123591,
-    3364452033, 1148564857, 687371067, 2854068671, 1883165473, 505794538, 2988060450, 3159489326,
-    2531348317, 3215191468, 849106862, 3892080979, 3288073877, 2242451748, 4183778142, 2995818208,
-    2477501924, 325481258, 2487842652, 1774082830, 1933815724, 2962865281, 1168579910, 2724829000,
-    2360374019, 2315984659, 2360052375, 3251779801, 1664357844, 28,
-];
-const POW5_11: [u32; 75] = [
-    689565697, 4116392818, 1853628763, 516071302, 2568769159, 365238920, 336250165, 1283268122,
-    3425490969, 248595470, 2305176814, 2111925499, 507770399, 2681111421, 589114268, 591287751,
-    1708941527, 4098957707, 475844916, 3378731398, 2452339615, 2817037361, 2678008327, 1656645978,
-    2383430340, 73103988, 448667107, 2329420453, 3124020241, 3625235717, 3208634035, 2412059158,
-    2981664444, 4117622508, 838560765, 3069470027, 270153238, 1802868219, 3692709886, 2161737865,
-    2159912357, 2585798786, 837488486, 4237238160, 2540319504, 3798629246, 3748148874, 1021550776,
-    2386715342, 1973637538, 1823520457, 1146713475, 833971519, 3277251466, 905620390, 26278816,
-    2680483154, 2294040859, 373297482, 5996609, 4109575006, 512575049, 917036550, 1942311753,
-    2816916778, 3248920332, 1192784020, 3537586671, 2456567643, 2925660628, 759380297, 888447942,
-    3559939476, 3654687237, 805,
-];
-const POW5_12: [u32; 149] = [
-    322166785, 3809044581, 2994556223, 1239584207, 3962455841, 4001882964, 3053876612, 915114683,
-    2783289745, 785739093, 4253185907, 3931164994, 1370983858, 2553556126, 3360742076, 2255410929,
-    422849554, 2457422215, 3539495362, 1720790602, 1908931983, 1470596141, 592794347, 4219465164,
-    4085652704, 941661409, 2534650953, 885063988, 2355909854, 2812815516, 767256131, 3821757683,
-    2155151105, 3817418473, 281116564, 2834395026, 2821201622, 2524625843, 1511330880, 2572352493,
-    330571332, 2951088579, 2730271766, 4044456479, 4212286644, 2444937588, 3603420843, 2387148597,
-    1142537539, 3299235429, 1751012624, 861228086, 2873722519, 230498814, 1023297821, 2553128038,
-    3421129895, 2651917435, 2042981258, 1606787143, 2228751918, 447345732, 1930371132, 1784132011,
-    3612538790, 2275925090, 2487567871, 1080427616, 2009179183, 3383506781, 3899054063, 1950782960,
-    2168622213, 2717674390, 3616636027, 2079341593, 1530129217, 1461057425, 2406264415, 3674671357,
-    2972036238, 2019354295, 1455849819, 1866918619, 1324269294, 424891864, 2722422332, 2641594816,
-    1400249021, 3482963993, 3734946379, 225889849, 1891545473, 777383150, 3589824633, 4117601611,
-    4220028667, 334453379, 1083130821, 1060342180, 4208163139, 1489826908, 4163762246, 1096580926,
-    689301528, 2336054516, 1782865703, 4175148410, 3398369392, 2329412588, 3001580596, 59740741,
-    3202189932, 3351895776, 246185302, 718535188, 3772647488, 4151666556, 4055698133, 2461934110,
-    2281316281, 3466396836, 3536023465, 1064267812, 2955456354, 2423805422, 3627960790, 1325057500,
-    3876919979, 2009959531, 175455101, 184092852, 2358785571, 3842977831, 2485266289, 487121622,
-    4159252710, 4075707558, 459389244, 300652075, 2521346588, 3458976673, 888631636, 2076098096,
-    3844514585, 2363697580, 3729421522, 3051115477, 649395,
-];
-const POW5_13: [u32; 298] = [
-    711442433, 3564261005, 2399042279, 4170849936, 4010295575, 1423987028, 330414929, 1349249065,
-    4213813618, 3852031822, 4040843590, 2154565331, 3094013374, 1159028371, 3227065538, 2115927092,
-    2085102554, 488590542, 2609619432, 3602898805, 3812736528, 3269439096, 23816114, 253984538,
-    1035905997, 2942969204, 3400787671, 338562688, 1637191975, 740509713, 2264962817, 3410753922,
-    4162231428, 2282041228, 1759373012, 3155367777, 4278913285, 1420532801, 1981002276, 438054990,
-    1006507643, 1142697287, 1332538012, 2029019521, 3949305784, 818392641, 2491288846, 2716584663,
-    3648886102, 556814413, 444795339, 4071412999, 1066321706, 4253169466, 2510832316, 672091442,
-    4083256000, 2165985028, 1841538484, 3549854235, 364431512, 3707648143, 1162785440, 2268641545,
-    281340310, 735693841, 848809228, 1700785200, 2919703985, 4094234344, 58530286, 965505005,
-    1000010347, 3381961808, 3040089923, 1973852082, 2890971585, 1019960210, 4292895237, 2821887841,
-    3756675650, 3951282907, 3885870583, 1008791145, 503998487, 1881258362, 1949332730, 392996726,
-    2012973814, 3970014187, 2461725150, 2942547730, 3728066699, 2766901132, 3778532841, 1085564064,
-    2278673896, 1116879805, 3448726271, 774279411, 157211670, 1506320155, 531168605, 1362654525,
-    956967721, 2148871960, 769186085, 4186232894, 2055679604, 3248365487, 3981268013, 3975787984,
-    2489510517, 3309046495, 212771124, 933418041, 3371839114, 562115198, 1853601831, 757336096,
-    1354633440, 1486083256, 2872126393, 522920738, 1141587749, 3210903262, 1926940553, 3054024853,
-    2021162538, 2262742000, 1877899947, 3147002868, 669840763, 4158174590, 4238502559, 1023731922,
-    3386840011, 829588074, 3449720188, 2835142880, 2999162007, 813056473, 482949569, 638108879,
-    3067201471, 1026714238, 4004452838, 2383667807, 3999477803, 771648919, 630660440, 3827121348,
-    176185980, 2878191002, 2666149832, 3909811063, 2429163983, 2665690412, 907266128, 4269332098,
-    2022665808, 1527122180, 3072053668, 1072477492, 3006022924, 549664855, 2800340954, 37352654,
-    1212772743, 2711280533, 3029527946, 2511120040, 1305308377, 3474662224, 4226330922, 442988428,
-    954940108, 3274548099, 4212288177, 2688499880, 3982226758, 3922609956, 1279948029, 1939943640,
-    3650489901, 2733364929, 2494263275, 1864579964, 1225941120, 2390465139, 1267503249, 3533240729,
-    904410805, 2842550015, 2517736241, 1796069820, 3335274381, 673539835, 1924694759, 3598098235,
-    2792633405, 16535707, 3703535497, 3592841791, 2929082877, 1317622811, 294990855, 1396706563,
-    2383271770, 3853857605, 277813677, 277580220, 1101318484, 3761974115, 1132150143, 2544692622,
-    3419825776, 743770306, 1695464553, 1548693232, 2421159615, 2575672031, 2678971806, 1591267897,
-    626546738, 3823443129, 267710932, 1455435162, 2353985540, 3248523795, 335348168, 3872552561,
-    2814522612, 2634118860, 3503767026, 1301019273, 1414467789, 722985138, 3070909565, 4253482569,
-    3744939841, 558142907, 2229819389, 13833173, 77003966, 2763671364, 3905603970, 2931990126,
-    2280419384, 1879090457, 2934846267, 4284933164, 2331863845, 62191163, 3178861020, 1522063815,
-    785672270, 1215568492, 2936443917, 802972489, 2956820173, 3916732783, 2893572089, 1391232801,
-    3168640330, 2396859648, 894950918, 1103583736, 961991865, 2807302642, 305977505, 3054505899,
-    1048256994, 781017659, 2459278754, 3164823415, 537658277, 905753687, 464963300, 4149131560,
-    1029507924, 2278300961, 1231291503, 414073408, 3630740085, 2345841814, 475358196, 3258243317,
-    4167625072, 4178911231, 2927355042, 655438830, 3138378018, 623200562, 2785714112, 273403236,
-    807993669, 98,
-];
-const POW5_14: [u32; 595] = [
-    1691320321, 2671006246, 1682531301, 2072858707, 1240508969, 3108358191, 1125119096, 2470144952,
-    1610099978, 1690632660, 1941696884, 2663506355, 1006364675, 3909158537, 4147711374, 1072663936,
-    4078768933, 745751659, 4123687570, 471458681, 655028926, 4113407388, 3945524552, 985625313,
-    1254424514, 2127508744, 570530434, 945388122, 3194649404, 2589065070, 2731705399, 202030749,
-    2090780394, 3348662271, 1481754777, 1130635472, 4025144705, 1924486271, 2578567861, 125491448,
-    1558036315, 994248173, 3817216711, 763950077, 1030439870, 959586474, 3845661701, 483795093,
-    1637944470, 2275463649, 3398804829, 1758016486, 2665513698, 2004912571, 1094885097, 4223064276,
-    3307819021, 651121777, 1757003305, 3603542336, 129917786, 2215974994, 3042386306, 2205352757,
-    3944939700, 3710987569, 97967515, 1217242524, 930630949, 3660328512, 1787663098, 1784141600,
-    2500542892, 4034561586, 3444961378, 785043562, 3869499367, 885623728, 2625011087, 3053789617,
-    1965731793, 3900511934, 2648823592, 3851062028, 3321968688, 799195417, 1011847510, 1369129160,
-    1348009103, 2876796955, 2915408967, 3305284948, 263399535, 1715990604, 2645821294, 1587844552,
-    2624912049, 3035631499, 2306636348, 3499275462, 675152704, 854794152, 4004972748, 1739996642,
-    1333476491, 4012621867, 3658792931, 3297985728, 2864481726, 3066357406, 785287846, 1671499798,
-    433044045, 1919608025, 264833858, 3999983367, 1116778570, 1301982149, 4213901070, 4081649357,
-    536169226, 1389008649, 188923873, 373495152, 2551132278, 1800758715, 3951840330, 2632334454,
-    3118778225, 1034046547, 1862428410, 3037609062, 1994608505, 29051798, 2571685694, 264151332,
-    2260643090, 2717535964, 3508441116, 3283713017, 1903365635, 923575694, 1219598101, 2288281570,
-    3676533911, 1014136356, 555142354, 2389170030, 4185108175, 884862419, 836141292, 2957159173,
-    1997444768, 4233903127, 2876184692, 3089125070, 1480848293, 1097600237, 299700527, 2507669891,
-    2982628312, 2114881043, 2529576251, 2812279824, 2987750993, 4241938954, 2204775591, 1037094060,
-    829315638, 1231047149, 52608178, 3735136637, 3455232602, 962039123, 488286513, 50685385,
-    3516451821, 843975207, 1572355722, 675489076, 2428445672, 1555117248, 3708476086, 10375249,
-    4172112346, 2117510871, 2227658327, 3187664554, 3050656558, 328034318, 3179601324, 1247769761,
-    3439263953, 1431538938, 2962525068, 1213366289, 3813013550, 2651093719, 1860661503, 3933716208,
-    264320617, 789980519, 2257856172, 102000748, 977269860, 1113845122, 3008928583, 1461738106,
-    557786285, 2926560363, 1038106190, 3643478847, 828004507, 457818698, 1933056971, 373408056,
-    2076808229, 3160935130, 2781854874, 2519636100, 177606000, 4237103862, 3977834316, 1621936232,
-    2599050516, 319893558, 3343370366, 765044144, 976657331, 7026264, 294277429, 3829376742,
-    3029627280, 2705178718, 3614653880, 230519152, 3288033233, 293525479, 3805751881, 3227511198,
-    2520308544, 3648103003, 1111086184, 437622105, 2232033852, 3239146386, 584244184, 1450926016,
-    2462430443, 3226534010, 298582169, 4214576928, 1762099469, 964985185, 1585788148, 1641127666,
-    787006566, 2315956284, 3258232694, 2275058964, 2541003317, 1508235863, 2613339827, 4080647514,
-    1152057965, 3149266279, 731345410, 914737650, 65395712, 1884566942, 1379520432, 2611027720,
-    4163073378, 2619704967, 2746552541, 1388822415, 3005141199, 843440249, 4288674003, 3136174279,
-    4051522914, 4144149433, 3427566947, 3419023197, 3758479825, 3893877676, 96899594, 1657725776,
-    253618880, 434129337, 1499045748, 2996992534, 4036042074, 2110713869, 906222950, 928326225,
-    2541827893, 1604330202, 226792470, 4022228930, 815850898, 1466012310, 3377712199, 292769859,
-    2822055597, 3225701344, 3052947004, 385831222, 705324593, 4030158636, 3540280538, 2982120874,
-    2136414455, 255762046, 3852783591, 3262064164, 2358991588, 3756586117, 4143612643, 3326743817,
-    2897365738, 807711264, 3719310016, 3721264861, 3627337076, 944539331, 3640975513, 3712525681,
-    1162911839, 2008243316, 2179489649, 2867584109, 261861553, 3570253908, 2062868357, 2220328623,
-    3857004679, 3744109002, 4138041873, 1451860932, 2364975637, 2802161722, 2680106834, 753401584,
-    1223182946, 1245401957, 4163377735, 3565815922, 2216942838, 4036140094, 71979081, 3924559643,
-    400477238, 551750683, 1174153235, 859969898, 1185921017, 1711399735, 812991545, 4051735761,
-    3549118738, 1631653329, 3631835958, 3648867800, 1206500363, 2155893137, 361030362, 3454286017,
-    2505909489, 1083595169, 453595313, 1510564703, 1706163902, 1632924345, 1381875722, 1661526119,
-    1082778324, 3571910052, 1140625929, 851544870, 1145546234, 2938573139, 907528924, 1304752338,
-    1764668294, 1788942063, 1700368828, 104979467, 1413911959, 3327497828, 1956384744, 1272712474,
-    2815637534, 3307809377, 1320574940, 1111968962, 4073107827, 434096622, 169451929, 3201183459,
-    3331028877, 2852366972, 3369830128, 2924794558, 3106537952, 3739481231, 1612955817, 4138608722,
-    2721281595, 2755775390, 843505117, 982234295, 1157276611, 814674632, 4246504726, 3532006708,
-    992340967, 1647538031, 204696133, 193866982, 3899126129, 300851698, 1379496684, 1759463683,
-    1354782756, 1374637239, 3410883240, 1073406229, 3038431791, 1053909855, 3607043270, 173719711,
-    3733903830, 171820911, 1573050589, 932781534, 4183534770, 2158849555, 372245998, 3573073830,
-    841339264, 2759200520, 1610547277, 2603293319, 3890906486, 1557138278, 3964109906, 677238797,
-    537994297, 1124184993, 4287078344, 4207654540, 2943022776, 2977947524, 3255359985, 4098397558,
-    2274666217, 2915862060, 243524940, 2467726756, 2869020032, 507521339, 3403121914, 522051455,
-    1803903108, 3471254194, 473535371, 1948602036, 3352095732, 3116527002, 1795743673, 775867940,
-    2551469548, 3757442064, 3162525227, 3765412747, 3040105484, 1927625810, 48214767, 2997207130,
-    1342349989, 2536583992, 1501320191, 3592287317, 887432730, 967585477, 3334212779, 948663609,
-    1064513472, 15386372, 2465931737, 3230242590, 3036652803, 2063155087, 1927500726, 2821790499,
-    2187774383, 501520074, 3688568496, 3606711121, 2576459247, 3176542345, 378322447, 156541411,
-    1400607301, 1406179107, 677848877, 2253753529, 193196070, 4207435024, 4166396241, 509467541,
-    2906024136, 1221753746, 3375413222, 431327897, 2749265123, 2848827671, 3412997614, 2051920238,
-    1283516885, 1300498239, 1957256104, 2634010560, 3531900395, 360276850, 1461184973, 2012063967,
-    2873572430, 2914608609, 4289554777, 1539331673, 1859532928, 4213441063, 538215691, 3512720863,
-    4258743698, 3040408445, 982396546, 343095663, 4138069496, 1021581857, 214185242, 1968079460,
-    2864275059, 3347192726, 4096783459, 3259169450, 3707808869, 142485006, 399610869, 230556456,
-    2219467721, 4191227798, 2242548189, 3136366572, 179755707, 3464881829, 452317775, 3887426070,
-    3446430233, 1473370015, 1576807208, 3964523248, 419325089, 2373067114, 1596072055, 1928415752,
-    3635452689, 1005598891, 3335462724, 3290848636, 3669078247, 1178176812, 2110774376, 3068593619,
-    1253036518, 908857731, 3631223047, 4138506423, 2903592318, 3596915748, 3289036113, 3721512676,
-    2704409359, 3386016968, 3676268074, 2185259502, 1096257611, 3360076717, 3548676554, 170167319,
-    3360064287, 3899940843, 9640,
-];
-
-pub(crate) const POW5: [&'static [u32]; 14] = [
-    &POW5_1, &POW5_2, &POW5_3, &POW5_4, &POW5_5, &POW5_6, &POW5_7, &POW5_8, &POW5_9, &POW5_10,
-    &POW5_11, &POW5_12, &POW5_13, &POW5_14,
-];
diff --git a/vendor/serde_json/src/lexical/large_powers64.rs b/vendor/serde_json/src/lexical/large_powers64.rs
deleted file mode 100644
index ee36561..0000000
--- a/vendor/serde_json/src/lexical/large_powers64.rs
+++ /dev/null
@@ -1,625 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Precalculated large powers for 64-bit limbs.
-
-/// Large powers (&[u64]) for base5 operations.
-const POW5_1: [u64; 1] = [5];
-const POW5_2: [u64; 1] = [25];
-const POW5_3: [u64; 1] = [625];
-const POW5_4: [u64; 1] = [390625];
-const POW5_5: [u64; 1] = [152587890625];
-const POW5_6: [u64; 2] = [3273344365508751233, 1262];
-const POW5_7: [u64; 3] = [7942358959831785217, 16807427164405733357, 1593091];
-const POW5_8: [u64; 5] = [
-    279109966635548161,
-    2554917779393558781,
-    14124656261812188652,
-    11976055582626787546,
-    2537941837315,
-];
-const POW5_9: [u64; 10] = [
-    13750482914757213185,
-    1302999927698857842,
-    14936872543252795590,
-    2788415840139466767,
-    2095640732773017264,
-    7205570348933370714,
-    7348167152523113408,
-    9285516396840364274,
-    6907659600622710236,
-    349175,
-];
-const POW5_10: [u64; 19] = [
-    8643096425819600897,
-    6743743997439985372,
-    14059704609098336919,
-    10729359125898331411,
-    4933048501514368705,
-    12258131603170554683,
-    2172371001088594721,
-    13569903330219142946,
-    13809142207969578845,
-    16716360519037769646,
-    9631256923806107285,
-    12866941232305103710,
-    1397931361048440292,
-    7619627737732970332,
-    12725409486282665900,
-    11703051443360963910,
-    9947078370803086083,
-    13966287901448440471,
-    121923442132,
-];
-const POW5_11: [u64; 38] = [
-    17679772531488845825,
-    2216509366347768155,
-    1568689219195129479,
-    5511594616325588277,
-    1067709417009240089,
-    9070650952098657518,
-    11515285870634858015,
-    2539561553659505564,
-    17604889300961091799,
-    14511540856854204724,
-    12099083339557485471,
-    7115240299237943815,
-    313979240050606788,
-    10004784664717172195,
-    15570268847930131473,
-    10359715202835930803,
-    17685054012115162812,
-    13183273382855797757,
-    7743260039872919062,
-    9284593436392572926,
-    11105921222066415013,
-    18198799323400703846,
-    16314988383739458320,
-    4387527177871570570,
-    8476708682254672590,
-    4925096874831034057,
-    14075687868072027455,
-    112866656203221926,
-    9852830467773230418,
-    25755239915196746,
-    2201493076310172510,
-    8342165458688466438,
-    13954006576066379050,
-    15193819059903295636,
-    12565616718911389531,
-    3815854855847885129,
-    15696762163583540628,
-    805,
-];
-const POW5_12: [u64; 75] = [
-    16359721904723189761,
-    5323973632697650495,
-    17187956456762001185,
-    3930387638628283780,
-    3374723710406992273,
-    16884225088663222131,
-    10967440051041439154,
-    9686916182456720060,
-    10554548046311730194,
-    7390739362393647554,
-    6316162333127736719,
-    18122464886584070891,
-    4044404959645932768,
-    3801320885861987401,
-    12080950653257274590,
-    16414324262488991299,
-    16395687498836410113,
-    12173633940896186260,
-    10843185433142632150,
-    11048169832730399808,
-    12674828934734683716,
-    17370808310130582550,
-    10500926985433408692,
-    10252725158410704555,
-    14170108270502067523,
-    3698946465517688080,
-    989984870770509463,
-    10965601426733943069,
-    11389898658438335655,
-    6901098232861256586,
-    1921335291173932590,
-    7662788640922083388,
-    9775023833308395430,
-    4640401278902814207,
-    14532050972198413359,
-    8378549018693130223,
-    11672322628395371653,
-    8930704142764178555,
-    6275193859483102017,
-    15782593304269205087,
-    8673060659034172558,
-    8018354414354334043,
-    1824896661540749038,
-    11345563346725559868,
-    14959216444480821949,
-    970189517688324683,
-    3338835207603007873,
-    17684964260791738489,
-    1436466329061721851,
-    4554134986752476101,
-    6398757850768963907,
-    4709779218751158342,
-    10033277748582410264,
-    17932125878679265063,
-    10004750887749091440,
-    256584531835386932,
-    14396282740722731628,
-    3086085133731396950,
-    17831272085689600064,
-    10573926491412564693,
-    14888061047859191737,
-    4570995450261499817,
-    10410165022312935266,
-    5691078631447480790,
-    8632710455805418155,
-    790672778942823293,
-    16505464105756800547,
-    2092171438149740401,
-    17505030673829275878,
-    1291290830058928444,
-    14856191690683232796,
-    8916773426496500052,
-    10152003807578858265,
-    13104441193763861714,
-    649395,
-];
-const POW5_13: [u64; 149] = [
-    15308384451594534913,
-    17913664074042735335,
-    6115977719198531863,
-    5794980608663993169,
-    16544350702855106930,
-    9253787637781258566,
-    4977988951675168190,
-    9087837664087448770,
-    2098480401110016986,
-    15474332540882100712,
-    14042133997396540944,
-    1090855284423485362,
-    12639956485351058381,
-    1454115676006639319,
-    3180465001342538023,
-    14649076551958697729,
-    9801292446545910916,
-    13552201410826594004,
-    6101141927469189381,
-    1881431857880609316,
-    4907847477899433595,
-    8714572486973123228,
-    3514969632331374520,
-    11667642286891470094,
-    2391499697425323350,
-    17486585679659076043,
-    18267223761882105642,
-    2886610765822313148,
-    9302834862968900288,
-    15246507846733637044,
-    15924227519624562840,
-    9743741243284697760,
-    3159780987244964246,
-    7304816812369628428,
-    17584602612559717809,
-    4146812420657846766,
-    14525415362681041515,
-    8477630142371600195,
-    4380695748062263745,
-    12119915994367943173,
-    16970630866565485122,
-    4332724980155264503,
-    8079943140620527639,
-    1687908087554405626,
-    17051081099834002166,
-    12638146269730763230,
-    11883749876933445771,
-    4662462156371383785,
-    4796962238316531176,
-    3325504751659868927,
-    6469595803187862550,
-    5852556621152583005,
-    9229334792448387881,
-    17979733373938620709,
-    13951623534175792756,
-    17075879371091039277,
-    14212246479457938037,
-    4008999959804158260,
-    2414266395366403722,
-    3252733766253918247,
-    6382678985007829216,
-    2245927470982310841,
-    13790724502051307301,
-    13116936866733148041,
-    9718402891306794538,
-    13516274400356104875,
-    17859223875778049403,
-    4396895129099725471,
-    3563053650368467915,
-    12176845952536972668,
-    3492050964335269015,
-    2740656767075170753,
-    4409704077614761919,
-    10237775279597492710,
-    3314206875098230827,
-    16437361028114095448,
-    12361736225407656572,
-    16792510651790145480,
-    11449053143229929935,
-    18336641737580333136,
-    6558939822118891088,
-    4606255756908155300,
-    2360792578991605004,
-    160428430149144538,
-    11644861220729221511,
-    10785178451159739786,
-    14923560618031934681,
-    1902620814992781610,
-    14064076995338910412,
-    11547019064112212657,
-    16847481479966225734,
-    8331994491163145469,
-    11739712981738851885,
-    8008309968651120619,
-    10266969595459035264,
-    15175153381217702033,
-    12208659352573720245,
-    7714061140750342961,
-    2892831567213510541,
-    15453714249045017319,
-    71020323573871677,
-    15431137995750602633,
-    5659146884637671933,
-    5998809010488554503,
-    16552192379299157850,
-    1192197967194298797,
-    16157555793424861524,
-    10929371590994640255,
-    3194469143425738352,
-    6651586784672005225,
-    11062427140788057791,
-    6834443579468668318,
-    16421563197797455922,
-    6251046422506172884,
-    13952303462156793860,
-    16632486601871393224,
-    11313454360291325172,
-    5587835232504462834,
-    3105197524618514637,
-    18268568531031972989,
-    2397205535804309313,
-    59413027864729597,
-    11869878125348715710,
-    12592801707270523266,
-    8070632061321113656,
-    18403647807860650811,
-    267109013517069093,
-    6537214311028855260,
-    5220826919973709902,
-    3448740582779163661,
-    16822239213112884941,
-    5975299384311048185,
-    10294433804430712138,
-    4739856055412448774,
-    12057273038326387897,
-    13119002941950056609,
-    3354445304051737058,
-    13592813067499314594,
-    3890182464434078629,
-    17820384357466425060,
-    9785228118969879380,
-    1778431746734556271,
-    10075313876350055029,
-    13994048489400919028,
-    17948287074199726448,
-    2815088342305858722,
-    2676626035777198370,
-    1174257960026283968,
-    421714788677,
-];
-const POW5_14: [u64; 298] = [
-    11471884475673051137,
-    8902860357476377573,
-    13350296775839230505,
-    10609191786344608888,
-    7261211985859587338,
-    11439672689354862964,
-    16789708072300570627,
-    4607056528866348430,
-    3202978990421512997,
-    2024899620433984146,
-    17666950207239811774,
-    4233228489390288200,
-    9137580478688460738,
-    4060411066587388546,
-    11119949806060600124,
-    867715462473090103,
-    14382394941384869610,
-    4856042377419278489,
-    8265605599571137921,
-    538981667666252469,
-    4270263388700786523,
-    3281140600308898503,
-    4121392524544394174,
-    2077884106245940229,
-    9773041957329767574,
-    7550623316597646685,
-    8611033926449791714,
-    18137922955420802793,
-    2796546741236224013,
-    15477096484628446761,
-    9517540128113714010,
-    9471917970500821378,
-    15938570248662483124,
-    5228016831978462619,
-    15720991252586974501,
-    7662829825220776698,
-    17328310068068434348,
-    3371736428170309730,
-    3803724952191098855,
-    13115926536504376719,
-    16752571196153442257,
-    16540185467776259880,
-    3432518182450051120,
-    5880364967211798870,
-    12355748840305392783,
-    14196090758536469575,
-    7370123524686686319,
-    6819740424617592686,
-    13037938013537368753,
-    15029273671291927100,
-    3671312928327205696,
-    7473228676544792780,
-    17234079691312938123,
-    14164740848093544419,
-    13169904779481875902,
-    7179036968465894054,
-    8244653688947194445,
-    17179797746073799490,
-    5591970751047577674,
-    17530550506268329742,
-    5965746721852312330,
-    1604149463243472865,
-    7734199791463116918,
-    11305790396015856714,
-    4441196105025505137,
-    13046431581185664762,
-    124776524294606713,
-    1134521334706523966,
-    11671728093344476434,
-    14103440020972933148,
-    3966727403013869059,
-    9828094508409132821,
-    4355682486381147287,
-    10261407143988481234,
-    3800455155249557199,
-    12700901937937547500,
-    18184475466894579360,
-    13267691151779895412,
-    4714157123477697445,
-    10770360171308585263,
-    9083344917597998040,
-    12078649873810212155,
-    18218989082046199377,
-    4454285072780637351,
-    5287307245618354742,
-    16042289702059031730,
-    4131926574212754010,
-    217692071448455473,
-    3624845916216282093,
-    2901203491797614218,
-    6679177724033967080,
-    44561358851332790,
-    9094639944041587162,
-    13690915012276084311,
-    1408896670826320686,
-    5359130319612337580,
-    6148412925099835601,
-    5211368532286409612,
-    11386360825549027374,
-    16895182466965795071,
-    3392940493846427241,
-    438089879085393580,
-    4783928372776399972,
-    6278117363595909959,
-    12569481049412674733,
-    15648622492570893902,
-    1966316336235305115,
-    1603775390515993547,
-    13576113010204316709,
-    10821754650102840474,
-    18198222517222903152,
-    6966163076615302988,
-    1373932372410129684,
-    3285839581819684990,
-    30177575069719475,
-    16447047871247307061,
-    11618654126674833808,
-    990072222556306872,
-    1260682336135768017,
-    13862055046689532489,
-    15668483092844698432,
-    1879572630092764264,
-    13912027797058626108,
-    6231679788219816920,
-    13857858054844167403,
-    18101470072534728857,
-    4144579812461609229,
-    7048589655616599284,
-    9946956499532694630,
-    9771303850109874038,
-    6477823708780339765,
-    17526247621747041971,
-    13525995675852669549,
-    3928768291901239810,
-    8094153383078124544,
-    11214278667728965552,
-    11251547162596832610,
-    5964946855123292381,
-    3622548288590237903,
-    13469765967150053587,
-    17798986288523466082,
-    14684592818807932259,
-    16724077276802963921,
-    7119877993753121290,
-    1864571304902781632,
-    12871984921385213812,
-    9065447042604670298,
-    3987130777300360550,
-    6890545752116901685,
-    17275341711601865750,
-    6296474927799264658,
-    1257436973037243463,
-    13854281781965301421,
-    1657132483318662716,
-    17309399540017292849,
-    12808111630089217242,
-    1098489625264462071,
-    14010458905686364135,
-    16134414519481621220,
-    14288255900328821475,
-    3469093466388187882,
-    15982710881468295872,
-    4056765540058056052,
-    15945176389096104089,
-    8625339365793505375,
-    12316179968863788913,
-    15334123773538054321,
-    9536238824220581765,
-    16080825720106203271,
-    6235695225418121745,
-    12035192956458019349,
-    3235835166714703698,
-    5348960676912581218,
-    15315062772709464647,
-    17335089708021308662,
-    16855855317958414409,
-    2369751139431140406,
-    3693542588628609043,
-    7350405893393987577,
-    17402072586341663801,
-    7007897690013647122,
-    15671767872059304758,
-    9259490518292347915,
-    14836045474406130394,
-    4654005815464502513,
-    6487825998330548401,
-    7013356660323385022,
-    7136200343936679946,
-    15341236858676437716,
-    3657357368867197449,
-    12621075530054608378,
-    5603868621997066972,
-    7683447656788439942,
-    450883379216880060,
-    14291494350184945047,
-    5466258454997635048,
-    14206933098432772126,
-    4775870327277641692,
-    1864430798867181939,
-    13748978265070608793,
-    12250822864261576589,
-    12561896977498605296,
-    16060949594257359328,
-    17775189113543311529,
-    11835965177892927035,
-    4218664174878121437,
-    3499000902478111683,
-    15169853304359126294,
-    7076121963053575143,
-    832652347668916805,
-    1292148207755194737,
-    7556838978364207852,
-    5904021986723518500,
-    4610244652288570024,
-    4526508363195533871,
-    746120481022614726,
-    737965197247830486,
-    4006266184415762653,
-    9272188239892688050,
-    15346235246415709678,
-    11850675997347533184,
-    11181059668610842701,
-    6687857983250662774,
-    2908718488661492818,
-    4828337780126983225,
-    18071738646453002184,
-    12790187227727197880,
-    17602483480871623153,
-    12523532189621855977,
-    10598805712727696716,
-    2179787555896149376,
-    2242193929457337594,
-    14908923241136742532,
-    8369182018012550027,
-    13385381554043022324,
-    3332327430110633913,
-    16138090784046208492,
-    16172324607469047339,
-    8279089815915615244,
-    12872906602736235247,
-    10894545290539475621,
-    15428756545851905023,
-    4155747980686992922,
-    4074479178894544043,
-    66083965608603584,
-    13873786284662268377,
-    8861183628277687555,
-    12119497911296021430,
-    2154012318305274287,
-    15490706314503067312,
-    13643145488710608367,
-    672340241093017103,
-    6039493278284091973,
-    9679797700977436461,
-    18070795828318171174,
-    2188146431134935377,
-    5247392385741514952,
-    1852539214842869734,
-    12235621681634112739,
-    8812930319623534062,
-    5585597406294108629,
-    11312989214475901864,
-    1547377291787797995,
-    8641748937186208205,
-    12518148659168623694,
-    6611379197521520985,
-    18096591571068008576,
-    15087021227100112139,
-    13058454842015958418,
-    1473584652966833794,
-    4387660670140018168,
-    8452836916843525402,
-    14376083294443363955,
-    13998026203969090659,
-    611968444648172645,
-    990232438801273845,
-    18001186324715561929,
-    13470591857250177501,
-    14881554140239420091,
-    16696367836720124495,
-    6328076032778459673,
-    17027497695968504616,
-    10192245646262428833,
-    8282482589527318647,
-    4319014353374321425,
-    14134087271041670980,
-    5060230880114618599,
-    13179509240430058600,
-    3903514232614801894,
-    17774749744702165255,
-    15448635507030969726,
-    15983775238358480209,
-    14542832143965487887,
-    9385618098039514666,
-    14431419612662304843,
-    730863073501675978,
-    16750118380379734815,
-    9640,
-];
-
-pub(crate) const POW5: [&[u64]; 14] = [
-    &POW5_1, &POW5_2, &POW5_3, &POW5_4, &POW5_5, &POW5_6, &POW5_7, &POW5_8, &POW5_9, &POW5_10,
-    &POW5_11, &POW5_12, &POW5_13, &POW5_14,
-];
diff --git a/vendor/serde_json/src/lexical/math.rs b/vendor/serde_json/src/lexical/math.rs
deleted file mode 100644
index d7122bf..0000000
--- a/vendor/serde_json/src/lexical/math.rs
+++ /dev/null
@@ -1,886 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Building-blocks for arbitrary-precision math.
-//!
-//! These algorithms assume little-endian order for the large integer
-//! buffers, so for a `vec![0, 1, 2, 3]`, `3` is the most significant limb,
-//! and `0` is the least significant limb.
-
-use super::large_powers;
-use super::num::*;
-use super::small_powers::*;
-use alloc::vec::Vec;
-use core::{cmp, iter, mem};
-
-// ALIASES
-// -------
-
-//  Type for a single limb of the big integer.
-//
-//  A limb is analogous to a digit in base10, except, it stores 32-bit
-//  or 64-bit numbers instead.
-//
-//  This should be all-known 64-bit platforms supported by Rust.
-//      https://forge.rust-lang.org/platform-support.html
-//
-//  Platforms where native 128-bit multiplication is explicitly supported:
-//      - x86_64 (Supported via `MUL`).
-//      - mips64 (Supported via `DMULTU`, which `HI` and `LO` can be read-from).
-//
-//  Platforms where native 64-bit multiplication is supported and
-//  you can extract hi-lo for 64-bit multiplications.
-//      aarch64 (Requires `UMULH` and `MUL` to capture high and low bits).
-//      powerpc64 (Requires `MULHDU` and `MULLD` to capture high and low bits).
-//
-//  Platforms where native 128-bit multiplication is not supported,
-//  requiring software emulation.
-//      sparc64 (`UMUL` only supported double-word arguments).
-
-// 32-BIT LIMB
-#[cfg(limb_width_32)]
-pub type Limb = u32;
-
-#[cfg(limb_width_32)]
-pub const POW5_LIMB: &[Limb] = &POW5_32;
-
-#[cfg(limb_width_32)]
-pub const POW10_LIMB: &[Limb] = &POW10_32;
-
-#[cfg(limb_width_32)]
-type Wide = u64;
-
-// 64-BIT LIMB
-#[cfg(limb_width_64)]
-pub type Limb = u64;
-
-#[cfg(limb_width_64)]
-pub const POW5_LIMB: &[Limb] = &POW5_64;
-
-#[cfg(limb_width_64)]
-pub const POW10_LIMB: &[Limb] = &POW10_64;
-
-#[cfg(limb_width_64)]
-type Wide = u128;
-
-/// Cast to limb type.
-#[inline]
-pub(crate) fn as_limb<T: Integer>(t: T) -> Limb {
-    Limb::as_cast(t)
-}
-
-/// Cast to wide type.
-#[inline]
-fn as_wide<T: Integer>(t: T) -> Wide {
-    Wide::as_cast(t)
-}
-
-// SPLIT
-// -----
-
-/// Split u64 into limbs, in little-endian order.
-#[inline]
-#[cfg(limb_width_32)]
-fn split_u64(x: u64) -> [Limb; 2] {
-    [as_limb(x), as_limb(x >> 32)]
-}
-
-/// Split u64 into limbs, in little-endian order.
-#[inline]
-#[cfg(limb_width_64)]
-fn split_u64(x: u64) -> [Limb; 1] {
-    [as_limb(x)]
-}
-
-// HI64
-// ----
-
-// NONZERO
-
-/// Check if any of the remaining bits are non-zero.
-#[inline]
-pub fn nonzero<T: Integer>(x: &[T], rindex: usize) -> bool {
-    let len = x.len();
-    let slc = &x[..len - rindex];
-    slc.iter().rev().any(|&x| x != T::ZERO)
-}
-
-/// Shift 64-bit integer to high 64-bits.
-#[inline]
-fn u64_to_hi64_1(r0: u64) -> (u64, bool) {
-    debug_assert!(r0 != 0);
-    let ls = r0.leading_zeros();
-    (r0 << ls, false)
-}
-
-/// Shift 2 64-bit integers to high 64-bits.
-#[inline]
-fn u64_to_hi64_2(r0: u64, r1: u64) -> (u64, bool) {
-    debug_assert!(r0 != 0);
-    let ls = r0.leading_zeros();
-    let rs = 64 - ls;
-    let v = match ls {
-        0 => r0,
-        _ => (r0 << ls) | (r1 >> rs),
-    };
-    let n = r1 << ls != 0;
-    (v, n)
-}
-
-/// Trait to export the high 64-bits from a little-endian slice.
-trait Hi64<T>: AsRef<[T]> {
-    /// Get the hi64 bits from a 1-limb slice.
-    fn hi64_1(&self) -> (u64, bool);
-
-    /// Get the hi64 bits from a 2-limb slice.
-    fn hi64_2(&self) -> (u64, bool);
-
-    /// Get the hi64 bits from a 3-limb slice.
-    fn hi64_3(&self) -> (u64, bool);
-
-    /// High-level exporter to extract the high 64 bits from a little-endian slice.
-    #[inline]
-    fn hi64(&self) -> (u64, bool) {
-        match self.as_ref().len() {
-            0 => (0, false),
-            1 => self.hi64_1(),
-            2 => self.hi64_2(),
-            _ => self.hi64_3(),
-        }
-    }
-}
-
-impl Hi64<u32> for [u32] {
-    #[inline]
-    fn hi64_1(&self) -> (u64, bool) {
-        debug_assert!(self.len() == 1);
-        let r0 = self[0] as u64;
-        u64_to_hi64_1(r0)
-    }
-
-    #[inline]
-    fn hi64_2(&self) -> (u64, bool) {
-        debug_assert!(self.len() == 2);
-        let r0 = (self[1] as u64) << 32;
-        let r1 = self[0] as u64;
-        u64_to_hi64_1(r0 | r1)
-    }
-
-    #[inline]
-    fn hi64_3(&self) -> (u64, bool) {
-        debug_assert!(self.len() >= 3);
-        let r0 = self[self.len() - 1] as u64;
-        let r1 = (self[self.len() - 2] as u64) << 32;
-        let r2 = self[self.len() - 3] as u64;
-        let (v, n) = u64_to_hi64_2(r0, r1 | r2);
-        (v, n || nonzero(self, 3))
-    }
-}
-
-impl Hi64<u64> for [u64] {
-    #[inline]
-    fn hi64_1(&self) -> (u64, bool) {
-        debug_assert!(self.len() == 1);
-        let r0 = self[0];
-        u64_to_hi64_1(r0)
-    }
-
-    #[inline]
-    fn hi64_2(&self) -> (u64, bool) {
-        debug_assert!(self.len() >= 2);
-        let r0 = self[self.len() - 1];
-        let r1 = self[self.len() - 2];
-        let (v, n) = u64_to_hi64_2(r0, r1);
-        (v, n || nonzero(self, 2))
-    }
-
-    #[inline]
-    fn hi64_3(&self) -> (u64, bool) {
-        self.hi64_2()
-    }
-}
-
-// SCALAR
-// ------
-
-// Scalar-to-scalar operations, for building-blocks for arbitrary-precision
-// operations.
-
-mod scalar {
-    use super::*;
-
-    // ADDITION
-
-    /// Add two small integers and return the resulting value and if overflow happens.
-    #[inline]
-    pub fn add(x: Limb, y: Limb) -> (Limb, bool) {
-        x.overflowing_add(y)
-    }
-
-    /// AddAssign two small integers and return if overflow happens.
-    #[inline]
-    pub fn iadd(x: &mut Limb, y: Limb) -> bool {
-        let t = add(*x, y);
-        *x = t.0;
-        t.1
-    }
-
-    // SUBTRACTION
-
-    /// Subtract two small integers and return the resulting value and if overflow happens.
-    #[inline]
-    pub fn sub(x: Limb, y: Limb) -> (Limb, bool) {
-        x.overflowing_sub(y)
-    }
-
-    /// SubAssign two small integers and return if overflow happens.
-    #[inline]
-    pub fn isub(x: &mut Limb, y: Limb) -> bool {
-        let t = sub(*x, y);
-        *x = t.0;
-        t.1
-    }
-
-    // MULTIPLICATION
-
-    /// Multiply two small integers (with carry) (and return the overflow contribution).
-    ///
-    /// Returns the (low, high) components.
-    #[inline]
-    pub fn mul(x: Limb, y: Limb, carry: Limb) -> (Limb, Limb) {
-        // Cannot overflow, as long as wide is 2x as wide. This is because
-        // the following is always true:
-        // `Wide::max_value() - (Narrow::max_value() * Narrow::max_value()) >= Narrow::max_value()`
-        let z: Wide = as_wide(x) * as_wide(y) + as_wide(carry);
-        let bits = mem::size_of::<Limb>() * 8;
-        (as_limb(z), as_limb(z >> bits))
-    }
-
-    /// Multiply two small integers (with carry) (and return if overflow happens).
-    #[inline]
-    pub fn imul(x: &mut Limb, y: Limb, carry: Limb) -> Limb {
-        let t = mul(*x, y, carry);
-        *x = t.0;
-        t.1
-    }
-} // scalar
-
-// SMALL
-// -----
-
-// Large-to-small operations, to modify a big integer from a native scalar.
-
-mod small {
-    use super::*;
-
-    // MULTIPLICATIION
-
-    /// ADDITION
-
-    /// Implied AddAssign implementation for adding a small integer to bigint.
-    ///
-    /// Allows us to choose a start-index in x to store, to allow incrementing
-    /// from a non-zero start.
-    #[inline]
-    pub fn iadd_impl(x: &mut Vec<Limb>, y: Limb, xstart: usize) {
-        if x.len() <= xstart {
-            x.push(y);
-        } else {
-            // Initial add
-            let mut carry = scalar::iadd(&mut x[xstart], y);
-
-            // Increment until overflow stops occurring.
-            let mut size = xstart + 1;
-            while carry && size < x.len() {
-                carry = scalar::iadd(&mut x[size], 1);
-                size += 1;
-            }
-
-            // If we overflowed the buffer entirely, need to add 1 to the end
-            // of the buffer.
-            if carry {
-                x.push(1);
-            }
-        }
-    }
-
-    /// AddAssign small integer to bigint.
-    #[inline]
-    pub fn iadd(x: &mut Vec<Limb>, y: Limb) {
-        iadd_impl(x, y, 0);
-    }
-
-    // SUBTRACTION
-
-    /// SubAssign small integer to bigint.
-    /// Does not do overflowing subtraction.
-    #[inline]
-    pub fn isub_impl(x: &mut Vec<Limb>, y: Limb, xstart: usize) {
-        debug_assert!(x.len() > xstart && (x[xstart] >= y || x.len() > xstart + 1));
-
-        // Initial subtraction
-        let mut carry = scalar::isub(&mut x[xstart], y);
-
-        // Increment until overflow stops occurring.
-        let mut size = xstart + 1;
-        while carry && size < x.len() {
-            carry = scalar::isub(&mut x[size], 1);
-            size += 1;
-        }
-        normalize(x);
-    }
-
-    // MULTIPLICATION
-
-    /// MulAssign small integer to bigint.
-    #[inline]
-    pub fn imul(x: &mut Vec<Limb>, y: Limb) {
-        // Multiply iteratively over all elements, adding the carry each time.
-        let mut carry: Limb = 0;
-        for xi in &mut *x {
-            carry = scalar::imul(xi, y, carry);
-        }
-
-        // Overflow of value, add to end.
-        if carry != 0 {
-            x.push(carry);
-        }
-    }
-
-    /// Mul small integer to bigint.
-    #[inline]
-    pub fn mul(x: &[Limb], y: Limb) -> Vec<Limb> {
-        let mut z = Vec::<Limb>::default();
-        z.extend_from_slice(x);
-        imul(&mut z, y);
-        z
-    }
-
-    /// MulAssign by a power.
-    ///
-    /// Theoretically...
-    ///
-    /// Use an exponentiation by squaring method, since it reduces the time
-    /// complexity of the multiplication to ~`O(log(n))` for the squaring,
-    /// and `O(n*m)` for the result. Since `m` is typically a lower-order
-    /// factor, this significantly reduces the number of multiplications
-    /// we need to do. Iteratively multiplying by small powers follows
-    /// the nth triangular number series, which scales as `O(p^2)`, but
-    /// where `p` is `n+m`. In short, it scales very poorly.
-    ///
-    /// Practically....
-    ///
-    /// Exponentiation by Squaring:
-    ///     running 2 tests
-    ///     test bigcomp_f32_lexical ... bench:       1,018 ns/iter (+/- 78)
-    ///     test bigcomp_f64_lexical ... bench:       3,639 ns/iter (+/- 1,007)
-    ///
-    /// Exponentiation by Iterative Small Powers:
-    ///     running 2 tests
-    ///     test bigcomp_f32_lexical ... bench:         518 ns/iter (+/- 31)
-    ///     test bigcomp_f64_lexical ... bench:         583 ns/iter (+/- 47)
-    ///
-    /// Exponentiation by Iterative Large Powers (of 2):
-    ///     running 2 tests
-    ///     test bigcomp_f32_lexical ... bench:         671 ns/iter (+/- 31)
-    ///     test bigcomp_f64_lexical ... bench:       1,394 ns/iter (+/- 47)
-    ///
-    /// Even using worst-case scenarios, exponentiation by squaring is
-    /// significantly slower for our workloads. Just multiply by small powers,
-    /// in simple cases, and use precalculated large powers in other cases.
-    pub fn imul_pow5(x: &mut Vec<Limb>, n: u32) {
-        use super::large::KARATSUBA_CUTOFF;
-
-        let small_powers = POW5_LIMB;
-        let large_powers = large_powers::POW5;
-
-        if n == 0 {
-            // No exponent, just return.
-            // The 0-index of the large powers is `2^0`, which is 1, so we want
-            // to make sure we don't take that path with a literal 0.
-            return;
-        }
-
-        // We want to use the asymptotically faster algorithm if we're going
-        // to be using Karabatsu multiplication sometime during the result,
-        // otherwise, just use exponentiation by squaring.
-        let bit_length = 32 - n.leading_zeros() as usize;
-        debug_assert!(bit_length != 0 && bit_length <= large_powers.len());
-        if x.len() + large_powers[bit_length - 1].len() < 2 * KARATSUBA_CUTOFF {
-            // We can use iterative small powers to make this faster for the
-            // easy cases.
-
-            // Multiply by the largest small power until n < step.
-            let step = small_powers.len() - 1;
-            let power = small_powers[step];
-            let mut n = n as usize;
-            while n >= step {
-                imul(x, power);
-                n -= step;
-            }
-
-            // Multiply by the remainder.
-            imul(x, small_powers[n]);
-        } else {
-            // In theory, this code should be asymptotically a lot faster,
-            // in practice, our small::imul seems to be the limiting step,
-            // and large imul is slow as well.
-
-            // Multiply by higher order powers.
-            let mut idx: usize = 0;
-            let mut bit: usize = 1;
-            let mut n = n as usize;
-            while n != 0 {
-                if n & bit != 0 {
-                    debug_assert!(idx < large_powers.len());
-                    large::imul(x, large_powers[idx]);
-                    n ^= bit;
-                }
-                idx += 1;
-                bit <<= 1;
-            }
-        }
-    }
-
-    // BIT LENGTH
-
-    /// Get number of leading zero bits in the storage.
-    #[inline]
-    pub fn leading_zeros(x: &[Limb]) -> usize {
-        x.last().map_or(0, |x| x.leading_zeros() as usize)
-    }
-
-    /// Calculate the bit-length of the big-integer.
-    #[inline]
-    pub fn bit_length(x: &[Limb]) -> usize {
-        let bits = mem::size_of::<Limb>() * 8;
-        // Avoid overflowing, calculate via total number of bits
-        // minus leading zero bits.
-        let nlz = leading_zeros(x);
-        bits.checked_mul(x.len())
-            .map_or_else(usize::max_value, |v| v - nlz)
-    }
-
-    // SHL
-
-    /// Shift-left bits inside a buffer.
-    ///
-    /// Assumes `n < Limb::BITS`, IE, internally shifting bits.
-    #[inline]
-    pub fn ishl_bits(x: &mut Vec<Limb>, n: usize) {
-        // Need to shift by the number of `bits % Limb::BITS)`.
-        let bits = mem::size_of::<Limb>() * 8;
-        debug_assert!(n < bits);
-        if n == 0 {
-            return;
-        }
-
-        // Internally, for each item, we shift left by n, and add the previous
-        // right shifted limb-bits.
-        // For example, we transform (for u8) shifted left 2, to:
-        //      b10100100 b01000010
-        //      b10 b10010001 b00001000
-        let rshift = bits - n;
-        let lshift = n;
-        let mut prev: Limb = 0;
-        for xi in &mut *x {
-            let tmp = *xi;
-            *xi <<= lshift;
-            *xi |= prev >> rshift;
-            prev = tmp;
-        }
-
-        // Always push the carry, even if it creates a non-normal result.
-        let carry = prev >> rshift;
-        if carry != 0 {
-            x.push(carry);
-        }
-    }
-
-    /// Shift-left `n` digits inside a buffer.
-    ///
-    /// Assumes `n` is not 0.
-    #[inline]
-    pub fn ishl_limbs(x: &mut Vec<Limb>, n: usize) {
-        debug_assert!(n != 0);
-        if !x.is_empty() {
-            x.reserve(n);
-            x.splice(..0, iter::repeat(0).take(n));
-        }
-    }
-
-    /// Shift-left buffer by n bits.
-    #[inline]
-    pub fn ishl(x: &mut Vec<Limb>, n: usize) {
-        let bits = mem::size_of::<Limb>() * 8;
-        // Need to pad with zeros for the number of `bits / Limb::BITS`,
-        // and shift-left with carry for `bits % Limb::BITS`.
-        let rem = n % bits;
-        let div = n / bits;
-        ishl_bits(x, rem);
-        if div != 0 {
-            ishl_limbs(x, div);
-        }
-    }
-
-    // NORMALIZE
-
-    /// Normalize the container by popping any leading zeros.
-    #[inline]
-    pub fn normalize(x: &mut Vec<Limb>) {
-        // Remove leading zero if we cause underflow. Since we're dividing
-        // by a small power, we have at max 1 int removed.
-        while x.last() == Some(&0) {
-            x.pop();
-        }
-    }
-} // small
-
-// LARGE
-// -----
-
-// Large-to-large operations, to modify a big integer from a native scalar.
-
-mod large {
-    use super::*;
-
-    // RELATIVE OPERATORS
-
-    /// Compare `x` to `y`, in little-endian order.
-    #[inline]
-    pub fn compare(x: &[Limb], y: &[Limb]) -> cmp::Ordering {
-        if x.len() > y.len() {
-            cmp::Ordering::Greater
-        } else if x.len() < y.len() {
-            cmp::Ordering::Less
-        } else {
-            let iter = x.iter().rev().zip(y.iter().rev());
-            for (&xi, &yi) in iter {
-                if xi > yi {
-                    return cmp::Ordering::Greater;
-                } else if xi < yi {
-                    return cmp::Ordering::Less;
-                }
-            }
-            // Equal case.
-            cmp::Ordering::Equal
-        }
-    }
-
-    /// Check if x is less than y.
-    #[inline]
-    pub fn less(x: &[Limb], y: &[Limb]) -> bool {
-        compare(x, y) == cmp::Ordering::Less
-    }
-
-    /// Check if x is greater than or equal to y.
-    #[inline]
-    pub fn greater_equal(x: &[Limb], y: &[Limb]) -> bool {
-        !less(x, y)
-    }
-
-    // ADDITION
-
-    /// Implied AddAssign implementation for bigints.
-    ///
-    /// Allows us to choose a start-index in x to store, so we can avoid
-    /// padding the buffer with zeros when not needed, optimized for vectors.
-    pub fn iadd_impl(x: &mut Vec<Limb>, y: &[Limb], xstart: usize) {
-        // The effective x buffer is from `xstart..x.len()`, so we need to treat
-        // that as the current range. If the effective y buffer is longer, need
-        // to resize to that, + the start index.
-        if y.len() > x.len() - xstart {
-            x.resize(y.len() + xstart, 0);
-        }
-
-        // Iteratively add elements from y to x.
-        let mut carry = false;
-        for (xi, yi) in x[xstart..].iter_mut().zip(y.iter()) {
-            // Only one op of the two can overflow, since we added at max
-            // Limb::max_value() + Limb::max_value(). Add the previous carry,
-            // and store the current carry for the next.
-            let mut tmp = scalar::iadd(xi, *yi);
-            if carry {
-                tmp |= scalar::iadd(xi, 1);
-            }
-            carry = tmp;
-        }
-
-        // Overflow from the previous bit.
-        if carry {
-            small::iadd_impl(x, 1, y.len() + xstart);
-        }
-    }
-
-    /// AddAssign bigint to bigint.
-    #[inline]
-    pub fn iadd(x: &mut Vec<Limb>, y: &[Limb]) {
-        iadd_impl(x, y, 0);
-    }
-
-    /// Add bigint to bigint.
-    #[inline]
-    pub fn add(x: &[Limb], y: &[Limb]) -> Vec<Limb> {
-        let mut z = Vec::<Limb>::default();
-        z.extend_from_slice(x);
-        iadd(&mut z, y);
-        z
-    }
-
-    // SUBTRACTION
-
-    /// SubAssign bigint to bigint.
-    pub fn isub(x: &mut Vec<Limb>, y: &[Limb]) {
-        // Basic underflow checks.
-        debug_assert!(greater_equal(x, y));
-
-        // Iteratively add elements from y to x.
-        let mut carry = false;
-        for (xi, yi) in x.iter_mut().zip(y.iter()) {
-            // Only one op of the two can overflow, since we added at max
-            // Limb::max_value() + Limb::max_value(). Add the previous carry,
-            // and store the current carry for the next.
-            let mut tmp = scalar::isub(xi, *yi);
-            if carry {
-                tmp |= scalar::isub(xi, 1);
-            }
-            carry = tmp;
-        }
-
-        if carry {
-            small::isub_impl(x, 1, y.len());
-        } else {
-            small::normalize(x);
-        }
-    }
-
-    // MULTIPLICATION
-
-    /// Number of digits to bottom-out to asymptotically slow algorithms.
-    ///
-    /// Karatsuba tends to out-perform long-multiplication at ~320-640 bits,
-    /// so we go halfway, while Newton division tends to out-perform
-    /// Algorithm D at ~1024 bits. We can toggle this for optimal performance.
-    pub const KARATSUBA_CUTOFF: usize = 32;
-
-    /// Grade-school multiplication algorithm.
-    ///
-    /// Slow, naive algorithm, using limb-bit bases and just shifting left for
-    /// each iteration. This could be optimized with numerous other algorithms,
-    /// but it's extremely simple, and works in O(n*m) time, which is fine
-    /// by me. Each iteration, of which there are `m` iterations, requires
-    /// `n` multiplications, and `n` additions, or grade-school multiplication.
-    fn long_mul(x: &[Limb], y: &[Limb]) -> Vec<Limb> {
-        // Using the immutable value, multiply by all the scalars in y, using
-        // the algorithm defined above. Use a single buffer to avoid
-        // frequent reallocations. Handle the first case to avoid a redundant
-        // addition, since we know y.len() >= 1.
-        let mut z: Vec<Limb> = small::mul(x, y[0]);
-        z.resize(x.len() + y.len(), 0);
-
-        // Handle the iterative cases.
-        for (i, &yi) in y[1..].iter().enumerate() {
-            let zi: Vec<Limb> = small::mul(x, yi);
-            iadd_impl(&mut z, &zi, i + 1);
-        }
-
-        small::normalize(&mut z);
-
-        z
-    }
-
-    /// Split two buffers into halfway, into (lo, hi).
-    #[inline]
-    pub fn karatsuba_split(z: &[Limb], m: usize) -> (&[Limb], &[Limb]) {
-        (&z[..m], &z[m..])
-    }
-
-    /// Karatsuba multiplication algorithm with roughly equal input sizes.
-    ///
-    /// Assumes `y.len() >= x.len()`.
-    fn karatsuba_mul(x: &[Limb], y: &[Limb]) -> Vec<Limb> {
-        if y.len() <= KARATSUBA_CUTOFF {
-            // Bottom-out to long division for small cases.
-            long_mul(x, y)
-        } else if x.len() < y.len() / 2 {
-            karatsuba_uneven_mul(x, y)
-        } else {
-            // Do our 3 multiplications.
-            let m = y.len() / 2;
-            let (xl, xh) = karatsuba_split(x, m);
-            let (yl, yh) = karatsuba_split(y, m);
-            let sumx = add(xl, xh);
-            let sumy = add(yl, yh);
-            let z0 = karatsuba_mul(xl, yl);
-            let mut z1 = karatsuba_mul(&sumx, &sumy);
-            let z2 = karatsuba_mul(xh, yh);
-            // Properly scale z1, which is `z1 - z2 - zo`.
-            isub(&mut z1, &z2);
-            isub(&mut z1, &z0);
-
-            // Create our result, which is equal to, in little-endian order:
-            // [z0, z1 - z2 - z0, z2]
-            //  z1 must be shifted m digits (2^(32m)) over.
-            //  z2 must be shifted 2*m digits (2^(64m)) over.
-            let len = z0.len().max(m + z1.len()).max(2 * m + z2.len());
-            let mut result = z0;
-            result.reserve_exact(len - result.len());
-            iadd_impl(&mut result, &z1, m);
-            iadd_impl(&mut result, &z2, 2 * m);
-
-            result
-        }
-    }
-
-    /// Karatsuba multiplication algorithm where y is substantially larger than x.
-    ///
-    /// Assumes `y.len() >= x.len()`.
-    fn karatsuba_uneven_mul(x: &[Limb], mut y: &[Limb]) -> Vec<Limb> {
-        let mut result = Vec::<Limb>::default();
-        result.resize(x.len() + y.len(), 0);
-
-        // This effectively is like grade-school multiplication between
-        // two numbers, except we're using splits on `y`, and the intermediate
-        // step is a Karatsuba multiplication.
-        let mut start = 0;
-        while !y.is_empty() {
-            let m = x.len().min(y.len());
-            let (yl, yh) = karatsuba_split(y, m);
-            let prod = karatsuba_mul(x, yl);
-            iadd_impl(&mut result, &prod, start);
-            y = yh;
-            start += m;
-        }
-        small::normalize(&mut result);
-
-        result
-    }
-
-    /// Forwarder to the proper Karatsuba algorithm.
-    #[inline]
-    fn karatsuba_mul_fwd(x: &[Limb], y: &[Limb]) -> Vec<Limb> {
-        if x.len() < y.len() {
-            karatsuba_mul(x, y)
-        } else {
-            karatsuba_mul(y, x)
-        }
-    }
-
-    /// MulAssign bigint to bigint.
-    #[inline]
-    pub fn imul(x: &mut Vec<Limb>, y: &[Limb]) {
-        if y.len() == 1 {
-            small::imul(x, y[0]);
-        } else {
-            // We're not really in a condition where using Karatsuba
-            // multiplication makes sense, so we're just going to use long
-            // division. ~20% speedup compared to:
-            //      *x = karatsuba_mul_fwd(x, y);
-            *x = karatsuba_mul_fwd(x, y);
-        }
-    }
-} // large
-
-// TRAITS
-// ------
-
-/// Traits for shared operations for big integers.
-///
-/// None of these are implemented using normal traits, since these
-/// are very expensive operations, and we want to deliberately
-/// and explicitly use these functions.
-pub(crate) trait Math: Clone + Sized + Default {
-    // DATA
-
-    /// Get access to the underlying data
-    fn data(&self) -> &Vec<Limb>;
-
-    /// Get access to the underlying data
-    fn data_mut(&mut self) -> &mut Vec<Limb>;
-
-    // RELATIVE OPERATIONS
-
-    /// Compare self to y.
-    #[inline]
-    fn compare(&self, y: &Self) -> cmp::Ordering {
-        large::compare(self.data(), y.data())
-    }
-
-    // PROPERTIES
-
-    /// Get the high 64-bits from the bigint and if there are remaining bits.
-    #[inline]
-    fn hi64(&self) -> (u64, bool) {
-        self.data().as_slice().hi64()
-    }
-
-    /// Calculate the bit-length of the big-integer.
-    /// Returns usize::max_value() if the value overflows,
-    /// IE, if `self.data().len() > usize::max_value() / 8`.
-    #[inline]
-    fn bit_length(&self) -> usize {
-        small::bit_length(self.data())
-    }
-
-    // INTEGER CONVERSIONS
-
-    /// Create new big integer from u64.
-    #[inline]
-    fn from_u64(x: u64) -> Self {
-        let mut v = Self::default();
-        let slc = split_u64(x);
-        v.data_mut().extend_from_slice(&slc);
-        v.normalize();
-        v
-    }
-
-    // NORMALIZE
-
-    /// Normalize the integer, so any leading zero values are removed.
-    #[inline]
-    fn normalize(&mut self) {
-        small::normalize(self.data_mut());
-    }
-
-    // ADDITION
-
-    /// AddAssign small integer.
-    #[inline]
-    fn iadd_small(&mut self, y: Limb) {
-        small::iadd(self.data_mut(), y);
-    }
-
-    // MULTIPLICATION
-
-    /// MulAssign small integer.
-    #[inline]
-    fn imul_small(&mut self, y: Limb) {
-        small::imul(self.data_mut(), y);
-    }
-
-    /// Multiply by a power of 2.
-    #[inline]
-    fn imul_pow2(&mut self, n: u32) {
-        self.ishl(n as usize);
-    }
-
-    /// Multiply by a power of 5.
-    #[inline]
-    fn imul_pow5(&mut self, n: u32) {
-        small::imul_pow5(self.data_mut(), n);
-    }
-
-    /// MulAssign by a power of 10.
-    #[inline]
-    fn imul_pow10(&mut self, n: u32) {
-        self.imul_pow5(n);
-        self.imul_pow2(n);
-    }
-
-    // SHIFTS
-
-    /// Shift-left the entire buffer n bits.
-    #[inline]
-    fn ishl(&mut self, n: usize) {
-        small::ishl(self.data_mut(), n);
-    }
-}
diff --git a/vendor/serde_json/src/lexical/mod.rs b/vendor/serde_json/src/lexical/mod.rs
deleted file mode 100644
index b1a45e2..0000000
--- a/vendor/serde_json/src/lexical/mod.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// The code in this module is derived from the `lexical` crate by @Alexhuszagh
-// which the author condensed into this minimal subset for use in serde_json.
-// For the serde_json use case we care more about reliably round tripping all
-// possible floating point values than about parsing any arbitrarily long string
-// of digits with perfect accuracy, as the latter would take a high cost in
-// compile time and performance.
-//
-// Dual licensed as MIT and Apache 2.0 just like the rest of serde_json, but
-// copyright Alexander Huszagh.
-
-//! Fast, minimal float-parsing algorithm.
-
-// MODULES
-pub(crate) mod algorithm;
-mod bhcomp;
-mod bignum;
-mod cached;
-mod cached_float80;
-mod digit;
-mod errors;
-pub(crate) mod exponent;
-pub(crate) mod float;
-mod large_powers;
-pub(crate) mod math;
-pub(crate) mod num;
-pub(crate) mod parse;
-pub(crate) mod rounding;
-mod shift;
-mod small_powers;
-
-#[cfg(limb_width_32)]
-mod large_powers32;
-
-#[cfg(limb_width_64)]
-mod large_powers64;
-
-// API
-pub use self::parse::{parse_concise_float, parse_truncated_float};
diff --git a/vendor/serde_json/src/lexical/num.rs b/vendor/serde_json/src/lexical/num.rs
deleted file mode 100644
index e47e003..0000000
--- a/vendor/serde_json/src/lexical/num.rs
+++ /dev/null
@@ -1,440 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Utilities for Rust numbers.
-
-use core::ops;
-
-/// Precalculated values of radix**i for i in range [0, arr.len()-1].
-/// Each value can be **exactly** represented as that type.
-const F32_POW10: [f32; 11] = [
-    1.0,
-    10.0,
-    100.0,
-    1000.0,
-    10000.0,
-    100000.0,
-    1000000.0,
-    10000000.0,
-    100000000.0,
-    1000000000.0,
-    10000000000.0,
-];
-
-/// Precalculated values of radix**i for i in range [0, arr.len()-1].
-/// Each value can be **exactly** represented as that type.
-const F64_POW10: [f64; 23] = [
-    1.0,
-    10.0,
-    100.0,
-    1000.0,
-    10000.0,
-    100000.0,
-    1000000.0,
-    10000000.0,
-    100000000.0,
-    1000000000.0,
-    10000000000.0,
-    100000000000.0,
-    1000000000000.0,
-    10000000000000.0,
-    100000000000000.0,
-    1000000000000000.0,
-    10000000000000000.0,
-    100000000000000000.0,
-    1000000000000000000.0,
-    10000000000000000000.0,
-    100000000000000000000.0,
-    1000000000000000000000.0,
-    10000000000000000000000.0,
-];
-
-/// Type that can be converted to primitive with `as`.
-pub trait AsPrimitive: Sized + Copy + PartialOrd {
-    fn as_u32(self) -> u32;
-    fn as_u64(self) -> u64;
-    fn as_u128(self) -> u128;
-    fn as_usize(self) -> usize;
-    fn as_f32(self) -> f32;
-    fn as_f64(self) -> f64;
-}
-
-macro_rules! as_primitive_impl {
-    ($($ty:ident)*) => {
-        $(
-            impl AsPrimitive for $ty {
-                #[inline]
-                fn as_u32(self) -> u32 {
-                    self as u32
-                }
-
-                #[inline]
-                fn as_u64(self) -> u64 {
-                    self as u64
-                }
-
-                #[inline]
-                fn as_u128(self) -> u128 {
-                    self as u128
-                }
-
-                #[inline]
-                fn as_usize(self) -> usize {
-                    self as usize
-                }
-
-                #[inline]
-                fn as_f32(self) -> f32 {
-                    self as f32
-                }
-
-                #[inline]
-                fn as_f64(self) -> f64 {
-                    self as f64
-                }
-            }
-        )*
-    };
-}
-
-as_primitive_impl! { u32 u64 u128 usize f32 f64 }
-
-/// An interface for casting between machine scalars.
-pub trait AsCast: AsPrimitive {
-    /// Creates a number from another value that can be converted into
-    /// a primitive via the `AsPrimitive` trait.
-    fn as_cast<N: AsPrimitive>(n: N) -> Self;
-}
-
-macro_rules! as_cast_impl {
-    ($ty:ident, $method:ident) => {
-        impl AsCast for $ty {
-            #[inline]
-            fn as_cast<N: AsPrimitive>(n: N) -> Self {
-                n.$method()
-            }
-        }
-    };
-}
-
-as_cast_impl!(u32, as_u32);
-as_cast_impl!(u64, as_u64);
-as_cast_impl!(u128, as_u128);
-as_cast_impl!(usize, as_usize);
-as_cast_impl!(f32, as_f32);
-as_cast_impl!(f64, as_f64);
-
-/// Numerical type trait.
-pub trait Number: AsCast + ops::Add<Output = Self> {}
-
-macro_rules! number_impl {
-    ($($ty:ident)*) => {
-        $(
-            impl Number for $ty {}
-        )*
-    };
-}
-
-number_impl! { u32 u64 u128 usize f32 f64 }
-
-/// Defines a trait that supports integral operations.
-pub trait Integer: Number + ops::BitAnd<Output = Self> + ops::Shr<i32, Output = Self> {
-    const ZERO: Self;
-}
-
-macro_rules! integer_impl {
-    ($($ty:tt)*) => {
-        $(
-            impl Integer for $ty {
-                const ZERO: Self = 0;
-            }
-        )*
-    };
-}
-
-integer_impl! { u32 u64 u128 usize }
-
-/// Type trait for the mantissa type.
-pub trait Mantissa: Integer {
-    /// Mask to extract the high bits from the integer.
-    const HIMASK: Self;
-    /// Mask to extract the low bits from the integer.
-    const LOMASK: Self;
-    /// Full size of the integer, in bits.
-    const FULL: i32;
-    /// Half size of the integer, in bits.
-    const HALF: i32 = Self::FULL / 2;
-}
-
-impl Mantissa for u64 {
-    const HIMASK: u64 = 0xFFFFFFFF00000000;
-    const LOMASK: u64 = 0x00000000FFFFFFFF;
-    const FULL: i32 = 64;
-}
-
-/// Get exact exponent limit for radix.
-pub trait Float: Number {
-    /// Unsigned type of the same size.
-    type Unsigned: Integer;
-
-    /// Literal zero.
-    const ZERO: Self;
-    /// Maximum number of digits that can contribute in the mantissa.
-    ///
-    /// We can exactly represent a float in radix `b` from radix 2 if
-    /// `b` is divisible by 2. This function calculates the exact number of
-    /// digits required to exactly represent that float.
-    ///
-    /// According to the "Handbook of Floating Point Arithmetic",
-    /// for IEEE754, with emin being the min exponent, p2 being the
-    /// precision, and b being the radix, the number of digits follows as:
-    ///
-    /// `−emin + p2 + ⌊(emin + 1) log(2, b) − log(1 − 2^(−p2), b)⌋`
-    ///
-    /// For f32, this follows as:
-    ///     emin = -126
-    ///     p2 = 24
-    ///
-    /// For f64, this follows as:
-    ///     emin = -1022
-    ///     p2 = 53
-    ///
-    /// In Python:
-    ///     `-emin + p2 + math.floor((emin+1)*math.log(2, b) - math.log(1-2**(-p2), b))`
-    ///
-    /// This was used to calculate the maximum number of digits for [2, 36].
-    const MAX_DIGITS: usize;
-
-    // MASKS
-
-    /// Bitmask for the sign bit.
-    const SIGN_MASK: Self::Unsigned;
-    /// Bitmask for the exponent, including the hidden bit.
-    const EXPONENT_MASK: Self::Unsigned;
-    /// Bitmask for the hidden bit in exponent, which is an implicit 1 in the fraction.
-    const HIDDEN_BIT_MASK: Self::Unsigned;
-    /// Bitmask for the mantissa (fraction), excluding the hidden bit.
-    const MANTISSA_MASK: Self::Unsigned;
-
-    // PROPERTIES
-
-    /// Positive infinity as bits.
-    const INFINITY_BITS: Self::Unsigned;
-    /// Positive infinity as bits.
-    const NEGATIVE_INFINITY_BITS: Self::Unsigned;
-    /// Size of the significand (mantissa) without hidden bit.
-    const MANTISSA_SIZE: i32;
-    /// Bias of the exponet
-    const EXPONENT_BIAS: i32;
-    /// Exponent portion of a denormal float.
-    const DENORMAL_EXPONENT: i32;
-    /// Maximum exponent value in float.
-    const MAX_EXPONENT: i32;
-
-    // ROUNDING
-
-    /// Default number of bits to shift (or 64 - mantissa size - 1).
-    const DEFAULT_SHIFT: i32;
-    /// Mask to determine if a full-carry occurred (1 in bit above hidden bit).
-    const CARRY_MASK: u64;
-
-    /// Get min and max exponent limits (exact) from radix.
-    fn exponent_limit() -> (i32, i32);
-
-    /// Get the number of digits that can be shifted from exponent to mantissa.
-    fn mantissa_limit() -> i32;
-
-    // Re-exported methods from std.
-    fn pow10(self, n: i32) -> Self;
-    fn from_bits(u: Self::Unsigned) -> Self;
-    fn to_bits(self) -> Self::Unsigned;
-    fn is_sign_positive(self) -> bool;
-    fn is_sign_negative(self) -> bool;
-
-    /// Returns true if the float is a denormal.
-    #[inline]
-    fn is_denormal(self) -> bool {
-        self.to_bits() & Self::EXPONENT_MASK == Self::Unsigned::ZERO
-    }
-
-    /// Returns true if the float is a NaN or Infinite.
-    #[inline]
-    fn is_special(self) -> bool {
-        self.to_bits() & Self::EXPONENT_MASK == Self::EXPONENT_MASK
-    }
-
-    /// Returns true if the float is infinite.
-    #[inline]
-    fn is_inf(self) -> bool {
-        self.is_special() && (self.to_bits() & Self::MANTISSA_MASK) == Self::Unsigned::ZERO
-    }
-
-    /// Get exponent component from the float.
-    #[inline]
-    fn exponent(self) -> i32 {
-        if self.is_denormal() {
-            return Self::DENORMAL_EXPONENT;
-        }
-
-        let bits = self.to_bits();
-        let biased_e = ((bits & Self::EXPONENT_MASK) >> Self::MANTISSA_SIZE).as_u32();
-        biased_e as i32 - Self::EXPONENT_BIAS
-    }
-
-    /// Get mantissa (significand) component from float.
-    #[inline]
-    fn mantissa(self) -> Self::Unsigned {
-        let bits = self.to_bits();
-        let s = bits & Self::MANTISSA_MASK;
-        if !self.is_denormal() {
-            s + Self::HIDDEN_BIT_MASK
-        } else {
-            s
-        }
-    }
-
-    /// Get next greater float for a positive float.
-    /// Value must be >= 0.0 and < INFINITY.
-    #[inline]
-    fn next_positive(self) -> Self {
-        debug_assert!(self.is_sign_positive() && !self.is_inf());
-        Self::from_bits(self.to_bits() + Self::Unsigned::as_cast(1u32))
-    }
-
-    /// Round a positive number to even.
-    #[inline]
-    fn round_positive_even(self) -> Self {
-        if self.mantissa() & Self::Unsigned::as_cast(1u32) == Self::Unsigned::as_cast(1u32) {
-            self.next_positive()
-        } else {
-            self
-        }
-    }
-}
-
-impl Float for f32 {
-    type Unsigned = u32;
-
-    const ZERO: f32 = 0.0;
-    const MAX_DIGITS: usize = 114;
-    const SIGN_MASK: u32 = 0x80000000;
-    const EXPONENT_MASK: u32 = 0x7F800000;
-    const HIDDEN_BIT_MASK: u32 = 0x00800000;
-    const MANTISSA_MASK: u32 = 0x007FFFFF;
-    const INFINITY_BITS: u32 = 0x7F800000;
-    const NEGATIVE_INFINITY_BITS: u32 = Self::INFINITY_BITS | Self::SIGN_MASK;
-    const MANTISSA_SIZE: i32 = 23;
-    const EXPONENT_BIAS: i32 = 127 + Self::MANTISSA_SIZE;
-    const DENORMAL_EXPONENT: i32 = 1 - Self::EXPONENT_BIAS;
-    const MAX_EXPONENT: i32 = 0xFF - Self::EXPONENT_BIAS;
-    const DEFAULT_SHIFT: i32 = u64::FULL - f32::MANTISSA_SIZE - 1;
-    const CARRY_MASK: u64 = 0x1000000;
-
-    #[inline]
-    fn exponent_limit() -> (i32, i32) {
-        (-10, 10)
-    }
-
-    #[inline]
-    fn mantissa_limit() -> i32 {
-        7
-    }
-
-    #[inline]
-    fn pow10(self, n: i32) -> f32 {
-        // Check the exponent is within bounds in debug builds.
-        debug_assert!({
-            let (min, max) = Self::exponent_limit();
-            n >= min && n <= max
-        });
-
-        if n > 0 {
-            self * F32_POW10[n as usize]
-        } else {
-            self / F32_POW10[-n as usize]
-        }
-    }
-
-    #[inline]
-    fn from_bits(u: u32) -> f32 {
-        f32::from_bits(u)
-    }
-
-    #[inline]
-    fn to_bits(self) -> u32 {
-        f32::to_bits(self)
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        f32::is_sign_positive(self)
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        f32::is_sign_negative(self)
-    }
-}
-
-impl Float for f64 {
-    type Unsigned = u64;
-
-    const ZERO: f64 = 0.0;
-    const MAX_DIGITS: usize = 769;
-    const SIGN_MASK: u64 = 0x8000000000000000;
-    const EXPONENT_MASK: u64 = 0x7FF0000000000000;
-    const HIDDEN_BIT_MASK: u64 = 0x0010000000000000;
-    const MANTISSA_MASK: u64 = 0x000FFFFFFFFFFFFF;
-    const INFINITY_BITS: u64 = 0x7FF0000000000000;
-    const NEGATIVE_INFINITY_BITS: u64 = Self::INFINITY_BITS | Self::SIGN_MASK;
-    const MANTISSA_SIZE: i32 = 52;
-    const EXPONENT_BIAS: i32 = 1023 + Self::MANTISSA_SIZE;
-    const DENORMAL_EXPONENT: i32 = 1 - Self::EXPONENT_BIAS;
-    const MAX_EXPONENT: i32 = 0x7FF - Self::EXPONENT_BIAS;
-    const DEFAULT_SHIFT: i32 = u64::FULL - f64::MANTISSA_SIZE - 1;
-    const CARRY_MASK: u64 = 0x20000000000000;
-
-    #[inline]
-    fn exponent_limit() -> (i32, i32) {
-        (-22, 22)
-    }
-
-    #[inline]
-    fn mantissa_limit() -> i32 {
-        15
-    }
-
-    #[inline]
-    fn pow10(self, n: i32) -> f64 {
-        // Check the exponent is within bounds in debug builds.
-        debug_assert!({
-            let (min, max) = Self::exponent_limit();
-            n >= min && n <= max
-        });
-
-        if n > 0 {
-            self * F64_POW10[n as usize]
-        } else {
-            self / F64_POW10[-n as usize]
-        }
-    }
-
-    #[inline]
-    fn from_bits(u: u64) -> f64 {
-        f64::from_bits(u)
-    }
-
-    #[inline]
-    fn to_bits(self) -> u64 {
-        f64::to_bits(self)
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        f64::is_sign_positive(self)
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        f64::is_sign_negative(self)
-    }
-}
diff --git a/vendor/serde_json/src/lexical/parse.rs b/vendor/serde_json/src/lexical/parse.rs
deleted file mode 100644
index e3d7f1e..0000000
--- a/vendor/serde_json/src/lexical/parse.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use super::algorithm::*;
-use super::bhcomp::*;
-use super::digit::*;
-use super::exponent::*;
-use super::num::*;
-
-// PARSERS
-// -------
-
-/// Parse float for which the entire integer and fraction parts fit into a 64
-/// bit mantissa.
-pub fn parse_concise_float<F>(mantissa: u64, mant_exp: i32) -> F
-where
-    F: Float,
-{
-    if let Some(float) = fast_path(mantissa, mant_exp) {
-        return float;
-    }
-
-    // Moderate path (use an extended 80-bit representation).
-    let truncated = false;
-    let (fp, valid) = moderate_path::<F>(mantissa, mant_exp, truncated);
-    if valid {
-        return fp.into_float::<F>();
-    }
-
-    let b = fp.into_downward_float::<F>();
-    if b.is_special() {
-        // We have a non-finite number, we get to leave early.
-        return b;
-    }
-
-    // Slow path, fast path didn't work.
-    let mut buffer = itoa::Buffer::new();
-    let integer = buffer.format(mantissa).as_bytes();
-    let fraction = &[];
-    bhcomp(b, integer, fraction, mant_exp)
-}
-
-/// Parse float from extracted float components.
-///
-/// * `integer`     - Slice containing the integer digits.
-/// * `fraction`    - Slice containing the fraction digits.
-/// * `exponent`    - Parsed, 32-bit exponent.
-///
-/// Precondition: The integer must not have leading zeros.
-pub fn parse_truncated_float<F>(integer: &[u8], mut fraction: &[u8], exponent: i32) -> F
-where
-    F: Float,
-{
-    // Trim trailing zeroes from the fraction part.
-    while fraction.last() == Some(&b'0') {
-        fraction = &fraction[..fraction.len() - 1];
-    }
-
-    // Calculate the number of truncated digits.
-    let mut truncated = 0;
-    let mut mantissa: u64 = 0;
-    let mut iter = integer.iter().chain(fraction);
-    for &c in &mut iter {
-        mantissa = match add_digit(mantissa, to_digit(c).unwrap()) {
-            Some(v) => v,
-            None => {
-                truncated = 1 + iter.count();
-                break;
-            }
-        };
-    }
-
-    let mant_exp = mantissa_exponent(exponent, fraction.len(), truncated);
-    let is_truncated = true;
-
-    fallback_path(
-        integer,
-        fraction,
-        mantissa,
-        exponent,
-        mant_exp,
-        is_truncated,
-    )
-}
diff --git a/vendor/serde_json/src/lexical/rounding.rs b/vendor/serde_json/src/lexical/rounding.rs
deleted file mode 100644
index 6ec1292..0000000
--- a/vendor/serde_json/src/lexical/rounding.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Defines rounding schemes for floating-point numbers.
-
-use super::float::ExtendedFloat;
-use super::num::*;
-use super::shift::*;
-use core::mem;
-
-// MASKS
-
-/// Calculate a scalar factor of 2 above the halfway point.
-#[inline]
-pub(crate) fn nth_bit(n: u64) -> u64 {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!(n < bits, "nth_bit() overflow in shl.");
-
-    1 << n
-}
-
-/// Generate a bitwise mask for the lower `n` bits.
-#[inline]
-pub(crate) fn lower_n_mask(n: u64) -> u64 {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!(n <= bits, "lower_n_mask() overflow in shl.");
-
-    if n == bits {
-        u64::max_value()
-    } else {
-        (1 << n) - 1
-    }
-}
-
-/// Calculate the halfway point for the lower `n` bits.
-#[inline]
-pub(crate) fn lower_n_halfway(n: u64) -> u64 {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!(n <= bits, "lower_n_halfway() overflow in shl.");
-
-    if n == 0 {
-        0
-    } else {
-        nth_bit(n - 1)
-    }
-}
-
-/// Calculate a bitwise mask with `n` 1 bits starting at the `bit` position.
-#[inline]
-pub(crate) fn internal_n_mask(bit: u64, n: u64) -> u64 {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!(bit <= bits, "internal_n_halfway() overflow in shl.");
-    debug_assert!(n <= bits, "internal_n_halfway() overflow in shl.");
-    debug_assert!(bit >= n, "internal_n_halfway() overflow in sub.");
-
-    lower_n_mask(bit) ^ lower_n_mask(bit - n)
-}
-
-// NEAREST ROUNDING
-
-// Shift right N-bytes and round to the nearest.
-//
-// Return if we are above halfway and if we are halfway.
-#[inline]
-pub(crate) fn round_nearest(fp: &mut ExtendedFloat, shift: i32) -> (bool, bool) {
-    // Extract the truncated bits using mask.
-    // Calculate if the value of the truncated bits are either above
-    // the mid-way point, or equal to it.
-    //
-    // For example, for 4 truncated bytes, the mask would be b1111
-    // and the midway point would be b1000.
-    let mask: u64 = lower_n_mask(shift as u64);
-    let halfway: u64 = lower_n_halfway(shift as u64);
-
-    let truncated_bits = fp.mant & mask;
-    let is_above = truncated_bits > halfway;
-    let is_halfway = truncated_bits == halfway;
-
-    // Bit shift so the leading bit is in the hidden bit.
-    overflowing_shr(fp, shift);
-
-    (is_above, is_halfway)
-}
-
-// Tie rounded floating point to event.
-#[inline]
-pub(crate) fn tie_even(fp: &mut ExtendedFloat, is_above: bool, is_halfway: bool) {
-    // Extract the last bit after shifting (and determine if it is odd).
-    let is_odd = fp.mant & 1 == 1;
-
-    // Calculate if we need to roundup.
-    // We need to roundup if we are above halfway, or if we are odd
-    // and at half-way (need to tie-to-even).
-    if is_above || (is_odd && is_halfway) {
-        fp.mant += 1;
-    }
-}
-
-// Shift right N-bytes and round nearest, tie-to-even.
-//
-// Floating-point arithmetic uses round to nearest, ties to even,
-// which rounds to the nearest value, if the value is halfway in between,
-// round to an even value.
-#[inline]
-pub(crate) fn round_nearest_tie_even(fp: &mut ExtendedFloat, shift: i32) {
-    let (is_above, is_halfway) = round_nearest(fp, shift);
-    tie_even(fp, is_above, is_halfway);
-}
-
-// DIRECTED ROUNDING
-
-// Shift right N-bytes and round towards a direction.
-//
-// Return if we have any truncated bytes.
-#[inline]
-fn round_toward(fp: &mut ExtendedFloat, shift: i32) -> bool {
-    let mask: u64 = lower_n_mask(shift as u64);
-    let truncated_bits = fp.mant & mask;
-
-    // Bit shift so the leading bit is in the hidden bit.
-    overflowing_shr(fp, shift);
-
-    truncated_bits != 0
-}
-
-// Round down.
-#[inline]
-fn downard(_: &mut ExtendedFloat, _: bool) {}
-
-// Shift right N-bytes and round toward zero.
-//
-// Floating-point arithmetic defines round toward zero, which rounds
-// towards positive zero.
-#[inline]
-pub(crate) fn round_downward(fp: &mut ExtendedFloat, shift: i32) {
-    // Bit shift so the leading bit is in the hidden bit.
-    // No rounding schemes, so we just ignore everything else.
-    let is_truncated = round_toward(fp, shift);
-    downard(fp, is_truncated);
-}
-
-// ROUND TO FLOAT
-
-// Shift the ExtendedFloat fraction to the fraction bits in a native float.
-//
-// Floating-point arithmetic uses round to nearest, ties to even,
-// which rounds to the nearest value, if the value is halfway in between,
-// round to an even value.
-#[inline]
-pub(crate) fn round_to_float<F, Algorithm>(fp: &mut ExtendedFloat, algorithm: Algorithm)
-where
-    F: Float,
-    Algorithm: FnOnce(&mut ExtendedFloat, i32),
-{
-    // Calculate the difference to allow a single calculation
-    // rather than a loop, to minimize the number of ops required.
-    // This does underflow detection.
-    let final_exp = fp.exp + F::DEFAULT_SHIFT;
-    if final_exp < F::DENORMAL_EXPONENT {
-        // We would end up with a denormal exponent, try to round to more
-        // digits. Only shift right if we can avoid zeroing out the value,
-        // which requires the exponent diff to be < M::BITS. The value
-        // is already normalized, so we shouldn't have any issue zeroing
-        // out the value.
-        let diff = F::DENORMAL_EXPONENT - fp.exp;
-        if diff <= u64::FULL {
-            // We can avoid underflow, can get a valid representation.
-            algorithm(fp, diff);
-        } else {
-            // Certain underflow, assign literal 0s.
-            fp.mant = 0;
-            fp.exp = 0;
-        }
-    } else {
-        algorithm(fp, F::DEFAULT_SHIFT);
-    }
-
-    if fp.mant & F::CARRY_MASK == F::CARRY_MASK {
-        // Roundup carried over to 1 past the hidden bit.
-        shr(fp, 1);
-    }
-}
-
-// AVOID OVERFLOW/UNDERFLOW
-
-// Avoid overflow for large values, shift left as needed.
-//
-// Shift until a 1-bit is in the hidden bit, if the mantissa is not 0.
-#[inline]
-pub(crate) fn avoid_overflow<F>(fp: &mut ExtendedFloat)
-where
-    F: Float,
-{
-    // Calculate the difference to allow a single calculation
-    // rather than a loop, minimizing the number of ops required.
-    if fp.exp >= F::MAX_EXPONENT {
-        let diff = fp.exp - F::MAX_EXPONENT;
-        if diff <= F::MANTISSA_SIZE {
-            // Our overflow mask needs to start at the hidden bit, or at
-            // `F::MANTISSA_SIZE+1`, and needs to have `diff+1` bits set,
-            // to see if our value overflows.
-            let bit = (F::MANTISSA_SIZE + 1) as u64;
-            let n = (diff + 1) as u64;
-            let mask = internal_n_mask(bit, n);
-            if (fp.mant & mask) == 0 {
-                // If we have no 1-bit in the hidden-bit position,
-                // which is index 0, we need to shift 1.
-                let shift = diff + 1;
-                shl(fp, shift);
-            }
-        }
-    }
-}
-
-// ROUND TO NATIVE
-
-// Round an extended-precision float to a native float representation.
-#[inline]
-pub(crate) fn round_to_native<F, Algorithm>(fp: &mut ExtendedFloat, algorithm: Algorithm)
-where
-    F: Float,
-    Algorithm: FnOnce(&mut ExtendedFloat, i32),
-{
-    // Shift all the way left, to ensure a consistent representation.
-    // The following right-shifts do not work for a non-normalized number.
-    fp.normalize();
-
-    // Round so the fraction is in a native mantissa representation,
-    // and avoid overflow/underflow.
-    round_to_float::<F, _>(fp, algorithm);
-    avoid_overflow::<F>(fp);
-}
diff --git a/vendor/serde_json/src/lexical/shift.rs b/vendor/serde_json/src/lexical/shift.rs
deleted file mode 100644
index a0bae01..0000000
--- a/vendor/serde_json/src/lexical/shift.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Bit-shift helpers.
-
-use super::float::ExtendedFloat;
-use core::mem;
-
-// Shift extended-precision float right `shift` bytes.
-#[inline]
-pub(crate) fn shr(fp: &mut ExtendedFloat, shift: i32) {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!((shift as u64) < bits, "shr() overflow in shift right.");
-
-    fp.mant >>= shift;
-    fp.exp += shift;
-}
-
-// Shift extended-precision float right `shift` bytes.
-//
-// Accepts when the shift is the same as the type size, and
-// sets the value to 0.
-#[inline]
-pub(crate) fn overflowing_shr(fp: &mut ExtendedFloat, shift: i32) {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!(
-        (shift as u64) <= bits,
-        "overflowing_shr() overflow in shift right."
-    );
-
-    fp.mant = if shift as u64 == bits {
-        0
-    } else {
-        fp.mant >> shift
-    };
-    fp.exp += shift;
-}
-
-// Shift extended-precision float left `shift` bytes.
-#[inline]
-pub(crate) fn shl(fp: &mut ExtendedFloat, shift: i32) {
-    let bits: u64 = mem::size_of::<u64>() as u64 * 8;
-    debug_assert!((shift as u64) < bits, "shl() overflow in shift left.");
-
-    fp.mant <<= shift;
-    fp.exp -= shift;
-}
diff --git a/vendor/serde_json/src/lexical/small_powers.rs b/vendor/serde_json/src/lexical/small_powers.rs
deleted file mode 100644
index 219d826..0000000
--- a/vendor/serde_json/src/lexical/small_powers.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-//! Pre-computed small powers.
-
-// 32 BIT
-#[cfg(limb_width_32)]
-pub(crate) const POW5_32: [u32; 14] = [
-    1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625,
-    1220703125,
-];
-
-#[cfg(limb_width_32)]
-pub(crate) const POW10_32: [u32; 10] = [
-    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
-];
-
-// 64 BIT
-#[cfg(limb_width_64)]
-pub(crate) const POW5_64: [u64; 28] = [
-    1,
-    5,
-    25,
-    125,
-    625,
-    3125,
-    15625,
-    78125,
-    390625,
-    1953125,
-    9765625,
-    48828125,
-    244140625,
-    1220703125,
-    6103515625,
-    30517578125,
-    152587890625,
-    762939453125,
-    3814697265625,
-    19073486328125,
-    95367431640625,
-    476837158203125,
-    2384185791015625,
-    11920928955078125,
-    59604644775390625,
-    298023223876953125,
-    1490116119384765625,
-    7450580596923828125,
-];
-pub(crate) const POW10_64: [u64; 20] = [
-    1,
-    10,
-    100,
-    1000,
-    10000,
-    100000,
-    1000000,
-    10000000,
-    100000000,
-    1000000000,
-    10000000000,
-    100000000000,
-    1000000000000,
-    10000000000000,
-    100000000000000,
-    1000000000000000,
-    10000000000000000,
-    100000000000000000,
-    1000000000000000000,
-    10000000000000000000,
-];
diff --git a/vendor/serde_json/src/lib.rs b/vendor/serde_json/src/lib.rs
deleted file mode 100644
index 3cdbd3a..0000000
--- a/vendor/serde_json/src/lib.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-//! # Serde JSON
-//!
-//! JSON is a ubiquitous open-standard format that uses human-readable text to
-//! transmit data objects consisting of key-value pairs.
-//!
-//! ```json
-//! {
-//!     "name": "John Doe",
-//!     "age": 43,
-//!     "address": {
-//!         "street": "10 Downing Street",
-//!         "city": "London"
-//!     },
-//!     "phones": [
-//!         "+44 1234567",
-//!         "+44 2345678"
-//!     ]
-//! }
-//! ```
-//!
-//! There are three common ways that you might find yourself needing to work
-//! with JSON data in Rust.
-//!
-//!  - **As text data.** An unprocessed string of JSON data that you receive on
-//!    an HTTP endpoint, read from a file, or prepare to send to a remote
-//!    server.
-//!  - **As an untyped or loosely typed representation.** Maybe you want to
-//!    check that some JSON data is valid before passing it on, but without
-//!    knowing the structure of what it contains. Or you want to do very basic
-//!    manipulations like insert a key in a particular spot.
-//!  - **As a strongly typed Rust data structure.** When you expect all or most
-//!    of your data to conform to a particular structure and want to get real
-//!    work done without JSON's loosey-goosey nature tripping you up.
-//!
-//! Serde JSON provides efficient, flexible, safe ways of converting data
-//! between each of these representations.
-//!
-//! # Operating on untyped JSON values
-//!
-//! Any valid JSON data can be manipulated in the following recursive enum
-//! representation. This data structure is [`serde_json::Value`][value].
-//!
-//! ```
-//! # use serde_json::{Number, Map};
-//! #
-//! # #[allow(dead_code)]
-//! enum Value {
-//!     Null,
-//!     Bool(bool),
-//!     Number(Number),
-//!     String(String),
-//!     Array(Vec<Value>),
-//!     Object(Map<String, Value>),
-//! }
-//! ```
-//!
-//! A string of JSON data can be parsed into a `serde_json::Value` by the
-//! [`serde_json::from_str`][from_str] function. There is also [`from_slice`]
-//! for parsing from a byte slice &\[u8\] and [`from_reader`] for parsing from
-//! any `io::Read` like a File or a TCP stream.
-//!
-//! ```
-//! use serde_json::{Result, Value};
-//!
-//! fn untyped_example() -> Result<()> {
-//!     // Some JSON input data as a &str. Maybe this comes from the user.
-//!     let data = r#"
-//!         {
-//!             "name": "John Doe",
-//!             "age": 43,
-//!             "phones": [
-//!                 "+44 1234567",
-//!                 "+44 2345678"
-//!             ]
-//!         }"#;
-//!
-//!     // Parse the string of data into serde_json::Value.
-//!     let v: Value = serde_json::from_str(data)?;
-//!
-//!     // Access parts of the data by indexing with square brackets.
-//!     println!("Please call {} at the number {}", v["name"], v["phones"][0]);
-//!
-//!     Ok(())
-//! }
-//! #
-//! # fn main() {
-//! #     untyped_example().unwrap();
-//! # }
-//! ```
-//!
-//! The result of square bracket indexing like `v["name"]` is a borrow of the
-//! data at that index, so the type is `&Value`. A JSON map can be indexed with
-//! string keys, while a JSON array can be indexed with integer keys. If the
-//! type of the data is not right for the type with which it is being indexed,
-//! or if a map does not contain the key being indexed, or if the index into a
-//! vector is out of bounds, the returned element is `Value::Null`.
-//!
-//! When a `Value` is printed, it is printed as a JSON string. So in the code
-//! above, the output looks like `Please call "John Doe" at the number "+44
-//! 1234567"`. The quotation marks appear because `v["name"]` is a `&Value`
-//! containing a JSON string and its JSON representation is `"John Doe"`.
-//! Printing as a plain string without quotation marks involves converting from
-//! a JSON string to a Rust string with [`as_str()`] or avoiding the use of
-//! `Value` as described in the following section.
-//!
-//! [`as_str()`]: crate::Value::as_str
-//!
-//! The `Value` representation is sufficient for very basic tasks but can be
-//! tedious to work with for anything more significant. Error handling is
-//! verbose to implement correctly, for example imagine trying to detect the
-//! presence of unrecognized fields in the input data. The compiler is powerless
-//! to help you when you make a mistake, for example imagine typoing `v["name"]`
-//! as `v["nmae"]` in one of the dozens of places it is used in your code.
-//!
-//! # Parsing JSON as strongly typed data structures
-//!
-//! Serde provides a powerful way of mapping JSON data into Rust data structures
-//! largely automatically.
-//!
-//! ```
-//! use serde::{Deserialize, Serialize};
-//! use serde_json::Result;
-//!
-//! #[derive(Serialize, Deserialize)]
-//! struct Person {
-//!     name: String,
-//!     age: u8,
-//!     phones: Vec<String>,
-//! }
-//!
-//! fn typed_example() -> Result<()> {
-//!     // Some JSON input data as a &str. Maybe this comes from the user.
-//!     let data = r#"
-//!         {
-//!             "name": "John Doe",
-//!             "age": 43,
-//!             "phones": [
-//!                 "+44 1234567",
-//!                 "+44 2345678"
-//!             ]
-//!         }"#;
-//!
-//!     // Parse the string of data into a Person object. This is exactly the
-//!     // same function as the one that produced serde_json::Value above, but
-//!     // now we are asking it for a Person as output.
-//!     let p: Person = serde_json::from_str(data)?;
-//!
-//!     // Do things just like with any other Rust data structure.
-//!     println!("Please call {} at the number {}", p.name, p.phones[0]);
-//!
-//!     Ok(())
-//! }
-//! #
-//! # fn main() {
-//! #     typed_example().unwrap();
-//! # }
-//! ```
-//!
-//! This is the same `serde_json::from_str` function as before, but this time we
-//! assign the return value to a variable of type `Person` so Serde will
-//! automatically interpret the input data as a `Person` and produce informative
-//! error messages if the layout does not conform to what a `Person` is expected
-//! to look like.
-//!
-//! Any type that implements Serde's `Deserialize` trait can be deserialized
-//! this way. This includes built-in Rust standard library types like `Vec<T>`
-//! and `HashMap<K, V>`, as well as any structs or enums annotated with
-//! `#[derive(Deserialize)]`.
-//!
-//! Once we have `p` of type `Person`, our IDE and the Rust compiler can help us
-//! use it correctly like they do for any other Rust code. The IDE can
-//! autocomplete field names to prevent typos, which was impossible in the
-//! `serde_json::Value` representation. And the Rust compiler can check that
-//! when we write `p.phones[0]`, then `p.phones` is guaranteed to be a
-//! `Vec<String>` so indexing into it makes sense and produces a `String`.
-//!
-//! # Constructing JSON values
-//!
-//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
-//! objects with very natural JSON syntax.
-//!
-//! ```
-//! use serde_json::json;
-//!
-//! fn main() {
-//!     // The type of `john` is `serde_json::Value`
-//!     let john = json!({
-//!         "name": "John Doe",
-//!         "age": 43,
-//!         "phones": [
-//!             "+44 1234567",
-//!             "+44 2345678"
-//!         ]
-//!     });
-//!
-//!     println!("first phone number: {}", john["phones"][0]);
-//!
-//!     // Convert to a string of JSON and print it out
-//!     println!("{}", john.to_string());
-//! }
-//! ```
-//!
-//! The `Value::to_string()` function converts a `serde_json::Value` into a
-//! `String` of JSON text.
-//!
-//! One neat thing about the `json!` macro is that variables and expressions can
-//! be interpolated directly into the JSON value as you are building it. Serde
-//! will check at compile time that the value you are interpolating is able to
-//! be represented as JSON.
-//!
-//! ```
-//! # use serde_json::json;
-//! #
-//! # fn random_phone() -> u16 { 0 }
-//! #
-//! let full_name = "John Doe";
-//! let age_last_year = 42;
-//!
-//! // The type of `john` is `serde_json::Value`
-//! let john = json!({
-//!     "name": full_name,
-//!     "age": age_last_year + 1,
-//!     "phones": [
-//!         format!("+44 {}", random_phone())
-//!     ]
-//! });
-//! ```
-//!
-//! This is amazingly convenient, but we have the problem we had before with
-//! `Value`: the IDE and Rust compiler cannot help us if we get it wrong. Serde
-//! JSON provides a better way of serializing strongly-typed data structures
-//! into JSON text.
-//!
-//! # Creating JSON by serializing data structures
-//!
-//! A data structure can be converted to a JSON string by
-//! [`serde_json::to_string`][to_string]. There is also
-//! [`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
-//! [`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
-//! such as a File or a TCP stream.
-//!
-//! ```
-//! use serde::{Deserialize, Serialize};
-//! use serde_json::Result;
-//!
-//! #[derive(Serialize, Deserialize)]
-//! struct Address {
-//!     street: String,
-//!     city: String,
-//! }
-//!
-//! fn print_an_address() -> Result<()> {
-//!     // Some data structure.
-//!     let address = Address {
-//!         street: "10 Downing Street".to_owned(),
-//!         city: "London".to_owned(),
-//!     };
-//!
-//!     // Serialize it to a JSON string.
-//!     let j = serde_json::to_string(&address)?;
-//!
-//!     // Print, write to a file, or send to an HTTP server.
-//!     println!("{}", j);
-//!
-//!     Ok(())
-//! }
-//! #
-//! # fn main() {
-//! #     print_an_address().unwrap();
-//! # }
-//! ```
-//!
-//! Any type that implements Serde's `Serialize` trait can be serialized this
-//! way. This includes built-in Rust standard library types like `Vec<T>` and
-//! `HashMap<K, V>`, as well as any structs or enums annotated with
-//! `#[derive(Serialize)]`.
-//!
-//! # No-std support
-//!
-//! As long as there is a memory allocator, it is possible to use serde_json
-//! without the rest of the Rust standard library. Disable the default "std"
-//! feature and enable the "alloc" feature:
-//!
-//! ```toml
-//! [dependencies]
-//! serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
-//! ```
-//!
-//! For JSON support in Serde without a memory allocator, please see the
-//! [`serde-json-core`] crate.
-//!
-//! [value]: crate::value::Value
-//! [from_str]: crate::de::from_str
-//! [from_slice]: crate::de::from_slice
-//! [from_reader]: crate::de::from_reader
-//! [to_string]: crate::ser::to_string
-//! [to_vec]: crate::ser::to_vec
-//! [to_writer]: crate::ser::to_writer
-//! [macro]: crate::json
-//! [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-core
-
-#![doc(html_root_url = "https://docs.rs/serde_json/1.0.111")]
-// Ignored clippy lints
-#![allow(
-    clippy::collapsible_else_if,
-    clippy::comparison_chain,
-    clippy::deprecated_cfg_attr,
-    clippy::doc_markdown,
-    clippy::excessive_precision,
-    clippy::explicit_auto_deref,
-    clippy::float_cmp,
-    clippy::manual_range_contains,
-    clippy::match_like_matches_macro,
-    clippy::match_single_binding,
-    clippy::needless_doctest_main,
-    clippy::needless_late_init,
-    clippy::return_self_not_must_use,
-    clippy::transmute_ptr_to_ptr,
-    clippy::unnecessary_wraps
-)]
-// Ignored clippy_pedantic lints
-#![allow(
-    // Deserializer::from_str, into_iter
-    clippy::should_implement_trait,
-    // integer and float ser/de requires these sorts of casts
-    clippy::cast_possible_truncation,
-    clippy::cast_possible_wrap,
-    clippy::cast_precision_loss,
-    clippy::cast_sign_loss,
-    // correctly used
-    clippy::enum_glob_use,
-    clippy::if_not_else,
-    clippy::integer_division,
-    clippy::let_underscore_untyped,
-    clippy::map_err_ignore,
-    clippy::match_same_arms,
-    clippy::similar_names,
-    clippy::unused_self,
-    clippy::wildcard_imports,
-    // things are often more readable this way
-    clippy::cast_lossless,
-    clippy::module_name_repetitions,
-    clippy::redundant_else,
-    clippy::shadow_unrelated,
-    clippy::single_match_else,
-    clippy::too_many_lines,
-    clippy::unreadable_literal,
-    clippy::unseparated_literal_suffix,
-    clippy::use_self,
-    clippy::zero_prefixed_literal,
-    // we support older compilers
-    clippy::checked_conversions,
-    clippy::mem_replace_with_default,
-    // noisy
-    clippy::missing_errors_doc,
-    clippy::must_use_candidate,
-)]
-// Restrictions
-#![deny(clippy::question_mark_used)]
-#![allow(non_upper_case_globals)]
-#![deny(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-extern crate alloc;
-
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-#[doc(inline)]
-pub use crate::de::from_reader;
-#[doc(inline)]
-pub use crate::de::{from_slice, from_str, Deserializer, StreamDeserializer};
-#[doc(inline)]
-pub use crate::error::{Error, Result};
-#[doc(inline)]
-pub use crate::ser::{to_string, to_string_pretty, to_vec, to_vec_pretty};
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-#[doc(inline)]
-pub use crate::ser::{to_writer, to_writer_pretty, Serializer};
-#[doc(inline)]
-pub use crate::value::{from_value, to_value, Map, Number, Value};
-
-// We only use our own error type; no need for From conversions provided by the
-// standard library's try! macro. This reduces lines of LLVM IR by 4%.
-macro_rules! tri {
-    ($e:expr $(,)?) => {
-        match $e {
-            core::result::Result::Ok(val) => val,
-            core::result::Result::Err(err) => return core::result::Result::Err(err),
-        }
-    };
-}
-
-#[macro_use]
-mod macros;
-
-pub mod de;
-pub mod error;
-pub mod map;
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub mod ser;
-#[cfg(not(feature = "std"))]
-mod ser;
-pub mod value;
-
-mod features_check;
-
-mod io;
-#[cfg(feature = "std")]
-mod iter;
-#[cfg(feature = "float_roundtrip")]
-mod lexical;
-mod number;
-mod read;
-
-#[cfg(feature = "raw_value")]
-mod raw;
diff --git a/vendor/serde_json/src/macros.rs b/vendor/serde_json/src/macros.rs
deleted file mode 100644
index e8c6cd2..0000000
--- a/vendor/serde_json/src/macros.rs
+++ /dev/null
@@ -1,304 +0,0 @@
-/// Construct a `serde_json::Value` from a JSON literal.
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// let value = json!({
-///     "code": 200,
-///     "success": true,
-///     "payload": {
-///         "features": [
-///             "serde",
-///             "json"
-///         ],
-///         "homepage": null
-///     }
-/// });
-/// ```
-///
-/// Variables or expressions can be interpolated into the JSON literal. Any type
-/// interpolated into an array element or object value must implement Serde's
-/// `Serialize` trait, while any type interpolated into a object key must
-/// implement `Into<String>`. If the `Serialize` implementation of the
-/// interpolated type decides to fail, or if the interpolated type contains a
-/// map with non-string keys, the `json!` macro will panic.
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// let code = 200;
-/// let features = vec!["serde", "json"];
-///
-/// let value = json!({
-///     "code": code,
-///     "success": code == 200,
-///     "payload": {
-///         features[0]: features[1]
-///     }
-/// });
-/// ```
-///
-/// Trailing commas are allowed inside both arrays and objects.
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// let value = json!([
-///     "notice",
-///     "the",
-///     "trailing",
-///     "comma -->",
-/// ]);
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! json {
-    // Hide distracting implementation details from the generated rustdoc.
-    ($($json:tt)+) => {
-        json_internal!($($json)+)
-    };
-}
-
-// Rocket relies on this because they export their own `json!` with a different
-// doc comment than ours, and various Rust bugs prevent them from calling our
-// `json!` from their `json!` so they call `json_internal!` directly. Check with
-// @SergioBenitez before making breaking changes to this macro.
-//
-// Changes are fine as long as `json_internal!` does not call any new helper
-// macros and can still be invoked as `json_internal!($($json)+)`.
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! json_internal {
-    //////////////////////////////////////////////////////////////////////////
-    // TT muncher for parsing the inside of an array [...]. Produces a vec![...]
-    // of the elements.
-    //
-    // Must be invoked as: json_internal!(@array [] $($tt)*)
-    //////////////////////////////////////////////////////////////////////////
-
-    // Done with trailing comma.
-    (@array [$($elems:expr,)*]) => {
-        json_internal_vec![$($elems,)*]
-    };
-
-    // Done without trailing comma.
-    (@array [$($elems:expr),*]) => {
-        json_internal_vec![$($elems),*]
-    };
-
-    // Next element is `null`.
-    (@array [$($elems:expr,)*] null $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!(null)] $($rest)*)
-    };
-
-    // Next element is `true`.
-    (@array [$($elems:expr,)*] true $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!(true)] $($rest)*)
-    };
-
-    // Next element is `false`.
-    (@array [$($elems:expr,)*] false $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!(false)] $($rest)*)
-    };
-
-    // Next element is an array.
-    (@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!([$($array)*])] $($rest)*)
-    };
-
-    // Next element is a map.
-    (@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!({$($map)*})] $($rest)*)
-    };
-
-    // Next element is an expression followed by comma.
-    (@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)* json_internal!($next),] $($rest)*)
-    };
-
-    // Last element is an expression with no trailing comma.
-    (@array [$($elems:expr,)*] $last:expr) => {
-        json_internal!(@array [$($elems,)* json_internal!($last)])
-    };
-
-    // Comma after the most recent element.
-    (@array [$($elems:expr),*] , $($rest:tt)*) => {
-        json_internal!(@array [$($elems,)*] $($rest)*)
-    };
-
-    // Unexpected token after most recent element.
-    (@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => {
-        json_unexpected!($unexpected)
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // TT muncher for parsing the inside of an object {...}. Each entry is
-    // inserted into the given map variable.
-    //
-    // Must be invoked as: json_internal!(@object $map () ($($tt)*) ($($tt)*))
-    //
-    // We require two copies of the input tokens so that we can match on one
-    // copy and trigger errors on the other copy.
-    //////////////////////////////////////////////////////////////////////////
-
-    // Done.
-    (@object $object:ident () () ()) => {};
-
-    // Insert the current entry followed by trailing comma.
-    (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
-        let _ = $object.insert(($($key)+).into(), $value);
-        json_internal!(@object $object () ($($rest)*) ($($rest)*));
-    };
-
-    // Current entry followed by unexpected token.
-    (@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => {
-        json_unexpected!($unexpected);
-    };
-
-    // Insert the last entry without trailing comma.
-    (@object $object:ident [$($key:tt)+] ($value:expr)) => {
-        let _ = $object.insert(($($key)+).into(), $value);
-    };
-
-    // Next value is `null`.
-    (@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!(null)) $($rest)*);
-    };
-
-    // Next value is `true`.
-    (@object $object:ident ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!(true)) $($rest)*);
-    };
-
-    // Next value is `false`.
-    (@object $object:ident ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!(false)) $($rest)*);
-    };
-
-    // Next value is an array.
-    (@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!([$($array)*])) $($rest)*);
-    };
-
-    // Next value is a map.
-    (@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!({$($map)*})) $($rest)*);
-    };
-
-    // Next value is an expression followed by comma.
-    (@object $object:ident ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!($value)) , $($rest)*);
-    };
-
-    // Last value is an expression with no trailing comma.
-    (@object $object:ident ($($key:tt)+) (: $value:expr) $copy:tt) => {
-        json_internal!(@object $object [$($key)+] (json_internal!($value)));
-    };
-
-    // Missing value for last entry. Trigger a reasonable error message.
-    (@object $object:ident ($($key:tt)+) (:) $copy:tt) => {
-        // "unexpected end of macro invocation"
-        json_internal!();
-    };
-
-    // Missing colon and value for last entry. Trigger a reasonable error
-    // message.
-    (@object $object:ident ($($key:tt)+) () $copy:tt) => {
-        // "unexpected end of macro invocation"
-        json_internal!();
-    };
-
-    // Misplaced colon. Trigger a reasonable error message.
-    (@object $object:ident () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => {
-        // Takes no arguments so "no rules expected the token `:`".
-        json_unexpected!($colon);
-    };
-
-    // Found a comma inside a key. Trigger a reasonable error message.
-    (@object $object:ident ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
-        // Takes no arguments so "no rules expected the token `,`".
-        json_unexpected!($comma);
-    };
-
-    // Key is fully parenthesized. This avoids clippy double_parens false
-    // positives because the parenthesization may be necessary here.
-    (@object $object:ident () (($key:expr) : $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object ($key) (: $($rest)*) (: $($rest)*));
-    };
-
-    // Refuse to absorb colon token into key expression.
-    (@object $object:ident ($($key:tt)*) (: $($unexpected:tt)+) $copy:tt) => {
-        json_expect_expr_comma!($($unexpected)+);
-    };
-
-    // Munch a token into the current key.
-    (@object $object:ident ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => {
-        json_internal!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*));
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // The main implementation.
-    //
-    // Must be invoked as: json_internal!($($json)+)
-    //////////////////////////////////////////////////////////////////////////
-
-    (null) => {
-        $crate::Value::Null
-    };
-
-    (true) => {
-        $crate::Value::Bool(true)
-    };
-
-    (false) => {
-        $crate::Value::Bool(false)
-    };
-
-    ([]) => {
-        $crate::Value::Array(json_internal_vec![])
-    };
-
-    ([ $($tt:tt)+ ]) => {
-        $crate::Value::Array(json_internal!(@array [] $($tt)+))
-    };
-
-    ({}) => {
-        $crate::Value::Object($crate::Map::new())
-    };
-
-    ({ $($tt:tt)+ }) => {
-        $crate::Value::Object({
-            let mut object = $crate::Map::new();
-            json_internal!(@object object () ($($tt)+) ($($tt)+));
-            object
-        })
-    };
-
-    // Any Serialize type: numbers, strings, struct literals, variables etc.
-    // Must be below every other rule.
-    ($other:expr) => {
-        $crate::to_value(&$other).unwrap()
-    };
-}
-
-// The json_internal macro above cannot invoke vec directly because it uses
-// local_inner_macros. A vec invocation there would resolve to $crate::vec.
-// Instead invoke vec here outside of local_inner_macros.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! json_internal_vec {
-    ($($content:tt)*) => {
-        vec![$($content)*]
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! json_unexpected {
-    () => {};
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! json_expect_expr_comma {
-    ($e:expr , $($tt:tt)*) => {};
-}
diff --git a/vendor/serde_json/src/map.rs b/vendor/serde_json/src/map.rs
deleted file mode 100644
index 675058b..0000000
--- a/vendor/serde_json/src/map.rs
+++ /dev/null
@@ -1,901 +0,0 @@
-//! A map of String to serde_json::Value.
-//!
-//! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`
-//! feature of serde_json to use [`IndexMap`] instead.
-//!
-//! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
-//! [`IndexMap`]: https://docs.rs/indexmap/*/indexmap/map/struct.IndexMap.html
-
-use crate::value::Value;
-use alloc::string::String;
-use core::borrow::Borrow;
-use core::fmt::{self, Debug};
-use core::hash::Hash;
-use core::iter::FusedIterator;
-#[cfg(feature = "preserve_order")]
-use core::mem;
-use core::ops;
-use serde::de;
-
-#[cfg(not(feature = "preserve_order"))]
-use alloc::collections::{btree_map, BTreeMap};
-#[cfg(feature = "preserve_order")]
-use indexmap::{self, IndexMap};
-
-/// Represents a JSON key/value type.
-pub struct Map<K, V> {
-    map: MapImpl<K, V>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type MapImpl<K, V> = BTreeMap<K, V>;
-#[cfg(feature = "preserve_order")]
-type MapImpl<K, V> = IndexMap<K, V>;
-
-impl Map<String, Value> {
-    /// Makes a new empty Map.
-    #[inline]
-    pub fn new() -> Self {
-        Map {
-            map: MapImpl::new(),
-        }
-    }
-
-    /// Makes a new empty Map with the given initial capacity.
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Map {
-            #[cfg(not(feature = "preserve_order"))]
-            map: {
-                // does not support with_capacity
-                let _ = capacity;
-                BTreeMap::new()
-            },
-            #[cfg(feature = "preserve_order")]
-            map: IndexMap::with_capacity(capacity),
-        }
-    }
-
-    /// Clears the map, removing all values.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.map.clear();
-    }
-
-    /// Returns a reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn get<Q>(&self, key: &Q) -> Option<&Value>
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        self.map.get(key)
-    }
-
-    /// Returns true if the map contains a value for the specified key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn contains_key<Q>(&self, key: &Q) -> bool
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        self.map.contains_key(key)
-    }
-
-    /// Returns a mutable reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut Value>
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        self.map.get_mut(key)
-    }
-
-    /// Returns the key-value pair matching the given key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&String, &Value)>
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        self.map.get_key_value(key)
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not have this key present, `None` is returned.
-    ///
-    /// If the map did have this key present, the value is updated, and the old
-    /// value is returned.
-    #[inline]
-    pub fn insert(&mut self, k: String, v: Value) -> Option<Value> {
-        self.map.insert(k, v)
-    }
-
-    /// Removes a key from the map, returning the value at the key if the key
-    /// was previously in the map.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    #[inline]
-    pub fn remove<Q>(&mut self, key: &Q) -> Option<Value>
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        #[cfg(feature = "preserve_order")]
-        return self.map.swap_remove(key);
-        #[cfg(not(feature = "preserve_order"))]
-        return self.map.remove(key);
-    }
-
-    /// Removes a key from the map, returning the stored key and value if the
-    /// key was previously in the map.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(String, Value)>
-    where
-        String: Borrow<Q>,
-        Q: ?Sized + Ord + Eq + Hash,
-    {
-        self.map.remove_entry(key)
-    }
-
-    /// Moves all elements from other into self, leaving other empty.
-    #[inline]
-    pub fn append(&mut self, other: &mut Self) {
-        #[cfg(feature = "preserve_order")]
-        self.map
-            .extend(mem::replace(&mut other.map, MapImpl::default()));
-        #[cfg(not(feature = "preserve_order"))]
-        self.map.append(&mut other.map);
-    }
-
-    /// Gets the given key's corresponding entry in the map for in-place
-    /// manipulation.
-    pub fn entry<S>(&mut self, key: S) -> Entry
-    where
-        S: Into<String>,
-    {
-        #[cfg(not(feature = "preserve_order"))]
-        use alloc::collections::btree_map::Entry as EntryImpl;
-        #[cfg(feature = "preserve_order")]
-        use indexmap::map::Entry as EntryImpl;
-
-        match self.map.entry(key.into()) {
-            EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant }),
-            EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied }),
-        }
-    }
-
-    /// Returns the number of elements in the map.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.map.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.map.is_empty()
-    }
-
-    /// Gets an iterator over the entries of the map.
-    #[inline]
-    pub fn iter(&self) -> Iter {
-        Iter {
-            iter: self.map.iter(),
-        }
-    }
-
-    /// Gets a mutable iterator over the entries of the map.
-    #[inline]
-    pub fn iter_mut(&mut self) -> IterMut {
-        IterMut {
-            iter: self.map.iter_mut(),
-        }
-    }
-
-    /// Gets an iterator over the keys of the map.
-    #[inline]
-    pub fn keys(&self) -> Keys {
-        Keys {
-            iter: self.map.keys(),
-        }
-    }
-
-    /// Gets an iterator over the values of the map.
-    #[inline]
-    pub fn values(&self) -> Values {
-        Values {
-            iter: self.map.values(),
-        }
-    }
-
-    /// Gets an iterator over mutable values of the map.
-    #[inline]
-    pub fn values_mut(&mut self) -> ValuesMut {
-        ValuesMut {
-            iter: self.map.values_mut(),
-        }
-    }
-
-    /// Retains only the elements specified by the predicate.
-    ///
-    /// In other words, remove all pairs `(k, v)` such that `f(&k, &mut v)`
-    /// returns `false`.
-    #[inline]
-    pub fn retain<F>(&mut self, f: F)
-    where
-        F: FnMut(&String, &mut Value) -> bool,
-    {
-        self.map.retain(f);
-    }
-}
-
-#[allow(clippy::derivable_impls)] // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7655
-impl Default for Map<String, Value> {
-    #[inline]
-    fn default() -> Self {
-        Map {
-            map: MapImpl::new(),
-        }
-    }
-}
-
-impl Clone for Map<String, Value> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Map {
-            map: self.map.clone(),
-        }
-    }
-
-    #[inline]
-    fn clone_from(&mut self, source: &Self) {
-        self.map.clone_from(&source.map);
-    }
-}
-
-impl PartialEq for Map<String, Value> {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        self.map.eq(&other.map)
-    }
-}
-
-impl Eq for Map<String, Value> {}
-
-/// Access an element of this map. Panics if the given key is not present in the
-/// map.
-///
-/// ```
-/// # use serde_json::Value;
-/// #
-/// # let val = &Value::String("".to_owned());
-/// # let _ =
-/// match val {
-///     Value::String(s) => Some(s.as_str()),
-///     Value::Array(arr) => arr[0].as_str(),
-///     Value::Object(map) => map["type"].as_str(),
-///     _ => None,
-/// }
-/// # ;
-/// ```
-impl<'a, Q> ops::Index<&'a Q> for Map<String, Value>
-where
-    String: Borrow<Q>,
-    Q: ?Sized + Ord + Eq + Hash,
-{
-    type Output = Value;
-
-    fn index(&self, index: &Q) -> &Value {
-        self.map.index(index)
-    }
-}
-
-/// Mutably access an element of this map. Panics if the given key is not
-/// present in the map.
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// # let mut map = serde_json::Map::new();
-/// # map.insert("key".to_owned(), serde_json::Value::Null);
-/// #
-/// map["key"] = json!("value");
-/// ```
-impl<'a, Q> ops::IndexMut<&'a Q> for Map<String, Value>
-where
-    String: Borrow<Q>,
-    Q: ?Sized + Ord + Eq + Hash,
-{
-    fn index_mut(&mut self, index: &Q) -> &mut Value {
-        self.map.get_mut(index).expect("no entry found for key")
-    }
-}
-
-impl Debug for Map<String, Value> {
-    #[inline]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        self.map.fmt(formatter)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl serde::ser::Serialize for Map<String, Value> {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::ser::Serializer,
-    {
-        use serde::ser::SerializeMap;
-        let mut map = tri!(serializer.serialize_map(Some(self.len())));
-        for (k, v) in self {
-            tri!(map.serialize_entry(k, v));
-        }
-        map.end()
-    }
-}
-
-impl<'de> de::Deserialize<'de> for Map<String, Value> {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct Visitor;
-
-        impl<'de> de::Visitor<'de> for Visitor {
-            type Value = Map<String, Value>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a map")
-            }
-
-            #[inline]
-            fn visit_unit<E>(self) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok(Map::new())
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            #[inline]
-            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let mut values = Map::new();
-
-                while let Some((key, value)) = tri!(visitor.next_entry()) {
-                    values.insert(key, value);
-                }
-
-                Ok(values)
-            }
-        }
-
-        deserializer.deserialize_map(Visitor)
-    }
-}
-
-impl FromIterator<(String, Value)> for Map<String, Value> {
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = (String, Value)>,
-    {
-        Map {
-            map: FromIterator::from_iter(iter),
-        }
-    }
-}
-
-impl Extend<(String, Value)> for Map<String, Value> {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = (String, Value)>,
-    {
-        self.map.extend(iter);
-    }
-}
-
-macro_rules! delegate_iterator {
-    (($name:ident $($generics:tt)*) => $item:ty) => {
-        impl $($generics)* Iterator for $name $($generics)* {
-            type Item = $item;
-            #[inline]
-            fn next(&mut self) -> Option<Self::Item> {
-                self.iter.next()
-            }
-            #[inline]
-            fn size_hint(&self) -> (usize, Option<usize>) {
-                self.iter.size_hint()
-            }
-        }
-
-        impl $($generics)* DoubleEndedIterator for $name $($generics)* {
-            #[inline]
-            fn next_back(&mut self) -> Option<Self::Item> {
-                self.iter.next_back()
-            }
-        }
-
-        impl $($generics)* ExactSizeIterator for $name $($generics)* {
-            #[inline]
-            fn len(&self) -> usize {
-                self.iter.len()
-            }
-        }
-
-        impl $($generics)* FusedIterator for $name $($generics)* {}
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// A view into a single entry in a map, which may either be vacant or occupied.
-/// This enum is constructed from the [`entry`] method on [`Map`].
-///
-/// [`entry`]: struct.Map.html#method.entry
-/// [`Map`]: struct.Map.html
-pub enum Entry<'a> {
-    /// A vacant Entry.
-    Vacant(VacantEntry<'a>),
-    /// An occupied Entry.
-    Occupied(OccupiedEntry<'a>),
-}
-
-/// A vacant Entry. It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-pub struct VacantEntry<'a> {
-    vacant: VacantEntryImpl<'a>,
-}
-
-/// An occupied Entry. It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-pub struct OccupiedEntry<'a> {
-    occupied: OccupiedEntryImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type VacantEntryImpl<'a> = btree_map::VacantEntry<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type VacantEntryImpl<'a> = indexmap::map::VacantEntry<'a, String, Value>;
-
-#[cfg(not(feature = "preserve_order"))]
-type OccupiedEntryImpl<'a> = btree_map::OccupiedEntry<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type OccupiedEntryImpl<'a> = indexmap::map::OccupiedEntry<'a, String, Value>;
-
-impl<'a> Entry<'a> {
-    /// Returns a reference to this entry's key.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut map = serde_json::Map::new();
-    /// assert_eq!(map.entry("serde").key(), &"serde");
-    /// ```
-    pub fn key(&self) -> &String {
-        match self {
-            Entry::Vacant(e) => e.key(),
-            Entry::Occupied(e) => e.key(),
-        }
-    }
-
-    /// Ensures a value is in the entry by inserting the default if empty, and
-    /// returns a mutable reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut map = serde_json::Map::new();
-    /// map.entry("serde").or_insert(json!(12));
-    ///
-    /// assert_eq!(map["serde"], 12);
-    /// ```
-    pub fn or_insert(self, default: Value) -> &'a mut Value {
-        match self {
-            Entry::Vacant(entry) => entry.insert(default),
-            Entry::Occupied(entry) => entry.into_mut(),
-        }
-    }
-
-    /// Ensures a value is in the entry by inserting the result of the default
-    /// function if empty, and returns a mutable reference to the value in the
-    /// entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut map = serde_json::Map::new();
-    /// map.entry("serde").or_insert_with(|| json!("hoho"));
-    ///
-    /// assert_eq!(map["serde"], "hoho".to_owned());
-    /// ```
-    pub fn or_insert_with<F>(self, default: F) -> &'a mut Value
-    where
-        F: FnOnce() -> Value,
-    {
-        match self {
-            Entry::Vacant(entry) => entry.insert(default()),
-            Entry::Occupied(entry) => entry.into_mut(),
-        }
-    }
-
-    /// Provides in-place mutable access to an occupied entry before any
-    /// potential inserts into the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut map = serde_json::Map::new();
-    /// map.entry("serde")
-    ///     .and_modify(|e| *e = json!("rust"))
-    ///     .or_insert(json!("cpp"));
-    ///
-    /// assert_eq!(map["serde"], "cpp");
-    ///
-    /// map.entry("serde")
-    ///     .and_modify(|e| *e = json!("rust"))
-    ///     .or_insert(json!("cpp"));
-    ///
-    /// assert_eq!(map["serde"], "rust");
-    /// ```
-    pub fn and_modify<F>(self, f: F) -> Self
-    where
-        F: FnOnce(&mut Value),
-    {
-        match self {
-            Entry::Occupied(mut entry) => {
-                f(entry.get_mut());
-                Entry::Occupied(entry)
-            }
-            Entry::Vacant(entry) => Entry::Vacant(entry),
-        }
-    }
-}
-
-impl<'a> VacantEntry<'a> {
-    /// Gets a reference to the key that would be used when inserting a value
-    /// through the VacantEntry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Vacant(vacant) => {
-    ///         assert_eq!(vacant.key(), &"serde");
-    ///     }
-    ///     Entry::Occupied(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn key(&self) -> &String {
-        self.vacant.key()
-    }
-
-    /// Sets the value of the entry with the VacantEntry's key, and returns a
-    /// mutable reference to it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Vacant(vacant) => {
-    ///         vacant.insert(json!("hoho"));
-    ///     }
-    ///     Entry::Occupied(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn insert(self, value: Value) -> &'a mut Value {
-        self.vacant.insert(value)
-    }
-}
-
-impl<'a> OccupiedEntry<'a> {
-    /// Gets a reference to the key in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!(12));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(occupied) => {
-    ///         assert_eq!(occupied.key(), &"serde");
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn key(&self) -> &String {
-        self.occupied.key()
-    }
-
-    /// Gets a reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!(12));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(occupied) => {
-    ///         assert_eq!(occupied.get(), 12);
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn get(&self) -> &Value {
-        self.occupied.get()
-    }
-
-    /// Gets a mutable reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!([1, 2, 3]));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(mut occupied) => {
-    ///         occupied.get_mut().as_array_mut().unwrap().push(json!(4));
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    ///
-    /// assert_eq!(map["serde"].as_array().unwrap().len(), 4);
-    /// ```
-    #[inline]
-    pub fn get_mut(&mut self) -> &mut Value {
-        self.occupied.get_mut()
-    }
-
-    /// Converts the entry into a mutable reference to its value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!([1, 2, 3]));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(mut occupied) => {
-    ///         occupied.into_mut().as_array_mut().unwrap().push(json!(4));
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    ///
-    /// assert_eq!(map["serde"].as_array().unwrap().len(), 4);
-    /// ```
-    #[inline]
-    pub fn into_mut(self) -> &'a mut Value {
-        self.occupied.into_mut()
-    }
-
-    /// Sets the value of the entry with the `OccupiedEntry`'s key, and returns
-    /// the entry's old value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!(12));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(mut occupied) => {
-    ///         assert_eq!(occupied.insert(json!(13)), 12);
-    ///         assert_eq!(occupied.get(), 13);
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn insert(&mut self, value: Value) -> Value {
-        self.occupied.insert(value)
-    }
-
-    /// Takes the value of the entry out of the map, and returns it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// use serde_json::map::Entry;
-    ///
-    /// let mut map = serde_json::Map::new();
-    /// map.insert("serde".to_owned(), json!(12));
-    ///
-    /// match map.entry("serde") {
-    ///     Entry::Occupied(occupied) => {
-    ///         assert_eq!(occupied.remove(), 12);
-    ///     }
-    ///     Entry::Vacant(_) => unimplemented!(),
-    /// }
-    /// ```
-    #[inline]
-    pub fn remove(self) -> Value {
-        #[cfg(feature = "preserve_order")]
-        return self.occupied.swap_remove();
-        #[cfg(not(feature = "preserve_order"))]
-        return self.occupied.remove();
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> IntoIterator for &'a Map<String, Value> {
-    type Item = (&'a String, &'a Value);
-    type IntoIter = Iter<'a>;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        Iter {
-            iter: self.map.iter(),
-        }
-    }
-}
-
-/// An iterator over a serde_json::Map's entries.
-pub struct Iter<'a> {
-    iter: IterImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IterImpl<'a> = btree_map::Iter<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type IterImpl<'a> = indexmap::map::Iter<'a, String, Value>;
-
-delegate_iterator!((Iter<'a>) => (&'a String, &'a Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> IntoIterator for &'a mut Map<String, Value> {
-    type Item = (&'a String, &'a mut Value);
-    type IntoIter = IterMut<'a>;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        IterMut {
-            iter: self.map.iter_mut(),
-        }
-    }
-}
-
-/// A mutable iterator over a serde_json::Map's entries.
-pub struct IterMut<'a> {
-    iter: IterMutImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IterMutImpl<'a> = btree_map::IterMut<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type IterMutImpl<'a> = indexmap::map::IterMut<'a, String, Value>;
-
-delegate_iterator!((IterMut<'a>) => (&'a String, &'a mut Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl IntoIterator for Map<String, Value> {
-    type Item = (String, Value);
-    type IntoIter = IntoIter;
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter {
-            iter: self.map.into_iter(),
-        }
-    }
-}
-
-/// An owning iterator over a serde_json::Map's entries.
-pub struct IntoIter {
-    iter: IntoIterImpl,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type IntoIterImpl = btree_map::IntoIter<String, Value>;
-#[cfg(feature = "preserve_order")]
-type IntoIterImpl = indexmap::map::IntoIter<String, Value>;
-
-delegate_iterator!((IntoIter) => (String, Value));
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// An iterator over a serde_json::Map's keys.
-pub struct Keys<'a> {
-    iter: KeysImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type KeysImpl<'a> = btree_map::Keys<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type KeysImpl<'a> = indexmap::map::Keys<'a, String, Value>;
-
-delegate_iterator!((Keys<'a>) => &'a String);
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// An iterator over a serde_json::Map's values.
-pub struct Values<'a> {
-    iter: ValuesImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type ValuesImpl<'a> = btree_map::Values<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type ValuesImpl<'a> = indexmap::map::Values<'a, String, Value>;
-
-delegate_iterator!((Values<'a>) => &'a Value);
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// A mutable iterator over a serde_json::Map's values.
-pub struct ValuesMut<'a> {
-    iter: ValuesMutImpl<'a>,
-}
-
-#[cfg(not(feature = "preserve_order"))]
-type ValuesMutImpl<'a> = btree_map::ValuesMut<'a, String, Value>;
-#[cfg(feature = "preserve_order")]
-type ValuesMutImpl<'a> = indexmap::map::ValuesMut<'a, String, Value>;
-
-delegate_iterator!((ValuesMut<'a>) => &'a mut Value);
diff --git a/vendor/serde_json/src/number.rs b/vendor/serde_json/src/number.rs
deleted file mode 100644
index b0231a8..0000000
--- a/vendor/serde_json/src/number.rs
+++ /dev/null
@@ -1,801 +0,0 @@
-use crate::de::ParserNumber;
-use crate::error::Error;
-#[cfg(feature = "arbitrary_precision")]
-use crate::error::ErrorCode;
-#[cfg(feature = "arbitrary_precision")]
-use alloc::borrow::ToOwned;
-#[cfg(feature = "arbitrary_precision")]
-use alloc::string::{String, ToString};
-use core::fmt::{self, Debug, Display};
-#[cfg(not(feature = "arbitrary_precision"))]
-use core::hash::{Hash, Hasher};
-use serde::de::{self, Unexpected, Visitor};
-#[cfg(feature = "arbitrary_precision")]
-use serde::de::{IntoDeserializer, MapAccess};
-use serde::{forward_to_deserialize_any, Deserialize, Deserializer, Serialize, Serializer};
-
-#[cfg(feature = "arbitrary_precision")]
-pub(crate) const TOKEN: &str = "$serde_json::private::Number";
-
-/// Represents a JSON number, whether integer or floating point.
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct Number {
-    n: N,
-}
-
-#[cfg(not(feature = "arbitrary_precision"))]
-#[derive(Copy, Clone)]
-enum N {
-    PosInt(u64),
-    /// Always less than zero.
-    NegInt(i64),
-    /// Always finite.
-    Float(f64),
-}
-
-#[cfg(not(feature = "arbitrary_precision"))]
-impl PartialEq for N {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (N::PosInt(a), N::PosInt(b)) => a == b,
-            (N::NegInt(a), N::NegInt(b)) => a == b,
-            (N::Float(a), N::Float(b)) => a == b,
-            _ => false,
-        }
-    }
-}
-
-// Implementing Eq is fine since any float values are always finite.
-#[cfg(not(feature = "arbitrary_precision"))]
-impl Eq for N {}
-
-#[cfg(not(feature = "arbitrary_precision"))]
-impl Hash for N {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        match *self {
-            N::PosInt(i) => i.hash(h),
-            N::NegInt(i) => i.hash(h),
-            N::Float(f) => {
-                if f == 0.0f64 {
-                    // There are 2 zero representations, +0 and -0, which
-                    // compare equal but have different bits. We use the +0 hash
-                    // for both so that hash(+0) == hash(-0).
-                    0.0f64.to_bits().hash(h);
-                } else {
-                    f.to_bits().hash(h);
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-type N = String;
-
-impl Number {
-    /// Returns true if the `Number` is an integer between `i64::MIN` and
-    /// `i64::MAX`.
-    ///
-    /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_i64());
-    ///
-    /// // Greater than i64::MAX.
-    /// assert!(!v["b"].is_i64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_i64());
-    /// ```
-    #[inline]
-    pub fn is_i64(&self) -> bool {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(v) => v <= i64::max_value() as u64,
-            N::NegInt(_) => true,
-            N::Float(_) => false,
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.as_i64().is_some()
-    }
-
-    /// Returns true if the `Number` is an integer between zero and `u64::MAX`.
-    ///
-    /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_u64());
-    ///
-    /// // Negative integer.
-    /// assert!(!v["b"].is_u64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_u64());
-    /// ```
-    #[inline]
-    pub fn is_u64(&self) -> bool {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(_) => true,
-            N::NegInt(_) | N::Float(_) => false,
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.as_u64().is_some()
-    }
-
-    /// Returns true if the `Number` can be represented by f64.
-    ///
-    /// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to
-    /// return the floating point value.
-    ///
-    /// Currently this function returns true if and only if both `is_i64` and
-    /// `is_u64` return false but this is not a guarantee in the future.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert!(v["a"].is_f64());
-    ///
-    /// // Integers.
-    /// assert!(!v["b"].is_f64());
-    /// assert!(!v["c"].is_f64());
-    /// ```
-    #[inline]
-    pub fn is_f64(&self) -> bool {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::Float(_) => true,
-            N::PosInt(_) | N::NegInt(_) => false,
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        {
-            for c in self.n.chars() {
-                if c == '.' || c == 'e' || c == 'E' {
-                    return self.n.parse::<f64>().ok().map_or(false, f64::is_finite);
-                }
-            }
-            false
-        }
-    }
-
-    /// If the `Number` is an integer, represent it as i64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_i64(), Some(64));
-    /// assert_eq!(v["b"].as_i64(), None);
-    /// assert_eq!(v["c"].as_i64(), None);
-    /// ```
-    #[inline]
-    pub fn as_i64(&self) -> Option<i64> {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(n) => {
-                if n <= i64::max_value() as u64 {
-                    Some(n as i64)
-                } else {
-                    None
-                }
-            }
-            N::NegInt(n) => Some(n),
-            N::Float(_) => None,
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.n.parse().ok()
-    }
-
-    /// If the `Number` is an integer, represent it as u64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_u64(), Some(64));
-    /// assert_eq!(v["b"].as_u64(), None);
-    /// assert_eq!(v["c"].as_u64(), None);
-    /// ```
-    #[inline]
-    pub fn as_u64(&self) -> Option<u64> {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(n) => Some(n),
-            N::NegInt(_) | N::Float(_) => None,
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.n.parse().ok()
-    }
-
-    /// Represents the number as f64 if possible. Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert_eq!(v["a"].as_f64(), Some(256.0));
-    /// assert_eq!(v["b"].as_f64(), Some(64.0));
-    /// assert_eq!(v["c"].as_f64(), Some(-64.0));
-    /// ```
-    #[inline]
-    pub fn as_f64(&self) -> Option<f64> {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(n) => Some(n as f64),
-            N::NegInt(n) => Some(n as f64),
-            N::Float(n) => Some(n),
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.n.parse::<f64>().ok().filter(|float| float.is_finite())
-    }
-
-    /// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSON
-    /// numbers.
-    ///
-    /// ```
-    /// # use std::f64;
-    /// #
-    /// # use serde_json::Number;
-    /// #
-    /// assert!(Number::from_f64(256.0).is_some());
-    ///
-    /// assert!(Number::from_f64(f64::NAN).is_none());
-    /// ```
-    #[inline]
-    pub fn from_f64(f: f64) -> Option<Number> {
-        if f.is_finite() {
-            let n = {
-                #[cfg(not(feature = "arbitrary_precision"))]
-                {
-                    N::Float(f)
-                }
-                #[cfg(feature = "arbitrary_precision")]
-                {
-                    ryu::Buffer::new().format_finite(f).to_owned()
-                }
-            };
-            Some(Number { n })
-        } else {
-            None
-        }
-    }
-
-    /// Returns the exact original JSON representation that this Number was
-    /// parsed from.
-    ///
-    /// For numbers constructed not via parsing, such as by `From<i32>`, returns
-    /// the JSON representation that serde\_json would serialize for this
-    /// number.
-    ///
-    /// ```
-    /// # use serde_json::Number;
-    /// for value in [
-    ///     "7",
-    ///     "12.34",
-    ///     "34e-56789",
-    ///     "0.0123456789000000012345678900000001234567890000123456789",
-    ///     "343412345678910111213141516171819202122232425262728293034",
-    ///     "-343412345678910111213141516171819202122232425262728293031",
-    /// ] {
-    ///     let number: Number = serde_json::from_str(value).unwrap();
-    ///     assert_eq!(number.as_str(), value);
-    /// }
-    /// ```
-    #[cfg(feature = "arbitrary_precision")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "arbitrary_precision")))]
-    pub fn as_str(&self) -> &str {
-        &self.n
-    }
-
-    pub(crate) fn as_f32(&self) -> Option<f32> {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        match self.n {
-            N::PosInt(n) => Some(n as f32),
-            N::NegInt(n) => Some(n as f32),
-            N::Float(n) => Some(n as f32),
-        }
-        #[cfg(feature = "arbitrary_precision")]
-        self.n.parse::<f32>().ok().filter(|float| float.is_finite())
-    }
-
-    pub(crate) fn from_f32(f: f32) -> Option<Number> {
-        if f.is_finite() {
-            let n = {
-                #[cfg(not(feature = "arbitrary_precision"))]
-                {
-                    N::Float(f as f64)
-                }
-                #[cfg(feature = "arbitrary_precision")]
-                {
-                    ryu::Buffer::new().format_finite(f).to_owned()
-                }
-            };
-            Some(Number { n })
-        } else {
-            None
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    /// Not public API. Only tests use this.
-    #[doc(hidden)]
-    #[inline]
-    pub fn from_string_unchecked(n: String) -> Self {
-        Number { n }
-    }
-}
-
-impl Display for Number {
-    #[cfg(not(feature = "arbitrary_precision"))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self.n {
-            N::PosInt(u) => formatter.write_str(itoa::Buffer::new().format(u)),
-            N::NegInt(i) => formatter.write_str(itoa::Buffer::new().format(i)),
-            N::Float(f) => formatter.write_str(ryu::Buffer::new().format_finite(f)),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.n, formatter)
-    }
-}
-
-impl Debug for Number {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        write!(formatter, "Number({})", self)
-    }
-}
-
-impl Serialize for Number {
-    #[cfg(not(feature = "arbitrary_precision"))]
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.n {
-            N::PosInt(u) => serializer.serialize_u64(u),
-            N::NegInt(i) => serializer.serialize_i64(i),
-            N::Float(f) => serializer.serialize_f64(f),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut s = tri!(serializer.serialize_struct(TOKEN, 1));
-        tri!(s.serialize_field(TOKEN, &self.n));
-        s.end()
-    }
-}
-
-impl<'de> Deserialize<'de> for Number {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct NumberVisitor;
-
-        impl<'de> Visitor<'de> for NumberVisitor {
-            type Value = Number;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a JSON number")
-            }
-
-            #[inline]
-            fn visit_i64<E>(self, value: i64) -> Result<Number, E> {
-                Ok(value.into())
-            }
-
-            #[inline]
-            fn visit_u64<E>(self, value: u64) -> Result<Number, E> {
-                Ok(value.into())
-            }
-
-            #[inline]
-            fn visit_f64<E>(self, value: f64) -> Result<Number, E>
-            where
-                E: de::Error,
-            {
-                Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number"))
-            }
-
-            #[cfg(feature = "arbitrary_precision")]
-            #[inline]
-            fn visit_map<V>(self, mut visitor: V) -> Result<Number, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let value = tri!(visitor.next_key::<NumberKey>());
-                if value.is_none() {
-                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
-                }
-                let v: NumberFromString = tri!(visitor.next_value());
-                Ok(v.value)
-            }
-        }
-
-        deserializer.deserialize_any(NumberVisitor)
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-struct NumberKey;
-
-#[cfg(feature = "arbitrary_precision")]
-impl<'de> de::Deserialize<'de> for NumberKey {
-    fn deserialize<D>(deserializer: D) -> Result<NumberKey, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct FieldVisitor;
-
-        impl<'de> de::Visitor<'de> for FieldVisitor {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a valid number field")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<(), E>
-            where
-                E: de::Error,
-            {
-                if s == TOKEN {
-                    Ok(())
-                } else {
-                    Err(de::Error::custom("expected field with custom name"))
-                }
-            }
-        }
-
-        tri!(deserializer.deserialize_identifier(FieldVisitor));
-        Ok(NumberKey)
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-pub struct NumberFromString {
-    pub value: Number,
-}
-
-#[cfg(feature = "arbitrary_precision")]
-impl<'de> de::Deserialize<'de> for NumberFromString {
-    fn deserialize<D>(deserializer: D) -> Result<NumberFromString, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        struct Visitor;
-
-        impl<'de> de::Visitor<'de> for Visitor {
-            type Value = NumberFromString;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("string containing a number")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<NumberFromString, E>
-            where
-                E: de::Error,
-            {
-                let n = tri!(s.parse().map_err(de::Error::custom));
-                Ok(NumberFromString { value: n })
-            }
-        }
-
-        deserializer.deserialize_str(Visitor)
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-fn invalid_number() -> Error {
-    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
-}
-
-macro_rules! deserialize_any {
-    (@expand [$($num_string:tt)*]) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        #[inline]
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self.n {
-                N::PosInt(u) => visitor.visit_u64(u),
-                N::NegInt(i) => visitor.visit_i64(i),
-                N::Float(f) => visitor.visit_f64(f),
-            }
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        #[inline]
-        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-            where V: Visitor<'de>
-        {
-            if let Some(u) = self.as_u64() {
-                return visitor.visit_u64(u);
-            } else if let Some(i) = self.as_i64() {
-                return visitor.visit_i64(i);
-            } else if let Some(f) = self.as_f64() {
-                if ryu::Buffer::new().format_finite(f) == self.n || f.to_string() == self.n {
-                    return visitor.visit_f64(f);
-                }
-            }
-
-            visitor.visit_map(NumberDeserializer {
-                number: Some(self.$($num_string)*),
-            })
-        }
-    };
-
-    (owned) => {
-        deserialize_any!(@expand [n]);
-    };
-
-    (ref) => {
-        deserialize_any!(@expand [n.clone()]);
-    };
-}
-
-macro_rules! deserialize_number {
-    ($deserialize:ident => $visit:ident) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.deserialize_any(visitor)
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            visitor.$visit(tri!(self.n.parse().map_err(|_| invalid_number())))
-        }
-    };
-}
-
-impl<'de> Deserializer<'de> for Number {
-    type Error = Error;
-
-    deserialize_any!(owned);
-
-    deserialize_number!(deserialize_i8 => visit_i8);
-    deserialize_number!(deserialize_i16 => visit_i16);
-    deserialize_number!(deserialize_i32 => visit_i32);
-    deserialize_number!(deserialize_i64 => visit_i64);
-    deserialize_number!(deserialize_i128 => visit_i128);
-    deserialize_number!(deserialize_u8 => visit_u8);
-    deserialize_number!(deserialize_u16 => visit_u16);
-    deserialize_number!(deserialize_u32 => visit_u32);
-    deserialize_number!(deserialize_u64 => visit_u64);
-    deserialize_number!(deserialize_u128 => visit_u128);
-    deserialize_number!(deserialize_f32 => visit_f32);
-    deserialize_number!(deserialize_f64 => visit_f64);
-
-    forward_to_deserialize_any! {
-        bool char str string bytes byte_buf option unit unit_struct
-        newtype_struct seq tuple tuple_struct map struct enum identifier
-        ignored_any
-    }
-}
-
-impl<'de, 'a> Deserializer<'de> for &'a Number {
-    type Error = Error;
-
-    deserialize_any!(ref);
-
-    deserialize_number!(deserialize_i8 => visit_i8);
-    deserialize_number!(deserialize_i16 => visit_i16);
-    deserialize_number!(deserialize_i32 => visit_i32);
-    deserialize_number!(deserialize_i64 => visit_i64);
-    deserialize_number!(deserialize_i128 => visit_i128);
-    deserialize_number!(deserialize_u8 => visit_u8);
-    deserialize_number!(deserialize_u16 => visit_u16);
-    deserialize_number!(deserialize_u32 => visit_u32);
-    deserialize_number!(deserialize_u64 => visit_u64);
-    deserialize_number!(deserialize_u128 => visit_u128);
-    deserialize_number!(deserialize_f32 => visit_f32);
-    deserialize_number!(deserialize_f64 => visit_f64);
-
-    forward_to_deserialize_any! {
-        bool char str string bytes byte_buf option unit unit_struct
-        newtype_struct seq tuple tuple_struct map struct enum identifier
-        ignored_any
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-pub(crate) struct NumberDeserializer {
-    pub number: Option<String>,
-}
-
-#[cfg(feature = "arbitrary_precision")]
-impl<'de> MapAccess<'de> for NumberDeserializer {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.number.is_none() {
-            return Ok(None);
-        }
-        seed.deserialize(NumberFieldDeserializer).map(Some)
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self.number.take().unwrap().into_deserializer())
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-struct NumberFieldDeserializer;
-
-#[cfg(feature = "arbitrary_precision")]
-impl<'de> Deserializer<'de> for NumberFieldDeserializer {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(TOKEN)
-    }
-
-    forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
-        bytes byte_buf map struct option unit newtype_struct ignored_any
-        unit_struct tuple_struct tuple enum identifier
-    }
-}
-
-impl From<ParserNumber> for Number {
-    fn from(value: ParserNumber) -> Self {
-        let n = match value {
-            ParserNumber::F64(f) => {
-                #[cfg(not(feature = "arbitrary_precision"))]
-                {
-                    N::Float(f)
-                }
-                #[cfg(feature = "arbitrary_precision")]
-                {
-                    f.to_string()
-                }
-            }
-            ParserNumber::U64(u) => {
-                #[cfg(not(feature = "arbitrary_precision"))]
-                {
-                    N::PosInt(u)
-                }
-                #[cfg(feature = "arbitrary_precision")]
-                {
-                    u.to_string()
-                }
-            }
-            ParserNumber::I64(i) => {
-                #[cfg(not(feature = "arbitrary_precision"))]
-                {
-                    N::NegInt(i)
-                }
-                #[cfg(feature = "arbitrary_precision")]
-                {
-                    i.to_string()
-                }
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            ParserNumber::String(s) => s,
-        };
-        Number { n }
-    }
-}
-
-macro_rules! impl_from_unsigned {
-    (
-        $($ty:ty),*
-    ) => {
-        $(
-            impl From<$ty> for Number {
-                #[inline]
-                fn from(u: $ty) -> Self {
-                    let n = {
-                        #[cfg(not(feature = "arbitrary_precision"))]
-                        { N::PosInt(u as u64) }
-                        #[cfg(feature = "arbitrary_precision")]
-                        {
-                            itoa::Buffer::new().format(u).to_owned()
-                        }
-                    };
-                    Number { n }
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! impl_from_signed {
-    (
-        $($ty:ty),*
-    ) => {
-        $(
-            impl From<$ty> for Number {
-                #[inline]
-                fn from(i: $ty) -> Self {
-                    let n = {
-                        #[cfg(not(feature = "arbitrary_precision"))]
-                        {
-                            if i < 0 {
-                                N::NegInt(i as i64)
-                            } else {
-                                N::PosInt(i as u64)
-                            }
-                        }
-                        #[cfg(feature = "arbitrary_precision")]
-                        {
-                            itoa::Buffer::new().format(i).to_owned()
-                        }
-                    };
-                    Number { n }
-                }
-            }
-        )*
-    };
-}
-
-impl_from_unsigned!(u8, u16, u32, u64, usize);
-impl_from_signed!(i8, i16, i32, i64, isize);
-
-#[cfg(feature = "arbitrary_precision")]
-impl_from_unsigned!(u128);
-#[cfg(feature = "arbitrary_precision")]
-impl_from_signed!(i128);
-
-impl Number {
-    #[cfg(not(feature = "arbitrary_precision"))]
-    #[cold]
-    pub(crate) fn unexpected(&self) -> Unexpected {
-        match self.n {
-            N::PosInt(u) => Unexpected::Unsigned(u),
-            N::NegInt(i) => Unexpected::Signed(i),
-            N::Float(f) => Unexpected::Float(f),
-        }
-    }
-
-    #[cfg(feature = "arbitrary_precision")]
-    #[cold]
-    pub(crate) fn unexpected(&self) -> Unexpected {
-        Unexpected::Other("number")
-    }
-}
diff --git a/vendor/serde_json/src/raw.rs b/vendor/serde_json/src/raw.rs
deleted file mode 100644
index a2bf0ec..0000000
--- a/vendor/serde_json/src/raw.rs
+++ /dev/null
@@ -1,777 +0,0 @@
-use crate::error::Error;
-use alloc::borrow::ToOwned;
-use alloc::boxed::Box;
-use alloc::string::String;
-use core::fmt::{self, Debug, Display};
-use core::mem;
-use serde::de::value::BorrowedStrDeserializer;
-use serde::de::{
-    self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
-    Visitor,
-};
-use serde::forward_to_deserialize_any;
-use serde::ser::{Serialize, SerializeStruct, Serializer};
-
-/// Reference to a range of bytes encompassing a single valid JSON value in the
-/// input data.
-///
-/// A `RawValue` can be used to defer parsing parts of a payload until later,
-/// or to avoid parsing it at all in the case that part of the payload just
-/// needs to be transferred verbatim into a different output object.
-///
-/// When serializing, a value of this type will retain its original formatting
-/// and will not be minified or pretty-printed.
-///
-/// # Note
-///
-/// `RawValue` is only available if serde\_json is built with the `"raw_value"`
-/// feature.
-///
-/// ```toml
-/// [dependencies]
-/// serde_json = { version = "1.0", features = ["raw_value"] }
-/// ```
-///
-/// # Example
-///
-/// ```
-/// use serde::{Deserialize, Serialize};
-/// use serde_json::{Result, value::RawValue};
-///
-/// #[derive(Deserialize)]
-/// struct Input<'a> {
-///     code: u32,
-///     #[serde(borrow)]
-///     payload: &'a RawValue,
-/// }
-///
-/// #[derive(Serialize)]
-/// struct Output<'a> {
-///     info: (u32, &'a RawValue),
-/// }
-///
-/// // Efficiently rearrange JSON input containing separate "code" and "payload"
-/// // keys into a single "info" key holding an array of code and payload.
-/// //
-/// // This could be done equivalently using serde_json::Value as the type for
-/// // payload, but &RawValue will perform better because it does not require
-/// // memory allocation. The correct range of bytes is borrowed from the input
-/// // data and pasted verbatim into the output.
-/// fn rearrange(input: &str) -> Result<String> {
-///     let input: Input = serde_json::from_str(input)?;
-///
-///     let output = Output {
-///         info: (input.code, input.payload),
-///     };
-///
-///     serde_json::to_string(&output)
-/// }
-///
-/// fn main() -> Result<()> {
-///     let out = rearrange(r#" {"code": 200, "payload": {}} "#)?;
-///
-///     assert_eq!(out, r#"{"info":[200,{}]}"#);
-///
-///     Ok(())
-/// }
-/// ```
-///
-/// # Ownership
-///
-/// The typical usage of `RawValue` will be in the borrowed form:
-///
-/// ```
-/// # use serde::Deserialize;
-/// # use serde_json::value::RawValue;
-/// #
-/// #[derive(Deserialize)]
-/// struct SomeStruct<'a> {
-///     #[serde(borrow)]
-///     raw_value: &'a RawValue,
-/// }
-/// ```
-///
-/// The borrowed form is suitable when deserializing through
-/// [`serde_json::from_str`] and [`serde_json::from_slice`] which support
-/// borrowing from the input data without memory allocation.
-///
-/// When deserializing through [`serde_json::from_reader`] you will need to use
-/// the boxed form of `RawValue` instead. This is almost as efficient but
-/// involves buffering the raw value from the I/O stream into memory.
-///
-/// [`serde_json::from_str`]: ../fn.from_str.html
-/// [`serde_json::from_slice`]: ../fn.from_slice.html
-/// [`serde_json::from_reader`]: ../fn.from_reader.html
-///
-/// ```
-/// # use serde::Deserialize;
-/// # use serde_json::value::RawValue;
-/// #
-/// #[derive(Deserialize)]
-/// struct SomeStruct {
-///     raw_value: Box<RawValue>,
-/// }
-/// ```
-#[cfg_attr(not(doc), repr(transparent))]
-#[cfg_attr(docsrs, doc(cfg(feature = "raw_value")))]
-pub struct RawValue {
-    json: str,
-}
-
-impl RawValue {
-    fn from_borrowed(json: &str) -> &Self {
-        unsafe { mem::transmute::<&str, &RawValue>(json) }
-    }
-
-    fn from_owned(json: Box<str>) -> Box<Self> {
-        unsafe { mem::transmute::<Box<str>, Box<RawValue>>(json) }
-    }
-
-    fn into_owned(raw_value: Box<Self>) -> Box<str> {
-        unsafe { mem::transmute::<Box<RawValue>, Box<str>>(raw_value) }
-    }
-}
-
-impl Clone for Box<RawValue> {
-    fn clone(&self) -> Self {
-        (**self).to_owned()
-    }
-}
-
-impl ToOwned for RawValue {
-    type Owned = Box<RawValue>;
-
-    fn to_owned(&self) -> Self::Owned {
-        RawValue::from_owned(self.json.to_owned().into_boxed_str())
-    }
-}
-
-impl Default for Box<RawValue> {
-    fn default() -> Self {
-        RawValue::from_borrowed("null").to_owned()
-    }
-}
-
-impl Debug for RawValue {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_tuple("RawValue")
-            .field(&format_args!("{}", &self.json))
-            .finish()
-    }
-}
-
-impl Display for RawValue {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&self.json)
-    }
-}
-
-impl RawValue {
-    /// Convert an owned `String` of JSON data to an owned `RawValue`.
-    ///
-    /// This function is equivalent to `serde_json::from_str::<Box<RawValue>>`
-    /// except that we avoid an allocation and memcpy if both of the following
-    /// are true:
-    ///
-    /// - the input has no leading or trailing whitespace, and
-    /// - the input has capacity equal to its length.
-    pub fn from_string(json: String) -> Result<Box<Self>, Error> {
-        let borrowed = tri!(crate::from_str::<&Self>(&json));
-        if borrowed.json.len() < json.len() {
-            return Ok(borrowed.to_owned());
-        }
-        Ok(Self::from_owned(json.into_boxed_str()))
-    }
-
-    /// Access the JSON text underlying a raw value.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use serde::Deserialize;
-    /// use serde_json::{Result, value::RawValue};
-    ///
-    /// #[derive(Deserialize)]
-    /// struct Response<'a> {
-    ///     code: u32,
-    ///     #[serde(borrow)]
-    ///     payload: &'a RawValue,
-    /// }
-    ///
-    /// fn process(input: &str) -> Result<()> {
-    ///     let response: Response = serde_json::from_str(input)?;
-    ///
-    ///     let payload = response.payload.get();
-    ///     if payload.starts_with('{') {
-    ///         // handle a payload which is a JSON map
-    ///     } else {
-    ///         // handle any other type
-    ///     }
-    ///
-    ///     Ok(())
-    /// }
-    ///
-    /// fn main() -> Result<()> {
-    ///     process(r#" {"code": 200, "payload": {}} "#)?;
-    ///     Ok(())
-    /// }
-    /// ```
-    pub fn get(&self) -> &str {
-        &self.json
-    }
-}
-
-impl From<Box<RawValue>> for Box<str> {
-    fn from(raw_value: Box<RawValue>) -> Self {
-        RawValue::into_owned(raw_value)
-    }
-}
-
-/// Convert a `T` into a boxed `RawValue`.
-///
-/// # Example
-///
-/// ```
-/// // Upstream crate
-/// # #[derive(Serialize)]
-/// pub struct Thing {
-///     foo: String,
-///     bar: Option<String>,
-///     extra_data: Box<RawValue>,
-/// }
-///
-/// // Local crate
-/// use serde::Serialize;
-/// use serde_json::value::{to_raw_value, RawValue};
-///
-/// #[derive(Serialize)]
-/// struct MyExtraData {
-///     a: u32,
-///     b: u32,
-/// }
-///
-/// let my_thing = Thing {
-///     foo: "FooVal".into(),
-///     bar: None,
-///     extra_data: to_raw_value(&MyExtraData { a: 1, b: 2 }).unwrap(),
-/// };
-/// # assert_eq!(
-/// #     serde_json::to_value(my_thing).unwrap(),
-/// #     serde_json::json!({
-/// #         "foo": "FooVal",
-/// #         "bar": null,
-/// #         "extra_data": { "a": 1, "b": 2 }
-/// #     })
-/// # );
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-///
-/// ```
-/// use std::collections::BTreeMap;
-///
-/// // The keys in this map are vectors, not strings.
-/// let mut map = BTreeMap::new();
-/// map.insert(vec![32, 64], "x86");
-///
-/// println!("{}", serde_json::value::to_raw_value(&map).unwrap_err());
-/// ```
-#[cfg_attr(docsrs, doc(cfg(feature = "raw_value")))]
-pub fn to_raw_value<T>(value: &T) -> Result<Box<RawValue>, Error>
-where
-    T: ?Sized + Serialize,
-{
-    let json_string = tri!(crate::to_string(value));
-    Ok(RawValue::from_owned(json_string.into_boxed_str()))
-}
-
-pub const TOKEN: &str = "$serde_json::private::RawValue";
-
-impl Serialize for RawValue {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut s = tri!(serializer.serialize_struct(TOKEN, 1));
-        tri!(s.serialize_field(TOKEN, &self.json));
-        s.end()
-    }
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct ReferenceVisitor;
-
-        impl<'de> Visitor<'de> for ReferenceVisitor {
-            type Value = &'de RawValue;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                write!(formatter, "any valid JSON value")
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                let value = tri!(visitor.next_key::<RawKey>());
-                if value.is_none() {
-                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
-                }
-                visitor.next_value_seed(ReferenceFromString)
-            }
-        }
-
-        deserializer.deserialize_newtype_struct(TOKEN, ReferenceVisitor)
-    }
-}
-
-impl<'de> Deserialize<'de> for Box<RawValue> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct BoxedVisitor;
-
-        impl<'de> Visitor<'de> for BoxedVisitor {
-            type Value = Box<RawValue>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                write!(formatter, "any valid JSON value")
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                let value = tri!(visitor.next_key::<RawKey>());
-                if value.is_none() {
-                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
-                }
-                visitor.next_value_seed(BoxedFromString)
-            }
-        }
-
-        deserializer.deserialize_newtype_struct(TOKEN, BoxedVisitor)
-    }
-}
-
-struct RawKey;
-
-impl<'de> Deserialize<'de> for RawKey {
-    fn deserialize<D>(deserializer: D) -> Result<RawKey, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct FieldVisitor;
-
-        impl<'de> Visitor<'de> for FieldVisitor {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("raw value")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<(), E>
-            where
-                E: de::Error,
-            {
-                if s == TOKEN {
-                    Ok(())
-                } else {
-                    Err(de::Error::custom("unexpected raw value"))
-                }
-            }
-        }
-
-        tri!(deserializer.deserialize_identifier(FieldVisitor));
-        Ok(RawKey)
-    }
-}
-
-pub struct ReferenceFromString;
-
-impl<'de> DeserializeSeed<'de> for ReferenceFromString {
-    type Value = &'de RawValue;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(self)
-    }
-}
-
-impl<'de> Visitor<'de> for ReferenceFromString {
-    type Value = &'de RawValue;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("raw value")
-    }
-
-    fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(RawValue::from_borrowed(s))
-    }
-}
-
-pub struct BoxedFromString;
-
-impl<'de> DeserializeSeed<'de> for BoxedFromString {
-    type Value = Box<RawValue>;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(self)
-    }
-}
-
-impl<'de> Visitor<'de> for BoxedFromString {
-    type Value = Box<RawValue>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("raw value")
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(RawValue::from_owned(s.to_owned().into_boxed_str()))
-    }
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(RawValue::from_owned(s.into_boxed_str()))
-    }
-}
-
-struct RawKeyDeserializer;
-
-impl<'de> Deserializer<'de> for RawKeyDeserializer {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(TOKEN)
-    }
-
-    forward_to_deserialize_any! {
-        bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
-        bytes byte_buf map struct option unit newtype_struct ignored_any
-        unit_struct tuple_struct tuple enum identifier
-    }
-}
-
-pub struct OwnedRawDeserializer {
-    pub raw_value: Option<String>,
-}
-
-impl<'de> MapAccess<'de> for OwnedRawDeserializer {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.raw_value.is_none() {
-            return Ok(None);
-        }
-        seed.deserialize(RawKeyDeserializer).map(Some)
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self.raw_value.take().unwrap().into_deserializer())
-    }
-}
-
-pub struct BorrowedRawDeserializer<'de> {
-    pub raw_value: Option<&'de str>,
-}
-
-impl<'de> MapAccess<'de> for BorrowedRawDeserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
-    where
-        K: de::DeserializeSeed<'de>,
-    {
-        if self.raw_value.is_none() {
-            return Ok(None);
-        }
-        seed.deserialize(RawKeyDeserializer).map(Some)
-    }
-
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(BorrowedStrDeserializer::new(self.raw_value.take().unwrap()))
-    }
-}
-
-impl<'de> IntoDeserializer<'de, Error> for &'de RawValue {
-    type Deserializer = &'de RawValue;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de> Deserializer<'de> for &'de RawValue {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_any(visitor)
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_bool(visitor)
-    }
-
-    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_i8(visitor)
-    }
-
-    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_i16(visitor)
-    }
-
-    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_i32(visitor)
-    }
-
-    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_i64(visitor)
-    }
-
-    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_i128(visitor)
-    }
-
-    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_u8(visitor)
-    }
-
-    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_u16(visitor)
-    }
-
-    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_u32(visitor)
-    }
-
-    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_u64(visitor)
-    }
-
-    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_u128(visitor)
-    }
-
-    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_f32(visitor)
-    }
-
-    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_f64(visitor)
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_char(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_str(visitor)
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_string(visitor)
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_bytes(visitor)
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_byte_buf(visitor)
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_option(visitor)
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_unit(visitor)
-    }
-
-    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_unit_struct(name, visitor)
-    }
-
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_newtype_struct(name, visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_tuple(len, visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        name: &'static str,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_tuple_struct(name, len, visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_map(visitor)
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_struct(name, fields, visitor)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_enum(name, variants, visitor)
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_identifier(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        crate::Deserializer::from_str(&self.json).deserialize_ignored_any(visitor)
-    }
-}
diff --git a/vendor/serde_json/src/read.rs b/vendor/serde_json/src/read.rs
deleted file mode 100644
index 7446f28..0000000
--- a/vendor/serde_json/src/read.rs
+++ /dev/null
@@ -1,1004 +0,0 @@
-use crate::error::{Error, ErrorCode, Result};
-use alloc::vec::Vec;
-use core::char;
-use core::cmp;
-use core::ops::Deref;
-use core::str;
-
-#[cfg(feature = "std")]
-use crate::io;
-#[cfg(feature = "std")]
-use crate::iter::LineColIterator;
-
-#[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
-/// stable we can use actual specialization.
-///
-/// This trait is sealed and cannot be implemented for types outside of
-/// `serde_json`.
-pub trait Read<'de>: private::Sealed {
-    #[doc(hidden)]
-    fn next(&mut self) -> Result<Option<u8>>;
-    #[doc(hidden)]
-    fn peek(&mut self) -> Result<Option<u8>>;
-
-    /// Only valid after a call to peek(). Discards the peeked byte.
-    #[doc(hidden)]
-    fn discard(&mut self);
-
-    /// Position of the most recent call to next().
-    ///
-    /// The most recent call was probably next() and not peek(), but this method
-    /// should try to return a sensible result if the most recent call was
-    /// actually peek() because we don't always know.
-    ///
-    /// Only called in case of an error, so performance is not important.
-    #[doc(hidden)]
-    fn position(&self) -> Position;
-
-    /// Position of the most recent call to peek().
-    ///
-    /// The most recent call was probably peek() and not next(), but this method
-    /// should try to return a sensible result if the most recent call was
-    /// actually next() because we don't always know.
-    ///
-    /// Only called in case of an error, so performance is not important.
-    #[doc(hidden)]
-    fn peek_position(&self) -> Position;
-
-    /// Offset from the beginning of the input to the next byte that would be
-    /// returned by next() or peek().
-    #[doc(hidden)]
-    fn byte_offset(&self) -> usize;
-
-    /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
-    /// string until the next quotation mark using the given scratch space if
-    /// necessary. The scratch space is initially empty.
-    #[doc(hidden)]
-    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>>;
-
-    /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
-    /// string until the next quotation mark using the given scratch space if
-    /// necessary. The scratch space is initially empty.
-    ///
-    /// This function returns the raw bytes in the string with escape sequences
-    /// expanded but without performing unicode validation.
-    #[doc(hidden)]
-    fn parse_str_raw<'s>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-    ) -> Result<Reference<'de, 's, [u8]>>;
-
-    /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
-    /// string until the next quotation mark but discards the data.
-    #[doc(hidden)]
-    fn ignore_str(&mut self) -> Result<()>;
-
-    /// Assumes the previous byte was a hex escape sequence ('\u') in a string.
-    /// Parses next hexadecimal sequence.
-    #[doc(hidden)]
-    fn decode_hex_escape(&mut self) -> Result<u16>;
-
-    /// Switch raw buffering mode on.
-    ///
-    /// This is used when deserializing `RawValue`.
-    #[cfg(feature = "raw_value")]
-    #[doc(hidden)]
-    fn begin_raw_buffering(&mut self);
-
-    /// Switch raw buffering mode off and provides the raw buffered data to the
-    /// given visitor.
-    #[cfg(feature = "raw_value")]
-    #[doc(hidden)]
-    fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>;
-
-    /// Whether StreamDeserializer::next needs to check the failed flag. True
-    /// for IoRead, false for StrRead and SliceRead which can track failure by
-    /// truncating their input slice to avoid the extra check on every next
-    /// call.
-    #[doc(hidden)]
-    const should_early_return_if_failed: bool;
-
-    /// Mark a persistent failure of StreamDeserializer, either by setting the
-    /// flag or by truncating the input data.
-    #[doc(hidden)]
-    fn set_failed(&mut self, failed: &mut bool);
-}
-
-pub struct Position {
-    pub line: usize,
-    pub column: usize,
-}
-
-pub enum Reference<'b, 'c, T>
-where
-    T: ?Sized + 'static,
-{
-    Borrowed(&'b T),
-    Copied(&'c T),
-}
-
-impl<'b, 'c, T> Deref for Reference<'b, 'c, T>
-where
-    T: ?Sized + 'static,
-{
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        match *self {
-            Reference::Borrowed(b) => b,
-            Reference::Copied(c) => c,
-        }
-    }
-}
-
-/// JSON input source that reads from a std::io input stream.
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub struct IoRead<R>
-where
-    R: io::Read,
-{
-    iter: LineColIterator<io::Bytes<R>>,
-    /// Temporary storage of peeked byte.
-    ch: Option<u8>,
-    #[cfg(feature = "raw_value")]
-    raw_buffer: Option<Vec<u8>>,
-}
-
-/// JSON input source that reads from a slice of bytes.
-//
-// This is more efficient than other iterators because peek() can be read-only
-// and we can compute line/col position only if an error happens.
-pub struct SliceRead<'a> {
-    slice: &'a [u8],
-    /// Index of the *next* byte that will be returned by next() or peek().
-    index: usize,
-    #[cfg(feature = "raw_value")]
-    raw_buffering_start_index: usize,
-}
-
-/// JSON input source that reads from a UTF-8 string.
-//
-// Able to elide UTF-8 checks by assuming that the input is valid UTF-8.
-pub struct StrRead<'a> {
-    delegate: SliceRead<'a>,
-    #[cfg(feature = "raw_value")]
-    data: &'a str,
-}
-
-// Prevent users from implementing the Read trait.
-mod private {
-    pub trait Sealed {}
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-impl<R> IoRead<R>
-where
-    R: io::Read,
-{
-    /// Create a JSON input source to read from a std::io input stream.
-    pub fn new(reader: R) -> Self {
-        IoRead {
-            iter: LineColIterator::new(reader.bytes()),
-            ch: None,
-            #[cfg(feature = "raw_value")]
-            raw_buffer: None,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<R> private::Sealed for IoRead<R> where R: io::Read {}
-
-#[cfg(feature = "std")]
-impl<R> IoRead<R>
-where
-    R: io::Read,
-{
-    fn parse_str_bytes<'s, T, F>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-        validate: bool,
-        result: F,
-    ) -> Result<T>
-    where
-        T: 's,
-        F: FnOnce(&'s Self, &'s [u8]) -> Result<T>,
-    {
-        loop {
-            let ch = tri!(next_or_eof(self));
-            if !ESCAPE[ch as usize] {
-                scratch.push(ch);
-                continue;
-            }
-            match ch {
-                b'"' => {
-                    return result(self, scratch);
-                }
-                b'\\' => {
-                    tri!(parse_escape(self, validate, scratch));
-                }
-                _ => {
-                    if validate {
-                        return error(self, ErrorCode::ControlCharacterWhileParsingString);
-                    }
-                    scratch.push(ch);
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de, R> Read<'de> for IoRead<R>
-where
-    R: io::Read,
-{
-    #[inline]
-    fn next(&mut self) -> Result<Option<u8>> {
-        match self.ch.take() {
-            Some(ch) => {
-                #[cfg(feature = "raw_value")]
-                {
-                    if let Some(buf) = &mut self.raw_buffer {
-                        buf.push(ch);
-                    }
-                }
-                Ok(Some(ch))
-            }
-            None => match self.iter.next() {
-                Some(Err(err)) => Err(Error::io(err)),
-                Some(Ok(ch)) => {
-                    #[cfg(feature = "raw_value")]
-                    {
-                        if let Some(buf) = &mut self.raw_buffer {
-                            buf.push(ch);
-                        }
-                    }
-                    Ok(Some(ch))
-                }
-                None => Ok(None),
-            },
-        }
-    }
-
-    #[inline]
-    fn peek(&mut self) -> Result<Option<u8>> {
-        match self.ch {
-            Some(ch) => Ok(Some(ch)),
-            None => match self.iter.next() {
-                Some(Err(err)) => Err(Error::io(err)),
-                Some(Ok(ch)) => {
-                    self.ch = Some(ch);
-                    Ok(self.ch)
-                }
-                None => Ok(None),
-            },
-        }
-    }
-
-    #[cfg(not(feature = "raw_value"))]
-    #[inline]
-    fn discard(&mut self) {
-        self.ch = None;
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn discard(&mut self) {
-        if let Some(ch) = self.ch.take() {
-            if let Some(buf) = &mut self.raw_buffer {
-                buf.push(ch);
-            }
-        }
-    }
-
-    fn position(&self) -> Position {
-        Position {
-            line: self.iter.line(),
-            column: self.iter.col(),
-        }
-    }
-
-    fn peek_position(&self) -> Position {
-        // The LineColIterator updates its position during peek() so it has the
-        // right one here.
-        self.position()
-    }
-
-    fn byte_offset(&self) -> usize {
-        match self.ch {
-            Some(_) => self.iter.byte_offset() - 1,
-            None => self.iter.byte_offset(),
-        }
-    }
-
-    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> {
-        self.parse_str_bytes(scratch, true, as_str)
-            .map(Reference::Copied)
-    }
-
-    fn parse_str_raw<'s>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-    ) -> Result<Reference<'de, 's, [u8]>> {
-        self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
-            .map(Reference::Copied)
-    }
-
-    fn ignore_str(&mut self) -> Result<()> {
-        loop {
-            let ch = tri!(next_or_eof(self));
-            if !ESCAPE[ch as usize] {
-                continue;
-            }
-            match ch {
-                b'"' => {
-                    return Ok(());
-                }
-                b'\\' => {
-                    tri!(ignore_escape(self));
-                }
-                _ => {
-                    return error(self, ErrorCode::ControlCharacterWhileParsingString);
-                }
-            }
-        }
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16> {
-        let mut n = 0;
-        for _ in 0..4 {
-            match decode_hex_val(tri!(next_or_eof(self))) {
-                None => return error(self, ErrorCode::InvalidEscape),
-                Some(val) => {
-                    n = (n << 4) + val;
-                }
-            }
-        }
-        Ok(n)
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn begin_raw_buffering(&mut self) {
-        self.raw_buffer = Some(Vec::new());
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        let raw = self.raw_buffer.take().unwrap();
-        let raw = match String::from_utf8(raw) {
-            Ok(raw) => raw,
-            Err(_) => return error(self, ErrorCode::InvalidUnicodeCodePoint),
-        };
-        visitor.visit_map(OwnedRawDeserializer {
-            raw_value: Some(raw),
-        })
-    }
-
-    const should_early_return_if_failed: bool = true;
-
-    #[inline]
-    #[cold]
-    fn set_failed(&mut self, failed: &mut bool) {
-        *failed = true;
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> SliceRead<'a> {
-    /// Create a JSON input source to read from a slice of bytes.
-    pub fn new(slice: &'a [u8]) -> Self {
-        SliceRead {
-            slice,
-            index: 0,
-            #[cfg(feature = "raw_value")]
-            raw_buffering_start_index: 0,
-        }
-    }
-
-    fn position_of_index(&self, i: usize) -> Position {
-        let mut position = Position { line: 1, column: 0 };
-        for ch in &self.slice[..i] {
-            match *ch {
-                b'\n' => {
-                    position.line += 1;
-                    position.column = 0;
-                }
-                _ => {
-                    position.column += 1;
-                }
-            }
-        }
-        position
-    }
-
-    /// The big optimization here over IoRead is that if the string contains no
-    /// backslash escape sequences, the returned &str is a slice of the raw JSON
-    /// data so we avoid copying into the scratch space.
-    fn parse_str_bytes<'s, T, F>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-        validate: bool,
-        result: F,
-    ) -> Result<Reference<'a, 's, T>>
-    where
-        T: ?Sized + 's,
-        F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>,
-    {
-        // Index of the first byte not yet copied into the scratch space.
-        let mut start = self.index;
-
-        loop {
-            while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
-                self.index += 1;
-            }
-            if self.index == self.slice.len() {
-                return error(self, ErrorCode::EofWhileParsingString);
-            }
-            match self.slice[self.index] {
-                b'"' => {
-                    if scratch.is_empty() {
-                        // Fast path: return a slice of the raw JSON without any
-                        // copying.
-                        let borrowed = &self.slice[start..self.index];
-                        self.index += 1;
-                        return result(self, borrowed).map(Reference::Borrowed);
-                    } else {
-                        scratch.extend_from_slice(&self.slice[start..self.index]);
-                        self.index += 1;
-                        return result(self, scratch).map(Reference::Copied);
-                    }
-                }
-                b'\\' => {
-                    scratch.extend_from_slice(&self.slice[start..self.index]);
-                    self.index += 1;
-                    tri!(parse_escape(self, validate, scratch));
-                    start = self.index;
-                }
-                _ => {
-                    self.index += 1;
-                    if validate {
-                        return error(self, ErrorCode::ControlCharacterWhileParsingString);
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl<'a> private::Sealed for SliceRead<'a> {}
-
-impl<'a> Read<'a> for SliceRead<'a> {
-    #[inline]
-    fn next(&mut self) -> Result<Option<u8>> {
-        // `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))`
-        // is about 10% slower.
-        Ok(if self.index < self.slice.len() {
-            let ch = self.slice[self.index];
-            self.index += 1;
-            Some(ch)
-        } else {
-            None
-        })
-    }
-
-    #[inline]
-    fn peek(&mut self) -> Result<Option<u8>> {
-        // `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower
-        // for some reason.
-        Ok(if self.index < self.slice.len() {
-            Some(self.slice[self.index])
-        } else {
-            None
-        })
-    }
-
-    #[inline]
-    fn discard(&mut self) {
-        self.index += 1;
-    }
-
-    fn position(&self) -> Position {
-        self.position_of_index(self.index)
-    }
-
-    fn peek_position(&self) -> Position {
-        // Cap it at slice.len() just in case the most recent call was next()
-        // and it returned the last byte.
-        self.position_of_index(cmp::min(self.slice.len(), self.index + 1))
-    }
-
-    fn byte_offset(&self) -> usize {
-        self.index
-    }
-
-    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
-        self.parse_str_bytes(scratch, true, as_str)
-    }
-
-    fn parse_str_raw<'s>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-    ) -> Result<Reference<'a, 's, [u8]>> {
-        self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
-    }
-
-    fn ignore_str(&mut self) -> Result<()> {
-        loop {
-            while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
-                self.index += 1;
-            }
-            if self.index == self.slice.len() {
-                return error(self, ErrorCode::EofWhileParsingString);
-            }
-            match self.slice[self.index] {
-                b'"' => {
-                    self.index += 1;
-                    return Ok(());
-                }
-                b'\\' => {
-                    self.index += 1;
-                    tri!(ignore_escape(self));
-                }
-                _ => {
-                    return error(self, ErrorCode::ControlCharacterWhileParsingString);
-                }
-            }
-        }
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16> {
-        if self.index + 4 > self.slice.len() {
-            self.index = self.slice.len();
-            return error(self, ErrorCode::EofWhileParsingString);
-        }
-
-        let mut n = 0;
-        for _ in 0..4 {
-            let ch = decode_hex_val(self.slice[self.index]);
-            self.index += 1;
-            match ch {
-                None => return error(self, ErrorCode::InvalidEscape),
-                Some(val) => {
-                    n = (n << 4) + val;
-                }
-            }
-        }
-        Ok(n)
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn begin_raw_buffering(&mut self) {
-        self.raw_buffering_start_index = self.index;
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'a>,
-    {
-        let raw = &self.slice[self.raw_buffering_start_index..self.index];
-        let raw = match str::from_utf8(raw) {
-            Ok(raw) => raw,
-            Err(_) => return error(self, ErrorCode::InvalidUnicodeCodePoint),
-        };
-        visitor.visit_map(BorrowedRawDeserializer {
-            raw_value: Some(raw),
-        })
-    }
-
-    const should_early_return_if_failed: bool = false;
-
-    #[inline]
-    #[cold]
-    fn set_failed(&mut self, _failed: &mut bool) {
-        self.slice = &self.slice[..self.index];
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a> StrRead<'a> {
-    /// Create a JSON input source to read from a UTF-8 string.
-    pub fn new(s: &'a str) -> Self {
-        StrRead {
-            delegate: SliceRead::new(s.as_bytes()),
-            #[cfg(feature = "raw_value")]
-            data: s,
-        }
-    }
-}
-
-impl<'a> private::Sealed for StrRead<'a> {}
-
-impl<'a> Read<'a> for StrRead<'a> {
-    #[inline]
-    fn next(&mut self) -> Result<Option<u8>> {
-        self.delegate.next()
-    }
-
-    #[inline]
-    fn peek(&mut self) -> Result<Option<u8>> {
-        self.delegate.peek()
-    }
-
-    #[inline]
-    fn discard(&mut self) {
-        self.delegate.discard();
-    }
-
-    fn position(&self) -> Position {
-        self.delegate.position()
-    }
-
-    fn peek_position(&self) -> Position {
-        self.delegate.peek_position()
-    }
-
-    fn byte_offset(&self) -> usize {
-        self.delegate.byte_offset()
-    }
-
-    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
-        self.delegate.parse_str_bytes(scratch, true, |_, bytes| {
-            // The deserialization input came in as &str with a UTF-8 guarantee,
-            // and the \u-escapes are checked along the way, so don't need to
-            // check here.
-            Ok(unsafe { str::from_utf8_unchecked(bytes) })
-        })
-    }
-
-    fn parse_str_raw<'s>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-    ) -> Result<Reference<'a, 's, [u8]>> {
-        self.delegate.parse_str_raw(scratch)
-    }
-
-    fn ignore_str(&mut self) -> Result<()> {
-        self.delegate.ignore_str()
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16> {
-        self.delegate.decode_hex_escape()
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn begin_raw_buffering(&mut self) {
-        self.delegate.begin_raw_buffering();
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'a>,
-    {
-        let raw = &self.data[self.delegate.raw_buffering_start_index..self.delegate.index];
-        visitor.visit_map(BorrowedRawDeserializer {
-            raw_value: Some(raw),
-        })
-    }
-
-    const should_early_return_if_failed: bool = false;
-
-    #[inline]
-    #[cold]
-    fn set_failed(&mut self, failed: &mut bool) {
-        self.delegate.set_failed(failed);
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'a, 'de, R> private::Sealed for &'a mut R where R: Read<'de> {}
-
-impl<'a, 'de, R> Read<'de> for &'a mut R
-where
-    R: Read<'de>,
-{
-    fn next(&mut self) -> Result<Option<u8>> {
-        R::next(self)
-    }
-
-    fn peek(&mut self) -> Result<Option<u8>> {
-        R::peek(self)
-    }
-
-    fn discard(&mut self) {
-        R::discard(self);
-    }
-
-    fn position(&self) -> Position {
-        R::position(self)
-    }
-
-    fn peek_position(&self) -> Position {
-        R::peek_position(self)
-    }
-
-    fn byte_offset(&self) -> usize {
-        R::byte_offset(self)
-    }
-
-    fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> {
-        R::parse_str(self, scratch)
-    }
-
-    fn parse_str_raw<'s>(
-        &'s mut self,
-        scratch: &'s mut Vec<u8>,
-    ) -> Result<Reference<'de, 's, [u8]>> {
-        R::parse_str_raw(self, scratch)
-    }
-
-    fn ignore_str(&mut self) -> Result<()> {
-        R::ignore_str(self)
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16> {
-        R::decode_hex_escape(self)
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn begin_raw_buffering(&mut self) {
-        R::begin_raw_buffering(self);
-    }
-
-    #[cfg(feature = "raw_value")]
-    fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        R::end_raw_buffering(self, visitor)
-    }
-
-    const should_early_return_if_failed: bool = R::should_early_return_if_failed;
-
-    fn set_failed(&mut self, failed: &mut bool) {
-        R::set_failed(self, failed);
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/// Marker for whether StreamDeserializer can implement FusedIterator.
-pub trait Fused: private::Sealed {}
-impl<'a> Fused for SliceRead<'a> {}
-impl<'a> Fused for StrRead<'a> {}
-
-// Lookup table of bytes that must be escaped. A value of true at index i means
-// that byte i requires an escape sequence in the input.
-static ESCAPE: [bool; 256] = {
-    const CT: bool = true; // control character \x00..=\x1F
-    const QU: bool = true; // quote \x22
-    const BS: bool = true; // backslash \x5C
-    const __: bool = false; // allow unescaped
-    [
-        //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
-        CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 0
-        CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 1
-        __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4
-        __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
-    ]
-};
-
-fn next_or_eof<'de, R>(read: &mut R) -> Result<u8>
-where
-    R: ?Sized + Read<'de>,
-{
-    match tri!(read.next()) {
-        Some(b) => Ok(b),
-        None => error(read, ErrorCode::EofWhileParsingString),
-    }
-}
-
-fn peek_or_eof<'de, R>(read: &mut R) -> Result<u8>
-where
-    R: ?Sized + Read<'de>,
-{
-    match tri!(read.peek()) {
-        Some(b) => Ok(b),
-        None => error(read, ErrorCode::EofWhileParsingString),
-    }
-}
-
-fn error<'de, R, T>(read: &R, reason: ErrorCode) -> Result<T>
-where
-    R: ?Sized + Read<'de>,
-{
-    let position = read.position();
-    Err(Error::syntax(reason, position.line, position.column))
-}
-
-fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> {
-    str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint))
-}
-
-/// Parses a JSON escape sequence and appends it into the scratch space. Assumes
-/// the previous byte read was a backslash.
-fn parse_escape<'de, R: Read<'de>>(
-    read: &mut R,
-    validate: bool,
-    scratch: &mut Vec<u8>,
-) -> Result<()> {
-    let ch = tri!(next_or_eof(read));
-
-    match ch {
-        b'"' => scratch.push(b'"'),
-        b'\\' => scratch.push(b'\\'),
-        b'/' => scratch.push(b'/'),
-        b'b' => scratch.push(b'\x08'),
-        b'f' => scratch.push(b'\x0c'),
-        b'n' => scratch.push(b'\n'),
-        b'r' => scratch.push(b'\r'),
-        b't' => scratch.push(b'\t'),
-        b'u' => {
-            fn encode_surrogate(scratch: &mut Vec<u8>, n: u16) {
-                scratch.extend_from_slice(&[
-                    (n >> 12 & 0b0000_1111) as u8 | 0b1110_0000,
-                    (n >> 6 & 0b0011_1111) as u8 | 0b1000_0000,
-                    (n & 0b0011_1111) as u8 | 0b1000_0000,
-                ]);
-            }
-
-            let c = match tri!(read.decode_hex_escape()) {
-                n @ 0xDC00..=0xDFFF => {
-                    return if validate {
-                        error(read, ErrorCode::LoneLeadingSurrogateInHexEscape)
-                    } else {
-                        encode_surrogate(scratch, n);
-                        Ok(())
-                    };
-                }
-
-                // Non-BMP characters are encoded as a sequence of two hex
-                // escapes, representing UTF-16 surrogates. If deserializing a
-                // utf-8 string the surrogates are required to be paired,
-                // whereas deserializing a byte string accepts lone surrogates.
-                n1 @ 0xD800..=0xDBFF => {
-                    if tri!(peek_or_eof(read)) == b'\\' {
-                        read.discard();
-                    } else {
-                        return if validate {
-                            read.discard();
-                            error(read, ErrorCode::UnexpectedEndOfHexEscape)
-                        } else {
-                            encode_surrogate(scratch, n1);
-                            Ok(())
-                        };
-                    }
-
-                    if tri!(peek_or_eof(read)) == b'u' {
-                        read.discard();
-                    } else {
-                        return if validate {
-                            read.discard();
-                            error(read, ErrorCode::UnexpectedEndOfHexEscape)
-                        } else {
-                            encode_surrogate(scratch, n1);
-                            // The \ prior to this byte started an escape sequence,
-                            // so we need to parse that now. This recursive call
-                            // does not blow the stack on malicious input because
-                            // the escape is not \u, so it will be handled by one
-                            // of the easy nonrecursive cases.
-                            parse_escape(read, validate, scratch)
-                        };
-                    }
-
-                    let n2 = tri!(read.decode_hex_escape());
-
-                    if n2 < 0xDC00 || n2 > 0xDFFF {
-                        return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
-                    }
-
-                    let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000;
-
-                    match char::from_u32(n) {
-                        Some(c) => c,
-                        None => {
-                            return error(read, ErrorCode::InvalidUnicodeCodePoint);
-                        }
-                    }
-                }
-
-                // Every u16 outside of the surrogate ranges above is guaranteed
-                // to be a legal char.
-                n => char::from_u32(n as u32).unwrap(),
-            };
-
-            scratch.extend_from_slice(c.encode_utf8(&mut [0_u8; 4]).as_bytes());
-        }
-        _ => {
-            return error(read, ErrorCode::InvalidEscape);
-        }
-    }
-
-    Ok(())
-}
-
-/// Parses a JSON escape sequence and discards the value. Assumes the previous
-/// byte read was a backslash.
-fn ignore_escape<'de, R>(read: &mut R) -> Result<()>
-where
-    R: ?Sized + Read<'de>,
-{
-    let ch = tri!(next_or_eof(read));
-
-    match ch {
-        b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {}
-        b'u' => {
-            // At this point we don't care if the codepoint is valid. We just
-            // want to consume it. We don't actually know what is valid or not
-            // at this point, because that depends on if this string will
-            // ultimately be parsed into a string or a byte buffer in the "real"
-            // parse.
-
-            tri!(read.decode_hex_escape());
-        }
-        _ => {
-            return error(read, ErrorCode::InvalidEscape);
-        }
-    }
-
-    Ok(())
-}
-
-static HEX: [u8; 256] = {
-    const __: u8 = 255; // not a hex digit
-    [
-        //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 0
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 1
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
-        00, 01, 02, 03, 04, 05, 06, 07, 08, 09, __, __, __, __, __, __, // 3
-        __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 4
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 5
-        __, 10, 11, 12, 13, 14, 15, __, __, __, __, __, __, __, __, __, // 6
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
-        __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
-    ]
-};
-
-fn decode_hex_val(val: u8) -> Option<u16> {
-    let n = HEX[val as usize] as u16;
-    if n == 255 {
-        None
-    } else {
-        Some(n)
-    }
-}
diff --git a/vendor/serde_json/src/ser.rs b/vendor/serde_json/src/ser.rs
deleted file mode 100644
index 3742e0b..0000000
--- a/vendor/serde_json/src/ser.rs
+++ /dev/null
@@ -1,2247 +0,0 @@
-//! Serialize a Rust data structure into JSON data.
-
-use crate::error::{Error, ErrorCode, Result};
-use crate::io;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::fmt::{self, Display};
-use core::num::FpCategory;
-use serde::ser::{self, Impossible, Serialize};
-
-/// A structure for serializing Rust values into JSON.
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub struct Serializer<W, F = CompactFormatter> {
-    writer: W,
-    formatter: F,
-}
-
-impl<W> Serializer<W>
-where
-    W: io::Write,
-{
-    /// Creates a new JSON serializer.
-    #[inline]
-    pub fn new(writer: W) -> Self {
-        Serializer::with_formatter(writer, CompactFormatter)
-    }
-}
-
-impl<'a, W> Serializer<W, PrettyFormatter<'a>>
-where
-    W: io::Write,
-{
-    /// Creates a new JSON pretty print serializer.
-    #[inline]
-    pub fn pretty(writer: W) -> Self {
-        Serializer::with_formatter(writer, PrettyFormatter::new())
-    }
-}
-
-impl<W, F> Serializer<W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    /// Creates a new JSON visitor whose output will be written to the writer
-    /// specified.
-    #[inline]
-    pub fn with_formatter(writer: W, formatter: F) -> Self {
-        Serializer { writer, formatter }
-    }
-
-    /// Unwrap the `Writer` from the `Serializer`.
-    #[inline]
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    type SerializeSeq = Compound<'a, W, F>;
-    type SerializeTuple = Compound<'a, W, F>;
-    type SerializeTupleStruct = Compound<'a, W, F>;
-    type SerializeTupleVariant = Compound<'a, W, F>;
-    type SerializeMap = Compound<'a, W, F>;
-    type SerializeStruct = Compound<'a, W, F>;
-    type SerializeStructVariant = Compound<'a, W, F>;
-
-    #[inline]
-    fn serialize_bool(self, value: bool) -> Result<()> {
-        self.formatter
-            .write_bool(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_i8(self, value: i8) -> Result<()> {
-        self.formatter
-            .write_i8(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_i16(self, value: i16) -> Result<()> {
-        self.formatter
-            .write_i16(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_i32(self, value: i32) -> Result<()> {
-        self.formatter
-            .write_i32(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_i64(self, value: i64) -> Result<()> {
-        self.formatter
-            .write_i64(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i128(self, value: i128) -> Result<()> {
-        self.formatter
-            .write_i128(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_u8(self, value: u8) -> Result<()> {
-        self.formatter
-            .write_u8(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_u16(self, value: u16) -> Result<()> {
-        self.formatter
-            .write_u16(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_u32(self, value: u32) -> Result<()> {
-        self.formatter
-            .write_u32(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_u64(self, value: u64) -> Result<()> {
-        self.formatter
-            .write_u64(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u128(self, value: u128) -> Result<()> {
-        self.formatter
-            .write_u128(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_f32(self, value: f32) -> Result<()> {
-        match value.classify() {
-            FpCategory::Nan | FpCategory::Infinite => self
-                .formatter
-                .write_null(&mut self.writer)
-                .map_err(Error::io),
-            _ => self
-                .formatter
-                .write_f32(&mut self.writer, value)
-                .map_err(Error::io),
-        }
-    }
-
-    #[inline]
-    fn serialize_f64(self, value: f64) -> Result<()> {
-        match value.classify() {
-            FpCategory::Nan | FpCategory::Infinite => self
-                .formatter
-                .write_null(&mut self.writer)
-                .map_err(Error::io),
-            _ => self
-                .formatter
-                .write_f64(&mut self.writer, value)
-                .map_err(Error::io),
-        }
-    }
-
-    #[inline]
-    fn serialize_char(self, value: char) -> Result<()> {
-        // A char encoded as UTF-8 takes 4 bytes at most.
-        let mut buf = [0; 4];
-        self.serialize_str(value.encode_utf8(&mut buf))
-    }
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<()> {
-        format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
-        self.formatter
-            .write_byte_array(&mut self.writer, value)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_unit(self) -> Result<()> {
-        self.formatter
-            .write_null(&mut self.writer)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<()> {
-        self.serialize_str(variant)
-    }
-
-    /// Serialize newtypes without an object wrapper.
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        tri!(self
-            .formatter
-            .begin_object(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_key(&mut self.writer, true)
-            .map_err(Error::io));
-        tri!(self.serialize_str(variant));
-        tri!(self
-            .formatter
-            .end_object_key(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_value(&mut self.writer)
-            .map_err(Error::io));
-        tri!(value.serialize(&mut *self));
-        tri!(self
-            .formatter
-            .end_object_value(&mut self.writer)
-            .map_err(Error::io));
-        self.formatter
-            .end_object(&mut self.writer)
-            .map_err(Error::io)
-    }
-
-    #[inline]
-    fn serialize_none(self) -> Result<()> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        tri!(self
-            .formatter
-            .begin_array(&mut self.writer)
-            .map_err(Error::io));
-        if len == Some(0) {
-            tri!(self
-                .formatter
-                .end_array(&mut self.writer)
-                .map_err(Error::io));
-            Ok(Compound::Map {
-                ser: self,
-                state: State::Empty,
-            })
-        } else {
-            Ok(Compound::Map {
-                ser: self,
-                state: State::First,
-            })
-        }
-    }
-
-    #[inline]
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
-        self.serialize_seq(Some(len))
-    }
-
-    #[inline]
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        self.serialize_seq(Some(len))
-    }
-
-    #[inline]
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        tri!(self
-            .formatter
-            .begin_object(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_key(&mut self.writer, true)
-            .map_err(Error::io));
-        tri!(self.serialize_str(variant));
-        tri!(self
-            .formatter
-            .end_object_key(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_value(&mut self.writer)
-            .map_err(Error::io));
-        self.serialize_seq(Some(len))
-    }
-
-    #[inline]
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-        tri!(self
-            .formatter
-            .begin_object(&mut self.writer)
-            .map_err(Error::io));
-        if len == Some(0) {
-            tri!(self
-                .formatter
-                .end_object(&mut self.writer)
-                .map_err(Error::io));
-            Ok(Compound::Map {
-                ser: self,
-                state: State::Empty,
-            })
-        } else {
-            Ok(Compound::Map {
-                ser: self,
-                state: State::First,
-            })
-        }
-    }
-
-    #[inline]
-    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        match name {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(Compound::Number { ser: self }),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(Compound::RawValue { ser: self }),
-            _ => self.serialize_map(Some(len)),
-        }
-    }
-
-    #[inline]
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        tri!(self
-            .formatter
-            .begin_object(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_key(&mut self.writer, true)
-            .map_err(Error::io));
-        tri!(self.serialize_str(variant));
-        tri!(self
-            .formatter
-            .end_object_key(&mut self.writer)
-            .map_err(Error::io));
-        tri!(self
-            .formatter
-            .begin_object_value(&mut self.writer)
-            .map_err(Error::io));
-        self.serialize_map(Some(len))
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Display,
-    {
-        use self::fmt::Write;
-
-        struct Adapter<'ser, W: 'ser, F: 'ser> {
-            writer: &'ser mut W,
-            formatter: &'ser mut F,
-            error: Option<io::Error>,
-        }
-
-        impl<'ser, W, F> Write for Adapter<'ser, W, F>
-        where
-            W: io::Write,
-            F: Formatter,
-        {
-            fn write_str(&mut self, s: &str) -> fmt::Result {
-                debug_assert!(self.error.is_none());
-                match format_escaped_str_contents(self.writer, self.formatter, s) {
-                    Ok(()) => Ok(()),
-                    Err(err) => {
-                        self.error = Some(err);
-                        Err(fmt::Error)
-                    }
-                }
-            }
-        }
-
-        tri!(self
-            .formatter
-            .begin_string(&mut self.writer)
-            .map_err(Error::io));
-        let mut adapter = Adapter {
-            writer: &mut self.writer,
-            formatter: &mut self.formatter,
-            error: None,
-        };
-        match write!(adapter, "{}", value) {
-            Ok(()) => debug_assert!(adapter.error.is_none()),
-            Err(fmt::Error) => {
-                return Err(Error::io(adapter.error.expect("there should be an error")));
-            }
-        }
-        self.formatter
-            .end_string(&mut self.writer)
-            .map_err(Error::io)
-    }
-}
-
-// Not public API. Should be pub(crate).
-#[doc(hidden)]
-#[derive(Eq, PartialEq)]
-pub enum State {
-    Empty,
-    First,
-    Rest,
-}
-
-// Not public API. Should be pub(crate).
-#[doc(hidden)]
-pub enum Compound<'a, W: 'a, F: 'a> {
-    Map {
-        ser: &'a mut Serializer<W, F>,
-        state: State,
-    },
-    #[cfg(feature = "arbitrary_precision")]
-    Number { ser: &'a mut Serializer<W, F> },
-    #[cfg(feature = "raw_value")]
-    RawValue { ser: &'a mut Serializer<W, F> },
-}
-
-impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            Compound::Map { ser, state } => {
-                tri!(ser
-                    .formatter
-                    .begin_array_value(&mut ser.writer, *state == State::First)
-                    .map_err(Error::io));
-                *state = State::Rest;
-                tri!(value.serialize(&mut **ser));
-                ser.formatter
-                    .end_array_value(&mut ser.writer)
-                    .map_err(Error::io)
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        match self {
-            Compound::Map { ser, state } => match state {
-                State::Empty => Ok(()),
-                _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
-            },
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        ser::SerializeSeq::end(self)
-    }
-}
-
-impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        match self {
-            Compound::Map { ser, state } => {
-                match state {
-                    State::Empty => {}
-                    _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
-                }
-                tri!(ser
-                    .formatter
-                    .end_object_value(&mut ser.writer)
-                    .map_err(Error::io));
-                ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            Compound::Map { ser, state } => {
-                tri!(ser
-                    .formatter
-                    .begin_object_key(&mut ser.writer, *state == State::First)
-                    .map_err(Error::io));
-                *state = State::Rest;
-
-                tri!(key.serialize(MapKeySerializer { ser: *ser }));
-
-                ser.formatter
-                    .end_object_key(&mut ser.writer)
-                    .map_err(Error::io)
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    #[inline]
-    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            Compound::Map { ser, .. } => {
-                tri!(ser
-                    .formatter
-                    .begin_object_value(&mut ser.writer)
-                    .map_err(Error::io));
-                tri!(value.serialize(&mut **ser));
-                ser.formatter
-                    .end_object_value(&mut ser.writer)
-                    .map_err(Error::io)
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        match self {
-            Compound::Map { ser, state } => match state {
-                State::Empty => Ok(()),
-                _ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io),
-            },
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            Compound::Map { .. } => ser::SerializeMap::serialize_entry(self, key, value),
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { ser, .. } => {
-                if key == crate::number::TOKEN {
-                    value.serialize(NumberStrEmitter(ser))
-                } else {
-                    Err(invalid_number())
-                }
-            }
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { ser, .. } => {
-                if key == crate::raw::TOKEN {
-                    value.serialize(RawValueStrEmitter(ser))
-                } else {
-                    Err(invalid_raw_value())
-                }
-            }
-        }
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        match self {
-            Compound::Map { .. } => ser::SerializeMap::end(self),
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => Ok(()),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => Ok(()),
-        }
-    }
-}
-
-impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match *self {
-            Compound::Map { .. } => ser::SerializeStruct::serialize_field(self, key, value),
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    #[inline]
-    fn end(self) -> Result<()> {
-        match self {
-            Compound::Map { ser, state } => {
-                match state {
-                    State::Empty => {}
-                    _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
-                }
-                tri!(ser
-                    .formatter
-                    .end_object_value(&mut ser.writer)
-                    .map_err(Error::io));
-                ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            Compound::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            Compound::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-struct MapKeySerializer<'a, W: 'a, F: 'a> {
-    ser: &'a mut Serializer<W, F>,
-}
-
-#[cfg(feature = "arbitrary_precision")]
-fn invalid_number() -> Error {
-    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
-}
-
-#[cfg(feature = "raw_value")]
-fn invalid_raw_value() -> Error {
-    Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0)
-}
-
-fn key_must_be_a_string() -> Error {
-    Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
-}
-
-fn float_key_must_be_finite() -> Error {
-    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
-}
-
-impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F>
-where
-    W: io::Write,
-    F: Formatter,
-{
-    type Ok = ();
-    type Error = Error;
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<()> {
-        self.ser.serialize_str(value)
-    }
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<()> {
-        self.ser.serialize_str(variant)
-    }
-
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    type SerializeSeq = Impossible<(), Error>;
-    type SerializeTuple = Impossible<(), Error>;
-    type SerializeTupleStruct = Impossible<(), Error>;
-    type SerializeTupleVariant = Impossible<(), Error>;
-    type SerializeMap = Impossible<(), Error>;
-    type SerializeStruct = Impossible<(), Error>;
-    type SerializeStructVariant = Impossible<(), Error>;
-
-    fn serialize_bool(self, value: bool) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_bool(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_i8(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_i16(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_i32(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_i64(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_i128(self, value: i128) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_i128(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_u8(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_u16(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_u32(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_u64(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_u128(self, value: u128) -> Result<()> {
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_u128(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<()> {
-        if !value.is_finite() {
-            return Err(float_key_must_be_finite());
-        }
-
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_f32(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<()> {
-        if !value.is_finite() {
-            return Err(float_key_must_be_finite());
-        }
-
-        tri!(self
-            .ser
-            .formatter
-            .begin_string(&mut self.ser.writer)
-            .map_err(Error::io));
-        tri!(self
-            .ser
-            .formatter
-            .write_f64(&mut self.ser.writer, value)
-            .map_err(Error::io));
-        self.ser
-            .formatter
-            .end_string(&mut self.ser.writer)
-            .map_err(Error::io)
-    }
-
-    fn serialize_char(self, value: char) -> Result<()> {
-        self.ser.serialize_str(&value.to_string())
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit(self) -> Result<()> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_none(self) -> Result<()> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_some<T>(self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Display,
-    {
-        self.ser.collect_str(value)
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer<W, F>);
-
-#[cfg(feature = "arbitrary_precision")]
-impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, F> {
-    type Ok = ();
-    type Error = Error;
-
-    type SerializeSeq = Impossible<(), Error>;
-    type SerializeTuple = Impossible<(), Error>;
-    type SerializeTupleStruct = Impossible<(), Error>;
-    type SerializeTupleVariant = Impossible<(), Error>;
-    type SerializeMap = Impossible<(), Error>;
-    type SerializeStruct = Impossible<(), Error>;
-    type SerializeStructVariant = Impossible<(), Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i128(self, _v: i128) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u128(self, _v: u128) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_char(self, _v: char) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<()> {
-        let NumberStrEmitter(serializer) = self;
-        serializer
-            .formatter
-            .write_number_str(&mut serializer.writer, value)
-            .map_err(Error::io)
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_none(self) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit(self) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<()> {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(invalid_number())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(invalid_number())
-    }
-}
-
-#[cfg(feature = "raw_value")]
-struct RawValueStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer<W, F>);
-
-#[cfg(feature = "raw_value")]
-impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, W, F> {
-    type Ok = ();
-    type Error = Error;
-
-    type SerializeSeq = Impossible<(), Error>;
-    type SerializeTuple = Impossible<(), Error>;
-    type SerializeTupleStruct = Impossible<(), Error>;
-    type SerializeTupleVariant = Impossible<(), Error>;
-    type SerializeMap = Impossible<(), Error>;
-    type SerializeStruct = Impossible<(), Error>;
-    type SerializeStructVariant = Impossible<(), Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_i128(self, _v: i128) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_u128(self, _v: u128) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_char(self, _v: char) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_str(self, value: &str) -> Result<()> {
-        let RawValueStrEmitter(serializer) = self;
-        serializer
-            .formatter
-            .write_raw_fragment(&mut serializer.writer, value)
-            .map_err(Error::io)
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_none(self) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_unit(self) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<()> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(ser::Error::custom("expected RawValue"))
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
-    where
-        T: ?Sized + Display,
-    {
-        self.serialize_str(&value.to_string())
-    }
-}
-
-/// Represents a character escape code in a type-safe manner.
-pub enum CharEscape {
-    /// An escaped quote `"`
-    Quote,
-    /// An escaped reverse solidus `\`
-    ReverseSolidus,
-    /// An escaped solidus `/`
-    Solidus,
-    /// An escaped backspace character (usually escaped as `\b`)
-    Backspace,
-    /// An escaped form feed character (usually escaped as `\f`)
-    FormFeed,
-    /// An escaped line feed character (usually escaped as `\n`)
-    LineFeed,
-    /// An escaped carriage return character (usually escaped as `\r`)
-    CarriageReturn,
-    /// An escaped tab character (usually escaped as `\t`)
-    Tab,
-    /// An escaped ASCII plane control character (usually escaped as
-    /// `\u00XX` where `XX` are two hex characters)
-    AsciiControl(u8),
-}
-
-impl CharEscape {
-    #[inline]
-    fn from_escape_table(escape: u8, byte: u8) -> CharEscape {
-        match escape {
-            self::BB => CharEscape::Backspace,
-            self::TT => CharEscape::Tab,
-            self::NN => CharEscape::LineFeed,
-            self::FF => CharEscape::FormFeed,
-            self::RR => CharEscape::CarriageReturn,
-            self::QU => CharEscape::Quote,
-            self::BS => CharEscape::ReverseSolidus,
-            self::UU => CharEscape::AsciiControl(byte),
-            _ => unreachable!(),
-        }
-    }
-}
-
-/// This trait abstracts away serializing the JSON control characters, which allows the user to
-/// optionally pretty print the JSON output.
-pub trait Formatter {
-    /// Writes a `null` value to the specified writer.
-    #[inline]
-    fn write_null<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"null")
-    }
-
-    /// Writes a `true` or `false` value to the specified writer.
-    #[inline]
-    fn write_bool<W>(&mut self, writer: &mut W, value: bool) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let s = if value {
-            b"true" as &[u8]
-        } else {
-            b"false" as &[u8]
-        };
-        writer.write_all(s)
-    }
-
-    /// Writes an integer value like `-123` to the specified writer.
-    #[inline]
-    fn write_i8<W>(&mut self, writer: &mut W, value: i8) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `-123` to the specified writer.
-    #[inline]
-    fn write_i16<W>(&mut self, writer: &mut W, value: i16) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `-123` to the specified writer.
-    #[inline]
-    fn write_i32<W>(&mut self, writer: &mut W, value: i32) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `-123` to the specified writer.
-    #[inline]
-    fn write_i64<W>(&mut self, writer: &mut W, value: i64) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `-123` to the specified writer.
-    #[inline]
-    fn write_i128<W>(&mut self, writer: &mut W, value: i128) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `123` to the specified writer.
-    #[inline]
-    fn write_u8<W>(&mut self, writer: &mut W, value: u8) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `123` to the specified writer.
-    #[inline]
-    fn write_u16<W>(&mut self, writer: &mut W, value: u16) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `123` to the specified writer.
-    #[inline]
-    fn write_u32<W>(&mut self, writer: &mut W, value: u32) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `123` to the specified writer.
-    #[inline]
-    fn write_u64<W>(&mut self, writer: &mut W, value: u64) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes an integer value like `123` to the specified writer.
-    #[inline]
-    fn write_u128<W>(&mut self, writer: &mut W, value: u128) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = itoa::Buffer::new();
-        let s = buffer.format(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes a floating point value like `-31.26e+12` to the specified writer.
-    #[inline]
-    fn write_f32<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = ryu::Buffer::new();
-        let s = buffer.format_finite(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes a floating point value like `-31.26e+12` to the specified writer.
-    #[inline]
-    fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        let mut buffer = ryu::Buffer::new();
-        let s = buffer.format_finite(value);
-        writer.write_all(s.as_bytes())
-    }
-
-    /// Writes a number that has already been rendered to a string.
-    #[inline]
-    fn write_number_str<W>(&mut self, writer: &mut W, value: &str) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(value.as_bytes())
-    }
-
-    /// Called before each series of `write_string_fragment` and
-    /// `write_char_escape`.  Writes a `"` to the specified writer.
-    #[inline]
-    fn begin_string<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"\"")
-    }
-
-    /// Called after each series of `write_string_fragment` and
-    /// `write_char_escape`.  Writes a `"` to the specified writer.
-    #[inline]
-    fn end_string<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"\"")
-    }
-
-    /// Writes a string fragment that doesn't need any escaping to the
-    /// specified writer.
-    #[inline]
-    fn write_string_fragment<W>(&mut self, writer: &mut W, fragment: &str) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(fragment.as_bytes())
-    }
-
-    /// Writes a character escape code to the specified writer.
-    #[inline]
-    fn write_char_escape<W>(&mut self, writer: &mut W, char_escape: CharEscape) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        use self::CharEscape::*;
-
-        let s = match char_escape {
-            Quote => b"\\\"",
-            ReverseSolidus => b"\\\\",
-            Solidus => b"\\/",
-            Backspace => b"\\b",
-            FormFeed => b"\\f",
-            LineFeed => b"\\n",
-            CarriageReturn => b"\\r",
-            Tab => b"\\t",
-            AsciiControl(byte) => {
-                static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef";
-                let bytes = &[
-                    b'\\',
-                    b'u',
-                    b'0',
-                    b'0',
-                    HEX_DIGITS[(byte >> 4) as usize],
-                    HEX_DIGITS[(byte & 0xF) as usize],
-                ];
-                return writer.write_all(bytes);
-            }
-        };
-
-        writer.write_all(s)
-    }
-
-    /// Writes the representation of a byte array. Formatters can choose whether
-    /// to represent bytes as a JSON array of integers (the default), or some
-    /// JSON string encoding like hex or base64.
-    fn write_byte_array<W>(&mut self, writer: &mut W, value: &[u8]) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        tri!(self.begin_array(writer));
-        let mut first = true;
-        for byte in value {
-            tri!(self.begin_array_value(writer, first));
-            tri!(self.write_u8(writer, *byte));
-            tri!(self.end_array_value(writer));
-            first = false;
-        }
-        self.end_array(writer)
-    }
-
-    /// Called before every array.  Writes a `[` to the specified
-    /// writer.
-    #[inline]
-    fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"[")
-    }
-
-    /// Called after every array.  Writes a `]` to the specified
-    /// writer.
-    #[inline]
-    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"]")
-    }
-
-    /// Called before every array value.  Writes a `,` if needed to
-    /// the specified writer.
-    #[inline]
-    fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        if first {
-            Ok(())
-        } else {
-            writer.write_all(b",")
-        }
-    }
-
-    /// Called after every array value.
-    #[inline]
-    fn end_array_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        Ok(())
-    }
-
-    /// Called before every object.  Writes a `{` to the specified
-    /// writer.
-    #[inline]
-    fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"{")
-    }
-
-    /// Called after every object.  Writes a `}` to the specified
-    /// writer.
-    #[inline]
-    fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b"}")
-    }
-
-    /// Called before every object key.
-    #[inline]
-    fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        if first {
-            Ok(())
-        } else {
-            writer.write_all(b",")
-        }
-    }
-
-    /// Called after every object key.  A `:` should be written to the
-    /// specified writer by either this method or
-    /// `begin_object_value`.
-    #[inline]
-    fn end_object_key<W>(&mut self, _writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        Ok(())
-    }
-
-    /// Called before every object value.  A `:` should be written to
-    /// the specified writer by either this method or
-    /// `end_object_key`.
-    #[inline]
-    fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b":")
-    }
-
-    /// Called after every object value.
-    #[inline]
-    fn end_object_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        Ok(())
-    }
-
-    /// Writes a raw JSON fragment that doesn't need any escaping to the
-    /// specified writer.
-    #[inline]
-    fn write_raw_fragment<W>(&mut self, writer: &mut W, fragment: &str) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(fragment.as_bytes())
-    }
-}
-
-/// This structure compacts a JSON value with no extra whitespace.
-#[derive(Clone, Debug)]
-pub struct CompactFormatter;
-
-impl Formatter for CompactFormatter {}
-
-/// This structure pretty prints a JSON value to make it human readable.
-#[derive(Clone, Debug)]
-pub struct PrettyFormatter<'a> {
-    current_indent: usize,
-    has_value: bool,
-    indent: &'a [u8],
-}
-
-impl<'a> PrettyFormatter<'a> {
-    /// Construct a pretty printer formatter that defaults to using two spaces for indentation.
-    pub fn new() -> Self {
-        PrettyFormatter::with_indent(b"  ")
-    }
-
-    /// Construct a pretty printer formatter that uses the `indent` string for indentation.
-    pub fn with_indent(indent: &'a [u8]) -> Self {
-        PrettyFormatter {
-            current_indent: 0,
-            has_value: false,
-            indent,
-        }
-    }
-}
-
-impl<'a> Default for PrettyFormatter<'a> {
-    fn default() -> Self {
-        PrettyFormatter::new()
-    }
-}
-
-impl<'a> Formatter for PrettyFormatter<'a> {
-    #[inline]
-    fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.current_indent += 1;
-        self.has_value = false;
-        writer.write_all(b"[")
-    }
-
-    #[inline]
-    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.current_indent -= 1;
-
-        if self.has_value {
-            tri!(writer.write_all(b"\n"));
-            tri!(indent(writer, self.current_indent, self.indent));
-        }
-
-        writer.write_all(b"]")
-    }
-
-    #[inline]
-    fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
-        indent(writer, self.current_indent, self.indent)
-    }
-
-    #[inline]
-    fn end_array_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.has_value = true;
-        Ok(())
-    }
-
-    #[inline]
-    fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.current_indent += 1;
-        self.has_value = false;
-        writer.write_all(b"{")
-    }
-
-    #[inline]
-    fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.current_indent -= 1;
-
-        if self.has_value {
-            tri!(writer.write_all(b"\n"));
-            tri!(indent(writer, self.current_indent, self.indent));
-        }
-
-        writer.write_all(b"}")
-    }
-
-    #[inline]
-    fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
-        indent(writer, self.current_indent, self.indent)
-    }
-
-    #[inline]
-    fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        writer.write_all(b": ")
-    }
-
-    #[inline]
-    fn end_object_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
-    where
-        W: ?Sized + io::Write,
-    {
-        self.has_value = true;
-        Ok(())
-    }
-}
-
-fn format_escaped_str<W, F>(writer: &mut W, formatter: &mut F, value: &str) -> io::Result<()>
-where
-    W: ?Sized + io::Write,
-    F: ?Sized + Formatter,
-{
-    tri!(formatter.begin_string(writer));
-    tri!(format_escaped_str_contents(writer, formatter, value));
-    formatter.end_string(writer)
-}
-
-fn format_escaped_str_contents<W, F>(
-    writer: &mut W,
-    formatter: &mut F,
-    value: &str,
-) -> io::Result<()>
-where
-    W: ?Sized + io::Write,
-    F: ?Sized + Formatter,
-{
-    let bytes = value.as_bytes();
-
-    let mut start = 0;
-
-    for (i, &byte) in bytes.iter().enumerate() {
-        let escape = ESCAPE[byte as usize];
-        if escape == 0 {
-            continue;
-        }
-
-        if start < i {
-            tri!(formatter.write_string_fragment(writer, &value[start..i]));
-        }
-
-        let char_escape = CharEscape::from_escape_table(escape, byte);
-        tri!(formatter.write_char_escape(writer, char_escape));
-
-        start = i + 1;
-    }
-
-    if start == bytes.len() {
-        return Ok(());
-    }
-
-    formatter.write_string_fragment(writer, &value[start..])
-}
-
-const BB: u8 = b'b'; // \x08
-const TT: u8 = b't'; // \x09
-const NN: u8 = b'n'; // \x0A
-const FF: u8 = b'f'; // \x0C
-const RR: u8 = b'r'; // \x0D
-const QU: u8 = b'"'; // \x22
-const BS: u8 = b'\\'; // \x5C
-const UU: u8 = b'u'; // \x00...\x1F except the ones above
-const __: u8 = 0;
-
-// Lookup table of escape sequences. A value of b'x' at index i means that byte
-// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.
-static ESCAPE: [u8; 256] = [
-    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
-    UU, UU, UU, UU, UU, UU, UU, UU, BB, TT, NN, UU, FF, RR, UU, UU, // 0
-    UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, // 1
-    __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4
-    __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
-];
-
-/// Serialize the given data structure as JSON into the I/O stream.
-///
-/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
-where
-    W: io::Write,
-    T: ?Sized + Serialize,
-{
-    let mut ser = Serializer::new(writer);
-    value.serialize(&mut ser)
-}
-
-/// Serialize the given data structure as pretty-printed JSON into the I/O
-/// stream.
-///
-/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub fn to_writer_pretty<W, T>(writer: W, value: &T) -> Result<()>
-where
-    W: io::Write,
-    T: ?Sized + Serialize,
-{
-    let mut ser = Serializer::pretty(writer);
-    value.serialize(&mut ser)
-}
-
-/// Serialize the given data structure as a JSON byte vector.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
-where
-    T: ?Sized + Serialize,
-{
-    let mut writer = Vec::with_capacity(128);
-    tri!(to_writer(&mut writer, value));
-    Ok(writer)
-}
-
-/// Serialize the given data structure as a pretty-printed JSON byte vector.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-pub fn to_vec_pretty<T>(value: &T) -> Result<Vec<u8>>
-where
-    T: ?Sized + Serialize,
-{
-    let mut writer = Vec::with_capacity(128);
-    tri!(to_writer_pretty(&mut writer, value));
-    Ok(writer)
-}
-
-/// Serialize the given data structure as a String of JSON.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-pub fn to_string<T>(value: &T) -> Result<String>
-where
-    T: ?Sized + Serialize,
-{
-    let vec = tri!(to_vec(value));
-    let string = unsafe {
-        // We do not emit invalid UTF-8.
-        String::from_utf8_unchecked(vec)
-    };
-    Ok(string)
-}
-
-/// Serialize the given data structure as a pretty-printed String of JSON.
-///
-/// # Errors
-///
-/// Serialization can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-#[inline]
-pub fn to_string_pretty<T>(value: &T) -> Result<String>
-where
-    T: ?Sized + Serialize,
-{
-    let vec = tri!(to_vec_pretty(value));
-    let string = unsafe {
-        // We do not emit invalid UTF-8.
-        String::from_utf8_unchecked(vec)
-    };
-    Ok(string)
-}
-
-fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
-where
-    W: ?Sized + io::Write,
-{
-    for _ in 0..n {
-        tri!(wr.write_all(s));
-    }
-
-    Ok(())
-}
diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs
deleted file mode 100644
index 1e8b5ac..0000000
--- a/vendor/serde_json/src/value/de.rs
+++ /dev/null
@@ -1,1419 +0,0 @@
-use crate::error::{Error, ErrorCode};
-use crate::map::Map;
-use crate::number::Number;
-use crate::value::Value;
-use alloc::borrow::{Cow, ToOwned};
-use alloc::string::String;
-#[cfg(feature = "raw_value")]
-use alloc::string::ToString;
-use alloc::vec::{self, Vec};
-use core::fmt;
-use core::slice;
-use core::str::FromStr;
-use serde::de::{
-    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
-    SeqAccess, Unexpected, VariantAccess, Visitor,
-};
-use serde::forward_to_deserialize_any;
-
-#[cfg(feature = "arbitrary_precision")]
-use crate::number::NumberFromString;
-
-impl<'de> Deserialize<'de> for Value {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct ValueVisitor;
-
-        impl<'de> Visitor<'de> for ValueVisitor {
-            type Value = Value;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("any valid JSON value")
-            }
-
-            #[inline]
-            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
-                Ok(Value::Bool(value))
-            }
-
-            #[inline]
-            fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
-                Ok(Value::Number(value.into()))
-            }
-
-            #[inline]
-            fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
-                Ok(Value::Number(value.into()))
-            }
-
-            #[inline]
-            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
-                Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            #[inline]
-            fn visit_str<E>(self, value: &str) -> Result<Value, E>
-            where
-                E: serde::de::Error,
-            {
-                self.visit_string(String::from(value))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            #[inline]
-            fn visit_string<E>(self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            #[inline]
-            fn visit_none<E>(self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                Deserialize::deserialize(deserializer)
-            }
-
-            #[inline]
-            fn visit_unit<E>(self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: SeqAccess<'de>,
-            {
-                let mut vec = Vec::new();
-
-                while let Some(elem) = tri!(visitor.next_element()) {
-                    vec.push(elem);
-                }
-
-                Ok(Value::Array(vec))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                match tri!(visitor.next_key_seed(KeyClassifier)) {
-                    #[cfg(feature = "arbitrary_precision")]
-                    Some(KeyClass::Number) => {
-                        let number: NumberFromString = tri!(visitor.next_value());
-                        Ok(Value::Number(number.value))
-                    }
-                    #[cfg(feature = "raw_value")]
-                    Some(KeyClass::RawValue) => {
-                        let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString));
-                        crate::from_str(value.get()).map_err(de::Error::custom)
-                    }
-                    Some(KeyClass::Map(first_key)) => {
-                        let mut values = Map::new();
-
-                        values.insert(first_key, tri!(visitor.next_value()));
-                        while let Some((key, value)) = tri!(visitor.next_entry()) {
-                            values.insert(key, value);
-                        }
-
-                        Ok(Value::Object(values))
-                    }
-                    None => Ok(Value::Object(Map::new())),
-                }
-            }
-        }
-
-        deserializer.deserialize_any(ValueVisitor)
-    }
-}
-
-impl FromStr for Value {
-    type Err = Error;
-    fn from_str(s: &str) -> Result<Value, Error> {
-        super::super::de::from_str(s)
-    }
-}
-
-macro_rules! deserialize_number {
-    ($method:ident) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.deserialize_any(visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.$method(visitor),
-                _ => self.deserialize_any(visitor),
-            }
-        }
-    };
-}
-
-fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = array.len();
-    let mut deserializer = SeqDeserializer::new(array);
-    let seq = tri!(visitor.visit_seq(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(seq)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in array",
-        ))
-    }
-}
-
-fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = object.len();
-    let mut deserializer = MapDeserializer::new(object);
-    let map = tri!(visitor.visit_map(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(map)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in map",
-        ))
-    }
-}
-
-impl<'de> serde::Deserializer<'de> for Value {
-    type Error = Error;
-
-    #[inline]
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::Number(n) => n.deserialize_any(visitor),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => visit_array(v, visitor),
-            Value::Object(v) => visit_object(v, visitor),
-        }
-    }
-
-    deserialize_number!(deserialize_i8);
-    deserialize_number!(deserialize_i16);
-    deserialize_number!(deserialize_i32);
-    deserialize_number!(deserialize_i64);
-    deserialize_number!(deserialize_i128);
-    deserialize_number!(deserialize_u8);
-    deserialize_number!(deserialize_u16);
-    deserialize_number!(deserialize_u32);
-    deserialize_number!(deserialize_u64);
-    deserialize_number!(deserialize_u128);
-    deserialize_number!(deserialize_f32);
-    deserialize_number!(deserialize_f64);
-
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_none(),
-            _ => visitor.visit_some(self),
-        }
-    }
-
-    #[inline]
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        let (variant, value) = match self {
-            Value::Object(value) => {
-                let mut iter = value.into_iter();
-                let (variant, value) = match iter.next() {
-                    Some(v) => v,
-                    None => {
-                        return Err(serde::de::Error::invalid_value(
-                            Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                };
-                // enums are encoded in json as maps with a single key:value pair
-                if iter.next().is_some() {
-                    return Err(serde::de::Error::invalid_value(
-                        Unexpected::Map,
-                        &"map with a single key",
-                    ));
-                }
-                (variant, Some(value))
-            }
-            Value::String(variant) => (variant, None),
-            other => {
-                return Err(serde::de::Error::invalid_type(
-                    other.unexpected(),
-                    &"string or map",
-                ));
-            }
-        };
-
-        visitor.visit_enum(EnumDeserializer { variant, value })
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
-                    raw_value: Some(self.to_string()),
-                });
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Bool(v) => visitor.visit_bool(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_byte_buf(visitor)
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => visit_array(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_unit(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Object(v) => visit_object(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array(v, visitor),
-            Value::Object(v) => visit_object(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        drop(self);
-        visitor.visit_unit()
-    }
-}
-
-struct EnumDeserializer {
-    variant: String,
-    value: Option<Value>,
-}
-
-impl<'de> EnumAccess<'de> for EnumDeserializer {
-    type Error = Error;
-    type Variant = VariantDeserializer;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        let variant = self.variant.into_deserializer();
-        let visitor = VariantDeserializer { value: self.value };
-        seed.deserialize(variant).map(|v| (v, visitor))
-    }
-}
-
-impl<'de> IntoDeserializer<'de, Error> for Value {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de> IntoDeserializer<'de, Error> for &'de Value {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-struct VariantDeserializer {
-    value: Option<Value>,
-}
-
-impl<'de> VariantAccess<'de> for VariantDeserializer {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        match self.value {
-            Some(value) => Deserialize::deserialize(value),
-            None => Ok(()),
-        }
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            )),
-        }
-    }
-
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Array(v)) => {
-                if v.is_empty() {
-                    visitor.visit_unit()
-                } else {
-                    visit_array(v, visitor)
-                }
-            }
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"tuple variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            )),
-        }
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Object(v)) => visit_object(v, visitor),
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"struct variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            )),
-        }
-    }
-}
-
-struct SeqDeserializer {
-    iter: vec::IntoIter<Value>,
-}
-
-impl SeqDeserializer {
-    fn new(vec: Vec<Value>) -> Self {
-        SeqDeserializer {
-            iter: vec.into_iter(),
-        }
-    }
-}
-
-impl<'de> SeqAccess<'de> for SeqDeserializer {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => seed.deserialize(value).map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapDeserializer {
-    iter: <Map<String, Value> as IntoIterator>::IntoIter,
-    value: Option<Value>,
-}
-
-impl MapDeserializer {
-    fn new(map: Map<String, Value>) -> Self {
-        MapDeserializer {
-            iter: map.into_iter(),
-            value: None,
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for MapDeserializer {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                let key_de = MapKeyDeserializer {
-                    key: Cow::Owned(key),
-                };
-                seed.deserialize(key_de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value.take() {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::custom("value is missing")),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-macro_rules! deserialize_value_ref_number {
-    ($method:ident) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.deserialize_any(visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.$method(visitor),
-                _ => self.deserialize_any(visitor),
-            }
-        }
-    };
-}
-
-fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = array.len();
-    let mut deserializer = SeqRefDeserializer::new(array);
-    let seq = tri!(visitor.visit_seq(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(seq)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in array",
-        ))
-    }
-}
-
-fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = object.len();
-    let mut deserializer = MapRefDeserializer::new(object);
-    let map = tri!(visitor.visit_map(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(map)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in map",
-        ))
-    }
-}
-
-impl<'de> serde::Deserializer<'de> for &'de Value {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(*v),
-            Value::Number(n) => n.deserialize_any(visitor),
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            Value::Array(v) => visit_array_ref(v, visitor),
-            Value::Object(v) => visit_object_ref(v, visitor),
-        }
-    }
-
-    deserialize_value_ref_number!(deserialize_i8);
-    deserialize_value_ref_number!(deserialize_i16);
-    deserialize_value_ref_number!(deserialize_i32);
-    deserialize_value_ref_number!(deserialize_i64);
-    deserialize_number!(deserialize_i128);
-    deserialize_value_ref_number!(deserialize_u8);
-    deserialize_value_ref_number!(deserialize_u16);
-    deserialize_value_ref_number!(deserialize_u32);
-    deserialize_value_ref_number!(deserialize_u64);
-    deserialize_number!(deserialize_u128);
-    deserialize_value_ref_number!(deserialize_f32);
-    deserialize_value_ref_number!(deserialize_f64);
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Null => visitor.visit_none(),
-            _ => visitor.visit_some(self),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        let (variant, value) = match self {
-            Value::Object(value) => {
-                let mut iter = value.into_iter();
-                let (variant, value) = match iter.next() {
-                    Some(v) => v,
-                    None => {
-                        return Err(serde::de::Error::invalid_value(
-                            Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                };
-                // enums are encoded in json as maps with a single key:value pair
-                if iter.next().is_some() {
-                    return Err(serde::de::Error::invalid_value(
-                        Unexpected::Map,
-                        &"map with a single key",
-                    ));
-                }
-                (variant, Some(value))
-            }
-            Value::String(variant) => (variant, None),
-            other => {
-                return Err(serde::de::Error::invalid_type(
-                    other.unexpected(),
-                    &"string or map",
-                ));
-            }
-        };
-
-        visitor.visit_enum(EnumRefDeserializer { variant, value })
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
-                    raw_value: Some(self.to_string()),
-                });
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Bool(v) => visitor.visit_bool(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            Value::Array(v) => visit_array_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_bytes(visitor)
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Null => visitor.visit_unit(),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_unit(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Object(v) => visit_object_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array_ref(v, visitor),
-            Value::Object(v) => visit_object_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-}
-
-struct EnumRefDeserializer<'de> {
-    variant: &'de str,
-    value: Option<&'de Value>,
-}
-
-impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
-    type Error = Error;
-    type Variant = VariantRefDeserializer<'de>;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        let variant = self.variant.into_deserializer();
-        let visitor = VariantRefDeserializer { value: self.value };
-        seed.deserialize(variant).map(|v| (v, visitor))
-    }
-}
-
-struct VariantRefDeserializer<'de> {
-    value: Option<&'de Value>,
-}
-
-impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        match self.value {
-            Some(value) => Deserialize::deserialize(value),
-            None => Ok(()),
-        }
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            )),
-        }
-    }
-
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Array(v)) => {
-                if v.is_empty() {
-                    visitor.visit_unit()
-                } else {
-                    visit_array_ref(v, visitor)
-                }
-            }
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"tuple variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            )),
-        }
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Object(v)) => visit_object_ref(v, visitor),
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"struct variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            )),
-        }
-    }
-}
-
-struct SeqRefDeserializer<'de> {
-    iter: slice::Iter<'de, Value>,
-}
-
-impl<'de> SeqRefDeserializer<'de> {
-    fn new(slice: &'de [Value]) -> Self {
-        SeqRefDeserializer { iter: slice.iter() }
-    }
-}
-
-impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => seed.deserialize(value).map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapRefDeserializer<'de> {
-    iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
-    value: Option<&'de Value>,
-}
-
-impl<'de> MapRefDeserializer<'de> {
-    fn new(map: &'de Map<String, Value>) -> Self {
-        MapRefDeserializer {
-            iter: map.into_iter(),
-            value: None,
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                let key_de = MapKeyDeserializer {
-                    key: Cow::Borrowed(&**key),
-                };
-                seed.deserialize(key_de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value.take() {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::custom("value is missing")),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapKeyDeserializer<'de> {
-    key: Cow<'de, str>,
-}
-
-macro_rules! deserialize_numeric_key {
-    ($method:ident) => {
-        deserialize_numeric_key!($method, deserialize_number);
-    };
-
-    ($method:ident, $using:ident) => {
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            let mut de = crate::Deserializer::from_str(&self.key);
-
-            match tri!(de.peek()) {
-                Some(b'0'..=b'9' | b'-') => {}
-                _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)),
-            }
-
-            let number = tri!(de.$using(visitor));
-
-            if tri!(de.peek()).is_some() {
-                return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0));
-            }
-
-            Ok(number)
-        }
-    };
-}
-
-impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
-    }
-
-    deserialize_numeric_key!(deserialize_i8);
-    deserialize_numeric_key!(deserialize_i16);
-    deserialize_numeric_key!(deserialize_i32);
-    deserialize_numeric_key!(deserialize_i64);
-    deserialize_numeric_key!(deserialize_u8);
-    deserialize_numeric_key!(deserialize_u16);
-    deserialize_numeric_key!(deserialize_u32);
-    deserialize_numeric_key!(deserialize_u64);
-    #[cfg(not(feature = "float_roundtrip"))]
-    deserialize_numeric_key!(deserialize_f32);
-    deserialize_numeric_key!(deserialize_f64);
-
-    #[cfg(feature = "float_roundtrip")]
-    deserialize_numeric_key!(deserialize_f32, do_deserialize_f32);
-    deserialize_numeric_key!(deserialize_i128, do_deserialize_i128);
-    deserialize_numeric_key!(deserialize_u128, do_deserialize_u128);
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        if self.key == "true" {
-            visitor.visit_bool(true)
-        } else if self.key == "false" {
-            visitor.visit_bool(false)
-        } else {
-            Err(serde::de::Error::invalid_type(
-                Unexpected::Str(&self.key),
-                &visitor,
-            ))
-        }
-    }
-
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        // Map keys cannot be null.
-        visitor.visit_some(self)
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.key
-            .into_deserializer()
-            .deserialize_enum(name, variants, visitor)
-    }
-
-    forward_to_deserialize_any! {
-        char str string bytes byte_buf unit unit_struct seq tuple tuple_struct
-        map struct identifier ignored_any
-    }
-}
-
-struct KeyClassifier;
-
-enum KeyClass {
-    Map(String),
-    #[cfg(feature = "arbitrary_precision")]
-    Number,
-    #[cfg(feature = "raw_value")]
-    RawValue,
-}
-
-impl<'de> DeserializeSeed<'de> for KeyClassifier {
-    type Value = KeyClass;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_str(self)
-    }
-}
-
-impl<'de> Visitor<'de> for KeyClassifier {
-    type Value = KeyClass;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string key")
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        match s {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(KeyClass::Number),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(KeyClass::RawValue),
-            _ => Ok(KeyClass::Map(s.to_owned())),
-        }
-    }
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        match s.as_str() {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(KeyClass::Number),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(KeyClass::RawValue),
-            _ => Ok(KeyClass::Map(s)),
-        }
-    }
-}
-
-impl Value {
-    #[cold]
-    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
-    where
-        E: serde::de::Error,
-    {
-        serde::de::Error::invalid_type(self.unexpected(), exp)
-    }
-
-    #[cold]
-    fn unexpected(&self) -> Unexpected {
-        match self {
-            Value::Null => Unexpected::Unit,
-            Value::Bool(b) => Unexpected::Bool(*b),
-            Value::Number(n) => n.unexpected(),
-            Value::String(s) => Unexpected::Str(s),
-            Value::Array(_) => Unexpected::Seq,
-            Value::Object(_) => Unexpected::Map,
-        }
-    }
-}
-
-struct BorrowedCowStrDeserializer<'de> {
-    value: Cow<'de, str>,
-}
-
-impl<'de> BorrowedCowStrDeserializer<'de> {
-    fn new(value: Cow<'de, str>) -> Self {
-        BorrowedCowStrDeserializer { value }
-    }
-}
-
-impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value {
-            Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Cow::Owned(string) => visitor.visit_string(string),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
-    type Error = Error;
-    type Variant = UnitOnly;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let value = tri!(seed.deserialize(self));
-        Ok((value, UnitOnly))
-    }
-}
-
-struct UnitOnly;
-
-impl<'de> de::VariantAccess<'de> for UnitOnly {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"newtype variant",
-        ))
-    }
-
-    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"tuple variant",
-        ))
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        _visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"struct variant",
-        ))
-    }
-}
diff --git a/vendor/serde_json/src/value/from.rs b/vendor/serde_json/src/value/from.rs
deleted file mode 100644
index ed1e333..0000000
--- a/vendor/serde_json/src/value/from.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-use super::Value;
-use crate::map::Map;
-use crate::number::Number;
-use alloc::borrow::Cow;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-
-macro_rules! from_integer {
-    ($($ty:ident)*) => {
-        $(
-            impl From<$ty> for Value {
-                fn from(n: $ty) -> Self {
-                    Value::Number(n.into())
-                }
-            }
-        )*
-    };
-}
-
-from_integer! {
-    i8 i16 i32 i64 isize
-    u8 u16 u32 u64 usize
-}
-
-#[cfg(feature = "arbitrary_precision")]
-from_integer! {
-    i128 u128
-}
-
-impl From<f32> for Value {
-    /// Convert 32-bit floating point number to `Value::Number`, or
-    /// `Value::Null` if infinite or NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let f: f32 = 13.37;
-    /// let x: Value = f.into();
-    /// ```
-    fn from(f: f32) -> Self {
-        Number::from_f32(f).map_or(Value::Null, Value::Number)
-    }
-}
-
-impl From<f64> for Value {
-    /// Convert 64-bit floating point number to `Value::Number`, or
-    /// `Value::Null` if infinite or NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let f: f64 = 13.37;
-    /// let x: Value = f.into();
-    /// ```
-    fn from(f: f64) -> Self {
-        Number::from_f64(f).map_or(Value::Null, Value::Number)
-    }
-}
-
-impl From<bool> for Value {
-    /// Convert boolean to `Value::Bool`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let b = false;
-    /// let x: Value = b.into();
-    /// ```
-    fn from(f: bool) -> Self {
-        Value::Bool(f)
-    }
-}
-
-impl From<String> for Value {
-    /// Convert `String` to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let s: String = "lorem".to_string();
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: String) -> Self {
-        Value::String(f)
-    }
-}
-
-impl From<&str> for Value {
-    /// Convert string slice to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let s: &str = "lorem";
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: &str) -> Self {
-        Value::String(f.to_string())
-    }
-}
-
-impl<'a> From<Cow<'a, str>> for Value {
-    /// Convert copy-on-write string to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    /// use std::borrow::Cow;
-    ///
-    /// let s: Cow<str> = Cow::Borrowed("lorem");
-    /// let x: Value = s.into();
-    /// ```
-    ///
-    /// ```
-    /// use serde_json::Value;
-    /// use std::borrow::Cow;
-    ///
-    /// let s: Cow<str> = Cow::Owned("lorem".to_string());
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: Cow<'a, str>) -> Self {
-        Value::String(f.into_owned())
-    }
-}
-
-impl From<Number> for Value {
-    /// Convert `Number` to `Value::Number`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::{Number, Value};
-    ///
-    /// let n = Number::from(7);
-    /// let x: Value = n.into();
-    /// ```
-    fn from(f: Number) -> Self {
-        Value::Number(f)
-    }
-}
-
-impl From<Map<String, Value>> for Value {
-    /// Convert map (with string keys) to `Value::Object`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::{Map, Value};
-    ///
-    /// let mut m = Map::new();
-    /// m.insert("Lorem".to_string(), "ipsum".into());
-    /// let x: Value = m.into();
-    /// ```
-    fn from(f: Map<String, Value>) -> Self {
-        Value::Object(f)
-    }
-}
-
-impl<T: Into<Value>> From<Vec<T>> for Value {
-    /// Convert a `Vec` to `Value::Array`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v = vec!["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into();
-    /// ```
-    fn from(f: Vec<T>) -> Self {
-        Value::Array(f.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<T: Clone + Into<Value>> From<&[T]> for Value {
-    /// Convert a slice to `Value::Array`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into();
-    /// ```
-    fn from(f: &[T]) -> Self {
-        Value::Array(f.iter().cloned().map(Into::into).collect())
-    }
-}
-
-impl<T: Into<Value>> FromIterator<T> for Value {
-    /// Create a `Value::Array` by collecting an iterator of array elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v = std::iter::repeat(42).take(5);
-    /// let x: Value = v.collect();
-    /// ```
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into_iter().collect();
-    /// ```
-    ///
-    /// ```
-    /// use std::iter::FromIterator;
-    /// use serde_json::Value;
-    ///
-    /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
-    /// ```
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        Value::Array(iter.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value {
-    /// Create a `Value::Object` by collecting an iterator of key-value pairs.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
-    /// let x: Value = v.into_iter().collect();
-    /// ```
-    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
-        Value::Object(
-            iter.into_iter()
-                .map(|(k, v)| (k.into(), v.into()))
-                .collect(),
-        )
-    }
-}
-
-impl From<()> for Value {
-    /// Convert `()` to `Value::Null`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let u = ();
-    /// let x: Value = u.into();
-    /// ```
-    fn from((): ()) -> Self {
-        Value::Null
-    }
-}
-
-impl<T> From<Option<T>> for Value
-where
-    T: Into<Value>,
-{
-    fn from(opt: Option<T>) -> Self {
-        match opt {
-            None => Value::Null,
-            Some(value) => Into::into(value),
-        }
-    }
-}
diff --git a/vendor/serde_json/src/value/index.rs b/vendor/serde_json/src/value/index.rs
deleted file mode 100644
index 891ca8e..0000000
--- a/vendor/serde_json/src/value/index.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use super::Value;
-use crate::map::Map;
-use alloc::borrow::ToOwned;
-use alloc::string::String;
-use core::fmt::{self, Display};
-use core::ops;
-
-/// A type that can be used to index into a `serde_json::Value`.
-///
-/// The [`get`] and [`get_mut`] methods of `Value` accept any type that
-/// implements `Index`, as does the [square-bracket indexing operator]. This
-/// trait is implemented for strings which are used as the index into a JSON
-/// map, and for `usize` which is used as the index into a JSON array.
-///
-/// [`get`]: ../enum.Value.html#method.get
-/// [`get_mut`]: ../enum.Value.html#method.get_mut
-/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E
-///
-/// This trait is sealed and cannot be implemented for types outside of
-/// `serde_json`.
-///
-/// # Examples
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// let data = json!({ "inner": [1, 2, 3] });
-///
-/// // Data is a JSON map so it can be indexed with a string.
-/// let inner = &data["inner"];
-///
-/// // Inner is a JSON array so it can be indexed with an integer.
-/// let first = &inner[0];
-///
-/// assert_eq!(first, 1);
-/// ```
-pub trait Index: private::Sealed {
-    /// Return None if the key is not already in the array or object.
-    #[doc(hidden)]
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
-
-    /// Return None if the key is not already in the array or object.
-    #[doc(hidden)]
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
-
-    /// Panic if array index out of bounds. If key is not already in the object,
-    /// insert it with a value of null. Panic if Value is a type that cannot be
-    /// indexed into, except if Value is null then it can be treated as an empty
-    /// object.
-    #[doc(hidden)]
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
-}
-
-impl Index for usize {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        match v {
-            Value::Array(vec) => vec.get(*self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        match v {
-            Value::Array(vec) => vec.get_mut(*self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        match v {
-            Value::Array(vec) => {
-                let len = vec.len();
-                vec.get_mut(*self).unwrap_or_else(|| {
-                    panic!(
-                        "cannot access index {} of JSON array of length {}",
-                        self, len
-                    )
-                })
-            }
-            _ => panic!("cannot access index {} of JSON {}", self, Type(v)),
-        }
-    }
-}
-
-impl Index for str {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        match v {
-            Value::Object(map) => map.get(self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        match v {
-            Value::Object(map) => map.get_mut(self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        if let Value::Null = v {
-            *v = Value::Object(Map::new());
-        }
-        match v {
-            Value::Object(map) => map.entry(self.to_owned()).or_insert(Value::Null),
-            _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
-        }
-    }
-}
-
-impl Index for String {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        self[..].index_into(v)
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        self[..].index_into_mut(v)
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        self[..].index_or_insert(v)
-    }
-}
-
-impl<T> Index for &T
-where
-    T: ?Sized + Index,
-{
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        (**self).index_into(v)
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        (**self).index_into_mut(v)
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        (**self).index_or_insert(v)
-    }
-}
-
-// Prevent users from implementing the Index trait.
-mod private {
-    pub trait Sealed {}
-    impl Sealed for usize {}
-    impl Sealed for str {}
-    impl Sealed for alloc::string::String {}
-    impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
-}
-
-/// Used in panic messages.
-struct Type<'a>(&'a Value);
-
-impl<'a> Display for Type<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match *self.0 {
-            Value::Null => formatter.write_str("null"),
-            Value::Bool(_) => formatter.write_str("boolean"),
-            Value::Number(_) => formatter.write_str("number"),
-            Value::String(_) => formatter.write_str("string"),
-            Value::Array(_) => formatter.write_str("array"),
-            Value::Object(_) => formatter.write_str("object"),
-        }
-    }
-}
-
-// The usual semantics of Index is to panic on invalid indexing.
-//
-// That said, the usual semantics are for things like Vec and BTreeMap which
-// have different use cases than Value. If you are working with a Vec, you know
-// that you are working with a Vec and you can get the len of the Vec and make
-// sure your indices are within bounds. The Value use cases are more
-// loosey-goosey. You got some JSON from an endpoint and you want to pull values
-// out of it. Outside of this Index impl, you already have the option of using
-// value.as_array() and working with the Vec directly, or matching on
-// Value::Array and getting the Vec directly. The Index impl means you can skip
-// that and index directly into the thing using a concise syntax. You don't have
-// to check the type, you don't have to check the len, it is all about what you
-// expect the Value to look like.
-//
-// Basically the use cases that would be well served by panicking here are
-// better served by using one of the other approaches: get and get_mut,
-// as_array, or match. The value of this impl is that it adds a way of working
-// with Value that is not well served by the existing approaches: concise and
-// careless and sometimes that is exactly what you want.
-impl<I> ops::Index<I> for Value
-where
-    I: Index,
-{
-    type Output = Value;
-
-    /// Index into a `serde_json::Value` using the syntax `value[0]` or
-    /// `value["k"]`.
-    ///
-    /// Returns `Value::Null` if the type of `self` does not match the type of
-    /// the index, for example if the index is a string and `self` is an array
-    /// or a number. Also returns `Value::Null` if the given key does not exist
-    /// in the map or the given index is not within the bounds of the array.
-    ///
-    /// For retrieving deeply nested values, you should have a look at the
-    /// `Value::pointer` method.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let data = json!({
-    ///     "x": {
-    ///         "y": ["z", "zz"]
-    ///     }
-    /// });
-    ///
-    /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
-    /// assert_eq!(data["x"]["y"][0], json!("z"));
-    ///
-    /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
-    /// assert_eq!(data["a"]["b"], json!(null)); // does not panic
-    /// ```
-    fn index(&self, index: I) -> &Value {
-        static NULL: Value = Value::Null;
-        index.index_into(self).unwrap_or(&NULL)
-    }
-}
-
-impl<I> ops::IndexMut<I> for Value
-where
-    I: Index,
-{
-    /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
-    /// `value["k"] = ...`.
-    ///
-    /// If the index is a number, the value must be an array of length bigger
-    /// than the index. Indexing into a value that is not an array or an array
-    /// that is too small will panic.
-    ///
-    /// If the index is a string, the value must be an object or null which is
-    /// treated like an empty object. If the key is not already present in the
-    /// object, it will be inserted with a value of null. Indexing into a value
-    /// that is neither an object nor null will panic.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut data = json!({ "x": 0 });
-    ///
-    /// // replace an existing key
-    /// data["x"] = json!(1);
-    ///
-    /// // insert a new key
-    /// data["y"] = json!([false, false, false]);
-    ///
-    /// // replace an array value
-    /// data["y"][0] = json!(true);
-    ///
-    /// // inserted a deeply nested key
-    /// data["a"]["b"]["c"]["d"] = json!(true);
-    ///
-    /// println!("{}", data);
-    /// ```
-    fn index_mut(&mut self, index: I) -> &mut Value {
-        index.index_or_insert(self)
-    }
-}
diff --git a/vendor/serde_json/src/value/mod.rs b/vendor/serde_json/src/value/mod.rs
deleted file mode 100644
index b3f51ea..0000000
--- a/vendor/serde_json/src/value/mod.rs
+++ /dev/null
@@ -1,1009 +0,0 @@
-//! The Value enum, a loosely typed way of representing any valid JSON value.
-//!
-//! # Constructing JSON
-//!
-//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
-//! objects with very natural JSON syntax.
-//!
-//! ```
-//! use serde_json::json;
-//!
-//! fn main() {
-//!     // The type of `john` is `serde_json::Value`
-//!     let john = json!({
-//!         "name": "John Doe",
-//!         "age": 43,
-//!         "phones": [
-//!             "+44 1234567",
-//!             "+44 2345678"
-//!         ]
-//!     });
-//!
-//!     println!("first phone number: {}", john["phones"][0]);
-//!
-//!     // Convert to a string of JSON and print it out
-//!     println!("{}", john.to_string());
-//! }
-//! ```
-//!
-//! The `Value::to_string()` function converts a `serde_json::Value` into a
-//! `String` of JSON text.
-//!
-//! One neat thing about the `json!` macro is that variables and expressions can
-//! be interpolated directly into the JSON value as you are building it. Serde
-//! will check at compile time that the value you are interpolating is able to
-//! be represented as JSON.
-//!
-//! ```
-//! # use serde_json::json;
-//! #
-//! # fn random_phone() -> u16 { 0 }
-//! #
-//! let full_name = "John Doe";
-//! let age_last_year = 42;
-//!
-//! // The type of `john` is `serde_json::Value`
-//! let john = json!({
-//!     "name": full_name,
-//!     "age": age_last_year + 1,
-//!     "phones": [
-//!         format!("+44 {}", random_phone())
-//!     ]
-//! });
-//! ```
-//!
-//! A string of JSON data can be parsed into a `serde_json::Value` by the
-//! [`serde_json::from_str`][from_str] function. There is also
-//! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and
-//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
-//! a TCP stream.
-//!
-//! ```
-//! use serde_json::{json, Value, Error};
-//!
-//! fn untyped_example() -> Result<(), Error> {
-//!     // Some JSON input data as a &str. Maybe this comes from the user.
-//!     let data = r#"
-//!         {
-//!             "name": "John Doe",
-//!             "age": 43,
-//!             "phones": [
-//!                 "+44 1234567",
-//!                 "+44 2345678"
-//!             ]
-//!         }"#;
-//!
-//!     // Parse the string of data into serde_json::Value.
-//!     let v: Value = serde_json::from_str(data)?;
-//!
-//!     // Access parts of the data by indexing with square brackets.
-//!     println!("Please call {} at the number {}", v["name"], v["phones"][0]);
-//!
-//!     Ok(())
-//! }
-//! #
-//! # untyped_example().unwrap();
-//! ```
-//!
-//! [macro]: crate::json
-//! [from_str]: crate::de::from_str
-//! [from_slice]: crate::de::from_slice
-//! [from_reader]: crate::de::from_reader
-
-use crate::error::Error;
-use crate::io;
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::fmt::{self, Debug, Display};
-use core::mem;
-use core::str;
-use serde::de::DeserializeOwned;
-use serde::ser::Serialize;
-
-pub use self::index::Index;
-pub use self::ser::Serializer;
-pub use crate::map::Map;
-pub use crate::number::Number;
-
-#[cfg(feature = "raw_value")]
-#[cfg_attr(docsrs, doc(cfg(feature = "raw_value")))]
-pub use crate::raw::{to_raw_value, RawValue};
-
-/// Represents any valid JSON value.
-///
-/// See the [`serde_json::value` module documentation](self) for usage examples.
-#[derive(Clone, Eq, PartialEq)]
-pub enum Value {
-    /// Represents a JSON null value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(null);
-    /// ```
-    Null,
-
-    /// Represents a JSON boolean.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(true);
-    /// ```
-    Bool(bool),
-
-    /// Represents a JSON number, whether integer or floating point.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(12.5);
-    /// ```
-    Number(Number),
-
-    /// Represents a JSON string.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!("a string");
-    /// ```
-    String(String),
-
-    /// Represents a JSON array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(["an", "array"]);
-    /// ```
-    Array(Vec<Value>),
-
-    /// Represents a JSON object.
-    ///
-    /// By default the map is backed by a BTreeMap. Enable the `preserve_order`
-    /// feature of serde_json to use IndexMap instead, which preserves
-    /// entries in the order they are inserted into the map. In particular, this
-    /// allows JSON data to be deserialized into a Value and serialized to a
-    /// string while retaining the order of map keys in the input.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "an": "object" });
-    /// ```
-    Object(Map<String, Value>),
-}
-
-impl Debug for Value {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Value::Null => formatter.write_str("Null"),
-            Value::Bool(boolean) => write!(formatter, "Bool({})", boolean),
-            Value::Number(number) => Debug::fmt(number, formatter),
-            Value::String(string) => write!(formatter, "String({:?})", string),
-            Value::Array(vec) => {
-                tri!(formatter.write_str("Array "));
-                Debug::fmt(vec, formatter)
-            }
-            Value::Object(map) => {
-                tri!(formatter.write_str("Object "));
-                Debug::fmt(map, formatter)
-            }
-        }
-    }
-}
-
-impl Display for Value {
-    /// Display a JSON value as a string.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let json = json!({ "city": "London", "street": "10 Downing Street" });
-    ///
-    /// // Compact format:
-    /// //
-    /// // {"city":"London","street":"10 Downing Street"}
-    /// let compact = format!("{}", json);
-    /// assert_eq!(compact,
-    ///     "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");
-    ///
-    /// // Pretty format:
-    /// //
-    /// // {
-    /// //   "city": "London",
-    /// //   "street": "10 Downing Street"
-    /// // }
-    /// let pretty = format!("{:#}", json);
-    /// assert_eq!(pretty,
-    ///     "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");
-    /// ```
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        struct WriterFormatter<'a, 'b: 'a> {
-            inner: &'a mut fmt::Formatter<'b>,
-        }
-
-        impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                // Safety: the serializer below only emits valid utf8 when using
-                // the default formatter.
-                let s = unsafe { str::from_utf8_unchecked(buf) };
-                tri!(self.inner.write_str(s).map_err(io_error));
-                Ok(buf.len())
-            }
-
-            fn flush(&mut self) -> io::Result<()> {
-                Ok(())
-            }
-        }
-
-        fn io_error(_: fmt::Error) -> io::Error {
-            // Error value does not matter because Display impl just maps it
-            // back to fmt::Error.
-            io::Error::new(io::ErrorKind::Other, "fmt error")
-        }
-
-        let alternate = f.alternate();
-        let mut wr = WriterFormatter { inner: f };
-        if alternate {
-            // {:#}
-            super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
-        } else {
-            // {}
-            super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
-        }
-    }
-}
-
-fn parse_index(s: &str) -> Option<usize> {
-    if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) {
-        return None;
-    }
-    s.parse().ok()
-}
-
-impl Value {
-    /// Index into a JSON array or map. A string index can be used to access a
-    /// value in a map, and a usize index can be used to access an element of an
-    /// array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let object = json!({ "A": 65, "B": 66, "C": 67 });
-    /// assert_eq!(*object.get("A").unwrap(), json!(65));
-    ///
-    /// let array = json!([ "A", "B", "C" ]);
-    /// assert_eq!(*array.get(2).unwrap(), json!("C"));
-    ///
-    /// assert_eq!(array.get("A"), None);
-    /// ```
-    ///
-    /// Square brackets can also be used to index into a value in a more concise
-    /// way. This returns `Value::Null` in cases where `get` would have returned
-    /// `None`.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let object = json!({
-    ///     "A": ["a", "á", "à"],
-    ///     "B": ["b", "b́"],
-    ///     "C": ["c", "ć", "ć̣", "ḉ"],
-    /// });
-    /// assert_eq!(object["B"][0], json!("b"));
-    ///
-    /// assert_eq!(object["D"], json!(null));
-    /// assert_eq!(object[0]["x"]["y"]["z"], json!(null));
-    /// ```
-    pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
-        index.index_into(self)
-    }
-
-    /// Mutably index into a JSON array or map. A string index can be used to
-    /// access a value in a map, and a usize index can be used to access an
-    /// element of an array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
-    /// *object.get_mut("A").unwrap() = json!(69);
-    ///
-    /// let mut array = json!([ "A", "B", "C" ]);
-    /// *array.get_mut(2).unwrap() = json!("D");
-    /// ```
-    pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
-        index.index_into_mut(self)
-    }
-
-    /// Returns true if the `Value` is an Object. Returns false otherwise.
-    ///
-    /// For any Value on which `is_object` returns true, `as_object` and
-    /// `as_object_mut` are guaranteed to return the map representation of the
-    /// object.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
-    ///
-    /// assert!(obj.is_object());
-    /// assert!(obj["a"].is_object());
-    ///
-    /// // array, not an object
-    /// assert!(!obj["b"].is_object());
-    /// ```
-    pub fn is_object(&self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the `Value` is an Object, returns the associated Map. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });
-    ///
-    /// // The length of `{"nested": true}` is 1 entry.
-    /// assert_eq!(v["a"].as_object().unwrap().len(), 1);
-    ///
-    /// // The array `["an", "array"]` is not an object.
-    /// assert_eq!(v["b"].as_object(), None);
-    /// ```
-    pub fn as_object(&self) -> Option<&Map<String, Value>> {
-        match self {
-            Value::Object(map) => Some(map),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an Object, returns the associated mutable Map.
-    /// Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "a": { "nested": true } });
-    ///
-    /// v["a"].as_object_mut().unwrap().clear();
-    /// assert_eq!(v, json!({ "a": {} }));
-    /// ```
-    pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> {
-        match self {
-            Value::Object(map) => Some(map),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is an Array. Returns false otherwise.
-    ///
-    /// For any Value on which `is_array` returns true, `as_array` and
-    /// `as_array_mut` are guaranteed to return the vector representing the
-    /// array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
-    ///
-    /// assert!(obj["a"].is_array());
-    ///
-    /// // an object, not an array
-    /// assert!(!obj["b"].is_array());
-    /// ```
-    pub fn is_array(&self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the `Value` is an Array, returns the associated vector. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });
-    ///
-    /// // The length of `["an", "array"]` is 2 elements.
-    /// assert_eq!(v["a"].as_array().unwrap().len(), 2);
-    ///
-    /// // The object `{"an": "object"}` is not an array.
-    /// assert_eq!(v["b"].as_array(), None);
-    /// ```
-    pub fn as_array(&self) -> Option<&Vec<Value>> {
-        match self {
-            Value::Array(array) => Some(array),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an Array, returns the associated mutable vector.
-    /// Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "a": ["an", "array"] });
-    ///
-    /// v["a"].as_array_mut().unwrap().clear();
-    /// assert_eq!(v, json!({ "a": [] }));
-    /// ```
-    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
-        match self {
-            Value::Array(list) => Some(list),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a String. Returns false otherwise.
-    ///
-    /// For any Value on which `is_string` returns true, `as_str` is guaranteed
-    /// to return the string slice.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": "some string", "b": false });
-    ///
-    /// assert!(v["a"].is_string());
-    ///
-    /// // The boolean `false` is not a string.
-    /// assert!(!v["b"].is_string());
-    /// ```
-    pub fn is_string(&self) -> bool {
-        self.as_str().is_some()
-    }
-
-    /// If the `Value` is a String, returns the associated str. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": "some string", "b": false });
-    ///
-    /// assert_eq!(v["a"].as_str(), Some("some string"));
-    ///
-    /// // The boolean `false` is not a string.
-    /// assert_eq!(v["b"].as_str(), None);
-    ///
-    /// // JSON values are printed in JSON representation, so strings are in quotes.
-    /// //
-    /// //    The value is: "some string"
-    /// println!("The value is: {}", v["a"]);
-    ///
-    /// // Rust strings are printed without quotes.
-    /// //
-    /// //    The value is: some string
-    /// println!("The value is: {}", v["a"].as_str().unwrap());
-    /// ```
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            Value::String(s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Number. Returns false otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 1, "b": "2" });
-    ///
-    /// assert!(v["a"].is_number());
-    ///
-    /// // The string `"2"` is a string, not a number.
-    /// assert!(!v["b"].is_number());
-    /// ```
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Value::Number(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is a Number, returns the associated [`Number`]. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::{json, Number};
-    /// #
-    /// let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" });
-    ///
-    /// assert_eq!(v["a"].as_number(), Some(&Number::from(1u64)));
-    /// assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap()));
-    /// assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64)));
-    ///
-    /// // The string `"4"` is not a number.
-    /// assert_eq!(v["d"].as_number(), None);
-    /// ```
-    pub fn as_number(&self) -> Option<&Number> {
-        match self {
-            Value::Number(number) => Some(number),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is an integer between `i64::MIN` and
-    /// `i64::MAX`.
-    ///
-    /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_i64());
-    ///
-    /// // Greater than i64::MAX.
-    /// assert!(!v["b"].is_i64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_i64());
-    /// ```
-    pub fn is_i64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_i64(),
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is an integer between zero and `u64::MAX`.
-    ///
-    /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_u64());
-    ///
-    /// // Negative integer.
-    /// assert!(!v["b"].is_u64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_u64());
-    /// ```
-    pub fn is_u64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_u64(),
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a number that can be represented by f64.
-    ///
-    /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
-    /// return the floating point value.
-    ///
-    /// Currently this function returns true if and only if both `is_i64` and
-    /// `is_u64` return false but this is not a guarantee in the future.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert!(v["a"].is_f64());
-    ///
-    /// // Integers.
-    /// assert!(!v["b"].is_f64());
-    /// assert!(!v["c"].is_f64());
-    /// ```
-    pub fn is_f64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_f64(),
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is an integer, represent it as i64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_i64(), Some(64));
-    /// assert_eq!(v["b"].as_i64(), None);
-    /// assert_eq!(v["c"].as_i64(), None);
-    /// ```
-    pub fn as_i64(&self) -> Option<i64> {
-        match self {
-            Value::Number(n) => n.as_i64(),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an integer, represent it as u64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_u64(), Some(64));
-    /// assert_eq!(v["b"].as_u64(), None);
-    /// assert_eq!(v["c"].as_u64(), None);
-    /// ```
-    pub fn as_u64(&self) -> Option<u64> {
-        match self {
-            Value::Number(n) => n.as_u64(),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is a number, represent it as f64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert_eq!(v["a"].as_f64(), Some(256.0));
-    /// assert_eq!(v["b"].as_f64(), Some(64.0));
-    /// assert_eq!(v["c"].as_f64(), Some(-64.0));
-    /// ```
-    pub fn as_f64(&self) -> Option<f64> {
-        match self {
-            Value::Number(n) => n.as_f64(),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
-    ///
-    /// For any Value on which `is_boolean` returns true, `as_bool` is
-    /// guaranteed to return the boolean value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": false, "b": "false" });
-    ///
-    /// assert!(v["a"].is_boolean());
-    ///
-    /// // The string `"false"` is a string, not a boolean.
-    /// assert!(!v["b"].is_boolean());
-    /// ```
-    pub fn is_boolean(&self) -> bool {
-        self.as_bool().is_some()
-    }
-
-    /// If the `Value` is a Boolean, returns the associated bool. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": false, "b": "false" });
-    ///
-    /// assert_eq!(v["a"].as_bool(), Some(false));
-    ///
-    /// // The string `"false"` is a string, not a boolean.
-    /// assert_eq!(v["b"].as_bool(), None);
-    /// ```
-    pub fn as_bool(&self) -> Option<bool> {
-        match *self {
-            Value::Bool(b) => Some(b),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Null. Returns false otherwise.
-    ///
-    /// For any Value on which `is_null` returns true, `as_null` is guaranteed
-    /// to return `Some(())`.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": null, "b": false });
-    ///
-    /// assert!(v["a"].is_null());
-    ///
-    /// // The boolean `false` is not null.
-    /// assert!(!v["b"].is_null());
-    /// ```
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the `Value` is a Null, returns (). Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": null, "b": false });
-    ///
-    /// assert_eq!(v["a"].as_null(), Some(()));
-    ///
-    /// // The boolean `false` is not null.
-    /// assert_eq!(v["b"].as_null(), None);
-    /// ```
-    pub fn as_null(&self) -> Option<()> {
-        match *self {
-            Value::Null => Some(()),
-            _ => None,
-        }
-    }
-
-    /// Looks up a value by a JSON Pointer.
-    ///
-    /// JSON Pointer defines a string syntax for identifying a specific value
-    /// within a JavaScript Object Notation (JSON) document.
-    ///
-    /// A Pointer is a Unicode string with the reference tokens separated by `/`.
-    /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
-    /// addressed value is returned and if there is no such value `None` is
-    /// returned.
-    ///
-    /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let data = json!({
-    ///     "x": {
-    ///         "y": ["z", "zz"]
-    ///     }
-    /// });
-    ///
-    /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
-    /// assert_eq!(data.pointer("/a/b/c"), None);
-    /// ```
-    pub fn pointer(&self, pointer: &str) -> Option<&Value> {
-        if pointer.is_empty() {
-            return Some(self);
-        }
-        if !pointer.starts_with('/') {
-            return None;
-        }
-        pointer
-            .split('/')
-            .skip(1)
-            .map(|x| x.replace("~1", "/").replace("~0", "~"))
-            .try_fold(self, |target, token| match target {
-                Value::Object(map) => map.get(&token),
-                Value::Array(list) => parse_index(&token).and_then(|x| list.get(x)),
-                _ => None,
-            })
-    }
-
-    /// Looks up a value by a JSON Pointer and returns a mutable reference to
-    /// that value.
-    ///
-    /// JSON Pointer defines a string syntax for identifying a specific value
-    /// within a JavaScript Object Notation (JSON) document.
-    ///
-    /// A Pointer is a Unicode string with the reference tokens separated by `/`.
-    /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
-    /// addressed value is returned and if there is no such value `None` is
-    /// returned.
-    ///
-    /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
-    ///
-    /// # Example of Use
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// fn main() {
-    ///     let s = r#"{"x": 1.0, "y": 2.0}"#;
-    ///     let mut value: Value = serde_json::from_str(s).unwrap();
-    ///
-    ///     // Check value using read-only pointer
-    ///     assert_eq!(value.pointer("/x"), Some(&1.0.into()));
-    ///     // Change value with direct assignment
-    ///     *value.pointer_mut("/x").unwrap() = 1.5.into();
-    ///     // Check that new value was written
-    ///     assert_eq!(value.pointer("/x"), Some(&1.5.into()));
-    ///     // Or change the value only if it exists
-    ///     value.pointer_mut("/x").map(|v| *v = 1.5.into());
-    ///
-    ///     // "Steal" ownership of a value. Can replace with any valid Value.
-    ///     let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
-    ///     assert_eq!(old_x, 1.5);
-    ///     assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
-    /// }
-    /// ```
-    pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> {
-        if pointer.is_empty() {
-            return Some(self);
-        }
-        if !pointer.starts_with('/') {
-            return None;
-        }
-        pointer
-            .split('/')
-            .skip(1)
-            .map(|x| x.replace("~1", "/").replace("~0", "~"))
-            .try_fold(self, |target, token| match target {
-                Value::Object(map) => map.get_mut(&token),
-                Value::Array(list) => parse_index(&token).and_then(move |x| list.get_mut(x)),
-                _ => None,
-            })
-    }
-
-    /// Takes the value out of the `Value`, leaving a `Null` in its place.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "x": "y" });
-    /// assert_eq!(v["x"].take(), json!("y"));
-    /// assert_eq!(v, json!({ "x": null }));
-    /// ```
-    pub fn take(&mut self) -> Value {
-        mem::replace(self, Value::Null)
-    }
-}
-
-/// The default value is `Value::Null`.
-///
-/// This is useful for handling omitted `Value` fields when deserializing.
-///
-/// # Examples
-///
-/// ```
-/// # use serde::Deserialize;
-/// use serde_json::Value;
-///
-/// #[derive(Deserialize)]
-/// struct Settings {
-///     level: i32,
-///     #[serde(default)]
-///     extras: Value,
-/// }
-///
-/// # fn try_main() -> Result<(), serde_json::Error> {
-/// let data = r#" { "level": 42 } "#;
-/// let s: Settings = serde_json::from_str(data)?;
-///
-/// assert_eq!(s.level, 42);
-/// assert_eq!(s.extras, Value::Null);
-/// #
-/// #     Ok(())
-/// # }
-/// #
-/// # try_main().unwrap()
-/// ```
-impl Default for Value {
-    fn default() -> Value {
-        Value::Null
-    }
-}
-
-mod de;
-mod from;
-mod index;
-mod partial_eq;
-mod ser;
-
-/// Convert a `T` into `serde_json::Value` which is an enum that can represent
-/// any valid JSON data.
-///
-/// # Example
-///
-/// ```
-/// use serde::Serialize;
-/// use serde_json::json;
-/// use std::error::Error;
-///
-/// #[derive(Serialize)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn compare_json_values() -> Result<(), Box<dyn Error>> {
-///     let u = User {
-///         fingerprint: "0xF9BA143B95FF6D82".to_owned(),
-///         location: "Menlo Park, CA".to_owned(),
-///     };
-///
-///     // The type of `expected` is `serde_json::Value`
-///     let expected = json!({
-///         "fingerprint": "0xF9BA143B95FF6D82",
-///         "location": "Menlo Park, CA",
-///     });
-///
-///     let v = serde_json::to_value(u).unwrap();
-///     assert_eq!(v, expected);
-///
-///     Ok(())
-/// }
-/// #
-/// # compare_json_values().unwrap();
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-///
-/// ```
-/// use std::collections::BTreeMap;
-///
-/// fn main() {
-///     // The keys in this map are vectors, not strings.
-///     let mut map = BTreeMap::new();
-///     map.insert(vec![32, 64], "x86");
-///
-///     println!("{}", serde_json::to_value(map).unwrap_err());
-/// }
-/// ```
-// Taking by value is more friendly to iterator adapters, option and result
-// consumers, etc. See https://github.com/serde-rs/json/pull/149.
-pub fn to_value<T>(value: T) -> Result<Value, Error>
-where
-    T: Serialize,
-{
-    value.serialize(Serializer)
-}
-
-/// Interpret a `serde_json::Value` as an instance of type `T`.
-///
-/// # Example
-///
-/// ```
-/// use serde::Deserialize;
-/// use serde_json::json;
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn main() {
-///     // The type of `j` is `serde_json::Value`
-///     let j = json!({
-///         "fingerprint": "0xF9BA143B95FF6D82",
-///         "location": "Menlo Park, CA"
-///     });
-///
-///     let u: User = serde_json::from_value(j).unwrap();
-///     println!("{:#?}", u);
-/// }
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if the structure of the Value does not match the
-/// structure expected by `T`, for example if `T` is a struct type but the Value
-/// contains something other than a JSON map. It can also fail if the structure
-/// is correct but `T`'s implementation of `Deserialize` decides that something
-/// is wrong with the data, for example required struct fields are missing from
-/// the JSON map or some number is too big to fit in the expected primitive
-/// type.
-pub fn from_value<T>(value: Value) -> Result<T, Error>
-where
-    T: DeserializeOwned,
-{
-    T::deserialize(value)
-}
diff --git a/vendor/serde_json/src/value/partial_eq.rs b/vendor/serde_json/src/value/partial_eq.rs
deleted file mode 100644
index 46c1dbc..0000000
--- a/vendor/serde_json/src/value/partial_eq.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use super::Value;
-use alloc::string::String;
-
-fn eq_i64(value: &Value, other: i64) -> bool {
-    value.as_i64().map_or(false, |i| i == other)
-}
-
-fn eq_u64(value: &Value, other: u64) -> bool {
-    value.as_u64().map_or(false, |i| i == other)
-}
-
-fn eq_f32(value: &Value, other: f32) -> bool {
-    match value {
-        Value::Number(n) => n.as_f32().map_or(false, |i| i == other),
-        _ => false,
-    }
-}
-
-fn eq_f64(value: &Value, other: f64) -> bool {
-    value.as_f64().map_or(false, |i| i == other)
-}
-
-fn eq_bool(value: &Value, other: bool) -> bool {
-    value.as_bool().map_or(false, |i| i == other)
-}
-
-fn eq_str(value: &Value, other: &str) -> bool {
-    value.as_str().map_or(false, |i| i == other)
-}
-
-impl PartialEq<str> for Value {
-    fn eq(&self, other: &str) -> bool {
-        eq_str(self, other)
-    }
-}
-
-impl PartialEq<&str> for Value {
-    fn eq(&self, other: &&str) -> bool {
-        eq_str(self, *other)
-    }
-}
-
-impl PartialEq<Value> for str {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, self)
-    }
-}
-
-impl PartialEq<Value> for &str {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, *self)
-    }
-}
-
-impl PartialEq<String> for Value {
-    fn eq(&self, other: &String) -> bool {
-        eq_str(self, other.as_str())
-    }
-}
-
-impl PartialEq<Value> for String {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, self.as_str())
-    }
-}
-
-macro_rules! partialeq_numeric {
-    ($($eq:ident [$($ty:ty)*])*) => {
-        $($(
-            impl PartialEq<$ty> for Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(self, *other as _)
-                }
-            }
-
-            impl PartialEq<Value> for $ty {
-                fn eq(&self, other: &Value) -> bool {
-                    $eq(other, *self as _)
-                }
-            }
-
-            impl<'a> PartialEq<$ty> for &'a Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(*self, *other as _)
-                }
-            }
-
-            impl<'a> PartialEq<$ty> for &'a mut Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(*self, *other as _)
-                }
-            }
-        )*)*
-    }
-}
-
-partialeq_numeric! {
-    eq_i64[i8 i16 i32 i64 isize]
-    eq_u64[u8 u16 u32 u64 usize]
-    eq_f32[f32]
-    eq_f64[f64]
-    eq_bool[bool]
-}
diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs
deleted file mode 100644
index 835fa90..0000000
--- a/vendor/serde_json/src/value/ser.rs
+++ /dev/null
@@ -1,1053 +0,0 @@
-use crate::error::{Error, ErrorCode, Result};
-use crate::map::Map;
-use crate::value::{to_value, Value};
-use alloc::borrow::ToOwned;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::fmt::Display;
-use core::result;
-use serde::ser::{Impossible, Serialize};
-
-impl Serialize for Value {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
-    where
-        S: ::serde::Serializer,
-    {
-        match self {
-            Value::Null => serializer.serialize_unit(),
-            Value::Bool(b) => serializer.serialize_bool(*b),
-            Value::Number(n) => n.serialize(serializer),
-            Value::String(s) => serializer.serialize_str(s),
-            Value::Array(v) => v.serialize(serializer),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::Object(m) => {
-                use serde::ser::SerializeMap;
-                let mut map = tri!(serializer.serialize_map(Some(m.len())));
-                for (k, v) in m {
-                    tri!(map.serialize_entry(k, v));
-                }
-                map.end()
-            }
-        }
-    }
-}
-
-/// Serializer whose output is a `Value`.
-///
-/// This is the serializer that backs [`serde_json::to_value`][crate::to_value].
-/// Unlike the main serde_json serializer which goes from some serializable
-/// value of type `T` to JSON text, this one goes from `T` to
-/// `serde_json::Value`.
-///
-/// The `to_value` function is implementable as:
-///
-/// ```
-/// use serde::Serialize;
-/// use serde_json::{Error, Value};
-///
-/// pub fn to_value<T>(input: T) -> Result<Value, Error>
-/// where
-///     T: Serialize,
-/// {
-///     input.serialize(serde_json::value::Serializer)
-/// }
-/// ```
-pub struct Serializer;
-
-impl serde::Serializer for Serializer {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = SerializeVec;
-    type SerializeTuple = SerializeVec;
-    type SerializeTupleStruct = SerializeVec;
-    type SerializeTupleVariant = SerializeTupleVariant;
-    type SerializeMap = SerializeMap;
-    type SerializeStruct = SerializeMap;
-    type SerializeStructVariant = SerializeStructVariant;
-
-    #[inline]
-    fn serialize_bool(self, value: bool) -> Result<Value> {
-        Ok(Value::Bool(value))
-    }
-
-    #[inline]
-    fn serialize_i8(self, value: i8) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    #[inline]
-    fn serialize_i16(self, value: i16) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    #[inline]
-    fn serialize_i32(self, value: i32) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Value> {
-        Ok(Value::Number(value.into()))
-    }
-
-    fn serialize_i128(self, value: i128) -> Result<Value> {
-        #[cfg(feature = "arbitrary_precision")]
-        {
-            Ok(Value::Number(value.into()))
-        }
-
-        #[cfg(not(feature = "arbitrary_precision"))]
-        {
-            if let Ok(value) = u64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else if let Ok(value) = i64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else {
-                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
-            }
-        }
-    }
-
-    #[inline]
-    fn serialize_u8(self, value: u8) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u16(self, value: u16) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u32(self, value: u32) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u64(self, value: u64) -> Result<Value> {
-        Ok(Value::Number(value.into()))
-    }
-
-    fn serialize_u128(self, value: u128) -> Result<Value> {
-        #[cfg(feature = "arbitrary_precision")]
-        {
-            Ok(Value::Number(value.into()))
-        }
-
-        #[cfg(not(feature = "arbitrary_precision"))]
-        {
-            if let Ok(value) = u64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else {
-                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
-            }
-        }
-    }
-
-    #[inline]
-    fn serialize_f32(self, float: f32) -> Result<Value> {
-        Ok(Value::from(float))
-    }
-
-    #[inline]
-    fn serialize_f64(self, float: f64) -> Result<Value> {
-        Ok(Value::from(float))
-    }
-
-    #[inline]
-    fn serialize_char(self, value: char) -> Result<Value> {
-        let mut s = String::new();
-        s.push(value);
-        Ok(Value::String(s))
-    }
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        Ok(Value::String(value.to_owned()))
-    }
-
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
-        let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
-        Ok(Value::Array(vec))
-    }
-
-    #[inline]
-    fn serialize_unit(self) -> Result<Value> {
-        Ok(Value::Null)
-    }
-
-    #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<Value> {
-        self.serialize_str(variant)
-    }
-
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        let mut values = Map::new();
-        values.insert(String::from(variant), tri!(to_value(value)));
-        Ok(Value::Object(values))
-    }
-
-    #[inline]
-    fn serialize_none(self) -> Result<Value> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Ok(SerializeVec {
-            vec: Vec::with_capacity(len.unwrap_or(0)),
-        })
-    }
-
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Ok(SerializeTupleVariant {
-            name: String::from(variant),
-            vec: Vec::with_capacity(len),
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Ok(SerializeMap::Map {
-            map: Map::new(),
-            next_key: None,
-        })
-    }
-
-    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        match name {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }),
-            _ => self.serialize_map(Some(len)),
-        }
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Ok(SerializeStructVariant {
-            name: String::from(variant),
-            map: Map::new(),
-        })
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Display,
-    {
-        Ok(Value::String(value.to_string()))
-    }
-}
-
-pub struct SerializeVec {
-    vec: Vec<Value>,
-}
-
-pub struct SerializeTupleVariant {
-    name: String,
-    vec: Vec<Value>,
-}
-
-pub enum SerializeMap {
-    Map {
-        map: Map<String, Value>,
-        next_key: Option<String>,
-    },
-    #[cfg(feature = "arbitrary_precision")]
-    Number { out_value: Option<Value> },
-    #[cfg(feature = "raw_value")]
-    RawValue { out_value: Option<Value> },
-}
-
-pub struct SerializeStructVariant {
-    name: String,
-    map: Map<String, Value>,
-}
-
-impl serde::ser::SerializeSeq for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.vec.push(tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        Ok(Value::Array(self.vec))
-    }
-}
-
-impl serde::ser::SerializeTuple for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        serde::ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value> {
-        serde::ser::SerializeSeq::end(self)
-    }
-}
-
-impl serde::ser::SerializeTupleStruct for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        serde::ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value> {
-        serde::ser::SerializeSeq::end(self)
-    }
-}
-
-impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.vec.push(tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        let mut object = Map::new();
-
-        object.insert(self.name, Value::Array(self.vec));
-
-        Ok(Value::Object(object))
-    }
-}
-
-impl serde::ser::SerializeMap for SerializeMap {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { next_key, .. } => {
-                *next_key = Some(tri!(key.serialize(MapKeySerializer)));
-                Ok(())
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { map, next_key } => {
-                let key = next_key.take();
-                // Panic because this indicates a bug in the program rather than an
-                // expected failure.
-                let key = key.expect("serialize_value called before serialize_key");
-                map.insert(key, tri!(to_value(value)));
-                Ok(())
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    fn end(self) -> Result<Value> {
-        match self {
-            SerializeMap::Map { map, .. } => Ok(Value::Object(map)),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-struct MapKeySerializer;
-
-fn key_must_be_a_string() -> Error {
-    Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
-}
-
-fn float_key_must_be_finite() -> Error {
-    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
-}
-
-impl serde::Serializer for MapKeySerializer {
-    type Ok = String;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<String, Error>;
-    type SerializeTuple = Impossible<String, Error>;
-    type SerializeTupleStruct = Impossible<String, Error>;
-    type SerializeTupleVariant = Impossible<String, Error>;
-    type SerializeMap = Impossible<String, Error>;
-    type SerializeStruct = Impossible<String, Error>;
-    type SerializeStructVariant = Impossible<String, Error>;
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<String> {
-        Ok(variant.to_owned())
-    }
-
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_bool(self, value: bool) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
-    }
-
-    #[inline]
-    fn serialize_char(self, value: char) -> Result<String> {
-        Ok({
-            let mut s = String::new();
-            s.push(value);
-            s
-        })
-    }
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<String> {
-        Ok(value.to_owned())
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit(self) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_none(self) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<String>
-    where
-        T: ?Sized + Display,
-    {
-        Ok(value.to_string())
-    }
-}
-
-impl serde::ser::SerializeStruct for SerializeMap {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { out_value } => {
-                if key == crate::number::TOKEN {
-                    *out_value = Some(tri!(value.serialize(NumberValueEmitter)));
-                    Ok(())
-                } else {
-                    Err(invalid_number())
-                }
-            }
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { out_value } => {
-                if key == crate::raw::TOKEN {
-                    *out_value = Some(tri!(value.serialize(RawValueEmitter)));
-                    Ok(())
-                } else {
-                    Err(invalid_raw_value())
-                }
-            }
-        }
-    }
-
-    fn end(self) -> Result<Value> {
-        match self {
-            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { out_value, .. } => {
-                Ok(out_value.expect("number value was not emitted"))
-            }
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { out_value, .. } => {
-                Ok(out_value.expect("raw value was not emitted"))
-            }
-        }
-    }
-}
-
-impl serde::ser::SerializeStructVariant for SerializeStructVariant {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.map.insert(String::from(key), tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        let mut object = Map::new();
-
-        object.insert(self.name, Value::Object(self.map));
-
-        Ok(Value::Object(object))
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-struct NumberValueEmitter;
-
-#[cfg(feature = "arbitrary_precision")]
-fn invalid_number() -> Error {
-    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
-}
-
-#[cfg(feature = "arbitrary_precision")]
-impl serde::ser::Serializer for NumberValueEmitter {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<Value, Error>;
-    type SerializeTuple = Impossible<Value, Error>;
-    type SerializeTupleStruct = Impossible<Value, Error>;
-    type SerializeTupleVariant = Impossible<Value, Error>;
-    type SerializeMap = Impossible<Value, Error>;
-    type SerializeStruct = Impossible<Value, Error>;
-    type SerializeStructVariant = Impossible<Value, Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_char(self, _v: char) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        let n = tri!(value.to_owned().parse());
-        Ok(Value::Number(n))
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_none(self) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit(self) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(invalid_number())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(invalid_number())
-    }
-}
-
-#[cfg(feature = "raw_value")]
-struct RawValueEmitter;
-
-#[cfg(feature = "raw_value")]
-fn invalid_raw_value() -> Error {
-    Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0)
-}
-
-#[cfg(feature = "raw_value")]
-impl serde::ser::Serializer for RawValueEmitter {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<Value, Error>;
-    type SerializeTuple = Impossible<Value, Error>;
-    type SerializeTupleStruct = Impossible<Value, Error>;
-    type SerializeTupleVariant = Impossible<Value, Error>;
-    type SerializeMap = Impossible<Value, Error>;
-    type SerializeStruct = Impossible<Value, Error>;
-    type SerializeStructVariant = Impossible<Value, Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_char(self, _v: char) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        crate::from_str(value)
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_none(self) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit(self) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(invalid_raw_value())
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
-    where
-        T: ?Sized + Display,
-    {
-        self.serialize_str(&value.to_string())
-    }
-}
diff --git a/vendor/serde_json/tests/compiletest.rs b/vendor/serde_json/tests/compiletest.rs
deleted file mode 100644
index 7974a62..0000000
--- a/vendor/serde_json/tests/compiletest.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[rustversion::attr(not(nightly), ignore)]
-#[cfg_attr(miri, ignore)]
-#[test]
-fn ui() {
-    let t = trybuild::TestCases::new();
-    t.compile_fail("tests/ui/*.rs");
-}
diff --git a/vendor/serde_json/tests/debug.rs b/vendor/serde_json/tests/debug.rs
deleted file mode 100644
index 8ddcf5a..0000000
--- a/vendor/serde_json/tests/debug.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use indoc::indoc;
-use serde_json::{json, Number, Value};
-
-#[test]
-fn number() {
-    assert_eq!(format!("{:?}", Number::from(1)), "Number(1)");
-    assert_eq!(format!("{:?}", Number::from(-1)), "Number(-1)");
-    assert_eq!(
-        format!("{:?}", Number::from_f64(1.0).unwrap()),
-        "Number(1.0)"
-    );
-}
-
-#[test]
-fn value_null() {
-    assert_eq!(format!("{:?}", json!(null)), "Null");
-}
-
-#[test]
-fn value_bool() {
-    assert_eq!(format!("{:?}", json!(true)), "Bool(true)");
-    assert_eq!(format!("{:?}", json!(false)), "Bool(false)");
-}
-
-#[test]
-fn value_number() {
-    assert_eq!(format!("{:?}", json!(1)), "Number(1)");
-    assert_eq!(format!("{:?}", json!(-1)), "Number(-1)");
-    assert_eq!(format!("{:?}", json!(1.0)), "Number(1.0)");
-    assert_eq!(Number::from_f64(1.0).unwrap().to_string(), "1.0"); // not just "1"
-    assert_eq!(Number::from_f64(12e40).unwrap().to_string(), "1.2e41");
-}
-
-#[test]
-fn value_string() {
-    assert_eq!(format!("{:?}", json!("s")), "String(\"s\")");
-}
-
-#[test]
-fn value_array() {
-    assert_eq!(format!("{:?}", json!([])), "Array []");
-}
-
-#[test]
-fn value_object() {
-    assert_eq!(format!("{:?}", json!({})), "Object {}");
-}
-
-#[test]
-fn error() {
-    let err = serde_json::from_str::<Value>("{0}").unwrap_err();
-    let expected = "Error(\"key must be a string\", line: 1, column: 2)";
-    assert_eq!(format!("{:?}", err), expected);
-}
-
-#[test]
-fn indented() {
-    let j = json!({
-        "Array": [true],
-        "Bool": true,
-        "EmptyArray": [],
-        "EmptyObject": {},
-        "Null": null,
-        "Number": 1,
-        "String": "...",
-    });
-    let expected = indoc! {r#"
-        Object {
-            "Array": Array [
-                Bool(true),
-            ],
-            "Bool": Bool(true),
-            "EmptyArray": Array [],
-            "EmptyObject": Object {},
-            "Null": Null,
-            "Number": Number(1),
-            "String": String("..."),
-        }"#
-    };
-    assert_eq!(format!("{:#?}", j), expected);
-}
diff --git a/vendor/serde_json/tests/lexical.rs b/vendor/serde_json/tests/lexical.rs
deleted file mode 100644
index 368c844..0000000
--- a/vendor/serde_json/tests/lexical.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![allow(
-    clippy::cast_lossless,
-    clippy::cast_possible_truncation,
-    clippy::cast_possible_wrap,
-    clippy::cast_precision_loss,
-    clippy::cast_sign_loss,
-    clippy::comparison_chain,
-    clippy::doc_markdown,
-    clippy::excessive_precision,
-    clippy::float_cmp,
-    clippy::if_not_else,
-    clippy::let_underscore_untyped,
-    clippy::module_name_repetitions,
-    clippy::needless_late_init,
-    clippy::shadow_unrelated,
-    clippy::similar_names,
-    clippy::single_match_else,
-    clippy::too_many_lines,
-    clippy::unreadable_literal,
-    clippy::unseparated_literal_suffix,
-    clippy::wildcard_imports
-)]
-
-extern crate alloc;
-
-#[path = "../src/lexical/mod.rs"]
-mod lexical;
-
-#[path = "lexical/algorithm.rs"]
-mod algorithm;
-
-#[path = "lexical/exponent.rs"]
-mod exponent;
-
-#[path = "lexical/float.rs"]
-mod float;
-
-#[path = "lexical/math.rs"]
-mod math;
-
-#[path = "lexical/num.rs"]
-mod num;
-
-#[path = "lexical/parse.rs"]
-mod parse;
-
-#[path = "lexical/rounding.rs"]
-mod rounding;
diff --git a/vendor/serde_json/tests/lexical/algorithm.rs b/vendor/serde_json/tests/lexical/algorithm.rs
deleted file mode 100644
index 7f3a2c6..0000000
--- a/vendor/serde_json/tests/lexical/algorithm.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::algorithm::*;
-use crate::lexical::num::Float;
-
-#[test]
-fn float_fast_path_test() {
-    // valid
-    let mantissa = (1 << f32::MANTISSA_SIZE) - 1;
-    let (min_exp, max_exp) = f32::exponent_limit();
-    for exp in min_exp..=max_exp {
-        let f = fast_path::<f32>(mantissa, exp);
-        assert!(f.is_some(), "should be valid {:?}.", (mantissa, exp));
-    }
-
-    // Check slightly above valid exponents
-    let f = fast_path::<f32>(123, 15);
-    assert_eq!(f, Some(1.23e+17));
-
-    // Exponent is 1 too high, pushes over the mantissa.
-    let f = fast_path::<f32>(123, 16);
-    assert!(f.is_none());
-
-    // Mantissa is too large, checked_mul should overflow.
-    let f = fast_path::<f32>(mantissa, 11);
-    assert!(f.is_none());
-
-    // invalid exponents
-    let (min_exp, max_exp) = f32::exponent_limit();
-    let f = fast_path::<f32>(mantissa, min_exp - 1);
-    assert!(f.is_none(), "exponent under min_exp");
-
-    let f = fast_path::<f32>(mantissa, max_exp + 1);
-    assert!(f.is_none(), "exponent above max_exp");
-}
-
-#[test]
-fn double_fast_path_test() {
-    // valid
-    let mantissa = (1 << f64::MANTISSA_SIZE) - 1;
-    let (min_exp, max_exp) = f64::exponent_limit();
-    for exp in min_exp..=max_exp {
-        let f = fast_path::<f64>(mantissa, exp);
-        assert!(f.is_some(), "should be valid {:?}.", (mantissa, exp));
-    }
-
-    // invalid exponents
-    let (min_exp, max_exp) = f64::exponent_limit();
-    let f = fast_path::<f64>(mantissa, min_exp - 1);
-    assert!(f.is_none(), "exponent under min_exp");
-
-    let f = fast_path::<f64>(mantissa, max_exp + 1);
-    assert!(f.is_none(), "exponent above max_exp");
-
-    assert_eq!(
-        Some(0.04628372940652459),
-        fast_path::<f64>(4628372940652459, -17)
-    );
-    assert_eq!(None, fast_path::<f64>(26383446160308229, -272));
-}
-
-#[test]
-fn moderate_path_test() {
-    let (f, valid) = moderate_path::<f64>(1234567890, -1, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.0);
-
-    let (f, valid) = moderate_path::<f64>(1234567891, -1, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.1);
-
-    let (f, valid) = moderate_path::<f64>(12345678912, -2, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.12);
-
-    let (f, valid) = moderate_path::<f64>(123456789123, -3, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.123);
-
-    let (f, valid) = moderate_path::<f64>(1234567891234, -4, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.1234);
-
-    let (f, valid) = moderate_path::<f64>(12345678912345, -5, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.12345);
-
-    let (f, valid) = moderate_path::<f64>(123456789123456, -6, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.123456);
-
-    let (f, valid) = moderate_path::<f64>(1234567891234567, -7, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.1234567);
-
-    let (f, valid) = moderate_path::<f64>(12345678912345679, -8, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 123456789.12345679);
-
-    let (f, valid) = moderate_path::<f64>(4628372940652459, -17, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 0.04628372940652459);
-
-    let (f, valid) = moderate_path::<f64>(26383446160308229, -272, false);
-    assert!(valid, "should be valid");
-    assert_eq!(f.into_float::<f64>(), 2.6383446160308229e-256);
-
-    let (_, valid) = moderate_path::<f64>(26383446160308230, -272, false);
-    assert!(!valid, "should be invalid");
-}
diff --git a/vendor/serde_json/tests/lexical/exponent.rs b/vendor/serde_json/tests/lexical/exponent.rs
deleted file mode 100644
index f7a847b..0000000
--- a/vendor/serde_json/tests/lexical/exponent.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::exponent::*;
-
-#[test]
-fn scientific_exponent_test() {
-    // 0 digits in the integer
-    assert_eq!(scientific_exponent(0, 0, 5), -6);
-    assert_eq!(scientific_exponent(10, 0, 5), 4);
-    assert_eq!(scientific_exponent(-10, 0, 5), -16);
-
-    // >0 digits in the integer
-    assert_eq!(scientific_exponent(0, 1, 5), 0);
-    assert_eq!(scientific_exponent(0, 2, 5), 1);
-    assert_eq!(scientific_exponent(0, 2, 20), 1);
-    assert_eq!(scientific_exponent(10, 2, 20), 11);
-    assert_eq!(scientific_exponent(-10, 2, 20), -9);
-
-    // Underflow
-    assert_eq!(
-        scientific_exponent(i32::min_value(), 0, 0),
-        i32::min_value()
-    );
-    assert_eq!(
-        scientific_exponent(i32::min_value(), 0, 5),
-        i32::min_value()
-    );
-
-    // Overflow
-    assert_eq!(
-        scientific_exponent(i32::max_value(), 0, 0),
-        i32::max_value() - 1
-    );
-    assert_eq!(
-        scientific_exponent(i32::max_value(), 5, 0),
-        i32::max_value()
-    );
-}
-
-#[test]
-fn mantissa_exponent_test() {
-    assert_eq!(mantissa_exponent(10, 5, 0), 5);
-    assert_eq!(mantissa_exponent(0, 5, 0), -5);
-    assert_eq!(
-        mantissa_exponent(i32::max_value(), 5, 0),
-        i32::max_value() - 5
-    );
-    assert_eq!(mantissa_exponent(i32::max_value(), 0, 5), i32::max_value());
-    assert_eq!(mantissa_exponent(i32::min_value(), 5, 0), i32::min_value());
-    assert_eq!(
-        mantissa_exponent(i32::min_value(), 0, 5),
-        i32::min_value() + 5
-    );
-}
diff --git a/vendor/serde_json/tests/lexical/float.rs b/vendor/serde_json/tests/lexical/float.rs
deleted file mode 100644
index c87e7e1..0000000
--- a/vendor/serde_json/tests/lexical/float.rs
+++ /dev/null
@@ -1,581 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::float::ExtendedFloat;
-use crate::lexical::rounding::round_nearest_tie_even;
-use std::{f32, f64};
-
-// NORMALIZE
-
-fn check_normalize(mant: u64, exp: i32, shift: u32, r_mant: u64, r_exp: i32) {
-    let mut x = ExtendedFloat { mant, exp };
-    assert_eq!(x.normalize(), shift);
-    assert_eq!(
-        x,
-        ExtendedFloat {
-            mant: r_mant,
-            exp: r_exp
-        }
-    );
-}
-
-#[test]
-fn normalize_test() {
-    // F32
-    // 0
-    check_normalize(0, 0, 0, 0, 0);
-
-    // min value
-    check_normalize(1, -149, 63, 9223372036854775808, -212);
-
-    // 1.0e-40
-    check_normalize(71362, -149, 47, 10043308644012916736, -196);
-
-    // 1.0e-20
-    check_normalize(12379400, -90, 40, 13611294244890214400, -130);
-
-    // 1.0
-    check_normalize(8388608, -23, 40, 9223372036854775808, -63);
-
-    // 1e20
-    check_normalize(11368684, 43, 40, 12500000250510966784, 3);
-
-    // max value
-    check_normalize(16777213, 104, 40, 18446740775174668288, 64);
-
-    // F64
-
-    // min value
-    check_normalize(1, -1074, 63, 9223372036854775808, -1137);
-
-    // 1.0e-250
-    check_normalize(6448907850777164, -883, 11, 13207363278391631872, -894);
-
-    // 1.0e-150
-    check_normalize(7371020360979573, -551, 11, 15095849699286165504, -562);
-
-    // 1.0e-45
-    check_normalize(6427752177035961, -202, 11, 13164036458569648128, -213);
-
-    // 1.0e-40
-    check_normalize(4903985730770844, -185, 11, 10043362776618688512, -196);
-
-    // 1.0e-20
-    check_normalize(6646139978924579, -119, 11, 13611294676837537792, -130);
-
-    // 1.0
-    check_normalize(4503599627370496, -52, 11, 9223372036854775808, -63);
-
-    // 1e20
-    check_normalize(6103515625000000, 14, 11, 12500000000000000000, 3);
-
-    // 1e40
-    check_normalize(8271806125530277, 80, 11, 16940658945086007296, 69);
-
-    // 1e150
-    check_normalize(5503284107318959, 446, 11, 11270725851789228032, 435);
-
-    // 1e250
-    check_normalize(6290184345309700, 778, 11, 12882297539194265600, 767);
-
-    // max value
-    check_normalize(9007199254740991, 971, 11, 18446744073709549568, 960);
-}
-
-// ROUND
-
-fn check_round_to_f32(mant: u64, exp: i32, r_mant: u64, r_exp: i32) {
-    let mut x = ExtendedFloat { mant, exp };
-    x.round_to_native::<f32, _>(round_nearest_tie_even);
-    assert_eq!(
-        x,
-        ExtendedFloat {
-            mant: r_mant,
-            exp: r_exp
-        }
-    );
-}
-
-#[test]
-fn round_to_f32_test() {
-    // This is lossy, so some of these values are **slightly** rounded.
-
-    // underflow
-    check_round_to_f32(9223372036854775808, -213, 0, -149);
-
-    // min value
-    check_round_to_f32(9223372036854775808, -212, 1, -149);
-
-    // 1.0e-40
-    check_round_to_f32(10043308644012916736, -196, 71362, -149);
-
-    // 1.0e-20
-    check_round_to_f32(13611294244890214400, -130, 12379400, -90);
-
-    // 1.0
-    check_round_to_f32(9223372036854775808, -63, 8388608, -23);
-
-    // 1e20
-    check_round_to_f32(12500000250510966784, 3, 11368684, 43);
-
-    // max value
-    check_round_to_f32(18446740775174668288, 64, 16777213, 104);
-
-    // overflow
-    check_round_to_f32(18446740775174668288, 65, 16777213, 105);
-}
-
-fn check_round_to_f64(mant: u64, exp: i32, r_mant: u64, r_exp: i32) {
-    let mut x = ExtendedFloat { mant, exp };
-    x.round_to_native::<f64, _>(round_nearest_tie_even);
-    assert_eq!(
-        x,
-        ExtendedFloat {
-            mant: r_mant,
-            exp: r_exp
-        }
-    );
-}
-
-#[test]
-fn round_to_f64_test() {
-    // This is lossy, so some of these values are **slightly** rounded.
-
-    // underflow
-    check_round_to_f64(9223372036854775808, -1138, 0, -1074);
-
-    // min value
-    check_round_to_f64(9223372036854775808, -1137, 1, -1074);
-
-    // 1.0e-250
-    check_round_to_f64(15095849699286165504, -562, 7371020360979573, -551);
-
-    // 1.0e-150
-    check_round_to_f64(15095849699286165504, -562, 7371020360979573, -551);
-
-    // 1.0e-45
-    check_round_to_f64(13164036458569648128, -213, 6427752177035961, -202);
-
-    // 1.0e-40
-    check_round_to_f64(10043362776618688512, -196, 4903985730770844, -185);
-
-    // 1.0e-20
-    check_round_to_f64(13611294676837537792, -130, 6646139978924579, -119);
-
-    // 1.0
-    check_round_to_f64(9223372036854775808, -63, 4503599627370496, -52);
-
-    // 1e20
-    check_round_to_f64(12500000000000000000, 3, 6103515625000000, 14);
-
-    // 1e40
-    check_round_to_f64(16940658945086007296, 69, 8271806125530277, 80);
-
-    // 1e150
-    check_round_to_f64(11270725851789228032, 435, 5503284107318959, 446);
-
-    // 1e250
-    check_round_to_f64(12882297539194265600, 767, 6290184345309700, 778);
-
-    // max value
-    check_round_to_f64(18446744073709549568, 960, 9007199254740991, 971);
-
-    // Bug fixes
-    // 1.2345e-308
-    check_round_to_f64(10234494226754558294, -1086, 2498655817078750, -1074);
-}
-
-fn assert_normalized_eq(mut x: ExtendedFloat, mut y: ExtendedFloat) {
-    x.normalize();
-    y.normalize();
-    assert_eq!(x, y);
-}
-
-#[test]
-fn from_float() {
-    let values: [f32; 26] = [
-        1e-40, 2e-40, 1e-35, 2e-35, 1e-30, 2e-30, 1e-25, 2e-25, 1e-20, 2e-20, 1e-15, 2e-15, 1e-10,
-        2e-10, 1e-5, 2e-5, 1.0, 2.0, 1e5, 2e5, 1e10, 2e10, 1e15, 2e15, 1e20, 2e20,
-    ];
-    for value in &values {
-        assert_normalized_eq(
-            ExtendedFloat::from_float(*value),
-            ExtendedFloat::from_float(*value as f64),
-        );
-    }
-}
-
-// TO
-
-// Sample of interesting numbers to check during standard test builds.
-const INTEGERS: [u64; 32] = [
-    0,                    // 0x0
-    1,                    // 0x1
-    7,                    // 0x7
-    15,                   // 0xF
-    112,                  // 0x70
-    119,                  // 0x77
-    127,                  // 0x7F
-    240,                  // 0xF0
-    247,                  // 0xF7
-    255,                  // 0xFF
-    2032,                 // 0x7F0
-    2039,                 // 0x7F7
-    2047,                 // 0x7FF
-    4080,                 // 0xFF0
-    4087,                 // 0xFF7
-    4095,                 // 0xFFF
-    65520,                // 0xFFF0
-    65527,                // 0xFFF7
-    65535,                // 0xFFFF
-    1048560,              // 0xFFFF0
-    1048567,              // 0xFFFF7
-    1048575,              // 0xFFFFF
-    16777200,             // 0xFFFFF0
-    16777207,             // 0xFFFFF7
-    16777215,             // 0xFFFFFF
-    268435440,            // 0xFFFFFF0
-    268435447,            // 0xFFFFFF7
-    268435455,            // 0xFFFFFFF
-    4294967280,           // 0xFFFFFFF0
-    4294967287,           // 0xFFFFFFF7
-    4294967295,           // 0xFFFFFFFF
-    18446744073709551615, // 0xFFFFFFFFFFFFFFFF
-];
-
-#[test]
-fn to_f32_test() {
-    // underflow
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -213,
-    };
-    assert_eq!(x.into_float::<f32>(), 0.0);
-
-    // min value
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -212,
-    };
-    assert_eq!(x.into_float::<f32>(), 1e-45);
-
-    // 1.0e-40
-    let x = ExtendedFloat {
-        mant: 10043308644012916736,
-        exp: -196,
-    };
-    assert_eq!(x.into_float::<f32>(), 1e-40);
-
-    // 1.0e-20
-    let x = ExtendedFloat {
-        mant: 13611294244890214400,
-        exp: -130,
-    };
-    assert_eq!(x.into_float::<f32>(), 1e-20);
-
-    // 1.0
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -63,
-    };
-    assert_eq!(x.into_float::<f32>(), 1.0);
-
-    // 1e20
-    let x = ExtendedFloat {
-        mant: 12500000250510966784,
-        exp: 3,
-    };
-    assert_eq!(x.into_float::<f32>(), 1e20);
-
-    // max value
-    let x = ExtendedFloat {
-        mant: 18446740775174668288,
-        exp: 64,
-    };
-    assert_eq!(x.into_float::<f32>(), 3.402823e38);
-
-    // almost max, high exp
-    let x = ExtendedFloat {
-        mant: 1048575,
-        exp: 108,
-    };
-    assert_eq!(x.into_float::<f32>(), 3.4028204e38);
-
-    // max value + 1
-    let x = ExtendedFloat {
-        mant: 16777216,
-        exp: 104,
-    };
-    assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
-    // max value + 1
-    let x = ExtendedFloat {
-        mant: 1048576,
-        exp: 108,
-    };
-    assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
-    // 1e40
-    let x = ExtendedFloat {
-        mant: 16940658945086007296,
-        exp: 69,
-    };
-    assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
-    // Integers.
-    for int in &INTEGERS {
-        let fp = ExtendedFloat { mant: *int, exp: 0 };
-        assert_eq!(fp.into_float::<f32>(), *int as f32, "{:?} as f32", *int);
-    }
-}
-
-#[test]
-fn to_f64_test() {
-    // underflow
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -1138,
-    };
-    assert_eq!(x.into_float::<f64>(), 0.0);
-
-    // min value
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -1137,
-    };
-    assert_eq!(x.into_float::<f64>(), 5e-324);
-
-    // 1.0e-250
-    let x = ExtendedFloat {
-        mant: 13207363278391631872,
-        exp: -894,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e-250);
-
-    // 1.0e-150
-    let x = ExtendedFloat {
-        mant: 15095849699286165504,
-        exp: -562,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e-150);
-
-    // 1.0e-45
-    let x = ExtendedFloat {
-        mant: 13164036458569648128,
-        exp: -213,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e-45);
-
-    // 1.0e-40
-    let x = ExtendedFloat {
-        mant: 10043362776618688512,
-        exp: -196,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e-40);
-
-    // 1.0e-20
-    let x = ExtendedFloat {
-        mant: 13611294676837537792,
-        exp: -130,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e-20);
-
-    // 1.0
-    let x = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -63,
-    };
-    assert_eq!(x.into_float::<f64>(), 1.0);
-
-    // 1e20
-    let x = ExtendedFloat {
-        mant: 12500000000000000000,
-        exp: 3,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e20);
-
-    // 1e40
-    let x = ExtendedFloat {
-        mant: 16940658945086007296,
-        exp: 69,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e40);
-
-    // 1e150
-    let x = ExtendedFloat {
-        mant: 11270725851789228032,
-        exp: 435,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e150);
-
-    // 1e250
-    let x = ExtendedFloat {
-        mant: 12882297539194265600,
-        exp: 767,
-    };
-    assert_eq!(x.into_float::<f64>(), 1e250);
-
-    // max value
-    let x = ExtendedFloat {
-        mant: 9007199254740991,
-        exp: 971,
-    };
-    assert_eq!(x.into_float::<f64>(), 1.7976931348623157e308);
-
-    // max value
-    let x = ExtendedFloat {
-        mant: 18446744073709549568,
-        exp: 960,
-    };
-    assert_eq!(x.into_float::<f64>(), 1.7976931348623157e308);
-
-    // overflow
-    let x = ExtendedFloat {
-        mant: 9007199254740992,
-        exp: 971,
-    };
-    assert_eq!(x.into_float::<f64>(), f64::INFINITY);
-
-    // overflow
-    let x = ExtendedFloat {
-        mant: 18446744073709549568,
-        exp: 961,
-    };
-    assert_eq!(x.into_float::<f64>(), f64::INFINITY);
-
-    // Underflow
-    // Adapted from failures in strtod.
-    let x = ExtendedFloat {
-        exp: -1139,
-        mant: 18446744073709550712,
-    };
-    assert_eq!(x.into_float::<f64>(), 0.0);
-
-    let x = ExtendedFloat {
-        exp: -1139,
-        mant: 18446744073709551460,
-    };
-    assert_eq!(x.into_float::<f64>(), 0.0);
-
-    let x = ExtendedFloat {
-        exp: -1138,
-        mant: 9223372036854776103,
-    };
-    assert_eq!(x.into_float::<f64>(), 5e-324);
-
-    // Integers.
-    for int in &INTEGERS {
-        let fp = ExtendedFloat { mant: *int, exp: 0 };
-        assert_eq!(fp.into_float::<f64>(), *int as f64, "{:?} as f64", *int);
-    }
-}
-
-// OPERATIONS
-
-fn check_mul(a: ExtendedFloat, b: ExtendedFloat, c: ExtendedFloat) {
-    let r = a.mul(&b);
-    assert_eq!(r, c);
-}
-
-#[test]
-fn mul_test() {
-    // Normalized (64-bit mantissa)
-    let a = ExtendedFloat {
-        mant: 13164036458569648128,
-        exp: -213,
-    };
-    let b = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -62,
-    };
-    let c = ExtendedFloat {
-        mant: 6582018229284824064,
-        exp: -211,
-    };
-    check_mul(a, b, c);
-
-    // Check with integers
-    // 64-bit mantissa
-    let mut a = ExtendedFloat { mant: 10, exp: 0 };
-    let mut b = ExtendedFloat { mant: 10, exp: 0 };
-    a.normalize();
-    b.normalize();
-    assert_eq!(a.mul(&b).into_float::<f64>(), 100.0);
-
-    // Check both values need high bits set.
-    let a = ExtendedFloat {
-        mant: 1 << 32,
-        exp: -31,
-    };
-    let b = ExtendedFloat {
-        mant: 1 << 32,
-        exp: -31,
-    };
-    assert_eq!(a.mul(&b).into_float::<f64>(), 4.0);
-
-    // Check both values need high bits set.
-    let a = ExtendedFloat {
-        mant: 10 << 31,
-        exp: -31,
-    };
-    let b = ExtendedFloat {
-        mant: 10 << 31,
-        exp: -31,
-    };
-    assert_eq!(a.mul(&b).into_float::<f64>(), 100.0);
-}
-
-fn check_imul(mut a: ExtendedFloat, b: ExtendedFloat, c: ExtendedFloat) {
-    a.imul(&b);
-    assert_eq!(a, c);
-}
-
-#[test]
-fn imul_test() {
-    // Normalized (64-bit mantissa)
-    let a = ExtendedFloat {
-        mant: 13164036458569648128,
-        exp: -213,
-    };
-    let b = ExtendedFloat {
-        mant: 9223372036854775808,
-        exp: -62,
-    };
-    let c = ExtendedFloat {
-        mant: 6582018229284824064,
-        exp: -211,
-    };
-    check_imul(a, b, c);
-
-    // Check with integers
-    // 64-bit mantissa
-    let mut a = ExtendedFloat { mant: 10, exp: 0 };
-    let mut b = ExtendedFloat { mant: 10, exp: 0 };
-    a.normalize();
-    b.normalize();
-    a.imul(&b);
-    assert_eq!(a.into_float::<f64>(), 100.0);
-
-    // Check both values need high bits set.
-    let mut a = ExtendedFloat {
-        mant: 1 << 32,
-        exp: -31,
-    };
-    let b = ExtendedFloat {
-        mant: 1 << 32,
-        exp: -31,
-    };
-    a.imul(&b);
-    assert_eq!(a.into_float::<f64>(), 4.0);
-
-    // Check both values need high bits set.
-    let mut a = ExtendedFloat {
-        mant: 10 << 31,
-        exp: -31,
-    };
-    let b = ExtendedFloat {
-        mant: 10 << 31,
-        exp: -31,
-    };
-    a.imul(&b);
-    assert_eq!(a.into_float::<f64>(), 100.0);
-}
diff --git a/vendor/serde_json/tests/lexical/math.rs b/vendor/serde_json/tests/lexical/math.rs
deleted file mode 100644
index 79d3ef3..0000000
--- a/vendor/serde_json/tests/lexical/math.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::math::{Limb, Math};
-use std::cmp;
-
-#[derive(Clone, Default)]
-struct Bigint {
-    data: Vec<Limb>,
-}
-
-impl Math for Bigint {
-    fn data(&self) -> &Vec<Limb> {
-        &self.data
-    }
-
-    fn data_mut(&mut self) -> &mut Vec<Limb> {
-        &mut self.data
-    }
-}
-
-#[cfg(limb_width_32)]
-pub(crate) fn from_u32(x: &[u32]) -> Vec<Limb> {
-    x.iter().cloned().collect()
-}
-
-#[cfg(limb_width_64)]
-pub(crate) fn from_u32(x: &[u32]) -> Vec<Limb> {
-    let mut v = Vec::<Limb>::default();
-    for xi in x.chunks(2) {
-        match xi.len() {
-            1 => v.push(xi[0] as u64),
-            2 => v.push(((xi[1] as u64) << 32) | (xi[0] as u64)),
-            _ => unreachable!(),
-        }
-    }
-
-    v
-}
-
-#[test]
-fn compare_test() {
-    // Simple
-    let x = Bigint {
-        data: from_u32(&[1]),
-    };
-    let y = Bigint {
-        data: from_u32(&[2]),
-    };
-    assert_eq!(x.compare(&y), cmp::Ordering::Less);
-    assert_eq!(x.compare(&x), cmp::Ordering::Equal);
-    assert_eq!(y.compare(&x), cmp::Ordering::Greater);
-
-    // Check asymmetric
-    let x = Bigint {
-        data: from_u32(&[5, 1]),
-    };
-    let y = Bigint {
-        data: from_u32(&[2]),
-    };
-    assert_eq!(x.compare(&y), cmp::Ordering::Greater);
-    assert_eq!(x.compare(&x), cmp::Ordering::Equal);
-    assert_eq!(y.compare(&x), cmp::Ordering::Less);
-
-    // Check when we use reverse ordering properly.
-    let x = Bigint {
-        data: from_u32(&[5, 1, 9]),
-    };
-    let y = Bigint {
-        data: from_u32(&[6, 2, 8]),
-    };
-    assert_eq!(x.compare(&y), cmp::Ordering::Greater);
-    assert_eq!(x.compare(&x), cmp::Ordering::Equal);
-    assert_eq!(y.compare(&x), cmp::Ordering::Less);
-
-    // Complex scenario, check it properly uses reverse ordering.
-    let x = Bigint {
-        data: from_u32(&[0, 1, 9]),
-    };
-    let y = Bigint {
-        data: from_u32(&[4294967295, 0, 9]),
-    };
-    assert_eq!(x.compare(&y), cmp::Ordering::Greater);
-    assert_eq!(x.compare(&x), cmp::Ordering::Equal);
-    assert_eq!(y.compare(&x), cmp::Ordering::Less);
-}
-
-#[test]
-fn hi64_test() {
-    assert_eq!(Bigint::from_u64(0xA).hi64(), (0xA000000000000000, false));
-    assert_eq!(Bigint::from_u64(0xAB).hi64(), (0xAB00000000000000, false));
-    assert_eq!(
-        Bigint::from_u64(0xAB00000000).hi64(),
-        (0xAB00000000000000, false)
-    );
-    assert_eq!(
-        Bigint::from_u64(0xA23456789A).hi64(),
-        (0xA23456789A000000, false)
-    );
-}
-
-#[test]
-fn bit_length_test() {
-    let x = Bigint {
-        data: from_u32(&[0, 0, 0, 1]),
-    };
-    assert_eq!(x.bit_length(), 97);
-
-    let x = Bigint {
-        data: from_u32(&[0, 0, 0, 3]),
-    };
-    assert_eq!(x.bit_length(), 98);
-
-    let x = Bigint {
-        data: from_u32(&[1 << 31]),
-    };
-    assert_eq!(x.bit_length(), 32);
-}
-
-#[test]
-fn iadd_small_test() {
-    // Overflow check (single)
-    // This should set all the internal data values to 0, the top
-    // value to (1<<31), and the bottom value to (4>>1).
-    // This is because the max_value + 1 leads to all 0s, we set the
-    // topmost bit to 1.
-    let mut x = Bigint {
-        data: from_u32(&[4294967295]),
-    };
-    x.iadd_small(5);
-    assert_eq!(x.data, from_u32(&[4, 1]));
-
-    // No overflow, single value
-    let mut x = Bigint {
-        data: from_u32(&[5]),
-    };
-    x.iadd_small(7);
-    assert_eq!(x.data, from_u32(&[12]));
-
-    // Single carry, internal overflow
-    let mut x = Bigint::from_u64(0x80000000FFFFFFFF);
-    x.iadd_small(7);
-    assert_eq!(x.data, from_u32(&[6, 0x80000001]));
-
-    // Double carry, overflow
-    let mut x = Bigint::from_u64(0xFFFFFFFFFFFFFFFF);
-    x.iadd_small(7);
-    assert_eq!(x.data, from_u32(&[6, 0, 1]));
-}
-
-#[test]
-fn imul_small_test() {
-    // No overflow check, 1-int.
-    let mut x = Bigint {
-        data: from_u32(&[5]),
-    };
-    x.imul_small(7);
-    assert_eq!(x.data, from_u32(&[35]));
-
-    // No overflow check, 2-ints.
-    let mut x = Bigint::from_u64(0x4000000040000);
-    x.imul_small(5);
-    assert_eq!(x.data, from_u32(&[0x00140000, 0x140000]));
-
-    // Overflow, 1 carry.
-    let mut x = Bigint {
-        data: from_u32(&[0x33333334]),
-    };
-    x.imul_small(5);
-    assert_eq!(x.data, from_u32(&[4, 1]));
-
-    // Overflow, 1 carry, internal.
-    let mut x = Bigint::from_u64(0x133333334);
-    x.imul_small(5);
-    assert_eq!(x.data, from_u32(&[4, 6]));
-
-    // Overflow, 2 carries.
-    let mut x = Bigint::from_u64(0x3333333333333334);
-    x.imul_small(5);
-    assert_eq!(x.data, from_u32(&[4, 0, 1]));
-}
-
-#[test]
-fn shl_test() {
-    // Pattern generated via `''.join(["1" +"0"*i for i in range(20)])`
-    let mut big = Bigint {
-        data: from_u32(&[0xD2210408]),
-    };
-    big.ishl(5);
-    assert_eq!(big.data, from_u32(&[0x44208100, 0x1A]));
-    big.ishl(32);
-    assert_eq!(big.data, from_u32(&[0, 0x44208100, 0x1A]));
-    big.ishl(27);
-    assert_eq!(big.data, from_u32(&[0, 0, 0xD2210408]));
-
-    // 96-bits of previous pattern
-    let mut big = Bigint {
-        data: from_u32(&[0x20020010, 0x8040100, 0xD2210408]),
-    };
-    big.ishl(5);
-    assert_eq!(big.data, from_u32(&[0x400200, 0x802004, 0x44208101, 0x1A]));
-    big.ishl(32);
-    assert_eq!(
-        big.data,
-        from_u32(&[0, 0x400200, 0x802004, 0x44208101, 0x1A])
-    );
-    big.ishl(27);
-    assert_eq!(
-        big.data,
-        from_u32(&[0, 0, 0x20020010, 0x8040100, 0xD2210408])
-    );
-}
diff --git a/vendor/serde_json/tests/lexical/num.rs b/vendor/serde_json/tests/lexical/num.rs
deleted file mode 100644
index 1a94be0..0000000
--- a/vendor/serde_json/tests/lexical/num.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::num::{AsPrimitive, Float, Integer, Number};
-
-fn check_as_primitive<T: AsPrimitive>(t: T) {
-    let _: u32 = t.as_u32();
-    let _: u64 = t.as_u64();
-    let _: u128 = t.as_u128();
-    let _: usize = t.as_usize();
-    let _: f32 = t.as_f32();
-    let _: f64 = t.as_f64();
-}
-
-#[test]
-fn as_primitive_test() {
-    check_as_primitive(1u32);
-    check_as_primitive(1u64);
-    check_as_primitive(1u128);
-    check_as_primitive(1usize);
-    check_as_primitive(1f32);
-    check_as_primitive(1f64);
-}
-
-fn check_number<T: Number>(x: T, y: T) {
-    // Copy, partialeq, partialord
-    let _ = x;
-    assert!(x < y);
-    assert!(x != y);
-
-    // Operations
-    let _ = y + x;
-
-    // Conversions already tested.
-}
-
-#[test]
-fn number_test() {
-    check_number(1u32, 5);
-    check_number(1u64, 5);
-    check_number(1u128, 5);
-    check_number(1usize, 5);
-    check_number(1f32, 5.0);
-    check_number(1f64, 5.0);
-}
-
-fn check_integer<T: Integer>(x: T) {
-    // Bitwise operations
-    let _ = x & T::ZERO;
-}
-
-#[test]
-fn integer_test() {
-    check_integer(65u32);
-    check_integer(65u64);
-    check_integer(65u128);
-    check_integer(65usize);
-}
-
-fn check_float<T: Float>(x: T) {
-    // Check functions
-    let _ = x.pow10(5);
-    let _ = x.to_bits();
-    assert!(T::from_bits(x.to_bits()) == x);
-
-    // Check properties
-    let _ = x.to_bits() & T::SIGN_MASK;
-    let _ = x.to_bits() & T::EXPONENT_MASK;
-    let _ = x.to_bits() & T::HIDDEN_BIT_MASK;
-    let _ = x.to_bits() & T::MANTISSA_MASK;
-}
-
-#[test]
-fn float_test() {
-    check_float(123f32);
-    check_float(123f64);
-}
diff --git a/vendor/serde_json/tests/lexical/parse.rs b/vendor/serde_json/tests/lexical/parse.rs
deleted file mode 100644
index 03ec1a9..0000000
--- a/vendor/serde_json/tests/lexical/parse.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::num::Float;
-use crate::lexical::{parse_concise_float, parse_truncated_float};
-use core::f64;
-use core::fmt::Debug;
-
-fn check_concise_float<F>(mantissa: u64, exponent: i32, expected: F)
-where
-    F: Float + Debug,
-{
-    assert_eq!(parse_concise_float::<F>(mantissa, exponent), expected);
-}
-
-fn check_truncated_float<F>(integer: &str, fraction: &str, exponent: i32, expected: F)
-where
-    F: Float + Debug,
-{
-    let integer = integer.as_bytes();
-    let fraction = fraction.as_bytes();
-    assert_eq!(
-        parse_truncated_float::<F>(integer, fraction, exponent),
-        expected,
-    );
-}
-
-#[test]
-fn parse_f32_test() {
-    check_concise_float(0, 0, 0.0_f32);
-    check_concise_float(12345, -4, 1.2345_f32);
-    check_concise_float(12345, -3, 12.345_f32);
-    check_concise_float(123456789, -4, 12345.6789_f32);
-    check_concise_float(12345, 6, 1.2345e10_f32);
-    check_concise_float(12345, -42, 1.2345e-38_f32);
-
-    // Check expected rounding, using borderline cases.
-    // Round-down, halfway
-    check_concise_float(16777216, 0, 16777216.0_f32);
-    check_concise_float(16777217, 0, 16777216.0_f32);
-    check_concise_float(16777218, 0, 16777218.0_f32);
-    check_concise_float(33554432, 0, 33554432.0_f32);
-    check_concise_float(33554434, 0, 33554432.0_f32);
-    check_concise_float(33554436, 0, 33554436.0_f32);
-    check_concise_float(17179869184, 0, 17179869184.0_f32);
-    check_concise_float(17179870208, 0, 17179869184.0_f32);
-    check_concise_float(17179871232, 0, 17179871232.0_f32);
-
-    // Round-up, halfway
-    check_concise_float(16777218, 0, 16777218.0_f32);
-    check_concise_float(16777219, 0, 16777220.0_f32);
-    check_concise_float(16777220, 0, 16777220.0_f32);
-
-    check_concise_float(33554436, 0, 33554436.0_f32);
-    check_concise_float(33554438, 0, 33554440.0_f32);
-    check_concise_float(33554440, 0, 33554440.0_f32);
-
-    check_concise_float(17179871232, 0, 17179871232.0_f32);
-    check_concise_float(17179872256, 0, 17179873280.0_f32);
-    check_concise_float(17179873280, 0, 17179873280.0_f32);
-
-    // Round-up, above halfway
-    check_concise_float(33554435, 0, 33554436.0_f32);
-    check_concise_float(17179870209, 0, 17179871232.0_f32);
-
-    // Check exactly halfway, round-up at halfway
-    check_truncated_float("1", "00000017881393432617187499", 0, 1.0000001_f32);
-    check_truncated_float("1", "000000178813934326171875", 0, 1.0000002_f32);
-    check_truncated_float("1", "00000017881393432617187501", 0, 1.0000002_f32);
-}
-
-#[test]
-fn parse_f64_test() {
-    check_concise_float(0, 0, 0.0_f64);
-    check_concise_float(12345, -4, 1.2345_f64);
-    check_concise_float(12345, -3, 12.345_f64);
-    check_concise_float(123456789, -4, 12345.6789_f64);
-    check_concise_float(12345, 6, 1.2345e10_f64);
-    check_concise_float(12345, -312, 1.2345e-308_f64);
-
-    // Check expected rounding, using borderline cases.
-    // Round-down, halfway
-    check_concise_float(9007199254740992, 0, 9007199254740992.0_f64);
-    check_concise_float(9007199254740993, 0, 9007199254740992.0_f64);
-    check_concise_float(9007199254740994, 0, 9007199254740994.0_f64);
-
-    check_concise_float(18014398509481984, 0, 18014398509481984.0_f64);
-    check_concise_float(18014398509481986, 0, 18014398509481984.0_f64);
-    check_concise_float(18014398509481988, 0, 18014398509481988.0_f64);
-
-    check_concise_float(9223372036854775808, 0, 9223372036854775808.0_f64);
-    check_concise_float(9223372036854776832, 0, 9223372036854775808.0_f64);
-    check_concise_float(9223372036854777856, 0, 9223372036854777856.0_f64);
-
-    check_truncated_float(
-        "11417981541647679048466287755595961091061972992",
-        "",
-        0,
-        11417981541647679048466287755595961091061972992.0_f64,
-    );
-    check_truncated_float(
-        "11417981541647680316116887983825362587765178368",
-        "",
-        0,
-        11417981541647679048466287755595961091061972992.0_f64,
-    );
-    check_truncated_float(
-        "11417981541647681583767488212054764084468383744",
-        "",
-        0,
-        11417981541647681583767488212054764084468383744.0_f64,
-    );
-
-    // Round-up, halfway
-    check_concise_float(9007199254740994, 0, 9007199254740994.0_f64);
-    check_concise_float(9007199254740995, 0, 9007199254740996.0_f64);
-    check_concise_float(9007199254740996, 0, 9007199254740996.0_f64);
-
-    check_concise_float(18014398509481988, 0, 18014398509481988.0_f64);
-    check_concise_float(18014398509481990, 0, 18014398509481992.0_f64);
-    check_concise_float(18014398509481992, 0, 18014398509481992.0_f64);
-
-    check_concise_float(9223372036854777856, 0, 9223372036854777856.0_f64);
-    check_concise_float(9223372036854778880, 0, 9223372036854779904.0_f64);
-    check_concise_float(9223372036854779904, 0, 9223372036854779904.0_f64);
-
-    check_truncated_float(
-        "11417981541647681583767488212054764084468383744",
-        "",
-        0,
-        11417981541647681583767488212054764084468383744.0_f64,
-    );
-    check_truncated_float(
-        "11417981541647682851418088440284165581171589120",
-        "",
-        0,
-        11417981541647684119068688668513567077874794496.0_f64,
-    );
-    check_truncated_float(
-        "11417981541647684119068688668513567077874794496",
-        "",
-        0,
-        11417981541647684119068688668513567077874794496.0_f64,
-    );
-
-    // Round-up, above halfway
-    check_concise_float(9223372036854776833, 0, 9223372036854777856.0_f64);
-    check_truncated_float(
-        "11417981541647680316116887983825362587765178369",
-        "",
-        0,
-        11417981541647681583767488212054764084468383744.0_f64,
-    );
-
-    // Rounding error
-    // Adapted from failures in strtod.
-    check_concise_float(22250738585072014, -324, 2.2250738585072014e-308_f64);
-    check_truncated_float("2", "2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187499", -308, 2.225073858507201e-308_f64);
-    check_truncated_float("2", "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303962110687008643869459464552765720740782062174337998814106326732925355228688137214901298112245145188984905722230728525513315575501591439747639798341180199932396254828901710708185069063066665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028407889577179615094551674824347103070260914462157228988025818254518032570701886087211312807951223342628836862232150377566662250398253433597456888442390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042756718644338377048603786162277173854562306587467901408672332763671875", -308, 2.2250738585072014e-308_f64);
-    check_truncated_float("2", "2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187501", -308, 2.2250738585072014e-308_f64);
-    check_truncated_float("179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791", "9999999999999999999999999999999999999999999999999999999999999999999999", 0, 1.7976931348623157e+308_f64);
-    check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984374999", -324, 5.0e-324_f64);
-    check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375", -324, 1.0e-323_f64);
-    check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375001", -324, 1.0e-323_f64);
-    check_truncated_float("", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024703282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772285886546332835517796989819938739800539093906315035659515570226392290858392449105184435931802849936536152500319370457678249219365623669863658480757001585769269903706311928279558551332927834338409351978015531246597263579574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324673600968951340535537458516661134223766678604162159680461914467291840300530057530849048765391711386591646239524912623653881879636239373280423891018672348497668235089863388587925628302755995657524455507255189313690836254779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125", 0, 0.0_f64);
-
-    // Rounding error
-    // Adapted from:
-    //  https://www.exploringbinary.com/how-glibc-strtod-works/
-    check_truncated_float("", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375", 0, 2.2250738585072011e-308_f64);
-
-    // Rounding error
-    // Adapted from test-parse-random failures.
-    check_concise_float(1009, -31, 1.009e-28_f64);
-    check_concise_float(18294, 304, f64::INFINITY);
-
-    // Rounding error
-    // Adapted from a @dangrabcad's issue #20.
-    check_concise_float(7689539722041643, 149, 7.689539722041643e164_f64);
-    check_truncated_float("768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "", 0, 7.689539722041643e164_f64);
-    check_truncated_float("768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 7.689539722041643e164_f64);
-
-    // Check other cases similar to @dangrabcad's issue #20.
-    check_truncated_float("9223372036854776833", "0", 0, 9223372036854777856.0_f64);
-    check_truncated_float(
-        "11417981541647680316116887983825362587765178369",
-        "0",
-        0,
-        11417981541647681583767488212054764084468383744.0_f64,
-    );
-    check_concise_float(90071992547409950, -1, 9007199254740996.0_f64);
-    check_concise_float(180143985094819900, -1, 18014398509481992.0_f64);
-    check_truncated_float("9223372036854778880", "0", 0, 9223372036854779904.0_f64);
-    check_truncated_float(
-        "11417981541647682851418088440284165581171589120",
-        "0",
-        0,
-        11417981541647684119068688668513567077874794496.0_f64,
-    );
-
-    // Check other cases ostensibly identified via proptest.
-    check_truncated_float("71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
-    check_truncated_float("126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
-    check_truncated_float("38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
-}
diff --git a/vendor/serde_json/tests/lexical/rounding.rs b/vendor/serde_json/tests/lexical/rounding.rs
deleted file mode 100644
index 7ea1771..0000000
--- a/vendor/serde_json/tests/lexical/rounding.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::float::ExtendedFloat;
-use crate::lexical::num::Float;
-use crate::lexical::rounding::*;
-
-// MASKS
-
-#[test]
-fn lower_n_mask_test() {
-    assert_eq!(lower_n_mask(0u64), 0b0);
-    assert_eq!(lower_n_mask(1u64), 0b1);
-    assert_eq!(lower_n_mask(2u64), 0b11);
-    assert_eq!(lower_n_mask(10u64), 0b1111111111);
-    assert_eq!(lower_n_mask(32u64), 0b11111111111111111111111111111111);
-}
-
-#[test]
-fn lower_n_halfway_test() {
-    assert_eq!(lower_n_halfway(0u64), 0b0);
-    assert_eq!(lower_n_halfway(1u64), 0b1);
-    assert_eq!(lower_n_halfway(2u64), 0b10);
-    assert_eq!(lower_n_halfway(10u64), 0b1000000000);
-    assert_eq!(lower_n_halfway(32u64), 0b10000000000000000000000000000000);
-}
-
-#[test]
-fn nth_bit_test() {
-    assert_eq!(nth_bit(0u64), 0b1);
-    assert_eq!(nth_bit(1u64), 0b10);
-    assert_eq!(nth_bit(2u64), 0b100);
-    assert_eq!(nth_bit(10u64), 0b10000000000);
-    assert_eq!(nth_bit(31u64), 0b10000000000000000000000000000000);
-}
-
-#[test]
-fn internal_n_mask_test() {
-    assert_eq!(internal_n_mask(1u64, 0u64), 0b0);
-    assert_eq!(internal_n_mask(1u64, 1u64), 0b1);
-    assert_eq!(internal_n_mask(2u64, 1u64), 0b10);
-    assert_eq!(internal_n_mask(4u64, 2u64), 0b1100);
-    assert_eq!(internal_n_mask(10u64, 2u64), 0b1100000000);
-    assert_eq!(internal_n_mask(10u64, 4u64), 0b1111000000);
-    assert_eq!(
-        internal_n_mask(32u64, 4u64),
-        0b11110000000000000000000000000000
-    );
-}
-
-// NEAREST ROUNDING
-
-#[test]
-fn round_nearest_test() {
-    // Check exactly halfway (b'1100000')
-    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
-    let (above, halfway) = round_nearest(&mut fp, 6);
-    assert!(!above);
-    assert!(halfway);
-    assert_eq!(fp.mant, 1);
-
-    // Check above halfway (b'1100001')
-    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
-    let (above, halfway) = round_nearest(&mut fp, 6);
-    assert!(above);
-    assert!(!halfway);
-    assert_eq!(fp.mant, 1);
-
-    // Check below halfway (b'1011111')
-    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
-    let (above, halfway) = round_nearest(&mut fp, 6);
-    assert!(!above);
-    assert!(!halfway);
-    assert_eq!(fp.mant, 1);
-}
-
-// DIRECTED ROUNDING
-
-#[test]
-fn round_downward_test() {
-    // b0000000
-    let mut fp = ExtendedFloat { mant: 0x00, exp: 0 };
-    round_downward(&mut fp, 6);
-    assert_eq!(fp.mant, 0);
-
-    // b1000000
-    let mut fp = ExtendedFloat { mant: 0x40, exp: 0 };
-    round_downward(&mut fp, 6);
-    assert_eq!(fp.mant, 1);
-
-    // b1100000
-    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
-    round_downward(&mut fp, 6);
-    assert_eq!(fp.mant, 1);
-
-    // b1110000
-    let mut fp = ExtendedFloat { mant: 0x70, exp: 0 };
-    round_downward(&mut fp, 6);
-    assert_eq!(fp.mant, 1);
-}
-
-#[test]
-fn round_nearest_tie_even_test() {
-    // Check round-up, halfway
-    let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 2);
-
-    // Check round-down, halfway
-    let mut fp = ExtendedFloat { mant: 0x20, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 0);
-
-    // Check round-up, above halfway
-    let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 2);
-
-    let mut fp = ExtendedFloat { mant: 0x21, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 1);
-
-    // Check round-down, below halfway
-    let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 1);
-
-    let mut fp = ExtendedFloat { mant: 0x1F, exp: 0 };
-    round_nearest_tie_even(&mut fp, 6);
-    assert_eq!(fp.mant, 0);
-}
-
-// HIGH-LEVEL
-
-#[test]
-fn round_to_float_test() {
-    // Denormal
-    let mut fp = ExtendedFloat {
-        mant: 1 << 63,
-        exp: f64::DENORMAL_EXPONENT - 15,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 48);
-    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);
-
-    // Halfway, round-down (b'1000000000000000000000000000000000000000000000000000010000000000')
-    let mut fp = ExtendedFloat {
-        mant: 0x8000000000000400,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 52);
-    assert_eq!(fp.exp, -52);
-
-    // Halfway, round-up (b'1000000000000000000000000000000000000000000000000000110000000000')
-    let mut fp = ExtendedFloat {
-        mant: 0x8000000000000C00,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 2);
-    assert_eq!(fp.exp, -52);
-
-    // Above halfway
-    let mut fp = ExtendedFloat {
-        mant: 0x8000000000000401,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 1);
-    assert_eq!(fp.exp, -52);
-
-    let mut fp = ExtendedFloat {
-        mant: 0x8000000000000C01,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 2);
-    assert_eq!(fp.exp, -52);
-
-    // Below halfway
-    let mut fp = ExtendedFloat {
-        mant: 0x80000000000003FF,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 52);
-    assert_eq!(fp.exp, -52);
-
-    let mut fp = ExtendedFloat {
-        mant: 0x8000000000000BFF,
-        exp: -63,
-    };
-    round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 1);
-    assert_eq!(fp.exp, -52);
-}
-
-#[test]
-fn avoid_overflow_test() {
-    // Avoid overflow, fails by 1
-    let mut fp = ExtendedFloat {
-        mant: 0xFFFFFFFFFFFF,
-        exp: f64::MAX_EXPONENT + 5,
-    };
-    avoid_overflow::<f64>(&mut fp);
-    assert_eq!(fp.mant, 0xFFFFFFFFFFFF);
-    assert_eq!(fp.exp, f64::MAX_EXPONENT + 5);
-
-    // Avoid overflow, succeeds
-    let mut fp = ExtendedFloat {
-        mant: 0xFFFFFFFFFFFF,
-        exp: f64::MAX_EXPONENT + 4,
-    };
-    avoid_overflow::<f64>(&mut fp);
-    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
-    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);
-}
-
-#[test]
-fn round_to_native_test() {
-    // Overflow
-    let mut fp = ExtendedFloat {
-        mant: 0xFFFFFFFFFFFF,
-        exp: f64::MAX_EXPONENT + 4,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
-    assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);
-
-    // Need denormal
-    let mut fp = ExtendedFloat {
-        mant: 1,
-        exp: f64::DENORMAL_EXPONENT + 48,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 48);
-    assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);
-
-    // Halfway, round-down (b'10000000000000000000000000000000000000000000000000000100000')
-    let mut fp = ExtendedFloat {
-        mant: 0x400000000000020,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 52);
-    assert_eq!(fp.exp, -52);
-
-    // Halfway, round-up (b'10000000000000000000000000000000000000000000000000001100000')
-    let mut fp = ExtendedFloat {
-        mant: 0x400000000000060,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 2);
-    assert_eq!(fp.exp, -52);
-
-    // Above halfway
-    let mut fp = ExtendedFloat {
-        mant: 0x400000000000021,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 1);
-    assert_eq!(fp.exp, -52);
-
-    let mut fp = ExtendedFloat {
-        mant: 0x400000000000061,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 2);
-    assert_eq!(fp.exp, -52);
-
-    // Below halfway
-    let mut fp = ExtendedFloat {
-        mant: 0x40000000000001F,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1 << 52);
-    assert_eq!(fp.exp, -52);
-
-    let mut fp = ExtendedFloat {
-        mant: 0x40000000000005F,
-        exp: -58,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, (1 << 52) + 1);
-    assert_eq!(fp.exp, -52);
-
-    // Underflow
-    // Adapted from failures in strtod.
-    let mut fp = ExtendedFloat {
-        exp: -1139,
-        mant: 18446744073709550712,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 0);
-    assert_eq!(fp.exp, 0);
-
-    let mut fp = ExtendedFloat {
-        exp: -1139,
-        mant: 18446744073709551460,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 0);
-    assert_eq!(fp.exp, 0);
-
-    let mut fp = ExtendedFloat {
-        exp: -1138,
-        mant: 9223372036854776103,
-    };
-    round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
-    assert_eq!(fp.mant, 1);
-    assert_eq!(fp.exp, -1074);
-}
diff --git a/vendor/serde_json/tests/macros/mod.rs b/vendor/serde_json/tests/macros/mod.rs
deleted file mode 100644
index aaf820f..0000000
--- a/vendor/serde_json/tests/macros/mod.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(unused_macro_rules)]
-
-macro_rules! json_str {
-    ([]) => {
-        "[]"
-    };
-    ([ $e0:tt $(, $e:tt)* $(,)? ]) => {
-        concat!("[",
-            json_str!($e0),
-            $(",", json_str!($e),)*
-        "]")
-    };
-    ({}) => {
-        "{}"
-    };
-    ({ $k0:tt : $v0:tt $(, $k:tt : $v:tt)* $(,)? }) => {
-        concat!("{",
-            stringify!($k0), ":", json_str!($v0),
-            $(",", stringify!($k), ":", json_str!($v),)*
-        "}")
-    };
-    (($other:tt)) => {
-        $other
-    };
-    ($other:tt) => {
-        stringify!($other)
-    };
-}
-
-macro_rules! pretty_str {
-    ($json:tt) => {
-        pretty_str_impl!("", $json)
-    };
-}
-
-macro_rules! pretty_str_impl {
-    ($indent:expr, []) => {
-        "[]"
-    };
-    ($indent:expr, [ $e0:tt $(, $e:tt)* $(,)? ]) => {
-        concat!("[\n  ",
-            $indent, pretty_str_impl!(concat!("  ", $indent), $e0),
-            $(",\n  ", $indent, pretty_str_impl!(concat!("  ", $indent), $e),)*
-        "\n", $indent, "]")
-    };
-    ($indent:expr, {}) => {
-        "{}"
-    };
-    ($indent:expr, { $k0:tt : $v0:tt $(, $k:tt : $v:tt)* $(,)? }) => {
-        concat!("{\n  ",
-            $indent, stringify!($k0), ": ", pretty_str_impl!(concat!("  ", $indent), $v0),
-            $(",\n  ", $indent, stringify!($k), ": ", pretty_str_impl!(concat!("  ", $indent), $v),)*
-        "\n", $indent, "}")
-    };
-    ($indent:expr, ($other:tt)) => {
-        $other
-    };
-    ($indent:expr, $other:tt) => {
-        stringify!($other)
-    };
-}
diff --git a/vendor/serde_json/tests/map.rs b/vendor/serde_json/tests/map.rs
deleted file mode 100644
index 538cd16..0000000
--- a/vendor/serde_json/tests/map.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use serde_json::{from_str, Map, Value};
-
-#[test]
-fn test_preserve_order() {
-    // Sorted order
-    #[cfg(not(feature = "preserve_order"))]
-    const EXPECTED: &[&str] = &["a", "b", "c"];
-
-    // Insertion order
-    #[cfg(feature = "preserve_order")]
-    const EXPECTED: &[&str] = &["b", "a", "c"];
-
-    let v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
-    let keys: Vec<_> = v.as_object().unwrap().keys().collect();
-    assert_eq!(keys, EXPECTED);
-}
-
-#[test]
-fn test_append() {
-    // Sorted order
-    #[cfg(not(feature = "preserve_order"))]
-    const EXPECTED: &[&str] = &["a", "b", "c"];
-
-    // Insertion order
-    #[cfg(feature = "preserve_order")]
-    const EXPECTED: &[&str] = &["b", "a", "c"];
-
-    let mut v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
-    let val = v.as_object_mut().unwrap();
-    let mut m = Map::new();
-    m.append(val);
-    let keys: Vec<_> = m.keys().collect();
-
-    assert_eq!(keys, EXPECTED);
-    assert!(val.is_empty());
-}
-
-#[test]
-fn test_retain() {
-    let mut v: Value = from_str(r#"{"b":null,"a":null,"c":null}"#).unwrap();
-    let val = v.as_object_mut().unwrap();
-    val.retain(|k, _| k.as_str() != "b");
-
-    let keys: Vec<_> = val.keys().collect();
-    assert_eq!(keys, &["a", "c"]);
-}
diff --git a/vendor/serde_json/tests/regression.rs b/vendor/serde_json/tests/regression.rs
deleted file mode 100644
index fb2b25c..0000000
--- a/vendor/serde_json/tests/regression.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod regression {
-    automod::dir!("tests/regression");
-}
diff --git a/vendor/serde_json/tests/regression/issue1004.rs b/vendor/serde_json/tests/regression/issue1004.rs
deleted file mode 100644
index c09fb96..0000000
--- a/vendor/serde_json/tests/regression/issue1004.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![cfg(feature = "arbitrary_precision")]
-
-#[test]
-fn test() {
-    let float = 5.55f32;
-    let value = serde_json::to_value(float).unwrap();
-    let json = serde_json::to_string(&value).unwrap();
-
-    // If the f32 were cast to f64 by Value before serialization, then this
-    // would incorrectly serialize as 5.550000190734863.
-    assert_eq!(json, "5.55");
-}
diff --git a/vendor/serde_json/tests/regression/issue520.rs b/vendor/serde_json/tests/regression/issue520.rs
deleted file mode 100644
index 9ed3677..0000000
--- a/vendor/serde_json/tests/regression/issue520.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(clippy::float_cmp)]
-
-use serde_derive::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type", content = "data")]
-enum E {
-    Float(f32),
-}
-
-#[test]
-fn test() {
-    let e = E::Float(159.1);
-    let v = serde_json::to_value(e).unwrap();
-    let e = serde_json::from_value::<E>(v).unwrap();
-
-    match e {
-        E::Float(f) => assert_eq!(f, 159.1),
-    }
-}
diff --git a/vendor/serde_json/tests/regression/issue795.rs b/vendor/serde_json/tests/regression/issue795.rs
deleted file mode 100644
index bb82852..0000000
--- a/vendor/serde_json/tests/regression/issue795.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(clippy::assertions_on_result_states)]
-
-use serde::de::{
-    Deserialize, Deserializer, EnumAccess, IgnoredAny, MapAccess, VariantAccess, Visitor,
-};
-use serde_json::json;
-use std::fmt;
-
-#[derive(Debug)]
-pub enum Enum {
-    Variant { x: u8 },
-}
-
-impl<'de> Deserialize<'de> for Enum {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct EnumVisitor;
-
-        impl<'de> Visitor<'de> for EnumVisitor {
-            type Value = Enum;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("enum Enum")
-            }
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                let (IgnoredAny, variant) = data.variant()?;
-                variant.struct_variant(&["x"], self)
-            }
-
-            fn visit_map<A>(self, mut data: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut x = 0;
-                if let Some((IgnoredAny, value)) = data.next_entry()? {
-                    x = value;
-                }
-                Ok(Enum::Variant { x })
-            }
-        }
-
-        deserializer.deserialize_enum("Enum", &["Variant"], EnumVisitor)
-    }
-}
-
-#[test]
-fn test() {
-    let s = r#" {"Variant":{"x":0,"y":0}} "#;
-    assert!(serde_json::from_str::<Enum>(s).is_err());
-
-    let j = json!({"Variant":{"x":0,"y":0}});
-    assert!(serde_json::from_value::<Enum>(j).is_err());
-}
diff --git a/vendor/serde_json/tests/regression/issue845.rs b/vendor/serde_json/tests/regression/issue845.rs
deleted file mode 100644
index e8b0c0f..0000000
--- a/vendor/serde_json/tests/regression/issue845.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-#![allow(clippy::trait_duplication_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/8757
-
-use serde::{Deserialize, Deserializer};
-use std::fmt::{self, Display};
-use std::marker::PhantomData;
-use std::str::FromStr;
-
-pub struct NumberVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<'de, T> serde::de::Visitor<'de> for NumberVisitor<T>
-where
-    T: TryFrom<u64> + TryFrom<i64> + FromStr,
-    <T as TryFrom<u64>>::Error: Display,
-    <T as TryFrom<i64>>::Error: Display,
-    <T as FromStr>::Err: Display,
-{
-    type Value = T;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("an integer or string")
-    }
-
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        T::try_from(v).map_err(serde::de::Error::custom)
-    }
-
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        T::try_from(v).map_err(serde::de::Error::custom)
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        v.parse().map_err(serde::de::Error::custom)
-    }
-}
-
-fn deserialize_integer_or_string<'de, D, T>(deserializer: D) -> Result<T, D::Error>
-where
-    D: Deserializer<'de>,
-    T: TryFrom<u64> + TryFrom<i64> + FromStr,
-    <T as TryFrom<u64>>::Error: Display,
-    <T as TryFrom<i64>>::Error: Display,
-    <T as FromStr>::Err: Display,
-{
-    deserializer.deserialize_any(NumberVisitor {
-        marker: PhantomData,
-    })
-}
-
-#[derive(Deserialize, Debug)]
-pub struct Struct {
-    #[serde(deserialize_with = "deserialize_integer_or_string")]
-    pub i: i64,
-}
-
-#[test]
-fn test() {
-    let j = r#" {"i":100} "#;
-    println!("{:?}", serde_json::from_str::<Struct>(j).unwrap());
-
-    let j = r#" {"i":"100"} "#;
-    println!("{:?}", serde_json::from_str::<Struct>(j).unwrap());
-}
diff --git a/vendor/serde_json/tests/regression/issue953.rs b/vendor/serde_json/tests/regression/issue953.rs
deleted file mode 100644
index 771aa52..0000000
--- a/vendor/serde_json/tests/regression/issue953.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use serde_json::Value;
-
-#[test]
-fn test() {
-    let x1 = serde_json::from_str::<Value>("18446744073709551615.");
-    assert!(x1.is_err());
-    let x2 = serde_json::from_str::<Value>("18446744073709551616.");
-    assert!(x2.is_err());
-}
diff --git a/vendor/serde_json/tests/stream.rs b/vendor/serde_json/tests/stream.rs
deleted file mode 100644
index ec6b9e3..0000000
--- a/vendor/serde_json/tests/stream.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-#![cfg(not(feature = "preserve_order"))]
-#![allow(clippy::assertions_on_result_states)]
-
-use serde_json::{json, Deserializer, Value};
-
-// Rustfmt issue https://github.com/rust-lang-nursery/rustfmt/issues/2740
-#[rustfmt::skip]
-macro_rules! test_stream {
-    ($data:expr, $ty:ty, |$stream:ident| $test:block) => {
-        {
-            let de = Deserializer::from_str($data);
-            let mut $stream = de.into_iter::<$ty>();
-            assert_eq!($stream.byte_offset(), 0);
-            $test
-        }
-        {
-            let de = Deserializer::from_slice($data.as_bytes());
-            let mut $stream = de.into_iter::<$ty>();
-            assert_eq!($stream.byte_offset(), 0);
-            $test
-        }
-        {
-            let mut bytes = $data.as_bytes();
-            let de = Deserializer::from_reader(&mut bytes);
-            let mut $stream = de.into_iter::<$ty>();
-            assert_eq!($stream.byte_offset(), 0);
-            $test
-        }
-    };
-}
-
-#[test]
-fn test_json_stream_newlines() {
-    let data = "{\"x\":39} {\"x\":40}{\"x\":41}\n{\"x\":42}";
-
-    test_stream!(data, Value, |stream| {
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 39);
-        assert_eq!(stream.byte_offset(), 8);
-
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
-        assert_eq!(stream.byte_offset(), 17);
-
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 41);
-        assert_eq!(stream.byte_offset(), 25);
-
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
-        assert_eq!(stream.byte_offset(), 34);
-
-        assert!(stream.next().is_none());
-        assert_eq!(stream.byte_offset(), 34);
-    });
-}
-
-#[test]
-fn test_json_stream_trailing_whitespaces() {
-    let data = "{\"x\":42} \t\n";
-
-    test_stream!(data, Value, |stream| {
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
-        assert_eq!(stream.byte_offset(), 8);
-
-        assert!(stream.next().is_none());
-        assert_eq!(stream.byte_offset(), 11);
-    });
-}
-
-#[test]
-fn test_json_stream_truncated() {
-    let data = "{\"x\":40}\n{\"x\":";
-
-    test_stream!(data, Value, |stream| {
-        assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
-        assert_eq!(stream.byte_offset(), 8);
-
-        assert!(stream.next().unwrap().unwrap_err().is_eof());
-        assert_eq!(stream.byte_offset(), 9);
-    });
-}
-
-#[test]
-fn test_json_stream_truncated_decimal() {
-    let data = "{\"x\":4.";
-
-    test_stream!(data, Value, |stream| {
-        assert!(stream.next().unwrap().unwrap_err().is_eof());
-        assert_eq!(stream.byte_offset(), 0);
-    });
-}
-
-#[test]
-fn test_json_stream_truncated_negative() {
-    let data = "{\"x\":-";
-
-    test_stream!(data, Value, |stream| {
-        assert!(stream.next().unwrap().unwrap_err().is_eof());
-        assert_eq!(stream.byte_offset(), 0);
-    });
-}
-
-#[test]
-fn test_json_stream_truncated_exponent() {
-    let data = "{\"x\":4e";
-
-    test_stream!(data, Value, |stream| {
-        assert!(stream.next().unwrap().unwrap_err().is_eof());
-        assert_eq!(stream.byte_offset(), 0);
-    });
-}
-
-#[test]
-fn test_json_stream_empty() {
-    let data = "";
-
-    test_stream!(data, Value, |stream| {
-        assert!(stream.next().is_none());
-        assert_eq!(stream.byte_offset(), 0);
-    });
-}
-
-#[test]
-fn test_json_stream_primitive() {
-    let data = "{} true{}1[]\nfalse\"hey\"2 ";
-
-    test_stream!(data, Value, |stream| {
-        assert_eq!(stream.next().unwrap().unwrap(), json!({}));
-        assert_eq!(stream.byte_offset(), 2);
-
-        assert_eq!(stream.next().unwrap().unwrap(), true);
-        assert_eq!(stream.byte_offset(), 7);
-
-        assert_eq!(stream.next().unwrap().unwrap(), json!({}));
-        assert_eq!(stream.byte_offset(), 9);
-
-        assert_eq!(stream.next().unwrap().unwrap(), 1);
-        assert_eq!(stream.byte_offset(), 10);
-
-        assert_eq!(stream.next().unwrap().unwrap(), json!([]));
-        assert_eq!(stream.byte_offset(), 12);
-
-        assert_eq!(stream.next().unwrap().unwrap(), false);
-        assert_eq!(stream.byte_offset(), 18);
-
-        assert_eq!(stream.next().unwrap().unwrap(), "hey");
-        assert_eq!(stream.byte_offset(), 23);
-
-        assert_eq!(stream.next().unwrap().unwrap(), 2);
-        assert_eq!(stream.byte_offset(), 24);
-
-        assert!(stream.next().is_none());
-        assert_eq!(stream.byte_offset(), 25);
-    });
-}
-
-#[test]
-fn test_json_stream_invalid_literal() {
-    let data = "truefalse";
-
-    test_stream!(data, Value, |stream| {
-        let second = stream.next().unwrap().unwrap_err();
-        assert_eq!(second.to_string(), "trailing characters at line 1 column 5");
-    });
-}
-
-#[test]
-fn test_json_stream_invalid_number() {
-    let data = "1true";
-
-    test_stream!(data, Value, |stream| {
-        let second = stream.next().unwrap().unwrap_err();
-        assert_eq!(second.to_string(), "trailing characters at line 1 column 2");
-    });
-}
-
-#[test]
-fn test_error() {
-    let data = "true wrong false";
-
-    test_stream!(data, Value, |stream| {
-        assert_eq!(stream.next().unwrap().unwrap(), true);
-        assert!(stream.next().unwrap().is_err());
-        assert!(stream.next().is_none());
-    });
-}
diff --git a/vendor/serde_json/tests/test.rs b/vendor/serde_json/tests/test.rs
deleted file mode 100644
index 05b7f86..0000000
--- a/vendor/serde_json/tests/test.rs
+++ /dev/null
@@ -1,2505 +0,0 @@
-#![cfg(not(feature = "preserve_order"))]
-#![allow(
-    clippy::assertions_on_result_states,
-    clippy::cast_precision_loss,
-    clippy::derive_partial_eq_without_eq,
-    clippy::excessive_precision,
-    clippy::float_cmp,
-    clippy::items_after_statements,
-    clippy::let_underscore_untyped,
-    clippy::shadow_unrelated,
-    clippy::too_many_lines,
-    clippy::unreadable_literal,
-    clippy::unseparated_literal_suffix,
-    clippy::vec_init_then_push,
-    clippy::zero_sized_map_values
-)]
-
-#[macro_use]
-mod macros;
-
-#[cfg(feature = "raw_value")]
-use ref_cast::RefCast;
-use serde::de::{self, IgnoredAny, IntoDeserializer};
-use serde::ser::{self, SerializeMap, SerializeSeq, Serializer};
-use serde::{Deserialize, Serialize};
-use serde_bytes::{ByteBuf, Bytes};
-#[cfg(feature = "raw_value")]
-use serde_json::value::RawValue;
-use serde_json::{
-    from_reader, from_slice, from_str, from_value, json, to_string, to_string_pretty, to_value,
-    to_vec, Deserializer, Number, Value,
-};
-use std::collections::BTreeMap;
-#[cfg(feature = "raw_value")]
-use std::collections::HashMap;
-use std::fmt::{self, Debug};
-use std::hash::BuildHasher;
-#[cfg(feature = "raw_value")]
-use std::hash::{Hash, Hasher};
-use std::io;
-use std::iter;
-use std::marker::PhantomData;
-use std::mem;
-use std::str::FromStr;
-use std::string::ToString;
-use std::{f32, f64};
-use std::{i16, i32, i64, i8};
-use std::{u16, u32, u64, u8};
-
-macro_rules! treemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($k:expr => $v:expr),+ $(,)?) => {
-        {
-            let mut m = BTreeMap::new();
-            $(
-                m.insert($k, $v);
-            )+
-            m
-        }
-    };
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-enum Animal {
-    Dog,
-    Frog(String, Vec<isize>),
-    Cat { age: usize, name: String },
-    AntHive(Vec<String>),
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-struct Inner {
-    a: (),
-    b: usize,
-    c: Vec<String>,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-struct Outer {
-    inner: Vec<Inner>,
-}
-
-fn test_encode_ok<T>(errors: &[(T, &str)])
-where
-    T: PartialEq + Debug + ser::Serialize,
-{
-    for &(ref value, out) in errors {
-        let out = out.to_string();
-
-        let s = to_string(value).unwrap();
-        assert_eq!(s, out);
-
-        let v = to_value(value).unwrap();
-        let s = to_string(&v).unwrap();
-        assert_eq!(s, out);
-    }
-}
-
-fn test_pretty_encode_ok<T>(errors: &[(T, &str)])
-where
-    T: PartialEq + Debug + ser::Serialize,
-{
-    for &(ref value, out) in errors {
-        let out = out.to_string();
-
-        let s = to_string_pretty(value).unwrap();
-        assert_eq!(s, out);
-
-        let v = to_value(value).unwrap();
-        let s = to_string_pretty(&v).unwrap();
-        assert_eq!(s, out);
-    }
-}
-
-#[test]
-fn test_write_null() {
-    let tests = &[((), "null")];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_u64() {
-    let tests = &[(3u64, "3"), (u64::MAX, &u64::MAX.to_string())];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_i64() {
-    let tests = &[
-        (3i64, "3"),
-        (-2i64, "-2"),
-        (-1234i64, "-1234"),
-        (i64::MIN, &i64::MIN.to_string()),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_f64() {
-    let tests = &[
-        (3.0, "3.0"),
-        (3.1, "3.1"),
-        (-1.5, "-1.5"),
-        (0.5, "0.5"),
-        (f64::MIN, "-1.7976931348623157e308"),
-        (f64::MAX, "1.7976931348623157e308"),
-        (f64::EPSILON, "2.220446049250313e-16"),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_encode_nonfinite_float_yields_null() {
-    let v = to_value(::std::f64::NAN.copysign(1.0)).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(::std::f64::NAN.copysign(-1.0)).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(::std::f64::INFINITY).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(-::std::f64::INFINITY).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(::std::f32::NAN.copysign(1.0)).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(::std::f32::NAN.copysign(-1.0)).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(::std::f32::INFINITY).unwrap();
-    assert!(v.is_null());
-
-    let v = to_value(-::std::f32::INFINITY).unwrap();
-    assert!(v.is_null());
-}
-
-#[test]
-fn test_write_str() {
-    let tests = &[("", "\"\""), ("foo", "\"foo\"")];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_bool() {
-    let tests = &[(true, "true"), (false, "false")];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_char() {
-    let tests = &[
-        ('n', "\"n\""),
-        ('"', "\"\\\"\""),
-        ('\\', "\"\\\\\""),
-        ('/', "\"/\""),
-        ('\x08', "\"\\b\""),
-        ('\x0C', "\"\\f\""),
-        ('\n', "\"\\n\""),
-        ('\r', "\"\\r\""),
-        ('\t', "\"\\t\""),
-        ('\x0B', "\"\\u000b\""),
-        ('\u{3A3}', "\"\u{3A3}\""),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_list() {
-    test_encode_ok(&[
-        (vec![], "[]"),
-        (vec![true], "[true]"),
-        (vec![true, false], "[true,false]"),
-    ]);
-
-    test_encode_ok(&[
-        (vec![vec![], vec![], vec![]], "[[],[],[]]"),
-        (vec![vec![1, 2, 3], vec![], vec![]], "[[1,2,3],[],[]]"),
-        (vec![vec![], vec![1, 2, 3], vec![]], "[[],[1,2,3],[]]"),
-        (vec![vec![], vec![], vec![1, 2, 3]], "[[],[],[1,2,3]]"),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (vec![vec![], vec![], vec![]], pretty_str!([[], [], []])),
-        (
-            vec![vec![1, 2, 3], vec![], vec![]],
-            pretty_str!([[1, 2, 3], [], []]),
-        ),
-        (
-            vec![vec![], vec![1, 2, 3], vec![]],
-            pretty_str!([[], [1, 2, 3], []]),
-        ),
-        (
-            vec![vec![], vec![], vec![1, 2, 3]],
-            pretty_str!([[], [], [1, 2, 3]]),
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (vec![], "[]"),
-        (vec![true], pretty_str!([true])),
-        (vec![true, false], pretty_str!([true, false])),
-    ]);
-
-    let long_test_list = json!([false, null, ["foo\nbar", 3.5]]);
-
-    test_encode_ok(&[(
-        long_test_list.clone(),
-        json_str!([false, null, ["foo\nbar", 3.5]]),
-    )]);
-
-    test_pretty_encode_ok(&[(
-        long_test_list,
-        pretty_str!([false, null, ["foo\nbar", 3.5]]),
-    )]);
-}
-
-#[test]
-fn test_write_object() {
-    test_encode_ok(&[
-        (treemap!(), "{}"),
-        (treemap!("a".to_string() => true), "{\"a\":true}"),
-        (
-            treemap!(
-                "a".to_string() => true,
-                "b".to_string() => false,
-            ),
-            "{\"a\":true,\"b\":false}",
-        ),
-    ]);
-
-    test_encode_ok(&[
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![],
-            ],
-            "{\"a\":{},\"b\":{},\"c\":{}}",
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![],
-            ],
-            "{\"a\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"b\":{},\"c\":{}}",
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-                "c".to_string() => treemap![],
-            ],
-            "{\"a\":{},\"b\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"c\":{}}",
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-            ],
-            "{\"a\":{},\"b\":{},\"c\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}}}",
-        ),
-    ]);
-
-    test_encode_ok(&[(treemap!['c' => ()], "{\"c\":null}")]);
-
-    test_pretty_encode_ok(&[
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![],
-            ],
-            pretty_str!({
-                "a": {},
-                "b": {},
-                "c": {}
-            }),
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![],
-            ],
-            pretty_str!({
-                "a": {
-                    "a": {
-                        "a": [
-                            1,
-                            2,
-                            3
-                        ]
-                    },
-                    "b": {},
-                    "c": {}
-                },
-                "b": {},
-                "c": {}
-            }),
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-                "c".to_string() => treemap![],
-            ],
-            pretty_str!({
-                "a": {},
-                "b": {
-                    "a": {
-                        "a": [
-                            1,
-                            2,
-                            3
-                        ]
-                    },
-                    "b": {},
-                    "c": {}
-                },
-                "c": {}
-            }),
-        ),
-        (
-            treemap![
-                "a".to_string() => treemap![],
-                "b".to_string() => treemap![],
-                "c".to_string() => treemap![
-                    "a".to_string() => treemap!["a" => vec![1,2,3]],
-                    "b".to_string() => treemap![],
-                    "c".to_string() => treemap![],
-                ],
-            ],
-            pretty_str!({
-                "a": {},
-                "b": {},
-                "c": {
-                    "a": {
-                        "a": [
-                            1,
-                            2,
-                            3
-                        ]
-                    },
-                    "b": {},
-                    "c": {}
-                }
-            }),
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (treemap!(), "{}"),
-        (
-            treemap!("a".to_string() => true),
-            pretty_str!({
-                "a": true
-            }),
-        ),
-        (
-            treemap!(
-                "a".to_string() => true,
-                "b".to_string() => false,
-            ),
-            pretty_str!( {
-                "a": true,
-                "b": false
-            }),
-        ),
-    ]);
-
-    let complex_obj = json!({
-        "b": [
-            {"c": "\x0c\x1f\r"},
-            {"d": ""}
-        ]
-    });
-
-    test_encode_ok(&[(
-        complex_obj.clone(),
-        json_str!({
-            "b": [
-                {
-                    "c": (r#""\f\u001f\r""#)
-                },
-                {
-                    "d": ""
-                }
-            ]
-        }),
-    )]);
-
-    test_pretty_encode_ok(&[(
-        complex_obj,
-        pretty_str!({
-            "b": [
-                {
-                    "c": (r#""\f\u001f\r""#)
-                },
-                {
-                    "d": ""
-                }
-            ]
-        }),
-    )]);
-}
-
-#[test]
-fn test_write_tuple() {
-    test_encode_ok(&[((5,), "[5]")]);
-
-    test_pretty_encode_ok(&[((5,), pretty_str!([5]))]);
-
-    test_encode_ok(&[((5, (6, "abc")), "[5,[6,\"abc\"]]")]);
-
-    test_pretty_encode_ok(&[((5, (6, "abc")), pretty_str!([5, [6, "abc"]]))]);
-}
-
-#[test]
-fn test_write_enum() {
-    test_encode_ok(&[
-        (Animal::Dog, "\"Dog\""),
-        (
-            Animal::Frog("Henry".to_string(), vec![]),
-            "{\"Frog\":[\"Henry\",[]]}",
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349]),
-            "{\"Frog\":[\"Henry\",[349]]}",
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-            "{\"Frog\":[\"Henry\",[349,102]]}",
-        ),
-        (
-            Animal::Cat {
-                age: 5,
-                name: "Kate".to_string(),
-            },
-            "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}",
-        ),
-        (
-            Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
-            "{\"AntHive\":[\"Bob\",\"Stuart\"]}",
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (Animal::Dog, "\"Dog\""),
-        (
-            Animal::Frog("Henry".to_string(), vec![]),
-            pretty_str!({
-                "Frog": [
-                    "Henry",
-                    []
-                ]
-            }),
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349]),
-            pretty_str!({
-                "Frog": [
-                    "Henry",
-                    [
-                        349
-                    ]
-                ]
-            }),
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-            pretty_str!({
-                "Frog": [
-                    "Henry",
-                    [
-                      349,
-                      102
-                    ]
-                ]
-            }),
-        ),
-    ]);
-}
-
-#[test]
-fn test_write_option() {
-    test_encode_ok(&[(None, "null"), (Some("jodhpurs"), "\"jodhpurs\"")]);
-
-    test_encode_ok(&[
-        (None, "null"),
-        (Some(vec!["foo", "bar"]), "[\"foo\",\"bar\"]"),
-    ]);
-
-    test_pretty_encode_ok(&[(None, "null"), (Some("jodhpurs"), "\"jodhpurs\"")]);
-
-    test_pretty_encode_ok(&[
-        (None, "null"),
-        (Some(vec!["foo", "bar"]), pretty_str!(["foo", "bar"])),
-    ]);
-}
-
-#[test]
-fn test_write_newtype_struct() {
-    #[derive(Serialize, PartialEq, Debug)]
-    struct Newtype(BTreeMap<String, i32>);
-
-    let inner = Newtype(treemap!(String::from("inner") => 123));
-    let outer = treemap!(String::from("outer") => to_value(&inner).unwrap());
-
-    test_encode_ok(&[(inner, r#"{"inner":123}"#)]);
-
-    test_encode_ok(&[(outer, r#"{"outer":{"inner":123}}"#)]);
-}
-
-#[test]
-fn test_deserialize_number_to_untagged_enum() {
-    #[derive(Eq, PartialEq, Deserialize, Debug)]
-    #[serde(untagged)]
-    enum E {
-        N(i64),
-    }
-
-    assert_eq!(E::N(0), E::deserialize(Number::from(0)).unwrap());
-}
-
-fn test_parse_ok<T>(tests: Vec<(&str, T)>)
-where
-    T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned,
-{
-    for (s, value) in tests {
-        let v: T = from_str(s).unwrap();
-        assert_eq!(v, value.clone());
-
-        let v: T = from_slice(s.as_bytes()).unwrap();
-        assert_eq!(v, value.clone());
-
-        // Make sure we can deserialize into a `Value`.
-        let json_value: Value = from_str(s).unwrap();
-        assert_eq!(json_value, to_value(&value).unwrap());
-
-        // Make sure we can deserialize from a `&Value`.
-        let v = T::deserialize(&json_value).unwrap();
-        assert_eq!(v, value);
-
-        // Make sure we can deserialize from a `Value`.
-        let v: T = from_value(json_value.clone()).unwrap();
-        assert_eq!(v, value);
-
-        // Make sure we can round trip back to `Value`.
-        let json_value2: Value = from_value(json_value.clone()).unwrap();
-        assert_eq!(json_value2, json_value);
-
-        // Make sure we can fully ignore.
-        let twoline = s.to_owned() + "\n3735928559";
-        let mut de = Deserializer::from_str(&twoline);
-        IgnoredAny::deserialize(&mut de).unwrap();
-        assert_eq!(0xDEAD_BEEF, u64::deserialize(&mut de).unwrap());
-
-        // Make sure every prefix is an EOF error, except that a prefix of a
-        // number may be a valid number.
-        if !json_value.is_number() {
-            for (i, _) in s.trim_end().char_indices() {
-                assert!(from_str::<Value>(&s[..i]).unwrap_err().is_eof());
-                assert!(from_str::<IgnoredAny>(&s[..i]).unwrap_err().is_eof());
-            }
-        }
-    }
-}
-
-// For testing representations that the deserializer accepts but the serializer
-// never generates. These do not survive a round-trip through Value.
-fn test_parse_unusual_ok<T>(tests: Vec<(&str, T)>)
-where
-    T: Clone + Debug + PartialEq + ser::Serialize + de::DeserializeOwned,
-{
-    for (s, value) in tests {
-        let v: T = from_str(s).unwrap();
-        assert_eq!(v, value.clone());
-
-        let v: T = from_slice(s.as_bytes()).unwrap();
-        assert_eq!(v, value.clone());
-    }
-}
-
-macro_rules! test_parse_err {
-    ($name:ident::<$($ty:ty),*>($arg:expr) => $expected:expr) => {
-        let actual = $name::<$($ty),*>($arg).unwrap_err().to_string();
-        assert_eq!(actual, $expected, "unexpected {} error", stringify!($name));
-    };
-}
-
-fn test_parse_err<T>(errors: &[(&str, &'static str)])
-where
-    T: Debug + PartialEq + de::DeserializeOwned,
-{
-    for &(s, err) in errors {
-        test_parse_err!(from_str::<T>(s) => err);
-        test_parse_err!(from_slice::<T>(s.as_bytes()) => err);
-    }
-}
-
-fn test_parse_slice_err<T>(errors: &[(&[u8], &'static str)])
-where
-    T: Debug + PartialEq + de::DeserializeOwned,
-{
-    for &(s, err) in errors {
-        test_parse_err!(from_slice::<T>(s) => err);
-    }
-}
-
-fn test_fromstr_parse_err<T>(errors: &[(&str, &'static str)])
-where
-    T: Debug + PartialEq + FromStr,
-    <T as FromStr>::Err: ToString,
-{
-    for &(s, err) in errors {
-        let actual = s.parse::<T>().unwrap_err().to_string();
-        assert_eq!(actual, err, "unexpected parsing error");
-    }
-}
-
-#[test]
-fn test_parse_null() {
-    test_parse_err::<()>(&[
-        ("n", "EOF while parsing a value at line 1 column 1"),
-        ("nul", "EOF while parsing a value at line 1 column 3"),
-        ("nulla", "trailing characters at line 1 column 5"),
-    ]);
-
-    test_parse_ok(vec![("null", ())]);
-}
-
-#[test]
-fn test_parse_bool() {
-    test_parse_err::<bool>(&[
-        ("t", "EOF while parsing a value at line 1 column 1"),
-        ("truz", "expected ident at line 1 column 4"),
-        ("f", "EOF while parsing a value at line 1 column 1"),
-        ("faz", "expected ident at line 1 column 3"),
-        ("truea", "trailing characters at line 1 column 5"),
-        ("falsea", "trailing characters at line 1 column 6"),
-    ]);
-
-    test_parse_ok(vec![
-        ("true", true),
-        (" true ", true),
-        ("false", false),
-        (" false ", false),
-    ]);
-}
-
-#[test]
-fn test_parse_char() {
-    test_parse_err::<char>(&[
-        (
-            "\"ab\"",
-            "invalid value: string \"ab\", expected a character at line 1 column 4",
-        ),
-        (
-            "10",
-            "invalid type: integer `10`, expected a character at line 1 column 2",
-        ),
-    ]);
-
-    test_parse_ok(vec![
-        ("\"n\"", 'n'),
-        ("\"\\\"\"", '"'),
-        ("\"\\\\\"", '\\'),
-        ("\"/\"", '/'),
-        ("\"\\b\"", '\x08'),
-        ("\"\\f\"", '\x0C'),
-        ("\"\\n\"", '\n'),
-        ("\"\\r\"", '\r'),
-        ("\"\\t\"", '\t'),
-        ("\"\\u000b\"", '\x0B'),
-        ("\"\\u000B\"", '\x0B'),
-        ("\"\u{3A3}\"", '\u{3A3}'),
-    ]);
-}
-
-#[test]
-fn test_parse_number_errors() {
-    test_parse_err::<f64>(&[
-        ("+", "expected value at line 1 column 1"),
-        (".", "expected value at line 1 column 1"),
-        ("-", "EOF while parsing a value at line 1 column 1"),
-        ("00", "invalid number at line 1 column 2"),
-        ("0x80", "trailing characters at line 1 column 2"),
-        ("\\0", "expected value at line 1 column 1"),
-        (".0", "expected value at line 1 column 1"),
-        ("0.", "EOF while parsing a value at line 1 column 2"),
-        ("1.", "EOF while parsing a value at line 1 column 2"),
-        ("1.a", "invalid number at line 1 column 3"),
-        ("1.e1", "invalid number at line 1 column 3"),
-        ("1e", "EOF while parsing a value at line 1 column 2"),
-        ("1e+", "EOF while parsing a value at line 1 column 3"),
-        ("1a", "trailing characters at line 1 column 2"),
-        (
-            "100e777777777777777777777777777",
-            "number out of range at line 1 column 14",
-        ),
-        (
-            "-100e777777777777777777777777777",
-            "number out of range at line 1 column 15",
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000", // 1e309
-            "number out of range at line 1 column 310",
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             .0e9", // 1e309
-            "number out of range at line 1 column 305",
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             e9", // 1e309
-            "number out of range at line 1 column 303",
-        ),
-    ]);
-}
-
-#[test]
-fn test_parse_i64() {
-    test_parse_ok(vec![
-        ("-2", -2),
-        ("-1234", -1234),
-        (" -1234 ", -1234),
-        (&i64::MIN.to_string(), i64::MIN),
-        (&i64::MAX.to_string(), i64::MAX),
-    ]);
-}
-
-#[test]
-fn test_parse_u64() {
-    test_parse_ok(vec![
-        ("0", 0u64),
-        ("3", 3u64),
-        ("1234", 1234),
-        (&u64::MAX.to_string(), u64::MAX),
-    ]);
-}
-
-#[test]
-fn test_parse_negative_zero() {
-    for negative_zero in &[
-        "-0",
-        "-0.0",
-        "-0e2",
-        "-0.0e2",
-        "-1e-400",
-        "-1e-4000000000000000000000000000000000000000000000000",
-    ] {
-        assert!(
-            from_str::<f32>(negative_zero).unwrap().is_sign_negative(),
-            "should have been negative: {:?}",
-            negative_zero,
-        );
-        assert!(
-            from_str::<f64>(negative_zero).unwrap().is_sign_negative(),
-            "should have been negative: {:?}",
-            negative_zero,
-        );
-    }
-}
-
-#[test]
-fn test_parse_f64() {
-    test_parse_ok(vec![
-        ("0.0", 0.0f64),
-        ("3.0", 3.0f64),
-        ("3.1", 3.1),
-        ("-1.2", -1.2),
-        ("0.4", 0.4),
-        // Edge case from:
-        // https://github.com/serde-rs/json/issues/536#issuecomment-583714900
-        ("2.638344616030823e-256", 2.638344616030823e-256),
-    ]);
-
-    #[cfg(not(feature = "arbitrary_precision"))]
-    test_parse_ok(vec![
-        // With arbitrary-precision enabled, this parses as Number{"3.00"}
-        // but the float is Number{"3.0"}
-        ("3.00", 3.0f64),
-        ("0.4e5", 0.4e5),
-        ("0.4e+5", 0.4e5),
-        ("0.4e15", 0.4e15),
-        ("0.4e+15", 0.4e15),
-        ("0.4e-01", 0.4e-1),
-        (" 0.4e-01 ", 0.4e-1),
-        ("0.4e-001", 0.4e-1),
-        ("0.4e-0", 0.4e0),
-        ("0.00e00", 0.0),
-        ("0.00e+00", 0.0),
-        ("0.00e-00", 0.0),
-        ("3.5E-2147483647", 0.0),
-        ("0.0100000000000000000001", 0.01),
-        (
-            &format!("{}", (i64::MIN as f64) - 1.0),
-            (i64::MIN as f64) - 1.0,
-        ),
-        (
-            &format!("{}", (u64::MAX as f64) + 1.0),
-            (u64::MAX as f64) + 1.0,
-        ),
-        (&format!("{}", f64::EPSILON), f64::EPSILON),
-        (
-            "0.0000000000000000000000000000000000000000000000000123e50",
-            1.23,
-        ),
-        ("100e-777777777777777777777777777", 0.0),
-        (
-            "1010101010101010101010101010101010101010",
-            10101010101010101010e20,
-        ),
-        (
-            "0.1010101010101010101010101010101010101010",
-            0.1010101010101010101,
-        ),
-        ("0e1000000000000000000000000000000000000000000000", 0.0),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             00000000",
-            1e308,
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             .0e8",
-            1e308,
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             e8",
-            1e308,
-        ),
-        (
-            "1000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000e-10",
-            1e308,
-        ),
-    ]);
-}
-
-#[test]
-fn test_value_as_f64() {
-    let v = serde_json::from_str::<Value>("1e1000");
-
-    #[cfg(not(feature = "arbitrary_precision"))]
-    assert!(v.is_err());
-
-    #[cfg(feature = "arbitrary_precision")]
-    assert_eq!(v.unwrap().as_f64(), None);
-}
-
-// Test roundtrip with some values that were not perfectly roundtripped by the
-// old f64 deserializer.
-#[cfg(feature = "float_roundtrip")]
-#[test]
-fn test_roundtrip_f64() {
-    for &float in &[
-        // Samples from quickcheck-ing roundtrip with `input: f64`. Comments
-        // indicate the value returned by the old deserializer.
-        51.24817837550540_4,  // 51.2481783755054_1
-        -93.3113703768803_3,  // -93.3113703768803_2
-        -36.5739948427534_36, // -36.5739948427534_4
-        52.31400820410624_4,  // 52.31400820410624_
-        97.4536532003468_5,   // 97.4536532003468_4
-        // Samples from `rng.next_u64` + `f64::from_bits` + `is_finite` filter.
-        2.0030397744267762e-253,
-        7.101215824554616e260,
-        1.769268377902049e74,
-        -1.6727517818542075e58,
-        3.9287532173373315e299,
-    ] {
-        let json = serde_json::to_string(&float).unwrap();
-        let output: f64 = serde_json::from_str(&json).unwrap();
-        assert_eq!(float, output);
-    }
-}
-
-#[test]
-fn test_roundtrip_f32() {
-    // This number has 1 ULP error if parsed via f64 and converted to f32.
-    // https://github.com/serde-rs/json/pull/671#issuecomment-628534468
-    let float = 7.038531e-26;
-    let json = serde_json::to_string(&float).unwrap();
-    let output: f32 = serde_json::from_str(&json).unwrap();
-    assert_eq!(float, output);
-}
-
-#[test]
-fn test_serialize_char() {
-    let value = json!(
-        ({
-            let mut map = BTreeMap::new();
-            map.insert('c', ());
-            map
-        })
-    );
-    assert_eq!(&Value::Null, value.get("c").unwrap());
-}
-
-#[cfg(feature = "arbitrary_precision")]
-#[test]
-fn test_malicious_number() {
-    #[derive(Serialize)]
-    #[serde(rename = "$serde_json::private::Number")]
-    struct S {
-        #[serde(rename = "$serde_json::private::Number")]
-        f: &'static str,
-    }
-
-    let actual = serde_json::to_value(&S { f: "not a number" })
-        .unwrap_err()
-        .to_string();
-    assert_eq!(actual, "invalid number at line 1 column 1");
-}
-
-#[test]
-fn test_parse_number() {
-    test_parse_ok(vec![
-        ("0.0", Number::from_f64(0.0f64).unwrap()),
-        ("3.0", Number::from_f64(3.0f64).unwrap()),
-        ("3.1", Number::from_f64(3.1).unwrap()),
-        ("-1.2", Number::from_f64(-1.2).unwrap()),
-        ("0.4", Number::from_f64(0.4).unwrap()),
-    ]);
-
-    test_fromstr_parse_err::<Number>(&[
-        (" 1.0", "invalid number at line 1 column 1"),
-        ("1.0 ", "invalid number at line 1 column 4"),
-        ("\t1.0", "invalid number at line 1 column 1"),
-        ("1.0\t", "invalid number at line 1 column 4"),
-    ]);
-
-    #[cfg(feature = "arbitrary_precision")]
-    test_parse_ok(vec![
-        ("1e999", Number::from_string_unchecked("1e999".to_owned())),
-        ("1e+999", Number::from_string_unchecked("1e+999".to_owned())),
-        ("-1e999", Number::from_string_unchecked("-1e999".to_owned())),
-        ("1e-999", Number::from_string_unchecked("1e-999".to_owned())),
-        ("1E999", Number::from_string_unchecked("1E999".to_owned())),
-        ("1E+999", Number::from_string_unchecked("1E+999".to_owned())),
-        ("-1E999", Number::from_string_unchecked("-1E999".to_owned())),
-        ("1E-999", Number::from_string_unchecked("1E-999".to_owned())),
-        ("1E+000", Number::from_string_unchecked("1E+000".to_owned())),
-        (
-            "2.3e999",
-            Number::from_string_unchecked("2.3e999".to_owned()),
-        ),
-        (
-            "-2.3e999",
-            Number::from_string_unchecked("-2.3e999".to_owned()),
-        ),
-    ]);
-}
-
-#[test]
-fn test_parse_string() {
-    test_parse_err::<String>(&[
-        ("\"", "EOF while parsing a string at line 1 column 1"),
-        ("\"lol", "EOF while parsing a string at line 1 column 4"),
-        ("\"lol\"a", "trailing characters at line 1 column 6"),
-        (
-            "\"\\uD83C\\uFFFF\"",
-            "lone leading surrogate in hex escape at line 1 column 13",
-        ),
-        (
-            "\"\n\"",
-            "control character (\\u0000-\\u001F) found while parsing a string at line 2 column 0",
-        ),
-        (
-            "\"\x1F\"",
-            "control character (\\u0000-\\u001F) found while parsing a string at line 1 column 2",
-        ),
-    ]);
-
-    test_parse_slice_err::<String>(&[
-        (
-            &[b'"', 159, 146, 150, b'"'],
-            "invalid unicode code point at line 1 column 5",
-        ),
-        (
-            &[b'"', b'\\', b'n', 159, 146, 150, b'"'],
-            "invalid unicode code point at line 1 column 7",
-        ),
-        (
-            &[b'"', b'\\', b'u', 48, 48, 51],
-            "EOF while parsing a string at line 1 column 6",
-        ),
-        (
-            &[b'"', b'\\', b'u', 250, 48, 51, 48, b'"'],
-            "invalid escape at line 1 column 4",
-        ),
-        (
-            &[b'"', b'\\', b'u', 48, 250, 51, 48, b'"'],
-            "invalid escape at line 1 column 5",
-        ),
-        (
-            &[b'"', b'\\', b'u', 48, 48, 250, 48, b'"'],
-            "invalid escape at line 1 column 6",
-        ),
-        (
-            &[b'"', b'\\', b'u', 48, 48, 51, 250, b'"'],
-            "invalid escape at line 1 column 7",
-        ),
-        (
-            &[b'"', b'\n', b'"'],
-            "control character (\\u0000-\\u001F) found while parsing a string at line 2 column 0",
-        ),
-        (
-            &[b'"', b'\x1F', b'"'],
-            "control character (\\u0000-\\u001F) found while parsing a string at line 1 column 2",
-        ),
-    ]);
-
-    test_parse_ok(vec![
-        ("\"\"", String::new()),
-        ("\"foo\"", "foo".to_string()),
-        (" \"foo\" ", "foo".to_string()),
-        ("\"\\\"\"", "\"".to_string()),
-        ("\"\\b\"", "\x08".to_string()),
-        ("\"\\n\"", "\n".to_string()),
-        ("\"\\r\"", "\r".to_string()),
-        ("\"\\t\"", "\t".to_string()),
-        ("\"\\u12ab\"", "\u{12ab}".to_string()),
-        ("\"\\uAB12\"", "\u{AB12}".to_string()),
-        ("\"\\uD83C\\uDF95\"", "\u{1F395}".to_string()),
-    ]);
-}
-
-#[test]
-fn test_parse_list() {
-    test_parse_err::<Vec<f64>>(&[
-        ("[", "EOF while parsing a list at line 1 column 1"),
-        ("[ ", "EOF while parsing a list at line 1 column 2"),
-        ("[1", "EOF while parsing a list at line 1 column 2"),
-        ("[1,", "EOF while parsing a value at line 1 column 3"),
-        ("[1,]", "trailing comma at line 1 column 4"),
-        ("[1 2]", "expected `,` or `]` at line 1 column 4"),
-        ("[]a", "trailing characters at line 1 column 3"),
-    ]);
-
-    test_parse_ok(vec![
-        ("[]", vec![]),
-        ("[ ]", vec![]),
-        ("[null]", vec![()]),
-        (" [ null ] ", vec![()]),
-    ]);
-
-    test_parse_ok(vec![("[true]", vec![true])]);
-
-    test_parse_ok(vec![("[3,1]", vec![3u64, 1]), (" [ 3 , 1 ] ", vec![3, 1])]);
-
-    test_parse_ok(vec![("[[3], [1, 2]]", vec![vec![3u64], vec![1, 2]])]);
-
-    test_parse_ok(vec![("[1]", (1u64,))]);
-
-    test_parse_ok(vec![("[1, 2]", (1u64, 2u64))]);
-
-    test_parse_ok(vec![("[1, 2, 3]", (1u64, 2u64, 3u64))]);
-
-    test_parse_ok(vec![("[1, [2, 3]]", (1u64, (2u64, 3u64)))]);
-}
-
-#[test]
-fn test_parse_object() {
-    test_parse_err::<BTreeMap<String, u32>>(&[
-        ("{", "EOF while parsing an object at line 1 column 1"),
-        ("{ ", "EOF while parsing an object at line 1 column 2"),
-        ("{1", "key must be a string at line 1 column 2"),
-        ("{ \"a\"", "EOF while parsing an object at line 1 column 5"),
-        ("{\"a\"", "EOF while parsing an object at line 1 column 4"),
-        ("{\"a\" ", "EOF while parsing an object at line 1 column 5"),
-        ("{\"a\" 1", "expected `:` at line 1 column 6"),
-        ("{\"a\":", "EOF while parsing a value at line 1 column 5"),
-        ("{\"a\":1", "EOF while parsing an object at line 1 column 6"),
-        ("{\"a\":1 1", "expected `,` or `}` at line 1 column 8"),
-        ("{\"a\":1,", "EOF while parsing a value at line 1 column 7"),
-        ("{}a", "trailing characters at line 1 column 3"),
-    ]);
-
-    test_parse_ok(vec![
-        ("{}", treemap!()),
-        ("{ }", treemap!()),
-        ("{\"a\":3}", treemap!("a".to_string() => 3u64)),
-        ("{ \"a\" : 3 }", treemap!("a".to_string() => 3)),
-        (
-            "{\"a\":3,\"b\":4}",
-            treemap!("a".to_string() => 3, "b".to_string() => 4),
-        ),
-        (
-            " { \"a\" : 3 , \"b\" : 4 } ",
-            treemap!("a".to_string() => 3, "b".to_string() => 4),
-        ),
-    ]);
-
-    test_parse_ok(vec![(
-        "{\"a\": {\"b\": 3, \"c\": 4}}",
-        treemap!(
-            "a".to_string() => treemap!(
-                "b".to_string() => 3u64,
-                "c".to_string() => 4,
-            ),
-        ),
-    )]);
-
-    test_parse_ok(vec![("{\"c\":null}", treemap!('c' => ()))]);
-}
-
-#[test]
-fn test_parse_struct() {
-    test_parse_err::<Outer>(&[
-        (
-            "5",
-            "invalid type: integer `5`, expected struct Outer at line 1 column 1",
-        ),
-        (
-            "\"hello\"",
-            "invalid type: string \"hello\", expected struct Outer at line 1 column 7",
-        ),
-        (
-            "{\"inner\": true}",
-            "invalid type: boolean `true`, expected a sequence at line 1 column 14",
-        ),
-        ("{}", "missing field `inner` at line 1 column 2"),
-        (
-            r#"{"inner": [{"b": 42, "c": []}]}"#,
-            "missing field `a` at line 1 column 29",
-        ),
-    ]);
-
-    test_parse_ok(vec![
-        (
-            "{
-                \"inner\": []
-            }",
-            Outer { inner: vec![] },
-        ),
-        (
-            "{
-                \"inner\": [
-                    { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
-                ]
-            }",
-            Outer {
-                inner: vec![Inner {
-                    a: (),
-                    b: 2,
-                    c: vec!["abc".to_string(), "xyz".to_string()],
-                }],
-            },
-        ),
-    ]);
-
-    let v: Outer = from_str(
-        "[
-            [
-                [ null, 2, [\"abc\", \"xyz\"] ]
-            ]
-        ]",
-    )
-    .unwrap();
-
-    assert_eq!(
-        v,
-        Outer {
-            inner: vec![Inner {
-                a: (),
-                b: 2,
-                c: vec!["abc".to_string(), "xyz".to_string()],
-            }],
-        }
-    );
-
-    let j = json!([null, 2, []]);
-    Inner::deserialize(&j).unwrap();
-    Inner::deserialize(j).unwrap();
-}
-
-#[test]
-fn test_parse_option() {
-    test_parse_ok(vec![
-        ("null", None::<String>),
-        ("\"jodhpurs\"", Some("jodhpurs".to_string())),
-    ]);
-
-    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-    struct Foo {
-        x: Option<isize>,
-    }
-
-    let value: Foo = from_str("{}").unwrap();
-    assert_eq!(value, Foo { x: None });
-
-    test_parse_ok(vec![
-        ("{\"x\": null}", Foo { x: None }),
-        ("{\"x\": 5}", Foo { x: Some(5) }),
-    ]);
-}
-
-#[test]
-fn test_parse_enum_errors() {
-    test_parse_err::<Animal>(
-        &[
-            ("{}", "expected value at line 1 column 2"),
-            ("[]", "expected value at line 1 column 1"),
-            ("\"unknown\"",
-             "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 9"),
-            ("{\"unknown\":null}",
-             "unknown variant `unknown`, expected one of `Dog`, `Frog`, `Cat`, `AntHive` at line 1 column 10"),
-            ("{\"Dog\":", "EOF while parsing a value at line 1 column 7"),
-            ("{\"Dog\":}", "expected value at line 1 column 8"),
-            ("{\"Dog\":{}}", "invalid type: map, expected unit at line 1 column 7"),
-            ("\"Frog\"", "invalid type: unit variant, expected tuple variant"),
-            ("\"Frog\" 0 ", "invalid type: unit variant, expected tuple variant"),
-            ("{\"Frog\":{}}",
-             "invalid type: map, expected tuple variant Animal::Frog at line 1 column 8"),
-            ("{\"Cat\":[]}", "invalid length 0, expected struct variant Animal::Cat with 2 elements at line 1 column 9"),
-            ("{\"Cat\":[0]}", "invalid length 1, expected struct variant Animal::Cat with 2 elements at line 1 column 10"),
-            ("{\"Cat\":[0, \"\", 2]}", "trailing characters at line 1 column 16"),
-            ("{\"Cat\":{\"age\": 5, \"name\": \"Kate\", \"foo\":\"bar\"}",
-             "unknown field `foo`, expected `age` or `name` at line 1 column 39"),
-
-            // JSON does not allow trailing commas in data structures
-            ("{\"Cat\":[0, \"Kate\",]}", "trailing comma at line 1 column 19"),
-            ("{\"Cat\":{\"age\": 2, \"name\": \"Kate\",}}",
-             "trailing comma at line 1 column 34"),
-        ],
-    );
-}
-
-#[test]
-fn test_parse_enum() {
-    test_parse_ok(vec![
-        ("\"Dog\"", Animal::Dog),
-        (" \"Dog\" ", Animal::Dog),
-        (
-            "{\"Frog\":[\"Henry\",[]]}",
-            Animal::Frog("Henry".to_string(), vec![]),
-        ),
-        (
-            " { \"Frog\": [ \"Henry\" , [ 349, 102 ] ] } ",
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-        ),
-        (
-            "{\"Cat\": {\"age\": 5, \"name\": \"Kate\"}}",
-            Animal::Cat {
-                age: 5,
-                name: "Kate".to_string(),
-            },
-        ),
-        (
-            " { \"Cat\" : { \"age\" : 5 , \"name\" : \"Kate\" } } ",
-            Animal::Cat {
-                age: 5,
-                name: "Kate".to_string(),
-            },
-        ),
-        (
-            " { \"AntHive\" : [\"Bob\", \"Stuart\"] } ",
-            Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
-        ),
-    ]);
-
-    test_parse_unusual_ok(vec![
-        ("{\"Dog\":null}", Animal::Dog),
-        (" { \"Dog\" : null } ", Animal::Dog),
-    ]);
-
-    test_parse_ok(vec![(
-        concat!(
-            "{",
-            "  \"a\": \"Dog\",",
-            "  \"b\": {\"Frog\":[\"Henry\", []]}",
-            "}"
-        ),
-        treemap!(
-            "a".to_string() => Animal::Dog,
-            "b".to_string() => Animal::Frog("Henry".to_string(), vec![]),
-        ),
-    )]);
-}
-
-#[test]
-fn test_parse_trailing_whitespace() {
-    test_parse_ok(vec![
-        ("[1, 2] ", vec![1u64, 2]),
-        ("[1, 2]\n", vec![1, 2]),
-        ("[1, 2]\t", vec![1, 2]),
-        ("[1, 2]\t \n", vec![1, 2]),
-    ]);
-}
-
-#[test]
-fn test_multiline_errors() {
-    test_parse_err::<BTreeMap<String, String>>(&[(
-        "{\n  \"foo\":\n \"bar\"",
-        "EOF while parsing an object at line 3 column 6",
-    )]);
-}
-
-#[test]
-fn test_missing_option_field() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    struct Foo {
-        x: Option<u32>,
-    }
-
-    let value: Foo = from_str("{}").unwrap();
-    assert_eq!(value, Foo { x: None });
-
-    let value: Foo = from_str("{\"x\": 5}").unwrap();
-    assert_eq!(value, Foo { x: Some(5) });
-
-    let value: Foo = from_value(json!({})).unwrap();
-    assert_eq!(value, Foo { x: None });
-
-    let value: Foo = from_value(json!({"x": 5})).unwrap();
-    assert_eq!(value, Foo { x: Some(5) });
-}
-
-#[test]
-fn test_missing_nonoption_field() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    struct Foo {
-        x: u32,
-    }
-
-    test_parse_err::<Foo>(&[("{}", "missing field `x` at line 1 column 2")]);
-}
-
-#[test]
-fn test_missing_renamed_field() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    struct Foo {
-        #[serde(rename = "y")]
-        x: Option<u32>,
-    }
-
-    let value: Foo = from_str("{}").unwrap();
-    assert_eq!(value, Foo { x: None });
-
-    let value: Foo = from_str("{\"y\": 5}").unwrap();
-    assert_eq!(value, Foo { x: Some(5) });
-
-    let value: Foo = from_value(json!({})).unwrap();
-    assert_eq!(value, Foo { x: None });
-
-    let value: Foo = from_value(json!({"y": 5})).unwrap();
-    assert_eq!(value, Foo { x: Some(5) });
-}
-
-#[test]
-fn test_serialize_seq_with_no_len() {
-    #[derive(Clone, Debug, PartialEq)]
-    struct MyVec<T>(Vec<T>);
-
-    impl<T> ser::Serialize for MyVec<T>
-    where
-        T: ser::Serialize,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: ser::Serializer,
-        {
-            let mut seq = serializer.serialize_seq(None)?;
-            for elem in &self.0 {
-                seq.serialize_element(elem)?;
-            }
-            seq.end()
-        }
-    }
-
-    struct Visitor<T> {
-        marker: PhantomData<MyVec<T>>,
-    }
-
-    impl<'de, T> de::Visitor<'de> for Visitor<T>
-    where
-        T: de::Deserialize<'de>,
-    {
-        type Value = MyVec<T>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("array")
-        }
-
-        fn visit_unit<E>(self) -> Result<MyVec<T>, E>
-        where
-            E: de::Error,
-        {
-            Ok(MyVec(Vec::new()))
-        }
-
-        fn visit_seq<V>(self, mut visitor: V) -> Result<MyVec<T>, V::Error>
-        where
-            V: de::SeqAccess<'de>,
-        {
-            let mut values = Vec::new();
-
-            while let Some(value) = visitor.next_element()? {
-                values.push(value);
-            }
-
-            Ok(MyVec(values))
-        }
-    }
-
-    impl<'de, T> de::Deserialize<'de> for MyVec<T>
-    where
-        T: de::Deserialize<'de>,
-    {
-        fn deserialize<D>(deserializer: D) -> Result<MyVec<T>, D::Error>
-        where
-            D: de::Deserializer<'de>,
-        {
-            deserializer.deserialize_map(Visitor {
-                marker: PhantomData,
-            })
-        }
-    }
-
-    let mut vec = Vec::new();
-    vec.push(MyVec(Vec::new()));
-    vec.push(MyVec(Vec::new()));
-    let vec: MyVec<MyVec<u32>> = MyVec(vec);
-
-    test_encode_ok(&[(vec.clone(), "[[],[]]")]);
-
-    let s = to_string_pretty(&vec).unwrap();
-    let expected = pretty_str!([[], []]);
-    assert_eq!(s, expected);
-}
-
-#[test]
-fn test_serialize_map_with_no_len() {
-    #[derive(Clone, Debug, PartialEq)]
-    struct MyMap<K, V>(BTreeMap<K, V>);
-
-    impl<K, V> ser::Serialize for MyMap<K, V>
-    where
-        K: ser::Serialize + Ord,
-        V: ser::Serialize,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: ser::Serializer,
-        {
-            let mut map = serializer.serialize_map(None)?;
-            for (k, v) in &self.0 {
-                map.serialize_entry(k, v)?;
-            }
-            map.end()
-        }
-    }
-
-    struct Visitor<K, V> {
-        marker: PhantomData<MyMap<K, V>>,
-    }
-
-    impl<'de, K, V> de::Visitor<'de> for Visitor<K, V>
-    where
-        K: de::Deserialize<'de> + Eq + Ord,
-        V: de::Deserialize<'de>,
-    {
-        type Value = MyMap<K, V>;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str("map")
-        }
-
-        fn visit_unit<E>(self) -> Result<MyMap<K, V>, E>
-        where
-            E: de::Error,
-        {
-            Ok(MyMap(BTreeMap::new()))
-        }
-
-        fn visit_map<Visitor>(self, mut visitor: Visitor) -> Result<MyMap<K, V>, Visitor::Error>
-        where
-            Visitor: de::MapAccess<'de>,
-        {
-            let mut values = BTreeMap::new();
-
-            while let Some((key, value)) = visitor.next_entry()? {
-                values.insert(key, value);
-            }
-
-            Ok(MyMap(values))
-        }
-    }
-
-    impl<'de, K, V> de::Deserialize<'de> for MyMap<K, V>
-    where
-        K: de::Deserialize<'de> + Eq + Ord,
-        V: de::Deserialize<'de>,
-    {
-        fn deserialize<D>(deserializer: D) -> Result<MyMap<K, V>, D::Error>
-        where
-            D: de::Deserializer<'de>,
-        {
-            deserializer.deserialize_map(Visitor {
-                marker: PhantomData,
-            })
-        }
-    }
-
-    let mut map = BTreeMap::new();
-    map.insert("a", MyMap(BTreeMap::new()));
-    map.insert("b", MyMap(BTreeMap::new()));
-    let map: MyMap<_, MyMap<u32, u32>> = MyMap(map);
-
-    test_encode_ok(&[(map.clone(), "{\"a\":{},\"b\":{}}")]);
-
-    let s = to_string_pretty(&map).unwrap();
-    let expected = pretty_str!({
-        "a": {},
-        "b": {}
-    });
-    assert_eq!(s, expected);
-}
-
-#[cfg(not(miri))]
-#[test]
-fn test_deserialize_from_stream() {
-    use serde_json::to_writer;
-    use std::net::{TcpListener, TcpStream};
-    use std::thread;
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    struct Message {
-        message: String,
-    }
-
-    let l = TcpListener::bind("localhost:20000").unwrap();
-
-    thread::spawn(|| {
-        let l = l;
-        for stream in l.incoming() {
-            let mut stream = stream.unwrap();
-            let read_stream = stream.try_clone().unwrap();
-
-            let mut de = Deserializer::from_reader(read_stream);
-            let request = Message::deserialize(&mut de).unwrap();
-            let response = Message {
-                message: request.message,
-            };
-            to_writer(&mut stream, &response).unwrap();
-        }
-    });
-
-    let mut stream = TcpStream::connect("localhost:20000").unwrap();
-    let request = Message {
-        message: "hi there".to_string(),
-    };
-    to_writer(&mut stream, &request).unwrap();
-
-    let mut de = Deserializer::from_reader(stream);
-    let response = Message::deserialize(&mut de).unwrap();
-
-    assert_eq!(request, response);
-}
-
-#[test]
-fn test_serialize_rejects_adt_keys() {
-    let map = treemap!(
-        Some("a") => 2,
-        Some("b") => 4,
-        None => 6,
-    );
-
-    let err = to_vec(&map).unwrap_err();
-    assert_eq!(err.to_string(), "key must be a string");
-}
-
-#[test]
-fn test_bytes_ser() {
-    let buf = vec![];
-    let bytes = Bytes::new(&buf);
-    assert_eq!(to_string(&bytes).unwrap(), "[]".to_string());
-
-    let buf = vec![1, 2, 3];
-    let bytes = Bytes::new(&buf);
-    assert_eq!(to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
-#[test]
-fn test_byte_buf_ser() {
-    let bytes = ByteBuf::new();
-    assert_eq!(to_string(&bytes).unwrap(), "[]".to_string());
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    assert_eq!(to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
-#[test]
-fn test_byte_buf_de() {
-    let bytes = ByteBuf::new();
-    let v: ByteBuf = from_str("[]").unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    let v: ByteBuf = from_str("[1, 2, 3]").unwrap();
-    assert_eq!(v, bytes);
-}
-
-#[test]
-fn test_byte_buf_de_lone_surrogate() {
-    let bytes = ByteBuf::from(vec![237, 160, 188]);
-    let v: ByteBuf = from_str(r#""\ud83c""#).unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![237, 160, 188, 10]);
-    let v: ByteBuf = from_str(r#""\ud83c\n""#).unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![237, 160, 188, 32]);
-    let v: ByteBuf = from_str(r#""\ud83c ""#).unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![237, 176, 129]);
-    let v: ByteBuf = from_str(r#""\udc01""#).unwrap();
-    assert_eq!(v, bytes);
-
-    let res = from_str::<ByteBuf>(r#""\ud83c\!""#);
-    assert!(res.is_err());
-
-    let res = from_str::<ByteBuf>(r#""\ud83c\u""#);
-    assert!(res.is_err());
-
-    let res = from_str::<ByteBuf>(r#""\ud83c\ud83c""#);
-    assert!(res.is_err());
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_raw_de_lone_surrogate() {
-    use serde_json::value::RawValue;
-
-    assert!(from_str::<Box<RawValue>>(r#""\ud83c""#).is_ok());
-    assert!(from_str::<Box<RawValue>>(r#""\ud83c\n""#).is_ok());
-    assert!(from_str::<Box<RawValue>>(r#""\ud83c ""#).is_ok());
-    assert!(from_str::<Box<RawValue>>(r#""\udc01 ""#).is_ok());
-    assert!(from_str::<Box<RawValue>>(r#""\udc01\!""#).is_err());
-    assert!(from_str::<Box<RawValue>>(r#""\udc01\u""#).is_err());
-    assert!(from_str::<Box<RawValue>>(r#""\ud83c\ud83c""#).is_ok());
-}
-
-#[test]
-fn test_byte_buf_de_multiple() {
-    let s: Vec<ByteBuf> = from_str(r#"["ab\nc", "cd\ne"]"#).unwrap();
-    let a = ByteBuf::from(b"ab\nc".to_vec());
-    let b = ByteBuf::from(b"cd\ne".to_vec());
-    assert_eq!(vec![a, b], s);
-}
-
-#[test]
-fn test_json_pointer() {
-    // Test case taken from https://tools.ietf.org/html/rfc6901#page-5
-    let data: Value = from_str(
-        r#"{
-        "foo": ["bar", "baz"],
-        "": 0,
-        "a/b": 1,
-        "c%d": 2,
-        "e^f": 3,
-        "g|h": 4,
-        "i\\j": 5,
-        "k\"l": 6,
-        " ": 7,
-        "m~n": 8
-    }"#,
-    )
-    .unwrap();
-    assert_eq!(data.pointer("").unwrap(), &data);
-    assert_eq!(data.pointer("/foo").unwrap(), &json!(["bar", "baz"]));
-    assert_eq!(data.pointer("/foo/0").unwrap(), &json!("bar"));
-    assert_eq!(data.pointer("/").unwrap(), &json!(0));
-    assert_eq!(data.pointer("/a~1b").unwrap(), &json!(1));
-    assert_eq!(data.pointer("/c%d").unwrap(), &json!(2));
-    assert_eq!(data.pointer("/e^f").unwrap(), &json!(3));
-    assert_eq!(data.pointer("/g|h").unwrap(), &json!(4));
-    assert_eq!(data.pointer("/i\\j").unwrap(), &json!(5));
-    assert_eq!(data.pointer("/k\"l").unwrap(), &json!(6));
-    assert_eq!(data.pointer("/ ").unwrap(), &json!(7));
-    assert_eq!(data.pointer("/m~0n").unwrap(), &json!(8));
-    // Invalid pointers
-    assert!(data.pointer("/unknown").is_none());
-    assert!(data.pointer("/e^f/ertz").is_none());
-    assert!(data.pointer("/foo/00").is_none());
-    assert!(data.pointer("/foo/01").is_none());
-}
-
-#[test]
-fn test_json_pointer_mut() {
-    // Test case taken from https://tools.ietf.org/html/rfc6901#page-5
-    let mut data: Value = from_str(
-        r#"{
-        "foo": ["bar", "baz"],
-        "": 0,
-        "a/b": 1,
-        "c%d": 2,
-        "e^f": 3,
-        "g|h": 4,
-        "i\\j": 5,
-        "k\"l": 6,
-        " ": 7,
-        "m~n": 8
-    }"#,
-    )
-    .unwrap();
-
-    // Basic pointer checks
-    assert_eq!(data.pointer_mut("/foo").unwrap(), &json!(["bar", "baz"]));
-    assert_eq!(data.pointer_mut("/foo/0").unwrap(), &json!("bar"));
-    assert_eq!(data.pointer_mut("/").unwrap(), 0);
-    assert_eq!(data.pointer_mut("/a~1b").unwrap(), 1);
-    assert_eq!(data.pointer_mut("/c%d").unwrap(), 2);
-    assert_eq!(data.pointer_mut("/e^f").unwrap(), 3);
-    assert_eq!(data.pointer_mut("/g|h").unwrap(), 4);
-    assert_eq!(data.pointer_mut("/i\\j").unwrap(), 5);
-    assert_eq!(data.pointer_mut("/k\"l").unwrap(), 6);
-    assert_eq!(data.pointer_mut("/ ").unwrap(), 7);
-    assert_eq!(data.pointer_mut("/m~0n").unwrap(), 8);
-
-    // Invalid pointers
-    assert!(data.pointer_mut("/unknown").is_none());
-    assert!(data.pointer_mut("/e^f/ertz").is_none());
-    assert!(data.pointer_mut("/foo/00").is_none());
-    assert!(data.pointer_mut("/foo/01").is_none());
-
-    // Mutable pointer checks
-    *data.pointer_mut("/").unwrap() = 100.into();
-    assert_eq!(data.pointer("/").unwrap(), 100);
-    *data.pointer_mut("/foo/0").unwrap() = json!("buzz");
-    assert_eq!(data.pointer("/foo/0").unwrap(), &json!("buzz"));
-
-    // Example of ownership stealing
-    assert_eq!(
-        data.pointer_mut("/a~1b")
-            .map(|m| mem::replace(m, json!(null)))
-            .unwrap(),
-        1
-    );
-    assert_eq!(data.pointer("/a~1b").unwrap(), &json!(null));
-
-    // Need to compare against a clone so we don't anger the borrow checker
-    // by taking out two references to a mutable value
-    let mut d2 = data.clone();
-    assert_eq!(data.pointer_mut("").unwrap(), &mut d2);
-}
-
-#[test]
-fn test_stack_overflow() {
-    let brackets: String = iter::repeat('[')
-        .take(127)
-        .chain(iter::repeat(']').take(127))
-        .collect();
-    let _: Value = from_str(&brackets).unwrap();
-
-    let brackets = "[".repeat(129);
-    test_parse_err::<Value>(&[(&brackets, "recursion limit exceeded at line 1 column 128")]);
-}
-
-#[test]
-#[cfg(feature = "unbounded_depth")]
-fn test_disable_recursion_limit() {
-    let brackets: String = iter::repeat('[')
-        .take(140)
-        .chain(iter::repeat(']').take(140))
-        .collect();
-
-    let mut deserializer = Deserializer::from_str(&brackets);
-    deserializer.disable_recursion_limit();
-    Value::deserialize(&mut deserializer).unwrap();
-}
-
-#[test]
-fn test_integer_key() {
-    // map with integer keys
-    let map = treemap!(
-        1 => 2,
-        -1 => 6,
-    );
-    let j = r#"{"-1":6,"1":2}"#;
-    test_encode_ok(&[(&map, j)]);
-    test_parse_ok(vec![(j, map)]);
-
-    test_parse_err::<BTreeMap<i32, ()>>(&[
-        (
-            r#"{"x":null}"#,
-            "invalid value: expected key to be a number in quotes at line 1 column 2",
-        ),
-        (
-            r#"{" 123":null}"#,
-            "invalid value: expected key to be a number in quotes at line 1 column 2",
-        ),
-        (r#"{"123 ":null}"#, "expected `\"` at line 1 column 6"),
-    ]);
-
-    let err = from_value::<BTreeMap<i32, ()>>(json!({" 123":null})).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "invalid value: expected key to be a number in quotes",
-    );
-
-    let err = from_value::<BTreeMap<i32, ()>>(json!({"123 ":null})).unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "invalid value: expected key to be a number in quotes",
-    );
-}
-
-#[test]
-fn test_integer128_key() {
-    let map = treemap! {
-        100000000000000000000000000000000000000u128 => (),
-    };
-    let j = r#"{"100000000000000000000000000000000000000":null}"#;
-    assert_eq!(to_string(&map).unwrap(), j);
-    assert_eq!(from_str::<BTreeMap<u128, ()>>(j).unwrap(), map);
-}
-
-#[test]
-fn test_float_key() {
-    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone)]
-    struct Float;
-    impl Serialize for Float {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            serializer.serialize_f32(1.23)
-        }
-    }
-    impl<'de> Deserialize<'de> for Float {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: de::Deserializer<'de>,
-        {
-            f32::deserialize(deserializer).map(|_| Float)
-        }
-    }
-
-    // map with float key
-    let map = treemap!(Float => "x".to_owned());
-    let j = r#"{"1.23":"x"}"#;
-
-    test_encode_ok(&[(&map, j)]);
-    test_parse_ok(vec![(j, map)]);
-
-    let j = r#"{"x": null}"#;
-    test_parse_err::<BTreeMap<Float, ()>>(&[(
-        j,
-        "invalid value: expected key to be a number in quotes at line 1 column 2",
-    )]);
-}
-
-#[test]
-fn test_deny_non_finite_f32_key() {
-    // We store float bits so that we can derive Ord, and other traits. In a
-    // real context the code might involve a crate like ordered-float.
-
-    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone)]
-    struct F32Bits(u32);
-    impl Serialize for F32Bits {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            serializer.serialize_f32(f32::from_bits(self.0))
-        }
-    }
-
-    let map = treemap!(F32Bits(f32::INFINITY.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-
-    let map = treemap!(F32Bits(f32::NEG_INFINITY.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-
-    let map = treemap!(F32Bits(f32::NAN.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-}
-
-#[test]
-fn test_deny_non_finite_f64_key() {
-    // We store float bits so that we can derive Ord, and other traits. In a
-    // real context the code might involve a crate like ordered-float.
-
-    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone)]
-    struct F64Bits(u64);
-    impl Serialize for F64Bits {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            serializer.serialize_f64(f64::from_bits(self.0))
-        }
-    }
-
-    let map = treemap!(F64Bits(f64::INFINITY.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-
-    let map = treemap!(F64Bits(f64::NEG_INFINITY.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-
-    let map = treemap!(F64Bits(f64::NAN.to_bits()) => "x".to_owned());
-    assert!(serde_json::to_string(&map).is_err());
-    assert!(serde_json::to_value(map).is_err());
-}
-
-#[test]
-fn test_boolean_key() {
-    let map = treemap!(false => 0, true => 1);
-    let j = r#"{"false":0,"true":1}"#;
-    test_encode_ok(&[(&map, j)]);
-    test_parse_ok(vec![(j, map)]);
-}
-
-#[test]
-fn test_borrowed_key() {
-    let map: BTreeMap<&str, ()> = from_str("{\"borrowed\":null}").unwrap();
-    let expected = treemap! { "borrowed" => () };
-    assert_eq!(map, expected);
-
-    #[derive(Deserialize, Debug, Ord, PartialOrd, Eq, PartialEq)]
-    struct NewtypeStr<'a>(&'a str);
-
-    let map: BTreeMap<NewtypeStr, ()> = from_str("{\"borrowed\":null}").unwrap();
-    let expected = treemap! { NewtypeStr("borrowed") => () };
-    assert_eq!(map, expected);
-}
-
-#[test]
-fn test_effectively_string_keys() {
-    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Serialize, Deserialize)]
-    enum Enum {
-        One,
-        Two,
-    }
-    let map = treemap! {
-        Enum::One => 1,
-        Enum::Two => 2,
-    };
-    let expected = r#"{"One":1,"Two":2}"#;
-    test_encode_ok(&[(&map, expected)]);
-    test_parse_ok(vec![(expected, map)]);
-
-    #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Serialize, Deserialize)]
-    struct Wrapper(String);
-    let map = treemap! {
-        Wrapper("zero".to_owned()) => 0,
-        Wrapper("one".to_owned()) => 1,
-    };
-    let expected = r#"{"one":1,"zero":0}"#;
-    test_encode_ok(&[(&map, expected)]);
-    test_parse_ok(vec![(expected, map)]);
-}
-
-#[test]
-fn test_json_macro() {
-    // This is tricky because the <...> is not a single TT and the comma inside
-    // looks like an array element separator.
-    let _ = json!([
-        <Result<(), ()> as Clone>::clone(&Ok(())),
-        <Result<(), ()> as Clone>::clone(&Err(()))
-    ]);
-
-    // Same thing but in the map values.
-    let _ = json!({
-        "ok": <Result<(), ()> as Clone>::clone(&Ok(())),
-        "err": <Result<(), ()> as Clone>::clone(&Err(()))
-    });
-
-    // It works in map keys but only if they are parenthesized.
-    let _ = json!({
-        (<Result<&str, ()> as Clone>::clone(&Ok("")).unwrap()): "ok",
-        (<Result<(), &str> as Clone>::clone(&Err("")).unwrap_err()): "err"
-    });
-
-    #[deny(unused_results)]
-    let _ = json!({ "architecture": [true, null] });
-}
-
-#[test]
-fn issue_220() {
-    #[derive(Debug, PartialEq, Eq, Deserialize)]
-    enum E {
-        V(u8),
-    }
-
-    assert!(from_str::<E>(r#" "V"0 "#).is_err());
-
-    assert_eq!(from_str::<E>(r#"{"V": 0}"#).unwrap(), E::V(0));
-}
-
-macro_rules! number_partialeq_ok {
-    ($($n:expr)*) => {
-        $(
-            let value = to_value($n).unwrap();
-            let s = $n.to_string();
-            assert_eq!(value, $n);
-            assert_eq!($n, value);
-            assert_ne!(value, s);
-        )*
-    }
-}
-
-#[test]
-fn test_partialeq_number() {
-    number_partialeq_ok!(0 1 100
-        i8::MIN i8::MAX i16::MIN i16::MAX i32::MIN i32::MAX i64::MIN i64::MAX
-        u8::MIN u8::MAX u16::MIN u16::MAX u32::MIN u32::MAX u64::MIN u64::MAX
-        f32::MIN f32::MAX f32::MIN_EXP f32::MAX_EXP f32::MIN_POSITIVE
-        f64::MIN f64::MAX f64::MIN_EXP f64::MAX_EXP f64::MIN_POSITIVE
-        f32::consts::E f32::consts::PI f32::consts::LN_2 f32::consts::LOG2_E
-        f64::consts::E f64::consts::PI f64::consts::LN_2 f64::consts::LOG2_E
-    );
-}
-
-#[test]
-#[cfg(integer128)]
-#[cfg(feature = "arbitrary_precision")]
-fn test_partialeq_integer128() {
-    number_partialeq_ok!(i128::MIN i128::MAX u128::MIN u128::MAX)
-}
-
-#[test]
-fn test_partialeq_string() {
-    let v = to_value("42").unwrap();
-    assert_eq!(v, "42");
-    assert_eq!("42", v);
-    assert_ne!(v, 42);
-    assert_eq!(v, String::from("42"));
-    assert_eq!(String::from("42"), v);
-}
-
-#[test]
-fn test_partialeq_bool() {
-    let v = to_value(true).unwrap();
-    assert_eq!(v, true);
-    assert_eq!(true, v);
-    assert_ne!(v, false);
-    assert_ne!(v, "true");
-    assert_ne!(v, 1);
-    assert_ne!(v, 0);
-}
-
-struct FailReader(io::ErrorKind);
-
-impl io::Read for FailReader {
-    fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-        Err(io::Error::new(self.0, "oh no!"))
-    }
-}
-
-#[test]
-fn test_category() {
-    assert!(from_str::<String>("123").unwrap_err().is_data());
-
-    assert!(from_str::<String>("]").unwrap_err().is_syntax());
-
-    assert!(from_str::<String>("").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"\\").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"\\u").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"\\u0").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"\\u00").unwrap_err().is_eof());
-    assert!(from_str::<String>("\"\\u000").unwrap_err().is_eof());
-
-    assert!(from_str::<Vec<usize>>("[").unwrap_err().is_eof());
-    assert!(from_str::<Vec<usize>>("[0").unwrap_err().is_eof());
-    assert!(from_str::<Vec<usize>>("[0,").unwrap_err().is_eof());
-
-    assert!(from_str::<BTreeMap<String, usize>>("{")
-        .unwrap_err()
-        .is_eof());
-    assert!(from_str::<BTreeMap<String, usize>>("{\"k\"")
-        .unwrap_err()
-        .is_eof());
-    assert!(from_str::<BTreeMap<String, usize>>("{\"k\":")
-        .unwrap_err()
-        .is_eof());
-    assert!(from_str::<BTreeMap<String, usize>>("{\"k\":0")
-        .unwrap_err()
-        .is_eof());
-    assert!(from_str::<BTreeMap<String, usize>>("{\"k\":0,")
-        .unwrap_err()
-        .is_eof());
-
-    let fail = FailReader(io::ErrorKind::NotConnected);
-    assert!(from_reader::<_, String>(fail).unwrap_err().is_io());
-}
-
-#[test]
-// Clippy false positive: https://github.com/Manishearth/rust-clippy/issues/292
-#[allow(clippy::needless_lifetimes)]
-fn test_into_io_error() {
-    fn io_error<'de, T: Deserialize<'de> + Debug>(j: &'static str) -> io::Error {
-        from_str::<T>(j).unwrap_err().into()
-    }
-
-    assert_eq!(
-        io_error::<String>("\"\\u").kind(),
-        io::ErrorKind::UnexpectedEof
-    );
-    assert_eq!(io_error::<String>("0").kind(), io::ErrorKind::InvalidData);
-    assert_eq!(io_error::<String>("]").kind(), io::ErrorKind::InvalidData);
-
-    let fail = FailReader(io::ErrorKind::NotConnected);
-    let io_err: io::Error = from_reader::<_, u8>(fail).unwrap_err().into();
-    assert_eq!(io_err.kind(), io::ErrorKind::NotConnected);
-}
-
-#[test]
-fn test_borrow() {
-    let s: &str = from_str("\"borrowed\"").unwrap();
-    assert_eq!("borrowed", s);
-
-    let s: &str = from_slice(b"\"borrowed\"").unwrap();
-    assert_eq!("borrowed", s);
-}
-
-#[test]
-fn null_invalid_type() {
-    let err = serde_json::from_str::<String>("null").unwrap_err();
-    assert_eq!(
-        format!("{}", err),
-        String::from("invalid type: null, expected a string at line 1 column 4")
-    );
-}
-
-#[test]
-fn test_integer128() {
-    let signed = &[i128::min_value(), -1, 0, 1, i128::max_value()];
-    let unsigned = &[0, 1, u128::max_value()];
-
-    for integer128 in signed {
-        let expected = integer128.to_string();
-        assert_eq!(to_string(integer128).unwrap(), expected);
-        assert_eq!(from_str::<i128>(&expected).unwrap(), *integer128);
-    }
-
-    for integer128 in unsigned {
-        let expected = integer128.to_string();
-        assert_eq!(to_string(integer128).unwrap(), expected);
-        assert_eq!(from_str::<u128>(&expected).unwrap(), *integer128);
-    }
-
-    test_parse_err::<i128>(&[
-        (
-            "-170141183460469231731687303715884105729",
-            "number out of range at line 1 column 40",
-        ),
-        (
-            "170141183460469231731687303715884105728",
-            "number out of range at line 1 column 39",
-        ),
-    ]);
-
-    test_parse_err::<u128>(&[
-        ("-1", "number out of range at line 1 column 1"),
-        (
-            "340282366920938463463374607431768211456",
-            "number out of range at line 1 column 39",
-        ),
-    ]);
-}
-
-#[test]
-fn test_integer128_to_value() {
-    let signed = &[i128::from(i64::min_value()), i128::from(u64::max_value())];
-    let unsigned = &[0, u128::from(u64::max_value())];
-
-    for integer128 in signed {
-        let expected = integer128.to_string();
-        assert_eq!(to_value(integer128).unwrap().to_string(), expected);
-    }
-
-    for integer128 in unsigned {
-        let expected = integer128.to_string();
-        assert_eq!(to_value(integer128).unwrap().to_string(), expected);
-    }
-
-    if !cfg!(feature = "arbitrary_precision") {
-        let err = to_value(u128::from(u64::max_value()) + 1).unwrap_err();
-        assert_eq!(err.to_string(), "number out of range");
-    }
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_borrowed_raw_value() {
-    #[derive(Serialize, Deserialize)]
-    struct Wrapper<'a> {
-        a: i8,
-        #[serde(borrow)]
-        b: &'a RawValue,
-        c: i8,
-    }
-
-    let wrapper_from_str: Wrapper =
-        serde_json::from_str(r#"{"a": 1, "b": {"foo": 2}, "c": 3}"#).unwrap();
-    assert_eq!(r#"{"foo": 2}"#, wrapper_from_str.b.get());
-
-    let wrapper_to_string = serde_json::to_string(&wrapper_from_str).unwrap();
-    assert_eq!(r#"{"a":1,"b":{"foo": 2},"c":3}"#, wrapper_to_string);
-
-    let wrapper_to_value = serde_json::to_value(&wrapper_from_str).unwrap();
-    assert_eq!(json!({"a": 1, "b": {"foo": 2}, "c": 3}), wrapper_to_value);
-
-    let array_from_str: Vec<&RawValue> =
-        serde_json::from_str(r#"["a", 42, {"foo": "bar"}, null]"#).unwrap();
-    assert_eq!(r#""a""#, array_from_str[0].get());
-    assert_eq!(r#"42"#, array_from_str[1].get());
-    assert_eq!(r#"{"foo": "bar"}"#, array_from_str[2].get());
-    assert_eq!(r#"null"#, array_from_str[3].get());
-
-    let array_to_string = serde_json::to_string(&array_from_str).unwrap();
-    assert_eq!(r#"["a",42,{"foo": "bar"},null]"#, array_to_string);
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_raw_value_in_map_key() {
-    #[derive(RefCast)]
-    #[repr(transparent)]
-    struct RawMapKey(RawValue);
-
-    impl<'de> Deserialize<'de> for &'de RawMapKey {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            let raw_value = <&RawValue>::deserialize(deserializer)?;
-            Ok(RawMapKey::ref_cast(raw_value))
-        }
-    }
-
-    impl PartialEq for RawMapKey {
-        fn eq(&self, other: &Self) -> bool {
-            self.0.get() == other.0.get()
-        }
-    }
-
-    impl Eq for RawMapKey {}
-
-    impl Hash for RawMapKey {
-        fn hash<H: Hasher>(&self, hasher: &mut H) {
-            self.0.get().hash(hasher);
-        }
-    }
-
-    let map_from_str: HashMap<&RawMapKey, &RawValue> =
-        serde_json::from_str(r#" {"\\k":"\\v"} "#).unwrap();
-    let (map_k, map_v) = map_from_str.into_iter().next().unwrap();
-    assert_eq!("\"\\\\k\"", map_k.0.get());
-    assert_eq!("\"\\\\v\"", map_v.get());
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_boxed_raw_value() {
-    #[derive(Serialize, Deserialize)]
-    struct Wrapper {
-        a: i8,
-        b: Box<RawValue>,
-        c: i8,
-    }
-
-    let wrapper_from_str: Wrapper =
-        serde_json::from_str(r#"{"a": 1, "b": {"foo": 2}, "c": 3}"#).unwrap();
-    assert_eq!(r#"{"foo": 2}"#, wrapper_from_str.b.get());
-
-    let wrapper_from_reader: Wrapper =
-        serde_json::from_reader(br#"{"a": 1, "b": {"foo": 2}, "c": 3}"#.as_ref()).unwrap();
-    assert_eq!(r#"{"foo": 2}"#, wrapper_from_reader.b.get());
-
-    let wrapper_from_value: Wrapper =
-        serde_json::from_value(json!({"a": 1, "b": {"foo": 2}, "c": 3})).unwrap();
-    assert_eq!(r#"{"foo":2}"#, wrapper_from_value.b.get());
-
-    let wrapper_to_string = serde_json::to_string(&wrapper_from_str).unwrap();
-    assert_eq!(r#"{"a":1,"b":{"foo": 2},"c":3}"#, wrapper_to_string);
-
-    let wrapper_to_value = serde_json::to_value(&wrapper_from_str).unwrap();
-    assert_eq!(json!({"a": 1, "b": {"foo": 2}, "c": 3}), wrapper_to_value);
-
-    let array_from_str: Vec<Box<RawValue>> =
-        serde_json::from_str(r#"["a", 42, {"foo": "bar"}, null]"#).unwrap();
-    assert_eq!(r#""a""#, array_from_str[0].get());
-    assert_eq!(r#"42"#, array_from_str[1].get());
-    assert_eq!(r#"{"foo": "bar"}"#, array_from_str[2].get());
-    assert_eq!(r#"null"#, array_from_str[3].get());
-
-    let array_from_reader: Vec<Box<RawValue>> =
-        serde_json::from_reader(br#"["a", 42, {"foo": "bar"}, null]"#.as_ref()).unwrap();
-    assert_eq!(r#""a""#, array_from_reader[0].get());
-    assert_eq!(r#"42"#, array_from_reader[1].get());
-    assert_eq!(r#"{"foo": "bar"}"#, array_from_reader[2].get());
-    assert_eq!(r#"null"#, array_from_reader[3].get());
-
-    let array_to_string = serde_json::to_string(&array_from_str).unwrap();
-    assert_eq!(r#"["a",42,{"foo": "bar"},null]"#, array_to_string);
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_raw_invalid_utf8() {
-    let j = &[b'"', b'\xCE', b'\xF8', b'"'];
-    let value_err = serde_json::from_slice::<Value>(j).unwrap_err();
-    let raw_value_err = serde_json::from_slice::<Box<RawValue>>(j).unwrap_err();
-
-    assert_eq!(
-        value_err.to_string(),
-        "invalid unicode code point at line 1 column 4",
-    );
-    assert_eq!(
-        raw_value_err.to_string(),
-        "invalid unicode code point at line 1 column 4",
-    );
-}
-
-#[cfg(feature = "raw_value")]
-#[test]
-fn test_serialize_unsized_value_to_raw_value() {
-    assert_eq!(
-        serde_json::value::to_raw_value("foobar").unwrap().get(),
-        r#""foobar""#,
-    );
-}
-
-#[test]
-fn test_borrow_in_map_key() {
-    #[derive(Deserialize, Debug)]
-    struct Outer {
-        #[allow(dead_code)]
-        map: BTreeMap<MyMapKey, ()>,
-    }
-
-    #[derive(Ord, PartialOrd, Eq, PartialEq, Debug)]
-    struct MyMapKey(usize);
-
-    impl<'de> Deserialize<'de> for MyMapKey {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: de::Deserializer<'de>,
-        {
-            let s = <&str>::deserialize(deserializer)?;
-            let n = s.parse().map_err(de::Error::custom)?;
-            Ok(MyMapKey(n))
-        }
-    }
-
-    let value = json!({ "map": { "1": null } });
-    Outer::deserialize(&value).unwrap();
-}
-
-#[test]
-fn test_value_into_deserializer() {
-    #[derive(Deserialize)]
-    struct Outer {
-        inner: Inner,
-    }
-
-    #[derive(Deserialize)]
-    struct Inner {
-        string: String,
-    }
-
-    let mut map = BTreeMap::new();
-    map.insert("inner", json!({ "string": "Hello World" }));
-
-    let outer = Outer::deserialize(serde::de::value::MapDeserializer::new(
-        map.iter().map(|(k, v)| (*k, v)),
-    ))
-    .unwrap();
-    assert_eq!(outer.inner.string, "Hello World");
-
-    let outer = Outer::deserialize(map.into_deserializer()).unwrap();
-    assert_eq!(outer.inner.string, "Hello World");
-}
-
-#[test]
-fn hash_positive_and_negative_zero() {
-    let rand = std::hash::RandomState::new();
-
-    let k1 = serde_json::from_str::<Number>("0.0").unwrap();
-    let k2 = serde_json::from_str::<Number>("-0.0").unwrap();
-    if cfg!(feature = "arbitrary_precision") {
-        assert_ne!(k1, k2);
-        assert_ne!(rand.hash_one(k1), rand.hash_one(k2));
-    } else {
-        assert_eq!(k1, k2);
-        assert_eq!(rand.hash_one(k1), rand.hash_one(k2));
-    }
-}
diff --git a/vendor/serde_json/tests/ui/missing_colon.rs b/vendor/serde_json/tests/ui/missing_colon.rs
deleted file mode 100644
index d93b7b9..0000000
--- a/vendor/serde_json/tests/ui/missing_colon.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "a" });
-}
diff --git a/vendor/serde_json/tests/ui/missing_colon.stderr b/vendor/serde_json/tests/ui/missing_colon.stderr
deleted file mode 100644
index 1515211..0000000
--- a/vendor/serde_json/tests/ui/missing_colon.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: unexpected end of macro invocation
- --> tests/ui/missing_colon.rs:4:5
-  |
-4 |     json!({ "a" });
-  |     ^^^^^^^^^^^^^^ missing tokens in macro arguments
-  |
-note: while trying to match `@`
- --> src/macros.rs
-  |
-  |     (@array [$($elems:expr,)*]) => {
-  |      ^
-  = note: this error originates in the macro `json_internal` which comes from the expansion of the macro `json` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/serde_json/tests/ui/missing_comma.rs b/vendor/serde_json/tests/ui/missing_comma.rs
deleted file mode 100644
index 8818c3e..0000000
--- a/vendor/serde_json/tests/ui/missing_comma.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "1": "" "2": "" });
-}
diff --git a/vendor/serde_json/tests/ui/missing_comma.stderr b/vendor/serde_json/tests/ui/missing_comma.stderr
deleted file mode 100644
index bafa0f8..0000000
--- a/vendor/serde_json/tests/ui/missing_comma.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error: no rules expected the token `"2"`
- --> tests/ui/missing_comma.rs:4:21
-  |
-4 |     json!({ "1": "" "2": "" });
-  |                    -^^^ no rules expected this token in macro call
-  |                    |
-  |                    help: missing comma here
-  |
-note: while trying to match `,`
- --> src/macros.rs
-  |
-  |     ($e:expr , $($tt:tt)*) => {};
-  |              ^
diff --git a/vendor/serde_json/tests/ui/missing_value.rs b/vendor/serde_json/tests/ui/missing_value.rs
deleted file mode 100644
index 0ba14e2..0000000
--- a/vendor/serde_json/tests/ui/missing_value.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "a" : });
-}
diff --git a/vendor/serde_json/tests/ui/missing_value.stderr b/vendor/serde_json/tests/ui/missing_value.stderr
deleted file mode 100644
index 9c9de99..0000000
--- a/vendor/serde_json/tests/ui/missing_value.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: unexpected end of macro invocation
- --> tests/ui/missing_value.rs:4:5
-  |
-4 |     json!({ "a" : });
-  |     ^^^^^^^^^^^^^^^^ missing tokens in macro arguments
-  |
-note: while trying to match `@`
- --> src/macros.rs
-  |
-  |     (@array [$($elems:expr,)*]) => {
-  |      ^
-  = note: this error originates in the macro `json_internal` which comes from the expansion of the macro `json` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/serde_json/tests/ui/not_found.rs b/vendor/serde_json/tests/ui/not_found.rs
deleted file mode 100644
index 2df6870..0000000
--- a/vendor/serde_json/tests/ui/not_found.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "a" : x });
-}
diff --git a/vendor/serde_json/tests/ui/not_found.stderr b/vendor/serde_json/tests/ui/not_found.stderr
deleted file mode 100644
index 6fec180..0000000
--- a/vendor/serde_json/tests/ui/not_found.stderr
+++ /dev/null
@@ -1,5 +0,0 @@
-error[E0425]: cannot find value `x` in this scope
- --> tests/ui/not_found.rs:4:19
-  |
-4 |     json!({ "a" : x });
-  |                   ^ not found in this scope
diff --git a/vendor/serde_json/tests/ui/parse_expr.rs b/vendor/serde_json/tests/ui/parse_expr.rs
deleted file mode 100644
index e7f1805..0000000
--- a/vendor/serde_json/tests/ui/parse_expr.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "a" : ~ });
-}
diff --git a/vendor/serde_json/tests/ui/parse_expr.stderr b/vendor/serde_json/tests/ui/parse_expr.stderr
deleted file mode 100644
index cd3e1c9..0000000
--- a/vendor/serde_json/tests/ui/parse_expr.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: no rules expected the token `~`
- --> tests/ui/parse_expr.rs:4:19
-  |
-4 |     json!({ "a" : ~ });
-  |                   ^ no rules expected this token in macro call
-  |
-note: while trying to match meta-variable `$e:expr`
- --> src/macros.rs
-  |
-  |     ($e:expr , $($tt:tt)*) => {};
-  |      ^^^^^^^
diff --git a/vendor/serde_json/tests/ui/parse_key.rs b/vendor/serde_json/tests/ui/parse_key.rs
deleted file mode 100644
index 858bd71..0000000
--- a/vendor/serde_json/tests/ui/parse_key.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "".s : true });
-}
diff --git a/vendor/serde_json/tests/ui/parse_key.stderr b/vendor/serde_json/tests/ui/parse_key.stderr
deleted file mode 100644
index 15662dc..0000000
--- a/vendor/serde_json/tests/ui/parse_key.stderr
+++ /dev/null
@@ -1,5 +0,0 @@
-error[E0609]: no field `s` on type `&'static str`
- --> tests/ui/parse_key.rs:4:16
-  |
-4 |     json!({ "".s : true });
-  |                ^ unknown field
diff --git a/vendor/serde_json/tests/ui/unexpected_after_array_element.rs b/vendor/serde_json/tests/ui/unexpected_after_array_element.rs
deleted file mode 100644
index 226c58c..0000000
--- a/vendor/serde_json/tests/ui/unexpected_after_array_element.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!([ true => ]);
-}
diff --git a/vendor/serde_json/tests/ui/unexpected_after_array_element.stderr b/vendor/serde_json/tests/ui/unexpected_after_array_element.stderr
deleted file mode 100644
index ef449f7..0000000
--- a/vendor/serde_json/tests/ui/unexpected_after_array_element.stderr
+++ /dev/null
@@ -1,7 +0,0 @@
-error: no rules expected the token `=>`
- --> tests/ui/unexpected_after_array_element.rs:4:18
-  |
-4 |     json!([ true => ]);
-  |                  ^^ no rules expected this token in macro call
-  |
-  = note: while trying to match end of macro
diff --git a/vendor/serde_json/tests/ui/unexpected_after_map_entry.rs b/vendor/serde_json/tests/ui/unexpected_after_map_entry.rs
deleted file mode 100644
index 0dfb731..0000000
--- a/vendor/serde_json/tests/ui/unexpected_after_map_entry.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "k": true => });
-}
diff --git a/vendor/serde_json/tests/ui/unexpected_after_map_entry.stderr b/vendor/serde_json/tests/ui/unexpected_after_map_entry.stderr
deleted file mode 100644
index c62d90b..0000000
--- a/vendor/serde_json/tests/ui/unexpected_after_map_entry.stderr
+++ /dev/null
@@ -1,7 +0,0 @@
-error: no rules expected the token `=>`
- --> tests/ui/unexpected_after_map_entry.rs:4:23
-  |
-4 |     json!({ "k": true => });
-  |                       ^^ no rules expected this token in macro call
-  |
-  = note: while trying to match end of macro
diff --git a/vendor/serde_json/tests/ui/unexpected_colon.rs b/vendor/serde_json/tests/ui/unexpected_colon.rs
deleted file mode 100644
index e767ea6..0000000
--- a/vendor/serde_json/tests/ui/unexpected_colon.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ : true });
-}
diff --git a/vendor/serde_json/tests/ui/unexpected_colon.stderr b/vendor/serde_json/tests/ui/unexpected_colon.stderr
deleted file mode 100644
index 7e47726..0000000
--- a/vendor/serde_json/tests/ui/unexpected_colon.stderr
+++ /dev/null
@@ -1,7 +0,0 @@
-error: no rules expected the token `:`
- --> tests/ui/unexpected_colon.rs:4:13
-  |
-4 |     json!({ : true });
-  |             ^ no rules expected this token in macro call
-  |
-  = note: while trying to match end of macro
diff --git a/vendor/serde_json/tests/ui/unexpected_comma.rs b/vendor/serde_json/tests/ui/unexpected_comma.rs
deleted file mode 100644
index 338874e..0000000
--- a/vendor/serde_json/tests/ui/unexpected_comma.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use serde_json::json;
-
-fn main() {
-    json!({ "a" , "b": true });
-}
diff --git a/vendor/serde_json/tests/ui/unexpected_comma.stderr b/vendor/serde_json/tests/ui/unexpected_comma.stderr
deleted file mode 100644
index 552f399..0000000
--- a/vendor/serde_json/tests/ui/unexpected_comma.stderr
+++ /dev/null
@@ -1,7 +0,0 @@
-error: no rules expected the token `,`
- --> tests/ui/unexpected_comma.rs:4:17
-  |
-4 |     json!({ "a" , "b": true });
-  |                 ^ no rules expected this token in macro call
-  |
-  = note: while trying to match end of macro
author	Valentin Popov <valentin@popov.link>	2024-07-19 15:37:58 +0300
committer	Valentin Popov <valentin@popov.link>	2024-07-19 15:37:58 +0300
commit	a990de90fe41456a23e58bd087d2f107d321f3a1 (patch)
tree	15afc392522a9e85dc3332235e311b7d39352ea9 /vendor/serde_json
parent	3d48cd3f81164bbfc1a755dc1d4a9a02f98c8ddd (diff)
download	fparkan-a990de90fe41456a23e58bd087d2f107d321f3a1.tar.xz fparkan-a990de90fe41456a23e58bd087d2f107d321f3a1.zip