Merging upstream version 1.71.1+dfsg1.

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

35 files changed, 1099 insertions, 435 deletions

diff --git a/vendor/zerovec/.cargo-checksum.json b/vendor/zerovec/.cargo-checksum.json
index fbf1303f2..52d626117 100644
--- a/vendor/zerovec/.cargo-checksum.json
+++ b/vendor/zerovec/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.lock":"ab1a55fa6a0e30a1509d639a0a0c77f500470ddaf6b34a1a9e83ecd7931b9648","Cargo.toml":"977eb85b9a33c508f31264b230c72c66cbf1fd11de723ac79153c1b4f3080b58","LICENSE":"4ad7541d66a407234e2c84902124cef325c29f3e966353efdb800bedb8b8da21","README.md":"6f1174cdbf3467cb6f02e6f715bf105b833cea392995c18ed28cda871c4e15fa","benches/testdata/large_hashmap.postcard":"f327c7c25ee0ac05e0c2052ee38b76c77968240e084477b0f703b5a0bc6f4ccf","benches/testdata/large_zeromap.postcard":"d0f15324e7e3bf8318e87fefad9249c0bda8e8d555c220f81467e0a90270059a","benches/vzv.rs":"2b0de82b4a40d45151e7faa2d18cfcb65351059f3f391dd64f031c565212c561","benches/zeromap.rs":"eb001722b4158a405610d2cb8aa4ccbb53d5e29ea0898639912cf7d55598de6c","benches/zerovec.rs":"e32e380e653c62b1f344cb7be917016b739b2c4e722d62193aa3fa45908e77c0","benches/zerovec_iai.rs":"13028e4f1d85bad3ee5e5b783360b7ea247dd5de233d104b91ce46d19bf5765a","benches/zerovec_serde.rs":"7ed92aaaf5981755b4f02f366e1a0434b49a4a6ffa0945c96663626d787db070","examples/zv_serde.rs":"d7fd49aba0400636c1af16ac1cbf28f8d74c61a94ee7b318dcaf23213acec1e8","src/error.rs":"19ca9ab31b2b16cb0f604ed5f4a43c18796672bfd498af334b47aad76059b143","src/flexzerovec/databake.rs":"a32503b5aa4c3e4d5627e91ab0ec0ffbc40983dab93ba9062e4672ee1e7d0335","src/flexzerovec/mod.rs":"647678116fcf0321463b3451462920f7c517f4cf6c8a57f4f7b13f5248c8b9b0","src/flexzerovec/owned.rs":"dc6ea4cdc1b147f9e64f89281a0315fa729d134617a694646463013314e3ab46","src/flexzerovec/serde.rs":"a0c7a8fcf5ef06f5ea44cbfb89cac47f173c7150082d0cd745a457de3d375b4f","src/flexzerovec/slice.rs":"6c115b32011d127bb59f1818e7d1061a0786a8b2d4d7d174f43acf02189d73eb","src/flexzerovec/vec.rs":"103b72950ae6be8d1fd4c8db07460c2b6203c87927b722807d329177e8d41d48","src/lib.rs":"0e91c4fb200f27665b509796fd4d0672578d140502721a645fe068f23d6aa2bd","src/map/borrowed.rs":"abd5886b384075780498ddc39300eeeda0bc520bdee1cea43096f50a9ac42f07","src/map/databake.rs":"29afbc7882f30ce63596e2cb98f589f24bd76919d7062a18f02a5df630f31dce","src/map/kv.rs":"03f3745df8d61ff399b66d32ba1ac9a7ee298ca00dfb463c3ea8d81c746e9d41","src/map/map.rs":"d0298742d6f46ca39f3ebc9f0761ab2997523da40df5c9ea9515a8584b266c50","src/map/mod.rs":"4961ad14522fcef16b1aad804d9559c0a5eb2582fdd163bf76f9629cb765b6c4","src/map/serde.rs":"3bed09076a45774c65a8116dd21e72413f1657ed569fe32c4abb48e979fd3144","src/map/serde_helpers.rs":"72787005972b93e49b9dc17aa47d30699364e6da9dc95aadb820ce58e4bf5c54","src/map/vecs.rs":"86c9b04a92b7a918af3653e05fbf622fbb1b52b0a4307a5dadef070882778233","src/map2d/borrowed.rs":"f2a1f927c6d0942fd8ad183de24a32a2b1450f2f747cb328862163f6d9505ebb","src/map2d/cursor.rs":"e4447e7b5869e895b852124443151918bff5fe8cfb5207acfe5ff7b57b56bfdf","src/map2d/databake.rs":"c9451511566f9589236789c8dc5fbb32112a8324bd9b4bae75cd3be05b42962c","src/map2d/map.rs":"358408292de4c06e82f6eebf2f014d3737241f383d8fc3c946bfb44da1071b3b","src/map2d/mod.rs":"80beae7a263f1fe39c9a06d287c9150480fe3ed43397c2a7475a50ee2b2fd37f","src/map2d/serde.rs":"c4f32f25bc6e850eccd677e5b0cf9cd796df71855b80459893c0323ad7901bd5","src/samples.rs":"a3a2571da3a911f20bad9179441ba2676f4e5cf1ca2408a4dc6111cadbcef6cd","src/ule/chars.rs":"f8b32dd407dcc05b7d416c361d7a7c2166708d1edaa0559c829bd449dcb0a7aa","src/ule/custom.rs":"49604e3c1d67836a7e783b91ef2bfeaddfbe4758d6c5614ce3cd1ae60cfdb5ea","src/ule/encode.rs":"91a11ff2f2ddf3dffc1411343e286249e63b0cfa076d6c41f83ea952c527b014","src/ule/mod.rs":"4a71652bb0d771aee247518a1c50e72bdea12fd884feaf7f55385808047069ef","src/ule/multi.rs":"ed470e4b62c6233ee81b33f473eccf1e8db75db52275ec371cdc2b477478d959","src/ule/niche.rs":"1c64b5862cd7f1cd384160012a39414a335ea1f36119bb5fc56ac7cb5e050d8b","src/ule/option.rs":"32979913da36452a27951e3f073494006c26f570af5733a1b0ce5a75427300b4","src/ule/plain.rs":"27f47ce32cbcb62ef088dbd60dbb9d79c2d54e1a3ff024cdc863362542b74336","src/ule/slices.rs":"a7638535898b39be9f489f3ff9a2140b5334113c2ddc48c4fae2bc8b86efbd14","src/ule/tuple.rs":"498f6863b1af1e6b2c655e77df53cf9818613c60189b2ce1369850e388d09e3c","src/ule/unvalidated.rs":"a92f2e94ba8bb50b6f63914549501653aa0622b6d6810824c271afe37edc367a","src/varzerovec/components.rs":"6810dc5cf007572a4e22831f55822f79f720e29309c33b1c546057fd5dedfb61","src/varzerovec/databake.rs":"819c6e511e4256cb0c1e3fbf2bad521472f133355ce0cc12e46c97ec2f71dbb2","src/varzerovec/mod.rs":"c7aaaf571f7406e666d877920966a2e39373b5cf6a038cb31dbe4192b2e75d4d","src/varzerovec/owned.rs":"0aac2dd14fde57c22f4b5a943756ee90001d824d04682336782700c1f7efd272","src/varzerovec/serde.rs":"efb06a8b139dffc6d0534f7e0de4dc39b82ed224481f25bc5dea14d0159b5208","src/varzerovec/slice.rs":"4524631711cfa9ac530f116fc2801526d1d14e7a21ead10aa2bfb3f4de298cac","src/varzerovec/vec.rs":"6557bc9a146cc6563a17a62c3e8d38b68ba1451ff99d5741d0bbdb5b67703573","src/yoke_impls.rs":"3d2486b99eda20cc2c9dd6360d5589f95e6b2bfce847c3637b91134836f73566","src/zerofrom_impls.rs":"a3e02b3473cf6deba8c0e9dd815ad7db7ced75e7ad3b353597faea189b63c1d5","src/zerovec/databake.rs":"8d1f857fa89b8b64c7a5e2b2ba84d06b266b3cf6c716bc383c9004a6602c5d43","src/zerovec/mod.rs":"777a70ac94f0c80869f4576d8aaad5c96083a94eb3c3db86ebc98b4805b4a0ff","src/zerovec/serde.rs":"3a088c88732ffc0814a09777f89a83857e948c1eff6dfc2d1eb6bad5ece3976a","src/zerovec/slice.rs":"49c29036ddc9efee1fc327152a78e9d20f8f8174a71468dfe6d68a6437882419"},"package":"154df60c74c4a844bc04a53cef4fc18a909d3ea07e19f5225eaba86209da3aa6"}
\ No newline at end of file
+{"files":{"Cargo.lock":"b0241085abfd43aac61f2c8f19b0050bacd4a1683b0a90cbe771cf19f6d857a3","Cargo.toml":"6ac032c0ea72eed9cd65ac50548b2caccfb973c6c6ac027ea66ab47a3f7bd497","LICENSE":"4ad7541d66a407234e2c84902124cef325c29f3e966353efdb800bedb8b8da21","README.md":"6f1174cdbf3467cb6f02e6f715bf105b833cea392995c18ed28cda871c4e15fa","benches/testdata/large_hashmap.postcard":"f327c7c25ee0ac05e0c2052ee38b76c77968240e084477b0f703b5a0bc6f4ccf","benches/testdata/large_zerohashmap.postcard":"a78c257adb577b56ac09075645a1ef5771307ec84011ab047482b1e899612ad5","benches/testdata/large_zeromap.postcard":"d0f15324e7e3bf8318e87fefad9249c0bda8e8d555c220f81467e0a90270059a","benches/vzv.rs":"2b0de82b4a40d45151e7faa2d18cfcb65351059f3f391dd64f031c565212c561","benches/zeromap.rs":"b54fd73a41872ad25415378a04bcf2fce375daf0c2226cf6b5813618310497fc","benches/zerovec.rs":"e32e380e653c62b1f344cb7be917016b739b2c4e722d62193aa3fa45908e77c0","benches/zerovec_iai.rs":"13028e4f1d85bad3ee5e5b783360b7ea247dd5de233d104b91ce46d19bf5765a","benches/zerovec_serde.rs":"7ed92aaaf5981755b4f02f366e1a0434b49a4a6ffa0945c96663626d787db070","examples/zv_serde.rs":"d292088928926579479f2dedd942200b2a5274cbbae9bdd88031193cdd1af297","src/error.rs":"03abb5dbae8dd371fca01700d6caeb012204f3a15b9cbd6d843c7d4261b8f868","src/flexzerovec/databake.rs":"d02876dba1fc3df04301c4706451ccfc99ddedc8efb675b822ec4c79cdb9816d","src/flexzerovec/mod.rs":"647678116fcf0321463b3451462920f7c517f4cf6c8a57f4f7b13f5248c8b9b0","src/flexzerovec/owned.rs":"473b7834d04794098b16f84c164c7d4dcd08eb0468fbec78f2362c701cd2ce48","src/flexzerovec/serde.rs":"a0c7a8fcf5ef06f5ea44cbfb89cac47f173c7150082d0cd745a457de3d375b4f","src/flexzerovec/slice.rs":"12c5024f84b0476f45a3dd0eb1b33599f8bd1bd039d9929bd9d3b7c8df5251e0","src/flexzerovec/vec.rs":"06c0d672941f7a8d2c80de2ecdb71996f099cb30cff065f7048825fd4500328f","src/hashmap/algorithms.rs":"37d14b650b51b1000943f1ef7f2aa4df6f202a02947717cdaaed4e5a099e920e","src/hashmap/mod.rs":"ab4e6284d9ac16fc113368637722a3c2b94f2264c6eee79fadc6431eb9e06825","src/hashmap/serde.rs":"bf85ac1e3bf0449d32338c75816e22b1f7b172aead273856441ab19787e6ca22","src/lib.rs":"30060475b78ee663df74185a0fb3659b427ca6490fb66411b697ddc0503f3d82","src/map/borrowed.rs":"c04dc9329cabae4bfd3a3aba54f2899d55c3f2e80351cc82519d9b7282606e54","src/map/databake.rs":"52e3ae299fe8e023e8c14674dffdbef8cf8eb2c81dba08d3e6045dce07cf9688","src/map/kv.rs":"03f3745df8d61ff399b66d32ba1ac9a7ee298ca00dfb463c3ea8d81c746e9d41","src/map/map.rs":"d0298742d6f46ca39f3ebc9f0761ab2997523da40df5c9ea9515a8584b266c50","src/map/mod.rs":"4961ad14522fcef16b1aad804d9559c0a5eb2582fdd163bf76f9629cb765b6c4","src/map/serde.rs":"3bed09076a45774c65a8116dd21e72413f1657ed569fe32c4abb48e979fd3144","src/map/serde_helpers.rs":"72787005972b93e49b9dc17aa47d30699364e6da9dc95aadb820ce58e4bf5c54","src/map/vecs.rs":"1606310a274626b92df1d6f03e17fb0561301eff56afbd83e9a13a990413564b","src/map2d/borrowed.rs":"f2a1f927c6d0942fd8ad183de24a32a2b1450f2f747cb328862163f6d9505ebb","src/map2d/cursor.rs":"e4447e7b5869e895b852124443151918bff5fe8cfb5207acfe5ff7b57b56bfdf","src/map2d/databake.rs":"3f392a378fd50cabd6d8b1ba0247d4da66ef0c16e14ece8e4a8617c6909fe1c3","src/map2d/map.rs":"59d3f88b2451c8298e9efac9cac3472054e76749584018eddf8edd517a422b17","src/map2d/mod.rs":"80beae7a263f1fe39c9a06d287c9150480fe3ed43397c2a7475a50ee2b2fd37f","src/map2d/serde.rs":"5a11d53e25e3fada3807878e67dc67d8a28968eae02631ac490d70c42c0e52b0","src/samples.rs":"a3a2571da3a911f20bad9179441ba2676f4e5cf1ca2408a4dc6111cadbcef6cd","src/ule/chars.rs":"b787bdb24023bbe232890aa73b270ef22949d3c758aac28822c52b5e366d633f","src/ule/custom.rs":"49604e3c1d67836a7e783b91ef2bfeaddfbe4758d6c5614ce3cd1ae60cfdb5ea","src/ule/encode.rs":"f8b784981e1b2bebef58eb425dd881fde1482ac18c2081245c9869d0fe080b6f","src/ule/mod.rs":"4a71652bb0d771aee247518a1c50e72bdea12fd884feaf7f55385808047069ef","src/ule/multi.rs":"ce74f323b3ca9fff3106ff0bba91bc9d6a6484e67ce4d0347b154973fe7ecb36","src/ule/niche.rs":"8cfec0c7f1c1ce65e3286d2d558c02ecdbfad848beeb8798ce1d0f4ae1d7b77b","src/ule/option.rs":"e695385b11f76a30c94fd1974ddbd7dcd2ef60acecd7808aa0965bc17a4828e9","src/ule/plain.rs":"27f47ce32cbcb62ef088dbd60dbb9d79c2d54e1a3ff024cdc863362542b74336","src/ule/slices.rs":"a7638535898b39be9f489f3ff9a2140b5334113c2ddc48c4fae2bc8b86efbd14","src/ule/tuple.rs":"498f6863b1af1e6b2c655e77df53cf9818613c60189b2ce1369850e388d09e3c","src/ule/unvalidated.rs":"a92f2e94ba8bb50b6f63914549501653aa0622b6d6810824c271afe37edc367a","src/varzerovec/components.rs":"b3cdc11db7bb79598f6a1b9107faa74f62d8713995c5b01a1def0e0f6fa8095c","src/varzerovec/databake.rs":"d6d14d56662b970c8ff04a9d29740400cfc549578e13c4105858d43adf6e4da8","src/varzerovec/mod.rs":"c7aaaf571f7406e666d877920966a2e39373b5cf6a038cb31dbe4192b2e75d4d","src/varzerovec/owned.rs":"dd5d42098e52e7b7b5a425ffc45899181200aa18f7502d2399c4c5b2bf6d46e6","src/varzerovec/serde.rs":"efb06a8b139dffc6d0534f7e0de4dc39b82ed224481f25bc5dea14d0159b5208","src/varzerovec/slice.rs":"4524631711cfa9ac530f116fc2801526d1d14e7a21ead10aa2bfb3f4de298cac","src/varzerovec/vec.rs":"d9eb72a571f83cd02b919373f26dec8c93179bc1a06cee145fd04a6d6083999c","src/yoke_impls.rs":"9539f89cf970e8672d0df42b3cf22da3efc503711b6cb12916d7254174519a91","src/zerofrom_impls.rs":"587b6e30555b259a109eb085bbc08963ec5fd28d943aa6369bfdf172a668292e","src/zerovec/databake.rs":"12b169cf86fa3f132af3b9d0560d7d8f8332969be90871e0c27a0ef4eceae333","src/zerovec/mod.rs":"f0981202b07c279d50e34ab5854383a65987e7690d7f7a9032255cc7fd523681","src/zerovec/serde.rs":"3a088c88732ffc0814a09777f89a83857e948c1eff6dfc2d1eb6bad5ece3976a","src/zerovec/slice.rs":"cd36bc4d24c37cb93a1baf6c78fcd4ea0440ecf271380217962bdff396ec680e"},"package":"198f54134cd865f437820aa3b43d0ad518af4e68ee161b444cdd15d8e567c8ea"}
\ No newline at end of file
diff --git a/vendor/zerovec/Cargo.lock b/vendor/zerovec/Cargo.lock
index f722be128..024b3554f 100644
--- a/vendor/zerovec/Cargo.lock
+++ b/vendor/zerovec/Cargo.lock
@@ -3,13 +3,10 @@
 version = 3
 
 [[package]]
-name = "atomic-polyfill"
-version = "0.1.11"
+name = "anes"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3ff7eb3f316534d83a8a2c3d1674ace8a5a71198eba31e2e2b597833f699b28"
-dependencies = [
- "critical-section",
-]
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "atty"
@@ -44,30 +41,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "bstr"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
-dependencies = [
- "lazy_static",
- "memchr",
- "regex-automata",
- "serde",
-]
-
-[[package]]
 name = "bumpalo"
 version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
 
 [[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
 name = "cast"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -75,19 +54,62 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
+name = "ciborium"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c137568cc60b904a7724001b35ce2630fd00d5d84805fbb608ab89509d788f"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346de753af073cc87b52b2083a506b38ac176a44cfb05497b622e27be899b369"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213030a2b5a4e0c0892b6652260cf6ccac84827b83a85a534e178e3906c4cf1b"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
 name = "clap"
-version = "2.34.0"
+version = "3.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
 dependencies = [
  "bitflags",
+ "clap_lex",
+ "indexmap",
  "textwrap",
- "unicode-width",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
 ]
 
 [[package]]
@@ -98,15 +120,16 @@ checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
 
 [[package]]
 name = "criterion"
-version = "0.3.6"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f"
+checksum = "e7c76e09c1aae2bc52b3d2f29e13c6572553b30c4aa1b8a49fd70de6412654cb"
 dependencies = [
+ "anes",
  "atty",
  "cast",
+ "ciborium",
  "clap",
  "criterion-plot",
- "csv",
  "itertools",
  "lazy_static",
  "num-traits",
@@ -115,7 +138,6 @@ dependencies = [
  "rayon",
  "regex",
  "serde",
- "serde_cbor",
  "serde_derive",
  "serde_json",
  "tinytemplate",
@@ -124,27 +146,21 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.4.5"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
  "itertools",
 ]
 
 [[package]]
-name = "critical-section"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6548a0ad5d2549e111e1f6a11a6c2e2d00ce6a3dafe22948d67c2b443f775e52"
-
-[[package]]
 name = "crossbeam-channel"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "crossbeam-utils",
 ]
 
@@ -154,7 +170,7 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
@@ -166,7 +182,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a"
 dependencies = [
  "autocfg",
- "cfg-if",
+ "cfg-if 1.0.0",
  "crossbeam-utils",
  "memoffset",
  "scopeguard",
@@ -178,36 +194,14 @@ version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"
 dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "csv"
-version = "1.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
-dependencies = [
- "bstr",
- "csv-core",
- "itoa 0.4.8",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
-dependencies = [
- "memchr",
+ "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "databake"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df626c4717e455cd7a70a82c4358630554a07e4341f86dd095c625f1474a2857"
+checksum = "3feab871d671ecc2e912e83e3a64b9b3343a224c86b999334c4c99b07cf07f52"
 dependencies = [
  "databake-derive",
  "proc-macro2",
@@ -229,9 +223,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
 
 [[package]]
 name = "getrandom"
@@ -239,7 +233,7 @@ version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "js-sys",
  "libc",
  "wasi",
@@ -253,27 +247,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
 
 [[package]]
-name = "hash32"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
-dependencies = [
- "byteorder",
-]
-
-[[package]]
-name = "heapless"
-version = "0.7.16"
+name = "hashbrown"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db04bc24a18b9ea980628ecf00e6c0264f3c1426dac36c00cb49b6fbad8b0743"
-dependencies = [
- "atomic-polyfill",
- "hash32",
- "rustc_version",
- "serde",
- "spin",
- "stable_deref_trait",
-]
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hermit-abi"
@@ -300,6 +277,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71a816c97c42258aa5834d07590b718b4c9a598944cd39a52dc25b351185d678"
 
 [[package]]
+name = "indexmap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
 name = "itertools"
 version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -310,21 +297,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
-
-[[package]]
-name = "itoa"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
 
 [[package]]
 name = "js-sys"
-version = "0.3.60"
+version = "0.3.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -348,31 +329,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
 
 [[package]]
-name = "lock_api"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
 name = "log"
 version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 ]
 
 [[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
 name = "memoffset"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -414,6 +379,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
 [[package]]
+name = "os_str_bytes"
+version = "6.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
+
+[[package]]
 name = "plotters"
 version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -448,7 +419,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c2b180dc0bade59f03fd005cb967d3f1e5f69b13922dad0cd6e047cb8af2363"
 dependencies = [
  "cobs",
- "heapless",
  "serde",
 ]
 
@@ -460,9 +430,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.50"
+version = "1.0.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ef7d57beacfaf2d8aee5937dab7b7f28de3cb8b1828479bb5de2a7106f2bae2"
+checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
 dependencies = [
  "unicode-ident",
 ]
@@ -557,12 +527,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-
-[[package]]
 name = "regex-syntax"
 version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -570,9 +534,9 @@ checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
  "semver",
 ]
@@ -600,9 +564,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "semver"
-version = "1.0.16"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
@@ -614,16 +587,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "serde_cbor"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
-dependencies = [
- "half",
- "serde",
-]
-
-[[package]]
 name = "serde_derive"
 version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -636,25 +599,16 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.91"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
+checksum = "cad406b69c91885b5107daf2c29572f6c8cdb3c66826821e286c533490c0bc76"
 dependencies = [
- "itoa 1.0.5",
+ "itoa",
  "ryu",
  "serde",
 ]
 
 [[package]]
-name = "spin"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09"
-dependencies = [
- "lock_api",
-]
-
-[[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -684,15 +638,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "textwrap"
-version = "0.11.0"
+name = "t1ha"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+checksum = "fa44aa51ae1a544e2c35a38831ba54ae40591f21384816f531b84f3e984b9ccc"
 dependencies = [
- "unicode-width",
+ "cfg-if 0.1.10",
+ "lazy_static",
+ "num-traits",
+ "rustc_version",
 ]
 
 [[package]]
+name = "textwrap"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+
+[[package]]
 name = "tinytemplate"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -709,12 +672,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
 
 [[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
 name = "unicode-xid"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -739,19 +696,19 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
 dependencies = [
  "bumpalo",
  "log",
@@ -764,9 +721,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -774,9 +731,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -787,15 +744,15 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.84"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
 
 [[package]]
 name = "web-sys"
-version = "0.3.60"
+version = "0.3.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
+checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -834,9 +791,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "yoke"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222180af14a6b54ef2c33493c1eff77ae95a3687a21b243e752624006fb8f26e"
+checksum = "1848075a23a28f9773498ee9a0f2cf58fcbad4f8c0ccf84a210ab33c6ae495de"
 dependencies = [
  "serde",
  "stable_deref_trait",
@@ -845,13 +802,13 @@ dependencies = [
 
 [[package]]
 name = "zerofrom"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e9355fccf72b04b7deaa99ce7a0f6630530acf34045391b74460fcd714de54"
+checksum = "df54d76c3251de27615dfcce21e636c172dafb2549cd7fd93e21c66f6ca6bea2"
 
 [[package]]
 name = "zerovec"
-version = "0.9.2"
+version = "0.9.4"
 dependencies = [
  "bincode",
  "criterion",
@@ -864,6 +821,7 @@ dependencies = [
  "rand_pcg",
  "serde",
  "serde_json",
+ "t1ha",
  "yoke",
  "zerofrom",
  "zerovec-derive",
@@ -871,9 +829,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c630983d26a5f0c061dad3bf22df69a7329b4939a9752bc5f19f1cbd8e2263db"
+checksum = "486558732d5dde10d0f8cb2936507c1bb21bc539d924c949baf5f36a58e51bac"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/vendor/zerovec/Cargo.toml b/vendor/zerovec/Cargo.toml
index 2490aa0dc..5ef086ee1 100644
--- a/vendor/zerovec/Cargo.toml
+++ b/vendor/zerovec/Cargo.toml
@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "zerovec"
-version = "0.9.2"
+version = "0.9.4"
 authors = ["The ICU4X Project Developers"]
 include = [
     "src/**/*",
@@ -39,7 +39,6 @@ categories = [
 ]
 license = "Unicode-DFS-2016"
 repository = "https://github.com/unicode-org/icu4x"
-resolver = "2"
 
 [package.metadata.workspaces]
 independent = true
@@ -74,7 +73,10 @@ harness = false
 [[bench]]
 name = "zeromap"
 harness = false
-required-features = ["serde"]
+required-features = [
+    "serde",
+    "hashmap",
+]
 
 [dependencies.databake]
 version = "0.1.3"
@@ -87,8 +89,12 @@ features = ["alloc"]
 optional = true
 default-features = false
 
+[dependencies.t1ha]
+version = "0.1"
+optional = true
+
 [dependencies.yoke]
-version = "0.7.0"
+version = ">=0.6.0, <0.8.0"
 optional = true
 
 [dependencies.zerofrom]
@@ -102,7 +108,7 @@ optional = true
 version = "1.3"
 
 [dev-dependencies.criterion]
-version = "0.3.4"
+version = "0.4"
 
 [dev-dependencies.getrandom]
 version = "0.2"
@@ -114,6 +120,7 @@ version = "0.1"
 [dev-dependencies.postcard]
 version = "1.0.0"
 features = ["use-std"]
+default-features = false
 
 [dev-dependencies.rand]
 version = "0.8"
@@ -134,4 +141,5 @@ version = "1.0"
 [features]
 bench = []
 derive = ["dep:zerovec-derive"]
+hashmap = ["dep:t1ha"]
 std = []
diff --git a/vendor/zerovec/benches/testdata/large_zerohashmap.postcard b/vendor/zerovec/benches/testdata/large_zerohashmap.postcard
new file mode 100644
index 000000000..905a94cdd
--- /dev/null
+++ b/vendor/zerovec/benches/testdata/large_zerohashmap.postcard
diff --git a/vendor/zerovec/benches/zeromap.rs b/vendor/zerovec/benches/zeromap.rs
index 069331979..5a759fd09 100644
--- a/vendor/zerovec/benches/zeromap.rs
+++ b/vendor/zerovec/benches/zeromap.rs
@@ -8,7 +8,7 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 use zerovec::maps::ZeroMapKV;
 use zerovec::vecs::{Index32, VarZeroSlice, VarZeroVec};
-use zerovec::ZeroMap;
+use zerovec::{ZeroHashMap, ZeroMap};
 
 const DATA: [(&str, &str); 16] = [
     ("ar", "Arabic"),
@@ -56,13 +56,33 @@ const POSTCARD_HASHMAP: [u8; 176] = [
     114, 97, 98, 105, 99,
 ];
 
+const POSTCARD_ZEROHASHMAP: [u8; 412] = [
+    128, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
+    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
+    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 1,
+    0, 0, 0, 102, 16, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 8, 0, 0, 0, 11, 0,
+    0, 0, 13, 0, 0, 0, 15, 0, 0, 0, 17, 0, 0, 0, 19, 0, 0, 0, 21, 0, 0, 0, 24, 0, 0, 0, 26, 0, 0,
+    0, 28, 0, 0, 0, 30, 0, 0, 0, 32, 0, 0, 0, 101, 110, 102, 114, 106, 97, 101, 108, 99, 104, 114,
+    98, 110, 115, 114, 105, 117, 101, 111, 116, 114, 99, 99, 112, 122, 104, 114, 117, 101, 115,
+    116, 104, 97, 114, 177, 1, 16, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 13, 0, 0, 0, 21, 0, 0, 0, 26,
+    0, 0, 0, 34, 0, 0, 0, 40, 0, 0, 0, 47, 0, 0, 0, 56, 0, 0, 0, 65, 0, 0, 0, 72, 0, 0, 0, 78, 0,
+    0, 0, 85, 0, 0, 0, 92, 0, 0, 0, 99, 0, 0, 0, 103, 0, 0, 0, 69, 110, 103, 108, 105, 115, 104,
+    70, 114, 101, 110, 99, 104, 74, 97, 112, 97, 110, 101, 115, 101, 71, 114, 101, 101, 107, 67,
+    104, 101, 114, 111, 107, 101, 101, 66, 97, 110, 103, 108, 97, 83, 101, 114, 98, 105, 97, 110,
+    73, 110, 117, 107, 116, 105, 116, 117, 116, 69, 115, 112, 101, 114, 97, 110, 116, 111, 84, 117,
+    114, 107, 105, 115, 104, 67, 104, 97, 107, 109, 97, 67, 104, 105, 110, 101, 115, 101, 82, 117,
+    115, 115, 105, 97, 110, 83, 112, 97, 110, 105, 115, 104, 84, 104, 97, 105, 65, 114, 97, 98,
+    105, 99,
+];
+
 /// Run this function to print new data to the console.
 /// Requires the optional `serde` Cargo feature.
 #[allow(dead_code)]
-fn generate() {
+fn generate_zeromap() {
     let map = build_zeromap(false);
     let buf = postcard::to_stdvec(&map).unwrap();
-    println!("{:?}", buf);
+    println!("{buf:?}");
 }
 
 /// Run this function to print new data to the console.
@@ -71,7 +91,16 @@ fn generate() {
 fn generate_hashmap() {
     let map = build_hashmap(false);
     let buf = postcard::to_stdvec(&map).unwrap();
-    println!("{:?}", buf);
+    println!("{buf:?}");
+}
+
+/// Run this function to print new data to the console.
+/// Requires the optional `serde` Cargo feature.
+#[allow(dead_code)]
+fn generate_zerohashmap() {
+    let map = build_zerohashmap(false);
+    let buf = postcard::to_stdvec(&map).unwrap();
+    println!("{buf:?}");
 }
 
 #[cfg(feature = "generate")]
@@ -83,21 +112,29 @@ fn generate_test_data() {
     let hashmap = build_hashmap(true);
     let hashmap_bytes = postcard::to_stdvec(&hashmap).unwrap();
     fs::write("large_hashmap.postcard", &hashmap_bytes).unwrap();
+
+    let zerohashmap = build_zerohashmap(true);
+    let zerohashmap_bytes = postcard::to_stdvec(&zerohashmap).unwrap();
+    fs::write("large_zerohashmap.postcard", &zerohashmap_bytes).unwrap();
 }
 
 fn overview_bench(c: &mut Criterion) {
+    bench_zeromap(c);
+    bench_hashmap(c);
+    bench_zerohashmap(c);
+
+    #[cfg(feature = "generate")]
+    generate_test_data();
+}
+
+fn bench_zeromap(c: &mut Criterion) {
     // Uncomment the following line to re-generate the binary data.
-    // generate();
+    // generate_hashmap();
 
     bench_deserialize(c);
     bench_deserialize_large(c);
     bench_lookup(c);
     bench_lookup_large(c);
-
-    bench_hashmap(c);
-
-    #[cfg(feature = "generate")]
-    generate_test_data();
 }
 
 fn build_zeromap(large: bool) -> ZeroMap<'static, Index32Str, Index32Str> {
@@ -105,7 +142,7 @@ fn build_zeromap(large: bool) -> ZeroMap<'static, Index32Str, Index32Str> {
     for (key, value) in DATA.iter() {
         if large {
             for n in 0..8192 {
-                map.insert(indexify(&format!("{}{}", key, n)), indexify(value));
+                map.insert(indexify(&format!("{key}{n}")), indexify(value));
             }
         } else {
             map.insert(indexify(key), indexify(value));
@@ -185,7 +222,7 @@ fn build_hashmap(large: bool) -> HashMap<String, String> {
     for &(key, value) in DATA.iter() {
         if large {
             for n in 0..8192 {
-                map.insert(format!("{}{}", key, n), value.to_owned());
+                map.insert(format!("{key}{n}"), value.to_owned());
             }
         } else {
             map.insert(key.to_owned(), value.to_owned());
@@ -243,6 +280,102 @@ fn read_large_hashmap_postcard_bytes() -> Vec<u8> {
     fs::read(path).unwrap()
 }
 
+fn bench_zerohashmap(c: &mut Criterion) {
+    // Uncomment the following line to re-generate the binary data.
+    // generate_zerohashmap();
+
+    bench_deserialize_zerohashmap(c);
+    bench_deserialize_large_zerohashmap(c);
+    bench_zerohashmap_lookup(c);
+    bench_zerohashmap_lookup_large(c);
+}
+
+fn build_zerohashmap(large: bool) -> ZeroHashMap<'static, Index32Str, Index32Str> {
+    let mut kv = match large {
+        true => Vec::with_capacity(8192 * DATA.len()),
+        false => Vec::with_capacity(DATA.len()),
+    };
+
+    for (key, value) in DATA.iter() {
+        if large {
+            for n in 0..8192 {
+                kv.push((format!("{key}{n}"), indexify(value)));
+            }
+        } else {
+            kv.push((key.to_string(), indexify(value)));
+        }
+    }
+
+    ZeroHashMap::from_iter(kv.iter().map(|kv| (indexify(&kv.0), kv.1)))
+}
+
+fn bench_deserialize_zerohashmap(c: &mut Criterion) {
+    c.bench_function("zerohashmap/deserialize/small", |b| {
+        b.iter(|| {
+            let map: ZeroHashMap<Index32Str, Index32Str> =
+                postcard::from_bytes(black_box(&POSTCARD_ZEROHASHMAP)).unwrap();
+            assert_eq!(map.get(indexify("iu")).map(|x| &x.0), Some("Inuktitut"));
+        })
+    });
+}
+
+fn bench_deserialize_large_zerohashmap(c: &mut Criterion) {
+    let buf = read_large_zerohashmap_postcard_bytes();
+    c.bench_function("zerohashmap/deserialize/large", |b| {
+        b.iter(|| {
+            let map: ZeroHashMap<Index32Str, Index32Str> =
+                postcard::from_bytes(black_box(&buf)).unwrap();
+            assert_eq!(map.get(indexify("iu3333")).map(|x| &x.0), Some("Inuktitut"));
+        })
+    });
+}
+
+fn bench_zerohashmap_lookup(c: &mut Criterion) {
+    let zero_hashmap: ZeroHashMap<Index32Str, Index32Str> =
+        postcard::from_bytes(black_box(&POSTCARD_ZEROHASHMAP)).unwrap();
+
+    c.bench_function("zerohashmap/lookup/small", |b| {
+        b.iter(|| {
+            assert_eq!(
+                zero_hashmap.get(black_box(indexify("iu"))).map(|x| &x.0),
+                Some("Inuktitut")
+            );
+            assert_eq!(
+                zero_hashmap.get(black_box(indexify("zz"))).map(|x| &x.0),
+                None
+            );
+        });
+    });
+}
+
+fn bench_zerohashmap_lookup_large(c: &mut Criterion) {
+    let buf = read_large_zerohashmap_postcard_bytes();
+    let zero_hashmap: ZeroHashMap<Index32Str, Index32Str> = postcard::from_bytes(&buf).unwrap();
+
+    c.bench_function("zerohashmap/lookup/large", |b| {
+        b.iter(|| {
+            assert_eq!(
+                zero_hashmap
+                    .get(black_box(indexify("iu3333")))
+                    .map(|x| &x.0),
+                Some("Inuktitut")
+            );
+            assert_eq!(
+                zero_hashmap.get(black_box(indexify("zz"))).map(|x| &x.0),
+                None
+            );
+        });
+    });
+}
+
+fn read_large_zerohashmap_postcard_bytes() -> Vec<u8> {
+    let path = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/benches/testdata/large_zerohashmap.postcard"
+    );
+    fs::read(path).unwrap()
+}
+
 criterion_group!(benches, overview_bench);
 criterion_main!(benches);
 
@@ -258,7 +391,7 @@ criterion_main!(benches);
 #[zerovec::make_varule(Index32Str)]
 #[zerovec::skip_derive(ZeroMapKV)]
 #[derive(Eq, PartialEq, Ord, PartialOrd, serde::Serialize, serde::Deserialize)]
-#[zerovec::derive(Serialize, Deserialize)]
+#[zerovec::derive(Serialize, Deserialize, Hash)]
 pub(crate) struct Index32StrBorrowed<'a>(#[serde(borrow)] pub &'a str);
 
 impl<'a> ZeroMapKV<'a> for Index32Str {
diff --git a/vendor/zerovec/examples/zv_serde.rs b/vendor/zerovec/examples/zv_serde.rs
index 3cf428e1c..e4a8ec309 100644
--- a/vendor/zerovec/examples/zv_serde.rs
+++ b/vendor/zerovec/examples/zv_serde.rs
@@ -32,7 +32,7 @@ fn serialize() {
         nums: ZeroVec::from_slice_or_alloc(&U16_SLICE),
     };
     let postcard_bytes = postcard::to_stdvec(&data).expect("Serialization should be successful");
-    println!("Postcard bytes: {:#x?}", postcard_bytes);
+    println!("Postcard bytes: {postcard_bytes:#x?}");
     println!("ZeroVec bytes: {:#x?}", data.nums.as_bytes());
 }
 
diff --git a/vendor/zerovec/src/error.rs b/vendor/zerovec/src/error.rs
index 457a0d650..85de3ecc8 100644
--- a/vendor/zerovec/src/error.rs
+++ b/vendor/zerovec/src/error.rs
@@ -22,10 +22,10 @@ impl fmt::Display for ZeroVecError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
             ZeroVecError::InvalidLength { ty, len } => {
-                write!(f, "Invalid length {} for slice of type {}", len, ty)
+                write!(f, "Invalid length {len} for slice of type {ty}")
             }
             ZeroVecError::ParseError { ty } => {
-                write!(f, "Could not parse bytes to slice of type {}", ty)
+                write!(f, "Could not parse bytes to slice of type {ty}")
             }
             ZeroVecError::VarZeroVecFormatError => {
                 write!(f, "Invalid format for VarZeroVec buffer")
diff --git a/vendor/zerovec/src/flexzerovec/databake.rs b/vendor/zerovec/src/flexzerovec/databake.rs
index 23bf156ef..4ce5f7dea 100644
--- a/vendor/zerovec/src/flexzerovec/databake.rs
+++ b/vendor/zerovec/src/flexzerovec/databake.rs
@@ -8,16 +8,24 @@ use databake::*;
 impl Bake for FlexZeroVec<'_> {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        quote! { unsafe { ::zerovec::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[#(#bytes),*]).as_flexzerovec() } }
+        if self.is_empty() {
+            quote! { ::zerovec::vecs::FlexZeroVec::new() }
+        } else {
+            let slice = self.as_ref().bake(env);
+            quote! { #slice.as_flexzerovec() }
+        }
     }
 }
 
 impl Bake for &FlexZeroSlice {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        quote! { unsafe { ::zerovec::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[#(#bytes),*]) } }
+        if self.is_empty() {
+            quote! { ::zerovec::vecs::FlexZeroSlice::new_empty() }
+        } else {
+            let bytes = databake::Bake::bake(&self.as_bytes(), env);
+            quote! { unsafe { ::zerovec::vecs::FlexZeroSlice::from_byte_slice_unchecked(#bytes) } }
+        }
     }
 }
 
@@ -25,12 +33,16 @@ impl Bake for &FlexZeroSlice {
 fn test_baked_vec() {
     test_bake!(
         FlexZeroVec,
+        const: crate::vecs::FlexZeroVec::new(),
+        zerovec
+    );
+    test_bake!(
+        FlexZeroVec,
         const: unsafe {
-            crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[
-                2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8, 17u8,
-            ])
-            .as_flexzerovec()
-        },
+            crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(
+                b"\x02\x01\0\x16\0M\x01\x11"
+            )
+        }.as_flexzerovec(),
         zerovec
     );
 }
@@ -39,10 +51,15 @@ fn test_baked_vec() {
 fn test_baked_slice() {
     test_bake!(
         &FlexZeroSlice,
+        const: crate::vecs::FlexZeroSlice::new_empty(),
+        zerovec
+    );
+    test_bake!(
+        &FlexZeroSlice,
         const: unsafe {
-            crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[
-                2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8, 17u8,
-            ])
+            crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(
+                b"\x02\x01\0\x16\0M\x01\x11"
+            )
         },
         zerovec
     );
diff --git a/vendor/zerovec/src/flexzerovec/owned.rs b/vendor/zerovec/src/flexzerovec/owned.rs
index 1039c59ae..7d7bfb33d 100644
--- a/vendor/zerovec/src/flexzerovec/owned.rs
+++ b/vendor/zerovec/src/flexzerovec/owned.rs
@@ -30,7 +30,7 @@ impl FlexZeroVecOwned {
 
     /// Obtains this [`FlexZeroVecOwned`] as a [`FlexZeroSlice`].
     pub fn as_slice(&self) -> &FlexZeroSlice {
-        let slice: &[u8] = &*self.0;
+        let slice: &[u8] = &self.0;
         unsafe {
             // safety: the slice is known to come from a valid parsed FlexZeroSlice
             FlexZeroSlice::from_byte_slice_unchecked(slice)
@@ -39,7 +39,7 @@ impl FlexZeroVecOwned {
 
     /// Mutably obtains this `FlexZeroVecOwned` as a [`FlexZeroSlice`].
     pub(crate) fn as_mut_slice(&mut self) -> &mut FlexZeroSlice {
-        let slice: &mut [u8] = &mut *self.0;
+        let slice: &mut [u8] = &mut self.0;
         unsafe {
             // safety: the slice is known to come from a valid parsed FlexZeroSlice
             FlexZeroSlice::from_byte_slice_mut_unchecked(slice)
@@ -255,42 +255,27 @@ mod test {
     use super::*;
 
     fn check_contents(fzv: &FlexZeroSlice, expected: &[usize]) {
-        assert_eq!(
-            fzv.len(),
-            expected.len(),
-            "len: {:?} != {:?}",
-            fzv,
-            expected
-        );
+        assert_eq!(fzv.len(), expected.len(), "len: {fzv:?} != {expected:?}");
         assert_eq!(
             fzv.is_empty(),
             expected.is_empty(),
-            "is_empty: {:?} != {:?}",
-            fzv,
-            expected
+            "is_empty: {fzv:?} != {expected:?}"
         );
         assert_eq!(
             fzv.first(),
             expected.first().copied(),
-            "first: {:?} != {:?}",
-            fzv,
-            expected
+            "first: {fzv:?} != {expected:?}"
         );
         assert_eq!(
             fzv.last(),
             expected.last().copied(),
-            "last:  {:?} != {:?}",
-            fzv,
-            expected
+            "last:  {fzv:?} != {expected:?}"
         );
         for i in 0..(expected.len() + 1) {
             assert_eq!(
                 fzv.get(i),
                 expected.get(i).copied(),
-                "@{}: {:?} != {:?}",
-                i,
-                fzv,
-                expected
+                "@{i}: {fzv:?} != {expected:?}"
             );
         }
     }
diff --git a/vendor/zerovec/src/flexzerovec/slice.rs b/vendor/zerovec/src/flexzerovec/slice.rs
index ee164d05b..fb58d6215 100644
--- a/vendor/zerovec/src/flexzerovec/slice.rs
+++ b/vendor/zerovec/src/flexzerovec/slice.rs
@@ -22,6 +22,12 @@ pub struct FlexZeroSlice {
     data: [u8],
 }
 
+impl fmt::Debug for FlexZeroSlice {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.to_vec().fmt(f)
+    }
+}
+
 impl PartialEq for FlexZeroSlice {
     fn eq(&self, other: &Self) -> bool {
         self.width == other.width && self.data == other.data
@@ -507,12 +513,6 @@ impl FlexZeroSlice {
     }
 }
 
-impl fmt::Debug for &FlexZeroSlice {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self.to_vec())
-    }
-}
-
 #[inline]
 pub(crate) fn get_item_width(item_bytes: &[u8; USIZE_WIDTH]) -> usize {
     USIZE_WIDTH - item_bytes.iter().rev().take_while(|b| **b == 0).count()
diff --git a/vendor/zerovec/src/flexzerovec/vec.rs b/vendor/zerovec/src/flexzerovec/vec.rs
index a08f54e5d..dfd64ce65 100644
--- a/vendor/zerovec/src/flexzerovec/vec.rs
+++ b/vendor/zerovec/src/flexzerovec/vec.rs
@@ -134,7 +134,7 @@ impl<'a> FlexZeroVec<'a> {
     /// let zv: FlexZeroVec = FlexZeroVec::new();
     /// assert!(zv.is_empty());
     /// ```
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self::Borrowed(FlexZeroSlice::new_empty())
     }
 
diff --git a/vendor/zerovec/src/hashmap/algorithms.rs b/vendor/zerovec/src/hashmap/algorithms.rs
new file mode 100644
index 000000000..58ffc48f4
--- /dev/null
+++ b/vendor/zerovec/src/hashmap/algorithms.rs
@@ -0,0 +1,162 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use alloc::vec;
+use alloc::vec::Vec;
+use core::hash::{Hash, Hasher};
+use t1ha::T1haHasher;
+
+// Const seed to be used with [`T1haHasher::with_seed`].
+const SEED: u64 = 0xaabbccdd;
+
+/// Split the 64bit `hash` into (g, f0, f1).
+/// g denotes the highest 16bits of the hash modulo `m`, and is referred to as first level hash.
+/// (f0, f1) denotes the middle, and lower 24bits of the hash respectively.
+/// (f0, f1) are used to distribute the keys with same g, into distinct slots.
+///
+/// # Arguments
+///
+/// * `hash` - The hash to split.
+/// * `m` - The modulo used to split the hash.
+pub const fn split_hash64(hash: u64, m: usize) -> (usize, u32, u32) {
+    (
+        ((hash >> 48) as usize % m),
+        ((hash >> 24) as u32 & 0xffffff),
+        ((hash & 0xffffff) as u32),
+    )
+}
+
+/// Compute hash using [`T1haHasher`].
+pub fn compute_hash<K: Hash + ?Sized>(key: &K) -> u64 {
+    let mut hasher = T1haHasher::with_seed(SEED);
+    key.hash(&mut hasher);
+    hasher.finish()
+}
+
+/// Calculate the index using (f0, f1), (d0, d1) in modulo m.
+/// Returns [`None`] if d is (0, 0) or modulo is 0
+/// else returns the index computed using (f0 + f1 * d0 + d1) mod m.
+pub fn compute_index(f: (u32, u32), d: (u32, u32), m: u32) -> Option<usize> {
+    if d == (0, 0) || m == 0 {
+        None
+    } else {
+        Some((f.1.wrapping_mul(d.0).wrapping_add(f.0).wrapping_add(d.1) % m) as usize)
+    }
+}
+
+/// Compute displacements for the given `key_hashes`, which split the keys into distinct slots by a
+/// two-level hashing schema.
+/// Returns a tuple of where the first item is the displacement array and the second item is the
+/// reverse mapping used to permute keys, values into their slots.
+///
+/// 1. Split the hashes into (g, f0, f1).
+/// 2. Bucket and sort the split hash on g in descending order.
+/// 3. In decreasing order of bucket size, try until a (d0, d1) is found that splits the keys
+///    in the bucket into distinct slots.
+/// 4. Mark the slots for current bucket as occupied and store the reverse mapping.
+/// 5. Repeat untill all the keys have been assigned distinct slots.
+///
+/// # Arguments
+///
+/// * `key_hashes` - [`ExactSizeIterator`] over the hashed key values
+#[allow(clippy::indexing_slicing, clippy::unwrap_used)]
+pub fn compute_displacements(
+    key_hashes: impl ExactSizeIterator<Item = u64>,
+) -> (Vec<(u32, u32)>, Vec<usize>) {
+    let len = key_hashes.len();
+
+    // A vector to track the size of buckets for sorting.
+    let mut bucket_sizes = vec![0; len];
+
+    // A flattened representation of items in the buckets after applying first level hash function
+    let mut bucket_flatten = Vec::with_capacity(len);
+
+    // Compute initial displacement and bucket sizes
+
+    key_hashes.into_iter().enumerate().for_each(|(i, kh)| {
+        let h = split_hash64(kh, len);
+        bucket_sizes[h.0] += 1;
+        bucket_flatten.push((h, i))
+    });
+
+    // Sort by decreasing order of bucket_sizes.
+    bucket_flatten.sort_by(|&(ha, _), &(hb, _)| {
+        // ha.0, hb.0 are always within bounds of `bucket_sizes`
+        (bucket_sizes[hb.0], hb).cmp(&(bucket_sizes[ha.0], ha))
+    });
+
+    // Generation count while iterating buckets.
+    // Each trial of ((d0, d1), bucket chain) is a new generation.
+    // We use this to track which all slots are assigned for the current bucket chain.
+    let mut generation = 0;
+
+    // Whether a slot has been occupied by previous buckets with a different first level hash (different
+    // bucket chain).
+    let mut occupied = vec![false; len];
+
+    // Track generation count for the slots.
+    // A slot is empty if either it is unoccupied by the previous bucket chains and the
+    // assignment is not equal to generation.
+    let mut assignments = vec![0; len];
+
+    // Vec to store the displacements (saves us a recomputation of hash while assigning slots).
+    let mut current_displacements = Vec::with_capacity(16);
+
+    // (d0, d1) which splits the bucket into different slots
+    let mut displacements = vec![(0, 0); len];
+
+    // Vec to store mapping to the original order of keys.
+    // This is a permutation which will be applied to keys, values at the end.
+    let mut reverse_mapping = vec![0; len];
+
+    let mut start = 0;
+    while start < len {
+        // Bucket span with the same first level hash
+        // start is always within bounds of `bucket_flatten`
+        let g = bucket_flatten[start].0 .0;
+        // g is always within bounds of `bucket_sizes`
+        let end = start + bucket_sizes[g];
+        // start, end - 1 are always within bounds of `bucket_sizes`
+        let buckets = &bucket_flatten[start..end];
+
+        'd0: for d0 in 0..len as u32 {
+            'd1: for d1 in 0..len as u32 {
+                if (d0, d1) == (0, 0) {
+                    continue;
+                }
+                current_displacements.clear();
+                generation += 1;
+
+                for ((_, f0, f1), _) in buckets {
+                    let displacement_idx = compute_index((*f0, *f1), (d0, d1), len as u32).unwrap();
+
+                    // displacement_idx is always within bounds
+                    if occupied[displacement_idx] || assignments[displacement_idx] == generation {
+                        continue 'd1;
+                    }
+                    assignments[displacement_idx] = generation;
+                    current_displacements.push(displacement_idx);
+                }
+
+                // Successfully found a (d0, d1), store it as index g.
+                // g < displacements.len() due to modulo operation
+                displacements[g] = (d0, d1);
+
+                for (i, displacement_idx) in current_displacements.iter().enumerate() {
+                    // `current_displacements` has same size as `buckets`
+                    let (_, idx) = &buckets[i];
+
+                    // displacement_idx is always within bounds
+                    occupied[*displacement_idx] = true;
+                    reverse_mapping[*displacement_idx] = *idx;
+                }
+                break 'd0;
+            }
+        }
+
+        start = end;
+    }
+
+    (displacements, reverse_mapping)
+}
diff --git a/vendor/zerovec/src/hashmap/mod.rs b/vendor/zerovec/src/hashmap/mod.rs
new file mode 100644
index 000000000..5d91114ad
--- /dev/null
+++ b/vendor/zerovec/src/hashmap/mod.rs
@@ -0,0 +1,238 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use crate::map::{MutableZeroVecLike, ZeroMapKV, ZeroVecLike};
+use crate::ZeroVec;
+use alloc::borrow::Borrow;
+use alloc::vec;
+use core::hash::Hash;
+
+pub mod algorithms;
+use algorithms::*;
+
+#[cfg(feature = "serde")]
+mod serde;
+
+/// A perfect zerohashmap optimized for lookups over immutable keys.
+///
+/// # Examples
+/// ```
+/// use zerovec::ZeroHashMap;
+///
+/// let kv = vec![(0, "a"), (1, "b"), (2, "c")];
+/// let hashmap: ZeroHashMap<i32, str> = ZeroHashMap::from_iter(kv.into_iter());
+/// assert_eq!(hashmap.get(&0), Some("a"));
+/// assert_eq!(hashmap.get(&2), Some("c"));
+/// assert_eq!(hashmap.get(&4), None);
+/// ```
+#[derive(Debug)]
+pub struct ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized,
+    V: ZeroMapKV<'a> + ?Sized,
+{
+    /// Array of (d0, d1) which splits the keys with same first level hash into distinct
+    /// slots.
+    /// The ith index of the array splits the keys with first level hash i.
+    /// If no key with first level hash is found in the original keys, (0, 0) is used as an empty
+    /// placeholder.
+    displacements: ZeroVec<'a, (u32, u32)>,
+    keys: K::Container,
+    values: V::Container,
+}
+
+impl<'a, K, V> ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized,
+    V: ZeroMapKV<'a> + ?Sized,
+{
+    /// The number of elements in the [`ZeroHashMap`].
+    pub fn len(&self) -> usize {
+        self.values.zvl_len()
+    }
+
+    /// Whether the [`ZeroHashMap`] is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<'a, K, V> ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized + Hash + Eq,
+    V: ZeroMapKV<'a> + ?Sized,
+{
+    /// Given a `key` return the index for the key or [`None`] if the key is absent.
+    fn index<A>(&self, key: &A) -> Option<usize>
+    where
+        A: Borrow<K> + ?Sized,
+    {
+        let hash = compute_hash(key.borrow());
+        let (g, f0, f1) = split_hash64(hash, self.len());
+
+        #[allow(clippy::unwrap_used)] // g is in-range
+        let (d0, d1) = self.displacements.get(g).unwrap();
+        let index = compute_index((f0, f1), (d0, d1), self.displacements.len() as u32)?;
+
+        #[allow(clippy::unwrap_used)] // index is in 0..self.keys.len()
+        let found = self.keys.zvl_get(index).unwrap();
+        if K::Container::zvl_get_as_t(found, |found| found == key.borrow()) {
+            Some(index)
+        } else {
+            None
+        }
+    }
+
+    /// Get the value corresponding to `key`.
+    /// If absent [`None`] is returned.
+    ///
+    /// # Example
+    /// ```
+    /// use zerovec::ZeroHashMap;
+    ///
+    /// let hashmap: ZeroHashMap<str, str> =
+    ///     ZeroHashMap::from_iter(vec![("a", "A"), ("z", "Z")].into_iter());
+    ///
+    /// assert_eq!(hashmap.get("a"), Some("A"));
+    /// assert_eq!(hashmap.get("z"), Some("Z"));
+    /// assert_eq!(hashmap.get("0"), None);
+    /// ```
+    pub fn get<'b, A>(&'b self, key: &A) -> Option<&'b V::GetType>
+    where
+        A: Borrow<K> + ?Sized + 'b,
+    {
+        self.index(key).and_then(|i| self.values.zvl_get(i))
+    }
+
+    /// Returns whether `key` is contained in this hashmap
+    ///
+    /// # Example
+    /// ```rust
+    /// use zerovec::ZeroHashMap;
+    ///
+    /// let hashmap: ZeroHashMap<str, str> =
+    ///     ZeroHashMap::from_iter(vec![("a", "A"), ("z", "Z")].into_iter());
+    ///
+    /// assert!(hashmap.contains_key("a"));
+    /// assert!(!hashmap.contains_key("p"));
+    /// ```
+    pub fn contains_key(&self, key: &K) -> bool {
+        self.index(key).is_some()
+    }
+}
+
+impl<'a, K, V> ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized,
+    V: ZeroMapKV<'a> + ?Sized,
+{
+    // Produce an iterator over (key, value) pairs.
+    pub fn iter<'b>(
+        &'b self,
+    ) -> impl ExactSizeIterator<
+        Item = (
+            &'b <K as ZeroMapKV<'a>>::GetType,
+            &'b <V as ZeroMapKV<'a>>::GetType,
+        ),
+    > {
+        (0..self.len()).map(|index| {
+            (
+                #[allow(clippy::unwrap_used)] // index is in range
+                self.keys.zvl_get(index).unwrap(),
+                #[allow(clippy::unwrap_used)] // index is in range
+                self.values.zvl_get(index).unwrap(),
+            )
+        })
+    }
+
+    // Produce an iterator over keys.
+    pub fn iter_keys<'b>(
+        &'b self,
+    ) -> impl ExactSizeIterator<Item = &'b <K as ZeroMapKV<'a>>::GetType> {
+        #[allow(clippy::unwrap_used)] // index is in range
+        (0..self.len()).map(|index| self.keys.zvl_get(index).unwrap())
+    }
+
+    // Produce an iterator over values.
+    pub fn iter_values<'b>(
+        &'b self,
+    ) -> impl ExactSizeIterator<Item = &'b <V as ZeroMapKV<'a>>::GetType> {
+        #[allow(clippy::unwrap_used)] // index is in range
+        (0..self.len()).map(|index| self.values.zvl_get(index).unwrap())
+    }
+}
+
+impl<'a, K, V, A, B> FromIterator<(A, B)> for ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized + Hash + Eq,
+    V: ZeroMapKV<'a> + ?Sized,
+    B: Borrow<V>,
+    A: Borrow<K>,
+{
+    /// Build a [`ZeroHashMap`] from an iterator returning (K, V) tuples.
+    ///
+    /// # Example
+    /// ```
+    /// use zerovec::ZeroHashMap;
+    ///
+    /// let kv: Vec<(i32, &str)> = vec![(1, "a"), (2, "b"), (3, "c"), (4, "d")];
+    /// let hashmap: ZeroHashMap<i32, str> = ZeroHashMap::from_iter(kv.into_iter());
+    /// assert_eq!(hashmap.get(&1), Some("a"));
+    /// assert_eq!(hashmap.get(&2), Some("b"));
+    /// assert_eq!(hashmap.get(&3), Some("c"));
+    /// assert_eq!(hashmap.get(&4), Some("d"));
+    /// ```
+    fn from_iter<T: IntoIterator<Item = (A, B)>>(iter: T) -> Self {
+        let iter = iter.into_iter();
+        let size_hint = match iter.size_hint() {
+            (_, Some(upper)) => upper,
+            (lower, None) => lower,
+        };
+
+        let mut key_hashes = vec![];
+        key_hashes.reserve(size_hint);
+        let mut keys = K::Container::zvl_with_capacity(size_hint);
+        let mut values = V::Container::zvl_with_capacity(size_hint);
+        for (k, v) in iter {
+            keys.zvl_push(k.borrow());
+            key_hashes.push(compute_hash(k.borrow()));
+            values.zvl_push(v.borrow());
+        }
+
+        let (displacements, mut reverse_mapping) = compute_displacements(key_hashes.into_iter());
+
+        keys.zvl_permute(&mut reverse_mapping.clone());
+        values.zvl_permute(&mut reverse_mapping);
+
+        Self {
+            displacements: ZeroVec::alloc_from_slice(&displacements),
+            values,
+            keys,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ule::AsULE;
+    use rand::{distributions::Standard, Rng, SeedableRng};
+    use rand_pcg::Lcg64Xsh32;
+
+    #[test]
+    fn test_zhms_u64k_u64v() {
+        const N: usize = 65530;
+        let seed = u64::from_le_bytes(*b"testseed");
+        let rng = Lcg64Xsh32::seed_from_u64(seed);
+        let kv: Vec<(u64, u64)> = rng.sample_iter(&Standard).take(N).collect();
+        let hashmap: ZeroHashMap<u64, u64> =
+            ZeroHashMap::from_iter(kv.iter().map(|e| (&e.0, &e.1)));
+        for (k, v) in kv {
+            assert_eq!(
+                hashmap.get(&k).copied().map(<u64 as AsULE>::from_unaligned),
+                Some(v),
+            );
+        }
+    }
+}
diff --git a/vendor/zerovec/src/hashmap/serde.rs b/vendor/zerovec/src/hashmap/serde.rs
new file mode 100644
index 000000000..2d724ac05
--- /dev/null
+++ b/vendor/zerovec/src/hashmap/serde.rs
@@ -0,0 +1,147 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+use super::ZeroHashMap;
+use crate::{
+    map::{ZeroMapKV, ZeroVecLike},
+    ZeroVec,
+};
+
+use serde::{de, Deserialize, Serialize};
+
+impl<'a, K, V> Serialize for ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + Serialize + ?Sized,
+    V: ZeroMapKV<'a> + Serialize + ?Sized,
+    K::Container: Serialize,
+    V::Container: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (&self.displacements, &self.keys, &self.values).serialize(serializer)
+    }
+}
+
+impl<'de, 'a, K, V> Deserialize<'de> for ZeroHashMap<'a, K, V>
+where
+    K: ZeroMapKV<'a> + ?Sized,
+    V: ZeroMapKV<'a> + ?Sized,
+    K::Container: Deserialize<'de>,
+    V::Container: Deserialize<'de>,
+    'de: 'a,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let (displacements, keys, values): (ZeroVec<(u32, u32)>, K::Container, V::Container) =
+            Deserialize::deserialize(deserializer)?;
+        if keys.zvl_len() != values.zvl_len() {
+            return Err(de::Error::custom(
+                "Mismatched key and value sizes in ZeroHashMap",
+            ));
+        }
+        if displacements.zvl_len() != keys.zvl_len() {
+            return Err(de::Error::custom(
+                "Mismatched displacements and key, value sizes in ZeroHashMap",
+            ));
+        }
+        Ok(Self {
+            displacements,
+            keys,
+            values,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{VarZeroVec, ZeroHashMap, ZeroVec};
+    use serde::{Deserialize, Serialize};
+
+    const JSON_STR: &str = "[[[0,1],[0,0],[0,1]],[2,1,0],[\"c\",\"b\",\"a\"]]";
+
+    const BINCODE_BYTES: &[u8] = &[
+        24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+        0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0,
+        3, 0, 0, 0, 0, 0, 1, 0, 2, 0, 99, 98, 97,
+    ];
+
+    #[derive(Serialize, Deserialize)]
+    struct DeriveTestZeroHashMap<'data> {
+        #[serde(borrow)]
+        _data: ZeroHashMap<'data, str, [u8]>,
+    }
+
+    fn make_zerohashmap() -> ZeroHashMap<'static, u32, str> {
+        ZeroHashMap::from_iter(vec![(0, "a"), (1, "b"), (2, "c")].into_iter())
+    }
+
+    fn build_invalid_hashmap_str(
+        displacements: Vec<(u32, u32)>,
+        keys: Vec<u32>,
+        values: Vec<&str>,
+    ) -> String {
+        let invalid_hm: ZeroHashMap<u32, str> = ZeroHashMap {
+            displacements: ZeroVec::alloc_from_slice(&displacements),
+            keys: ZeroVec::alloc_from_slice(&keys),
+            values: VarZeroVec::<str>::from(&values),
+        };
+        serde_json::to_string(&invalid_hm).expect("serialize")
+    }
+
+    #[test]
+    fn test_invalid_deser_zhm() {
+        // Invalid hashmap |keys| != |values|
+        let mut invalid_hm_str =
+            build_invalid_hashmap_str(vec![(0, 1), (0, 0)], vec![1, 2], vec!["a", "b", "c"]);
+
+        assert_eq!(
+            serde_json::from_str::<ZeroHashMap<u32, str>>(&invalid_hm_str)
+                .unwrap_err()
+                .to_string(),
+            "Mismatched key and value sizes in ZeroHashMap"
+        );
+
+        // Invalid hashmap |displacements| != |keys| == |values|
+        // |displacements| = 2, |keys| = 3, |values| = 3
+        invalid_hm_str =
+            build_invalid_hashmap_str(vec![(0, 1), (0, 0)], vec![2, 1, 0], vec!["a", "b", "c"]);
+
+        assert_eq!(
+            serde_json::from_str::<ZeroHashMap<u32, str>>(&invalid_hm_str)
+                .unwrap_err()
+                .to_string(),
+            "Mismatched displacements and key, value sizes in ZeroHashMap"
+        );
+    }
+
+    #[test]
+    fn test_serde_valid_deser_zhm() {
+        let hm = make_zerohashmap();
+        let json_str = serde_json::to_string(&hm).expect("serialize");
+        assert_eq!(json_str, JSON_STR);
+        let deserialized_hm: ZeroHashMap<u32, str> =
+            serde_json::from_str(JSON_STR).expect("deserialize");
+        assert_eq!(
+            hm.iter().collect::<Vec<_>>(),
+            deserialized_hm.iter().collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn test_bincode_zhm() {
+        let hm = make_zerohashmap();
+        let bincode_bytes = bincode::serialize(&hm).expect("serialize");
+        assert_eq!(bincode_bytes, BINCODE_BYTES);
+        let deserialized_hm: ZeroHashMap<u32, str> =
+            bincode::deserialize(BINCODE_BYTES).expect("deserialize");
+        assert_eq!(
+            hm.iter().collect::<Vec<_>>(),
+            deserialized_hm.iter().collect::<Vec<_>>()
+        );
+    }
+}
diff --git a/vendor/zerovec/src/lib.rs b/vendor/zerovec/src/lib.rs
index b8b292488..add52f113 100644
--- a/vendor/zerovec/src/lib.rs
+++ b/vendor/zerovec/src/lib.rs
@@ -204,7 +204,7 @@
         clippy::panic,
         clippy::exhaustive_structs,
         clippy::exhaustive_enums,
-        // TODO(#2266): enable missing_debug_implementations,
+        missing_debug_implementations,
     )
 )]
 // this crate does a lot of nuanced lifetime manipulation, being explicit
@@ -215,6 +215,8 @@ extern crate alloc;
 
 mod error;
 mod flexzerovec;
+#[cfg(feature = "hashmap")]
+pub mod hashmap;
 mod map;
 mod map2d;
 #[cfg(test)]
@@ -231,6 +233,8 @@ mod yoke_impls;
 mod zerofrom_impls;
 
 pub use crate::error::ZeroVecError;
+#[cfg(feature = "hashmap")]
+pub use crate::hashmap::ZeroHashMap;
 pub use crate::map::map::ZeroMap;
 pub use crate::map2d::map::ZeroMap2d;
 pub use crate::varzerovec::{slice::VarZeroSlice, vec::VarZeroVec};
diff --git a/vendor/zerovec/src/map/borrowed.rs b/vendor/zerovec/src/map/borrowed.rs
index 9d0854601..bc93ee497 100644
--- a/vendor/zerovec/src/map/borrowed.rs
+++ b/vendor/zerovec/src/map/borrowed.rs
@@ -277,8 +277,8 @@ where
     /// to `K::ULE` and `V::ULE`, in cases when `K` and `V` are fixed-size
     #[allow(clippy::needless_lifetimes)] // Lifetime is necessary in impl Trait
     pub fn iter_copied<'b: 'a>(&'b self) -> impl Iterator<Item = (K, V)> + 'b {
-        let keys = &*self.keys;
-        let values = &*self.values;
+        let keys = &self.keys;
+        let values = &self.values;
         let len = self.keys.zvl_len();
         (0..len).map(move |idx| {
             (
diff --git a/vendor/zerovec/src/map/databake.rs b/vendor/zerovec/src/map/databake.rs
index d98b48f9f..fceb6a966 100644
--- a/vendor/zerovec/src/map/databake.rs
+++ b/vendor/zerovec/src/map/databake.rs
@@ -43,16 +43,14 @@ fn test_baked_map() {
             #[allow(unused_unsafe)]
             crate::ZeroMap::from_parts_unchecked(
                 unsafe {
-                    crate::VarZeroVec::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8, 0u8, 0u8, 97u8,
-                        100u8, 98u8, 99u8,
-                    ])
+                    crate::VarZeroVec::from_bytes_unchecked(
+                        b"\x02\0\0\0\0\0\0\0\x02\0\0\0adbc"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroVec::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 0u8, 69u8, 82u8,
-                        65u8, 49u8, 69u8, 82u8, 65u8, 48u8,
-                    ])
+                    crate::VarZeroVec::from_bytes_unchecked(
+                        b"\x02\0\0\0\0\0\0\0\x04\0\0\0ERA1ERA0"
+                    )
                 },
             )
         },
@@ -68,16 +66,14 @@ fn test_baked_borrowed_map() {
             #[allow(unused_unsafe)]
             crate::maps::ZeroMapBorrowed::from_parts_unchecked(
                 unsafe {
-                    crate::VarZeroSlice::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8, 0u8, 0u8, 97u8,
-                        100u8, 98u8, 99u8,
-                    ])
+                    crate::VarZeroSlice::from_bytes_unchecked(
+                        b"\x02\0\0\0\0\0\0\0\x02\0\0\0adbc"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroSlice::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 0u8, 69u8, 82u8,
-                        65u8, 49u8, 69u8, 82u8, 65u8, 48u8,
-                    ])
+                    crate::VarZeroSlice::from_bytes_unchecked(
+                        b"\x02\0\0\0\0\0\0\0\x04\0\0\0ERA1ERA0"
+                    )
                 },
             )
         },
diff --git a/vendor/zerovec/src/map/vecs.rs b/vendor/zerovec/src/map/vecs.rs
index b460e5967..5ee93d3fe 100644
--- a/vendor/zerovec/src/map/vecs.rs
+++ b/vendor/zerovec/src/map/vecs.rs
@@ -195,7 +195,7 @@ where
     where
         T: Ord,
     {
-        let zs: &ZeroSlice<T> = &*self;
+        let zs: &ZeroSlice<T> = self;
         zs.zvl_binary_search_in_range(k, range)
     }
     fn zvl_binary_search_by(
@@ -209,7 +209,7 @@ where
         predicate: impl FnMut(&T) -> Ordering,
         range: Range<usize>,
     ) -> Option<Result<usize, usize>> {
-        let zs: &ZeroSlice<T> = &*self;
+        let zs: &ZeroSlice<T> = self;
         zs.zvl_binary_search_in_range_by(predicate, range)
     }
     fn zvl_get(&self, index: usize) -> Option<&T::ULE> {
@@ -218,11 +218,9 @@ where
     fn zvl_len(&self) -> usize {
         ZeroSlice::len(self)
     }
-
     fn zvl_as_borrowed(&self) -> &ZeroSlice<T> {
-        &*self
+        self
     }
-
     #[inline]
     fn zvl_get_as_t<R>(g: &Self::GetType, f: impl FnOnce(&T) -> R) -> R {
         f(&T::from_unaligned(*g))
@@ -274,7 +272,6 @@ where
     fn zvl_len(&self) -> usize {
         ZeroSlice::len(self)
     }
-
     fn zvl_as_borrowed(&self) -> &ZeroSlice<T> {
         self
     }
@@ -565,7 +562,7 @@ impl<'a> ZeroVecLike<usize> for FlexZeroVec<'a> {
     }
 
     fn zvl_as_borrowed(&self) -> &FlexZeroSlice {
-        &*self
+        self
     }
 
     #[inline]
diff --git a/vendor/zerovec/src/map2d/databake.rs b/vendor/zerovec/src/map2d/databake.rs
index 90ab970bb..65e475c32 100644
--- a/vendor/zerovec/src/map2d/databake.rs
+++ b/vendor/zerovec/src/map2d/databake.rs
@@ -51,49 +51,24 @@ fn test_baked_map() {
             #[allow(unused_unsafe)]
             crate::ZeroMap2d::from_parts_unchecked(
                 unsafe {
-                    crate::VarZeroVec::from_bytes_unchecked(&[
-                        97u8, 114u8, 99u8, 97u8, 122u8, 0u8, 99u8, 117u8, 0u8, 101u8, 110u8, 0u8,
-                        102u8, 102u8, 0u8, 103u8, 114u8, 99u8, 107u8, 107u8, 0u8, 107u8, 117u8,
-                        0u8, 107u8, 121u8, 0u8, 108u8, 105u8, 102u8, 109u8, 97u8, 110u8, 109u8,
-                        110u8, 0u8, 112u8, 97u8, 0u8, 112u8, 97u8, 108u8, 115u8, 100u8, 0u8, 116u8,
-                        103u8, 0u8, 117u8, 103u8, 0u8, 117u8, 110u8, 114u8, 117u8, 122u8, 0u8,
-                        121u8, 117u8, 101u8, 122u8, 104u8, 0u8,
-                    ])
+                    crate::VarZeroVec::from_bytes_unchecked(
+                        b"arcaz\0cu\0en\0ff\0grckk\0ku\0ky\0lifmanmn\0pa\0palsd\0tg\0ug\0unruz\0yuezh\0"
+                    )
                 },
                 unsafe {
-                    crate::ZeroVec::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 3u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 0u8, 5u8, 0u8, 0u8,
-                        0u8, 6u8, 0u8, 0u8, 0u8, 7u8, 0u8, 0u8, 0u8, 8u8, 0u8, 0u8, 0u8, 10u8, 0u8,
-                        0u8, 0u8, 12u8, 0u8, 0u8, 0u8, 13u8, 0u8, 0u8, 0u8, 14u8, 0u8, 0u8, 0u8,
-                        15u8, 0u8, 0u8, 0u8, 16u8, 0u8, 0u8, 0u8, 17u8, 0u8, 0u8, 0u8, 20u8, 0u8,
-                        0u8, 0u8, 21u8, 0u8, 0u8, 0u8, 22u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8,
-                        24u8, 0u8, 0u8, 0u8, 25u8, 0u8, 0u8, 0u8, 28u8, 0u8, 0u8, 0u8,
-                    ])
+                    crate::ZeroVec::from_bytes_unchecked(
+                        b"\x02\0\0\0\x03\0\0\0\x04\0\0\0\x05\0\0\0\x06\0\0\0\x07\0\0\0\x08\0\0\0\n\0\0\0\x0C\0\0\0\r\0\0\0\x0E\0\0\0\x0F\0\0\0\x10\0\0\0\x11\0\0\0\x14\0\0\0\x15\0\0\0\x16\0\0\0\x17\0\0\0\x18\0\0\0\x19\0\0\0\x1C\0\0\0"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroVec::from_bytes_unchecked(&[
-                        78u8, 98u8, 97u8, 116u8, 80u8, 97u8, 108u8, 109u8, 65u8, 114u8, 97u8, 98u8,
-                        71u8, 108u8, 97u8, 103u8, 83u8, 104u8, 97u8, 119u8, 65u8, 100u8, 108u8,
-                        109u8, 76u8, 105u8, 110u8, 98u8, 65u8, 114u8, 97u8, 98u8, 65u8, 114u8,
-                        97u8, 98u8, 89u8, 101u8, 122u8, 105u8, 65u8, 114u8, 97u8, 98u8, 76u8, 97u8,
-                        116u8, 110u8, 76u8, 105u8, 109u8, 98u8, 78u8, 107u8, 111u8, 111u8, 77u8,
-                        111u8, 110u8, 103u8, 65u8, 114u8, 97u8, 98u8, 80u8, 104u8, 108u8, 112u8,
-                        68u8, 101u8, 118u8, 97u8, 75u8, 104u8, 111u8, 106u8, 83u8, 105u8, 110u8,
-                        100u8, 65u8, 114u8, 97u8, 98u8, 67u8, 121u8, 114u8, 108u8, 68u8, 101u8,
-                        118u8, 97u8, 65u8, 114u8, 97u8, 98u8, 72u8, 97u8, 110u8, 115u8, 66u8,
-                        111u8, 112u8, 111u8, 72u8, 97u8, 110u8, 98u8, 72u8, 97u8, 110u8, 116u8,
-                    ])
+                    crate::VarZeroVec::from_bytes_unchecked(
+                        b"NbatPalmArabGlagShawAdlmLinbArabArabYeziArabLatnLimbNkooMongArabPhlpDevaKhojSindArabCyrlDevaArabHansBopoHanbHant"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroVec::from_bytes_unchecked(&[
-                        74u8, 79u8, 0u8, 83u8, 89u8, 0u8, 73u8, 82u8, 0u8, 66u8, 71u8, 0u8, 71u8,
-                        66u8, 0u8, 71u8, 78u8, 0u8, 71u8, 82u8, 0u8, 67u8, 78u8, 0u8, 73u8, 81u8,
-                        0u8, 71u8, 69u8, 0u8, 67u8, 78u8, 0u8, 84u8, 82u8, 0u8, 73u8, 78u8, 0u8,
-                        71u8, 78u8, 0u8, 67u8, 78u8, 0u8, 80u8, 75u8, 0u8, 67u8, 78u8, 0u8, 73u8,
-                        78u8, 0u8, 73u8, 78u8, 0u8, 73u8, 78u8, 0u8, 80u8, 75u8, 0u8, 75u8, 90u8,
-                        0u8, 78u8, 80u8, 0u8, 65u8, 70u8, 0u8, 67u8, 78u8, 0u8, 84u8, 87u8, 0u8,
-                        84u8, 87u8, 0u8, 84u8, 87u8, 0u8,
-                    ])
+                    crate::VarZeroVec::from_bytes_unchecked(
+                        b"JO\0SY\0IR\0BG\0GB\0GN\0GR\0CN\0IQ\0GE\0CN\0TR\0IN\0GN\0CN\0PK\0CN\0IN\0IN\0IN\0PK\0KZ\0NP\0AF\0CN\0TW\0TW\0TW\0"
+                    )
                 },
             )
         },
@@ -109,49 +84,24 @@ fn test_baked_borrowed_map() {
             #[allow(unused_unsafe)]
             crate::maps::ZeroMap2dBorrowed::from_parts_unchecked(
                 unsafe {
-                    crate::VarZeroSlice::from_bytes_unchecked(&[
-                        97u8, 114u8, 99u8, 97u8, 122u8, 0u8, 99u8, 117u8, 0u8, 101u8, 110u8, 0u8,
-                        102u8, 102u8, 0u8, 103u8, 114u8, 99u8, 107u8, 107u8, 0u8, 107u8, 117u8,
-                        0u8, 107u8, 121u8, 0u8, 108u8, 105u8, 102u8, 109u8, 97u8, 110u8, 109u8,
-                        110u8, 0u8, 112u8, 97u8, 0u8, 112u8, 97u8, 108u8, 115u8, 100u8, 0u8, 116u8,
-                        103u8, 0u8, 117u8, 103u8, 0u8, 117u8, 110u8, 114u8, 117u8, 122u8, 0u8,
-                        121u8, 117u8, 101u8, 122u8, 104u8, 0u8,
-                    ])
+                    crate::VarZeroSlice::from_bytes_unchecked(
+                        b"arcaz\0cu\0en\0ff\0grckk\0ku\0ky\0lifmanmn\0pa\0palsd\0tg\0ug\0unruz\0yuezh\0"
+                    )
                 },
                 unsafe {
-                    crate::ZeroSlice::from_bytes_unchecked(&[
-                        2u8, 0u8, 0u8, 0u8, 3u8, 0u8, 0u8, 0u8, 4u8, 0u8, 0u8, 0u8, 5u8, 0u8, 0u8,
-                        0u8, 6u8, 0u8, 0u8, 0u8, 7u8, 0u8, 0u8, 0u8, 8u8, 0u8, 0u8, 0u8, 10u8, 0u8,
-                        0u8, 0u8, 12u8, 0u8, 0u8, 0u8, 13u8, 0u8, 0u8, 0u8, 14u8, 0u8, 0u8, 0u8,
-                        15u8, 0u8, 0u8, 0u8, 16u8, 0u8, 0u8, 0u8, 17u8, 0u8, 0u8, 0u8, 20u8, 0u8,
-                        0u8, 0u8, 21u8, 0u8, 0u8, 0u8, 22u8, 0u8, 0u8, 0u8, 23u8, 0u8, 0u8, 0u8,
-                        24u8, 0u8, 0u8, 0u8, 25u8, 0u8, 0u8, 0u8, 28u8, 0u8, 0u8, 0u8,
-                    ])
+                    crate::ZeroSlice::from_bytes_unchecked(
+                        b"\x02\0\0\0\x03\0\0\0\x04\0\0\0\x05\0\0\0\x06\0\0\0\x07\0\0\0\x08\0\0\0\n\0\0\0\x0C\0\0\0\r\0\0\0\x0E\0\0\0\x0F\0\0\0\x10\0\0\0\x11\0\0\0\x14\0\0\0\x15\0\0\0\x16\0\0\0\x17\0\0\0\x18\0\0\0\x19\0\0\0\x1C\0\0\0"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroSlice::from_bytes_unchecked(&[
-                        78u8, 98u8, 97u8, 116u8, 80u8, 97u8, 108u8, 109u8, 65u8, 114u8, 97u8, 98u8,
-                        71u8, 108u8, 97u8, 103u8, 83u8, 104u8, 97u8, 119u8, 65u8, 100u8, 108u8,
-                        109u8, 76u8, 105u8, 110u8, 98u8, 65u8, 114u8, 97u8, 98u8, 65u8, 114u8,
-                        97u8, 98u8, 89u8, 101u8, 122u8, 105u8, 65u8, 114u8, 97u8, 98u8, 76u8, 97u8,
-                        116u8, 110u8, 76u8, 105u8, 109u8, 98u8, 78u8, 107u8, 111u8, 111u8, 77u8,
-                        111u8, 110u8, 103u8, 65u8, 114u8, 97u8, 98u8, 80u8, 104u8, 108u8, 112u8,
-                        68u8, 101u8, 118u8, 97u8, 75u8, 104u8, 111u8, 106u8, 83u8, 105u8, 110u8,
-                        100u8, 65u8, 114u8, 97u8, 98u8, 67u8, 121u8, 114u8, 108u8, 68u8, 101u8,
-                        118u8, 97u8, 65u8, 114u8, 97u8, 98u8, 72u8, 97u8, 110u8, 115u8, 66u8,
-                        111u8, 112u8, 111u8, 72u8, 97u8, 110u8, 98u8, 72u8, 97u8, 110u8, 116u8,
-                    ])
+                    crate::VarZeroSlice::from_bytes_unchecked(
+                        b"NbatPalmArabGlagShawAdlmLinbArabArabYeziArabLatnLimbNkooMongArabPhlpDevaKhojSindArabCyrlDevaArabHansBopoHanbHant"
+                    )
                 },
                 unsafe {
-                    crate::VarZeroSlice::from_bytes_unchecked(&[
-                        74u8, 79u8, 0u8, 83u8, 89u8, 0u8, 73u8, 82u8, 0u8, 66u8, 71u8, 0u8, 71u8,
-                        66u8, 0u8, 71u8, 78u8, 0u8, 71u8, 82u8, 0u8, 67u8, 78u8, 0u8, 73u8, 81u8,
-                        0u8, 71u8, 69u8, 0u8, 67u8, 78u8, 0u8, 84u8, 82u8, 0u8, 73u8, 78u8, 0u8,
-                        71u8, 78u8, 0u8, 67u8, 78u8, 0u8, 80u8, 75u8, 0u8, 67u8, 78u8, 0u8, 73u8,
-                        78u8, 0u8, 73u8, 78u8, 0u8, 73u8, 78u8, 0u8, 80u8, 75u8, 0u8, 75u8, 90u8,
-                        0u8, 78u8, 80u8, 0u8, 65u8, 70u8, 0u8, 67u8, 78u8, 0u8, 84u8, 87u8, 0u8,
-                        84u8, 87u8, 0u8, 84u8, 87u8, 0u8,
-                    ])
+                    crate::VarZeroSlice::from_bytes_unchecked(
+                        b"JO\0SY\0IR\0BG\0GB\0GN\0GR\0CN\0IQ\0GE\0CN\0TR\0IN\0GN\0CN\0PK\0CN\0IN\0IN\0IN\0PK\0KZ\0NP\0AF\0CN\0TW\0TW\0TW\0"
+                    )
                 },
             )
         },
diff --git a/vendor/zerovec/src/map2d/map.rs b/vendor/zerovec/src/map2d/map.rs
index e6545dfa5..8bdefe792 100644
--- a/vendor/zerovec/src/map2d/map.rs
+++ b/vendor/zerovec/src/map2d/map.rs
@@ -160,7 +160,7 @@ where
     pub fn as_borrowed(&'a self) -> ZeroMap2dBorrowed<'a, K0, K1, V> {
         ZeroMap2dBorrowed {
             keys0: self.keys0.zvl_as_borrowed(),
-            joiner: &*self.joiner,
+            joiner: &self.joiner,
             keys1: self.keys1.zvl_as_borrowed(),
             values: self.values.zvl_as_borrowed(),
         }
@@ -710,7 +710,7 @@ mod test {
         let mut zm2d = ZeroMap2d::<u16, str, str>::new();
 
         assert_eq!(
-            format!("{:?}", zm2d),
+            format!("{zm2d:?}"),
             "ZeroMap2d { keys0: ZeroVec([]), joiner: ZeroVec([]), keys1: [], values: [] }"
         );
         assert_eq!(zm2d.get0(&0), None);
@@ -718,7 +718,7 @@ mod test {
         let result = zm2d.try_append(&3, "ccc", "CCC");
         assert!(matches!(result, None));
 
-        assert_eq!(format!("{:?}", zm2d), "ZeroMap2d { keys0: ZeroVec([3]), joiner: ZeroVec([1]), keys1: [\"ccc\"], values: [\"CCC\"] }");
+        assert_eq!(format!("{zm2d:?}"), "ZeroMap2d { keys0: ZeroVec([3]), joiner: ZeroVec([1]), keys1: [\"ccc\"], values: [\"CCC\"] }");
         assert_eq!(zm2d.get0(&0), None);
         assert_eq!(zm2d.get0(&3).unwrap().get1(""), None);
         assert_eq!(zm2d.get_2d(&3, "ccc"), Some("CCC"));
@@ -727,7 +727,7 @@ mod test {
         let result = zm2d.try_append(&3, "eee", "EEE");
         assert!(matches!(result, None));
 
-        assert_eq!(format!("{:?}", zm2d), "ZeroMap2d { keys0: ZeroVec([3]), joiner: ZeroVec([2]), keys1: [\"ccc\", \"eee\"], values: [\"CCC\", \"EEE\"] }");
+        assert_eq!(format!("{zm2d:?}"), "ZeroMap2d { keys0: ZeroVec([3]), joiner: ZeroVec([2]), keys1: [\"ccc\", \"eee\"], values: [\"CCC\", \"EEE\"] }");
         assert_eq!(zm2d.get0(&0), None);
         assert_eq!(zm2d.get0(&3).unwrap().get1(""), None);
         assert_eq!(zm2d.get_2d(&3, "ccc"), Some("CCC"));
@@ -751,7 +751,7 @@ mod test {
         let result = zm2d.try_append(&9, "yyy", "YYY");
         assert!(matches!(result, None));
 
-        assert_eq!(format!("{:?}", zm2d), "ZeroMap2d { keys0: ZeroVec([3, 5, 7, 9]), joiner: ZeroVec([2, 3, 6, 7]), keys1: [\"ccc\", \"eee\", \"ddd\", \"ddd\", \"eee\", \"www\", \"yyy\"], values: [\"CCC\", \"EEE\", \"DD1\", \"DD2\", \"EEE\", \"WWW\", \"YYY\"] }");
+        assert_eq!(format!("{zm2d:?}"), "ZeroMap2d { keys0: ZeroVec([3, 5, 7, 9]), joiner: ZeroVec([2, 3, 6, 7]), keys1: [\"ccc\", \"eee\", \"ddd\", \"ddd\", \"eee\", \"www\", \"yyy\"], values: [\"CCC\", \"EEE\", \"DD1\", \"DD2\", \"EEE\", \"WWW\", \"YYY\"] }");
         assert_eq!(zm2d.get0(&0), None);
         assert_eq!(zm2d.get0(&3).unwrap().get1(""), None);
         assert_eq!(zm2d.get_2d(&3, "ccc"), Some("CCC"));
@@ -782,7 +782,7 @@ mod test {
         zm2d.insert(&6, "mmm", "MM1");
         zm2d.insert(&6, "nnn", "NNN");
 
-        assert_eq!(format!("{:?}", zm2d), "ZeroMap2d { keys0: ZeroVec([3, 5, 6, 7, 9]), joiner: ZeroVec([3, 4, 7, 10, 11]), keys1: [\"ccc\", \"eee\", \"mmm\", \"ddd\", \"ddd\", \"mmm\", \"nnn\", \"ddd\", \"eee\", \"www\", \"yyy\"], values: [\"CCC\", \"EEE\", \"MM0\", \"DD1\", \"DD3\", \"MM1\", \"NNN\", \"DD2\", \"EEE\", \"WWW\", \"YYY\"] }");
+        assert_eq!(format!("{zm2d:?}"), "ZeroMap2d { keys0: ZeroVec([3, 5, 6, 7, 9]), joiner: ZeroVec([3, 4, 7, 10, 11]), keys1: [\"ccc\", \"eee\", \"mmm\", \"ddd\", \"ddd\", \"mmm\", \"nnn\", \"ddd\", \"eee\", \"www\", \"yyy\"], values: [\"CCC\", \"EEE\", \"MM0\", \"DD1\", \"DD3\", \"MM1\", \"NNN\", \"DD2\", \"EEE\", \"WWW\", \"YYY\"] }");
         assert_eq!(zm2d.get0(&0), None);
         assert_eq!(zm2d.get0(&3).unwrap().get1(""), None);
         assert_eq!(zm2d.get_2d(&3, "ccc"), Some("CCC"));
@@ -822,6 +822,6 @@ mod test {
         let result = zm2d.remove(&9, "yyy"); // last element
         assert_eq!(result.as_deref(), Some("YYY"));
 
-        assert_eq!(format!("{:?}", zm2d), "ZeroMap2d { keys0: ZeroVec([3, 6, 7]), joiner: ZeroVec([1, 4, 7]), keys1: [\"eee\", \"ddd\", \"mmm\", \"nnn\", \"ddd\", \"eee\", \"www\"], values: [\"EEE\", \"DD3\", \"MM1\", \"NNN\", \"DD2\", \"EEE\", \"WWW\"] }");
+        assert_eq!(format!("{zm2d:?}"), "ZeroMap2d { keys0: ZeroVec([3, 6, 7]), joiner: ZeroVec([1, 4, 7]), keys1: [\"eee\", \"ddd\", \"mmm\", \"nnn\", \"ddd\", \"eee\", \"www\"], values: [\"EEE\", \"DD3\", \"MM1\", \"NNN\", \"DD2\", \"EEE\", \"WWW\"] }");
     }
 }
diff --git a/vendor/zerovec/src/map2d/serde.rs b/vendor/zerovec/src/map2d/serde.rs
index b5e913654..53e3284b3 100644
--- a/vendor/zerovec/src/map2d/serde.rs
+++ b/vendor/zerovec/src/map2d/serde.rs
@@ -388,7 +388,7 @@ mod test {
         assert_eq!(JSON_STR, json_str);
         let new_map: ZeroMap2d<u32, u16, str> =
             serde_json::from_str(&json_str).expect("deserialize");
-        assert_eq!(format!("{:?}", new_map), format!("{:?}", map));
+        assert_eq!(format!("{new_map:?}"), format!("{map:?}"));
     }
 
     #[test]
@@ -399,15 +399,15 @@ mod test {
         let new_map: ZeroMap2d<u32, u16, str> =
             bincode::deserialize(&bincode_bytes).expect("deserialize");
         assert_eq!(
-            format!("{:?}", new_map),
-            format!("{:?}", map).replace("Owned", "Borrowed"),
+            format!("{new_map:?}"),
+            format!("{map:?}").replace("Owned", "Borrowed"),
         );
 
         let new_map: ZeroMap2dBorrowed<u32, u16, str> =
             bincode::deserialize(&bincode_bytes).expect("deserialize");
         assert_eq!(
-            format!("{:?}", new_map),
-            format!("{:?}", map)
+            format!("{new_map:?}"),
+            format!("{map:?}")
                 .replace("Owned", "Borrowed")
                 .replace("ZeroMap2d", "ZeroMap2dBorrowed")
         );
diff --git a/vendor/zerovec/src/ule/chars.rs b/vendor/zerovec/src/ule/chars.rs
index 4298d7338..7a4a97a4a 100644
--- a/vendor/zerovec/src/ule/chars.rs
+++ b/vendor/zerovec/src/ule/chars.rs
@@ -37,7 +37,7 @@ use core::convert::TryFrom;
 /// CharULE::parse_byte_slice(bytes).expect_err("Invalid bytes");
 /// ```
 #[repr(transparent)]
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct CharULE([u8; 3]);
 
 // Safety (based on the safety checklist on the ULE trait):
diff --git a/vendor/zerovec/src/ule/encode.rs b/vendor/zerovec/src/ule/encode.rs
index 3043bbd0a..2091cf06b 100644
--- a/vendor/zerovec/src/ule/encode.rs
+++ b/vendor/zerovec/src/ule/encode.rs
@@ -121,7 +121,7 @@ where
 
 unsafe impl<T: VarULE + ?Sized> EncodeAsVarULE<T> for Box<T> {
     fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R {
-        cb(&[T::as_byte_slice(&*self)])
+        cb(&[T::as_byte_slice(self)])
     }
 }
 
@@ -138,7 +138,7 @@ where
     T: ULE,
 {
     fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R {
-        cb(&[<[T] as VarULE>::as_byte_slice(&*self)])
+        cb(&[<[T] as VarULE>::as_byte_slice(self)])
     }
 }
 
diff --git a/vendor/zerovec/src/ule/multi.rs b/vendor/zerovec/src/ule/multi.rs
index 1eacfac69..0ba0aea89 100644
--- a/vendor/zerovec/src/ule/multi.rs
+++ b/vendor/zerovec/src/ule/multi.rs
@@ -15,7 +15,7 @@ use core::mem;
 /// where `V1` etc are potentially different [`VarULE`] types.
 ///
 /// Internally, it is represented by a VarZeroSlice.
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug)]
 #[repr(transparent)]
 pub struct MultiFieldsULE(VarZeroSlice<[u8], Index32>);
 
diff --git a/vendor/zerovec/src/ule/niche.rs b/vendor/zerovec/src/ule/niche.rs
index 688357f77..ae61faca0 100644
--- a/vendor/zerovec/src/ule/niche.rs
+++ b/vendor/zerovec/src/ule/niche.rs
@@ -10,7 +10,7 @@ use super::{AsULE, ULE};
 /// can never occur as a valid byte representation of the type.
 ///
 /// Guarantees for a valid implementation.
-/// 1. N must be equal to core::mem::sizeo_of::<Self>() or else it will
+/// 1. N must be equal to `core::mem::sizeo_of::<Self>()` or else it will
 ///    cause panics.
 /// 2. The bit pattern [`NicheBytes::NICHE_BIT_PATTERN`] must not be incorrect as it would lead to
 ///    weird behaviour.
@@ -54,8 +54,16 @@ pub union NichedOptionULE<U: NicheBytes<N> + ULE, const N: usize> {
     valid: U,
 }
 
+impl<U: NicheBytes<N> + ULE + core::fmt::Debug, const N: usize> core::fmt::Debug
+    for NichedOptionULE<U, N>
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.get().fmt(f)
+    }
+}
+
 impl<U: NicheBytes<N> + ULE, const N: usize> NichedOptionULE<U, N> {
-    /// New NichedOptionULE<U, N> from Option<U>
+    /// New `NichedOptionULE<U, N>` from `Option<U>`
     pub fn new(opt: Option<U>) -> Self {
         assert!(N == core::mem::size_of::<U>());
         match opt {
@@ -66,7 +74,7 @@ impl<U: NicheBytes<N> + ULE, const N: usize> NichedOptionULE<U, N> {
         }
     }
 
-    /// Convert to an Option<U>
+    /// Convert to an `Option<U>`
     pub fn get(self) -> Option<U> {
         // Safety: The union stores NICHE_BIT_PATTERN when None otherwise a valid U
         unsafe {
@@ -131,7 +139,7 @@ unsafe impl<U: NicheBytes<N> + ULE, const N: usize> ULE for NichedOptionULE<U, N
 }
 
 /// Optional type which uses [`NichedOptionULE<U,N>`] as ULE type.
-/// The implementors guarantee that N == core::mem::sizeo_of::<Self>()
+/// The implementors guarantee that `N == core::mem::sizeo_of::<Self>()`
 /// [`repr(transparent)`] guarantees that the layout is same as [`Option<U>`]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[repr(transparent)]
diff --git a/vendor/zerovec/src/ule/option.rs b/vendor/zerovec/src/ule/option.rs
index a6b1966a5..50b193aac 100644
--- a/vendor/zerovec/src/ule/option.rs
+++ b/vendor/zerovec/src/ule/option.rs
@@ -32,7 +32,7 @@ use core::mem::{self, MaybeUninit};
 pub struct OptionULE<U>(bool, MaybeUninit<U>);
 
 impl<U: Copy> OptionULE<U> {
-    /// Obtain this as an Option<T>
+    /// Obtain this as an `Option<T>`
     pub fn get(self) -> Option<U> {
         if self.0 {
             unsafe {
@@ -44,7 +44,7 @@ impl<U: Copy> OptionULE<U> {
         }
     }
 
-    /// Construct an OptionULE<U> from an equivalent Option<T>
+    /// Construct an `OptionULE<U>` from an equivalent `Option<T>`
     pub fn new(opt: Option<U>) -> Self {
         if let Some(inner) = opt {
             Self(true, MaybeUninit::new(inner))
@@ -54,6 +54,12 @@ impl<U: Copy> OptionULE<U> {
     }
 }
 
+impl<U: Copy + core::fmt::Debug> core::fmt::Debug for OptionULE<U> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.get().fmt(f)
+    }
+}
+
 // Safety (based on the safety checklist on the ULE trait):
 //  1. OptionULE does not include any uninitialized or padding bytes.
 //     (achieved by `#[repr(packed)]` on a struct containing only ULE fields,
@@ -152,6 +158,12 @@ impl<U: VarULE + ?Sized> OptionVarULE<U> {
     }
 }
 
+impl<U: VarULE + ?Sized + core::fmt::Debug> core::fmt::Debug for OptionVarULE<U> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.as_ref().fmt(f)
+    }
+}
+
 // Safety (based on the safety checklist on the VarULE trait):
 //  1. OptionVarULE<T> does not include any uninitialized or padding bytes
 //     (achieved by being repr(packed) on ULE types)
diff --git a/vendor/zerovec/src/varzerovec/components.rs b/vendor/zerovec/src/varzerovec/components.rs
index bf70c83c5..ff26d9029 100644
--- a/vendor/zerovec/src/varzerovec/components.rs
+++ b/vendor/zerovec/src/varzerovec/components.rs
@@ -85,7 +85,7 @@ unsafe impl VarZeroVecFormat for Index16 {
 
 unsafe impl VarZeroVecFormat for Index32 {
     const INDEX_WIDTH: usize = 4;
-    const MAX_VALUE: u32 = u32::MAX as u32;
+    const MAX_VALUE: u32 = u32::MAX;
     type RawBytes = RawBytesULE<4>;
     #[inline]
     fn rawbytes_to_usize(raw: Self::RawBytes) -> usize {
@@ -110,6 +110,7 @@ unsafe impl VarZeroVecFormat for Index32 {
 /// exist.
 ///
 /// See [`VarZeroVecComponents::parse_byte_slice()`] for information on the internal invariants involved
+#[derive(Debug)]
 pub struct VarZeroVecComponents<'a, T: ?Sized, F> {
     /// The number of elements
     len: u32,
@@ -197,7 +198,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecComponents<'a, T, F>
             .ok_or(ZeroVecError::VarZeroVecFormatError)?;
 
         let borrowed = VarZeroVecComponents {
-            len: len as u32,
+            len,
             indices: indices_bytes,
             things,
             entire_slice: slice,
@@ -392,7 +393,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecComponents<'a, T, F>
             .copied()
             .map(F::rawbytes_to_usize)
             .collect::<Vec<_>>();
-        format!("VarZeroVecComponents {{ indices: {:?} }}", indices)
+        format!("VarZeroVecComponents {{ indices: {indices:?} }}")
     }
 }
 
diff --git a/vendor/zerovec/src/varzerovec/databake.rs b/vendor/zerovec/src/varzerovec/databake.rs
index 2c3d506b3..8d9fc0bfc 100644
--- a/vendor/zerovec/src/varzerovec/databake.rs
+++ b/vendor/zerovec/src/varzerovec/databake.rs
@@ -8,18 +8,26 @@ use databake::*;
 impl<T: VarULE + ?Sized> Bake for VarZeroVec<'_, T> {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        // Safe because self.as_bytes is a safe input
-        quote! { unsafe { ::zerovec::VarZeroVec::from_bytes_unchecked(&[#(#bytes),*]) } }
+        if self.is_empty() {
+            quote! { ::zerovec::VarZeroVec::new() }
+        } else {
+            let bytes = databake::Bake::bake(&self.as_bytes(), env);
+            // Safe because self.as_bytes is a safe input
+            quote! { unsafe { ::zerovec::VarZeroVec::from_bytes_unchecked(#bytes) } }
+        }
     }
 }
 
 impl<T: VarULE + ?Sized> Bake for &VarZeroSlice<T> {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        // Safe because self.as_bytes is a safe input
-        quote! { unsafe { ::zerovec::VarZeroSlice::from_bytes_unchecked(&[#(#bytes),*]) } }
+        if self.is_empty() {
+            quote! { ::zerovec::VarZeroSlice::new_empty() }
+        } else {
+            let bytes = databake::Bake::bake(&self.as_bytes(), env);
+            // Safe because self.as_bytes is a safe input
+            quote! { unsafe { ::zerovec::VarZeroSlice::from_bytes_unchecked(#bytes) } }
+        }
     }
 }
 
@@ -27,10 +35,15 @@ impl<T: VarULE + ?Sized> Bake for &VarZeroSlice<T> {
 fn test_baked_vec() {
     test_bake!(
         VarZeroVec<str>,
+        const: crate::VarZeroVec::new(),
+        zerovec
+    );
+    test_bake!(
+        VarZeroVec<str>,
         const: unsafe {
-            crate::VarZeroVec::from_bytes_unchecked(&[
-                2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8, 17u8,
-            ])
+            crate::VarZeroVec::from_bytes_unchecked(
+                b"\x02\x01\0\x16\0M\x01\\\x11"
+            )
         },
         zerovec
     );
@@ -40,10 +53,15 @@ fn test_baked_vec() {
 fn test_baked_slice() {
     test_bake!(
         &VarZeroSlice<str>,
+        const: crate::VarZeroSlice::new_empty(),
+        zerovec
+    );
+    test_bake!(
+        &VarZeroSlice<str>,
         const: unsafe {
-            crate::VarZeroSlice::from_bytes_unchecked(&[
-                2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8, 17u8,
-            ])
+            crate::VarZeroSlice::from_bytes_unchecked(
+                b"\x02\x01\0\x16\0M\x01\\\x11"
+            )
         },
         zerovec
     );
diff --git a/vendor/zerovec/src/varzerovec/owned.rs b/vendor/zerovec/src/varzerovec/owned.rs
index af4692d48..76de48760 100644
--- a/vendor/zerovec/src/varzerovec/owned.rs
+++ b/vendor/zerovec/src/varzerovec/owned.rs
@@ -96,7 +96,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
 
     /// Obtain this `VarZeroVec` as a [`VarZeroSlice`]
     pub fn as_slice(&self) -> &VarZeroSlice<T, F> {
-        let slice: &[u8] = &*self.entire_slice;
+        let slice: &[u8] = &self.entire_slice;
         unsafe {
             // safety: the slice is known to come from a valid parsed VZV
             VarZeroSlice::from_byte_slice_unchecked(slice)
@@ -146,7 +146,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
     unsafe fn element_range_unchecked(&self, idx: usize) -> core::ops::Range<usize> {
         let start = self.element_position_unchecked(idx);
         let end = self.element_position_unchecked(idx + 1);
-        debug_assert!(start <= end, "{} > {}", start, end);
+        debug_assert!(start <= end, "{start} > {end}");
         start..end
     }
 
@@ -353,7 +353,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
             + METADATA_WIDTH
             + self.len() * F::INDEX_WIDTH
             + self.element_position_unchecked(index);
-        &mut self.entire_slice[element_pos..element_pos + new_size as usize]
+        &mut self.entire_slice[element_pos..element_pos + new_size]
     }
 
     /// Checks the internal invariants of the vec to ensure safe code will not cause UB.
@@ -423,10 +423,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
     pub fn insert<A: EncodeAsVarULE<T> + ?Sized>(&mut self, index: usize, element: &A) {
         let len = self.len();
         if index > len {
-            panic!(
-                "Called out-of-bounds insert() on VarZeroVec, index {} len {}",
-                index, len
-            );
+            panic!("Called out-of-bounds insert() on VarZeroVec, index {index} len {len}");
         }
 
         let value_len = element.encode_var_ule_len();
@@ -451,10 +448,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
     pub fn remove(&mut self, index: usize) {
         let len = self.len();
         if index >= len {
-            panic!(
-                "Called out-of-bounds remove() on VarZeroVec, index {} len {}",
-                index, len
-            );
+            panic!("Called out-of-bounds remove() on VarZeroVec, index {index} len {len}");
         }
         if len == 1 {
             // This is removing the last element. Set the slice to empty to ensure all empty vecs have empty data slices.
@@ -470,10 +464,7 @@ impl<T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVecOwned<T, F> {
     pub fn replace<A: EncodeAsVarULE<T> + ?Sized>(&mut self, index: usize, element: &A) {
         let len = self.len();
         if index >= len {
-            panic!(
-                "Called out-of-bounds replace() on VarZeroVec, index {} len {}",
-                index, len
-            );
+            panic!("Called out-of-bounds replace() on VarZeroVec, index {index} len {len}");
         }
 
         let value_len = element.encode_var_ule_len();
diff --git a/vendor/zerovec/src/varzerovec/vec.rs b/vendor/zerovec/src/varzerovec/vec.rs
index 7edb48a96..1401a180a 100644
--- a/vendor/zerovec/src/varzerovec/vec.rs
+++ b/vendor/zerovec/src/varzerovec/vec.rs
@@ -248,7 +248,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F> {
     /// assert!(vzv.is_empty());
     /// ```
     #[inline]
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self::Borrowed(VarZeroSlice::new_empty())
     }
 
@@ -354,7 +354,7 @@ impl<'a, T: VarULE + ?Sized, F: VarZeroVecFormat> VarZeroVec<'a, T, F> {
     /// Obtain this `VarZeroVec` as a [`VarZeroSlice`]
     pub fn as_slice(&self) -> &VarZeroSlice<T, F> {
         match *self {
-            VarZeroVec::Owned(ref owned) => &**owned,
+            VarZeroVec::Owned(ref owned) => owned,
             VarZeroVec::Borrowed(b) => b,
         }
     }
@@ -413,8 +413,7 @@ where
 {
     #[inline]
     fn from(elements: &Vec<A>) -> Self {
-        #[allow(clippy::unwrap_used)] // TODO(#1410) Better story for fallibility
-        VarZeroVecOwned::try_from_elements(elements).unwrap().into()
+        Self::from(elements.as_slice())
     }
 }
 
@@ -439,8 +438,7 @@ where
 {
     #[inline]
     fn from(elements: &[A; N]) -> Self {
-        #[allow(clippy::unwrap_used)] // TODO(#1410) Better story for fallibility
-        VarZeroVecOwned::try_from_elements(elements).unwrap().into()
+        Self::from(elements.as_slice())
     }
 }
 
diff --git a/vendor/zerovec/src/yoke_impls.rs b/vendor/zerovec/src/yoke_impls.rs
index 0efb47a2d..a5064a554 100644
--- a/vendor/zerovec/src/yoke_impls.rs
+++ b/vendor/zerovec/src/yoke_impls.rs
@@ -4,6 +4,7 @@
 
 // This way we can copy-paste Yokeable impls
 #![allow(clippy::forget_copy)]
+#![allow(clippy::forget_non_drop)]
 
 use crate::flexzerovec::FlexZeroVec;
 use crate::map::ZeroMapBorrowed;
@@ -305,11 +306,12 @@ mod test {
     }
 
     #[test]
+    #[ignore] // https://github.com/rust-lang/rust/issues/98906
     fn bake_ZeroVec() {
         test_bake!(
             DeriveTest_ZeroVec<'static>,
             crate::yoke_impls::test::DeriveTest_ZeroVec {
-                _data: unsafe { crate::ZeroVec::from_bytes_unchecked(&[]) },
+                _data: crate::ZeroVec::new(),
             },
             zerovec,
         );
@@ -328,7 +330,7 @@ mod test {
         test_bake!(
             DeriveTest_ZeroSlice<'static>,
             crate::yoke_impls::test::DeriveTest_ZeroSlice {
-                _data: unsafe { crate::ZeroSlice::from_bytes_unchecked(&[]) },
+                _data: crate::ZeroSlice::new_empty(),
             },
             zerovec,
         );
@@ -343,13 +345,13 @@ mod test {
     }
 
     #[test]
+    #[ignore] // https://github.com/rust-lang/rust/issues/98906
     fn bake_FlexZeroVec() {
         test_bake!(
             DeriveTest_FlexZeroVec<'static>,
             crate::yoke_impls::test::DeriveTest_FlexZeroVec {
-                _data: unsafe {
-                    crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[1u8]).as_flexzerovec()
-                },
+                _data: unsafe { crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(b"\x01") }
+                    .as_flexzerovec(),
             },
             zerovec,
         );
@@ -368,7 +370,7 @@ mod test {
         test_bake!(
             DeriveTest_FlexZeroSlice<'static>,
             crate::yoke_impls::test::DeriveTest_FlexZeroSlice {
-                _data: unsafe { crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(&[1u8]) },
+                _data: unsafe { crate::vecs::FlexZeroSlice::from_byte_slice_unchecked(b"\x01\0") },
             },
             zerovec,
         );
@@ -387,7 +389,7 @@ mod test {
         test_bake!(
             DeriveTest_VarZeroVec<'static>,
             crate::yoke_impls::test::DeriveTest_VarZeroVec {
-                _data: unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
+                _data: crate::VarZeroVec::new(),
             },
             zerovec,
         );
@@ -406,7 +408,7 @@ mod test {
         test_bake!(
             DeriveTest_VarZeroSlice<'static>,
             crate::yoke_impls::test::DeriveTest_VarZeroSlice {
-                _data: unsafe { crate::VarZeroSlice::from_bytes_unchecked(&[]) }
+                _data: crate::VarZeroSlice::new_empty()
             },
             zerovec,
         );
@@ -429,8 +431,8 @@ mod test {
                 _data: unsafe {
                     #[allow(unused_unsafe)]
                     crate::ZeroMap::from_parts_unchecked(
-                        unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
-                        unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
+                        crate::VarZeroVec::new(),
+                        crate::VarZeroVec::new(),
                     )
                 },
             },
@@ -455,8 +457,8 @@ mod test {
                 _data: unsafe {
                     #[allow(unused_unsafe)]
                     crate::maps::ZeroMapBorrowed::from_parts_unchecked(
-                        unsafe { crate::VarZeroSlice::from_bytes_unchecked(&[]) },
-                        unsafe { crate::VarZeroSlice::from_bytes_unchecked(&[]) },
+                        crate::VarZeroSlice::new_empty(),
+                        crate::VarZeroSlice::new_empty(),
                     )
                 },
             },
@@ -481,8 +483,8 @@ mod test {
                 _data: unsafe {
                     #[allow(unused_unsafe)]
                     crate::ZeroMap::from_parts_unchecked(
-                        unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
-                        unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
+                        crate::VarZeroVec::new(),
+                        crate::VarZeroVec::new(),
                     )
                 },
             },
@@ -507,10 +509,10 @@ mod test {
                 _data: unsafe {
                     #[allow(unused_unsafe)]
                     crate::ZeroMap2d::from_parts_unchecked(
-                        unsafe { crate::ZeroVec::from_bytes_unchecked(&[]) },
-                        unsafe { crate::ZeroVec::from_bytes_unchecked(&[]) },
-                        unsafe { crate::ZeroVec::from_bytes_unchecked(&[]) },
-                        unsafe { crate::VarZeroVec::from_bytes_unchecked(&[]) },
+                        crate::ZeroVec::new(),
+                        crate::ZeroVec::new(),
+                        crate::ZeroVec::new(),
+                        crate::VarZeroVec::new(),
                     )
                 },
             },
@@ -535,10 +537,10 @@ mod test {
                 _data: unsafe {
                     #[allow(unused_unsafe)]
                     crate::maps::ZeroMap2dBorrowed::from_parts_unchecked(
-                        unsafe { crate::ZeroSlice::from_bytes_unchecked(&[]) },
-                        unsafe { crate::ZeroSlice::from_bytes_unchecked(&[]) },
-                        unsafe { crate::ZeroSlice::from_bytes_unchecked(&[]) },
-                        unsafe { crate::VarZeroSlice::from_bytes_unchecked(&[]) },
+                        crate::ZeroSlice::new_empty(),
+                        crate::ZeroSlice::new_empty(),
+                        crate::ZeroSlice::new_empty(),
+                        crate::VarZeroSlice::new_empty(),
                     )
                 },
             },
diff --git a/vendor/zerovec/src/zerofrom_impls.rs b/vendor/zerovec/src/zerofrom_impls.rs
index dfb3da187..d17e432c4 100644
--- a/vendor/zerovec/src/zerofrom_impls.rs
+++ b/vendor/zerovec/src/zerofrom_impls.rs
@@ -41,14 +41,14 @@ where
 impl<'zf> ZeroFrom<'zf, FlexZeroVec<'_>> for FlexZeroVec<'zf> {
     #[inline]
     fn zero_from(other: &'zf FlexZeroVec<'_>) -> Self {
-        FlexZeroVec::Borrowed(&*other)
+        FlexZeroVec::Borrowed(other)
     }
 }
 
 impl<'zf> ZeroFrom<'zf, FlexZeroSlice> for FlexZeroVec<'zf> {
     #[inline]
     fn zero_from(other: &'zf FlexZeroSlice) -> Self {
-        FlexZeroVec::Borrowed(&*other)
+        FlexZeroVec::Borrowed(other)
     }
 }
 
diff --git a/vendor/zerovec/src/zerovec/databake.rs b/vendor/zerovec/src/zerovec/databake.rs
index 0643ddb40..e46065c38 100644
--- a/vendor/zerovec/src/zerovec/databake.rs
+++ b/vendor/zerovec/src/zerovec/databake.rs
@@ -12,8 +12,12 @@ where
 {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        quote! { unsafe { ::zerovec::ZeroVec::from_bytes_unchecked(&[#(#bytes),*]) } }
+        if self.is_empty() {
+            quote! { ::zerovec::ZeroVec::new() }
+        } else {
+            let bytes = databake::Bake::bake(&self.as_bytes(), env);
+            quote! { unsafe { ::zerovec::ZeroVec::from_bytes_unchecked(#bytes) } }
+        }
     }
 }
 
@@ -23,8 +27,12 @@ where
 {
     fn bake(&self, env: &CrateEnv) -> TokenStream {
         env.insert("zerovec");
-        let bytes = self.as_bytes();
-        quote! { unsafe { ::zerovec::ZeroSlice::from_bytes_unchecked(&[#(#bytes),*]) } }
+        if self.is_empty() {
+            quote! { ::zerovec::ZeroSlice::new_empty() }
+        } else {
+            let bytes = databake::Bake::bake(&self.as_bytes(), env);
+            quote! { unsafe { ::zerovec::ZeroSlice::from_bytes_unchecked(#bytes) } }
+        }
     }
 }
 
@@ -32,8 +40,13 @@ where
 fn test_baked_vec() {
     test_bake!(
         ZeroVec<u32>,
+        const: crate::ZeroVec::new(),
+        zerovec
+    );
+    test_bake!(
+        ZeroVec<u32>,
         const: unsafe {
-            crate::ZeroVec::from_bytes_unchecked(&[2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8])
+            crate::ZeroVec::from_bytes_unchecked(b"\x02\x01\0\x16\0M\x01\\")
         },
         zerovec
     );
@@ -43,8 +56,13 @@ fn test_baked_vec() {
 fn test_baked_slice() {
     test_bake!(
         &ZeroSlice<u32>,
+        const: crate::ZeroSlice::new_empty(),
+        zerovec
+    );
+    test_bake!(
+        &ZeroSlice<u32>,
         const: unsafe {
-            crate::ZeroSlice::from_bytes_unchecked(&[2u8, 1u8, 0u8, 22u8, 0u8, 77u8, 1u8, 92u8])
+            crate::ZeroSlice::from_bytes_unchecked(b"\x02\x01\0\x16\0M\x01\\")
         },
         zerovec
     );
diff --git a/vendor/zerovec/src/zerovec/mod.rs b/vendor/zerovec/src/zerovec/mod.rs
index 371450e21..e7c87f68e 100644
--- a/vendor/zerovec/src/zerovec/mod.rs
+++ b/vendor/zerovec/src/zerovec/mod.rs
@@ -284,7 +284,7 @@ where
         // Deconstruct the vector into parts
         // This is the only part of the code that goes from Vec
         // to ZeroVec, all other such operations should use this function
-        let slice: &[T::ULE] = &*vec;
+        let slice: &[T::ULE] = &vec;
         let slice = slice as *const [_] as *mut [_];
         let capacity = vec.capacity();
         mem::forget(vec);
diff --git a/vendor/zerovec/src/zerovec/slice.rs b/vendor/zerovec/src/zerovec/slice.rs
index 847705304..52ddc184b 100644
--- a/vendor/zerovec/src/zerovec/slice.rs
+++ b/vendor/zerovec/src/zerovec/slice.rs
@@ -191,6 +191,27 @@ where
             .map(T::from_unaligned)
     }
 
+    /// Gets the entire slice as an array of length `N`. Returns None if the slice
+    /// does not have exactly `N` elements.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use zerovec::ZeroVec;
+    ///
+    /// let bytes: &[u8] = &[0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
+    /// let zerovec: ZeroVec<u16> =
+    ///     ZeroVec::parse_byte_slice(bytes).expect("infallible");
+    /// let array: [u16; 4] =
+    ///     zerovec.get_as_array().expect("should be 4 items in array");
+    ///
+    /// assert_eq!(array[2], 421);
+    /// ```
+    pub fn get_as_array<const N: usize>(&self) -> Option<[T; N]> {
+        let ule_array = <&[T::ULE; N]>::try_from(self.as_ule_slice()).ok()?;
+        Some(ule_array.map(|u| T::from_unaligned(u)))
+    }
+
     /// Gets a subslice of elements within a certain range. Returns None if the range
     /// is out of bounds of this `ZeroSlice`.
     ///
@@ -510,7 +531,7 @@ where
     }
 }
 
-impl<'a, T: AsULE + PartialOrd> PartialOrd for ZeroSlice<T> {
+impl<T: AsULE + PartialOrd> PartialOrd for ZeroSlice<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.iter().partial_cmp(other.iter())
     }
@@ -524,13 +545,13 @@ impl<T: AsULE + Ord> Ord for ZeroSlice<T> {
 
 impl<T: AsULE> AsRef<ZeroSlice<T>> for Vec<T::ULE> {
     fn as_ref(&self) -> &ZeroSlice<T> {
-        ZeroSlice::<T>::from_ule_slice(&**self)
+        ZeroSlice::<T>::from_ule_slice(self)
     }
 }
 
 impl<T: AsULE> AsRef<ZeroSlice<T>> for &[T::ULE] {
     fn as_ref(&self) -> &ZeroSlice<T> {
-        ZeroSlice::<T>::from_ule_slice(&**self)
+        ZeroSlice::<T>::from_ule_slice(self)
     }
 }