Merging upstream version 1.73.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

19 files changed, 482 insertions, 249 deletions

diff --git a/vendor/serde_json/.cargo-checksum.json b/vendor/serde_json/.cargo-checksum.json
index 9e3a8f7f3..6e738fc99 100644
--- a/vendor/serde_json/.cargo-checksum.json
+++ b/vendor/serde_json/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"CONTRIBUTING.md":"f5270cafba66223a7b51ffc0d286075a17bb7cd88762fc80d333d3102629f4d8","Cargo.toml":"1092f991b7dea8f3bdd3bec644a2cfa2e9dc0e120f9e2ba6e2b7e01a8d3d6ce1","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"1e5a86e6b5e79f92f9e7226d9a8ba16d4ec70567d153c9cacebcb582770378a1","build.rs":"0dd97b63a07aa2d4bbb4c7d0e73b521da130769da9f49f28a7b63332781eb3de","src/de.rs":"322236fb65fb9d62b21fea19e3115997d7d6bb8a8bc4f16d77003354a64f887d","src/error.rs":"b16e56a5d689edf278f6feac758ad76a79d0f91222b8eec5637b48bf6d7022de","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":"4fbeb1994049348d1fc388dd1a29e481f8abb8fe1e28bfebf50f3bbce5fa5fbe","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":"a265b9072194a62a67dfc4df3c86d4213097cf3f82280d025e0012a5a262fd9d","src/lexical/errors.rs":"6bc993febceb7dd96ac1c8c5c53b5f5a30297016c0f813ed8ff8d7938d01534d","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":"27e22b724cdf990cdacd0ccfc3749e6e2eb7529d43ebf6e95b1999560b9e199a","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":"a75516c3daa3d3165fcf970e29e3a111584525cb678dbe713c78c7b7749d5ed2","src/macros.rs":"516f69976f433bcc5e48c32b3e29c2e0ab7b549810827d7a9c59171cdf11c1e2","src/map.rs":"14fa16650b462ef138bebe1d18cb296b0e1ff404f12f2c212f72ed7c969b3a12","src/number.rs":"50633e05cfa4be84b69eb0321cf176ee0a34f7120046c2f927ebdbb625c60048","src/raw.rs":"6d46836486b8d1c58f2aff563285400b1b0ec163eee34e7be78e0fa7a99aa0e8","src/read.rs":"49b4b1d067b6485cbded28fb961666ab5df82c36661af722dbae756efb6b2891","src/ser.rs":"edd6af71f1a576cac2396966b9de79f717048114e3794a2231dbf1733af03bac","src/value/de.rs":"78f938d960e285f671f3b86ed173d598a815690a14512d6daa94dee43d3ce4cf","src/value/from.rs":"eceab6531422c820a443981c2a71c9ba01e032fbbd38884d1ac6d03175d56244","src/value/index.rs":"8a99d8d50f5674181ced22f6e81dc529eaecb01e543e30346e51fe42cb4b8a5f","src/value/mod.rs":"81c62fcb50e92b2f424e361328df5b02621756781bf80b8e26fd3d13473b57cd","src/value/partial_eq.rs":"b64e1e1dffd50fefe3106ca74499aac01ea3d76b995d3cc1ef3a2b2768d0f1cf","src/value/ser.rs":"e06311be9ace2f3805ec7aacf9a1663ace5494ffae1b7dc16870f96b6d6561e1","tests/compiletest.rs":"022a8e400ef813d7ea1875b944549cee5125f6a995dc33e93b48cba3e1b57bd1","tests/debug.rs":"a8451217c1e127ad6e653ef11e0513525ee350e1e37dd575758a8ee9301b28fb","tests/lexical.rs":"b65eaef5edbc3294751c6ddc0a51eaf8de9165d65955f87c2e3b2679a49de3b0","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":"17c73e0a59d462716d974b8dd23a291eb6efdc3a933248874e5eab7e7209d67f","tests/lexical/rounding.rs":"6c56e39ba534616c1b2146e8efa6eb57aed322e683bf23183cd32a61fae6447e","tests/macros/mod.rs":"93aa1d54af20bc2c55b6ae8db73c1414cda2626eb9fa7bd57b9d613a3c6e6a19","tests/map.rs":"dcc5212242e4e93703c4335d54f5603b0211b33d6fb5ab410bb630cda6d46b09","tests/regression.rs":"86731134bfb9bb693d9a4fc62393027de80a8bf031109ea6c7ea475b1ebdde8d","tests/regression/issue1004.rs":"38d7e3b6c515b881078ebd21ca8063d2ca105cd319695d29538f879e37f091b5","tests/regression/issue520.rs":"d146be3472db902b48127d65fe83aa9f698143aca9074c83cd1a9d5dd28e3ec3","tests/regression/issue795.rs":"582e2e7c68113f05a4b1d2cb556a2df7cc77f2ce8164a32c5cc58ae68abb60ec","tests/regression/issue845.rs":"8bd64588fc344e119d0e9e5e7604236e7c168c574b0692033f15278e216a6b9c","tests/regression/issue953.rs":"b2cddc761f5ca6639900c173765a8a5868528a896924e5e925db2696469208f7","tests/stream.rs":"c7d91014538ecd8f495b196d40e999ab2745f2e69fa2ff9e52521605dc6ce856","tests/test.rs":"0fb9f0470b9ee1a8dd29c4ff5ded04da84a4d477db75a5e96705950c50e0ade2","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":"fcb44e060b804a4762b7291e128c41d7010ffa8ab820b8828fd13fbe6d405ca6","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":"46266871c240a00b8f503b877622fe33430b3c7d963bdc0f2adc511e54a1eae3"}
\ No newline at end of file
+{"files":{"CONTRIBUTING.md":"f5270cafba66223a7b51ffc0d286075a17bb7cd88762fc80d333d3102629f4d8","Cargo.toml":"8b667a3ab7e788a8a705440fc910533402f7de07d99d0acc01918c11acbf389d","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"1e5a86e6b5e79f92f9e7226d9a8ba16d4ec70567d153c9cacebcb582770378a1","build.rs":"0dd97b63a07aa2d4bbb4c7d0e73b521da130769da9f49f28a7b63332781eb3de","src/de.rs":"286a87b0a9330bcc2f73d31bc8d18de2b3ef92d0cb9d80bb5f08f09d4e8791ed","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":"d47c39c92dd8dedeb60cf3ace34a6e2e00cb3bf1deb30bcc857864f6903e67f3","src/macros.rs":"516f69976f433bcc5e48c32b3e29c2e0ab7b549810827d7a9c59171cdf11c1e2","src/map.rs":"b268a714042a3a2ce39878a5ae2eeac305460ccb6615b4b90b96ea38cf7b9e5d","src/number.rs":"21c95a6a8be8df5e2e4e7653984138640c6eb1d3d1b69f2f3841645c25b2226c","src/raw.rs":"d76153f2e8ccb8e770ae9c688c7ca93c3a56c1891c7ef1c0b49a215bb4da52ae","src/read.rs":"49b4b1d067b6485cbded28fb961666ab5df82c36661af722dbae756efb6b2891","src/ser.rs":"8affcb67c9e1ea2fc37d5b3138ca402f71f30cf226680c4d8df9aa7459422895","src/value/de.rs":"1333996bc3e9a7adf5f1ca17715003efbd552555252543bcd1c8b0ce3e7bb0b3","src/value/from.rs":"d17ecf4407137d87b1c00b0d3855655923f850c4b668a6c3b670b248e7bf8061","src/value/index.rs":"8a99d8d50f5674181ced22f6e81dc529eaecb01e543e30346e51fe42cb4b8a5f","src/value/mod.rs":"ee7305db19bcf9e9f0bcca8844ce46bf36efe41f6dadc14884d9cf0985f1bf7a","src/value/partial_eq.rs":"b64e1e1dffd50fefe3106ca74499aac01ea3d76b995d3cc1ef3a2b2768d0f1cf","src/value/ser.rs":"b0f7f65b4df27505f516d6926982100e15ffc978c7aea9be5131a8616b337fb8","tests/compiletest.rs":"022a8e400ef813d7ea1875b944549cee5125f6a995dc33e93b48cba3e1b57bd1","tests/debug.rs":"a8451217c1e127ad6e653ef11e0513525ee350e1e37dd575758a8ee9301b28fb","tests/lexical.rs":"b65eaef5edbc3294751c6ddc0a51eaf8de9165d65955f87c2e3b2679a49de3b0","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":"17c73e0a59d462716d974b8dd23a291eb6efdc3a933248874e5eab7e7209d67f","tests/lexical/rounding.rs":"6c56e39ba534616c1b2146e8efa6eb57aed322e683bf23183cd32a61fae6447e","tests/macros/mod.rs":"93aa1d54af20bc2c55b6ae8db73c1414cda2626eb9fa7bd57b9d613a3c6e6a19","tests/map.rs":"dcc5212242e4e93703c4335d54f5603b0211b33d6fb5ab410bb630cda6d46b09","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":"2cc1c3164a2e6e7e6346e74cb2b3bba1c87631495bc5e6406e6e8e5739213690","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":"fcb44e060b804a4762b7291e128c41d7010ffa8ab820b8828fd13fbe6d405ca6","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":"076066c5f1078eac5b722a31827a8832fe108bed65dfa75e233c89f8206e976c"}
\ No newline at end of file
diff --git a/vendor/serde_json/Cargo.toml b/vendor/serde_json/Cargo.toml
index 41855c58f..72f486eeb 100644
--- a/vendor/serde_json/Cargo.toml
+++ b/vendor/serde_json/Cargo.toml
@@ -10,10 +10,10 @@
 # See Cargo.toml.orig for the original contents.
 
 [package]
-edition = "2018"
-rust-version = "1.36"
+edition = "2021"
+rust-version = "1.56"
 name = "serde_json"
-version = "1.0.99"
+version = "1.0.104"
 authors = [
     "Erick Tryzelaar <erick.tryzelaar@gmail.com>",
     "David Tolnay <dtolnay@gmail.com>",
@@ -42,6 +42,7 @@ features = [
 rustdoc-args = [
     "--cfg",
     "docsrs",
+    "--generate-link-to-definition",
 ]
 targets = ["x86_64-unknown-linux-gnu"]
 
@@ -62,36 +63,36 @@ version = "1.0"
 version = "1.0"
 
 [dependencies.serde]
-version = "1.0.100"
+version = "1.0.166"
 default-features = false
 
 [dev-dependencies.automod]
-version = "1.0"
+version = "1.0.11"
 
 [dev-dependencies.indoc]
-version = "2.0"
+version = "2.0.2"
 
 [dev-dependencies.ref-cast]
-version = "1.0"
+version = "1.0.18"
 
 [dev-dependencies.rustversion]
-version = "1.0"
+version = "1.0.13"
 
 [dev-dependencies.serde]
-version = "1.0.100"
+version = "1.0.166"
 features = ["derive"]
 
 [dev-dependencies.serde_bytes]
-version = "0.11"
+version = "0.11.10"
 
 [dev-dependencies.serde_derive]
-version = "1.0"
+version = "1.0.166"
 
 [dev-dependencies.serde_stacker]
-version = "0.1"
+version = "0.1.8"
 
 [dev-dependencies.trybuild]
-version = "1.0.49"
+version = "1.0.81"
 features = ["diff"]
 
 [features]
diff --git a/vendor/serde_json/src/de.rs b/vendor/serde_json/src/de.rs
index 4b16ba2a8..7f3145980 100644
--- a/vendor/serde_json/src/de.rs
+++ b/vendor/serde_json/src/de.rs
@@ -209,7 +209,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         self.disable_recursion_limit = true;
     }
 
-    fn peek(&mut self) -> Result<Option<u8>> {
+    pub(crate) fn peek(&mut self) -> Result<Option<u8>> {
         self.read.peek()
     }
 
@@ -248,7 +248,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
     fn parse_whitespace(&mut self) -> Result<Option<u8>> {
         loop {
             match tri!(self.peek()) {
-                Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => {
+                Some(b' ' | b'\n' | b'\t' | b'\r') => {
                     self.eat_char();
                 }
                 other => {
@@ -309,9 +309,9 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         self.fix_position(err)
     }
 
-    fn deserialize_number<V>(&mut self, visitor: V) -> Result<V::Value>
+    pub(crate) fn deserialize_number<'any, V>(&mut self, visitor: V) -> Result<V::Value>
     where
-        V: de::Visitor<'de>,
+        V: de::Visitor<'any>,
     {
         let peek = match tri!(self.parse_whitespace()) {
             Some(b) => b,
@@ -335,6 +335,79 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         }
     }
 
+    #[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' => {
@@ -860,7 +933,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         if !positive {
             buf.push('-');
         }
-        self.scan_integer(&mut buf)?;
+        tri!(self.scan_integer(&mut buf));
         if positive {
             if let Ok(unsigned) = buf.parse() {
                 return Ok(ParserNumber::U64(unsigned));
@@ -913,7 +986,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
     fn scan_number(&mut self, buf: &mut String) -> Result<()> {
         match tri!(self.peek_or_null()) {
             b'.' => self.scan_decimal(buf),
-            e @ b'e' | e @ b'E' => self.scan_exponent(e as char, buf),
+            e @ (b'e' | b'E') => self.scan_exponent(e as char, buf),
             _ => Ok(()),
         }
     }
@@ -938,7 +1011,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
         }
 
         match tri!(self.peek_or_null()) {
-            e @ b'e' | e @ b'E' => self.scan_exponent(e as char, buf),
+            e @ (b'e' | b'E') => self.scan_exponent(e as char, buf),
             _ => Ok(()),
         }
     }
@@ -1059,7 +1132,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
                     tri!(self.read.ignore_str());
                     None
                 }
-                frame @ b'[' | frame @ b'{' => {
+                frame @ (b'[' | b'{') => {
                     self.scratch.extend(enclosing.take());
                     self.eat_char();
                     Some(frame)
@@ -1204,9 +1277,9 @@ impl<'de, R: Read<'de>> Deserializer<R> {
     where
         V: de::Visitor<'de>,
     {
-        self.parse_whitespace()?;
+        tri!(self.parse_whitespace());
         self.read.begin_raw_buffering();
-        self.ignore_value()?;
+        tri!(self.ignore_value());
         self.read.end_raw_buffering(visitor)
     }
 }
@@ -1258,11 +1331,15 @@ static POW10: [f64; 309] = [
 
 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.deserialize_number(visitor)
+            self.$using(visitor)
         }
     };
 }
@@ -1424,77 +1501,9 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
     deserialize_number!(deserialize_f64);
 
     #[cfg(feature = "float_roundtrip")]
-    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.single_precision = true;
-        let val = self.deserialize_number(visitor);
-        self.single_precision = false;
-        val
-    }
-
-    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        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)),
-        }
-    }
-
-    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: de::Visitor<'de>,
-    {
-        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)),
-        }
-    }
+    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
@@ -2118,24 +2127,47 @@ struct MapKey<'a, R: 'a> {
     de: &'a mut Deserializer<R>,
 }
 
-macro_rules! deserialize_integer_key {
-    ($method:ident => $visit:ident) => {
+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();
-            self.de.scratch.clear();
-            let string = tri!(self.de.read.parse_str(&mut self.de.scratch));
-            match (string.parse(), string) {
-                (Ok(integer), _) => visitor.$visit(integer),
-                (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s),
-                (Err(_), Reference::Copied(s)) => visitor.visit_str(s),
+
+            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>,
@@ -2155,16 +2187,21 @@ where
         }
     }
 
-    deserialize_integer_key!(deserialize_i8 => visit_i8);
-    deserialize_integer_key!(deserialize_i16 => visit_i16);
-    deserialize_integer_key!(deserialize_i32 => visit_i32);
-    deserialize_integer_key!(deserialize_i64 => visit_i64);
-    deserialize_integer_key!(deserialize_i128 => visit_i128);
-    deserialize_integer_key!(deserialize_u8 => visit_u8);
-    deserialize_integer_key!(deserialize_u16 => visit_u16);
-    deserialize_integer_key!(deserialize_u32 => visit_u32);
-    deserialize_integer_key!(deserialize_u64 => visit_u64);
-    deserialize_integer_key!(deserialize_u128 => visit_u128);
+    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);
 
     #[inline]
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
@@ -2221,8 +2258,8 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map
-        struct identifier ignored_any
+        bool char str string unit unit_struct seq tuple tuple_struct map struct
+        identifier ignored_any
     }
 }
 
@@ -2318,8 +2355,8 @@ where
 
     fn peek_end_of_value(&mut self) -> Result<()> {
         match tri!(self.de.peek()) {
-            Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[')
-            | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()),
+            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(
diff --git a/vendor/serde_json/src/error.rs b/vendor/serde_json/src/error.rs
index 7ba3a4edd..03555eb4c 100644
--- a/vendor/serde_json/src/error.rs
+++ b/vendor/serde_json/src/error.rs
@@ -64,12 +64,15 @@ impl Error {
             | 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
@@ -264,6 +267,9 @@ pub(crate) enum ErrorCode {
     /// Expected this character to start a JSON value.
     ExpectedSomeValue,
 
+    /// Expected this character to be a `"`.
+    ExpectedDoubleQuote,
+
     /// Invalid hex escape code.
     InvalidEscape,
 
@@ -282,6 +288,12 @@ pub(crate) enum ErrorCode {
     /// 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,
 
@@ -348,6 +360,7 @@ impl Display for ErrorCode {
             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"),
@@ -356,6 +369,12 @@ impl Display for ErrorCode {
                 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")
             }
diff --git a/vendor/serde_json/src/lexical/algorithm.rs b/vendor/serde_json/src/lexical/algorithm.rs
index a2cbf18af..eaa5e7ebc 100644
--- a/vendor/serde_json/src/lexical/algorithm.rs
+++ b/vendor/serde_json/src/lexical/algorithm.rs
@@ -51,7 +51,10 @@ where
         // 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 = mantissa.checked_mul(power)?;
+        let value = match mantissa.checked_mul(power) {
+            None => return None,
+            Some(value) => value,
+        };
         if value >> mantissa_size != 0 {
             None
         } else {
diff --git a/vendor/serde_json/src/lexical/digit.rs b/vendor/serde_json/src/lexical/digit.rs
index 882aa9eef..3d150a1af 100644
--- a/vendor/serde_json/src/lexical/digit.rs
+++ b/vendor/serde_json/src/lexical/digit.rs
@@ -11,5 +11,8 @@ pub(crate) fn to_digit(c: u8) -> Option<u32> {
 // Add digit to mantissa.
 #[inline]
 pub(crate) fn add_digit(value: u64, digit: u32) -> Option<u64> {
-    value.checked_mul(10)?.checked_add(digit as 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
index cad4bd3d5..f4f41cdc5 100644
--- a/vendor/serde_json/src/lexical/errors.rs
+++ b/vendor/serde_json/src/lexical/errors.rs
@@ -5,8 +5,7 @@
 //! 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
+//! found here: <https://golang.org/src/strconv/atof.go>
 
 use super::float::*;
 use super::num::*;
diff --git a/vendor/serde_json/src/lexical/math.rs b/vendor/serde_json/src/lexical/math.rs
index 37cc1d24a..d7122bffa 100644
--- a/vendor/serde_json/src/lexical/math.rs
+++ b/vendor/serde_json/src/lexical/math.rs
@@ -336,7 +336,7 @@ mod small {
     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 x.iter_mut() {
+        for xi in &mut *x {
             carry = scalar::imul(xi, y, carry);
         }
 
@@ -482,7 +482,7 @@ mod small {
         let rshift = bits - n;
         let lshift = n;
         let mut prev: Limb = 0;
-        for xi in x.iter_mut() {
+        for xi in &mut *x {
             let tmp = *xi;
             *xi <<= lshift;
             *xi |= prev >> rshift;
diff --git a/vendor/serde_json/src/lib.rs b/vendor/serde_json/src/lib.rs
index 227a87bd8..c322ed8a4 100644
--- a/vendor/serde_json/src/lib.rs
+++ b/vendor/serde_json/src/lib.rs
@@ -300,7 +300,7 @@
 //! [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.99")]
+#![doc(html_root_url = "https://docs.rs/serde_json/1.0.104")]
 // Ignored clippy lints
 #![allow(
     clippy::collapsible_else_if,
@@ -315,18 +315,12 @@
     clippy::match_single_binding,
     clippy::needless_doctest_main,
     clippy::needless_late_init,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/8366
-    clippy::ptr_arg,
     clippy::return_self_not_must_use,
     clippy::transmute_ptr_to_ptr,
-    clippy::unnecessary_wraps,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-    clippy::unnested_or_patterns,
+    clippy::unnecessary_wraps
 )]
 // Ignored clippy_pedantic lints
 #![allow(
-    // buggy
-    clippy::iter_not_returning_iterator, // https://github.com/rust-lang/rust-clippy/issues/8285
     // Deserializer::from_str, into_iter
     clippy::should_implement_trait,
     // integer and float ser/de requires these sorts of casts
@@ -362,6 +356,8 @@
     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)]
diff --git a/vendor/serde_json/src/map.rs b/vendor/serde_json/src/map.rs
index 3e8a3814c..a1b622294 100644
--- a/vendor/serde_json/src/map.rs
+++ b/vendor/serde_json/src/map.rs
@@ -11,7 +11,7 @@ use alloc::string::String;
 use core::borrow::Borrow;
 use core::fmt::{self, Debug};
 use core::hash::Hash;
-use core::iter::{FromIterator, FusedIterator};
+use core::iter::FusedIterator;
 #[cfg(feature = "preserve_order")]
 use core::mem;
 use core::ops;
diff --git a/vendor/serde_json/src/number.rs b/vendor/serde_json/src/number.rs
index 5ecbde873..7ff66681d 100644
--- a/vendor/serde_json/src/number.rs
+++ b/vendor/serde_json/src/number.rs
@@ -361,8 +361,8 @@ impl Serialize for Number {
     {
         use serde::ser::SerializeStruct;
 
-        let mut s = serializer.serialize_struct(TOKEN, 1)?;
-        s.serialize_field(TOKEN, &self.n)?;
+        let mut s = tri!(serializer.serialize_struct(TOKEN, 1));
+        tri!(s.serialize_field(TOKEN, &self.n));
         s.end()
     }
 }
@@ -406,11 +406,11 @@ impl<'de> Deserialize<'de> for Number {
             where
                 V: de::MapAccess<'de>,
             {
-                let value = visitor.next_key::<NumberKey>()?;
+                let value = tri!(visitor.next_key::<NumberKey>());
                 if value.is_none() {
                     return Err(de::Error::invalid_type(Unexpected::Map, &self));
                 }
-                let v: NumberFromString = visitor.next_value()?;
+                let v: NumberFromString = tri!(visitor.next_value());
                 Ok(v.value)
             }
         }
@@ -449,7 +449,7 @@ impl<'de> de::Deserialize<'de> for NumberKey {
             }
         }
 
-        deserializer.deserialize_identifier(FieldVisitor)?;
+        tri!(deserializer.deserialize_identifier(FieldVisitor));
         Ok(NumberKey)
     }
 }
@@ -552,7 +552,7 @@ macro_rules! deserialize_number {
         where
             V: de::Visitor<'de>,
         {
-            visitor.$visit(self.n.parse().map_err(|_| invalid_number())?)
+            visitor.$visit(tri!(self.n.parse().map_err(|_| invalid_number())))
         }
     };
 }
diff --git a/vendor/serde_json/src/raw.rs b/vendor/serde_json/src/raw.rs
index 6aa4ffcb6..651f4797d 100644
--- a/vendor/serde_json/src/raw.rs
+++ b/vendor/serde_json/src/raw.rs
@@ -177,11 +177,9 @@ impl RawValue {
     /// - 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 = crate::from_str::<&Self>(&json)?;
-            if borrowed.json.len() < json.len() {
-                return Ok(borrowed.to_owned());
-            }
+        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()))
     }
@@ -287,7 +285,7 @@ pub fn to_raw_value<T>(value: &T) -> Result<Box<RawValue>, Error>
 where
     T: ?Sized + Serialize,
 {
-    let json_string = crate::to_string(value)?;
+    let json_string = tri!(crate::to_string(value));
     Ok(RawValue::from_owned(json_string.into_boxed_str()))
 }
 
@@ -298,8 +296,8 @@ impl Serialize for RawValue {
     where
         S: Serializer,
     {
-        let mut s = serializer.serialize_struct(TOKEN, 1)?;
-        s.serialize_field(TOKEN, &self.json)?;
+        let mut s = tri!(serializer.serialize_struct(TOKEN, 1));
+        tri!(s.serialize_field(TOKEN, &self.json));
         s.end()
     }
 }
@@ -322,7 +320,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue {
             where
                 V: MapAccess<'de>,
             {
-                let value = visitor.next_key::<RawKey>()?;
+                let value = tri!(visitor.next_key::<RawKey>());
                 if value.is_none() {
                     return Err(de::Error::invalid_type(Unexpected::Map, &self));
                 }
@@ -352,7 +350,7 @@ impl<'de> Deserialize<'de> for Box<RawValue> {
             where
                 V: MapAccess<'de>,
             {
-                let value = visitor.next_key::<RawKey>()?;
+                let value = tri!(visitor.next_key::<RawKey>());
                 if value.is_none() {
                     return Err(de::Error::invalid_type(Unexpected::Map, &self));
                 }
@@ -392,7 +390,7 @@ impl<'de> Deserialize<'de> for RawKey {
             }
         }
 
-        deserializer.deserialize_identifier(FieldVisitor)?;
+        tri!(deserializer.deserialize_identifier(FieldVisitor));
         Ok(RawKey)
     }
 }
diff --git a/vendor/serde_json/src/ser.rs b/vendor/serde_json/src/ser.rs
index 820825d37..6bb6fd761 100644
--- a/vendor/serde_json/src/ser.rs
+++ b/vendor/serde_json/src/ser.rs
@@ -189,12 +189,9 @@ where
 
     #[inline]
     fn serialize_bytes(self, value: &[u8]) -> Result<()> {
-        use serde::ser::SerializeSeq;
-        let mut seq = tri!(self.serialize_seq(Some(value.len())));
-        for byte in value {
-            tri!(seq.serialize_element(byte));
-        }
-        seq.end()
+        self.formatter
+            .write_byte_array(&mut self.writer, value)
+            .map_err(Error::io)
     }
 
     #[inline]
@@ -439,17 +436,15 @@ where
             .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")));
-                }
+        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
@@ -789,6 +784,10 @@ 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,
@@ -1002,12 +1001,46 @@ where
             .map_err(Error::io)
     }
 
-    fn serialize_f32(self, _value: f32) -> Result<()> {
-        Err(key_must_be_a_string())
+    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<()> {
-        Err(key_must_be_a_string())
+    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<()> {
@@ -1734,6 +1767,24 @@ pub trait Formatter {
         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]
diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs
index 9c266d08a..2090dd009 100644
--- a/vendor/serde_json/src/value/de.rs
+++ b/vendor/serde_json/src/value/de.rs
@@ -1,4 +1,4 @@
-use crate::error::Error;
+use crate::error::{Error, ErrorCode};
 use crate::map::Map;
 use crate::number::Number;
 use crate::value::Value;
@@ -106,15 +106,15 @@ impl<'de> Deserialize<'de> for Value {
             where
                 V: MapAccess<'de>,
             {
-                match visitor.next_key_seed(KeyClassifier)? {
+                match tri!(visitor.next_key_seed(KeyClassifier)) {
                     #[cfg(feature = "arbitrary_precision")]
                     Some(KeyClass::Number) => {
-                        let number: NumberFromString = visitor.next_value()?;
+                        let number: NumberFromString = tri!(visitor.next_value());
                         Ok(Value::Number(number.value))
                     }
                     #[cfg(feature = "raw_value")]
                     Some(KeyClass::RawValue) => {
-                        let value = visitor.next_value_seed(crate::raw::BoxedFromString)?;
+                        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)) => {
@@ -482,6 +482,14 @@ impl<'de> IntoDeserializer<'de, Error> for Value {
     }
 }
 
+impl<'de> IntoDeserializer<'de, Error> for &'de Value {
+    type Deserializer = Self;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        self
+    }
+}
+
 struct VariantDeserializer {
     value: Option<Value>,
 }
@@ -1120,18 +1128,30 @@ struct MapKeyDeserializer<'de> {
     key: Cow<'de, str>,
 }
 
-macro_rules! deserialize_integer_key {
-    ($method:ident => $visit:ident) => {
+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>,
         {
-            match (self.key.parse(), self.key) {
-                (Ok(integer), _) => visitor.$visit(integer),
-                (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
-                #[cfg(any(feature = "std", feature = "alloc"))]
-                (Err(_), Cow::Owned(s)) => visitor.visit_string(s),
+            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)
         }
     };
 }
@@ -1146,16 +1166,22 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
         BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
     }
 
-    deserialize_integer_key!(deserialize_i8 => visit_i8);
-    deserialize_integer_key!(deserialize_i16 => visit_i16);
-    deserialize_integer_key!(deserialize_i32 => visit_i32);
-    deserialize_integer_key!(deserialize_i64 => visit_i64);
-    deserialize_integer_key!(deserialize_i128 => visit_i128);
-    deserialize_integer_key!(deserialize_u8 => visit_u8);
-    deserialize_integer_key!(deserialize_u16 => visit_u16);
-    deserialize_integer_key!(deserialize_u32 => visit_u32);
-    deserialize_integer_key!(deserialize_u64 => visit_u64);
-    deserialize_integer_key!(deserialize_u128 => visit_u128);
+    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);
 
     #[inline]
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
@@ -1193,7 +1219,7 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
     }
 
     forward_to_deserialize_any! {
-        bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
+        bool char str string bytes byte_buf unit unit_struct seq tuple
         tuple_struct map struct identifier ignored_any
     }
 }
@@ -1327,7 +1353,7 @@ impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
     where
         T: de::DeserializeSeed<'de>,
     {
-        let value = seed.deserialize(self)?;
+        let value = tri!(seed.deserialize(self));
         Ok((value, UnitOnly))
     }
 }
diff --git a/vendor/serde_json/src/value/from.rs b/vendor/serde_json/src/value/from.rs
index 462ad3f51..159592ba8 100644
--- a/vendor/serde_json/src/value/from.rs
+++ b/vendor/serde_json/src/value/from.rs
@@ -4,7 +4,6 @@ use crate::number::Number;
 use alloc::borrow::Cow;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
-use core::iter::FromIterator;
 
 macro_rules! from_integer {
     ($($ty:ident)*) => {
diff --git a/vendor/serde_json/src/value/mod.rs b/vendor/serde_json/src/value/mod.rs
index 470b6b24d..79ffe9488 100644
--- a/vendor/serde_json/src/value/mod.rs
+++ b/vendor/serde_json/src/value/mod.rs
@@ -182,11 +182,11 @@ impl Debug for Value {
             Value::Number(number) => Debug::fmt(number, formatter),
             Value::String(string) => write!(formatter, "String({:?})", string),
             Value::Array(vec) => {
-                formatter.write_str("Array ")?;
+                tri!(formatter.write_str("Array "));
                 Debug::fmt(vec, formatter)
             }
             Value::Object(map) => {
-                formatter.write_str("Object ")?;
+                tri!(formatter.write_str("Object "));
                 Debug::fmt(map, formatter)
             }
         }
@@ -889,7 +889,6 @@ mod ser;
 /// ```
 /// use serde::Serialize;
 /// use serde_json::json;
-///
 /// use std::error::Error;
 ///
 /// #[derive(Serialize)]
@@ -898,7 +897,7 @@ mod ser;
 ///     location: String,
 /// }
 ///
-/// fn compare_json_values() -> Result<(), Box<Error>> {
+/// fn compare_json_values() -> Result<(), Box<dyn Error>> {
 ///     let u = User {
 ///         fingerprint: "0xF9BA143B95FF6D82".to_owned(),
 ///         location: "Menlo Park, CA".to_owned(),
diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs
index 875d22e24..6ca53d4c5 100644
--- a/vendor/serde_json/src/value/ser.rs
+++ b/vendor/serde_json/src/value/ser.rs
@@ -4,8 +4,6 @@ use crate::value::{to_value, Value};
 use alloc::borrow::ToOwned;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
-#[cfg(not(feature = "arbitrary_precision"))]
-use core::convert::TryFrom;
 use core::fmt::Display;
 use core::result;
 use serde::ser::{Impossible, Serialize};
@@ -451,6 +449,10 @@ 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;
@@ -517,12 +519,20 @@ impl serde::Serializer for MapKeySerializer {
         Ok(value.to_string())
     }
 
-    fn serialize_f32(self, _value: f32) -> Result<String> {
-        Err(key_must_be_a_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> {
-        Err(key_must_be_a_string())
+    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]
@@ -640,7 +650,7 @@ impl serde::ser::SerializeStruct for SerializeMap {
             #[cfg(feature = "arbitrary_precision")]
             SerializeMap::Number { out_value } => {
                 if key == crate::number::TOKEN {
-                    *out_value = Some(value.serialize(NumberValueEmitter)?);
+                    *out_value = Some(tri!(value.serialize(NumberValueEmitter)));
                     Ok(())
                 } else {
                     Err(invalid_number())
@@ -649,7 +659,7 @@ impl serde::ser::SerializeStruct for SerializeMap {
             #[cfg(feature = "raw_value")]
             SerializeMap::RawValue { out_value } => {
                 if key == crate::raw::TOKEN {
-                    *out_value = Some(value.serialize(RawValueEmitter)?);
+                    *out_value = Some(tri!(value.serialize(RawValueEmitter)));
                     Ok(())
                 } else {
                     Err(invalid_raw_value())
diff --git a/vendor/serde_json/tests/regression/issue845.rs b/vendor/serde_json/tests/regression/issue845.rs
index 56037ae66..e8b0c0fd0 100644
--- a/vendor/serde_json/tests/regression/issue845.rs
+++ b/vendor/serde_json/tests/regression/issue845.rs
@@ -1,7 +1,6 @@
 #![allow(clippy::trait_duplication_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/8757
 
 use serde::{Deserialize, Deserializer};
-use std::convert::TryFrom;
 use std::fmt::{self, Display};
 use std::marker::PhantomData;
 use std::str::FromStr;
diff --git a/vendor/serde_json/tests/test.rs b/vendor/serde_json/tests/test.rs
index 6c08cc8d2..8d9a5942a 100644
--- a/vendor/serde_json/tests/test.rs
+++ b/vendor/serde_json/tests/test.rs
@@ -53,7 +53,7 @@ macro_rules! treemap {
     () => {
         BTreeMap::new()
     };
-    ($($k:expr => $v:expr),+) => {
+    ($($k:expr => $v:expr),+ $(,)?) => {
         {
             let mut m = BTreeMap::new();
             $(
@@ -264,7 +264,7 @@ fn test_write_object() {
         (
             treemap!(
                 "a".to_string() => true,
-                "b".to_string() => false
+                "b".to_string() => false,
             ),
             "{\"a\":true,\"b\":false}",
         ),
@@ -275,7 +275,7 @@ fn test_write_object() {
             treemap![
                 "a".to_string() => treemap![],
                 "b".to_string() => treemap![],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             "{\"a\":{},\"b\":{},\"c\":{}}",
         ),
@@ -284,10 +284,10 @@ fn test_write_object() {
                 "a".to_string() => treemap![
                     "a".to_string() => treemap!["a" => vec![1,2,3]],
                     "b".to_string() => treemap![],
-                    "c".to_string() => treemap![]
+                    "c".to_string() => treemap![],
                 ],
                 "b".to_string() => treemap![],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             "{\"a\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"b\":{},\"c\":{}}",
         ),
@@ -297,9 +297,9 @@ fn test_write_object() {
                 "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![],
                 ],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             "{\"a\":{},\"b\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}},\"c\":{}}",
         ),
@@ -310,8 +310,8 @@ fn test_write_object() {
                 "c".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\":{},\"c\":{\"a\":{\"a\":[1,2,3]},\"b\":{},\"c\":{}}}",
         ),
@@ -324,7 +324,7 @@ fn test_write_object() {
             treemap![
                 "a".to_string() => treemap![],
                 "b".to_string() => treemap![],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             pretty_str!({
                 "a": {},
@@ -337,10 +337,10 @@ fn test_write_object() {
                 "a".to_string() => treemap![
                     "a".to_string() => treemap!["a" => vec![1,2,3]],
                     "b".to_string() => treemap![],
-                    "c".to_string() => treemap![]
+                    "c".to_string() => treemap![],
                 ],
                 "b".to_string() => treemap![],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             pretty_str!({
                 "a": {
@@ -364,9 +364,9 @@ fn test_write_object() {
                 "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![],
                 ],
-                "c".to_string() => treemap![]
+                "c".to_string() => treemap![],
             ],
             pretty_str!({
                 "a": {},
@@ -391,8 +391,8 @@ fn test_write_object() {
                 "c".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": {},
@@ -423,7 +423,7 @@ fn test_write_object() {
         (
             treemap!(
                 "a".to_string() => true,
-                "b".to_string() => false
+                "b".to_string() => false,
             ),
             pretty_str!( {
                 "a": true,
@@ -1192,8 +1192,8 @@ fn test_parse_object() {
         treemap!(
             "a".to_string() => treemap!(
                 "b".to_string() => 3u64,
-                "c".to_string() => 4
-            )
+                "c".to_string() => 4,
+            ),
         ),
     )]);
 
@@ -1369,7 +1369,7 @@ fn test_parse_enum() {
         ),
         treemap!(
             "a".to_string() => Animal::Dog,
-            "b".to_string() => Animal::Frog("Henry".to_string(), vec![])
+            "b".to_string() => Animal::Frog("Henry".to_string(), vec![]),
         ),
     )]);
 }
@@ -1452,7 +1452,6 @@ fn test_serialize_seq_with_no_len() {
     where
         T: ser::Serialize,
     {
-        #[inline]
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: ser::Serializer,
@@ -1479,7 +1478,6 @@ fn test_serialize_seq_with_no_len() {
             formatter.write_str("array")
         }
 
-        #[inline]
         fn visit_unit<E>(self) -> Result<MyVec<T>, E>
         where
             E: de::Error,
@@ -1487,7 +1485,6 @@ fn test_serialize_seq_with_no_len() {
             Ok(MyVec(Vec::new()))
         }
 
-        #[inline]
         fn visit_seq<V>(self, mut visitor: V) -> Result<MyVec<T>, V::Error>
         where
             V: de::SeqAccess<'de>,
@@ -1538,7 +1535,6 @@ fn test_serialize_map_with_no_len() {
         K: ser::Serialize + Ord,
         V: ser::Serialize,
     {
-        #[inline]
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: ser::Serializer,
@@ -1566,7 +1562,6 @@ fn test_serialize_map_with_no_len() {
             formatter.write_str("map")
         }
 
-        #[inline]
         fn visit_unit<E>(self) -> Result<MyMap<K, V>, E>
         where
             E: de::Error,
@@ -1574,7 +1569,6 @@ fn test_serialize_map_with_no_len() {
             Ok(MyMap(BTreeMap::new()))
         }
 
-        #[inline]
         fn visit_map<Visitor>(self, mut visitor: Visitor) -> Result<MyMap<K, V>, Visitor::Error>
         where
             Visitor: de::MapAccess<'de>,
@@ -1664,7 +1658,7 @@ fn test_deserialize_from_stream() {
 fn test_serialize_rejects_bool_keys() {
     let map = treemap!(
         true => 2,
-        false => 4
+        false => 4,
     );
 
     let err = to_vec(&map).unwrap_err();
@@ -1676,7 +1670,7 @@ fn test_serialize_rejects_adt_keys() {
     let map = treemap!(
         Some("a") => 2,
         Some("b") => 4,
-        None => 6
+        None => 6,
     );
 
     let err = to_vec(&map).unwrap_err();
@@ -1890,23 +1884,41 @@ fn test_integer_key() {
     // map with integer keys
     let map = treemap!(
         1 => 2,
-        -1 => 6
+        -1 => 6,
     );
     let j = r#"{"-1":6,"1":2}"#;
     test_encode_ok(&[(&map, j)]);
     test_parse_ok(vec![(j, map)]);
 
-    let j = r#"{"x":null}"#;
-    test_parse_err::<BTreeMap<i32, ()>>(&[(
-        j,
-        "invalid type: string \"x\", expected i32 at line 1 column 4",
-    )]);
+    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 => ()
+        100000000000000000000000000000000000000u128 => (),
     };
     let j = r#"{"100000000000000000000000000000000000000":null}"#;
     assert_eq!(to_string(&map).unwrap(), j);
@@ -1914,20 +1926,95 @@ fn test_integer128_key() {
 }
 
 #[test]
-fn test_deny_float_key() {
-    #[derive(Eq, PartialEq, Ord, PartialOrd)]
+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.0)
+            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");
+    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());
 }
 
@@ -1954,7 +2041,7 @@ fn test_effectively_string_keys() {
     }
     let map = treemap! {
         Enum::One => 1,
-        Enum::Two => 2
+        Enum::Two => 2,
     };
     let expected = r#"{"One":1,"Two":2}"#;
     test_encode_ok(&[(&map, expected)]);
@@ -1964,7 +2051,7 @@ fn test_effectively_string_keys() {
     struct Wrapper(String);
     let map = treemap! {
         Wrapper("zero".to_owned()) => 0,
-        Wrapper("one".to_owned()) => 1
+        Wrapper("one".to_owned()) => 1,
     };
     let expected = r#"{"one":1,"zero":0}"#;
     test_encode_ok(&[(&map, expected)]);
@@ -2385,6 +2472,12 @@ fn test_value_into_deserializer() {
     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");
 }