diff --git a/anneal/v2/Cargo.lock b/anneal/v2/Cargo.lock new file mode 100644 index 0000000000..6e0fd1450c --- /dev/null +++ b/anneal/v2/Cargo.lock @@ -0,0 +1,914 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" + +[[package]] +name = "block-buffer" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cargo-anneal" +version = "0.1.0-alpha.22" +dependencies = [ + "exocrate", + "toml_const", +] + +[[package]] +name = "cc" +version = "1.2.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crypto-common" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "block-buffer", + "const-oid", + "crypto-common", +] + +[[package]] +name = "dirs" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.61.2", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "exocrate" +version = "0.1.0" +dependencies = [ + "dirs", + "fs4", + "libc", + "log", + "sha2", + "sha2-const", + "tar", + "tempfile", + "toml_const", + "ureq", + "windows-sys 0.52.0", + "zstd", +] + +[[package]] +name = "fastrand" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" + +[[package]] +name = "filetime" +version = "0.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759" +dependencies = [ + "cfg-if", + "libc", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "fs4" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e72ed92b67c146290f88e9c89d60ca163ea417a446f61ffd7b72df3e7f1dfd5" +dependencies = [ + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "hybrid-array" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da" +dependencies = [ + "typenum", +] + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libredox" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c" +dependencies = [ + "libc", +] + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "phf" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7" +dependencies = [ + "phf_macros", + "phf_shared", + "serde", +] + +[[package]] +name = "phf_generator" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cbb1126afed61dd6368748dae63b1ee7dc480191c6262a3b4ff1e29d86a6c5b" +dependencies = [ + "fastrand", + "phf_shared", +] + +[[package]] +name = "phf_macros" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d713258393a82f091ead52047ca779d37e5766226d009de21696c4e667044368" +dependencies = [ + "phf_generator", + "phf_shared", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_shared" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981" +dependencies = [ + "siphasher", +] + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "redox_users" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" +dependencies = [ + "getrandom 0.2.17", + "libredox", + "thiserror", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b" +dependencies = [ + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_spanned" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +dependencies = [ + "serde", +] + +[[package]] +name = "sha2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sha2-const" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbb83f144cbda94be5d2278400eee9e0a03eb68b5504349943655b7b1603c4af" + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "simd-adler32" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + +[[package]] +name = "siphasher" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tar" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.3.4", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "toml" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", +] + +[[package]] +name = "toml_const" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a93119c23cd286a0e585f25bffcd1c292eaa6b90edfd8d58c442a3d2fe57c1" +dependencies = [ + "phf", + "toml", + "toml_const_macros", +] + +[[package]] +name = "toml_const_macros" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0ca608371311e568b6f918f3cf851640c6811625f39852c188b50ce11e2201b" +dependencies = [ + "indexmap", + "proc-macro2", + "quote", + "syn", + "toml", +] + +[[package]] +name = "toml_datetime" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.22.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_write", + "winnow", +] + +[[package]] +name = "toml_write" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" + +[[package]] +name = "typenum" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "ureq" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dea7109cdcd5864d4eeb1b58a1648dc9bf520360d7af16ec26d0a9354bafcfc0" +dependencies = [ + "base64", + "flate2", + "log", + "percent-encoding", + "rustls", + "rustls-pki-types", + "ureq-proto", + "utf8-zero", + "webpki-roots", +] + +[[package]] +name = "ureq-proto" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e994ba84b0bd1b1b0cf92878b7ef898a5c1760108fe7b6010327e274917a808c" +dependencies = [ + "base64", + "http", + "httparse", + "log", +] + +[[package]] +name = "utf8-zero" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.3+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "xattr" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156" +dependencies = [ + "libc", + "rustix", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/anneal/v2/Cargo.toml b/anneal/v2/Cargo.toml new file mode 100644 index 0000000000..59580554de --- /dev/null +++ b/anneal/v2/Cargo.toml @@ -0,0 +1,42 @@ +[workspace] +members = [".", "exocrate"] + +[package] +name = "cargo-anneal" +edition = "2024" +version = "0.1.0-alpha.22" +description = "Formally verify that your safety comments are correct." +categories = [ + "development-tools::cargo-plugins", + "development-tools::testing", + "compilers", + "mathematics", + "security", +] +keywords = ["verification", "cargo", "plugin", "unsafe", "lean"] +authors = ["Joshua Liebow-Feeser "] +license = "BSD-2-Clause OR Apache-2.0 OR MIT" +repository = "https://github.com/google/zerocopy/tree/main/anneal" +publish = true + +exclude = [".*", "testdata"] + +[package.metadata.exocrate.linux.x86_64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/linux-x86_64.tar.zst" + +[package.metadata.exocrate.macos.x86_64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/macos-x86_64.tar.zst" + +[package.metadata.exocrate.linux.aarch64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/linux-aarch64.tar.zst" + +[package.metadata.exocrate.macos.aarch64] +sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +url = "https://example.com/macos-aarch64.tar.zst" + +[dependencies] +exocrate = { path = "./exocrate" } +toml_const = "1.2.1" diff --git a/anneal/v2/diagram1.jpeg b/anneal/v2/diagram1.jpeg new file mode 100644 index 0000000000..74de136d1d Binary files /dev/null and b/anneal/v2/diagram1.jpeg differ diff --git a/anneal/v2/diagram2.png b/anneal/v2/diagram2.png new file mode 100644 index 0000000000..feca0e9bd4 Binary files /dev/null and b/anneal/v2/diagram2.png differ diff --git a/anneal/v2/exocrate/Cargo.toml b/anneal/v2/exocrate/Cargo.toml new file mode 100644 index 0000000000..e7fcf0cc68 --- /dev/null +++ b/anneal/v2/exocrate/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "exocrate" +version = "0.1.0" +edition = "2024" + +[dependencies] +dirs = "6.0.0" +fs4 = "1.1.0" +log = "0.4.29" +sha2 = "0.11.0" +sha2-const = "0.1.3" +tar = "0.4.45" +tempfile = "3.27.0" +toml_const = "1.2.1" +ureq = "3.3.0" +zstd = "0.13.3" + +[target.'cfg(unix)'.dev-dependencies] +libc = "0.2" + +[target.'cfg(windows)'.dev-dependencies] +windows-sys = { version = "0.52", features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_IO"] } diff --git a/anneal/v2/exocrate/src/lib.rs b/anneal/v2/exocrate/src/lib.rs new file mode 100644 index 0000000000..19f116dfef --- /dev/null +++ b/anneal/v2/exocrate/src/lib.rs @@ -0,0 +1,653 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +//! Exocrate: An exoskeleton for your crate. +//! +//! Exocrate is a manager for crate dependencies which are not managed by Cargo +//! itself. This might include external toolchains, large binary files, etc. + +mod sync; + +use std::{ + io::{Read, Result as IoResult}, + path::{Path, PathBuf}, +}; + +use sha2::Digest as _; +use sync::ManagedDirName; + +pub struct RemoteArchive { + pub url: &'static str, + /// The SHA-256 hash of the file at `url`. + pub sha256: [u8; 32], +} + +pub struct Config { + /// The relative path of the directory containing dependencies, stored as a + /// sequence of path components for cross-platform compatibility. + /// + /// Dependencies are stored in ``. In production use, this is + /// relative to `~`. In development, this is relative to Cargo's `target` + /// directory if it can be resolved, and otherwise relative to the current + /// working directory. + // + // FIXME: Make this non-`pub` and validate at construction that each item + // is valid for the OS. + pub rel_dir_path: &'static [&'static str], + /// A unique identifier for this version of the dependencies. + pub version_slug: &'static str, +} + +/// The location to install dependencies. +pub enum Location { + /// A location in the user's home directory. + UserGlobal, + /// A location in the Cargo `target` directory if it can be resolved, and + /// otherwise in the current working directory. + Local, +} + +/// The source from which to install dependencies +pub enum Source { + /// Download the dependencies from the internet. + Remote(RemoteArchive), + /// Use a locally available archive. + Local(PathBuf), +} + +impl Config { + /// Resolves the dependency directory, failing if it doesn't exist. + pub fn resolve_installation_dir(&self, location: Location) -> IoResult { + let dir_path = self.dir_path(location); + let _ = ManagedDirName::new(&dir_path).check_exists()?; + Ok(dir_path) + } + + /// Resolves the dependency directory, installing it if needed. + pub fn resolve_installation_dir_or_install( + &self, + location: Location, + source: Source, + ) -> IoResult { + let dir_path = self.dir_path(location); + if ManagedDirName::new(&dir_path).check_exists().is_ok() { + return Ok(dir_path); + } + let (reader, expected_sha) = self.open_source(source)?; + install(reader, &dir_path, expected_sha)?; + Ok(dir_path) + } + + /// Opens the given source. + /// + /// For `Source::Download`, returns the SHA-256 hash which should be used to + /// validate the downloaded contents. + fn open_source(&self, source: Source) -> IoResult<(impl Read, Option<[u8; 32]>)> { + enum SourceReader { + Download(D), + Local(L), + } + + impl Read for SourceReader { + fn read(&mut self, buf: &mut [u8]) -> IoResult { + match self { + Self::Download(r) => r.read(buf), + Self::Local(r) => r.read(buf), + } + } + } + + match source { + Source::Remote(RemoteArchive { url, sha256 }) => { + let resp = ureq::get(url) + .call() + .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?; + let reader = resp.into_body().into_reader(); + Ok((SourceReader::Download(reader), Some(sha256))) + } + Source::Local(path) => { + let file = std::fs::File::open(path)?; + Ok((SourceReader::Local(file), None)) + } + } + } + + /// Calculates the directory path: + /// - The parent is `~` for `UserGlobal` and `CARGO_MANIFEST_DIR/target` for + /// `Local` (or `./target` if `CARGO_MANIFEST_DIR` is not set). + /// - The remainder is `{self.rel_dir_path}/{self.version_slug}`. + fn dir_path(&self, location: Location) -> PathBuf { + let mut parts = match location { + Location::UserGlobal => dirs::home_dir().expect("home dir not found"), + Location::Local => { + std::env::var("CARGO_MANIFEST_DIR") + .map(PathBuf::from) + // Fall back to current directory if `CARGO_MANIFEST_DIR` is + // not set, which can happen if the binary is executed + // directly rather than via `cargo run`. + .unwrap_or_else(|_| std::env::current_dir().unwrap()) + .join("target") + } + }; + + parts.extend(self.rel_dir_path); + parts.join(self.version_slug) + } +} + +/// Extracts the `.tar.zst` from `reader` and installs it at `dst`, optionally +/// validating its hash. +fn install(mut reader: impl Read, dst: &Path, expected_sha256: Option<[u8; 32]>) -> IoResult<()> { + struct HashingReader { + reader: R, + hasher: sha2::Sha256, + } + + impl std::io::Read for HashingReader { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + let n = self.reader.read(buf)?; + sha2::Digest::update(&mut self.hasher, &buf[..n]); + Ok(n) + } + } + + sync::ManagedDirName::new(dst) + .check_exists_or_create(|target_dir| { + if let Some(expected) = expected_sha256 { + let mut hash_reader = HashingReader { reader, hasher: sha2::Sha256::new() }; + { + let decoder = zstd::stream::read::Decoder::new(&mut hash_reader)?; + let mut archive = tar::Archive::new(decoder); + archive.unpack(target_dir)?; + } + + // Ensure any remaining trailing bytes in the stream are read + // and hashed. Zstd may skip trailing data which isn't necessary + // to decompress, but we need to account for it in the hash, or + // else a valid archive could fail to hash properly if that + // archive contains trailing data which isn't required for + // decompression. + std::io::copy(&mut hash_reader, &mut std::io::sink())?; + + let hash: [u8; 32] = sha2::Digest::finalize(hash_reader.hasher).into(); + if hash != expected { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "SHA-256 hash mismatch", + )); + } + } else { + let decoder = zstd::stream::read::Decoder::new(&mut reader)?; + let mut archive = tar::Archive::new(decoder); + archive.unpack(target_dir)?; + } + Ok(()) + }) + .map(|_| ()) +} + +/// Parses a [`RemoteArchive`] from the `Cargo.toml` at `$cargo_toml_path`. +/// +/// The `Cargo.toml` is expected to have content of the form: +/// +/// ```toml +/// [package.metadata.exocrate.linux.x86_64] +/// sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +/// url = "https://example.com/linux-x86_64.tar.zst" +/// +/// [package.metadata.exocrate.macos.x86_64] +/// sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +/// url = "https://example.com/macos-x86_64.tar.zst" +/// +/// [package.metadata.exocrate.linux.aarch64] +/// sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +/// url = "https://example.com/linux-aarch64.tar.zst" +/// +/// [package.metadata.exocrate.macos.aarch64] +/// sha256 = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" +/// url = "https://example.com/macos-aarch64.tar.zst" +/// ``` +/// +/// The `parse_remote_archive!` invocation must specify the set of OS/Arch +/// pairs, e.g.: +/// +/// ```rust,ignore +/// parse_remote_archive! { +/// const REMOTE: RemoteArchive = "Cargo.toml" [ +/// (linux, x86_64), +/// (linux, aarch64), +/// (macos, aarch64), +/// (macos, x86_64), +/// ]; +/// } +/// ``` +/// +/// **NOTE**: The calling crate must have its own dependency on the `toml_const` +/// crate. +// FIXME: +// - Lift this limitation. +// - Don't require the user to specify os/arch pairs in the macro invocation. +#[macro_export] +macro_rules! parse_remote_archive { + ($vis:vis const $name:ident: RemoteArchive = $cargo_toml_path:literal [ + $(($os:ident, $arch:ident)),* $(,)? + ];) => { + $vis const $name: $crate::RemoteArchive = { + ::toml_const::toml_const!{ + const MANIFEST: $cargo_toml_path; + } + + let config = { + use std::env::consts::*; + use $crate::macro_util::pack; + + // NOTE: Rust doesn't support checking `&str`s for equality in a + // `const` context. We work around that limitation by packing + // their bytes into `u128`s, which can be compared. + // + // FIXME: How can we detect if os/arch pairs have been added to + // `Cargo.toml` without being added to the macro invocation? + match (pack(OS), pack(ARCH)) { + $( + (os, arch) if os == pack(stringify!($os)) && arch == pack(stringify!($arch)) => { + MANIFEST.package.metadata.exocrate.$os.$arch + } + )* + _ => panic!("unsupported platform"), + } + }; + + let Some(sha256) = $crate::macro_util::decode_hex(config.sha256) else { + panic!("invalid sha256") + }; + $crate::RemoteArchive { + sha256, + url: config.url, + } + }; + } +} + +// TODO: Better name that connotes that we're hashing everything? +#[macro_export] +macro_rules! config { + ($vis:vis const $name:ident: Config = Config { rel_dir_path: $rel_dir_path:expr };) => { + $vis const $name: $crate::Config = { + $crate::Config { + rel_dir_path: &$rel_dir_path, + version_slug: { + const HEX: [u8; 64] = { + // FIXME: Pick a reasonably-collision-resistant hash + // function that is cheaper to evaluate at const time. + #[allow(long_running_const_eval)] + let hash = $crate::macro_util::Sha256::new() + .update(include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/Cargo.toml"))) + .update(include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/Cargo.lock"))) + .update(std::env::consts::OS.as_bytes()) + .update(std::env::consts::ARCH.as_bytes()) + .finalize(); + $crate::macro_util::encode_hex::<{ 32 }, { 64 }>(&hash) + }; + + let Ok(s) = str::from_utf8(&HEX) else { + unreachable!() + }; + s + } + } + }; + }; +} + +#[doc(hidden)] +pub mod macro_util { + pub use sha2_const::Sha256; + + /// Packs the bytes of `s` into a `u128`. + /// + /// # Panics + /// + /// Panics if `s.as_bytes().len() > 16`. + pub const fn pack(s: &str) -> u128 { + let b = s.as_bytes(); + assert!(b.len() <= 16, "slice too large to pack into u128"); + + let mut res = 0u128; + let mut i = 0; + while i < b.len() { + res |= (b[i] as u128) << (i * 8); + i += 1; + } + res + } + + /// Decodes a hexadecimal string into its byte representation. + pub const fn decode_hex(s: &str) -> Option<[u8; 32]> { + let bytes = s.as_bytes(); + if bytes.len() != 64 { + return None; + } + let mut res = [0u8; 32]; + let mut i = 0; + while i < 32 { + let (h, l) = (bytes[i * 2], bytes[i * 2 + 1]); + let h_nib = match decode_nibble(h) { + Some(n) => n, + None => return None, + }; + let l_nib = match decode_nibble(l) { + Some(n) => n, + None => return None, + }; + res[i] = (h_nib << 4) | l_nib; + i += 1; + } + Some(res) + } + + const fn decode_nibble(c: u8) -> Option { + match c { + b'0'..=b'9' => Some(c - b'0'), + b'a'..=b'f' => Some(c - b'a' + 10), + b'A'..=b'F' => Some(c - b'A' + 10), + _ => None, + } + } + + pub const fn encode_hex(bytes: &[u8; N]) -> [u8; M] { + assert!(M == N * 2, "Output buffer must be exactly twice the input length"); + + let mut res = [0u8; M]; + const HEX_TABLE: &[u8; 16] = b"0123456789abcdef"; + + let mut i = 0; + while i < N { + res[i * 2] = HEX_TABLE[(bytes[i] >> 4) as usize]; + res[i * 2 + 1] = HEX_TABLE[(bytes[i] & 0x0f) as usize]; + i += 1; + } + res + } +} + +#[cfg(test)] +mod tests { + use std::fs; + + use super::*; + + fn create_dummy_tar_zst(files: &[(&str, &[u8])]) -> Vec { + let mut zstd_enc = zstd::stream::write::Encoder::new(Vec::new(), 0).unwrap(); + { + let mut tar_builder = tar::Builder::new(&mut zstd_enc); + for (name, content) in files { + let mut header = tar::Header::new_gnu(); + header.set_size(content.len() as u64); + header.set_mode(0o644); + header.set_cksum(); + tar_builder.append_data(&mut header, name, *content).unwrap(); + } + tar_builder.finish().unwrap(); + } + zstd_enc.finish().unwrap() + } + + fn compute_sha256(data: &[u8]) -> [u8; 32] { + let mut hasher = sha2::Sha256::new(); + hasher.update(data); + hasher.finalize().into() + } + + fn dummy_config(rel_dir_path: &'static [&'static str]) -> Config { + Config { rel_dir_path, version_slug: "slug" } + } + + #[allow(dead_code)] + fn dummy_remote() -> RemoteArchive { + RemoteArchive { + url: "https://example.com/dummy.tar.zst", + sha256: compute_sha256(b"dummy content"), + } + } + + #[test] + fn test_install_new() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[ + ("hello.txt", b"hello world"), + ("nested/dir/data.bin", b"\x01\x02\x03"), + ]); + let expected_hash = compute_sha256(&tar_zst); + + install(tar_zst.as_slice(), &dst, Some(expected_hash)).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("hello.txt")).unwrap(), "hello world"); + assert_eq!(fs::read(dst.join("nested/dir/data.bin")).unwrap(), b"\x01\x02\x03"); + } + + #[test] + fn test_install_without_hash_validation() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[("hello.txt", b"hello world")]); + + install(tar_zst.as_slice(), &dst, None).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("hello.txt")).unwrap(), "hello world"); + } + + #[test] + fn test_install_invalid_archive() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + + let invalid_data = b"definitely not a valid zstd or tar"; + + let result = install(&invalid_data[..], &dst, None); + assert!(result.is_err()); + + assert!(!dst.exists()); + let entries: Vec<_> = fs::read_dir(temp.path()) + .unwrap() + .map(|e| e.unwrap().file_name()) + .filter(|n| n != "install_target.lock") + .collect(); + assert!(entries.is_empty()); + } + + #[test] + fn test_install_already_exists() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + fs::create_dir_all(&dst).unwrap(); + fs::write(dst.join("existing.txt"), "existing content").unwrap(); + + // Since dst already exists as a managed directory, install returns early + // without reading the invalid archive or validating the hash. + let bad_data = b"invalid archive data"; + let bad_hash = [0u8; 32]; + install(&bad_data[..], &dst, Some(bad_hash)).unwrap(); + + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("existing.txt")).unwrap(), "existing content"); + } + + #[test] + fn test_install_hash_mismatch() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let tar_zst = create_dummy_tar_zst(&[("hello.txt", b"hello world")]); + + let bad_hash = [0u8; 32]; + + let result = install(tar_zst.as_slice(), &dst, Some(bad_hash)); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::InvalidData); + + assert!(!dst.exists()); + let entries: Vec<_> = fs::read_dir(temp.path()) + .unwrap() + .map(|e| e.unwrap().file_name()) + .filter(|n| n != "install_target.lock") + .collect(); + assert!(entries.is_empty()); + } + + #[test] + fn test_install_trailing_garbage_hash_mismatch() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let valid_tar_zst = create_dummy_tar_zst(&[("hello.txt", b"hello world")]); + let expected_hash = compute_sha256(&valid_tar_zst); + + // Append trailing garbage to the archive + let mut corrupted_archive = valid_tar_zst.clone(); + corrupted_archive.extend_from_slice(b"trailing garbage data"); + + // Even though the archive unpacks successfully, the trailing bytes should be + // read and hashed, causing a hash mismatch. + let result = install(corrupted_archive.as_slice(), &dst, Some(expected_hash)); + assert!(result.is_err()); + assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::InvalidData); + } + + #[test] + fn test_macro_util_encode_hex() { + let res1 = macro_util::encode_hex::<0, 0>(b""); + assert_eq!(std::str::from_utf8(&res1).unwrap(), ""); + + let res2 = macro_util::encode_hex::<6, 12>(b"\x00\x01\x0a\x0f\x10\xff"); + assert_eq!(std::str::from_utf8(&res2).unwrap(), "00010a0f10ff"); + } + + #[test] + fn test_macro_util_pack() { + assert_eq!(macro_util::pack("a"), 0x61); + assert_eq!(macro_util::pack("ab"), 0x6261); + assert_eq!(macro_util::pack("linux"), 0x78756e696c); + } + + #[test] + #[should_panic(expected = "slice too large to pack into u128")] + fn test_macro_util_pack_too_large() { + let _ = macro_util::pack("this_identifier_is_way_too_long"); + } + + #[test] + fn test_macro_util_decode_hex() { + let valid_hex = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"; + let decoded = macro_util::decode_hex(valid_hex).unwrap(); + assert_eq!(decoded.len(), 32); + assert_eq!(decoded[0], 0xba); + assert_eq!(decoded[1], 0x78); + assert_eq!(decoded[31], 0xad); + + assert!(macro_util::decode_hex("ba78").is_none()); + let invalid_hex = "ga7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"; + assert!(macro_util::decode_hex(invalid_hex).is_none()); + } + + #[test] + fn test_config_dir_path() { + let config = dummy_config(&["test_dir_path"]); + let prod_path = config.dir_path(Location::UserGlobal); + assert!(prod_path.starts_with(dirs::home_dir().unwrap())); + assert!(prod_path.ends_with(PathBuf::from_iter(["test_dir_path", "slug"]))); + + let dev_path = config.dir_path(Location::Local); + assert!( + dev_path.starts_with( + std::env::var("CARGO_MANIFEST_DIR") + .map(PathBuf::from) + .unwrap_or_else(|_| std::env::current_dir().unwrap()) + .join("target") + ) + ); + assert!(dev_path.ends_with(PathBuf::from_iter(["test_dir_path", "slug"]))); + } + + #[test] + fn test_config_resolve_installation_dir() { + let config = dummy_config(&["test_dir_resolve"]); + assert!(config.resolve_installation_dir(Location::Local).is_err()); + + let dev_path = config.dir_path(Location::Local); + fs::create_dir_all(&dev_path).unwrap(); + + let resolved = config.resolve_installation_dir(Location::Local).unwrap(); + assert_eq!(resolved, dev_path); + + fs::remove_dir_all(&dev_path).unwrap(); + } + + #[test] + fn test_config_resolve_installation_dir_or_install_local() { + let temp = tempfile::tempdir().unwrap(); + let archive_path = temp.path().join("archive.tar.zst"); + let dummy_tar = create_dummy_tar_zst(&[("bin/compiler", b"binary data")]); + fs::write(&archive_path, &dummy_tar).unwrap(); + + let config = Config { rel_dir_path: &["test_dir_install"], version_slug: "slug" }; + + let dev_path = config.dir_path(Location::Local); + let _ = fs::remove_dir_all(&dev_path); + + let resolved = config + .resolve_installation_dir_or_install(Location::Local, Source::Local(archive_path)) + .unwrap(); + assert_eq!(resolved, dev_path); + assert!(dev_path.join("bin/compiler").exists()); + + let resolved2 = config + .resolve_installation_dir_or_install( + Location::Local, + Source::Local(PathBuf::from("/nonexistent/path/should/not/be/accessed")), + ) + .unwrap(); + assert_eq!(resolved2, dev_path); + + fs::remove_dir_all(&dev_path).unwrap(); + } + + #[test] + fn test_config_open_source_not_found() { + let config = dummy_config(&["test_open_source"]); + let res = + config.open_source(Source::Local(PathBuf::from("/nonexistent/path/file.missing"))); + assert!(res.is_err()); + } + + #[test] + fn test_config_macro() { + config! { + const CONFIG: Config = Config { rel_dir_path: ["test", "project"] }; + } + + assert_eq!(CONFIG.rel_dir_path, &["test", "project"]); + assert_eq!(CONFIG.version_slug.len(), 64); + } + + #[test] + fn test_parse_remote_archive_macro() { + parse_remote_archive! { + const REMOTE: RemoteArchive = "../Cargo.toml" [ + (linux, x86_64), + (linux, aarch64), + (macos, x86_64), + (macos, aarch64), + ]; + } + + assert!(REMOTE.url.starts_with("https://example.com/")); + assert_eq!(REMOTE.sha256.len(), 32); + } +} diff --git a/anneal/v2/exocrate/src/sync.rs b/anneal/v2/exocrate/src/sync.rs new file mode 100644 index 0000000000..c1b3233066 --- /dev/null +++ b/anneal/v2/exocrate/src/sync.rs @@ -0,0 +1,428 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +use std::{ + fs::{self, File, OpenOptions}, + io::Result as IoResult, + path::{Path, PathBuf}, +}; + +/// A directory managed by this library. +/// +/// A `ManagedDir` has the following properties: +/// - The directory itself is guaranteed to be atomic. That is, if a directory +/// at the path exists, then it has already been fully populated. This means +/// that no locking is required to check whether the directory exists. +/// - Populating and installing the directory requires a lock. In other words, +/// writers are required to actively synchronize with one another. This +/// simplifies the writer implementation by avoiding the necessity for +/// complex wait-free synchronization logic. +/// - The name of the lock file shares the same prefix with the name of the +/// guarded directory. As long as two directories have different names, their +/// lock files can never conflict. +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub(crate) struct ManagedDir<'a> { + path: &'a Path, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub(crate) struct ManagedDirName<'a> { + // INVARIANT: `path.file_name().is_some()`. + path: &'a Path, +} + +impl<'a> ManagedDirName<'a> { + pub(crate) fn new(path: &'a Path) -> Self { + assert!(path.file_name().is_some(), "ManagedDirName path must have a filename"); + Self { path } + } + + /// Checks if the directory exists. + pub(crate) fn check_exists(self) -> IoResult> { + if self.path.is_dir() { + Ok(ManagedDir { path: self.path }) + } else if self.path.try_exists()? { + Err(std::io::Error::new( + std::io::ErrorKind::AlreadyExists, + "Path exists but is not a directory", + )) + } else { + Err(std::io::Error::new( + std::io::ErrorKind::NotFound, + "Managed directory does not exist", + )) + } + } + + /// Checks if the directory exists, creating it if not. + /// + /// # Concurrency + /// + /// `check_exists_or_create` is **not** concurrency-safe if multiple + /// concurrent calls are made *from the same process*. + pub(crate) fn check_exists_or_create( + self, + populate: impl FnOnce(&Path) -> IoResult<()>, + ) -> IoResult> { + if let Ok(dir) = self.check_exists() { + return Ok(dir); + } + + if let Some(parent) = self.path.parent() { + // NOTE: `create_dir_all` is safe to call concurrently with other + // processes attempting to create the same directory: + // + // Notable exception [to the error conditions] is made for + // situations where any of the directories specified in the path + // could not be created as it was being created concurrently. Such + // cases are considered to be successful. That is, calling + // create_dir_all concurrently from multiple threads or processes + // is guaranteed not to fail due to a race condition with itself. + fs::create_dir_all(parent)?; + } + + let lock_file_path = self.lock_path(); + let lock_file = + OpenOptions::new().read(true).write(true).create(true).open(&lock_file_path)?; + + <_ as fs4::FileExt>::lock(&lock_file)?; + + let staging_dir = self.staging(); + + struct StagingGuard<'a> { + staging_dir: &'a Path, + lock_file: File, + completed: bool, + } + + impl Drop for StagingGuard<'_> { + fn drop(&mut self) { + if !self.completed { + let _ = fs::remove_dir_all(&self.staging_dir); + } + let _ = <_ as fs4::FileExt>::unlock(&self.lock_file); + } + } + + // A guard that will clean up even if `populate` panics. + let mut guard = StagingGuard { staging_dir: &staging_dir, lock_file, completed: false }; + + // Handle the case where, while we were waiting to acquire the lock, + // another process populated the directory. + if let Ok(dir) = self.check_exists() { + guard.completed = true; + return Ok(dir); + } + + // Clean up from any previous failed attempt to populate the directory. + let _ = fs::remove_dir_all(&guard.staging_dir); + fs::create_dir_all(&guard.staging_dir)?; + + populate(&guard.staging_dir)?; + + fs::rename(&guard.staging_dir, self.path).map_err(|e| { + std::io::Error::new( + e.kind(), + format!( + "Failed to rename staging directory to target path (this indicates a {}): {}", + if cfg!(windows) { + "manual modification, concurrency bug, or open file handle" + } else { + "manual modification or concurrency bug" + }, + e + ), + ) + })?; + + guard.completed = true; + Ok(ManagedDir { path: self.path }) + } + + fn staging(&self) -> PathBuf { + let mut file_name = + self.path.file_name().expect("ManagedDirName path must have a filename").to_os_string(); + file_name.push(".staging"); + self.path.with_file_name(file_name) + } + + // NOTE: It's important that `lock_path` returns a lock path whose name + // has the directory name as a prefix. See the comment on `ManagedDir`. + fn lock_path(&self) -> PathBuf { + let mut file_name = + self.path.file_name().expect("ManagedDirName path must have a filename").to_os_string(); + file_name.push(".lock"); + self.path.with_file_name(file_name) + } +} + +#[cfg(test)] +mod tests { + use std::{fs, path::Path}; + + use super::*; + + #[test] + fn test_check_exists_or_create_success() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let managed = ManagedDirName::new(&dst); + + let dir = managed + .check_exists_or_create(|staging| { + fs::write(staging.join("data.txt"), "success content").unwrap(); + Ok(()) + }) + .unwrap(); + + assert_eq!(dir.path, dst.as_path()); + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("data.txt")).unwrap(), "success content"); + } + + #[test] + fn test_check_exists_or_create_already_exists() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let managed = ManagedDirName::new(&dst); + + managed + .check_exists_or_create(|staging| { + fs::write(staging.join("v1.txt"), "v1").unwrap(); + Ok(()) + }) + .unwrap(); + + let dir = managed + .check_exists_or_create(|_| { + panic!("should not be called on already existing directory"); + }) + .unwrap(); + + assert_eq!(dir.path, dst.as_path()); + assert!(dst.is_dir()); + assert_eq!(fs::read_to_string(dst.join("v1.txt")).unwrap(), "v1"); + assert!(!dst.join("v2.txt").exists()); + } + + #[test] + fn test_check_exists_or_create_failure_cleanup() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let managed = ManagedDirName::new(&dst); + + let res = managed.check_exists_or_create(|staging| { + fs::write(staging.join("partial.txt"), "partial").unwrap(); + Err(std::io::Error::new(std::io::ErrorKind::Other, "simulated error")) + }); + assert!(res.is_err()); + + assert!(!dst.exists()); + let entries: Vec<_> = fs::read_dir(temp.path()) + .unwrap() + .map(|e| e.unwrap().file_name()) + .filter(|n| n != "install_target.lock") + .collect(); + assert!(entries.is_empty()); + } + + #[test] + fn test_check_exists_file_not_dir() { + let temp = tempfile::tempdir().unwrap(); + let file_path = temp.path().join("not_a_dir"); + fs::write(&file_path, "some data").unwrap(); + + let managed = ManagedDirName::new(&file_path); + let res = managed.check_exists(); + assert!(res.is_err()); + } + + #[test] + fn test_check_exists_or_create_panic_cleanup() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let managed = ManagedDirName::new(&dst); + + let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _ = managed.check_exists_or_create(|staging| { + fs::write(staging.join("partial.txt"), "partial").unwrap(); + panic!("simulated panic"); + }); + })); + assert!(res.is_err()); + + assert!(!dst.exists()); + let entries: Vec<_> = fs::read_dir(temp.path()) + .unwrap() + .map(|e| e.unwrap().file_name()) + .filter(|n| n != "install_target.lock") + .collect(); + assert!(entries.is_empty()); + } + + #[test] + fn test_check_exists_or_create_rename_failure() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("install_target"); + let managed = ManagedDirName::new(&dst); + + let res = managed.check_exists_or_create(|staging| { + fs::write(staging.join("staged.txt"), "staged").unwrap(); + // Simulate conflicting file at destination + fs::write(&dst, "conflicting file").unwrap(); + Ok(()) + }); + assert!(res.is_err()); + + let entries: Vec<_> = fs::read_dir(temp.path()) + .unwrap() + .map(|e| e.unwrap().file_name()) + .filter(|n| n != "install_target.lock" && n != "install_target") + .collect(); + assert!(entries.is_empty()); + } + + #[test] + #[should_panic(expected = "ManagedDirName path must have a filename")] + fn test_no_filename() { + let dst = Path::new(""); + let managed = ManagedDirName::new(dst); + let _ = managed.check_exists_or_create(|_| Ok(())); + } + + #[test] + #[should_panic(expected = "ManagedDirName path must have a filename")] + fn test_invalid_filename_root() { + let dst = Path::new("/"); + let managed = ManagedDirName::new(dst); + let _ = managed.check_exists_or_create(|_| Ok(())); + } + + #[test] + #[should_panic(expected = "ManagedDirName path must have a filename")] + fn test_invalid_filename_dot() { + let dst = Path::new("."); + let managed = ManagedDirName::new(dst); + let _ = managed.check_exists_or_create(|_| Ok(())); + } + + #[test] + #[should_panic(expected = "ManagedDirName path must have a filename")] + fn test_invalid_filename_dotdot() { + let dst = Path::new(".."); + let managed = ManagedDirName::new(dst); + let _ = managed.check_exists_or_create(|_| Ok(())); + } + + #[test] + fn test_managed_dir() { + let temp = tempfile::tempdir().unwrap(); + let target = temp.path().join("managed"); + let managed_name = ManagedDirName::new(&target); + + assert!(managed_name.check_exists().is_err()); + + let dir = managed_name + .check_exists_or_create(|staging| { + fs::write(staging.join("test.txt"), "hello").unwrap(); + Ok(()) + }) + .unwrap(); + + assert_eq!(dir.path, target.as_path()); + assert!(target.join("test.txt").exists()); + + // Second call should return early via check_exists + let dir2 = managed_name + .check_exists_or_create(|_| { + panic!("should not be called"); + }) + .unwrap(); + + assert_eq!(dir2.path, target.as_path()); + } + + // This test exists to verify that the *implementation* of the lockfile + // is stable across versions of this library. If this test fails, it may + // indicate a breaking change that would cause two different versions of + // this code to be incompatible when used to synchronize the same target + // directory. + #[test] + fn test_lockfile_semantics() { + let temp = tempfile::tempdir().unwrap(); + let dst = temp.path().join("my_target_dir"); + let managed = ManagedDirName::new(&dst); + + let expected_lock = temp.path().join("my_target_dir.lock"); + + let is_locked = |path: &Path| { + #[cfg(unix)] + { + use std::os::fd::AsRawFd; + let file = OpenOptions::new().read(true).write(true).open(path).unwrap(); + let fd = file.as_raw_fd(); + let res = unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) }; + if res == 0 { + unsafe { libc::flock(fd, libc::LOCK_UN) }; + false + } else { + true + } + } + + #[cfg(windows)] + { + use std::os::windows::io::AsRawHandle; + + use windows_sys::Win32::Storage::FileSystem::{LockFile, UnlockFile}; + let file = OpenOptions::new().read(true).write(true).open(path).unwrap(); + let handle = file.as_raw_handle() as isize; + let res = unsafe { LockFile(handle, 0, 0, 1, 0) }; + if res != 0 { + unsafe { UnlockFile(handle, 0, 0, 1, 0) }; + false + } else { + true + } + } + }; + + assert!(!expected_lock.exists(), "Lockfile must not exist to start"); + let _ = managed + .check_exists_or_create(|staging| { + assert!(expected_lock.exists(), "Lockfile must exist at expected path"); + assert!(expected_lock.is_file(), "Lockfile must be a regular file"); + assert!(is_locked(&expected_lock), "Lockfile must be in the 'locked' state"); + fs::write(staging.join("data.txt"), "content").unwrap(); + Ok(()) + }) + .unwrap(); + assert!( + expected_lock.exists(), + "Lockfile permanently remains on disk to prevent inode replacement race conditions" + ); + assert!(!is_locked(&expected_lock), "Lockfile must be in the 'unlocked' state"); + + fs::remove_dir_all(&dst).unwrap(); + assert!(expected_lock.exists(), "Lockfile permanently remains on disk"); + assert!(!is_locked(&expected_lock), "Lockfile must be in the 'unlocked' state"); + + let _ = managed + .check_exists_or_create(|staging| { + assert!(expected_lock.exists(), "Lockfile must exist at expected path"); + assert!(expected_lock.is_file(), "Lockfile must be a regular file"); + assert!(is_locked(&expected_lock), "Lockfile must be in the 'locked' state"); + fs::write(staging.join("recreated.txt"), "recreated").unwrap(); + Ok(()) + }) + .unwrap(); + assert!(expected_lock.exists(), "Lockfile permanently remains on disk"); + assert!(!is_locked(&expected_lock), "Lockfile must be in the 'unlocked' state"); + } +} diff --git a/anneal/v2/src/main.rs b/anneal/v2/src/main.rs new file mode 100644 index 0000000000..eaa6c72ea7 --- /dev/null +++ b/anneal/v2/src/main.rs @@ -0,0 +1,23 @@ +// Copyright 2026 The Fuchsia Authors +// +// Licensed under the 2-Clause BSD License , Apache License, Version 2.0 +// , or the MIT +// license , at your option. +// This file may not be copied, modified, or distributed except according to +// those terms. + +exocrate::config! { + const CONFIG: Config = Config { rel_dir_path: [".anneal", "toolchain"] }; +} + +exocrate::parse_remote_archive! { + const REMOTE: RemoteArchive = "Cargo.toml" [ + (linux, x86_64), + (macos, x86_64), + (linux, aarch64), + (macos, aarch64), + ]; +} + +fn main() {} diff --git a/anneal/vendor/ascii/.cargo-checksum.json b/anneal/vendor/ascii/.cargo-checksum.json deleted file mode 100644 index f60d070600..0000000000 --- a/anneal/vendor/ascii/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"7dc279d6cc614afd157d09eaf63f0249a590d99bd3659976740a48e19b51c783",".github/workflows/ci.yml":"26ca0180639f06c994852c2e6f6c10edbee283d9aa173de9d1a0fde1c50f0d96","Cargo.toml":"466554aebd51e2ff3da0e3b2160c9c77785701812d65f2bbeda5d2d0b3fc0c9e","Cargo.toml.orig":"5199ce15775aa1d2a706f6d2d3a45339fa6ce79fa50b263949cdd023392a3650","LICENSE-APACHE":"fabba0cb7d00a4b3211fdc13699223ab2d22f88678ccd608494cf2b332b903e9","LICENSE-MIT":"7e4b8a17b118d3d7fd7a362a4b6563e0bd98b098a24c4c7f07dd22042091a847","README.md":"c229f6bd9fb52731479c5e1d321b53ef7eb9bb33105b0052870620107add1425","RELEASES.md":"81ec9d5ed1268c499e5a7e4d9d7bbf7469f2e3ddeede45ad62ed5128f700f818","src/ascii_char.rs":"8c4bdedd3bc07387baddbea23cff6a5abd469884f2fe274c6f6a03c00110b549","src/ascii_str.rs":"464c156b2a9f8183e8f472df6b6b34ea8406c19cab85112475669585a607efff","src/ascii_string.rs":"0cc46f26623721221c0635f17951cd2c40ae1aed4a2e08c333802117ebd94640","src/free_functions.rs":"efebe83e30b05d2394f5f491254e868f8b2837029c39159756eda599199c27b8","src/lib.rs":"3f0640d3cb0fd274c7ddd60efc7ab09e633b7ce726ef366fcf468b784be451dc","src/serialization/ascii_char.rs":"09328995f6691f55be8be016e886cfb390eabe0a002057a41f2e6e029ca5588a","src/serialization/ascii_str.rs":"2dea9ba3d101fa42c09645c2889dc02f16ed2a05409f0d2212b8fc75f2e2fe8b","src/serialization/ascii_string.rs":"342f74d9f367f8450ba9f6c8b76022dc04c9af6bd038dc5e4fc99882b7e978c5","src/serialization/mod.rs":"0f92b7e47156ea3b86ef0c6131c749862fc3b3922e9d16ee22264324fed9a56f","tests.rs":"58cff9cd5607746c9334fd07f73bac9db3fd97034232b1a4751024666d3f1657"},"package":"d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"} \ No newline at end of file diff --git a/anneal/vendor/ascii/.cargo_vcs_info.json b/anneal/vendor/ascii/.cargo_vcs_info.json deleted file mode 100644 index 2887e77a44..0000000000 --- a/anneal/vendor/ascii/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "8605175df3a9bd1c5e36a300fa68eb5b4a181e6f" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/ascii/.github/workflows/ci.yml b/anneal/vendor/ascii/.github/workflows/ci.yml deleted file mode 100644 index e8cabbede6..0000000000 --- a/anneal/vendor/ascii/.github/workflows/ci.yml +++ /dev/null @@ -1,57 +0,0 @@ -name: CI - -on: - pull_request: - push: - branches: - - master - -jobs: - test: - name: Test with Rust ${{ matrix.rust }} - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - rust: [1.41.1, stable, beta, nightly] - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - rust-version: ${{ matrix.rust }} - - run: cargo test --verbose --all-features - - run: cargo test --verbose --no-default-features --features alloc - - run: cargo test --verbose --no-default-features - - clippy: - name: Lint with Clippy - runs-on: ubuntu-latest - env: - RUSTFLAGS: -Dwarnings - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - components: clippy - - run: cargo clippy --all-targets --verbose --no-default-features - - run: cargo clippy --all-targets --verbose --all-features - - test-minimal: - name: Test minimal dependency version with Rust nightly - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - uses: hecrj/setup-rust-action@v1 - with: - rust-version: nightly - - run: cargo test -Zminimal-versions --verbose --all-features - - miri: - name: Run tests under `miri` to check for UB - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@nightly - with: - components: miri - - run: cargo miri test --all-features diff --git a/anneal/vendor/ascii/Cargo.toml b/anneal/vendor/ascii/Cargo.toml deleted file mode 100644 index ce17c6f73b..0000000000 --- a/anneal/vendor/ascii/Cargo.toml +++ /dev/null @@ -1,41 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -name = "ascii" -version = "1.1.0" -authors = [ - "Thomas Bahn ", - "Torbjørn Birch Moltu ", - "Simon Sapin ", -] -description = "ASCII-only equivalents to `char`, `str` and `String`." -documentation = "https://docs.rs/ascii" -readme = "README.md" -license = "Apache-2.0 OR MIT" -repository = "https://github.com/tomprogrammer/rust-ascii" - -[[test]] -name = "tests" -path = "tests.rs" - -[dependencies.serde] -version = "1.0.25" -optional = true - -[dependencies.serde_test] -version = "1.0" -optional = true - -[features] -alloc = [] -default = ["std"] -std = ["alloc"] diff --git a/anneal/vendor/ascii/Cargo.toml.orig b/anneal/vendor/ascii/Cargo.toml.orig deleted file mode 100644 index 8ec25de27d..0000000000 --- a/anneal/vendor/ascii/Cargo.toml.orig +++ /dev/null @@ -1,22 +0,0 @@ -[package] -authors = ["Thomas Bahn ", "Torbjørn Birch Moltu ", "Simon Sapin "] -description = "ASCII-only equivalents to `char`, `str` and `String`." -documentation = "https://docs.rs/ascii" -license = "Apache-2.0 OR MIT" -name = "ascii" -readme = "README.md" -repository = "https://github.com/tomprogrammer/rust-ascii" -version = "1.1.0" - -[dependencies] -serde = { version = "1.0.25", optional = true } -serde_test = { version = "1.0", optional = true } - -[features] -default = ["std"] -std = ["alloc"] -alloc = [] - -[[test]] -name = "tests" -path = "tests.rs" diff --git a/anneal/vendor/ascii/LICENSE-APACHE b/anneal/vendor/ascii/LICENSE-APACHE deleted file mode 100644 index 211fa24663..0000000000 --- a/anneal/vendor/ascii/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/anneal/vendor/ascii/LICENSE-MIT b/anneal/vendor/ascii/LICENSE-MIT deleted file mode 100644 index 84c5b9e430..0000000000 --- a/anneal/vendor/ascii/LICENSE-MIT +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright (c) 2017 Thomas Bahn and contributors -Copyright (c) 2014 The Rust Project Developers - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/anneal/vendor/ascii/README.md b/anneal/vendor/ascii/README.md deleted file mode 100644 index 690fd59f23..0000000000 --- a/anneal/vendor/ascii/README.md +++ /dev/null @@ -1,64 +0,0 @@ -# ascii - -A library that provides ASCII-only string and character types, equivalent to the -`char`, `str` and `String` types in the standard library. - -Types and conversion traits are described in the [Documentation](https://docs.rs/ascii). - -You can include this crate in your cargo project by adding it to the -dependencies section in `Cargo.toml`: - -```toml -[dependencies] -ascii = "1.1" -``` - -## Using ascii without libstd - -Most of `AsciiChar` and `AsciiStr` can be used without `std` by disabling the -default features. The owned string type `AsciiString` and the conversion trait -`IntoAsciiString` as well as all methods referring to these types can be -re-enabled by enabling the `alloc` feature. - -Methods referring to `CStr` and `CString` are also unavailable. -The `Error` trait also only exists in `std`, but `description()` is made -available as an inherent method for `ToAsciiCharError` and `AsAsciiStrError` -in `#![no_std]`-mode. - -To use the `ascii` crate in `#![no_std]` mode in your cargo project, -just add the following dependency declaration in `Cargo.toml`: - -```toml -[dependencies] -ascii = { version = "1.1", default-features = false, features = ["alloc"] } -``` - -## Minimum supported Rust version - -The minimum Rust version for 1.1.\* releases is 1.41.1. -Later 1.y.0 releases might require newer Rust versions, but the three most -recent stable releases at the time of publishing will always be supported. -For example this means that if the current stable Rust version is 1.70 when -ascii 1.2.0 is released, then ascii 1.2.\* will not require a newer -Rust version than 1.68. - -## History - -This package included the Ascii types that were removed from the Rust standard -library by the 2014-12 [reform of the `std::ascii` module](https://github.com/rust-lang/rfcs/pull/486). -The API changed significantly since then. - -## License - -Licensed under either of - -* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) -* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) - -at your option. - -### Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any -additional terms or conditions. diff --git a/anneal/vendor/ascii/RELEASES.md b/anneal/vendor/ascii/RELEASES.md deleted file mode 100644 index aa1057890f..0000000000 --- a/anneal/vendor/ascii/RELEASES.md +++ /dev/null @@ -1,193 +0,0 @@ -Version 1.1.0 (2022-09-18) -========================== -* Add alloc feature. - This enables `AsciiString` and methods that take or return `Box<[AsciiStr]>` in `!#[no_std]`-mode. -* Add `AsciiStr::into_ascii_string()`, `AsciiString::into_boxed_ascii_str()` and `AsciiString::insert_str()`. -* Implement `From>` and `From` for `AsciiString`. -* Implement `From` for `Box`, `Rc`, `Arc` and `Vec`. -* Make `AsciiString::new()`, `AsciiStr::len()` and `AsciiStr::is_empty()` `const fn`. -* Require Rust 1.44.1. - -Version 1.0.0 (2019-08-26) -========================== - -Breaking changes: - -* Change `AsciiChar.is_whitespace()` to also return true for '\0xb' (vertical tab) and '\0xc' (form feed). -* Remove quickcheck feature. -* Remove `AsciiStr::new()`. -* Rename `AsciiChar::from()` and `AsciiChar::from_unchecked()` to `from_ascii()` and `from_ascii_unchecked()`. -* Rename several `AsciiChar.is_xxx()` methods to `is_ascii_xxx()` (for comsistency with std). -* Rename `AsciiChar::Null` to `Nul` (for consistency with eg. `CStr::from_bytes_with_nul()`). -* Rename `AsciiStr.trim_left()` and `AsciiStr.trim_right()` to `trim_start()` and `trim_end()`. -* Remove impls of the deprecated `std::ascii::AsciiExt` trait. -* Change iterators `Chars`, `CharsMut` and `CharsRef` from type aliases to newtypes. -* Return `impl Trait` from `AsciiStr.lines()` and `AsciiStr.split()`, and remove iterator types `Lines` and `Split`. -* Add `slice_ascii_str()`, `get_ascii()` and `unwrap_ascii()` to the `AsAsciiStr` trait. -* Add `slice_mut_ascii_str()` and `unwrap_ascii_mut()` to the `AsMutAsciiStr` trait. -* Require Rust 1.33.0 for 1.0.\*, and allow later semver-compatible 1.y.0 releases to increase it. - -Additions: - -* Add `const fn` `AsciiChar::new()` which panicks on invalid values. -* Make most `AsciiChar` methods `const fn`. -* Add multiple `AsciiChar::is_[ascii_]xxx()` methods. -* Implement `AsRef` for `AsciiChar`. -* Make `AsciiString`'s `Extend` and `FromIterator` impl generic over all `AsRef`. -* Implement inclusive range indexing for `AsciiStr` (and thereby `AsciiString`). -* Mark `AsciiStr` and `AsciiString` `#[repr(transparent)]` (to `[AsciiChar]` and `Vec` respectively). - -Version 0.9.3 (2019-08-26) -========================== - -Soundness fix: - -**Remove** [unsound](https://github.com/tomprogrammer/rust-ascii/issues/64) impls of `From<&mut AsciiStr>` for `&mut [u8]` and `&mut str`. -This is a breaking change, but theese impls can lead to undefined behavior in safe code. - -If you use this impl and know that non-ASCII values are never inserted into the `[u8]` or `str`, -you can pin ascii to 0.9.2. - -Other changes: - -* Make quickcheck `Arbitrary` impl sometimes produce `AsciiChar::DEL`. -* Implement `Clone`, `Copy` and `Eq` for `ToAsciiCharError`. -* Implement `ToAsciiChar` for `u16`, `u32` and `i8`. - -Version 0.9.2 (2019-07-07) -========================== -* Implement the `IntoAsciiString` trait for `std::ffi::CStr` and `std::ffi::CString` types, - and implemented the `AsAsciiStr` trait for `std::ffi::CStr` type. -* Implement the `IntoAsciiString` for `std::borrow::Cow`, where the inner types themselves - implement `IntoAsciiString`. -* Implement conversions between `AsciiString` and `Cow<'a, AsciiStr>`. -* Implement the `std::ops::AddAssign` trait for `AsciiString`. -* Implement `BorrowMut`, `AsRef<[AsciiChar]>`, `AsRef`, `AsMut<[AsciiChar]>` for `AsciiString`. -* Implement `PartialEq<[u8]>` and `PartialEq<[AsciiChar]>` for `AsciiStr`. -* Add `AsciiStr::first()`, `AsciiStr::last()` and `AsciiStr::split()` methods. -* Implement `DoubleEndedIterator` for `AsciiStr::lines()`. -* Implement `AsRef` and `AsMut for AsciiString`. - -Version 0.8.4 (2017-04-18) -========================== -* Fix the tests when running without std. - -Version 0.8.3 (2017-04-18) -========================== -* Bugfix: `::to_ascii_lowercase` did erroneously convert to uppercase. - -Version 0.8.2 (2017-04-17) -========================== -* Implement `IntoAsciiString` for `&'a str` and `&'a [u8]`. -* Implement the `quickcheck::Arbitrary` trait for `AsciiChar` and `AsciiString`. - The implementation is enabled by the `quickcheck` feature. - -Version 0.8.1 (2017-02-11) -========================== -* Add `Chars`, `CharsMut` and `Lines` iterators. -* Implement `std::fmt::Write` for `AsciiString`. - -Version 0.8.0 (2017-01-02) -========================== - -Breaking changes: - -* Return `FromAsciiError` instead of the input when `AsciiString::from_ascii()` or `into_ascii_string()` fails. -* Replace the `no_std` feature with the additive `std` feature, which is part of the default features. (Issue #29) -* `AsciiChar::is_*()` and `::as_{byte,char}()` take `self` by value instead of by reference. - -Additions: - -* Make `AsciiChar` comparable with `char` and `u8`. -* Add `AsciiChar::as_printable_char()` and the free functions `caret_encode()` and `caret_decode()`. -* Implement some methods from `AsciiExt` and `Error` (which are not in libcore) directly in `core` mode: - * `Ascii{Char,Str}::eq_ignore_ascii_case()` - * `AsciiChar::to_ascii_{upper,lower}case()` - * `AsciiStr::make_ascii_{upper,lower}case()` - * `{ToAsciiChar,AsAsciiStr}Error::description()` - -Version 0.7.1 (2016-08-15) -========================== -* Fix the implementation of `AsciiExt::to_ascii_lowercase()` for `AsciiChar` converting to uppercase. (introduced in 0.7.0) - -Version 0.7.0 (2016-06-25) -========================== -* Rename `Ascii` to `AsciiChar` and convert it into an enum. - (with a variant for every ASCII character) -* Replace `OwnedAsciiCast` with `IntoAsciiString`. -* Replace `AsciiCast` with `As[Mut]AsciiStr` and `IntoAsciiChar`. -* Add *from[_ascii]_unchecked* methods. -* Replace *from_bytes* with *from_ascii* in method names. -* Return `std::error::Error`-implementing types instead of `()` and `None` when - conversion to `AsciiStr` or `AsciiChar` fails. -* Implement `AsciiExt` without the `unstable` Cargo feature flag, which is removed. -* Require Rust 1.9 or later. -* Add `#[no_std]` support in a Cargo feature. -* Implement `From<{&,&mut,Box<}AsciiStr>` for `[Ascii]`, `[u8]` and `str` -* Implement `From<{&,&mut,Box<}[Ascii]>`, `As{Ref,Mut}<[Ascii]>` and Default for `AsciiStr` -* Implement `From>` for `AsciiString`. -* Implement `AsMut` for `AsciiString`. -* Stop some `Ascii::is_xxx()` methods from panicking. -* Add `Ascii::is_whitespace()`. -* Add `AsciiString::as_mut_slice()`. -* Add raw pointer methods on `AsciiString`: - * `from_raw_parts` - * `as_ptr` - * `as_mut_ptr` - -Version 0.6.0 (2015-12-30) -========================== -* Add `Ascii::from_byte()` -* Add `AsciiStr::trim[_{left,right}]()` - -Version 0.5.4 (2015-07-29) -========================== -Implement `IndexMut` for AsciiStr and AsciiString. - -Version 0.5.1 (2015-06-13) -========================== -* Add `Ascii::from()`. -* Implement `Index` for `AsciiStr` and `AsciiString`. -* Implement `Default`,`FromIterator`,`Extend` and `Add` for `AsciiString` -* Added inherent methods on `AsciiString`: - * `with_capacity` - * `push_str` - * `capacity` - * `reserve` - * `reserve_exact` - * `shrink_to_fit` - * `push` - * `truncate` - * `pop` - * `remove` - * `insert` - * `len` - * `is_empty` - * `clear` - -Version 0.5.0 (2015-05-05) -========================== -First release compatible with Rust 1.0.0. diff --git a/anneal/vendor/ascii/src/ascii_char.rs b/anneal/vendor/ascii/src/ascii_char.rs deleted file mode 100644 index 5011949f76..0000000000 --- a/anneal/vendor/ascii/src/ascii_char.rs +++ /dev/null @@ -1,1069 +0,0 @@ -use core::cmp::Ordering; -use core::mem; -use core::{char, fmt}; -#[cfg(feature = "std")] -use std::error::Error; - -#[allow(non_camel_case_types)] -/// An ASCII character. It wraps a `u8`, with the highest bit always zero. -#[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Hash, Copy)] -#[repr(u8)] -pub enum AsciiChar { - /// `'\0'` - Null = 0, - /// [Start Of Heading](http://en.wikipedia.org/wiki/Start_of_Heading) - SOH = 1, - /// [Start Of teXt](http://en.wikipedia.org/wiki/Start_of_Text) - SOX = 2, - /// [End of TeXt](http://en.wikipedia.org/wiki/End-of-Text_character) - ETX = 3, - /// [End Of Transmission](http://en.wikipedia.org/wiki/End-of-Transmission_character) - EOT = 4, - /// [Enquiry](http://en.wikipedia.org/wiki/Enquiry_character) - ENQ = 5, - /// [Acknowledgement](http://en.wikipedia.org/wiki/Acknowledge_character) - ACK = 6, - /// [bell / alarm / audible](http://en.wikipedia.org/wiki/Bell_character) - /// - /// `'\a'` is not recognized by Rust. - Bell = 7, - /// [Backspace](http://en.wikipedia.org/wiki/Backspace) - /// - /// `'\b'` is not recognized by Rust. - BackSpace = 8, - /// `'\t'` - Tab = 9, - /// `'\n'` - LineFeed = 10, - /// [Vertical tab](http://en.wikipedia.org/wiki/Vertical_Tab) - /// - /// `'\v'` is not recognized by Rust. - VT = 11, - /// [Form Feed](http://en.wikipedia.org/wiki/Form_Feed) - /// - /// `'\f'` is not recognized by Rust. - FF = 12, - /// `'\r'` - CarriageReturn = 13, - /// [Shift In](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) - SI = 14, - /// [Shift Out](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) - SO = 15, - /// [Data Link Escape](http://en.wikipedia.org/wiki/Data_Link_Escape) - DLE = 16, - /// [Device control 1, often XON](http://en.wikipedia.org/wiki/Device_Control_1) - DC1 = 17, - /// Device control 2 - DC2 = 18, - /// Device control 3, Often XOFF - DC3 = 19, - /// Device control 4 - DC4 = 20, - /// [Negative AcKnowledgement](http://en.wikipedia.org/wiki/Negative-acknowledge_character) - NAK = 21, - /// [Synchronous idle](http://en.wikipedia.org/wiki/Synchronous_Idle) - SYN = 22, - /// [End of Transmission Block](http://en.wikipedia.org/wiki/End-of-Transmission-Block_character) - ETB = 23, - /// [Cancel](http://en.wikipedia.org/wiki/Cancel_character) - CAN = 24, - /// [End of Medium](http://en.wikipedia.org/wiki/End_of_Medium) - EM = 25, - /// [Substitute](http://en.wikipedia.org/wiki/Substitute_character) - SUB = 26, - /// [Escape](http://en.wikipedia.org/wiki/Escape_character) - /// - /// `'\e'` is not recognized by Rust. - ESC = 27, - /// [File Separator](http://en.wikipedia.org/wiki/File_separator) - FS = 28, - /// [Group Separator](http://en.wikipedia.org/wiki/Group_separator) - GS = 29, - /// [Record Separator](http://en.wikipedia.org/wiki/Record_separator) - RS = 30, - /// [Unit Separator](http://en.wikipedia.org/wiki/Unit_separator) - US = 31, - /// `' '` - Space = 32, - /// `'!'` - Exclamation = 33, - /// `'"'` - Quotation = 34, - /// `'#'` - Hash = 35, - /// `'$'` - Dollar = 36, - /// `'%'` - Percent = 37, - /// `'&'` - Ampersand = 38, - /// `'\''` - Apostrophe = 39, - /// `'('` - ParenOpen = 40, - /// `')'` - ParenClose = 41, - /// `'*'` - Asterisk = 42, - /// `'+'` - Plus = 43, - /// `','` - Comma = 44, - /// `'-'` - Minus = 45, - /// `'.'` - Dot = 46, - /// `'/'` - Slash = 47, - /// `'0'` - _0 = 48, - /// `'1'` - _1 = 49, - /// `'2'` - _2 = 50, - /// `'3'` - _3 = 51, - /// `'4'` - _4 = 52, - /// `'5'` - _5 = 53, - /// `'6'` - _6 = 54, - /// `'7'` - _7 = 55, - /// `'8'` - _8 = 56, - /// `'9'` - _9 = 57, - /// `':'` - Colon = 58, - /// `';'` - Semicolon = 59, - /// `'<'` - LessThan = 60, - /// `'='` - Equal = 61, - /// `'>'` - GreaterThan = 62, - /// `'?'` - Question = 63, - /// `'@'` - At = 64, - /// `'A'` - A = 65, - /// `'B'` - B = 66, - /// `'C'` - C = 67, - /// `'D'` - D = 68, - /// `'E'` - E = 69, - /// `'F'` - F = 70, - /// `'G'` - G = 71, - /// `'H'` - H = 72, - /// `'I'` - I = 73, - /// `'J'` - J = 74, - /// `'K'` - K = 75, - /// `'L'` - L = 76, - /// `'M'` - M = 77, - /// `'N'` - N = 78, - /// `'O'` - O = 79, - /// `'P'` - P = 80, - /// `'Q'` - Q = 81, - /// `'R'` - R = 82, - /// `'S'` - S = 83, - /// `'T'` - T = 84, - /// `'U'` - U = 85, - /// `'V'` - V = 86, - /// `'W'` - W = 87, - /// `'X'` - X = 88, - /// `'Y'` - Y = 89, - /// `'Z'` - Z = 90, - /// `'['` - BracketOpen = 91, - /// `'\'` - BackSlash = 92, - /// `']'` - BracketClose = 93, - /// `'^'` - Caret = 94, - /// `'_'` - UnderScore = 95, - /// `'`'` - Grave = 96, - /// `'a'` - a = 97, - /// `'b'` - b = 98, - /// `'c'` - c = 99, - /// `'d'` - d = 100, - /// `'e'` - e = 101, - /// `'f'` - f = 102, - /// `'g'` - g = 103, - /// `'h'` - h = 104, - /// `'i'` - i = 105, - /// `'j'` - j = 106, - /// `'k'` - k = 107, - /// `'l'` - l = 108, - /// `'m'` - m = 109, - /// `'n'` - n = 110, - /// `'o'` - o = 111, - /// `'p'` - p = 112, - /// `'q'` - q = 113, - /// `'r'` - r = 114, - /// `'s'` - s = 115, - /// `'t'` - t = 116, - /// `'u'` - u = 117, - /// `'v'` - v = 118, - /// `'w'` - w = 119, - /// `'x'` - x = 120, - /// `'y'` - y = 121, - /// `'z'` - z = 122, - /// `'{'` - CurlyBraceOpen = 123, - /// `'|'` - VerticalBar = 124, - /// `'}'` - CurlyBraceClose = 125, - /// `'~'` - Tilde = 126, - /// [Delete](http://en.wikipedia.org/wiki/Delete_character) - DEL = 127, -} - -impl AsciiChar { - /// Constructs an ASCII character from a `u8`, `char` or other character type. - /// - /// # Errors - /// Returns `Err(())` if the character can't be ASCII encoded. - /// - /// # Example - /// ``` - /// # use ascii::AsciiChar; - /// let a = AsciiChar::from_ascii('g').unwrap(); - /// assert_eq!(a.as_char(), 'g'); - /// ``` - #[inline] - pub fn from_ascii(ch: C) -> Result { - ch.to_ascii_char() - } - - /// Create an `AsciiChar` from a `char`, panicking if it's not ASCII. - /// - /// This function is intended for creating `AsciiChar` values from - /// hardcoded known-good character literals such as `'K'`, `'-'` or `'\0'`, - /// and for use in `const` contexts. - /// Use [`from_ascii()`](#method.from_ascii) instead when you're not - /// certain the character is ASCII. - /// - /// # Examples - /// - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('@'), AsciiChar::At); - /// assert_eq!(AsciiChar::new('C').as_char(), 'C'); - /// ``` - /// - /// In a constant: - /// ``` - /// # use ascii::AsciiChar; - /// const SPLIT_ON: AsciiChar = AsciiChar::new(','); - /// ``` - /// - /// This will not compile: - /// ```compile_fail - /// # use ascii::AsciiChar; - /// const BAD: AsciiChar = AsciiChar::new('Ø'); - /// ``` - /// - /// # Panics - /// - /// This function will panic if passed a non-ASCII character. - /// - /// The panic message might not be the most descriptive due to the - /// current limitations of `const fn`. - #[must_use] - pub const fn new(ch: char) -> AsciiChar { - // It's restricted to this function, and without it - // we'd need to specify `AsciiChar::` or `Self::` 128 times. - #[allow(clippy::enum_glob_use)] - use AsciiChar::*; - - #[rustfmt::skip] - const ALL: [AsciiChar; 128] = [ - Null, SOH, SOX, ETX, EOT, ENQ, ACK, Bell, - BackSpace, Tab, LineFeed, VT, FF, CarriageReturn, SI, SO, - DLE, DC1, DC2, DC3, DC4, NAK, SYN, ETB, - CAN, EM, SUB, ESC, FS, GS, RS, US, - Space, Exclamation, Quotation, Hash, Dollar, Percent, Ampersand, Apostrophe, - ParenOpen, ParenClose, Asterisk, Plus, Comma, Minus, Dot, Slash, - _0, _1, _2, _3, _4, _5, _6, _7, - _8, _9, Colon, Semicolon, LessThan, Equal, GreaterThan, Question, - At, A, B, C, D, E, F, G, - H, I, J, K, L, M, N, O, - P, Q, R, S, T, U, V, W, - X, Y, Z, BracketOpen, BackSlash, BracketClose, Caret, UnderScore, - Grave, a, b, c, d, e, f, g, - h, i, j, k, l, m, n, o, - p, q, r, s, t, u, v, w, - x, y, z, CurlyBraceOpen, VerticalBar, CurlyBraceClose, Tilde, DEL, - ]; - - // We want to slice here and detect `const_err` from rustc if the slice is invalid - #[allow(clippy::indexing_slicing)] - ALL[ch as usize] - } - - /// Constructs an ASCII character from a `u8`, `char` or other character - /// type without any checks. - /// - /// # Safety - /// - /// This function is very unsafe as it can create invalid enum - /// discriminants, which instantly creates undefined behavior. - /// (`let _ = AsciiChar::from_ascii_unchecked(200);` alone is UB). - /// - /// The undefined behavior is not just theoretical either: - /// For example, `[0; 128][AsciiChar::from_ascii_unchecked(255) as u8 as usize] = 0` - /// might not panic, creating a buffer overflow, - /// and `Some(AsciiChar::from_ascii_unchecked(128))` might be `None`. - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(ch: u8) -> Self { - // SAFETY: Caller guarantees `ch` is within bounds of ascii. - unsafe { ch.to_ascii_char_unchecked() } - } - - /// Converts an ASCII character into a `u8`. - #[inline] - #[must_use] - pub const fn as_byte(self) -> u8 { - self as u8 - } - - /// Converts an ASCII character into a `char`. - #[inline] - #[must_use] - pub const fn as_char(self) -> char { - self as u8 as char - } - - // the following methods are like ctype, and the implementation is inspired by musl. - // The ascii_ methods take self by reference for maximum compatibility - // with the corresponding methods on u8 and char. - // It is bad for both usability and performance, but marking those - // that doesn't have a non-ascii sibling #[inline] should - // make the compiler optimize away the indirection. - - /// Turns uppercase into lowercase, but also modifies '@' and '<'..='_' - #[must_use] - const fn to_not_upper(self) -> u8 { - self as u8 | 0b010_0000 - } - - /// Check if the character is a letter (a-z, A-Z) - #[inline] - #[must_use] - pub const fn is_alphabetic(self) -> bool { - (self.to_not_upper() >= b'a') & (self.to_not_upper() <= b'z') - } - - /// Check if the character is a letter (a-z, A-Z). - /// - /// This method is identical to [`is_alphabetic()`](#method.is_alphabetic) - #[inline] - #[must_use] - pub const fn is_ascii_alphabetic(&self) -> bool { - self.is_alphabetic() - } - - /// Check if the character is a digit in the given radix. - /// - /// If the radix is always 10 or 16, - /// [`is_ascii_digit()`](#method.is_ascii_digit) and - /// [`is_ascii_hexdigit()`](#method.is_ascii_hexdigit()) will be faster. - /// - /// # Panics - /// - /// Radixes greater than 36 are not supported and will result in a panic. - #[must_use] - pub fn is_digit(self, radix: u32) -> bool { - match (self as u8, radix) { - (b'0'..=b'9', 0..=36) => u32::from(self as u8 - b'0') < radix, - (b'a'..=b'z', 11..=36) => u32::from(self as u8 - b'a') < radix - 10, - (b'A'..=b'Z', 11..=36) => u32::from(self as u8 - b'A') < radix - 10, - (_, 0..=36) => false, - (_, _) => panic!("radixes greater than 36 are not supported"), - } - } - - /// Check if the character is a number (0-9) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('0').is_ascii_digit(), true); - /// assert_eq!(AsciiChar::new('9').is_ascii_digit(), true); - /// assert_eq!(AsciiChar::new('a').is_ascii_digit(), false); - /// assert_eq!(AsciiChar::new('A').is_ascii_digit(), false); - /// assert_eq!(AsciiChar::new('/').is_ascii_digit(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_digit(&self) -> bool { - (*self as u8 >= b'0') & (*self as u8 <= b'9') - } - - /// Check if the character is a letter or number - #[inline] - #[must_use] - pub const fn is_alphanumeric(self) -> bool { - self.is_alphabetic() | self.is_ascii_digit() - } - - /// Check if the character is a letter or number - /// - /// This method is identical to [`is_alphanumeric()`](#method.is_alphanumeric) - #[inline] - #[must_use] - pub const fn is_ascii_alphanumeric(&self) -> bool { - self.is_alphanumeric() - } - - /// Check if the character is a space or horizontal tab - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert!(AsciiChar::Space.is_ascii_blank()); - /// assert!(AsciiChar::Tab.is_ascii_blank()); - /// assert!(!AsciiChar::VT.is_ascii_blank()); - /// assert!(!AsciiChar::LineFeed.is_ascii_blank()); - /// assert!(!AsciiChar::CarriageReturn.is_ascii_blank()); - /// assert!(!AsciiChar::FF.is_ascii_blank()); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_blank(&self) -> bool { - (*self as u8 == b' ') | (*self as u8 == b'\t') - } - - /// Check if the character one of ' ', '\t', '\n', '\r', - /// '\0xb' (vertical tab) or '\0xc' (form feed). - #[inline] - #[must_use] - pub const fn is_whitespace(self) -> bool { - let b = self as u8; - self.is_ascii_blank() | (b == b'\n') | (b == b'\r') | (b == 0x0b) | (b == 0x0c) - } - - /// Check if the character is a ' ', '\t', '\n', '\r' or '\0xc' (form feed). - /// - /// This method is NOT identical to `is_whitespace()`. - #[inline] - #[must_use] - pub const fn is_ascii_whitespace(&self) -> bool { - self.is_ascii_blank() - | (*self as u8 == b'\n') - | (*self as u8 == b'\r') - | (*self as u8 == 0x0c/*form feed*/) - } - - /// Check if the character is a control character - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('\0').is_ascii_control(), true); - /// assert_eq!(AsciiChar::new('n').is_ascii_control(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_control(), false); - /// assert_eq!(AsciiChar::new('\n').is_ascii_control(), true); - /// assert_eq!(AsciiChar::new('\t').is_ascii_control(), true); - /// assert_eq!(AsciiChar::EOT.is_ascii_control(), true); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_control(&self) -> bool { - ((*self as u8) < b' ') | (*self as u8 == 127) - } - - /// Checks if the character is printable (except space) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_graphic(), true); - /// assert_eq!(AsciiChar::new(' ').is_ascii_graphic(), false); - /// assert_eq!(AsciiChar::new('\n').is_ascii_graphic(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_graphic(&self) -> bool { - self.as_byte().wrapping_sub(b' ' + 1) < 0x5E - } - - /// Checks if the character is printable (including space) - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_printable(), true); - /// assert_eq!(AsciiChar::new(' ').is_ascii_printable(), true); - /// assert_eq!(AsciiChar::new('\n').is_ascii_printable(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_printable(&self) -> bool { - self.as_byte().wrapping_sub(b' ') < 0x5F - } - - /// Checks if the character is alphabetic and lowercase (a-z). - /// - /// # Examples - /// ``` - /// use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('a').is_lowercase(), true); - /// assert_eq!(AsciiChar::new('A').is_lowercase(), false); - /// assert_eq!(AsciiChar::new('@').is_lowercase(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_lowercase(self) -> bool { - self.as_byte().wrapping_sub(b'a') < 26 - } - - /// Checks if the character is alphabetic and lowercase (a-z). - /// - /// This method is identical to [`is_lowercase()`](#method.is_lowercase) - #[inline] - #[must_use] - pub const fn is_ascii_lowercase(&self) -> bool { - self.is_lowercase() - } - - /// Checks if the character is alphabetic and uppercase (A-Z). - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('A').is_uppercase(), true); - /// assert_eq!(AsciiChar::new('a').is_uppercase(), false); - /// assert_eq!(AsciiChar::new('@').is_uppercase(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_uppercase(self) -> bool { - self.as_byte().wrapping_sub(b'A') < 26 - } - - /// Checks if the character is alphabetic and uppercase (A-Z). - /// - /// This method is identical to [`is_uppercase()`](#method.is_uppercase) - #[inline] - #[must_use] - pub const fn is_ascii_uppercase(&self) -> bool { - self.is_uppercase() - } - - /// Checks if the character is punctuation - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('n').is_ascii_punctuation(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_punctuation(), false); - /// assert_eq!(AsciiChar::new('_').is_ascii_punctuation(), true); - /// assert_eq!(AsciiChar::new('~').is_ascii_punctuation(), true); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_punctuation(&self) -> bool { - self.is_ascii_graphic() & !self.is_alphanumeric() - } - - /// Checks if the character is a valid hex digit - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('5').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('a').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('F').is_ascii_hexdigit(), true); - /// assert_eq!(AsciiChar::new('G').is_ascii_hexdigit(), false); - /// assert_eq!(AsciiChar::new(' ').is_ascii_hexdigit(), false); - /// ``` - #[inline] - #[must_use] - pub const fn is_ascii_hexdigit(&self) -> bool { - self.is_ascii_digit() | ((*self as u8 | 0x20_u8).wrapping_sub(b'a') < 6) - } - - /// Unicode has printable versions of the ASCII control codes, like '␛'. - /// - /// This function is identical with `.as_char()` - /// for all values `.is_printable()` returns true for, - /// but replaces the control codes with those unicodes printable versions. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('\0').as_printable_char(), '␀'); - /// assert_eq!(AsciiChar::new('\n').as_printable_char(), '␊'); - /// assert_eq!(AsciiChar::new(' ').as_printable_char(), ' '); - /// assert_eq!(AsciiChar::new('p').as_printable_char(), 'p'); - /// ``` - #[must_use] - pub fn as_printable_char(self) -> char { - match self as u8 { - // Non printable characters - // SAFETY: From codepoint 0x2400 ('␀') to 0x241f (`␟`), there are characters representing - // the unprintable characters from 0x0 to 0x1f, ordered correctly. - // As `b` is guaranteed to be within 0x0 to 0x1f, the conversion represents a - // valid character. - b @ 0x0..=0x1f => unsafe { char::from_u32_unchecked(u32::from('␀') + u32::from(b)) }, - - // 0x7f (delete) has it's own character at codepoint 0x2420, not 0x247f, so it is special - // cased to return it's character - 0x7f => '␡', - - // All other characters are printable, and per function contract use `Self::as_char` - _ => self.as_char(), - } - } - - /// Replaces letters `a` to `z` with `A` to `Z` - pub fn make_ascii_uppercase(&mut self) { - *self = self.to_ascii_uppercase(); - } - - /// Replaces letters `A` to `Z` with `a` to `z` - pub fn make_ascii_lowercase(&mut self) { - *self = self.to_ascii_lowercase(); - } - - /// Maps letters a-z to A-Z and returns any other character unchanged. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('u').to_ascii_uppercase().as_char(), 'U'); - /// assert_eq!(AsciiChar::new('U').to_ascii_uppercase().as_char(), 'U'); - /// assert_eq!(AsciiChar::new('2').to_ascii_uppercase().as_char(), '2'); - /// assert_eq!(AsciiChar::new('=').to_ascii_uppercase().as_char(), '='); - /// assert_eq!(AsciiChar::new('[').to_ascii_uppercase().as_char(), '['); - /// ``` - #[inline] - #[must_use] - #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1` - pub const fn to_ascii_uppercase(&self) -> Self { - [*self, AsciiChar::new((*self as u8 & 0b101_1111) as char)][self.is_lowercase() as usize] - } - - /// Maps letters A-Z to a-z and returns any other character unchanged. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiChar; - /// assert_eq!(AsciiChar::new('U').to_ascii_lowercase().as_char(), 'u'); - /// assert_eq!(AsciiChar::new('u').to_ascii_lowercase().as_char(), 'u'); - /// assert_eq!(AsciiChar::new('2').to_ascii_lowercase().as_char(), '2'); - /// assert_eq!(AsciiChar::new('^').to_ascii_lowercase().as_char(), '^'); - /// assert_eq!(AsciiChar::new('\x7f').to_ascii_lowercase().as_char(), '\x7f'); - /// ``` - #[inline] - #[must_use] - #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1` - pub const fn to_ascii_lowercase(&self) -> Self { - [*self, AsciiChar::new(self.to_not_upper() as char)][self.is_uppercase() as usize] - } - - /// Compares two characters case-insensitively. - #[inline] - #[must_use] - pub const fn eq_ignore_ascii_case(&self, other: &Self) -> bool { - (self.as_byte() == other.as_byte()) - | (self.is_alphabetic() & (self.to_not_upper() == other.to_not_upper())) - } -} - -impl fmt::Display for AsciiChar { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_char().fmt(f) - } -} - -impl fmt::Debug for AsciiChar { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.as_char().fmt(f) - } -} - -impl Default for AsciiChar { - fn default() -> AsciiChar { - AsciiChar::Null - } -} - -macro_rules! impl_into_partial_eq_ord { - ($wider:ty, $to_wider:expr) => { - impl From for $wider { - #[inline] - fn from(a: AsciiChar) -> $wider { - $to_wider(a) - } - } - impl PartialEq<$wider> for AsciiChar { - #[inline] - fn eq(&self, rhs: &$wider) -> bool { - $to_wider(*self) == *rhs - } - } - impl PartialEq for $wider { - #[inline] - fn eq(&self, rhs: &AsciiChar) -> bool { - *self == $to_wider(*rhs) - } - } - impl PartialOrd<$wider> for AsciiChar { - #[inline] - fn partial_cmp(&self, rhs: &$wider) -> Option { - $to_wider(*self).partial_cmp(rhs) - } - } - impl PartialOrd for $wider { - #[inline] - fn partial_cmp(&self, rhs: &AsciiChar) -> Option { - self.partial_cmp(&$to_wider(*rhs)) - } - } - }; -} -impl_into_partial_eq_ord! {u8, AsciiChar::as_byte} -impl_into_partial_eq_ord! {char, AsciiChar::as_char} - -/// Error returned by `ToAsciiChar`. -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct ToAsciiCharError(()); - -const ERRORMSG_CHAR: &str = "not an ASCII character"; - -#[cfg(not(feature = "std"))] -impl ToAsciiCharError { - /// Returns a description for this error, like `std::error::Error::description`. - #[inline] - #[must_use] - #[allow(clippy::unused_self)] - pub const fn description(&self) -> &'static str { - ERRORMSG_CHAR - } -} - -impl fmt::Debug for ToAsciiCharError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "{}", ERRORMSG_CHAR) - } -} - -impl fmt::Display for ToAsciiCharError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "{}", ERRORMSG_CHAR) - } -} - -#[cfg(feature = "std")] -impl Error for ToAsciiCharError { - #[inline] - fn description(&self) -> &'static str { - ERRORMSG_CHAR - } -} - -/// Convert `char`, `u8` and other character types to `AsciiChar`. -pub trait ToAsciiChar { - /// Convert to `AsciiChar`. - /// - /// # Errors - /// If `self` is outside the valid ascii range, this returns `Err` - fn to_ascii_char(self) -> Result; - - /// Convert to `AsciiChar` without checking that it is an ASCII character. - /// - /// # Safety - /// Calling this function with a value outside of the ascii range, `0x0` to `0x7f` inclusive, - /// is undefined behavior. - // TODO: Make sure this is the contract we want to express in this function. - // It is ambigous if numbers such as `0xffffff20_u32` are valid ascii characters, - // as this function returns `Ascii::Space` due to the cast to `u8`, even though - // `to_ascii_char` returns `Err()`. - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar; -} - -impl ToAsciiChar for AsciiChar { - #[inline] - fn to_ascii_char(self) -> Result { - Ok(self) - } - - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - self - } -} - -impl ToAsciiChar for u8 { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees `self` is within bounds of the enum - // variants, so this cast successfully produces a valid ascii - // variant - unsafe { mem::transmute::(self) } - } -} - -// Note: Casts to `u8` here does not cause problems, as the negative -// range is mapped outside of ascii bounds and we don't mind losing -// the sign, as long as negative numbers are mapped outside ascii range. -#[allow(clippy::cast_sign_loss)] -impl ToAsciiChar for i8 { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self as u8).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees `self` is within bounds of the enum - // variants, so this cast successfully produces a valid ascii - // variant - unsafe { mem::transmute::(self as u8) } - } -} - -impl ToAsciiChar for char { - #[inline] - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // SAFETY: Caller guarantees we're within ascii range. - unsafe { u32::from(self).to_ascii_char_unchecked() } - } -} - -impl ToAsciiChar for u32 { - fn to_ascii_char(self) -> Result { - match self { - // SAFETY: We're within the valid ascii range in this branch. - 0x0..=0x7f => Ok(unsafe { self.to_ascii_char_unchecked() }), - _ => Err(ToAsciiCharError(())), - } - } - - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // Note: This cast discards the top bytes, this may cause problems, see - // the TODO on this method's documentation in the trait. - // SAFETY: Caller guarantees we're within ascii range. - #[allow(clippy::cast_possible_truncation)] // We want to truncate it - unsafe { - (self as u8).to_ascii_char_unchecked() - } - } -} - -impl ToAsciiChar for u16 { - fn to_ascii_char(self) -> Result { - u32::from(self).to_ascii_char() - } - #[inline] - unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { - // Note: This cast discards the top bytes, this may cause problems, see - // the TODO on this method's documentation in the trait. - // SAFETY: Caller guarantees we're within ascii range. - #[allow(clippy::cast_possible_truncation)] // We want to truncate it - unsafe { - (self as u8).to_ascii_char_unchecked() - } - } -} - -#[cfg(test)] -mod tests { - use super::{AsciiChar, ToAsciiChar, ToAsciiCharError}; - - #[test] - fn to_ascii_char() { - fn generic(ch: C) -> Result { - ch.to_ascii_char() - } - assert_eq!(generic(AsciiChar::A), Ok(AsciiChar::A)); - assert_eq!(generic(b'A'), Ok(AsciiChar::A)); - assert_eq!(generic('A'), Ok(AsciiChar::A)); - assert!(generic(200_u16).is_err()); - assert!(generic('λ').is_err()); - } - - #[test] - fn as_byte_and_char() { - assert_eq!(AsciiChar::A.as_byte(), b'A'); - assert_eq!(AsciiChar::A.as_char(), 'A'); - } - - #[test] - fn new_array_is_correct() { - for byte in 0..128_u8 { - assert_eq!(AsciiChar::new(byte as char).as_byte(), byte); - } - } - - #[test] - fn is_all() { - #![allow(clippy::is_digit_ascii_radix)] // testing it - for byte in 0..128_u8 { - let ch = byte as char; - let ascii = AsciiChar::new(ch); - assert_eq!(ascii.is_alphabetic(), ch.is_alphabetic()); - assert_eq!(ascii.is_ascii_alphabetic(), ch.is_ascii_alphabetic()); - assert_eq!(ascii.is_alphanumeric(), ch.is_alphanumeric()); - assert_eq!(ascii.is_ascii_alphanumeric(), ch.is_ascii_alphanumeric()); - assert_eq!(ascii.is_digit(8), ch.is_digit(8), "is_digit(8) {:?}", ch); - assert_eq!(ascii.is_digit(10), ch.is_digit(10), "is_digit(10) {:?}", ch); - assert_eq!(ascii.is_digit(16), ch.is_digit(16), "is_digit(16) {:?}", ch); - assert_eq!(ascii.is_digit(36), ch.is_digit(36), "is_digit(36) {:?}", ch); - assert_eq!(ascii.is_ascii_digit(), ch.is_ascii_digit()); - assert_eq!(ascii.is_ascii_hexdigit(), ch.is_ascii_hexdigit()); - assert_eq!(ascii.is_ascii_control(), ch.is_ascii_control()); - assert_eq!(ascii.is_ascii_graphic(), ch.is_ascii_graphic()); - assert_eq!(ascii.is_ascii_punctuation(), ch.is_ascii_punctuation()); - assert_eq!( - ascii.is_whitespace(), - ch.is_whitespace(), - "{:?} ({:#04x})", - ch, - byte - ); - assert_eq!( - ascii.is_ascii_whitespace(), - ch.is_ascii_whitespace(), - "{:?} ({:#04x})", - ch, - byte - ); - assert_eq!(ascii.is_uppercase(), ch.is_uppercase()); - assert_eq!(ascii.is_ascii_uppercase(), ch.is_ascii_uppercase()); - assert_eq!(ascii.is_lowercase(), ch.is_lowercase()); - assert_eq!(ascii.is_ascii_lowercase(), ch.is_ascii_lowercase()); - assert_eq!(ascii.to_ascii_uppercase(), ch.to_ascii_uppercase()); - assert_eq!(ascii.to_ascii_lowercase(), ch.to_ascii_lowercase()); - } - } - - #[test] - fn is_digit_strange_radixes() { - assert_eq!(AsciiChar::_0.is_digit(0), '0'.is_digit(0)); - assert_eq!(AsciiChar::_0.is_digit(1), '0'.is_digit(1)); - assert_eq!(AsciiChar::_5.is_digit(5), '5'.is_digit(5)); - assert_eq!(AsciiChar::z.is_digit(35), 'z'.is_digit(35)); - } - - #[test] - #[should_panic] - fn is_digit_bad_radix() { - let _ = AsciiChar::_7.is_digit(37); - } - - #[test] - fn cmp_wider() { - assert_eq!(AsciiChar::A, 'A'); - assert_eq!(b'b', AsciiChar::b); - assert!(AsciiChar::a < 'z'); - } - - #[test] - fn ascii_case() { - assert_eq!(AsciiChar::At.to_ascii_lowercase(), AsciiChar::At); - assert_eq!(AsciiChar::At.to_ascii_uppercase(), AsciiChar::At); - assert_eq!(AsciiChar::A.to_ascii_lowercase(), AsciiChar::a); - assert_eq!(AsciiChar::A.to_ascii_uppercase(), AsciiChar::A); - assert_eq!(AsciiChar::a.to_ascii_lowercase(), AsciiChar::a); - assert_eq!(AsciiChar::a.to_ascii_uppercase(), AsciiChar::A); - - let mut mutable = (AsciiChar::A, AsciiChar::a); - mutable.0.make_ascii_lowercase(); - mutable.1.make_ascii_uppercase(); - assert_eq!(mutable.0, AsciiChar::a); - assert_eq!(mutable.1, AsciiChar::A); - - assert!(AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::LineFeed)); - assert!(!AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::CarriageReturn)); - assert!(AsciiChar::z.eq_ignore_ascii_case(&AsciiChar::Z)); - assert!(AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::z)); - assert!(AsciiChar::A.eq_ignore_ascii_case(&AsciiChar::a)); - assert!(!AsciiChar::K.eq_ignore_ascii_case(&AsciiChar::C)); - assert!(!AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::DEL)); - assert!(!AsciiChar::BracketOpen.eq_ignore_ascii_case(&AsciiChar::CurlyBraceOpen)); - assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::At)); - assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::DEL)); - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii() { - assert_eq!(format!("{}", AsciiChar::t), "t"); - assert_eq!(format!("{:?}", AsciiChar::t), "'t'"); - assert_eq!(format!("{}", AsciiChar::LineFeed), "\n"); - assert_eq!(format!("{:?}", AsciiChar::LineFeed), "'\\n'"); - } -} diff --git a/anneal/vendor/ascii/src/ascii_str.rs b/anneal/vendor/ascii/src/ascii_str.rs deleted file mode 100644 index e8a6e12550..0000000000 --- a/anneal/vendor/ascii/src/ascii_str.rs +++ /dev/null @@ -1,1600 +0,0 @@ -#[cfg(feature = "alloc")] -use alloc::borrow::ToOwned; -#[cfg(feature = "alloc")] -use alloc::boxed::Box; -use core::fmt; -use core::ops::{Index, IndexMut}; -use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive}; -use core::slice::{self, Iter, IterMut, SliceIndex}; -#[cfg(feature = "std")] -use std::error::Error; -#[cfg(feature = "std")] -use std::ffi::CStr; - -use ascii_char::AsciiChar; -#[cfg(feature = "alloc")] -use ascii_string::AsciiString; - -/// [`AsciiStr`] represents a byte or string slice that only contains ASCII characters. -/// -/// It wraps an `[AsciiChar]` and implements many of `str`s methods and traits. -/// -/// It can be created by a checked conversion from a `str` or `[u8]`, or borrowed from an -/// `AsciiString`. -#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -pub struct AsciiStr { - slice: [AsciiChar], -} - -impl AsciiStr { - /// Converts `&self` to a `&str` slice. - #[inline] - #[must_use] - pub fn as_str(&self) -> &str { - // SAFETY: All variants of `AsciiChar` are valid bytes for a `str`. - unsafe { &*(self as *const AsciiStr as *const str) } - } - - /// Converts `&self` into a byte slice. - #[inline] - #[must_use] - pub fn as_bytes(&self) -> &[u8] { - // SAFETY: All variants of `AsciiChar` are valid `u8`, given they're `repr(u8)`. - unsafe { &*(self as *const AsciiStr as *const [u8]) } - } - - /// Returns the entire string as slice of `AsciiChar`s. - #[inline] - #[must_use] - pub const fn as_slice(&self) -> &[AsciiChar] { - &self.slice - } - - /// Returns the entire string as mutable slice of `AsciiChar`s. - #[inline] - #[must_use] - pub fn as_mut_slice(&mut self) -> &mut [AsciiChar] { - &mut self.slice - } - - /// Returns a raw pointer to the `AsciiStr`'s buffer. - /// - /// The caller must ensure that the slice outlives the pointer this function returns, or else it - /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be - /// reallocated, which would also make any pointers to it invalid. - #[inline] - #[must_use] - pub const fn as_ptr(&self) -> *const AsciiChar { - self.as_slice().as_ptr() - } - - /// Returns an unsafe mutable pointer to the `AsciiStr`'s buffer. - /// - /// The caller must ensure that the slice outlives the pointer this function returns, or else it - /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be - /// reallocated, which would also make any pointers to it invalid. - #[inline] - #[must_use] - pub fn as_mut_ptr(&mut self) -> *mut AsciiChar { - self.as_mut_slice().as_mut_ptr() - } - - /// Copies the content of this `AsciiStr` into an owned `AsciiString`. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_string(&self) -> AsciiString { - AsciiString::from(self.slice.to_vec()) - } - - /// Converts anything that can represent a byte slice into an `AsciiStr`. - /// - /// # Errors - /// If `bytes` contains a non-ascii byte, `Err` will be returned - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let foo = AsciiStr::from_ascii(b"foo"); - /// let err = AsciiStr::from_ascii("Ŋ"); - /// assert_eq!(foo.unwrap().as_str(), "foo"); - /// assert_eq!(err.unwrap_err().valid_up_to(), 0); - /// ``` - #[inline] - pub fn from_ascii(bytes: &B) -> Result<&AsciiStr, AsAsciiStrError> - where - B: AsRef<[u8]> + ?Sized, - { - bytes.as_ref().as_ascii_str() - } - - /// Converts anything that can be represented as a byte slice to an `AsciiStr` without checking - /// for non-ASCII characters.. - /// - /// # Safety - /// If any of the bytes in `bytes` do not represent valid ascii characters, calling - /// this function is undefined behavior. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let foo = unsafe { AsciiStr::from_ascii_unchecked(&b"foo"[..]) }; - /// assert_eq!(foo.as_str(), "foo"); - /// ``` - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(bytes: &[u8]) -> &AsciiStr { - // SAFETY: Caller guarantees all bytes in `bytes` are valid - // ascii characters. - unsafe { bytes.as_ascii_str_unchecked() } - } - - /// Returns the number of characters / bytes in this ASCII sequence. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let s = AsciiStr::from_ascii("foo").unwrap(); - /// assert_eq!(s.len(), 3); - /// ``` - #[inline] - #[must_use] - pub const fn len(&self) -> usize { - self.slice.len() - } - - /// Returns true if the ASCII slice contains zero bytes. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let mut empty = AsciiStr::from_ascii("").unwrap(); - /// let mut full = AsciiStr::from_ascii("foo").unwrap(); - /// assert!(empty.is_empty()); - /// assert!(!full.is_empty()); - /// ``` - #[inline] - #[must_use] - pub const fn is_empty(&self) -> bool { - self.len() == 0 - } - - /// Returns an iterator over the characters of the `AsciiStr`. - #[inline] - #[must_use] - pub fn chars(&self) -> Chars { - Chars(self.slice.iter()) - } - - /// Returns an iterator over the characters of the `AsciiStr` which allows you to modify the - /// value of each `AsciiChar`. - #[inline] - #[must_use] - pub fn chars_mut(&mut self) -> CharsMut { - CharsMut(self.slice.iter_mut()) - } - - /// Returns an iterator over parts of the `AsciiStr` separated by a character. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiStr, AsciiChar}; - /// let words = AsciiStr::from_ascii("apple banana lemon").unwrap() - /// .split(AsciiChar::Space) - /// .map(|a| a.as_str()) - /// .collect::>(); - /// assert_eq!(words, ["apple", "banana", "lemon"]); - /// ``` - #[must_use] - pub fn split(&self, on: AsciiChar) -> impl DoubleEndedIterator { - Split { - on, - ended: false, - chars: self.chars(), - } - } - - /// Returns an iterator over the lines of the `AsciiStr`, which are themselves `AsciiStr`s. - /// - /// Lines are ended with either `LineFeed` (`\n`), or `CarriageReturn` then `LineFeed` (`\r\n`). - /// - /// The final line ending is optional. - #[inline] - #[must_use] - pub fn lines(&self) -> impl DoubleEndedIterator { - Lines { string: self } - } - - /// Returns an ASCII string slice with leading and trailing whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!("white \tspace", example.trim()); - /// ``` - #[must_use] - pub fn trim(&self) -> &Self { - self.trim_start().trim_end() - } - - /// Returns an ASCII string slice with leading whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!("white \tspace \t", example.trim_start()); - /// ``` - #[must_use] - pub fn trim_start(&self) -> &Self { - let whitespace_len = self - .chars() - .position(|ch| !ch.is_whitespace()) - .unwrap_or_else(|| self.len()); - - // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice. - unsafe { self.as_slice().get_unchecked(whitespace_len..).into() } - } - - /// Returns an ASCII string slice with trailing whitespace removed. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiStr; - /// let example = AsciiStr::from_ascii(" \twhite \tspace \t").unwrap(); - /// assert_eq!(" \twhite \tspace", example.trim_end()); - /// ``` - #[must_use] - pub fn trim_end(&self) -> &Self { - // Number of whitespace characters counting from the end - let whitespace_len = self - .chars() - .rev() - .position(|ch| !ch.is_whitespace()) - .unwrap_or_else(|| self.len()); - - // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice, and at least `0`, which is the whole slice. - unsafe { - self.as_slice() - .get_unchecked(..self.len() - whitespace_len) - .into() - } - } - - /// Compares two strings case-insensitively. - #[must_use] - pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool { - self.len() == other.len() - && self - .chars() - .zip(other.chars()) - .all(|(ch, other_ch)| ch.eq_ignore_ascii_case(&other_ch)) - } - - /// Replaces lowercase letters with their uppercase equivalent. - pub fn make_ascii_uppercase(&mut self) { - for ch in self.chars_mut() { - *ch = ch.to_ascii_uppercase(); - } - } - - /// Replaces uppercase letters with their lowercase equivalent. - pub fn make_ascii_lowercase(&mut self) { - for ch in self.chars_mut() { - *ch = ch.to_ascii_lowercase(); - } - } - - /// Returns a copy of this string where letters 'a' to 'z' are mapped to 'A' to 'Z'. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_uppercase(&self) -> AsciiString { - let mut ascii_string = self.to_ascii_string(); - ascii_string.make_ascii_uppercase(); - ascii_string - } - - /// Returns a copy of this string where letters 'A' to 'Z' are mapped to 'a' to 'z'. - #[cfg(feature = "alloc")] - #[must_use] - pub fn to_ascii_lowercase(&self) -> AsciiString { - let mut ascii_string = self.to_ascii_string(); - ascii_string.make_ascii_lowercase(); - ascii_string - } - - /// Returns the first character if the string is not empty. - #[inline] - #[must_use] - pub fn first(&self) -> Option { - self.slice.first().copied() - } - - /// Returns the last character if the string is not empty. - #[inline] - #[must_use] - pub fn last(&self) -> Option { - self.slice.last().copied() - } - - /// Converts a [`Box`] into a [`AsciiString`] without copying or allocating. - #[cfg(feature = "alloc")] - #[inline] - #[must_use] - pub fn into_ascii_string(self: Box) -> AsciiString { - let slice = Box::<[AsciiChar]>::from(self); - AsciiString::from(slice.into_vec()) - } -} - -macro_rules! impl_partial_eq { - ($wider: ty) => { - impl PartialEq<$wider> for AsciiStr { - #[inline] - fn eq(&self, other: &$wider) -> bool { - >::as_ref(self) == other - } - } - impl PartialEq for $wider { - #[inline] - fn eq(&self, other: &AsciiStr) -> bool { - self == >::as_ref(other) - } - } - }; -} - -impl_partial_eq! {str} -impl_partial_eq! {[u8]} -impl_partial_eq! {[AsciiChar]} - -#[cfg(feature = "alloc")] -impl ToOwned for AsciiStr { - type Owned = AsciiString; - - #[inline] - fn to_owned(&self) -> AsciiString { - self.to_ascii_string() - } -} - -impl AsRef<[u8]> for AsciiStr { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} -impl AsRef for AsciiStr { - #[inline] - fn as_ref(&self) -> &str { - self.as_str() - } -} -impl AsRef<[AsciiChar]> for AsciiStr { - #[inline] - fn as_ref(&self) -> &[AsciiChar] { - &self.slice - } -} -impl AsMut<[AsciiChar]> for AsciiStr { - #[inline] - fn as_mut(&mut self) -> &mut [AsciiChar] { - &mut self.slice - } -} - -impl Default for &'static AsciiStr { - #[inline] - fn default() -> &'static AsciiStr { - From::from(&[] as &[AsciiChar]) - } -} -impl<'a> From<&'a [AsciiChar]> for &'a AsciiStr { - #[inline] - fn from(slice: &[AsciiChar]) -> &AsciiStr { - let ptr = slice as *const [AsciiChar] as *const AsciiStr; - unsafe { &*ptr } - } -} -impl<'a> From<&'a mut [AsciiChar]> for &'a mut AsciiStr { - #[inline] - fn from(slice: &mut [AsciiChar]) -> &mut AsciiStr { - let ptr = slice as *mut [AsciiChar] as *mut AsciiStr; - unsafe { &mut *ptr } - } -} -#[cfg(feature = "alloc")] -impl From> for Box { - #[inline] - fn from(owned: Box<[AsciiChar]>) -> Box { - let ptr = Box::into_raw(owned) as *mut AsciiStr; - unsafe { Box::from_raw(ptr) } - } -} - -impl AsRef for AsciiStr { - #[inline] - fn as_ref(&self) -> &AsciiStr { - self - } -} -impl AsMut for AsciiStr { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - self - } -} -impl AsRef for [AsciiChar] { - #[inline] - fn as_ref(&self) -> &AsciiStr { - self.into() - } -} -impl AsMut for [AsciiChar] { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - self.into() - } -} - -impl<'a> From<&'a AsciiStr> for &'a [AsciiChar] { - #[inline] - fn from(astr: &AsciiStr) -> &[AsciiChar] { - &astr.slice - } -} -impl<'a> From<&'a mut AsciiStr> for &'a mut [AsciiChar] { - #[inline] - fn from(astr: &mut AsciiStr) -> &mut [AsciiChar] { - &mut astr.slice - } -} -impl<'a> From<&'a AsciiStr> for &'a [u8] { - #[inline] - fn from(astr: &AsciiStr) -> &[u8] { - astr.as_bytes() - } -} -impl<'a> From<&'a AsciiStr> for &'a str { - #[inline] - fn from(astr: &AsciiStr) -> &str { - astr.as_str() - } -} -macro_rules! widen_box { - ($wider: ty) => { - #[cfg(feature = "alloc")] - impl From> for Box<$wider> { - #[inline] - fn from(owned: Box) -> Box<$wider> { - let ptr = Box::into_raw(owned) as *mut $wider; - unsafe { Box::from_raw(ptr) } - } - } - }; -} -widen_box! {[AsciiChar]} -widen_box! {[u8]} -widen_box! {str} - -// allows &AsciiChar to be used by generic AsciiString Extend and FromIterator -impl AsRef for AsciiChar { - fn as_ref(&self) -> &AsciiStr { - slice::from_ref(self).into() - } -} - -impl fmt::Display for AsciiStr { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self.as_str(), f) - } -} - -impl fmt::Debug for AsciiStr { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(self.as_str(), f) - } -} - -macro_rules! impl_index { - ($idx:ty) => { - #[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default - impl Index<$idx> for AsciiStr { - type Output = AsciiStr; - - #[inline] - fn index(&self, index: $idx) -> &AsciiStr { - self.slice[index].as_ref() - } - } - - #[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default - impl IndexMut<$idx> for AsciiStr { - #[inline] - fn index_mut(&mut self, index: $idx) -> &mut AsciiStr { - self.slice[index].as_mut() - } - } - }; -} - -impl_index! { Range } -impl_index! { RangeTo } -impl_index! { RangeFrom } -impl_index! { RangeFull } -impl_index! { RangeInclusive } -impl_index! { RangeToInclusive } - -#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default -impl Index for AsciiStr { - type Output = AsciiChar; - - #[inline] - fn index(&self, index: usize) -> &AsciiChar { - &self.slice[index] - } -} - -#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default -impl IndexMut for AsciiStr { - #[inline] - fn index_mut(&mut self, index: usize) -> &mut AsciiChar { - &mut self.slice[index] - } -} - -/// Produces references for compatibility with `[u8]`. -/// -/// (`str` doesn't implement `IntoIterator` for its references, -/// so there is no compatibility to lose.) -impl<'a> IntoIterator for &'a AsciiStr { - type Item = &'a AsciiChar; - type IntoIter = CharsRef<'a>; - #[inline] - fn into_iter(self) -> Self::IntoIter { - CharsRef(self.as_slice().iter()) - } -} - -impl<'a> IntoIterator for &'a mut AsciiStr { - type Item = &'a mut AsciiChar; - type IntoIter = CharsMut<'a>; - #[inline] - fn into_iter(self) -> Self::IntoIter { - self.chars_mut() - } -} - -/// A copying iterator over the characters of an `AsciiStr`. -#[derive(Clone, Debug)] -pub struct Chars<'a>(Iter<'a, AsciiChar>); -impl<'a> Chars<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn as_str(&self) -> &'a AsciiStr { - self.0.as_slice().into() - } -} -impl<'a> Iterator for Chars<'a> { - type Item = AsciiChar; - #[inline] - fn next(&mut self) -> Option { - self.0.next().copied() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for Chars<'a> { - #[inline] - fn next_back(&mut self) -> Option { - self.0.next_back().copied() - } -} -impl<'a> ExactSizeIterator for Chars<'a> { - fn len(&self) -> usize { - self.0.len() - } -} - -/// A mutable iterator over the characters of an `AsciiStr`. -#[derive(Debug)] -pub struct CharsMut<'a>(IterMut<'a, AsciiChar>); -impl<'a> CharsMut<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn into_str(self) -> &'a mut AsciiStr { - self.0.into_slice().into() - } -} -impl<'a> Iterator for CharsMut<'a> { - type Item = &'a mut AsciiChar; - #[inline] - fn next(&mut self) -> Option<&'a mut AsciiChar> { - self.0.next() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for CharsMut<'a> { - #[inline] - fn next_back(&mut self) -> Option<&'a mut AsciiChar> { - self.0.next_back() - } -} -impl<'a> ExactSizeIterator for CharsMut<'a> { - fn len(&self) -> usize { - self.0.len() - } -} - -/// An immutable iterator over the characters of an `AsciiStr`. -#[derive(Clone, Debug)] -pub struct CharsRef<'a>(Iter<'a, AsciiChar>); -impl<'a> CharsRef<'a> { - /// Returns the ascii string slice with the remaining characters. - #[must_use] - pub fn as_str(&self) -> &'a AsciiStr { - self.0.as_slice().into() - } -} -impl<'a> Iterator for CharsRef<'a> { - type Item = &'a AsciiChar; - #[inline] - fn next(&mut self) -> Option<&'a AsciiChar> { - self.0.next() - } - fn size_hint(&self) -> (usize, Option) { - self.0.size_hint() - } -} -impl<'a> DoubleEndedIterator for CharsRef<'a> { - #[inline] - fn next_back(&mut self) -> Option<&'a AsciiChar> { - self.0.next_back() - } -} - -/// An iterator over parts of an `AsciiStr` separated by an `AsciiChar`. -/// -/// This type is created by [`AsciiChar::split()`](struct.AsciiChar.html#method.split). -#[derive(Clone, Debug)] -struct Split<'a> { - on: AsciiChar, - ended: bool, - chars: Chars<'a>, -} -impl<'a> Iterator for Split<'a> { - type Item = &'a AsciiStr; - - fn next(&mut self) -> Option<&'a AsciiStr> { - if !self.ended { - let start: &AsciiStr = self.chars.as_str(); - let split_on = self.on; - - if let Some(at) = self.chars.position(|ch| ch == split_on) { - // SAFETY: `at` is guaranteed to be in bounds, as `position` returns `Ok(0..len)`. - Some(unsafe { start.as_slice().get_unchecked(..at).into() }) - } else { - self.ended = true; - Some(start) - } - } else { - None - } - } -} -impl<'a> DoubleEndedIterator for Split<'a> { - fn next_back(&mut self) -> Option<&'a AsciiStr> { - if !self.ended { - let start: &AsciiStr = self.chars.as_str(); - let split_on = self.on; - - if let Some(at) = self.chars.rposition(|ch| ch == split_on) { - // SAFETY: `at` is guaranteed to be in bounds, as `rposition` returns `Ok(0..len)`, and slices `1..`, `2..`, etc... until `len..` inclusive, are valid. - Some(unsafe { start.as_slice().get_unchecked(at + 1..).into() }) - } else { - self.ended = true; - Some(start) - } - } else { - None - } - } -} - -/// An iterator over the lines of the internal character array. -#[derive(Clone, Debug)] -struct Lines<'a> { - string: &'a AsciiStr, -} -impl<'a> Iterator for Lines<'a> { - type Item = &'a AsciiStr; - - fn next(&mut self) -> Option<&'a AsciiStr> { - if let Some(idx) = self - .string - .chars() - .position(|chr| chr == AsciiChar::LineFeed) - { - // SAFETY: `idx` is guaranteed to be `1..len`, as we get it from `position` as `0..len` and make sure it's not `0`. - let line = if idx > 0 - && *unsafe { self.string.as_slice().get_unchecked(idx - 1) } - == AsciiChar::CarriageReturn - { - // SAFETY: As per above, `idx` is guaranteed to be `1..len` - unsafe { self.string.as_slice().get_unchecked(..idx - 1).into() } - } else { - // SAFETY: As per above, `idx` is guaranteed to be `0..len` - unsafe { self.string.as_slice().get_unchecked(..idx).into() } - }; - // SAFETY: As per above, `idx` is guaranteed to be `0..len`, so at the extreme, slicing `len..` is a valid empty slice. - self.string = unsafe { self.string.as_slice().get_unchecked(idx + 1..).into() }; - Some(line) - } else if self.string.is_empty() { - None - } else { - let line = self.string; - // SAFETY: An empty string is a valid string. - self.string = unsafe { AsciiStr::from_ascii_unchecked(b"") }; - Some(line) - } - } -} - -impl<'a> DoubleEndedIterator for Lines<'a> { - fn next_back(&mut self) -> Option<&'a AsciiStr> { - if self.string.is_empty() { - return None; - } - - // If we end with `LF` / `CR/LF`, remove them - if let Some(AsciiChar::LineFeed) = self.string.last() { - // SAFETY: `last()` returned `Some`, so our len is at least 1. - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - 1) - .into() - }; - - if let Some(AsciiChar::CarriageReturn) = self.string.last() { - // SAFETY: `last()` returned `Some`, so our len is at least 1. - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - 1) - .into() - }; - } - } - - // Get the position of the first `LF` from the end. - let lf_rev_pos = self - .string - .chars() - .rev() - .position(|ch| ch == AsciiChar::LineFeed) - .unwrap_or_else(|| self.string.len()); - - // SAFETY: `lf_rev_pos` will be in range `0..=len`, so `len - lf_rev_pos` - // will be within `0..=len`, making it correct as a start and end - // point for the strings. - let line = unsafe { - self.string - .as_slice() - .get_unchecked(self.string.len() - lf_rev_pos..) - .into() - }; - self.string = unsafe { - self.string - .as_slice() - .get_unchecked(..self.string.len() - lf_rev_pos) - .into() - }; - Some(line) - } -} - -/// Error that is returned when a sequence of `u8` are not all ASCII. -/// -/// Is used by `As[Mut]AsciiStr` and the `from_ascii` method on `AsciiStr` and `AsciiString`. -#[derive(Clone, Copy, PartialEq, Eq, Debug)] -pub struct AsAsciiStrError(usize); - -const ERRORMSG_STR: &str = "one or more bytes are not ASCII"; - -impl AsAsciiStrError { - /// Returns the index of the first non-ASCII byte. - /// - /// It is the maximum index such that `from_ascii(input[..index])` would return `Ok(_)`. - #[inline] - #[must_use] - pub const fn valid_up_to(self) -> usize { - self.0 - } - #[cfg(not(feature = "std"))] - /// Returns a description for this error, like `std::error::Error::description`. - #[inline] - #[must_use] - #[allow(clippy::unused_self)] - pub const fn description(&self) -> &'static str { - ERRORMSG_STR - } -} -impl fmt::Display for AsAsciiStrError { - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - write!(fmtr, "the byte at index {} is not ASCII", self.0) - } -} -#[cfg(feature = "std")] -impl Error for AsAsciiStrError { - #[inline] - fn description(&self) -> &'static str { - ERRORMSG_STR - } -} - -/// Convert slices of bytes or [`AsciiChar`] to [`AsciiStr`]. -// Could nearly replace this trait with SliceIndex, but its methods isn't even -// on a path for stabilization. -pub trait AsAsciiStr { - /// Used to constrain `SliceIndex` - #[doc(hidden)] - type Inner; - /// Convert a subslice to an ASCII slice. - /// - /// # Errors - /// Returns `Err` if the range is out of bounds or if not all bytes in the - /// slice are ASCII. The value in the error will be the index of the first - /// non-ASCII byte or the end of the slice. - /// - /// # Examples - /// ``` - /// use ascii::AsAsciiStr; - /// assert!("'zoä'".slice_ascii(..3).is_ok()); - /// assert!("'zoä'".slice_ascii(0..4).is_err()); - /// assert!("'zoä'".slice_ascii(5..=5).is_ok()); - /// assert!("'zoä'".slice_ascii(4..).is_err()); - /// assert!(b"\r\n".slice_ascii(..).is_ok()); - /// ``` - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>; - /// Convert to an ASCII slice. - /// - /// # Errors - /// Returns `Err` if not all bytes are valid ascii values. - /// - /// # Example - /// ``` - /// use ascii::{AsAsciiStr, AsciiChar}; - /// assert!("ASCII".as_ascii_str().is_ok()); - /// assert!(b"\r\n".as_ascii_str().is_ok()); - /// assert!("'zoä'".as_ascii_str().is_err()); - /// assert!(b"\xff".as_ascii_str().is_err()); - /// assert!([AsciiChar::C][..].as_ascii_str().is_ok()); // infallible - /// ``` - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.slice_ascii(..) - } - /// Get a single ASCII character from the slice. - /// - /// Returns `None` if the index is out of bounds or the byte is not ASCII. - /// - /// # Examples - /// ``` - /// use ascii::{AsAsciiStr, AsciiChar}; - /// assert_eq!("'zoä'".get_ascii(4), None); - /// assert_eq!("'zoä'".get_ascii(5), Some(AsciiChar::Apostrophe)); - /// assert_eq!("'zoä'".get_ascii(6), None); - /// ``` - fn get_ascii(&self, index: usize) -> Option { - self.slice_ascii(index..=index) - .ok() - .and_then(AsciiStr::first) - } - /// Convert to an ASCII slice without checking for non-ASCII characters. - /// - /// # Safety - /// Calling this function when `self` contains non-ascii characters is - /// undefined behavior. - /// - /// # Examples - /// - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr; -} - -/// Convert mutable slices of bytes or [`AsciiChar`] to [`AsciiStr`]. -pub trait AsMutAsciiStr: AsAsciiStr { - /// Convert a subslice to an ASCII slice. - /// - /// # Errors - /// This function returns `Err` if range is out of bounds, or if - /// `self` contains non-ascii values - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>; - - /// Convert to a mutable ASCII slice. - /// - /// # Errors - /// This function returns `Err` if `self` contains non-ascii values - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - self.slice_ascii_mut(..) - } - - /// Convert to a mutable ASCII slice without checking for non-ASCII characters. - /// - /// # Safety - /// Calling this function when `self` contains non-ascii characters is - /// undefined behavior. - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr; -} - -// These generic implementations mirror the generic implementations for AsRef in core. -impl<'a, T> AsAsciiStr for &'a T -where - T: AsAsciiStr + ?Sized, -{ - type Inner = ::Inner; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii(*self, range) - } - - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_ascii_str_unchecked(*self) } - } -} - -impl<'a, T> AsAsciiStr for &'a mut T -where - T: AsAsciiStr + ?Sized, -{ - type Inner = ::Inner; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii(*self, range) - } - - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_ascii_str_unchecked(*self) } - } -} - -impl<'a, T> AsMutAsciiStr for &'a mut T -where - T: AsMutAsciiStr + ?Sized, -{ - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[Self::Inner], Output = [Self::Inner]>, - { - ::slice_ascii_mut(*self, range) - } - - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { ::as_mut_ascii_str_unchecked(*self) } - } -} - -impl AsAsciiStr for AsciiStr { - type Inner = AsciiChar; - - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - self.slice.slice_ascii(range) - } - - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - Ok(self) - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - self - } - - #[inline] - fn get_ascii(&self, index: usize) -> Option { - self.slice.get_ascii(index) - } -} -impl AsMutAsciiStr for AsciiStr { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - self.slice.slice_ascii_mut(range) - } - - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - self - } -} - -impl AsAsciiStr for [AsciiChar] { - type Inner = AsciiChar; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - match self.get(range) { - Some(slice) => Ok(slice.into()), - None => Err(AsAsciiStrError(self.len())), - } - } - - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - Ok(self.into()) - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - <&AsciiStr>::from(self) - } - - #[inline] - fn get_ascii(&self, index: usize) -> Option { - self.get(index).copied() - } -} -impl AsMutAsciiStr for [AsciiChar] { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[AsciiChar], Output = [AsciiChar]>, - { - let len = self.len(); - match self.get_mut(range) { - Some(slice) => Ok(slice.into()), - None => Err(AsAsciiStrError(len)), - } - } - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - <&mut AsciiStr>::from(self) - } -} - -impl AsAsciiStr for [u8] { - type Inner = u8; - - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - if let Some(slice) = self.get(range) { - slice.as_ascii_str().map_err(|AsAsciiStrError(not_ascii)| { - let offset = slice.as_ptr() as usize - self.as_ptr() as usize; - AsAsciiStrError(offset + not_ascii) - }) - } else { - Err(AsAsciiStrError(self.len())) - } - } - - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - // is_ascii is likely optimized - if self.is_ascii() { - // SAFETY: `is_ascii` guarantees all bytes are within ascii range. - unsafe { Ok(self.as_ascii_str_unchecked()) } - } else { - Err(AsAsciiStrError( - self.iter().take_while(|&b| b.is_ascii()).count(), - )) - } - } - - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { &*(self as *const [u8] as *const AsciiStr) } - } -} -impl AsMutAsciiStr for [u8] { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - let (ptr, len) = (self.as_ptr(), self.len()); - if let Some(slice) = self.get_mut(range) { - let slice_ptr = slice.as_ptr(); - slice - .as_mut_ascii_str() - .map_err(|AsAsciiStrError(not_ascii)| { - let offset = slice_ptr as usize - ptr as usize; - AsAsciiStrError(offset + not_ascii) - }) - } else { - Err(AsAsciiStrError(len)) - } - } - - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - // is_ascii() is likely optimized - if self.is_ascii() { - // SAFETY: `is_ascii` guarantees all bytes are within ascii range. - unsafe { Ok(self.as_mut_ascii_str_unchecked()) } - } else { - Err(AsAsciiStrError( - self.iter().take_while(|&b| b.is_ascii()).count(), - )) - } - } - - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { &mut *(self as *mut [u8] as *mut AsciiStr) } - } -} - -impl AsAsciiStr for str { - type Inner = u8; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - self.as_bytes().slice_ascii(range) - } - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.as_bytes().as_ascii_str() - } - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { self.as_bytes().as_ascii_str_unchecked() } - } -} -impl AsMutAsciiStr for str { - fn slice_ascii_mut(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - // SAFETY: We don't modify the reference in this function, and the caller may - // only modify it to include valid ascii characters. - let bytes = unsafe { self.as_bytes_mut() }; - match bytes.get_mut(range) { - // Valid ascii slice - Some(slice) if slice.is_ascii() => { - // SAFETY: All bytes are ascii, so this cast is valid - let ptr = slice.as_mut_ptr().cast::(); - let len = slice.len(); - - // SAFETY: The pointer is valid for `len` elements, as it came - // from a slice. - unsafe { - let slice = core::slice::from_raw_parts_mut(ptr, len); - Ok(<&mut AsciiStr>::from(slice)) - } - } - Some(slice) => { - let not_ascii_len = slice.iter().copied().take_while(u8::is_ascii).count(); - let offset = slice.as_ptr() as usize - self.as_ptr() as usize; - - Err(AsAsciiStrError(offset + not_ascii_len)) - } - None => Err(AsAsciiStrError(self.len())), - } - } - fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> { - match self.bytes().position(|b| !b.is_ascii()) { - Some(index) => Err(AsAsciiStrError(index)), - // SAFETY: All bytes were iterated, and all were ascii - None => unsafe { Ok(self.as_mut_ascii_str_unchecked()) }, - } - } - #[inline] - unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - &mut *(self as *mut str as *mut AsciiStr) - } -} - -/// Note that the trailing null byte will be removed in the conversion. -#[cfg(feature = "std")] -impl AsAsciiStr for CStr { - type Inner = u8; - fn slice_ascii(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> - where - R: SliceIndex<[u8], Output = [u8]>, - { - self.to_bytes().slice_ascii(range) - } - #[inline] - fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> { - self.to_bytes().as_ascii_str() - } - #[inline] - unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr { - // SAFETY: Caller guarantees `self` does not contain non-ascii characters - unsafe { self.to_bytes().as_ascii_str_unchecked() } - } -} - -#[cfg(test)] -mod tests { - use super::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr}; - #[cfg(feature = "alloc")] - use alloc::string::{String, ToString}; - #[cfg(feature = "alloc")] - use alloc::vec::Vec; - use AsciiChar; - - /// Ensures that common types, `str`, `[u8]`, `AsciiStr` and their - /// references, shared and mutable implement `AsAsciiStr`. - #[test] - fn generic_as_ascii_str() { - // Generic function to ensure `C` implements `AsAsciiStr` - fn generic(c: &C) -> Result<&AsciiStr, AsAsciiStrError> { - c.as_ascii_str() - } - - let arr = [AsciiChar::A]; - let ascii_str = arr.as_ref().into(); - let mut mut_arr = arr; // Note: We need a second copy to prevent overlapping mutable borrows. - let mut_ascii_str = mut_arr.as_mut().into(); - let mut_arr_mut_ref: &mut [AsciiChar] = &mut [AsciiChar::A]; - let mut string_bytes = [b'A']; - let string_mut = unsafe { core::str::from_utf8_unchecked_mut(&mut string_bytes) }; // SAFETY: 'A' is a valid string. - let string_mut_bytes: &mut [u8] = &mut [b'A']; - - // Note: This is a trick because `rustfmt` doesn't support - // attributes on blocks yet. - #[rustfmt::skip] - let _ = [ - assert_eq!(generic::("A" ), Ok(ascii_str)), - assert_eq!(generic::<[u8] >(&b"A"[..] ), Ok(ascii_str)), - assert_eq!(generic::(ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<[AsciiChar] >(&arr ), Ok(ascii_str)), - assert_eq!(generic::<&str >(&"A" ), Ok(ascii_str)), - assert_eq!(generic::<&[u8] >(&&b"A"[..] ), Ok(ascii_str)), - assert_eq!(generic::<&AsciiStr >(&ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<&[AsciiChar] >(&&arr[..] ), Ok(ascii_str)), - assert_eq!(generic::<&mut str >(&string_mut ), Ok(ascii_str)), - assert_eq!(generic::<&mut [u8] >(&string_mut_bytes), Ok(ascii_str)), - assert_eq!(generic::<&mut AsciiStr >(&mut_ascii_str ), Ok(ascii_str)), - assert_eq!(generic::<&mut [AsciiChar]>(&mut_arr_mut_ref ), Ok(ascii_str)), - ]; - } - - #[cfg(feature = "std")] - #[test] - fn cstring_as_ascii_str() { - use std::ffi::CString; - fn generic(c: &C) -> Result<&AsciiStr, AsAsciiStrError> { - c.as_ascii_str() - } - let arr = [AsciiChar::A]; - let ascii_str: &AsciiStr = arr.as_ref().into(); - let cstr = CString::new("A").unwrap(); - assert_eq!(generic(&*cstr), Ok(ascii_str)); - } - - #[test] - fn generic_as_mut_ascii_str() { - fn generic_mut( - c: &mut C, - ) -> Result<&mut AsciiStr, AsAsciiStrError> { - c.as_mut_ascii_str() - } - - let mut arr_mut = [AsciiChar::B]; - let mut ascii_str_mut: &mut AsciiStr = arr_mut.as_mut().into(); - // Need a second reference to prevent overlapping mutable borrows - let mut arr_mut_2 = [AsciiChar::B]; - let ascii_str_mut_2: &mut AsciiStr = arr_mut_2.as_mut().into(); - assert_eq!(generic_mut(&mut ascii_str_mut), Ok(&mut *ascii_str_mut_2)); - assert_eq!(generic_mut(ascii_str_mut), Ok(&mut *ascii_str_mut_2)); - } - - #[test] - fn as_ascii_str() { - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let s = "abčd"; - let b = s.as_bytes(); - assert_eq!(s.as_ascii_str(), err!(2)); - assert_eq!(b.as_ascii_str(), err!(2)); - let a: &AsciiStr = [AsciiChar::a, AsciiChar::b][..].as_ref(); - assert_eq!(s[..2].as_ascii_str(), Ok(a)); - assert_eq!(b[..2].as_ascii_str(), Ok(a)); - assert_eq!(s.slice_ascii(..2), Ok(a)); - assert_eq!(b.slice_ascii(..2), Ok(a)); - assert_eq!(s.slice_ascii(..=2), err!(2)); - assert_eq!(b.slice_ascii(..=2), err!(2)); - assert_eq!(s.get_ascii(4), Some(AsciiChar::d)); - assert_eq!(b.get_ascii(4), Some(AsciiChar::d)); - assert_eq!(s.get_ascii(3), None); - assert_eq!(b.get_ascii(3), None); - assert_eq!(s.get_ascii(b.len()), None); - assert_eq!(b.get_ascii(b.len()), None); - assert_eq!(a.get_ascii(0), Some(AsciiChar::a)); - assert_eq!(a.get_ascii(a.len()), None); - } - - #[test] - #[cfg(feature = "std")] - fn cstr_as_ascii_str() { - use std::ffi::CStr; - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let cstr = CStr::from_bytes_with_nul(b"a\xbbcde\xffg\0").unwrap(); - assert_eq!(cstr.as_ascii_str(), err!(1)); - assert_eq!(cstr.slice_ascii(2..), err!(5)); - assert_eq!(cstr.get_ascii(5), None); - assert_eq!(cstr.get_ascii(6), Some(AsciiChar::g)); - assert_eq!(cstr.get_ascii(7), None); - let ascii_slice = &[AsciiChar::X, AsciiChar::Y, AsciiChar::Z, AsciiChar::Null][..]; - let ascii_str: &AsciiStr = ascii_slice.as_ref(); - let cstr = CStr::from_bytes_with_nul(ascii_str.as_bytes()).unwrap(); - assert_eq!(cstr.slice_ascii(..2), Ok(&ascii_str[..2])); - assert_eq!(cstr.as_ascii_str(), Ok(&ascii_str[..3])); - } - - #[test] - #[cfg(feature = "alloc")] - fn as_mut_ascii_str() { - macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}} - let mut s: String = "abčd".to_string(); - let mut b: Vec = s.clone().into(); - let mut first = [AsciiChar::a, AsciiChar::b]; - let mut second = [AsciiChar::d]; - assert_eq!(s.as_mut_ascii_str(), err!(2)); - assert_eq!(b.as_mut_ascii_str(), err!(2)); - assert_eq!(s.slice_ascii_mut(..), err!(2)); - assert_eq!(b.slice_ascii_mut(..), err!(2)); - assert_eq!(s[..2].as_mut_ascii_str(), Ok((&mut first[..]).into())); - assert_eq!(b[..2].as_mut_ascii_str(), Ok((&mut first[..]).into())); - assert_eq!(s.slice_ascii_mut(0..2), Ok((&mut first[..]).into())); - assert_eq!(b.slice_ascii_mut(0..2), Ok((&mut first[..]).into())); - assert_eq!(s.slice_ascii_mut(4..), Ok((&mut second[..]).into())); - assert_eq!(b.slice_ascii_mut(4..), Ok((&mut second[..]).into())); - assert_eq!(s.slice_ascii_mut(4..=10), err!(5)); - assert_eq!(b.slice_ascii_mut(4..=10), err!(5)); - } - - #[test] - fn default() { - let default: &'static AsciiStr = Default::default(); - assert!(default.is_empty()); - } - - #[test] - #[allow(clippy::redundant_slicing)] - fn index() { - let mut arr = [AsciiChar::A, AsciiChar::B, AsciiChar::C, AsciiChar::D]; - { - let a: &AsciiStr = arr[..].into(); - assert_eq!(a[..].as_slice(), &a.as_slice()[..]); - assert_eq!(a[..4].as_slice(), &a.as_slice()[..4]); - assert_eq!(a[4..].as_slice(), &a.as_slice()[4..]); - assert_eq!(a[2..3].as_slice(), &a.as_slice()[2..3]); - assert_eq!(a[..=3].as_slice(), &a.as_slice()[..=3]); - assert_eq!(a[1..=1].as_slice(), &a.as_slice()[1..=1]); - } - let mut copy = arr; - let a_mut: &mut AsciiStr = { &mut arr[..] }.into(); - assert_eq!(a_mut[..].as_mut_slice(), &mut copy[..]); - assert_eq!(a_mut[..2].as_mut_slice(), &mut copy[..2]); - assert_eq!(a_mut[3..].as_mut_slice(), &mut copy[3..]); - assert_eq!(a_mut[4..4].as_mut_slice(), &mut copy[4..4]); - assert_eq!(a_mut[..=0].as_mut_slice(), &mut copy[..=0]); - assert_eq!(a_mut[0..=2].as_mut_slice(), &mut copy[0..=2]); - } - - #[test] - fn as_str() { - let b = b"( ;"; - let v = AsciiStr::from_ascii(b).unwrap(); - assert_eq!(v.as_str(), "( ;"); - assert_eq!(AsRef::::as_ref(v), "( ;"); - } - - #[test] - fn as_bytes() { - let b = b"( ;"; - let v = AsciiStr::from_ascii(b).unwrap(); - assert_eq!(v.as_bytes(), b"( ;"); - assert_eq!(AsRef::<[u8]>::as_ref(v), b"( ;"); - } - - #[test] - fn make_ascii_case() { - let mut bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']); - let a = bytes.0.as_mut_ascii_str().unwrap(); - let b = bytes.1.as_mut_ascii_str().unwrap(); - assert!(a.eq_ignore_ascii_case(b)); - assert!(b.eq_ignore_ascii_case(a)); - a.make_ascii_lowercase(); - b.make_ascii_uppercase(); - assert_eq!(a, "a@a"); - assert_eq!(b, "A@A"); - } - - #[test] - #[cfg(feature = "alloc")] - fn to_ascii_case() { - let bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']); - let a = bytes.0.as_ascii_str().unwrap(); - let b = bytes.1.as_ascii_str().unwrap(); - assert_eq!(a.to_ascii_lowercase().as_str(), "a@a"); - assert_eq!(a.to_ascii_uppercase().as_str(), "A@A"); - assert_eq!(b.to_ascii_lowercase().as_str(), "a@a"); - assert_eq!(b.to_ascii_uppercase().as_str(), "A@A"); - } - - #[test] - fn chars_iter() { - let chars = &[ - b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0', - ]; - let ascii = AsciiStr::from_ascii(chars).unwrap(); - for (achar, byte) in ascii.chars().zip(chars.iter().copied()) { - assert_eq!(achar, byte); - } - } - - #[test] - fn chars_iter_mut() { - let chars = &mut [ - b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0', - ]; - let ascii = chars.as_mut_ascii_str().unwrap(); - *ascii.chars_mut().next().unwrap() = AsciiChar::H; - assert_eq!(ascii[0], b'H'); - } - - #[test] - fn lines_iter() { - use core::iter::Iterator; - - let lines: [&str; 4] = ["foo", "bar", "", "baz"]; - let joined = "foo\r\nbar\n\nbaz\n"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - for (asciiline, line) in ascii.lines().zip(&lines) { - assert_eq!(asciiline, *line); - } - assert_eq!(ascii.lines().count(), lines.len()); - - let lines: [&str; 4] = ["foo", "bar", "", "baz"]; - let joined = "foo\r\nbar\n\nbaz"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - for (asciiline, line) in ascii.lines().zip(&lines) { - assert_eq!(asciiline, *line); - } - assert_eq!(ascii.lines().count(), lines.len()); - - let trailing_line_break = b"\n"; - let ascii = AsciiStr::from_ascii(&trailing_line_break).unwrap(); - let mut line_iter = ascii.lines(); - assert_eq!(line_iter.next(), Some(AsciiStr::from_ascii("").unwrap())); - assert_eq!(line_iter.next(), None); - - let empty_lines = b"\n\r\n\n\r\n"; - let mut iter_count = 0; - let ascii = AsciiStr::from_ascii(&empty_lines).unwrap(); - for line in ascii.lines() { - iter_count += 1; - assert!(line.is_empty()); - } - assert_eq!(4, iter_count); - } - - #[test] - fn lines_iter_rev() { - let joined = "foo\r\nbar\n\nbaz\n"; - let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap(); - assert_eq!(ascii.lines().rev().count(), 4); - assert_eq!(ascii.lines().rev().count(), joined.lines().rev().count()); - for (asciiline, line) in ascii.lines().rev().zip(joined.lines().rev()) { - assert_eq!(asciiline, line); - } - let mut iter = ascii.lines(); - assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("bar".as_ascii_str().unwrap())); - - let empty_lines = b"\n\r\n\n\r\n"; - let mut iter_count = 0; - let ascii = AsciiStr::from_ascii(&empty_lines).unwrap(); - for line in ascii.lines().rev() { - iter_count += 1; - assert!(line.is_empty()); - } - assert_eq!(4, iter_count); - } - - #[test] - fn lines_iter_empty() { - assert_eq!("".as_ascii_str().unwrap().lines().next(), None); - assert_eq!("".as_ascii_str().unwrap().lines().next_back(), None); - assert_eq!("".lines().next(), None); - } - - #[test] - fn split_str() { - fn split_equals_str(haystack: &str, needle: char) { - let mut strs = haystack.split(needle); - let mut asciis = haystack - .as_ascii_str() - .unwrap() - .split(AsciiChar::from_ascii(needle).unwrap()) - .map(AsciiStr::as_str); - loop { - assert_eq!(asciis.size_hint(), strs.size_hint()); - let (a, s) = (asciis.next(), strs.next()); - assert_eq!(a, s); - if a == None { - break; - } - } - // test fusedness if str's version is fused - if strs.next() == None { - assert_eq!(asciis.next(), None); - } - } - split_equals_str("", '='); - split_equals_str("1,2,3", ','); - split_equals_str("foo;bar;baz;", ';'); - split_equals_str("|||", '|'); - split_equals_str(" a b c ", ' '); - } - - #[test] - fn split_str_rev() { - let words = " foo bar baz "; - let ascii = words.as_ascii_str().unwrap(); - for (word, asciiword) in words - .split(' ') - .rev() - .zip(ascii.split(AsciiChar::Space).rev()) - { - assert_eq!(asciiword, word); - } - let mut iter = ascii.split(AsciiChar::Space); - assert_eq!(iter.next(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), Some("bar".as_ascii_str().unwrap())); - assert_eq!(iter.next(), Some("".as_ascii_str().unwrap())); - assert_eq!(iter.next_back(), None); - } - - #[test] - fn split_str_empty() { - let empty = <&AsciiStr>::default(); - let mut iter = empty.split(AsciiChar::NAK); - assert_eq!(iter.next(), Some(empty)); - assert_eq!(iter.next(), None); - let mut iter = empty.split(AsciiChar::NAK); - assert_eq!(iter.next_back(), Some(empty)); - assert_eq!(iter.next_back(), None); - assert_eq!("".split('s').next(), Some("")); // str.split() also produces one element - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii_str() { - let s = "abc".as_ascii_str().unwrap(); - assert_eq!(format!("{}", s), "abc".to_string()); - assert_eq!(format!("{:?}", s), "\"abc\"".to_string()); - } -} diff --git a/anneal/vendor/ascii/src/ascii_string.rs b/anneal/vendor/ascii/src/ascii_string.rs deleted file mode 100644 index 4cb6a17356..0000000000 --- a/anneal/vendor/ascii/src/ascii_string.rs +++ /dev/null @@ -1,1057 +0,0 @@ -use alloc::borrow::{Borrow, BorrowMut, Cow, ToOwned}; -use alloc::fmt; -use alloc::string::String; -use alloc::vec::Vec; -use alloc::boxed::Box; -use alloc::rc::Rc; -use alloc::sync::Arc; -#[cfg(feature = "std")] -use core::any::Any; -use core::iter::FromIterator; -use core::mem; -use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut}; -use core::str::FromStr; -#[cfg(feature = "std")] -use std::error::Error; -#[cfg(feature = "std")] -use std::ffi::{CStr, CString}; - -use ascii_char::AsciiChar; -use ascii_str::{AsAsciiStr, AsAsciiStrError, AsciiStr}; - -/// A growable string stored as an ASCII encoded buffer. -#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[repr(transparent)] -pub struct AsciiString { - vec: Vec, -} - -impl AsciiString { - /// Creates a new, empty ASCII string buffer without allocating. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// ``` - #[inline] - #[must_use] - pub const fn new() -> Self { - AsciiString { vec: Vec::new() } - } - - /// Creates a new ASCII string buffer with the given capacity. - /// The string will be able to hold exactly `capacity` bytes without reallocating. - /// If `capacity` is 0, the ASCII string will not allocate. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::with_capacity(10); - /// ``` - #[inline] - #[must_use] - pub fn with_capacity(capacity: usize) -> Self { - AsciiString { - vec: Vec::with_capacity(capacity), - } - } - - /// Creates a new `AsciiString` from a length, capacity and pointer. - /// - /// # Safety - /// - /// This is highly unsafe, due to the number of invariants that aren't checked: - /// - /// * The memory at `buf` need to have been previously allocated by the same allocator this - /// library uses, with an alignment of 1. - /// * `length` needs to be less than or equal to `capacity`. - /// * `capacity` needs to be the correct value. - /// * `buf` must have `length` valid ascii elements and contain a total of `capacity` total, - /// possibly, uninitialized, elements. - /// * Nothing else must be using the memory `buf` points to. - /// - /// Violating these may cause problems like corrupting the allocator's internal data structures. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use ascii::AsciiString; - /// use std::mem; - /// - /// unsafe { - /// let mut s = AsciiString::from_ascii("hello").unwrap(); - /// let ptr = s.as_mut_ptr(); - /// let len = s.len(); - /// let capacity = s.capacity(); - /// - /// mem::forget(s); - /// - /// let s = AsciiString::from_raw_parts(ptr, len, capacity); - /// - /// assert_eq!(AsciiString::from_ascii("hello").unwrap(), s); - /// } - /// ``` - #[inline] - #[must_use] - pub unsafe fn from_raw_parts(buf: *mut AsciiChar, length: usize, capacity: usize) -> Self { - AsciiString { - // SAFETY: Caller guarantees that `buf` was previously allocated by this library, - // that `buf` contains `length` valid ascii elements and has a total capacity - // of `capacity` elements, and that nothing else is using the momory. - vec: unsafe { Vec::from_raw_parts(buf, length, capacity) }, - } - } - - /// Converts a vector of bytes to an `AsciiString` without checking for non-ASCII characters. - /// - /// # Safety - /// This function is unsafe because it does not check that the bytes passed to it are valid - /// ASCII characters. If this constraint is violated, it may cause memory unsafety issues with - /// future of the `AsciiString`, as the rest of this library assumes that `AsciiString`s are - /// ASCII encoded. - #[inline] - #[must_use] - pub unsafe fn from_ascii_unchecked(bytes: B) -> Self - where - B: Into>, - { - let mut bytes = bytes.into(); - // SAFETY: The caller guarantees all bytes are valid ascii bytes. - let ptr = bytes.as_mut_ptr().cast::(); - let length = bytes.len(); - let capacity = bytes.capacity(); - mem::forget(bytes); - - // SAFETY: We guarantee all invariants, as we got the - // pointer, length and capacity from a `Vec`, - // and we also guarantee the pointer is valid per - // the `SAFETY` notice above. - let vec = Vec::from_raw_parts(ptr, length, capacity); - - Self { vec } - } - - /// Converts anything that can represent a byte buffer into an `AsciiString`. - /// - /// # Errors - /// Returns the byte buffer if not all of the bytes are ASCII characters. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let foo = AsciiString::from_ascii("foo".to_string()).unwrap(); - /// let err = AsciiString::from_ascii("Ŋ".to_string()).unwrap_err(); - /// assert_eq!(foo.as_str(), "foo"); - /// assert_eq!(err.into_source(), "Ŋ"); - /// ``` - pub fn from_ascii(bytes: B) -> Result> - where - B: Into> + AsRef<[u8]>, - { - match bytes.as_ref().as_ascii_str() { - // SAFETY: `as_ascii_str` guarantees all bytes are valid ascii bytes. - Ok(_) => Ok(unsafe { AsciiString::from_ascii_unchecked(bytes) }), - Err(e) => Err(FromAsciiError { - error: e, - owner: bytes, - }), - } - } - - /// Pushes the given ASCII string onto this ASCII string buffer. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString, AsAsciiStr}; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("foo").unwrap(); - /// s.push_str("bar".as_ascii_str().unwrap()); - /// assert_eq!(s, "foobar".as_ascii_str().unwrap()); - /// ``` - #[inline] - pub fn push_str(&mut self, string: &AsciiStr) { - self.vec.extend(string.chars()); - } - - /// Inserts the given ASCII string at the given place in this ASCII string buffer. - /// - /// # Panics - /// - /// Panics if `idx` is larger than the `AsciiString`'s length. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString, AsAsciiStr}; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("abc").unwrap(); - /// s.insert_str(1, "def".as_ascii_str().unwrap()); - /// assert_eq!(&*s, "adefbc"); - #[inline] - pub fn insert_str(&mut self, idx: usize, string: &AsciiStr) { - self.vec.reserve(string.len()); - self.vec.splice(idx..idx, string.into_iter().copied()); - } - - /// Returns the number of bytes that this ASCII string buffer can hold without reallocating. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let s = String::with_capacity(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - #[must_use] - pub fn capacity(&self) -> usize { - self.vec.capacity() - } - - /// Reserves capacity for at least `additional` more bytes to be inserted in the given - /// `AsciiString`. The collection may reserve more space to avoid frequent reallocations. - /// - /// # Panics - /// Panics if the new capacity overflows `usize`. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// s.reserve(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - pub fn reserve(&mut self, additional: usize) { - self.vec.reserve(additional); - } - - /// Reserves the minimum capacity for exactly `additional` more bytes to be inserted in the - /// given `AsciiString`. Does nothing if the capacity is already sufficient. - /// - /// Note that the allocator may give the collection more space than it requests. Therefore - /// capacity can not be relied upon to be precisely minimal. Prefer `reserve` if future - /// insertions are expected. - /// - /// # Panics - /// Panics if the new capacity overflows `usize`. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::new(); - /// s.reserve_exact(10); - /// assert!(s.capacity() >= 10); - /// ``` - #[inline] - - pub fn reserve_exact(&mut self, additional: usize) { - self.vec.reserve_exact(additional); - } - - /// Shrinks the capacity of this ASCII string buffer to match it's length. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// use std::str::FromStr; - /// let mut s = AsciiString::from_str("foo").unwrap(); - /// s.reserve(100); - /// assert!(s.capacity() >= 100); - /// s.shrink_to_fit(); - /// assert_eq!(s.capacity(), 3); - /// ``` - #[inline] - - pub fn shrink_to_fit(&mut self) { - self.vec.shrink_to_fit(); - } - - /// Adds the given ASCII character to the end of the ASCII string. - /// - /// # Examples - /// ``` - /// # use ascii::{ AsciiChar, AsciiString}; - /// let mut s = AsciiString::from_ascii("abc").unwrap(); - /// s.push(AsciiChar::from_ascii('1').unwrap()); - /// s.push(AsciiChar::from_ascii('2').unwrap()); - /// s.push(AsciiChar::from_ascii('3').unwrap()); - /// assert_eq!(s, "abc123"); - /// ``` - #[inline] - - pub fn push(&mut self, ch: AsciiChar) { - self.vec.push(ch); - } - - /// Shortens a ASCII string to the specified length. - /// - /// # Panics - /// Panics if `new_len` > current length. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("hello").unwrap(); - /// s.truncate(2); - /// assert_eq!(s, "he"); - /// ``` - #[inline] - - pub fn truncate(&mut self, new_len: usize) { - self.vec.truncate(new_len); - } - - /// Removes the last character from the ASCII string buffer and returns it. - /// Returns `None` if this string buffer is empty. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o')); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o')); - /// assert_eq!(s.pop().map(|c| c.as_char()), Some('f')); - /// assert_eq!(s.pop(), None); - /// ``` - #[inline] - #[must_use] - pub fn pop(&mut self) -> Option { - self.vec.pop() - } - - /// Removes the ASCII character at position `idx` from the buffer and returns it. - /// - /// # Warning - /// This is an O(n) operation as it requires copying every element in the buffer. - /// - /// # Panics - /// If `idx` is out of bounds this function will panic. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.remove(0).as_char(), 'f'); - /// assert_eq!(s.remove(1).as_char(), 'o'); - /// assert_eq!(s.remove(0).as_char(), 'o'); - /// ``` - #[inline] - #[must_use] - pub fn remove(&mut self, idx: usize) -> AsciiChar { - self.vec.remove(idx) - } - - /// Inserts an ASCII character into the buffer at position `idx`. - /// - /// # Warning - /// This is an O(n) operation as it requires copying every element in the buffer. - /// - /// # Panics - /// If `idx` is out of bounds this function will panic. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiString,AsciiChar}; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// s.insert(2, AsciiChar::b); - /// assert_eq!(s, "fobo"); - /// ``` - #[inline] - - pub fn insert(&mut self, idx: usize, ch: AsciiChar) { - self.vec.insert(idx, ch); - } - - /// Returns the number of bytes in this ASCII string. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let s = AsciiString::from_ascii("foo").unwrap(); - /// assert_eq!(s.len(), 3); - /// ``` - #[inline] - #[must_use] - pub fn len(&self) -> usize { - self.vec.len() - } - - /// Returns true if the ASCII string contains zero bytes. - /// - /// # Examples - /// ``` - /// # use ascii::{AsciiChar, AsciiString}; - /// let mut s = AsciiString::new(); - /// assert!(s.is_empty()); - /// s.push(AsciiChar::from_ascii('a').unwrap()); - /// assert!(!s.is_empty()); - /// ``` - #[inline] - #[must_use] - pub fn is_empty(&self) -> bool { - self.len() == 0 - } - - /// Truncates the ASCII string, setting length (but not capacity) to zero. - /// - /// # Examples - /// ``` - /// # use ascii::AsciiString; - /// let mut s = AsciiString::from_ascii("foo").unwrap(); - /// s.clear(); - /// assert!(s.is_empty()); - /// ``` - #[inline] - - pub fn clear(&mut self) { - self.vec.clear(); - } - - /// Converts this [`AsciiString`] into a [`Box`]`<`[`AsciiStr`]`>`. - /// - /// This will drop any excess capacity - #[inline] - #[must_use] - pub fn into_boxed_ascii_str(self) -> Box { - let slice = self.vec.into_boxed_slice(); - Box::from(slice) - } -} - -impl Deref for AsciiString { - type Target = AsciiStr; - - #[inline] - fn deref(&self) -> &AsciiStr { - self.vec.as_slice().as_ref() - } -} - -impl DerefMut for AsciiString { - #[inline] - fn deref_mut(&mut self) -> &mut AsciiStr { - self.vec.as_mut_slice().as_mut() - } -} - -impl PartialEq for AsciiString { - #[inline] - fn eq(&self, other: &str) -> bool { - **self == *other - } -} - -impl PartialEq for str { - #[inline] - fn eq(&self, other: &AsciiString) -> bool { - **other == *self - } -} - -macro_rules! impl_eq { - ($lhs:ty, $rhs:ty) => { - impl PartialEq<$rhs> for $lhs { - #[inline] - fn eq(&self, other: &$rhs) -> bool { - PartialEq::eq(&**self, &**other) - } - } - }; -} - -impl_eq! { AsciiString, String } -impl_eq! { String, AsciiString } -impl_eq! { &AsciiStr, String } -impl_eq! { String, &AsciiStr } -impl_eq! { &AsciiStr, AsciiString } -impl_eq! { AsciiString, &AsciiStr } -impl_eq! { &str, AsciiString } -impl_eq! { AsciiString, &str } - -impl Borrow for AsciiString { - #[inline] - fn borrow(&self) -> &AsciiStr { - &**self - } -} - -impl BorrowMut for AsciiString { - #[inline] - fn borrow_mut(&mut self) -> &mut AsciiStr { - &mut **self - } -} - -impl From> for AsciiString { - #[inline] - fn from(vec: Vec) -> Self { - AsciiString { vec } - } -} - -impl From for AsciiString { - #[inline] - fn from(ch: AsciiChar) -> Self { - AsciiString { vec: vec![ch] } - } -} - -impl From for Vec { - fn from(mut s: AsciiString) -> Vec { - // SAFETY: All ascii bytes are valid `u8`, as we are `repr(u8)`. - // Note: We forget `self` to avoid `self.vec` from being deallocated. - let ptr = s.vec.as_mut_ptr().cast::(); - let length = s.vec.len(); - let capacity = s.vec.capacity(); - mem::forget(s); - - // SAFETY: We guarantee all invariants due to getting `ptr`, `length` - // and `capacity` from a `Vec`. We also guarantee `ptr` is valid - // due to the `SAFETY` block above. - unsafe { Vec::from_raw_parts(ptr, length, capacity) } - } -} - -impl From for Vec { - fn from(s: AsciiString) -> Vec { - s.vec - } -} - -impl<'a> From<&'a AsciiStr> for AsciiString { - #[inline] - fn from(s: &'a AsciiStr) -> Self { - s.to_ascii_string() - } -} - -impl<'a> From<&'a [AsciiChar]> for AsciiString { - #[inline] - fn from(s: &'a [AsciiChar]) -> AsciiString { - s.iter().copied().collect() - } -} - -impl From for String { - #[inline] - fn from(s: AsciiString) -> String { - // SAFETY: All ascii bytes are `utf8`. - unsafe { String::from_utf8_unchecked(s.into()) } - } -} - -impl From> for AsciiString { - #[inline] - fn from(boxed: Box) -> Self { - boxed.into_ascii_string() - } -} - -impl From for Box { - #[inline] - fn from(string: AsciiString) -> Self { - string.into_boxed_ascii_str() - } -} - -impl From for Rc { - fn from(s: AsciiString) -> Rc { - let var: Rc<[AsciiChar]> = s.vec.into(); - // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar] - unsafe { Rc::from_raw(Rc::into_raw(var) as *const AsciiStr) } - } -} - -impl From for Arc { - fn from(s: AsciiString) -> Arc { - let var: Arc<[AsciiChar]> = s.vec.into(); - // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar] - unsafe { Arc::from_raw(Arc::into_raw(var) as *const AsciiStr) } - } -} - -impl<'a> From> for AsciiString { - fn from(cow: Cow<'a, AsciiStr>) -> AsciiString { - cow.into_owned() - } -} - -impl From for Cow<'static, AsciiStr> { - fn from(string: AsciiString) -> Cow<'static, AsciiStr> { - Cow::Owned(string) - } -} - -impl<'a> From<&'a AsciiStr> for Cow<'a, AsciiStr> { - fn from(s: &'a AsciiStr) -> Cow<'a, AsciiStr> { - Cow::Borrowed(s) - } -} - -impl AsRef for AsciiString { - #[inline] - fn as_ref(&self) -> &AsciiStr { - &**self - } -} - -impl AsRef<[AsciiChar]> for AsciiString { - #[inline] - fn as_ref(&self) -> &[AsciiChar] { - &self.vec - } -} - -impl AsRef<[u8]> for AsciiString { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} - -impl AsRef for AsciiString { - #[inline] - fn as_ref(&self) -> &str { - self.as_str() - } -} - -impl AsMut for AsciiString { - #[inline] - fn as_mut(&mut self) -> &mut AsciiStr { - &mut *self - } -} - -impl AsMut<[AsciiChar]> for AsciiString { - #[inline] - fn as_mut(&mut self) -> &mut [AsciiChar] { - &mut self.vec - } -} - -impl FromStr for AsciiString { - type Err = AsAsciiStrError; - - fn from_str(s: &str) -> Result { - s.as_ascii_str().map(AsciiStr::to_ascii_string) - } -} - -impl fmt::Display for AsciiString { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&**self, f) - } -} - -impl fmt::Debug for AsciiString { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&**self, f) - } -} - -/// Please note that the `std::fmt::Result` returned by these methods does not support -/// transmission of an error other than that an error occurred. -impl fmt::Write for AsciiString { - fn write_str(&mut self, s: &str) -> fmt::Result { - if let Ok(astr) = AsciiStr::from_ascii(s) { - self.push_str(astr); - Ok(()) - } else { - Err(fmt::Error) - } - } - - fn write_char(&mut self, c: char) -> fmt::Result { - if let Ok(achar) = AsciiChar::from_ascii(c) { - self.push(achar); - Ok(()) - } else { - Err(fmt::Error) - } - } -} - -impl> FromIterator for AsciiString { - fn from_iter>(iter: I) -> AsciiString { - let mut buf = AsciiString::new(); - buf.extend(iter); - buf - } -} - -impl> Extend for AsciiString { - fn extend>(&mut self, iterable: I) { - let iterator = iterable.into_iter(); - let (lower_bound, _) = iterator.size_hint(); - self.reserve(lower_bound); - for item in iterator { - self.push_str(item.as_ref()); - } - } -} - -impl<'a> Add<&'a AsciiStr> for AsciiString { - type Output = AsciiString; - - #[inline] - fn add(mut self, other: &AsciiStr) -> AsciiString { - self.push_str(other); - self - } -} - -impl<'a> AddAssign<&'a AsciiStr> for AsciiString { - #[inline] - fn add_assign(&mut self, other: &AsciiStr) { - self.push_str(other); - } -} - -#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default -impl Index for AsciiString -where - AsciiStr: Index, -{ - type Output = >::Output; - - #[inline] - fn index(&self, index: T) -> &>::Output { - &(**self)[index] - } -} - -#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default -impl IndexMut for AsciiString -where - AsciiStr: IndexMut, -{ - #[inline] - fn index_mut(&mut self, index: T) -> &mut >::Output { - &mut (**self)[index] - } -} - -/// A possible error value when converting an `AsciiString` from a byte vector or string. -/// It wraps an `AsAsciiStrError` which you can get through the `ascii_error()` method. -/// -/// This is the error type for `AsciiString::from_ascii()` and -/// `IntoAsciiString::into_ascii_string()`. They will never clone or touch the content of the -/// original type; It can be extracted by the `into_source` method. -/// -/// #Examples -/// ``` -/// # use ascii::IntoAsciiString; -/// let err = "bø!".to_string().into_ascii_string().unwrap_err(); -/// assert_eq!(err.ascii_error().valid_up_to(), 1); -/// assert_eq!(err.into_source(), "bø!".to_string()); -/// ``` -#[derive(Clone, Copy, PartialEq, Eq)] -pub struct FromAsciiError { - error: AsAsciiStrError, - owner: O, -} -impl FromAsciiError { - /// Get the position of the first non-ASCII byte or character. - #[inline] - #[must_use] - pub fn ascii_error(&self) -> AsAsciiStrError { - self.error - } - /// Get back the original, unmodified type. - #[inline] - #[must_use] - pub fn into_source(self) -> O { - self.owner - } -} -impl fmt::Debug for FromAsciiError { - #[inline] - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - fmt::Debug::fmt(&self.error, fmtr) - } -} -impl fmt::Display for FromAsciiError { - #[inline] - fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&self.error, fmtr) - } -} -#[cfg(feature = "std")] -impl Error for FromAsciiError { - #[inline] - #[allow(deprecated)] // TODO: Remove deprecation once the earliest version we support deprecates this method. - fn description(&self) -> &str { - self.error.description() - } - /// Always returns an `AsAsciiStrError` - fn cause(&self) -> Option<&dyn Error> { - Some(&self.error as &dyn Error) - } -} - -/// Convert vectors into `AsciiString`. -pub trait IntoAsciiString: Sized { - /// Convert to `AsciiString` without checking for non-ASCII characters. - /// - /// # Safety - /// If `self` contains non-ascii characters, calling this function is - /// undefined behavior. - unsafe fn into_ascii_string_unchecked(self) -> AsciiString; - - /// Convert to `AsciiString`. - /// - /// # Errors - /// If `self` contains non-ascii characters, this will return `Err` - fn into_ascii_string(self) -> Result>; -} - -impl IntoAsciiString for Vec { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -impl<'a> IntoAsciiString for &'a [AsciiChar] { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -impl<'a> IntoAsciiString for &'a AsciiStr { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - AsciiString::from(self) - } - #[inline] - fn into_ascii_string(self) -> Result> { - Ok(AsciiString::from(self)) - } -} - -macro_rules! impl_into_ascii_string { - ('a, $wider:ty) => { - impl<'a> IntoAsciiString for $wider { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self) } - } - - #[inline] - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self) - } - } - }; - - ($wider:ty) => { - impl IntoAsciiString for $wider { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self) } - } - - #[inline] - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self) - } - } - }; -} - -impl_into_ascii_string! {AsciiString} -impl_into_ascii_string! {Vec} -impl_into_ascii_string! {'a, &'a [u8]} -impl_into_ascii_string! {String} -impl_into_ascii_string! {'a, &'a str} - -/// # Notes -/// The trailing null byte `CString` has will be removed during this conversion. -#[cfg(feature = "std")] -impl IntoAsciiString for CString { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self.into_bytes()) } - } - - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self.into_bytes_with_nul()) - .map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - // SAFETY: We don't discard the NULL byte from the original - // string, so we ensure that it's null terminated - owner: unsafe { CString::from_vec_unchecked(owner) }, - error, - } - }) - .map(|mut s| { - let nul = s.pop(); - debug_assert_eq!(nul, Some(AsciiChar::Null)); - s - }) - } -} - -/// Note that the trailing null byte will be removed in the conversion. -#[cfg(feature = "std")] -impl<'a> IntoAsciiString for &'a CStr { - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { AsciiString::from_ascii_unchecked(self.to_bytes()) } - } - - fn into_ascii_string(self) -> Result> { - AsciiString::from_ascii(self.to_bytes_with_nul()) - .map_err(|FromAsciiError { error, owner }| FromAsciiError { - // SAFETY: We don't discard the NULL byte from the original - // string, so we ensure that it's null terminated - owner: unsafe { CStr::from_ptr(owner.as_ptr().cast()) }, - error, - }) - .map(|mut s| { - let nul = s.pop(); - debug_assert_eq!(nul, Some(AsciiChar::Null)); - s - }) - } -} - -impl<'a, B> IntoAsciiString for Cow<'a, B> -where - B: 'a + ToOwned + ?Sized, - &'a B: IntoAsciiString, - ::Owned: IntoAsciiString, -{ - #[inline] - unsafe fn into_ascii_string_unchecked(self) -> AsciiString { - // SAFETY: Caller guarantees `self` only has valid ascii bytes - unsafe { IntoAsciiString::into_ascii_string_unchecked(self.into_owned()) } - } - - fn into_ascii_string(self) -> Result> { - match self { - Cow::Owned(b) => { - IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - owner: Cow::Owned(owner), - error, - } - }) - } - Cow::Borrowed(b) => { - IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| { - FromAsciiError { - owner: Cow::Borrowed(owner), - error, - } - }) - } - } - } -} - -#[cfg(test)] -mod tests { - use super::{AsciiString, IntoAsciiString}; - use alloc::str::FromStr; - use alloc::string::{String, ToString}; - use alloc::vec::Vec; - use alloc::boxed::Box; - #[cfg(feature = "std")] - use std::ffi::CString; - use {AsciiChar, AsciiStr}; - - #[test] - fn into_string() { - let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap(); - assert_eq!(Into::::into(v), "( ;".to_string()); - } - - #[test] - fn into_bytes() { - let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap(); - assert_eq!(Into::>::into(v), vec![40_u8, 32, 59]); - } - - #[test] - fn from_ascii_vec() { - let vec = vec![ - AsciiChar::from_ascii('A').unwrap(), - AsciiChar::from_ascii('B').unwrap(), - ]; - assert_eq!(AsciiString::from(vec), AsciiString::from_str("AB").unwrap()); - } - - #[test] - #[cfg(feature = "std")] - fn from_cstring() { - let cstring = CString::new("baz").unwrap(); - let ascii_str = cstring.clone().into_ascii_string().unwrap(); - let expected_chars = &[AsciiChar::b, AsciiChar::a, AsciiChar::z]; - assert_eq!(ascii_str.len(), 3); - assert_eq!(ascii_str.as_slice(), expected_chars); - - // SAFETY: "baz" only contains valid ascii characters. - let ascii_str_unchecked = unsafe { cstring.into_ascii_string_unchecked() }; - assert_eq!(ascii_str_unchecked.len(), 3); - assert_eq!(ascii_str_unchecked.as_slice(), expected_chars); - - let sparkle_heart_bytes = vec![240_u8, 159, 146, 150]; - let cstring = CString::new(sparkle_heart_bytes).unwrap(); - let cstr = &*cstring; - let ascii_err = cstr.into_ascii_string().unwrap_err(); - assert_eq!(ascii_err.into_source(), &*cstring); - } - - #[test] - #[cfg(feature = "std")] - fn fmt_ascii_string() { - let s = "abc".to_string().into_ascii_string().unwrap(); - assert_eq!(format!("{}", s), "abc".to_string()); - assert_eq!(format!("{:?}", s), "\"abc\"".to_string()); - } - - #[test] - fn write_fmt() { - use alloc::{fmt, str}; - - let mut s0 = AsciiString::new(); - fmt::write(&mut s0, format_args!("Hello World")).unwrap(); - assert_eq!(s0, "Hello World"); - - let mut s1 = AsciiString::new(); - fmt::write(&mut s1, format_args!("{}", 9)).unwrap(); - assert_eq!(s1, "9"); - - let mut s2 = AsciiString::new(); - let sparkle_heart_bytes = [240, 159, 146, 150]; - let sparkle_heart = str::from_utf8(&sparkle_heart_bytes).unwrap(); - assert!(fmt::write(&mut s2, format_args!("{}", sparkle_heart)).is_err()); - } - - #[test] - fn to_and_from_box() { - let string = "abc".into_ascii_string().unwrap(); - let converted: Box = Box::from(string.clone()); - let converted: AsciiString = converted.into(); - assert_eq!(string, converted); - } -} diff --git a/anneal/vendor/ascii/src/free_functions.rs b/anneal/vendor/ascii/src/free_functions.rs deleted file mode 100644 index 55d97321e4..0000000000 --- a/anneal/vendor/ascii/src/free_functions.rs +++ /dev/null @@ -1,59 +0,0 @@ -use ascii_char::{AsciiChar, ToAsciiChar}; - -/// Terminals use [caret notation](https://en.wikipedia.org/wiki/Caret_notation) -/// to display some typed control codes, such as ^D for EOT and ^Z for SUB. -/// -/// This function returns the caret notation letter for control codes, -/// or `None` for printable characters. -/// -/// # Examples -/// ``` -/// # use ascii::{AsciiChar, caret_encode}; -/// assert_eq!(caret_encode(b'\0'), Some(AsciiChar::At)); -/// assert_eq!(caret_encode(AsciiChar::DEL), Some(AsciiChar::Question)); -/// assert_eq!(caret_encode(b'E'), None); -/// assert_eq!(caret_encode(b'\n'), Some(AsciiChar::J)); -/// ``` -pub fn caret_encode>(c: C) -> Option { - // The formula is explained in the Wikipedia article. - let c = c.into() ^ 0b0100_0000; - if (b'?'..=b'_').contains(&c) { - // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) are valid ascii characters. - Some(unsafe { c.to_ascii_char_unchecked() }) - } else { - None - } -} - -/// Returns the control code represented by a [caret notation](https://en.wikipedia.org/wiki/Caret_notation) -/// letter, or `None` if the letter is not used in caret notation. -/// -/// This function is the inverse of `caret_encode()`. -/// -/// # Examples -/// -/// Basic usage: -/// -/// ``` -/// # use ascii::{AsciiChar, caret_decode}; -/// assert_eq!(caret_decode(b'?'), Some(AsciiChar::DEL)); -/// assert_eq!(caret_decode(AsciiChar::D), Some(AsciiChar::EOT)); -/// assert_eq!(caret_decode(b'\0'), None); -/// ``` -/// -/// Symmetry: -/// -/// ``` -/// # use ascii::{AsciiChar, caret_encode, caret_decode}; -/// assert_eq!(caret_encode(AsciiChar::US).and_then(caret_decode), Some(AsciiChar::US)); -/// assert_eq!(caret_decode(b'@').and_then(caret_encode), Some(AsciiChar::At)); -/// ``` -pub fn caret_decode>(c: C) -> Option { - // The formula is explained in the Wikipedia article. - match c.into() { - // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) after `xoring` with `0b0100_0000` are - // valid bytes, as they represent characters between '␀' (0x0) and '␠' (0x1f) + '␡' (0x7f) - b'?'..=b'_' => Some(unsafe { AsciiChar::from_ascii_unchecked(c.into() ^ 0b0100_0000) }), - _ => None, - } -} diff --git a/anneal/vendor/ascii/src/lib.rs b/anneal/vendor/ascii/src/lib.rs deleted file mode 100644 index 5eacc162fb..0000000000 --- a/anneal/vendor/ascii/src/lib.rs +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! A library that provides ASCII-only string and character types, equivalent to the `char`, `str` -//! and `String` types in the standard library. -//! -//! Please refer to the readme file to learn about the different feature modes of this crate. -//! -//! # Minimum supported Rust version -//! -//! The minimum Rust version for 1.1.\* releases is 1.41.1. -//! Later 1.y.0 releases might require newer Rust versions, but the three most -//! recent stable releases at the time of publishing will always be supported. -//! For example this means that if the current stable Rust version is 1.70 when -//! ascii 1.2.0 is released, then ascii 1.2.\* will not require a newer -//! Rust version than 1.68. -//! -//! # History -//! -//! This package included the Ascii types that were removed from the Rust standard library by the -//! 2014-12 [reform of the `std::ascii` module](https://github.com/rust-lang/rfcs/pull/486). The -//! API changed significantly since then. - -#![cfg_attr(not(feature = "std"), no_std)] -// Clippy lints -#![warn( - clippy::pedantic, - clippy::decimal_literal_representation, - clippy::get_unwrap, - clippy::indexing_slicing -)] -// Naming conventions sometimes go against this lint -#![allow(clippy::module_name_repetitions)] -// We need to get literal non-asciis for tests -#![allow(clippy::non_ascii_literal)] -// Sometimes it looks better to invert the order, such as when the `else` block is small -#![allow(clippy::if_not_else)] -// Shadowing is common and doesn't affect understanding -// TODO: Consider removing `shadow_unrelated`, as it can show some actual logic errors -#![allow(clippy::shadow_unrelated, clippy::shadow_reuse, clippy::shadow_same)] -// A `if let` / `else` sometimes looks better than using iterator adaptors -#![allow(clippy::option_if_let_else)] -// In tests, we're fine with indexing, since a panic is a failure. -#![cfg_attr(test, allow(clippy::indexing_slicing))] -// for compatibility with methods on char and u8 -#![allow(clippy::trivially_copy_pass_by_ref)] -// In preparation for feature `unsafe_block_in_unsafe_fn` (https://github.com/rust-lang/rust/issues/71668) -#![allow(unused_unsafe)] - -#[cfg(feature = "alloc")] -#[macro_use] -extern crate alloc; -#[cfg(feature = "std")] -extern crate core; - -#[cfg(feature = "serde")] -extern crate serde; - -#[cfg(all(test, feature = "serde_test"))] -extern crate serde_test; - -mod ascii_char; -mod ascii_str; -#[cfg(feature = "alloc")] -mod ascii_string; -mod free_functions; -#[cfg(feature = "serde")] -mod serialization; - -pub use ascii_char::{AsciiChar, ToAsciiChar, ToAsciiCharError}; -pub use ascii_str::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr}; -pub use ascii_str::{Chars, CharsMut, CharsRef}; -#[cfg(feature = "alloc")] -pub use ascii_string::{AsciiString, FromAsciiError, IntoAsciiString}; -pub use free_functions::{caret_decode, caret_encode}; diff --git a/anneal/vendor/ascii/src/serialization/ascii_char.rs b/anneal/vendor/ascii/src/serialization/ascii_char.rs deleted file mode 100644 index 9fd843a149..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_char.rs +++ /dev/null @@ -1,89 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_char::AsciiChar; - -impl Serialize for AsciiChar { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_char(self.as_char()) - } -} - -struct AsciiCharVisitor; - -impl<'de> Visitor<'de> for AsciiCharVisitor { - type Value = AsciiChar; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("an ascii character") - } - - #[inline] - fn visit_char(self, v: char) -> Result { - AsciiChar::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Char(v), &self)) - } - - #[inline] - fn visit_str(self, v: &str) -> Result { - if v.len() == 1 { - let c = v.chars().next().unwrap(); - self.visit_char(c) - } else { - Err(Error::invalid_value(Unexpected::Str(v), &self)) - } - } -} - -impl<'de> Deserialize<'de> for AsciiChar { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_char(AsciiCharVisitor) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII_CHAR: char = 'e'; - #[cfg(feature = "serde_test")] - const ASCII_STR: &str = "e"; - #[cfg(feature = "serde_test")] - const UNICODE_CHAR: char = 'é'; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::(); - assert_deserialize::(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap(); - assert_tokens(&ascii_char, &[Token::Char(ASCII_CHAR)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap(); - assert_de_tokens(&ascii_char, &[Token::String(ASCII_STR)]); - assert_de_tokens(&ascii_char, &[Token::Str(ASCII_STR)]); - assert_de_tokens(&ascii_char, &[Token::BorrowedStr(ASCII_STR)]); - assert_de_tokens_error::( - &[Token::Char(UNICODE_CHAR)], - "invalid value: character `é`, expected an ascii character", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/ascii_str.rs b/anneal/vendor/ascii/src/serialization/ascii_str.rs deleted file mode 100644 index 9aa9353afb..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_str.rs +++ /dev/null @@ -1,79 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_str::AsciiStr; - -impl Serialize for AsciiStr { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.as_str()) - } -} - -struct AsciiStrVisitor; - -impl<'a> Visitor<'a> for AsciiStrVisitor { - type Value = &'a AsciiStr; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("a borrowed ascii string") - } - - fn visit_borrowed_str(self, v: &'a str) -> Result { - AsciiStr::from_ascii(v.as_bytes()) - .map_err(|_| Error::invalid_value(Unexpected::Str(v), &self)) - } - - fn visit_borrowed_bytes(self, v: &'a [u8]) -> Result { - AsciiStr::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) - } -} - -impl<'de: 'a, 'a> Deserialize<'de> for &'a AsciiStr { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_str(AsciiStrVisitor) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII: &str = "Francais"; - #[cfg(feature = "serde_test")] - const UNICODE: &str = "Français"; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::<&AsciiStr>(); - assert_deserialize::<&AsciiStr>(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - let ascii_str = AsciiStr::from_ascii(ASCII).unwrap(); - assert_tokens(&ascii_str, &[Token::BorrowedStr(ASCII)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_str = AsciiStr::from_ascii(ASCII).unwrap(); - assert_de_tokens(&ascii_str, &[Token::BorrowedBytes(ASCII.as_bytes())]); - assert_de_tokens_error::<&AsciiStr>( - &[Token::BorrowedStr(UNICODE)], - "invalid value: string \"Français\", expected a borrowed ascii string", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/ascii_string.rs b/anneal/vendor/ascii/src/serialization/ascii_string.rs deleted file mode 100644 index 1547655f1e..0000000000 --- a/anneal/vendor/ascii/src/serialization/ascii_string.rs +++ /dev/null @@ -1,149 +0,0 @@ -use std::fmt; - -use serde::de::{Error, Unexpected, Visitor}; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; - -use ascii_str::AsciiStr; -use ascii_string::AsciiString; - -impl Serialize for AsciiString { - #[inline] - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.as_str()) - } -} - -struct AsciiStringVisitor; - -impl<'de> Visitor<'de> for AsciiStringVisitor { - type Value = AsciiString; - - fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("an ascii string") - } - - fn visit_str(self, v: &str) -> Result { - AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Str(v), &self)) - } - - fn visit_string(self, v: String) -> Result { - AsciiString::from_ascii(v.as_bytes()) - .map_err(|_| Error::invalid_value(Unexpected::Str(&v), &self)) - } - - fn visit_bytes(self, v: &[u8]) -> Result { - AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) - } - - fn visit_byte_buf(self, v: Vec) -> Result { - AsciiString::from_ascii(v.as_slice()) - .map_err(|_| Error::invalid_value(Unexpected::Bytes(&v), &self)) - } -} - -struct AsciiStringInPlaceVisitor<'a>(&'a mut AsciiString); - -impl<'a, 'de> Visitor<'de> for AsciiStringInPlaceVisitor<'a> { - type Value = (); - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("an ascii string") - } - - fn visit_str(self, v: &str) -> Result { - let ascii_str = match AsciiStr::from_ascii(v.as_bytes()) { - Ok(ascii_str) => ascii_str, - Err(_) => return Err(Error::invalid_value(Unexpected::Str(v), &self)), - }; - self.0.clear(); - self.0.push_str(ascii_str); - Ok(()) - } - - fn visit_string(self, v: String) -> Result { - let ascii_string = match AsciiString::from_ascii(v.as_bytes()) { - Ok(ascii_string) => ascii_string, - Err(_) => return Err(Error::invalid_value(Unexpected::Str(&v), &self)), - }; - *self.0 = ascii_string; - Ok(()) - } - - fn visit_bytes(self, v: &[u8]) -> Result { - let ascii_str = match AsciiStr::from_ascii(v) { - Ok(ascii_str) => ascii_str, - Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(v), &self)), - }; - self.0.clear(); - self.0.push_str(ascii_str); - Ok(()) - } - - fn visit_byte_buf(self, v: Vec) -> Result { - let ascii_string = match AsciiString::from_ascii(v.as_slice()) { - Ok(ascii_string) => ascii_string, - Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(&v), &self)), - }; - *self.0 = ascii_string; - Ok(()) - } -} - -impl<'de> Deserialize<'de> for AsciiString { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - deserializer.deserialize_string(AsciiStringVisitor) - } - - fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> - where - D: Deserializer<'de>, - { - deserializer.deserialize_string(AsciiStringInPlaceVisitor(place)) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(feature = "serde_test")] - const ASCII: &str = "Francais"; - #[cfg(feature = "serde_test")] - const UNICODE: &str = "Français"; - - #[test] - fn basic() { - fn assert_serialize() {} - fn assert_deserialize<'de, T: Deserialize<'de>>() {} - assert_serialize::(); - assert_deserialize::(); - } - - #[test] - #[cfg(feature = "serde_test")] - fn serialize() { - use serde_test::{assert_tokens, Token}; - - let ascii_string = AsciiString::from_ascii(ASCII).unwrap(); - assert_tokens(&ascii_string, &[Token::String(ASCII)]); - assert_tokens(&ascii_string, &[Token::Str(ASCII)]); - assert_tokens(&ascii_string, &[Token::BorrowedStr(ASCII)]); - } - - #[test] - #[cfg(feature = "serde_test")] - fn deserialize() { - use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; - let ascii_string = AsciiString::from_ascii(ASCII).unwrap(); - assert_de_tokens(&ascii_string, &[Token::Bytes(ASCII.as_bytes())]); - assert_de_tokens(&ascii_string, &[Token::BorrowedBytes(ASCII.as_bytes())]); - assert_de_tokens(&ascii_string, &[Token::ByteBuf(ASCII.as_bytes())]); - assert_de_tokens_error::( - &[Token::String(UNICODE)], - "invalid value: string \"Français\", expected an ascii string", - ); - } -} diff --git a/anneal/vendor/ascii/src/serialization/mod.rs b/anneal/vendor/ascii/src/serialization/mod.rs deleted file mode 100644 index 69a4e03a1c..0000000000 --- a/anneal/vendor/ascii/src/serialization/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -mod ascii_char; -mod ascii_str; -mod ascii_string; diff --git a/anneal/vendor/ascii/tests.rs b/anneal/vendor/ascii/tests.rs deleted file mode 100644 index 017a7be781..0000000000 --- a/anneal/vendor/ascii/tests.rs +++ /dev/null @@ -1,143 +0,0 @@ -extern crate ascii; - -use ascii::{AsAsciiStr, AsciiChar, AsciiStr}; -#[cfg(feature = "std")] -use ascii::{AsciiString, IntoAsciiString}; - -#[test] -#[cfg(feature = "std")] -fn ascii_vec() { - let test = b"( ;"; - let a = AsciiStr::from_ascii(test).unwrap(); - assert_eq!(test.as_ascii_str(), Ok(a)); - assert_eq!("( ;".as_ascii_str(), Ok(a)); - let v = test.to_vec(); - assert_eq!(v.as_ascii_str(), Ok(a)); - assert_eq!("( ;".to_string().as_ascii_str(), Ok(a)); -} - -#[test] -fn to_ascii() { - assert!("zoä华".as_ascii_str().is_err()); - assert!([127_u8, 128, 255].as_ascii_str().is_err()); - - let arr = [AsciiChar::ParenOpen, AsciiChar::Space, AsciiChar::Semicolon]; - let a: &AsciiStr = (&arr[..]).into(); - assert_eq!(b"( ;".as_ascii_str(), Ok(a)); - assert_eq!("( ;".as_ascii_str(), Ok(a)); -} - -#[test] -#[cfg(feature = "std")] -fn into_ascii() { - let arr = [AsciiChar::ParenOpen, AsciiChar::Space, AsciiChar::Semicolon]; - let v = AsciiString::from(arr.to_vec()); - assert_eq!(b"( ;".to_vec().into_ascii_string(), Ok(v.clone())); - assert_eq!("( ;".to_string().into_ascii_string(), Ok(v.clone())); - assert_eq!(b"( ;", AsRef::<[u8]>::as_ref(&v)); - - let err = "zoä华".to_string().into_ascii_string().unwrap_err(); - assert_eq!(Err(err.ascii_error()), "zoä华".as_ascii_str()); - assert_eq!(err.into_source(), "zoä华"); - let err = vec![127, 128, 255].into_ascii_string().unwrap_err(); - assert_eq!(Err(err.ascii_error()), [127, 128, 255].as_ascii_str()); - assert_eq!(err.into_source(), &[127, 128, 255]); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_ascii_str() { - let v = b"abc"; - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - let ascii_str = AsciiStr::from_ascii(v).unwrap(); - assert!(ascii_string == ascii_str); - assert!(ascii_str == ascii_string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_string() { - let v = b"abc"; - let string = String::from_utf8(v.to_vec()).unwrap(); - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - assert!(string == ascii_string); - assert!(ascii_string == string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_str_string() { - let v = b"abc"; - let string = String::from_utf8(v.to_vec()).unwrap(); - let ascii_str = AsciiStr::from_ascii(&v[..]).unwrap(); - assert!(string == ascii_str); - assert!(ascii_str == string); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_str() { - let v = b"abc"; - let sstr = ::std::str::from_utf8(v).unwrap(); - let ascii_string = AsciiString::from_ascii(&v[..]).unwrap(); - assert!(sstr == ascii_string); - assert!(ascii_string == sstr); -} - -#[test] -fn compare_ascii_str_str() { - let v = b"abc"; - let sstr = ::std::str::from_utf8(v).unwrap(); - let ascii_str = AsciiStr::from_ascii(v).unwrap(); - assert!(sstr == ascii_str); - assert!(ascii_str == sstr); -} - -#[test] -#[allow(clippy::redundant_slicing)] -fn compare_ascii_str_slice() { - let b = b"abc".as_ascii_str().unwrap(); - let c = b"ab".as_ascii_str().unwrap(); - assert_eq!(&b[..2], &c[..]); - assert_eq!(c[1].as_char(), 'b'); -} - -#[test] -#[cfg(feature = "std")] -fn compare_ascii_string_slice() { - let b = AsciiString::from_ascii("abc").unwrap(); - let c = AsciiString::from_ascii("ab").unwrap(); - assert_eq!(&b[..2], &c[..]); - assert_eq!(c[1].as_char(), 'b'); -} - -#[test] -#[cfg(feature = "std")] -fn extend_from_iterator() { - use std::borrow::Cow; - - let abc = "abc".as_ascii_str().unwrap(); - let mut s = abc.chars().collect::(); - assert_eq!(s, abc); - s.extend(abc); - assert_eq!(s, "abcabc"); - - let lines = "one\ntwo\nthree".as_ascii_str().unwrap().lines(); - s.extend(lines); - assert_eq!(s, "abcabconetwothree"); - - let cows = "ASCII Ascii ascii" - .as_ascii_str() - .unwrap() - .split(AsciiChar::Space) - .map(|case| { - if case.chars().all(AsciiChar::is_uppercase) { - Cow::from(case) - } else { - Cow::from(case.to_ascii_uppercase()) - } - }); - s.extend(cows); - s.extend(&[AsciiChar::LineFeed]); - assert_eq!(s, "abcabconetwothreeASCIIASCIIASCII\n"); -} diff --git a/anneal/vendor/chunked_transfer/.cargo-checksum.json b/anneal/vendor/chunked_transfer/.cargo-checksum.json deleted file mode 100644 index 83680bf097..0000000000 --- a/anneal/vendor/chunked_transfer/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"6efd477ff120102f1e31ff8f7625366ab64d193a5f0bb5d70882c3413e89e00a",".github/workflows/rust.yml":"6fdda8eaeae4d2e4b64a8497b836e40a244bd8f725ec49f19a9e1095aa62e819","Cargo.toml":"7753964e6adfc969908ea8f54aaad4c4bfed26a05e44bedb0faf588b9961f746","Cargo.toml.orig":"bcc025821244a7c37bf244d24a9116c9c48a0ade225fbcd34c825ff68c8036d7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"5eda8c6538e7d543efe31ebad3fc0e66a7c4df056ddb901a5bdfbf5ef397e116","README.md":"4c3df261bfbfe8f7ed7bef76b833c606164dc768fe2919d7faf2ad3a3c1cb749","benches/encode.rs":"39e69d513bde63cbc977a4dc70f289c2ff494919ce0b934769039ffa82579312","src/decoder.rs":"e6df82dca0f409e866898464cb83d65cefb8d99b08109b77501444ff0c5ca5ec","src/encoder.rs":"1f645db6731b69d0394cb2e06250ea1de7a07c348aacc50df07b593421846953","src/lib.rs":"b1af36d3dddf7d2f7f45732281fa3fcafb741a60146f6befd33884fab51a6b03"},"package":"6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"} \ No newline at end of file diff --git a/anneal/vendor/chunked_transfer/.cargo_vcs_info.json b/anneal/vendor/chunked_transfer/.cargo_vcs_info.json deleted file mode 100644 index 6bade92d3b..0000000000 --- a/anneal/vendor/chunked_transfer/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "d4637cda63ec2da7052bba9d4d37f69cbeae9ab8" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/chunked_transfer/.github/workflows/rust.yml b/anneal/vendor/chunked_transfer/.github/workflows/rust.yml deleted file mode 100644 index 31000a2744..0000000000 --- a/anneal/vendor/chunked_transfer/.github/workflows/rust.yml +++ /dev/null @@ -1,22 +0,0 @@ -name: Rust - -on: - push: - branches: [ "main" ] - pull_request: - branches: [ "main" ] - -env: - CARGO_TERM_COLOR: always - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v3 - - name: Build - run: cargo build --verbose - - name: Run tests - run: cargo test --verbose diff --git a/anneal/vendor/chunked_transfer/Cargo.toml b/anneal/vendor/chunked_transfer/Cargo.toml deleted file mode 100644 index 52bd6cd984..0000000000 --- a/anneal/vendor/chunked_transfer/Cargo.toml +++ /dev/null @@ -1,27 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -name = "chunked_transfer" -version = "1.5.0" -authors = ["Corey Farwell "] -description = "Encoder and decoder for HTTP chunked transfer coding (RFC 7230 § 4.1)" -readme = "README.md" -license = "MIT OR Apache-2.0" -repository = "https://github.com/frewsxcv/rust-chunked-transfer" - -[[bench]] -name = "encode" -harness = false - -[dev-dependencies.criterion] -version = "0.3" diff --git a/anneal/vendor/chunked_transfer/Cargo.toml.orig b/anneal/vendor/chunked_transfer/Cargo.toml.orig deleted file mode 100644 index e0eaae9dab..0000000000 --- a/anneal/vendor/chunked_transfer/Cargo.toml.orig +++ /dev/null @@ -1,15 +0,0 @@ -[package] -name = "chunked_transfer" -version = "1.5.0" -authors = ["Corey Farwell "] -license = "MIT OR Apache-2.0" -repository = "https://github.com/frewsxcv/rust-chunked-transfer" -description = "Encoder and decoder for HTTP chunked transfer coding (RFC 7230 § 4.1)" -edition = "2018" - -[dev-dependencies] -criterion = "0.3" - -[[bench]] -name = "encode" -harness = false diff --git a/anneal/vendor/chunked_transfer/LICENSE-APACHE b/anneal/vendor/chunked_transfer/LICENSE-APACHE deleted file mode 100644 index 16fe87b06e..0000000000 --- a/anneal/vendor/chunked_transfer/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/chunked_transfer/LICENSE-MIT b/anneal/vendor/chunked_transfer/LICENSE-MIT deleted file mode 100644 index 892d6c7c47..0000000000 --- a/anneal/vendor/chunked_transfer/LICENSE-MIT +++ /dev/null @@ -1,22 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2015 The tiny-http Contributors -Copyright (c) 2015 The rust-chunked-transfer Contributors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/anneal/vendor/chunked_transfer/README.md b/anneal/vendor/chunked_transfer/README.md deleted file mode 100644 index 92cfe05993..0000000000 --- a/anneal/vendor/chunked_transfer/README.md +++ /dev/null @@ -1,59 +0,0 @@ -# rust-chunked-transfer - -[Documentation](https://docs.rs/chunked_transfer/) - -Encoder and decoder for HTTP chunked transfer coding. For more information about chunked transfer encoding: - -* [RFC 7230 § 4.1](https://tools.ietf.org/html/rfc7230#section-4.1) -* [RFC 2616 § 3.6.1](https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1) (deprecated) -* [Wikipedia: Chunked transfer encoding](https://en.wikipedia.org/wiki/Chunked_transfer_encoding) - -## Example - -### Decoding - -```rust -use chunked_transfer::Decoder; -use std::io::Read; - -let encoded = b"3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n"; -let mut decoded = String::new(); - -let mut decoder = Decoder::new(encoded as &[u8]); -decoder.read_to_string(&mut decoded); - -assert_eq!(decoded, "hello world!!!"); -``` - -### Encoding - -```rust -use chunked_transfer::Encoder; -use std::io::Write; - -let mut decoded = "hello world"; -let mut encoded: Vec = vec![]; - -{ - let mut encoder = Encoder::with_chunks_size(&mut encoded, 5); - encoder.write_all(decoded.as_bytes()); -} - -assert_eq!(encoded, b"5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); -``` - -## Authors - -* [tomaka](https://github.com/tomaka) -* [frewsxcv](https://github.com/frewsxcv) - -# License - -Licensed under either of: - - * Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0) - * MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT) - -## Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. diff --git a/anneal/vendor/chunked_transfer/benches/encode.rs b/anneal/vendor/chunked_transfer/benches/encode.rs deleted file mode 100644 index 76306ff64b..0000000000 --- a/anneal/vendor/chunked_transfer/benches/encode.rs +++ /dev/null @@ -1,22 +0,0 @@ -#![feature(test)] - -use chunked_transfer; -use criterion::{criterion_group, criterion_main, Criterion}; -use std::io::Write; - -extern crate test; - -fn encode_benchmark(c: &mut Criterion) { - c.bench_function("encode", |b| { - let writer = vec![]; - let mut encoder = chunked_transfer::Encoder::new(writer); - let mut to_write = vec![b'a'; 1000]; - - b.iter(|| { - test::black_box(encoder.write_all(&mut to_write)); - }); - }); -} - -criterion_group!(benches, encode_benchmark); -criterion_main!(benches); diff --git a/anneal/vendor/chunked_transfer/src/decoder.rs b/anneal/vendor/chunked_transfer/src/decoder.rs deleted file mode 100644 index 453752fd69..0000000000 --- a/anneal/vendor/chunked_transfer/src/decoder.rs +++ /dev/null @@ -1,300 +0,0 @@ -use std::error::Error; -use std::fmt; -use std::io::Error as IoError; -use std::io::ErrorKind; -use std::io::Read; -use std::io::Result as IoResult; - -/// Reads HTTP chunks and sends back real data. -/// -/// # Example -/// -/// ``` -/// use chunked_transfer::Decoder; -/// use std::io::Read; -/// -/// let encoded = b"3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n"; -/// let mut decoded = String::new(); -/// -/// let mut decoder = Decoder::new(encoded as &[u8]); -/// decoder.read_to_string(&mut decoded); -/// -/// assert_eq!(decoded, "hello world!!!"); -/// ``` -pub struct Decoder { - // where the chunks come from - source: R, - - // remaining size of the chunk being read - // none if we are not in a chunk - remaining_chunks_size: Option, -} - -impl Decoder -where - R: Read, -{ - pub fn new(source: R) -> Decoder { - Decoder { - source, - remaining_chunks_size: None, - } - } - - /// Returns the remaining bytes left in the chunk being read. - pub fn remaining_chunks_size(&self) -> Option { - self.remaining_chunks_size - } - - /// Unwraps the Decoder into its inner `Read` source. - pub fn into_inner(self) -> R { - self.source - } - - /// Gets a reference to the underlying value in this decoder. - pub fn get_ref(&self) -> &R { - &self.source - } - - /// Gets a mutable reference to the underlying value in this decoder. - pub fn get_mut(&mut self) -> &mut R { - &mut self.source - } - - fn read_chunk_size(&mut self) -> IoResult { - let mut chunk_size_bytes = Vec::new(); - let mut has_ext = false; - - loop { - let byte = match self.source.by_ref().bytes().next() { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - }; - - if byte == b'\r' { - break; - } - - if byte == b';' { - has_ext = true; - break; - } - - chunk_size_bytes.push(byte); - } - - // Ignore extensions for now - if has_ext { - loop { - let byte = match self.source.by_ref().bytes().next() { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - }; - if byte == b'\r' { - break; - } - } - } - - self.read_line_feed()?; - - let chunk_size = String::from_utf8(chunk_size_bytes) - .ok() - .and_then(|c| usize::from_str_radix(c.trim(), 16).ok()) - .ok_or_else(|| IoError::new(ErrorKind::InvalidInput, DecoderError))?; - - Ok(chunk_size) - } - - fn read_carriage_return(&mut self) -> IoResult<()> { - match self.source.by_ref().bytes().next() { - Some(Ok(b'\r')) => Ok(()), - _ => Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - } - } - - fn read_line_feed(&mut self) -> IoResult<()> { - match self.source.by_ref().bytes().next() { - Some(Ok(b'\n')) => Ok(()), - _ => Err(IoError::new(ErrorKind::InvalidInput, DecoderError)), - } - } -} - -impl Read for Decoder -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - let remaining_chunks_size = match self.remaining_chunks_size { - Some(c) => c, - None => { - // first possibility: we are not in a chunk, so we'll attempt to determine - // the chunks size - let chunk_size = self.read_chunk_size()?; - - // if the chunk size is 0, we are at EOF - if chunk_size == 0 { - self.read_carriage_return()?; - self.read_line_feed()?; - return Ok(0); - } - - chunk_size - } - }; - - // second possibility: we continue reading from a chunk - if buf.len() < remaining_chunks_size { - let read = self.source.read(buf)?; - self.remaining_chunks_size = Some(remaining_chunks_size - read); - return Ok(read); - } - - // third possibility: the read request goes further than the current chunk - // we simply read until the end of the chunk and return - assert!(buf.len() >= remaining_chunks_size); - - let buf = &mut buf[..remaining_chunks_size]; - let read = self.source.read(buf)?; - - self.remaining_chunks_size = if read == remaining_chunks_size { - self.read_carriage_return()?; - self.read_line_feed()?; - None - } else { - Some(remaining_chunks_size - read) - }; - - Ok(read) - } -} - -#[derive(Debug, Copy, Clone)] -struct DecoderError; - -impl fmt::Display for DecoderError { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { - write!(fmt, "Error while decoding chunks") - } -} - -impl Error for DecoderError { - fn description(&self) -> &str { - "Error while decoding chunks" - } -} - -#[cfg(test)] -mod test { - use super::Decoder; - use std::io; - use std::io::Read; - - /// This unit test is taken from from Hyper - /// https://github.com/hyperium/hyper - /// Copyright (c) 2014 Sean McArthur - #[test] - fn test_read_chunk_size() { - fn read(s: &str, expected: usize) { - let mut decoded = Decoder::new(s.as_bytes()); - let actual = decoded.read_chunk_size().unwrap(); - assert_eq!(expected, actual); - } - - fn read_err(s: &str) { - let mut decoded = Decoder::new(s.as_bytes()); - let err_kind = decoded.read_chunk_size().unwrap_err().kind(); - assert_eq!(err_kind, io::ErrorKind::InvalidInput); - } - - read("1\r\n", 1); - read("01\r\n", 1); - read("0\r\n", 0); - read("00\r\n", 0); - read("A\r\n", 10); - read("a\r\n", 10); - read("Ff\r\n", 255); - read("Ff \r\n", 255); - // Missing LF or CRLF - read_err("F\rF"); - read_err("F"); - // Invalid hex digit - read_err("X\r\n"); - read_err("1X\r\n"); - read_err("-\r\n"); - read_err("-1\r\n"); - // Acceptable (if not fully valid) extensions do not influence the size - read("1;extension\r\n", 1); - read("a;ext name=value\r\n", 10); - read("1;extension;extension2\r\n", 1); - read("1;;; ;\r\n", 1); - read("2; extension...\r\n", 2); - read("3 ; extension=123\r\n", 3); - read("3 ;\r\n", 3); - read("3 ; \r\n", 3); - // Invalid extensions cause an error - read_err("1 invalid extension\r\n"); - read_err("1 A\r\n"); - read_err("1;no CRLF"); - } - - #[test] - fn test_valid_chunk_decode() { - let source = io::Cursor::new( - "3\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - decoded.read_to_string(&mut string).unwrap(); - - assert_eq!(string, "hello world!!!"); - } - - #[test] - fn test_decode_zero_length() { - let mut decoder = Decoder::new(b"0\r\n\r\n" as &[u8]); - - let mut decoded = String::new(); - decoder.read_to_string(&mut decoded).unwrap(); - - assert_eq!(decoded, ""); - } - - #[test] - fn test_decode_invalid_chunk_length() { - let mut decoder = Decoder::new(b"m\r\n\r\n" as &[u8]); - - let mut decoded = String::new(); - assert!(decoder.read_to_string(&mut decoded).is_err()); - } - - #[test] - fn invalid_input1() { - let source = io::Cursor::new( - "2\r\nhel\r\nb\r\nlo world!!!\r\n0\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - assert!(decoded.read_to_string(&mut string).is_err()); - } - - #[test] - fn invalid_input2() { - let source = io::Cursor::new( - "3\rhel\r\nb\r\nlo world!!!\r\n0\r\n" - .to_string() - .into_bytes(), - ); - let mut decoded = Decoder::new(source); - - let mut string = String::new(); - assert!(decoded.read_to_string(&mut string).is_err()); - } -} diff --git a/anneal/vendor/chunked_transfer/src/encoder.rs b/anneal/vendor/chunked_transfer/src/encoder.rs deleted file mode 100644 index f1f45d0cc9..0000000000 --- a/anneal/vendor/chunked_transfer/src/encoder.rs +++ /dev/null @@ -1,207 +0,0 @@ -use std::io::Result as IoResult; -use std::io::Write; - -/// Splits the incoming data into HTTP chunks. -/// -/// # Example -/// -/// ``` -/// use chunked_transfer::Encoder; -/// use std::io::Write; -/// -/// let mut decoded = "hello world"; -/// let mut encoded: Vec = vec![]; -/// -/// { -/// let mut encoder = Encoder::with_chunks_size(&mut encoded, 5); -/// encoder.write_all(decoded.as_bytes()); -/// } -/// -/// assert_eq!(encoded, b"5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); -/// ``` -pub struct Encoder -where - W: Write, -{ - // where to send the result - output: W, - - // size of each chunk - chunks_size: usize, - - // data waiting to be sent is stored here - // This will always be at least 6 bytes long. The first 6 bytes - // are reserved for the chunk size and \r\n. - buffer: Vec, - - // Flushes the internal buffer after each write. This might be useful - // if data should be sent immediately to downstream consumers - flush_after_write: bool, -} - -const MAX_CHUNK_SIZE: usize = std::u32::MAX as usize; -// This accounts for four hex digits (enough to hold a u32) plus two bytes -// for the \r\n -const MAX_HEADER_SIZE: usize = 6; - -impl Encoder -where - W: Write, -{ - pub fn new(output: W) -> Encoder { - Encoder::with_chunks_size(output, 8192) - } - - /// Gets a reference to the underlying value in this encoder. - pub fn get_ref(&self) -> &W { - &self.output - } - - /// Gets a mutable reference to the underlying value in this encoder. - pub fn get_mut(&mut self) -> &mut W { - &mut self.output - } - - pub fn with_chunks_size(output: W, chunks: usize) -> Encoder { - let chunks_size = chunks.min(MAX_CHUNK_SIZE); - let mut encoder = Encoder { - output, - chunks_size, - buffer: vec![0; MAX_HEADER_SIZE], - flush_after_write: false, - }; - encoder.reset_buffer(); - encoder - } - - pub fn with_flush_after_write(output: W) -> Encoder { - let mut encoder = Encoder { - output, - chunks_size: 8192, - buffer: vec![0; MAX_HEADER_SIZE], - flush_after_write: true, - }; - encoder.reset_buffer(); - encoder - } - - fn reset_buffer(&mut self) { - // Reset buffer, still leaving space for the chunk size. That space - // will be populated once we know the size of the chunk. - self.buffer.truncate(MAX_HEADER_SIZE); - } - - fn is_buffer_empty(&self) -> bool { - self.buffer.len() == MAX_HEADER_SIZE - } - - fn buffer_len(&self) -> usize { - self.buffer.len() - MAX_HEADER_SIZE - } - - fn send(&mut self) -> IoResult<()> { - // Never send an empty buffer, because that would be interpreted - // as the end of the stream, which we indicate explicitly on drop. - if self.is_buffer_empty() { - return Ok(()); - } - // Prepend the length and \r\n to the buffer. - let prelude = format!("{:x}\r\n", self.buffer_len()); - let prelude = prelude.as_bytes(); - - // This should never happen because MAX_CHUNK_SIZE of u32::MAX - // can always be encoded in 4 hex bytes. - assert!( - prelude.len() <= MAX_HEADER_SIZE, - "invariant failed: prelude longer than MAX_HEADER_SIZE" - ); - - // Copy the prelude into the buffer. For small chunks, this won't necessarily - // take up all the space that was reserved for the prelude. - let offset = MAX_HEADER_SIZE - prelude.len(); - self.buffer[offset..MAX_HEADER_SIZE].clone_from_slice(prelude); - - // Append the chunk-finishing \r\n to the buffer. - self.buffer.write_all(b"\r\n")?; - - self.output.write_all(&self.buffer[offset..])?; - self.reset_buffer(); - - Ok(()) - } -} - -impl Write for Encoder -where - W: Write, -{ - fn write(&mut self, data: &[u8]) -> IoResult { - let remaining_buffer_space = self.chunks_size - self.buffer_len(); - let bytes_to_buffer = std::cmp::min(remaining_buffer_space, data.len()); - self.buffer.extend_from_slice(&data[0..bytes_to_buffer]); - let more_to_write: bool = bytes_to_buffer < data.len(); - if self.flush_after_write || more_to_write { - self.send()?; - } - - // If we didn't write the whole thing, keep working on it. - if more_to_write { - self.write_all(&data[bytes_to_buffer..])?; - } - Ok(data.len()) - } - - fn flush(&mut self) -> IoResult<()> { - self.send() - } -} - -impl Drop for Encoder -where - W: Write, -{ - fn drop(&mut self) { - self.flush().ok(); - write!(self.output, "0\r\n\r\n").ok(); - } -} - -#[cfg(test)] -mod test { - use super::Encoder; - use std::io; - use std::io::Write; - use std::str::from_utf8; - - #[test] - fn test() { - let mut source = io::Cursor::new("hello world".to_string().into_bytes()); - let mut dest: Vec = vec![]; - - { - let mut encoder = Encoder::with_chunks_size(dest.by_ref(), 5); - io::copy(&mut source, &mut encoder).unwrap(); - assert!(!encoder.is_buffer_empty()); - } - - let output = from_utf8(&dest).unwrap(); - - assert_eq!(output, "5\r\nhello\r\n5\r\n worl\r\n1\r\nd\r\n0\r\n\r\n"); - } - #[test] - fn flush_after_write() { - let mut source = io::Cursor::new("hello world".to_string().into_bytes()); - let mut dest: Vec = vec![]; - - { - let mut encoder = Encoder::with_flush_after_write(dest.by_ref()); - io::copy(&mut source, &mut encoder).unwrap(); - // The internal buffer has been flushed. - assert!(encoder.is_buffer_empty()); - } - - let output = from_utf8(&dest).unwrap(); - - assert_eq!(output, "b\r\nhello world\r\n0\r\n\r\n"); - } -} diff --git a/anneal/vendor/chunked_transfer/src/lib.rs b/anneal/vendor/chunked_transfer/src/lib.rs deleted file mode 100644 index ba9542b334..0000000000 --- a/anneal/vendor/chunked_transfer/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod decoder; -pub use crate::decoder::Decoder; - -mod encoder; -pub use crate::encoder::Encoder; diff --git a/anneal/vendor/fancy-regex/.cargo-checksum.json b/anneal/vendor/fancy-regex/.cargo-checksum.json index f80c5752fc..4991b4963d 100644 --- a/anneal/vendor/fancy-regex/.cargo-checksum.json +++ b/anneal/vendor/fancy-regex/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"cf43644f4417a371f3b570fae27b3a6949dc254c597474a10b7ee23839965437","AUTHORS":"d5fca2653c88ad02d197faead77e22b80c70636b5bec6e02f2805f389a21b86d","CHANGELOG.md":"33e288ac35f2f0045f692c87624de90f10166e3bd0b3b311eeb7d28560a67aa1","CONTRIBUTING.md":"a7e0f3d282301aa5f4b546ed7fc5376159569987a002f24bf57082d49746fde6","Cargo.lock":"8846412681720cb85ae6a79ac3eae84ca145c7cb4a809e0bd52a3cbaed31ee31","Cargo.toml":"fe2d3062136b9c1bdacc09aaf8ad2766a4182de39732498de8bbb21c62f4384a","Cargo.toml.orig":"fc005fab26a48ff9c66f508c538a84b05cb5b5aea0968acf97daf9092687599a","LICENSE":"3bc70e239e91272782006c638fc0452a714d384224f11f0923036b7be07cf9b5","PERFORMANCE.md":"9de4fa787572943e7e350a2688002d571e986190e4869d08587048974bc2fcc6","README.md":"5321b581e5d6bea76875bc3ef93a482184fea9616b45f73781f5ec16542bdf9c","benches/bench.rs":"ec5005c0ec5b5155ae334f9204dffac98b583c377773dbe81e460ecf7404c1d0","codecov.yml":"d6ebfcadb4d940a0f86ab1a99928b673195c7d84cecee17a5eefeaf396c8477b","examples/toy.rs":"33c5f572f2afa1e0d359845708bd984bc95e272b4dcac0eb3ce55668b2a9d03b","src/analyze.rs":"0ea9e0b9661cef8c804a750459d6caf196b298dae1267d52661f1894f88c47d6","src/compile.rs":"54afdafd8004bc3cd27074e949fb1ccf0c81af0992f9c140141bea8f182ed42c","src/error.rs":"931e720cd907f7f62d41c10b69174f286c2944bb4230df8c3c1428aa75056260","src/expand.rs":"6eff8afef144363d8ebbb90922448783cf2ebfc71ef716948bd9da54793663af","src/lib.rs":"5fceb05786b2e860ec2141c8e6bfbb85014c97b4f48cc634d0842b81b0dd6477","src/parse.rs":"8991c0f8b311f404cd63bc8f2beb898055f14c2fd899ccfb86055b396a596229","src/replacer.rs":"5bf1c99d598c27248fd6591dab000e649eedc8f51179f904e00b94ac27919dc3","src/vm.rs":"8442aec0c60680576130f0ebbd6da494bba14d1141e7035f66c68f3849933731","tests/captures.rs":"0b561bbec208af0cdea12c8b10e3c72eab80ef2dbf1a9c1007fdffc7401b4434","tests/common/mod.rs":"b8ab2a7a3a25adad8317c8eb1f4566df6a81978c3a7ab49847ec2f838d77c888","tests/finding.rs":"76e60d370ae71585a304018fe0398e5206fe431fe21bbde6347cc2572afff0e5","tests/matching.rs":"3f8d1e0f6567375866b14610eda6e2dc1e96ed26ba1a451fe0c4bb2bf6f774fb","tests/oniguruma.rs":"78a54ef464d08fa7192959eb50c3de03df7dae0f9d41831b06ecfa170dfcfd65","tests/oniguruma/README.md":"eae6ac089cd32010ffacb4b2f0f8cbac03ad2623e115386af53bfc93e04d1903","tests/oniguruma/test_utf8.c":"1e4813ac64703cfdbcdca359b82856c5c6778abf977e577992f6b34ab26b92de","tests/oniguruma/test_utf8_ignore.c":"88760e1779017c58dfca5b03f382df7b067dceefcb4b52d81aef36f096b918a0","tests/regex_options.rs":"1744e707e8d76f19b999728c6b7de6e0e531342d1cd708af61ffbe74cef84a3f","tests/replace.rs":"689fef80c2cd243a510be212cb8e6a04a30a0b0fa6f1dd6be63b17a9abb158d8","tests/splitting.rs":"55a60e7953e92cf542fff8016c24607d3da4fdf9cbf68712348cc430b2bc0f3f"},"package":"6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"cf43644f4417a371f3b570fae27b3a6949dc254c597474a10b7ee23839965437","AUTHORS":"d5fca2653c88ad02d197faead77e22b80c70636b5bec6e02f2805f389a21b86d","CHANGELOG.md":"33e288ac35f2f0045f692c87624de90f10166e3bd0b3b311eeb7d28560a67aa1","CONTRIBUTING.md":"a7e0f3d282301aa5f4b546ed7fc5376159569987a002f24bf57082d49746fde6","Cargo.lock":"8846412681720cb85ae6a79ac3eae84ca145c7cb4a809e0bd52a3cbaed31ee31","Cargo.toml":"fe2d3062136b9c1bdacc09aaf8ad2766a4182de39732498de8bbb21c62f4384a","Cargo.toml.orig":"fc005fab26a48ff9c66f508c538a84b05cb5b5aea0968acf97daf9092687599a","LICENSE":"3bc70e239e91272782006c638fc0452a714d384224f11f0923036b7be07cf9b5","PERFORMANCE.md":"9de4fa787572943e7e350a2688002d571e986190e4869d08587048974bc2fcc6","README.md":"5321b581e5d6bea76875bc3ef93a482184fea9616b45f73781f5ec16542bdf9c","benches/bench.rs":"ec5005c0ec5b5155ae334f9204dffac98b583c377773dbe81e460ecf7404c1d0","codecov.yml":"d6ebfcadb4d940a0f86ab1a99928b673195c7d84cecee17a5eefeaf396c8477b","examples/toy.rs":"33c5f572f2afa1e0d359845708bd984bc95e272b4dcac0eb3ce55668b2a9d03b","src/analyze.rs":"0ea9e0b9661cef8c804a750459d6caf196b298dae1267d52661f1894f88c47d6","src/compile.rs":"54afdafd8004bc3cd27074e949fb1ccf0c81af0992f9c140141bea8f182ed42c","src/error.rs":"931e720cd907f7f62d41c10b69174f286c2944bb4230df8c3c1428aa75056260","src/expand.rs":"6eff8afef144363d8ebbb90922448783cf2ebfc71ef716948bd9da54793663af","src/lib.rs":"5fceb05786b2e860ec2141c8e6bfbb85014c97b4f48cc634d0842b81b0dd6477","src/parse.rs":"8991c0f8b311f404cd63bc8f2beb898055f14c2fd899ccfb86055b396a596229","src/replacer.rs":"5bf1c99d598c27248fd6591dab000e649eedc8f51179f904e00b94ac27919dc3","src/vm.rs":"8442aec0c60680576130f0ebbd6da494bba14d1141e7035f66c68f3849933731","tests/captures.rs":"0b561bbec208af0cdea12c8b10e3c72eab80ef2dbf1a9c1007fdffc7401b4434","tests/common/mod.rs":"b8ab2a7a3a25adad8317c8eb1f4566df6a81978c3a7ab49847ec2f838d77c888","tests/finding.rs":"76e60d370ae71585a304018fe0398e5206fe431fe21bbde6347cc2572afff0e5","tests/matching.rs":"3f8d1e0f6567375866b14610eda6e2dc1e96ed26ba1a451fe0c4bb2bf6f774fb","tests/oniguruma.rs":"78a54ef464d08fa7192959eb50c3de03df7dae0f9d41831b06ecfa170dfcfd65","tests/oniguruma/.gitattributes":"b8d35d419a619abf4283b4f1e8a3daeaca142c87df6634b4cd706b726d29a88d","tests/oniguruma/README.md":"eae6ac089cd32010ffacb4b2f0f8cbac03ad2623e115386af53bfc93e04d1903","tests/oniguruma/test_utf8.c":"1e4813ac64703cfdbcdca359b82856c5c6778abf977e577992f6b34ab26b92de","tests/oniguruma/test_utf8_ignore.c":"88760e1779017c58dfca5b03f382df7b067dceefcb4b52d81aef36f096b918a0","tests/regex_options.rs":"1744e707e8d76f19b999728c6b7de6e0e531342d1cd708af61ffbe74cef84a3f","tests/replace.rs":"689fef80c2cd243a510be212cb8e6a04a30a0b0fa6f1dd6be63b17a9abb158d8","tests/splitting.rs":"55a60e7953e92cf542fff8016c24607d3da4fdf9cbf68712348cc430b2bc0f3f"},"package":"6e24cb5a94bcae1e5408b0effca5cd7172ea3c5755049c5f3af4cd283a165298"} \ No newline at end of file diff --git a/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes b/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes new file mode 100644 index 0000000000..7d949a450f --- /dev/null +++ b/anneal/vendor/fancy-regex/tests/oniguruma/.gitattributes @@ -0,0 +1,2 @@ +# Imported from oniguruma +*.c linguist-vendored diff --git a/anneal/vendor/httpdate/.cargo-checksum.json b/anneal/vendor/httpdate/.cargo-checksum.json deleted file mode 100644 index 29b7b44f66..0000000000 --- a/anneal/vendor/httpdate/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"158299c819b7d96576c47ecdbb6d8a12749ea3f45de887679fe58e3a462cf6fc",".github/workflows/ci.yml":"9a88cd3211399918ee069a77456e6c9317efeddae0848c681d14d08364211814","Cargo.toml":"d1adbc974f706b302bc844ce7b6d6323d30a1689b9e3bf53ab78ba0bb09a9ed9","Cargo.toml.orig":"935ef51333a927e121be199efebd6aa6df22e14682770d1cfd9d32fd2bc931eb","LICENSE-APACHE":"4d10fe5f3aa176b05b229a248866bad70b834c173f1252a814ff4748d8a13837","LICENSE-MIT":"934887691e05d69d7c86ad3f2c360980fa30c15b035e351f3c9865e99da4debc","README.md":"276cab7dac6cc74706b2aec34e649ef09c5b0149dbf15329020781161bb13673","benches/benchmarks.rs":"13f1208dfb86e3c02dcd67a4c08c2bae300c0a153de5df437eac4a136579ec23","src/date.rs":"87e7de1394f6b0d37128bfbf5943e256c886c35ed3f9078d15a08309c2206c69","src/lib.rs":"1c5b99558a8b2fec28d003b58a198cb2aebd232f0a2d162906524c5e6ead162e"},"package":"df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"} \ No newline at end of file diff --git a/anneal/vendor/httpdate/.cargo_vcs_info.json b/anneal/vendor/httpdate/.cargo_vcs_info.json deleted file mode 100644 index f43f4cfa20..0000000000 --- a/anneal/vendor/httpdate/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "638da761065df8b67282b0a1d139c0a7e4a02429" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/httpdate/.github/workflows/ci.yml b/anneal/vendor/httpdate/.github/workflows/ci.yml deleted file mode 100644 index 8a9dfcc7de..0000000000 --- a/anneal/vendor/httpdate/.github/workflows/ci.yml +++ /dev/null @@ -1,24 +0,0 @@ -on: [push, pull_request] - -name: Continuous integration - -jobs: - check-test: - name: Check and test crate - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@stable - - run: cargo check --all-targets - - run: cargo test - - clippy-fmt: - name: Run Clippy and format code - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: dtolnay/rust-toolchain@stable - with: - components: clippy, rustfmt - - run: cargo clippy --all-targets -- -D warnings - - run: cargo fmt --all --check diff --git a/anneal/vendor/httpdate/Cargo.toml b/anneal/vendor/httpdate/Cargo.toml deleted file mode 100644 index f5049680ff..0000000000 --- a/anneal/vendor/httpdate/Cargo.toml +++ /dev/null @@ -1,35 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2021" -rust-version = "1.56" -name = "httpdate" -version = "1.0.3" -authors = ["Pyfisch "] -description = "HTTP date parsing and formatting" -readme = "README.md" -keywords = [ - "http", - "date", - "time", - "simple", - "timestamp", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/pyfisch/httpdate" - -[[bench]] -name = "benchmarks" -harness = false - -[dev-dependencies.criterion] -version = "0.5" diff --git a/anneal/vendor/httpdate/Cargo.toml.orig b/anneal/vendor/httpdate/Cargo.toml.orig deleted file mode 100644 index ddc17f1099..0000000000 --- a/anneal/vendor/httpdate/Cargo.toml.orig +++ /dev/null @@ -1,18 +0,0 @@ -[package] -name = "httpdate" -version = "1.0.3" -authors = ["Pyfisch "] -license = "MIT OR Apache-2.0" -description = "HTTP date parsing and formatting" -keywords = ["http", "date", "time", "simple", "timestamp"] -readme = "README.md" -repository = "https://github.com/pyfisch/httpdate" -edition = "2021" -rust-version = "1.56" - -[dev-dependencies] -criterion = "0.5" - -[[bench]] -name = "benchmarks" -harness = false diff --git a/anneal/vendor/httpdate/LICENSE-APACHE b/anneal/vendor/httpdate/LICENSE-APACHE deleted file mode 100644 index cd482d8976..0000000000 --- a/anneal/vendor/httpdate/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ -Apache License -Version 2.0, January 2004 -http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - -"License" shall mean the terms and conditions for use, reproduction, -and distribution as defined by Sections 1 through 9 of this document. - -"Licensor" shall mean the copyright owner or entity authorized by -the copyright owner that is granting the License. - -"Legal Entity" shall mean the union of the acting entity and all -other entities that control, are controlled by, or are under common -control with that entity. For the purposes of this definition, -"control" means (i) the power, direct or indirect, to cause the -direction or management of such entity, whether by contract or -otherwise, or (ii) ownership of fifty percent (50%) or more of the -outstanding shares, or (iii) beneficial ownership of such entity. - -"You" (or "Your") shall mean an individual or Legal Entity -exercising permissions granted by this License. - -"Source" form shall mean the preferred form for making modifications, -including but not limited to software source code, documentation -source, and configuration files. - -"Object" form shall mean any form resulting from mechanical -transformation or translation of a Source form, including but -not limited to compiled object code, generated documentation, -and conversions to other media types. - -"Work" shall mean the work of authorship, whether in Source or -Object form, made available under the License, as indicated by a -copyright notice that is included in or attached to the work -(an example is provided in the Appendix below). - -"Derivative Works" shall mean any work, whether in Source or Object -form, that is based on (or derived from) the Work and for which the -editorial revisions, annotations, elaborations, or other modifications -represent, as a whole, an original work of authorship. For the purposes -of this License, Derivative Works shall not include works that remain -separable from, or merely link (or bind by name) to the interfaces of, -the Work and Derivative Works thereof. - -"Contribution" shall mean any work of authorship, including -the original version of the Work and any modifications or additions -to that Work or Derivative Works thereof, that is intentionally -submitted to Licensor for inclusion in the Work by the copyright owner -or by an individual or Legal Entity authorized to submit on behalf of -the copyright owner. For the purposes of this definition, "submitted" -means any form of electronic, verbal, or written communication sent -to the Licensor or its representatives, including but not limited to -communication on electronic mailing lists, source code control systems, -and issue tracking systems that are managed by, or on behalf of, the -Licensor for the purpose of discussing and improving the Work, but -excluding communication that is conspicuously marked or otherwise -designated in writing by the copyright owner as "Not a Contribution." - -"Contributor" shall mean Licensor and any individual or Legal Entity -on behalf of whom a Contribution has been received by Licensor and -subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of -this License, each Contributor hereby grants to You a perpetual, -worldwide, non-exclusive, no-charge, royalty-free, irrevocable -copyright license to reproduce, prepare Derivative Works of, -publicly display, publicly perform, sublicense, and distribute the -Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of -this License, each Contributor hereby grants to You a perpetual, -worldwide, non-exclusive, no-charge, royalty-free, irrevocable -(except as stated in this section) patent license to make, have made, -use, offer to sell, sell, import, and otherwise transfer the Work, -where such license applies only to those patent claims licensable -by such Contributor that are necessarily infringed by their -Contribution(s) alone or by combination of their Contribution(s) -with the Work to which such Contribution(s) was submitted. If You -institute patent litigation against any entity (including a -cross-claim or counterclaim in a lawsuit) alleging that the Work -or a Contribution incorporated within the Work constitutes direct -or contributory patent infringement, then any patent licenses -granted to You under this License for that Work shall terminate -as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the -Work or Derivative Works thereof in any medium, with or without -modifications, and in Source or Object form, provided that You -meet the following conditions: - -(a) You must give any other recipients of the Work or -Derivative Works a copy of this License; and - -(b) You must cause any modified files to carry prominent notices -stating that You changed the files; and - -(c) You must retain, in the Source form of any Derivative Works -that You distribute, all copyright, patent, trademark, and -attribution notices from the Source form of the Work, -excluding those notices that do not pertain to any part of -the Derivative Works; and - -(d) If the Work includes a "NOTICE" text file as part of its -distribution, then any Derivative Works that You distribute must -include a readable copy of the attribution notices contained -within such NOTICE file, excluding those notices that do not -pertain to any part of the Derivative Works, in at least one -of the following places: within a NOTICE text file distributed -as part of the Derivative Works; within the Source form or -documentation, if provided along with the Derivative Works; or, -within a display generated by the Derivative Works, if and -wherever such third-party notices normally appear. The contents -of the NOTICE file are for informational purposes only and -do not modify the License. You may add Your own attribution -notices within Derivative Works that You distribute, alongside -or as an addendum to the NOTICE text from the Work, provided -that such additional attribution notices cannot be construed -as modifying the License. - -You may add Your own copyright statement to Your modifications and -may provide additional or different license terms and conditions -for use, reproduction, or distribution of Your modifications, or -for any such Derivative Works as a whole, provided Your use, -reproduction, and distribution of the Work otherwise complies with -the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, -any Contribution intentionally submitted for inclusion in the Work -by You to the Licensor shall be under the terms and conditions of -this License, without any additional terms or conditions. -Notwithstanding the above, nothing herein shall supersede or modify -the terms of any separate license agreement you may have executed -with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade -names, trademarks, service marks, or product names of the Licensor, -except as required for reasonable and customary use in describing the -origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or -agreed to in writing, Licensor provides the Work (and each -Contributor provides its Contributions) on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -implied, including, without limitation, any warranties or conditions -of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A -PARTICULAR PURPOSE. You are solely responsible for determining the -appropriateness of using or redistributing the Work and assume any -risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, -whether in tort (including negligence), contract, or otherwise, -unless required by applicable law (such as deliberate and grossly -negligent acts) or agreed to in writing, shall any Contributor be -liable to You for damages, including any direct, indirect, special, -incidental, or consequential damages of any character arising as a -result of this License or out of the use or inability to use the -Work (including but not limited to damages for loss of goodwill, -work stoppage, computer failure or malfunction, or any and all -other commercial damages or losses), even if such Contributor -has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing -the Work or Derivative Works thereof, You may choose to offer, -and charge a fee for, acceptance of support, warranty, indemnity, -or other liability obligations and/or rights consistent with this -License. However, in accepting such obligations, You may act only -on Your own behalf and on Your sole responsibility, not on behalf -of any other Contributor, and only if You agree to indemnify, -defend, and hold each Contributor harmless for any liability -incurred by, or claims asserted against, such Contributor by reason -of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - -To apply the Apache License to your work, attach the following -boilerplate notice, with the fields enclosed by brackets "[]" -replaced with your own identifying information. (Don't include -the brackets!) The text should be enclosed in the appropriate -comment syntax for the file format. We also recommend that a -file or class name and description of purpose be included on the -same "printed page" as the copyright notice for easier -identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - -http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/httpdate/LICENSE-MIT b/anneal/vendor/httpdate/LICENSE-MIT deleted file mode 100644 index 8819964156..0000000000 --- a/anneal/vendor/httpdate/LICENSE-MIT +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2016 Pyfisch - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/anneal/vendor/httpdate/README.md b/anneal/vendor/httpdate/README.md deleted file mode 100644 index dd436e86e0..0000000000 --- a/anneal/vendor/httpdate/README.md +++ /dev/null @@ -1,27 +0,0 @@ -# Date and time utils for HTTP. - -[![Build Status](https://github.com/pyfisch/httpdate/actions/workflows/ci.yml/badge.svg)](https://github.com/pyfisch/httpdate/actions/workflows/ci.yml) -[![Crates.io](https://img.shields.io/crates/v/httpdate.svg)](https://crates.io/crates/httpdate) -[![Documentation](https://docs.rs/httpdate/badge.svg)](https://docs.rs/httpdate) - -Multiple HTTP header fields store timestamps. -For example a response created on May 15, 2015 may contain the header -`Date: Fri, 15 May 2015 15:34:21 GMT`. Since the timestamp does not -contain any timezone or leap second information it is equvivalent to -writing 1431696861 Unix time. Rust’s `SystemTime` is used to store -these timestamps. - -This crate provides two public functions: - -* `parse_http_date` to parse a HTTP datetime string to a system time -* `fmt_http_date` to format a system time to a IMF-fixdate - -In addition it exposes the `HttpDate` type that can be used to parse -and format timestamps. Convert a sytem time to `HttpDate` and vice versa. -The `HttpDate` (8 bytes) is smaller than `SystemTime` (16 bytes) and -using the display impl avoids a temporary allocation. - -Read the [blog post](https://pyfisch.org/blog/http-datetime-handling/) to learn -more. - -Fuzz it by installing *cargo-fuzz* and running `cargo fuzz run fuzz_target_1`. diff --git a/anneal/vendor/httpdate/benches/benchmarks.rs b/anneal/vendor/httpdate/benches/benchmarks.rs deleted file mode 100644 index 4f82467bdb..0000000000 --- a/anneal/vendor/httpdate/benches/benchmarks.rs +++ /dev/null @@ -1,57 +0,0 @@ -use criterion::{black_box, criterion_group, criterion_main, Criterion}; - -pub fn parse_imf_fixdate(c: &mut Criterion) { - c.bench_function("parse_imf_fixdate", |b| { - b.iter(|| { - let d = black_box("Sun, 06 Nov 1994 08:49:37 GMT"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -pub fn parse_rfc850_date(c: &mut Criterion) { - c.bench_function("parse_rfc850_date", |b| { - b.iter(|| { - let d = black_box("Sunday, 06-Nov-94 08:49:37 GMT"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -pub fn parse_asctime(c: &mut Criterion) { - c.bench_function("parse_asctime", |b| { - b.iter(|| { - let d = black_box("Sun Nov 6 08:49:37 1994"); - black_box(httpdate::parse_http_date(d)).unwrap(); - }) - }); -} - -struct BlackBoxWrite; - -impl std::fmt::Write for BlackBoxWrite { - fn write_str(&mut self, s: &str) -> Result<(), std::fmt::Error> { - black_box(s); - Ok(()) - } -} - -pub fn encode_date(c: &mut Criterion) { - c.bench_function("encode_date", |b| { - let d = "Wed, 21 Oct 2015 07:28:00 GMT"; - black_box(httpdate::parse_http_date(d)).unwrap(); - b.iter(|| { - use std::fmt::Write; - let _ = write!(BlackBoxWrite, "{}", d); - }) - }); -} - -criterion_group!( - benches, - parse_imf_fixdate, - parse_rfc850_date, - parse_asctime, - encode_date -); -criterion_main!(benches); diff --git a/anneal/vendor/httpdate/src/date.rs b/anneal/vendor/httpdate/src/date.rs deleted file mode 100644 index 8bc0a3b33b..0000000000 --- a/anneal/vendor/httpdate/src/date.rs +++ /dev/null @@ -1,420 +0,0 @@ -use std::cmp; -use std::fmt::{self, Display, Formatter}; -use std::str::FromStr; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; - -use crate::Error; - -/// HTTP timestamp type. -/// -/// Parse using `FromStr` impl. -/// Format using the `Display` trait. -/// Convert timestamp into/from `SytemTime` to use. -/// Supports comparsion and sorting. -#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] -pub struct HttpDate { - /// 0...59 - sec: u8, - /// 0...59 - min: u8, - /// 0...23 - hour: u8, - /// 1...31 - day: u8, - /// 1...12 - mon: u8, - /// 1970...9999 - year: u16, - /// 1...7 - wday: u8, -} - -impl HttpDate { - fn is_valid(&self) -> bool { - self.sec < 60 - && self.min < 60 - && self.hour < 24 - && self.day > 0 - && self.day < 32 - && self.mon > 0 - && self.mon <= 12 - && self.year >= 1970 - && self.year <= 9999 - && &HttpDate::from(SystemTime::from(*self)) == self - } -} - -impl From for HttpDate { - fn from(v: SystemTime) -> HttpDate { - let dur = v - .duration_since(UNIX_EPOCH) - .expect("all times should be after the epoch"); - let secs_since_epoch = dur.as_secs(); - - if secs_since_epoch >= 253402300800 { - // year 9999 - panic!("date must be before year 9999"); - } - - /* 2000-03-01 (mod 400 year, immediately after feb29 */ - const LEAPOCH: i64 = 11017; - const DAYS_PER_400Y: i64 = 365 * 400 + 97; - const DAYS_PER_100Y: i64 = 365 * 100 + 24; - const DAYS_PER_4Y: i64 = 365 * 4 + 1; - - let days = (secs_since_epoch / 86400) as i64 - LEAPOCH; - let secs_of_day = secs_since_epoch % 86400; - - let mut qc_cycles = days / DAYS_PER_400Y; - let mut remdays = days % DAYS_PER_400Y; - - if remdays < 0 { - remdays += DAYS_PER_400Y; - qc_cycles -= 1; - } - - let mut c_cycles = remdays / DAYS_PER_100Y; - if c_cycles == 4 { - c_cycles -= 1; - } - remdays -= c_cycles * DAYS_PER_100Y; - - let mut q_cycles = remdays / DAYS_PER_4Y; - if q_cycles == 25 { - q_cycles -= 1; - } - remdays -= q_cycles * DAYS_PER_4Y; - - let mut remyears = remdays / 365; - if remyears == 4 { - remyears -= 1; - } - remdays -= remyears * 365; - - let mut year = 2000 + remyears + 4 * q_cycles + 100 * c_cycles + 400 * qc_cycles; - - let months = [31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29]; - let mut mon = 0; - for mon_len in months.iter() { - mon += 1; - if remdays < *mon_len { - break; - } - remdays -= *mon_len; - } - let mday = remdays + 1; - let mon = if mon + 2 > 12 { - year += 1; - mon - 10 - } else { - mon + 2 - }; - - let mut wday = (3 + days) % 7; - if wday <= 0 { - wday += 7 - }; - - HttpDate { - sec: (secs_of_day % 60) as u8, - min: ((secs_of_day % 3600) / 60) as u8, - hour: (secs_of_day / 3600) as u8, - day: mday as u8, - mon: mon as u8, - year: year as u16, - wday: wday as u8, - } - } -} - -impl From for SystemTime { - fn from(v: HttpDate) -> SystemTime { - let leap_years = - ((v.year - 1) - 1968) / 4 - ((v.year - 1) - 1900) / 100 + ((v.year - 1) - 1600) / 400; - let mut ydays = match v.mon { - 1 => 0, - 2 => 31, - 3 => 59, - 4 => 90, - 5 => 120, - 6 => 151, - 7 => 181, - 8 => 212, - 9 => 243, - 10 => 273, - 11 => 304, - 12 => 334, - _ => unreachable!(), - } + v.day as u64 - - 1; - if is_leap_year(v.year) && v.mon > 2 { - ydays += 1; - } - let days = (v.year as u64 - 1970) * 365 + leap_years as u64 + ydays; - UNIX_EPOCH - + Duration::from_secs( - v.sec as u64 + v.min as u64 * 60 + v.hour as u64 * 3600 + days * 86400, - ) - } -} - -impl FromStr for HttpDate { - type Err = Error; - - fn from_str(s: &str) -> Result { - if !s.is_ascii() { - return Err(Error(())); - } - let x = s.trim().as_bytes(); - let date = parse_imf_fixdate(x) - .or_else(|_| parse_rfc850_date(x)) - .or_else(|_| parse_asctime(x))?; - if !date.is_valid() { - return Err(Error(())); - } - Ok(date) - } -} - -impl Display for HttpDate { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - let wday = match self.wday { - 1 => b"Mon", - 2 => b"Tue", - 3 => b"Wed", - 4 => b"Thu", - 5 => b"Fri", - 6 => b"Sat", - 7 => b"Sun", - _ => unreachable!(), - }; - - let mon = match self.mon { - 1 => b"Jan", - 2 => b"Feb", - 3 => b"Mar", - 4 => b"Apr", - 5 => b"May", - 6 => b"Jun", - 7 => b"Jul", - 8 => b"Aug", - 9 => b"Sep", - 10 => b"Oct", - 11 => b"Nov", - 12 => b"Dec", - _ => unreachable!(), - }; - - let mut buf: [u8; 29] = *b" , 00 0000 00:00:00 GMT"; - buf[0] = wday[0]; - buf[1] = wday[1]; - buf[2] = wday[2]; - buf[5] = b'0' + (self.day / 10); - buf[6] = b'0' + (self.day % 10); - buf[8] = mon[0]; - buf[9] = mon[1]; - buf[10] = mon[2]; - buf[12] = b'0' + (self.year / 1000) as u8; - buf[13] = b'0' + (self.year / 100 % 10) as u8; - buf[14] = b'0' + (self.year / 10 % 10) as u8; - buf[15] = b'0' + (self.year % 10) as u8; - buf[17] = b'0' + (self.hour / 10); - buf[18] = b'0' + (self.hour % 10); - buf[20] = b'0' + (self.min / 10); - buf[21] = b'0' + (self.min % 10); - buf[23] = b'0' + (self.sec / 10); - buf[24] = b'0' + (self.sec % 10); - f.write_str(std::str::from_utf8(&buf[..]).unwrap()) - } -} - -impl Ord for HttpDate { - fn cmp(&self, other: &HttpDate) -> cmp::Ordering { - SystemTime::from(*self).cmp(&SystemTime::from(*other)) - } -} - -impl PartialOrd for HttpDate { - fn partial_cmp(&self, other: &HttpDate) -> Option { - Some(self.cmp(other)) - } -} - -fn toint_1(x: u8) -> Result { - let result = x.wrapping_sub(b'0'); - if result < 10 { - Ok(result) - } else { - Err(Error(())) - } -} - -fn toint_2(s: &[u8]) -> Result { - let high = s[0].wrapping_sub(b'0'); - let low = s[1].wrapping_sub(b'0'); - - if high < 10 && low < 10 { - Ok(high * 10 + low) - } else { - Err(Error(())) - } -} - -#[allow(clippy::many_single_char_names)] -fn toint_4(s: &[u8]) -> Result { - let a = u16::from(s[0].wrapping_sub(b'0')); - let b = u16::from(s[1].wrapping_sub(b'0')); - let c = u16::from(s[2].wrapping_sub(b'0')); - let d = u16::from(s[3].wrapping_sub(b'0')); - - if a < 10 && b < 10 && c < 10 && d < 10 { - Ok(a * 1000 + b * 100 + c * 10 + d) - } else { - Err(Error(())) - } -} - -fn parse_imf_fixdate(s: &[u8]) -> Result { - // Example: `Sun, 06 Nov 1994 08:49:37 GMT` - if s.len() != 29 || &s[25..] != b" GMT" || s[16] != b' ' || s[19] != b':' || s[22] != b':' { - return Err(Error(())); - } - Ok(HttpDate { - sec: toint_2(&s[23..25])?, - min: toint_2(&s[20..22])?, - hour: toint_2(&s[17..19])?, - day: toint_2(&s[5..7])?, - mon: match &s[7..12] { - b" Jan " => 1, - b" Feb " => 2, - b" Mar " => 3, - b" Apr " => 4, - b" May " => 5, - b" Jun " => 6, - b" Jul " => 7, - b" Aug " => 8, - b" Sep " => 9, - b" Oct " => 10, - b" Nov " => 11, - b" Dec " => 12, - _ => return Err(Error(())), - }, - year: toint_4(&s[12..16])?, - wday: match &s[..5] { - b"Mon, " => 1, - b"Tue, " => 2, - b"Wed, " => 3, - b"Thu, " => 4, - b"Fri, " => 5, - b"Sat, " => 6, - b"Sun, " => 7, - _ => return Err(Error(())), - }, - }) -} - -fn parse_rfc850_date(s: &[u8]) -> Result { - // Example: `Sunday, 06-Nov-94 08:49:37 GMT` - if s.len() < 23 { - return Err(Error(())); - } - - fn wday<'a>(s: &'a [u8], wday: u8, name: &'static [u8]) -> Option<(u8, &'a [u8])> { - if &s[0..name.len()] == name { - return Some((wday, &s[name.len()..])); - } - None - } - let (wday, s) = wday(s, 1, b"Monday, ") - .or_else(|| wday(s, 2, b"Tuesday, ")) - .or_else(|| wday(s, 3, b"Wednesday, ")) - .or_else(|| wday(s, 4, b"Thursday, ")) - .or_else(|| wday(s, 5, b"Friday, ")) - .or_else(|| wday(s, 6, b"Saturday, ")) - .or_else(|| wday(s, 7, b"Sunday, ")) - .ok_or(Error(()))?; - if s.len() != 22 || s[12] != b':' || s[15] != b':' || &s[18..22] != b" GMT" { - return Err(Error(())); - } - let mut year = u16::from(toint_2(&s[7..9])?); - if year < 70 { - year += 2000; - } else { - year += 1900; - } - Ok(HttpDate { - sec: toint_2(&s[16..18])?, - min: toint_2(&s[13..15])?, - hour: toint_2(&s[10..12])?, - day: toint_2(&s[0..2])?, - mon: match &s[2..7] { - b"-Jan-" => 1, - b"-Feb-" => 2, - b"-Mar-" => 3, - b"-Apr-" => 4, - b"-May-" => 5, - b"-Jun-" => 6, - b"-Jul-" => 7, - b"-Aug-" => 8, - b"-Sep-" => 9, - b"-Oct-" => 10, - b"-Nov-" => 11, - b"-Dec-" => 12, - _ => return Err(Error(())), - }, - year, - wday, - }) -} - -fn parse_asctime(s: &[u8]) -> Result { - // Example: `Sun Nov 6 08:49:37 1994` - if s.len() != 24 || s[10] != b' ' || s[13] != b':' || s[16] != b':' || s[19] != b' ' { - return Err(Error(())); - } - Ok(HttpDate { - sec: toint_2(&s[17..19])?, - min: toint_2(&s[14..16])?, - hour: toint_2(&s[11..13])?, - day: { - let x = &s[8..10]; - { - if x[0] == b' ' { - toint_1(x[1]) - } else { - toint_2(x) - } - }? - }, - mon: match &s[4..8] { - b"Jan " => 1, - b"Feb " => 2, - b"Mar " => 3, - b"Apr " => 4, - b"May " => 5, - b"Jun " => 6, - b"Jul " => 7, - b"Aug " => 8, - b"Sep " => 9, - b"Oct " => 10, - b"Nov " => 11, - b"Dec " => 12, - _ => return Err(Error(())), - }, - year: toint_4(&s[20..24])?, - wday: match &s[0..4] { - b"Mon " => 1, - b"Tue " => 2, - b"Wed " => 3, - b"Thu " => 4, - b"Fri " => 5, - b"Sat " => 6, - b"Sun " => 7, - _ => return Err(Error(())), - }, - }) -} - -fn is_leap_year(y: u16) -> bool { - y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) -} diff --git a/anneal/vendor/httpdate/src/lib.rs b/anneal/vendor/httpdate/src/lib.rs deleted file mode 100644 index 88cb6fa751..0000000000 --- a/anneal/vendor/httpdate/src/lib.rs +++ /dev/null @@ -1,160 +0,0 @@ -//! Date and time utils for HTTP. -//! -//! Multiple HTTP header fields store timestamps. -//! For example a response created on May 15, 2015 may contain the header -//! `Date: Fri, 15 May 2015 15:34:21 GMT`. Since the timestamp does not -//! contain any timezone or leap second information it is equvivalent to -//! writing 1431696861 Unix time. Rust’s `SystemTime` is used to store -//! these timestamps. -//! -//! This crate provides two public functions: -//! -//! * `parse_http_date` to parse a HTTP datetime string to a system time -//! * `fmt_http_date` to format a system time to a IMF-fixdate -//! -//! In addition it exposes the `HttpDate` type that can be used to parse -//! and format timestamps. Convert a sytem time to `HttpDate` and vice versa. -//! The `HttpDate` (8 bytes) is smaller than `SystemTime` (16 bytes) and -//! using the display impl avoids a temporary allocation. -#![forbid(unsafe_code)] - -use std::error; -use std::fmt::{self, Display, Formatter}; -use std::io; -use std::time::SystemTime; - -pub use date::HttpDate; - -mod date; - -/// An opaque error type for all parsing errors. -#[derive(Debug)] -pub struct Error(()); - -impl error::Error for Error {} - -impl Display for Error { - fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> { - f.write_str("string contains no or an invalid date") - } -} - -impl From for io::Error { - fn from(e: Error) -> io::Error { - io::Error::new(io::ErrorKind::Other, e) - } -} - -/// Parse a date from an HTTP header field. -/// -/// Supports the preferred IMF-fixdate and the legacy RFC 805 and -/// ascdate formats. Two digit years are mapped to dates between -/// 1970 and 2069. -pub fn parse_http_date(s: &str) -> Result { - s.parse::().map(|d| d.into()) -} - -/// Format a date to be used in a HTTP header field. -/// -/// Dates are formatted as IMF-fixdate: `Fri, 15 May 2015 15:34:21 GMT`. -pub fn fmt_http_date(d: SystemTime) -> String { - format!("{}", HttpDate::from(d)) -} - -#[cfg(test)] -mod tests { - use std::str; - use std::time::{Duration, UNIX_EPOCH}; - - use super::{fmt_http_date, parse_http_date, HttpDate}; - - #[test] - fn test_rfc_example() { - let d = UNIX_EPOCH + Duration::from_secs(784111777); - assert_eq!( - d, - parse_http_date("Sun, 06 Nov 1994 08:49:37 GMT").expect("#1") - ); - assert_eq!( - d, - parse_http_date("Sunday, 06-Nov-94 08:49:37 GMT").expect("#2") - ); - assert_eq!(d, parse_http_date("Sun Nov 6 08:49:37 1994").expect("#3")); - } - - #[test] - fn test2() { - let d = UNIX_EPOCH + Duration::from_secs(1475419451); - assert_eq!( - d, - parse_http_date("Sun, 02 Oct 2016 14:44:11 GMT").expect("#1") - ); - assert!(parse_http_date("Sun Nov 10 08:00:00 1000").is_err()); - assert!(parse_http_date("Sun Nov 10 08*00:00 2000").is_err()); - assert!(parse_http_date("Sunday, 06-Nov-94 08+49:37 GMT").is_err()); - } - - #[test] - fn test3() { - let mut d = UNIX_EPOCH; - assert_eq!(d, parse_http_date("Thu, 01 Jan 1970 00:00:00 GMT").unwrap()); - d += Duration::from_secs(3600); - assert_eq!(d, parse_http_date("Thu, 01 Jan 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(86400); - assert_eq!(d, parse_http_date("Fri, 02 Jan 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(2592000); - assert_eq!(d, parse_http_date("Sun, 01 Feb 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(2592000); - assert_eq!(d, parse_http_date("Tue, 03 Mar 1970 01:00:00 GMT").unwrap()); - d += Duration::from_secs(31536005); - assert_eq!(d, parse_http_date("Wed, 03 Mar 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(15552000); - assert_eq!(d, parse_http_date("Mon, 30 Aug 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(6048000); - assert_eq!(d, parse_http_date("Mon, 08 Nov 1971 01:00:05 GMT").unwrap()); - d += Duration::from_secs(864000000); - assert_eq!(d, parse_http_date("Fri, 26 Mar 1999 01:00:05 GMT").unwrap()); - } - - #[test] - fn test_fmt() { - let d = UNIX_EPOCH; - assert_eq!(fmt_http_date(d), "Thu, 01 Jan 1970 00:00:00 GMT"); - let d = UNIX_EPOCH + Duration::from_secs(1475419451); - assert_eq!(fmt_http_date(d), "Sun, 02 Oct 2016 14:44:11 GMT"); - } - - #[allow(dead_code)] - fn testcase(data: &[u8]) { - if let Ok(s) = str::from_utf8(data) { - println!("{:?}", s); - if let Ok(d) = parse_http_date(s) { - let o = fmt_http_date(d); - assert!(!o.is_empty()); - } - } - } - - #[test] - fn size_of() { - assert_eq!(::std::mem::size_of::(), 8); - } - - #[test] - fn test_date_comparison() { - let a = UNIX_EPOCH + Duration::from_secs(784111777); - let b = a + Duration::from_secs(30); - assert!(a < b); - let a_date: HttpDate = a.into(); - let b_date: HttpDate = b.into(); - assert!(a_date < b_date); - assert_eq!(a_date.cmp(&b_date), ::std::cmp::Ordering::Less) - } - - #[test] - fn test_parse_bad_date() { - // 1994-11-07 is actually a Monday - let parsed = "Sun, 07 Nov 1994 08:48:37 GMT".parse::(); - assert!(parsed.is_err()) - } -} diff --git a/anneal/vendor/libtest-mimic/.cargo-checksum.json b/anneal/vendor/libtest-mimic/.cargo-checksum.json index d0f2c6f227..b5348ca941 100644 --- a/anneal/vendor/libtest-mimic/.cargo-checksum.json +++ b/anneal/vendor/libtest-mimic/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"acfce605463c185aad0e2084ddb293f63fe48d2c5ce36754571c0a2d8b760f8b","CHANGELOG.md":"70de837dca41cc79e6a81bc3860ed90d98480d652dfcadb731f3e69848d80264","Cargo.lock":"bb5b27bbbf27e4c6526aa029d96f4cc46f8f6a59359ec50af8201bcfe12b208a","Cargo.toml":"7f11401bf48b216f00015d13c3e5c561cd09b1701fbe3b4105f744ae6a050d16","Cargo.toml.orig":"2f57ab1221c851fab5022bd5fce1c270226a2013d72abb4d8f8d35ae4d4ebbed","LICENSE-APACHE":"8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90","LICENSE-MIT":"6f54826bbf67526f2d41937c1904ae2de63ef5707b80c68deadbf073b5669c40","README.md":"2607b42f3591f387eae97d673b78a70745e6da07abacad0d1290297d59e580a7","examples/README.md":"c75a125e1c76b6e00ef5c23d16517dbde99e8a705d5b126bd9d89a6db5c6ed08","examples/simple.rs":"79b77fff7540cd309d0565696ccb0d1f2b7bbd89292a3f62d065deb9e90791f7","examples/tidy.rs":"145dce4e059083bd75046e05eac69d3f381d3edde01de04cad6f530596ffdd31","src/args.rs":"cf3c467b9a2bbfe2cbd745d14097fd64693b7653721ec456e38fb9297d256acd","src/lib.rs":"e43d1f693dc3a1af207e3c39efe1fba4ff4a4fd81eafb6eadd695e9346cccc6f","src/printer.rs":"35fa28570b64a9c5c9818ddd0682174ace28dc7616fd9f420722c1a4e3fd7e86","tests/all_passing.rs":"3e2fe5d97cf25ef172470770fe5ab28b9ea9c3e5ffb3fcea782c91d66dc917f6","tests/common/mod.rs":"a2891648ffe586825320aae4727912813605f8f3c18303a87a2b5e05a4a5373e","tests/json-output.json":"e09948e21e614d11532a91583be9371224b5df179cf87849d0ab5112a45c0d21","tests/mixed_bag.rs":"7c7a349b5cba2da89a642b13d794362d17124e365a68c7dc2eac28c62ac09903","tests/panic.rs":"378ea05bb0d4bb8f83f58eb52a678943209d9ab98575f9b5481b5c633de9417b","tests/real/README.md":"62d50b8a9576d9af7b1fd6bb9ab88874cf05ed158816594e4cee5d61bfcc715e","tests/real/ignored.rs":"4830deb1b09593d69a5b0398270419637be02c958a0238322d987aba07965e7a","tests/real/mixed_bag.rs":"d16c258e09f869f69e8b19be3f7cf0576b7b79cc24aad700b718f7582475ea7c","tests/threads.rs":"dabbbba7dca27a0e927bd751293d684fc549fb1c8591e85ac0f8a38e8f847889"},"package":"14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"acfce605463c185aad0e2084ddb293f63fe48d2c5ce36754571c0a2d8b760f8b","CHANGELOG.md":"70de837dca41cc79e6a81bc3860ed90d98480d652dfcadb731f3e69848d80264","Cargo.lock":"bb5b27bbbf27e4c6526aa029d96f4cc46f8f6a59359ec50af8201bcfe12b208a","Cargo.toml":"7f11401bf48b216f00015d13c3e5c561cd09b1701fbe3b4105f744ae6a050d16","Cargo.toml.orig":"2f57ab1221c851fab5022bd5fce1c270226a2013d72abb4d8f8d35ae4d4ebbed","LICENSE-APACHE":"8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90","LICENSE-MIT":"6f54826bbf67526f2d41937c1904ae2de63ef5707b80c68deadbf073b5669c40","README.md":"2607b42f3591f387eae97d673b78a70745e6da07abacad0d1290297d59e580a7","examples/README.md":"c75a125e1c76b6e00ef5c23d16517dbde99e8a705d5b126bd9d89a6db5c6ed08","examples/simple.rs":"79b77fff7540cd309d0565696ccb0d1f2b7bbd89292a3f62d065deb9e90791f7","examples/tidy.rs":"145dce4e059083bd75046e05eac69d3f381d3edde01de04cad6f530596ffdd31","src/args.rs":"cf3c467b9a2bbfe2cbd745d14097fd64693b7653721ec456e38fb9297d256acd","src/lib.rs":"e43d1f693dc3a1af207e3c39efe1fba4ff4a4fd81eafb6eadd695e9346cccc6f","src/printer.rs":"35fa28570b64a9c5c9818ddd0682174ace28dc7616fd9f420722c1a4e3fd7e86","tests/all_passing.rs":"3e2fe5d97cf25ef172470770fe5ab28b9ea9c3e5ffb3fcea782c91d66dc917f6","tests/common/mod.rs":"a2891648ffe586825320aae4727912813605f8f3c18303a87a2b5e05a4a5373e","tests/json-output.json":"e09948e21e614d11532a91583be9371224b5df179cf87849d0ab5112a45c0d21","tests/mixed_bag.rs":"7c7a349b5cba2da89a642b13d794362d17124e365a68c7dc2eac28c62ac09903","tests/panic.rs":"378ea05bb0d4bb8f83f58eb52a678943209d9ab98575f9b5481b5c633de9417b","tests/real/.gitignore":"926f9b5cbcdc8336736a2e912c21237bc4740b7dd9c0ad94d7b7fa3d9e0307d4","tests/real/README.md":"62d50b8a9576d9af7b1fd6bb9ab88874cf05ed158816594e4cee5d61bfcc715e","tests/real/ignored.rs":"4830deb1b09593d69a5b0398270419637be02c958a0238322d987aba07965e7a","tests/real/mixed_bag.rs":"d16c258e09f869f69e8b19be3f7cf0576b7b79cc24aad700b718f7582475ea7c","tests/threads.rs":"dabbbba7dca27a0e927bd751293d684fc549fb1c8591e85ac0f8a38e8f847889"},"package":"14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"} \ No newline at end of file diff --git a/anneal/vendor/libtest-mimic/tests/real/.gitignore b/anneal/vendor/libtest-mimic/tests/real/.gitignore new file mode 100644 index 0000000000..d1211df8df --- /dev/null +++ b/anneal/vendor/libtest-mimic/tests/real/.gitignore @@ -0,0 +1,3 @@ +# Compiled binaries +mixed_bad +ignored diff --git a/anneal/vendor/portable-atomic/.cargo-checksum.json b/anneal/vendor/portable-atomic/.cargo-checksum.json index 737318624a..9a12bb15b0 100644 --- a/anneal/vendor/portable-atomic/.cargo-checksum.json +++ b/anneal/vendor/portable-atomic/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"482f6b3cc06cfb0c7c9bfa8c260c040a02d762fa4603872cc844a975ab24a8f0","CHANGELOG.md":"b2562dcfd04a5c5907eb348296fa1ca57b7c7420b615c4384d1ee6b024741988","Cargo.lock":"4eea6ec59f568f532cac8e3e71029e24d2fa514d668dd4f86da5168c497b8cf6","Cargo.toml":"3366d6ebb1bada583bfdad414effb4776e4d090e22fd5bbd61c5b8a3560fa17b","Cargo.toml.orig":"ec7bbbc631719bf79a109603f496b852c636062776df74235987d74a825dbbcd","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"f1c6a56dd42e2e1d02f5d7fef3d77dfca493db10d2409edaee7d48cdc1463b45","build.rs":"4bd0a08a8377b9a468a97a98197db80312a802221b1d7421d6efb40e9e447e2a","matrix-old.json":"7e9c4478ef365531a53834130a53da5b9864e786563682b1b9fcf4dd428dcaf3","src/cfgs.rs":"2e7bdfd6ba48957a8760c0cec389c91917bd5965abaa04db32f916e6e75e8aae","src/gen/build.rs":"4ad2fa43f8f725631e9754338f39b80f64a2e61facdb3bd735efc215b95a6597","src/gen/utils.rs":"49dd2efed43772f91e440523e39d7f9974c1a3305eabde4bccf4044a285dd589","src/imp/atomic128/README.md":"240d085f57eff9e5c92cb87498e0d1bb260a4f0fe41cd64eb86cb96e1d686c96","src/imp/atomic128/aarch64.rs":"c6ecab7ffa5c9609ceac0308e12c6ead732a3e246d75f726b5125879090e721e","src/imp/atomic128/intrinsics.rs":"d268e4aa067b25019fd6329d18f0604210d96af3ee6faedb7ec40d8748646d89","src/imp/atomic128/macros.rs":"31f63dd5f6523fdc80d752afdd7b13e90394e7210b8f14bfa38a4feab0822cd5","src/imp/atomic128/mod.rs":"4d12d39ed3c0e5ab46724ac9536598ccc0028147d258b739ed27212c4e4d5e7e","src/imp/atomic128/powerpc64.rs":"3434fc2bd7fa1d4c93205df7c88aea26934bdcbf867282e99cdbb9d1e09b8806","src/imp/atomic128/riscv64.rs":"6f7c2425c9ddaf5c349039b1d341d5f19c1265705fe9df53a677c81dc91bcfb5","src/imp/atomic128/s390x.rs":"1615997158bdad3bf7d16cafe221c8c0885688fa5e074352c31cad242ac98b0a","src/imp/atomic128/x86_64.rs":"dd5e5e05cc5fff506f99b9ece813cf3f113f618a173e2e94249dce077d42ea93","src/imp/atomic64/README.md":"56ef5c1f1750515a6a8a94b9347fd42faa889cddf5a9f77cd7d650008a4a8b7c","src/imp/atomic64/arm_linux.rs":"adfc11193d412e1c89c7ecdefbee81c5278878279a49c461ab0329c6da7522ac","src/imp/atomic64/macros.rs":"5b6f0bfe40064885926cfd57a336f15da92f6964864c50d339d1bb9903802a9d","src/imp/atomic64/mod.rs":"2977468d184134a068179eb8361d73500865b8d1476b87590099d6b503db30e5","src/imp/atomic64/riscv32.rs":"dfc4cf24ea2e02f4838326ccdcdbab81632ef146f8d49f9cc0fcc85ec838962a","src/imp/avr.rs":"fa50cc025a934377ecb7312fe78c519744809c14f1e1d00f73d8613ffc125df8","src/imp/core_atomic.rs":"e17dc0c7498493dea2ee2800b221e23f1d81403dfc4b308c9eff83efe9e0436c","src/imp/detect/README.md":"68db4ae18738636927628c41de5412e784a026f13529dda9cfe4f8407fd5f89c","src/imp/detect/aarch64_aa64reg.rs":"7d1564035c3a5d8ec177ee255860526c7adf5759db4d6380330a490c77d4d494","src/imp/detect/aarch64_apple.rs":"72d77305801b597b3cd30d1204666169aeffa551dfe88efe3f169e10804aaf25","src/imp/detect/aarch64_fuchsia.rs":"cff2f3808bcf30f2b11c7010a8514cc0bda766615a203da87262fec9d918102c","src/imp/detect/aarch64_illumos.rs":"edc9bf24fc43969d36b2d4aaaf45a622d7699c9c06a7cc716c5cbb94b57f10dc","src/imp/detect/aarch64_windows.rs":"4cdf3df6539205800919a6bd8c17eb238b571183bb853a7a4600ab7a7ed7dbe7","src/imp/detect/auxv.rs":"a58e6da2e71c8544f01e3f026591ee2807bf645fb73e2e97911d32bb56d24da7","src/imp/detect/common.rs":"5a9a16421edb7df226d3ab51a20fe6f8cfca1331fc92613583cd0b1e44b19ecb","src/imp/detect/powerpc64_aix.rs":"34f3694a359bd50f18633817528bcffb45bc42db8405a9ab49cefb25fb4af1ee","src/imp/detect/riscv_linux.rs":"aa10f712f6e27cb919cbff03987623f3f21d898fbccadbfc94fffd1f42e5bf80","src/imp/detect/x86_64.rs":"c2849317ab717a5e97b6a72ac048b0139a964c3e85162d7230458de97a7e644b","src/imp/fallback/mod.rs":"e63d984025ae98941e1c2403b2e5e428d4b5aa67a19c465e788aac2a7d18c77b","src/imp/fallback/outline_atomics.rs":"041d872affc4ad0b6b452f695a1373a1f76fe75d1b2377c24c3c0d199d89e383","src/imp/fallback/seq_lock.rs":"71aae56446d9e656037f5b13cc34a15f2ff061db7d4ea2b0a40ff721956dd138","src/imp/fallback/seq_lock_wide.rs":"2b6646e2f737b9253d8c9d143dc0dabbe3d675b9b973a26162b9bc5ab9fb472b","src/imp/fallback/utils.rs":"86f0d521455069988ea33453b1ab9fcf892ea62134686656f4e9875305ba9fdc","src/imp/float/aarch64.rs":"7dfa52d232470a8a0573972d9dde874f5bf03d4d7532174d851010b3686392a7","src/imp/float/int.rs":"8801b336650a039bc6e056857c0f65c2f148a0774c83baa9bd9bf415618107e5","src/imp/float/mod.rs":"2c722182baee05df65f9f6e2b4de5d5474a3b2bf0c24803a65a771de78b76f95","src/imp/interrupt/README.md":"1f4ed0b78b42832800bc8e4db98576f17ef51e8e84b07375fa3e076addbf83e0","src/imp/interrupt/armv4t.rs":"6fb9e7d01f7fb483bc6bec07916fdcba8563b605b53bd87c5310662da04e55a4","src/imp/interrupt/armv6m.rs":"364a38f18ffb2b3cd836700dff6a390d9542f0f2a3eda07bc63bc8868dafaad1","src/imp/interrupt/avr.rs":"17896e2d3e37a03ddc90e884ba09b3e241a8e56ef611fe9790b799c19494b75f","src/imp/interrupt/mod.rs":"27593db509704456fc853f8c6fe28e5dd055b31ddd33a01e4fd6d88d01df4919","src/imp/interrupt/msp430.rs":"bb752aad62bbbddd3b190702ada84bb562e930752eae7de0c96ca0abc620fbe8","src/imp/interrupt/riscv.rs":"f27fe895d55da2ac097fcd1db64cc455a88d0f0d46668cf4ebb61155f8334281","src/imp/interrupt/xtensa.rs":"69e45c6e6a82e06a827967d34268be8c6545138112b46fd7a6610a68f51ba113","src/imp/mod.rs":"2c269d5051f136669cce386cefbe1be90a79e6731f9c42de83091813581a8bea","src/imp/msp430.rs":"16635485eeca1c1c4b866253eefc1f39fa6121c84c16ec389b904c03fa9cdb55","src/imp/riscv.rs":"6a7b7332800141a4da74e1b241e6c04e519b64e4d69ff9b9ef0f9b6a893cb6b0","src/imp/x86.rs":"97c0e1743d7ba7a3dbabd9f49c38ffc71447863ff9c91db53963e003d2b0adf8","src/lib.rs":"5fc1d48545cd2fcd1cba81898657de683f679c6a96b1bd8aea284c19265f167b","src/rustdoc.css":"fb503ec0cf2eb0dacbbdbea63ffb66d538637ddb0a6617cad69906bf58831d7f","src/tests/helper.rs":"08b56889f8fb78efcbd58bb835b66f05dc15672de8cd216d05a12d6a48460563","src/tests/mod.rs":"c1a316f83894a71f1fc870db04d5401774162a277fd7d0b33f955ce35fc05399","src/utils.rs":"3687375efdb580dee21373a9c427030757f640f23b140d4a8d8b47a4085104fa","version.rs":"cc5733c63aeabd7f37c7ae0c47f0be6a7d7a843f911ca181a4d41d9d4fd4c8f0"},"package":"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"482f6b3cc06cfb0c7c9bfa8c260c040a02d762fa4603872cc844a975ab24a8f0","CHANGELOG.md":"b2562dcfd04a5c5907eb348296fa1ca57b7c7420b615c4384d1ee6b024741988","Cargo.lock":"4eea6ec59f568f532cac8e3e71029e24d2fa514d668dd4f86da5168c497b8cf6","Cargo.toml":"3366d6ebb1bada583bfdad414effb4776e4d090e22fd5bbd61c5b8a3560fa17b","Cargo.toml.orig":"ec7bbbc631719bf79a109603f496b852c636062776df74235987d74a825dbbcd","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"f1c6a56dd42e2e1d02f5d7fef3d77dfca493db10d2409edaee7d48cdc1463b45","build.rs":"4bd0a08a8377b9a468a97a98197db80312a802221b1d7421d6efb40e9e447e2a","matrix-old.json":"7e9c4478ef365531a53834130a53da5b9864e786563682b1b9fcf4dd428dcaf3","src/cfgs.rs":"2e7bdfd6ba48957a8760c0cec389c91917bd5965abaa04db32f916e6e75e8aae","src/gen/build.rs":"4ad2fa43f8f725631e9754338f39b80f64a2e61facdb3bd735efc215b95a6597","src/gen/utils.rs":"49dd2efed43772f91e440523e39d7f9974c1a3305eabde4bccf4044a285dd589","src/imp/atomic128/README.md":"240d085f57eff9e5c92cb87498e0d1bb260a4f0fe41cd64eb86cb96e1d686c96","src/imp/atomic128/aarch64.rs":"c6ecab7ffa5c9609ceac0308e12c6ead732a3e246d75f726b5125879090e721e","src/imp/atomic128/intrinsics.rs":"d268e4aa067b25019fd6329d18f0604210d96af3ee6faedb7ec40d8748646d89","src/imp/atomic128/macros.rs":"31f63dd5f6523fdc80d752afdd7b13e90394e7210b8f14bfa38a4feab0822cd5","src/imp/atomic128/mod.rs":"4d12d39ed3c0e5ab46724ac9536598ccc0028147d258b739ed27212c4e4d5e7e","src/imp/atomic128/powerpc64.rs":"3434fc2bd7fa1d4c93205df7c88aea26934bdcbf867282e99cdbb9d1e09b8806","src/imp/atomic128/riscv64.rs":"6f7c2425c9ddaf5c349039b1d341d5f19c1265705fe9df53a677c81dc91bcfb5","src/imp/atomic128/s390x.rs":"1615997158bdad3bf7d16cafe221c8c0885688fa5e074352c31cad242ac98b0a","src/imp/atomic128/x86_64.rs":"dd5e5e05cc5fff506f99b9ece813cf3f113f618a173e2e94249dce077d42ea93","src/imp/atomic64/README.md":"56ef5c1f1750515a6a8a94b9347fd42faa889cddf5a9f77cd7d650008a4a8b7c","src/imp/atomic64/arm_linux.rs":"adfc11193d412e1c89c7ecdefbee81c5278878279a49c461ab0329c6da7522ac","src/imp/atomic64/macros.rs":"5b6f0bfe40064885926cfd57a336f15da92f6964864c50d339d1bb9903802a9d","src/imp/atomic64/mod.rs":"2977468d184134a068179eb8361d73500865b8d1476b87590099d6b503db30e5","src/imp/atomic64/riscv32.rs":"dfc4cf24ea2e02f4838326ccdcdbab81632ef146f8d49f9cc0fcc85ec838962a","src/imp/avr.rs":"fa50cc025a934377ecb7312fe78c519744809c14f1e1d00f73d8613ffc125df8","src/imp/core_atomic.rs":"e17dc0c7498493dea2ee2800b221e23f1d81403dfc4b308c9eff83efe9e0436c","src/imp/detect/README.md":"68db4ae18738636927628c41de5412e784a026f13529dda9cfe4f8407fd5f89c","src/imp/detect/aarch64_aa64reg.rs":"7d1564035c3a5d8ec177ee255860526c7adf5759db4d6380330a490c77d4d494","src/imp/detect/aarch64_apple.rs":"72d77305801b597b3cd30d1204666169aeffa551dfe88efe3f169e10804aaf25","src/imp/detect/aarch64_fuchsia.rs":"cff2f3808bcf30f2b11c7010a8514cc0bda766615a203da87262fec9d918102c","src/imp/detect/aarch64_illumos.rs":"edc9bf24fc43969d36b2d4aaaf45a622d7699c9c06a7cc716c5cbb94b57f10dc","src/imp/detect/aarch64_windows.rs":"4cdf3df6539205800919a6bd8c17eb238b571183bb853a7a4600ab7a7ed7dbe7","src/imp/detect/auxv.rs":"a58e6da2e71c8544f01e3f026591ee2807bf645fb73e2e97911d32bb56d24da7","src/imp/detect/common.rs":"5a9a16421edb7df226d3ab51a20fe6f8cfca1331fc92613583cd0b1e44b19ecb","src/imp/detect/powerpc64_aix.rs":"34f3694a359bd50f18633817528bcffb45bc42db8405a9ab49cefb25fb4af1ee","src/imp/detect/riscv_linux.rs":"aa10f712f6e27cb919cbff03987623f3f21d898fbccadbfc94fffd1f42e5bf80","src/imp/detect/x86_64.rs":"c2849317ab717a5e97b6a72ac048b0139a964c3e85162d7230458de97a7e644b","src/imp/fallback/mod.rs":"e63d984025ae98941e1c2403b2e5e428d4b5aa67a19c465e788aac2a7d18c77b","src/imp/fallback/outline_atomics.rs":"041d872affc4ad0b6b452f695a1373a1f76fe75d1b2377c24c3c0d199d89e383","src/imp/fallback/seq_lock.rs":"71aae56446d9e656037f5b13cc34a15f2ff061db7d4ea2b0a40ff721956dd138","src/imp/fallback/seq_lock_wide.rs":"2b6646e2f737b9253d8c9d143dc0dabbe3d675b9b973a26162b9bc5ab9fb472b","src/imp/fallback/utils.rs":"86f0d521455069988ea33453b1ab9fcf892ea62134686656f4e9875305ba9fdc","src/imp/float/aarch64.rs":"7dfa52d232470a8a0573972d9dde874f5bf03d4d7532174d851010b3686392a7","src/imp/float/int.rs":"8801b336650a039bc6e056857c0f65c2f148a0774c83baa9bd9bf415618107e5","src/imp/float/mod.rs":"2c722182baee05df65f9f6e2b4de5d5474a3b2bf0c24803a65a771de78b76f95","src/imp/interrupt/README.md":"1f4ed0b78b42832800bc8e4db98576f17ef51e8e84b07375fa3e076addbf83e0","src/imp/interrupt/armv4t.rs":"6fb9e7d01f7fb483bc6bec07916fdcba8563b605b53bd87c5310662da04e55a4","src/imp/interrupt/armv6m.rs":"364a38f18ffb2b3cd836700dff6a390d9542f0f2a3eda07bc63bc8868dafaad1","src/imp/interrupt/avr.rs":"17896e2d3e37a03ddc90e884ba09b3e241a8e56ef611fe9790b799c19494b75f","src/imp/interrupt/mod.rs":"27593db509704456fc853f8c6fe28e5dd055b31ddd33a01e4fd6d88d01df4919","src/imp/interrupt/msp430.rs":"bb752aad62bbbddd3b190702ada84bb562e930752eae7de0c96ca0abc620fbe8","src/imp/interrupt/riscv.rs":"f27fe895d55da2ac097fcd1db64cc455a88d0f0d46668cf4ebb61155f8334281","src/imp/interrupt/xtensa.rs":"69e45c6e6a82e06a827967d34268be8c6545138112b46fd7a6610a68f51ba113","src/imp/mod.rs":"2c269d5051f136669cce386cefbe1be90a79e6731f9c42de83091813581a8bea","src/imp/msp430.rs":"16635485eeca1c1c4b866253eefc1f39fa6121c84c16ec389b904c03fa9cdb55","src/imp/riscv.rs":"6a7b7332800141a4da74e1b241e6c04e519b64e4d69ff9b9ef0f9b6a893cb6b0","src/imp/x86.rs":"97c0e1743d7ba7a3dbabd9f49c38ffc71447863ff9c91db53963e003d2b0adf8","src/lib.rs":"5fc1d48545cd2fcd1cba81898657de683f679c6a96b1bd8aea284c19265f167b","src/rustdoc.css":"fb503ec0cf2eb0dacbbdbea63ffb66d538637ddb0a6617cad69906bf58831d7f","src/tests/helper.rs":"08b56889f8fb78efcbd58bb835b66f05dc15672de8cd216d05a12d6a48460563","src/tests/mod.rs":"c1a316f83894a71f1fc870db04d5401774162a277fd7d0b33f955ce35fc05399","src/utils.rs":"3687375efdb580dee21373a9c427030757f640f23b140d4a8d8b47a4085104fa","tests/.gitignore":"3c761e8831e160876acdfee9a0f48bc27270d671f58130bc67445897e9e7de81","version.rs":"cc5733c63aeabd7f37c7ae0c47f0be6a7d7a843f911ca181a4d41d9d4fd4c8f0"},"package":"c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"} \ No newline at end of file diff --git a/anneal/vendor/portable-atomic/tests/.gitignore b/anneal/vendor/portable-atomic/tests/.gitignore new file mode 100644 index 0000000000..2ef89d0aa5 --- /dev/null +++ b/anneal/vendor/portable-atomic/tests/.gitignore @@ -0,0 +1 @@ +!rust-toolchain.toml diff --git a/anneal/vendor/tiny_http/.cargo-checksum.json b/anneal/vendor/tiny_http/.cargo-checksum.json deleted file mode 100644 index 15da0bfa8a..0000000000 --- a/anneal/vendor/tiny_http/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{".cargo_vcs_info.json":"d2a5c2966bca9bcb96f1fb22d7839be5e6dc329dd4e3237696b5c0682720faef",".github/workflows/ci.yaml":"862b496fc6c3802d87dc5472252d5ca0c3622ac8d511938e23d0b99b0b3421a7","CHANGELOG.md":"f502b2cccd3ea9e63111b8cecd540a07ed4fedf00c46c6361607d8fbdfabc2ee","Cargo.lock":"7cb7bf8e1832e3a4d1be881a334fbe26cb63d8d1d215c9024da2a2a7defb0f3c","Cargo.toml":"03c7dfc1df0bbf4274890d33e256baddd4c77e0f9eaee1035ef07a250d229db8","Cargo.toml.orig":"43a7c801ff2acd0fd3af6c26bbdd8824bc0cf188fb19e479cd3c58cdc8d56ea6","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"e69bb98ae371fc43e5ef9cb1fc648762faf92edd93a8afd71411fac419b1b550","README.md":"3f8d7fb0101454ba4a3704d7bd4e29b81a142014b66640f3a0cce936214d95c8","benches/bench.rs":"803e8ac58aadee8bf3c037d622e04473b597c4c3399dfe0951065943599254ab","examples/hello-world.rs":"cc095046b2e9ae44dc095032185db2d478e6e556159614e93917f64c60ba3430","examples/php-cgi-example.php":"72b51bbf38c4b60638ea635752fe071c4f329dcf8a615badaf8228078d63030f","examples/php-cgi.rs":"f2650e84a807f11cec6568a9893169bea17dd2eb0013302d7dda38b5da249a55","examples/readme-example.rs":"5b93dd6584c3bea80896391842ceca5f2f350435b2470c7c0a5dd33fb4a46d92","examples/serve-root.rs":"05d84565ef1e38f5782296ae8bc014b621f4e0b9e7827274b5468efbc1aa3921","examples/ssl-cert.pem":"8a171360b51c9bf4fc9b108e263cfe90c689891c56674cea38e4c29e98c9b836","examples/ssl-key.pem":"e345c5c79dba8fd849f31fb06ee871a32d1f1bf1ef4c15b510e70a2524009626","examples/ssl.rs":"1595c78153214ffc5e5724aba903164e61f33fca1083c727f1d5c417aeee85b5","examples/websockets.rs":"69c96aa370a0378f072dab65fa3ab935309032fe2ddf537c523abce6e9662a0f","src/client.rs":"8fcc6344c2259e91677c267cd9e022a316463a1b03bb805c0a2ec692ef94c898","src/common.rs":"5cae33d9517acdf3f559488acbd4fd727b565ac5e10234b060d37f6398ef2c7b","src/connection.rs":"67dbb92f1d7b3edc8b9fb85b6d770bd50250fb08cde0fdc9e75ceacb68125ac0","src/lib.rs":"5545e94107ab9b4474ad8253d6367f0a20a696ad3f647c97136e21c2824b4a90","src/request.rs":"ef8fcf8d36706a0e1a146f3262917b4631ecf8db925408d4b6959a0d7423695a","src/response.rs":"946c4aa551b7a16cc2ea5f86f8ae2ce9b9bda3faecb2f9d1057d5bc17cb2dbdc","src/ssl.rs":"dd38964c51c5d9fe6dbafd383e172f89d0f62f8d52042e94247cc1d67e07c29e","src/ssl/openssl.rs":"7a7317d2d6d5e75b7e57caa282180a21ec0639e71813e5498a75dcba0dab7e7d","src/ssl/rustls.rs":"d39f329d74f611ec992c0a559a8ea32280b66981380f78683142102a0b758268","src/test.rs":"b6a2a4848acb46fbacc7593629cf6d2fac745e852ead9bf57e014e32623ca1b4","src/util/custom_stream.rs":"a6921b2eb16600070647c41a339c57eb2f616f24116b8b7135cf9a26b2e5ceec","src/util/equal_reader.rs":"7d7916b42316d745c12185509fa5719dd9a032fef1c19fe8057b154f48e8db55","src/util/fused_reader.rs":"2c92bf51a069ec7d6aa647fb44709bbb013131c43cd1667a4a0d1784a57eab6b","src/util/messages_queue.rs":"ac283569e0e24d4f5ff7515a4c74ea08a2cc8439152a17dd1121030429ebcb4f","src/util/mod.rs":"107ceae83c9a10672be797a1805e13772f9c25e68b74e02bef6f45af85018293","src/util/refined_tcp_stream.rs":"f1ee3a06ded63843209120d2d9bf94ae113bc781be91daedce7f5ce9e537a6a1","src/util/sequential.rs":"5ad84c87bd412edec8b289639d6d21486201e84f25a7edc1be4284be59c5570c","src/util/task_pool.rs":"08e3cc8139d1512bb751f828e9838579d8848607e7172ae41b4033d8ecc46fdb","tests/input-tests.rs":"591757acb069d74c6f3a36acee1d931ddb13fe9bc06fe8527d23527071c36e35","tests/network.rs":"ccb382c4c2205caa6025ad8c53c8c101f4fb7f2288c6891c6e04ddb6b31882d3","tests/non-chunked-buffering.rs":"66548e609ce52e8b20e557c3cebab465ed276af5246ea60921a3c344507a0a94","tests/promptness.rs":"1a59a54cde25b90d737f1285a5173b560f962bb8ca9e0a6c74477a5b366b431d","tests/simple-test.rs":"0bf6f66c281fb0ac1b59228c6933cfe49ba8423b7c4fb211b72fa0d800153250","tests/support/mod.rs":"2aed60864d0edb33157bfb3da9fe5d373001cf411a2e6b6fcb065dc972cc8887","tests/unblock-test.rs":"f4a474b808bc0832cf6b1c0e1db754d81a2ae2ea6cf1f539838ac23051e5f8f7","tests/unix-test.rs":"9b104a35858ef9b11d8c7e8803c2399d01b01b2faaf75a10d66dc110356f7dca"},"package":"389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"} \ No newline at end of file diff --git a/anneal/vendor/tiny_http/.cargo_vcs_info.json b/anneal/vendor/tiny_http/.cargo_vcs_info.json deleted file mode 100644 index 1fbb959db3..0000000000 --- a/anneal/vendor/tiny_http/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "212b1c45852fef2093dc1374875a9393c55eb4b9" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/anneal/vendor/tiny_http/.github/workflows/ci.yaml b/anneal/vendor/tiny_http/.github/workflows/ci.yaml deleted file mode 100644 index e4902a57ad..0000000000 --- a/anneal/vendor/tiny_http/.github/workflows/ci.yaml +++ /dev/null @@ -1,64 +0,0 @@ -on: [push, pull_request] -name: CI -jobs: - clippy_rustfmt: - name: Lint & Format - runs-on: ubuntu-latest - strategy: - matrix: - features: - - default - - ssl-openssl - - ssl-rustls - steps: - - uses: actions/checkout@v2 - - name: Install stable toolchain - uses: actions-rs/toolchain@v1 - with: - toolchain: stable - components: rustfmt, clippy - - - name: Clippy - uses: actions-rs/cargo@v1 - with: - command: clippy - args: --features ${{ matrix.features }} - - - name: Format - uses: actions-rs/cargo@v1 - with: - command: fmt - args: -- --check - - test: - name: Build & Test - runs-on: ubuntu-latest - strategy: - matrix: - rust: - - stable - - nightly - - 1.56 - features: - - default - - ssl-openssl - - ssl-rustls - steps: - - uses: actions/checkout@v2 - - name: Install toolchain - uses: actions-rs/toolchain@v1 - with: - toolchain: ${{ matrix.rust }} - override: true - - - name: Build - uses: actions-rs/cargo@v1 - with: - command: build - args: --features ${{ matrix.features }} - - - name: Test - uses: actions-rs/cargo@v1 - with: - command: test - args: --features ${{ matrix.features }} diff --git a/anneal/vendor/tiny_http/CHANGELOG.md b/anneal/vendor/tiny_http/CHANGELOG.md deleted file mode 100644 index 59c5ad9e1c..0000000000 --- a/anneal/vendor/tiny_http/CHANGELOG.md +++ /dev/null @@ -1,172 +0,0 @@ -# Changes - -## 0.12.0 -* Bumped the minimum compiler version tested by CI to 1.56 - this is necessary due to an increasing number of dependencies - introducing Cargo manifest features only supported on newer versions of Rust. - -* [Add support for UNIX sockets](https://github.com/tiny-http/tiny-http/pull/224) - - Thanks to @ColonelThirtyTwo for adding support for binding to UNIX sockets when creating a tiny-http server. This change - makes a few small breaking API modifications, if you are constructing `ServerConfig` manually you will need to use the new `ListenAddr` - type rather than directly supplying a `net::SocketAddr`. Likewise `Server::server_addr()` will now return an enum that can - represent either a TCP socket or a UNIX socket. - - Finally `Request::remote_addr()` now returns an `Option<&SocketAddr>` as UNIX sockets don't ever have a remote host. - -* [Reduce required dependencies by switching to `httpdate`](https://github.com/tiny-http/tiny-http/pull/228) - - @esheppa replaced our internal HTTPDate type with the `httpdate` library (used extensively in the community by Hyper, Tokio and others) - which reduces our baseline dependency tree from 18 crates to 5! - -* `TestRequest::path` no longer has a `'static` bound, allowing for fuzzers to generate test request paths at runtime. - -* Unpinned `zeroize` so it can float around any stable `^1` version. - -## 0.11.0 - -* [Add support for Rustls](https://github.com/tiny-http/tiny-http/pull/218) - - Thanks to @3xmblzj5 and @travispaul for their help in implementing [`Rustls`](https://github.com/rustls/rustls) as a - drop-in replacement for OpenSSL, you can now build `tiny-http` with TLS support without any external dependencies! - OpenSSL will remain the default implementation if you just enable the `ssl` feature, but you are strongly encouraged - to use `ssl-rustls` where possible! - -* [Fix incorrect certificate chain loading](https://github.com/tiny-http/tiny-http/commit/876efd6b752e991c699d27d3d0ad9a47e9d35c29) - - Fix a longstanding bug where we were only loading the first (i.e. the leaf) certificate from any PEM file supplied by - the user. - - -## 0.10.0 - -* [Replace chrono with time-rs](https://github.com/tiny-http/tiny-http/commit/75ac7758fd0ca660c35f58c2a36edb23a42cda32) - - `chrono` was only used to store and format `DateTime` into the slightly odd format required by RFC 7231, so to - avoid the numerous RUSTSEC advisories generated by the `localtime_r` issue, we can just drop it entirely and switch - to `time-rs`. - Unfortunately this means we need to **bump our minimum tested compiler version to 1.51**, and as such this change - requires a full minor release. - -## 0.9.0 - -* [Rust 2018 Refactor](https://github.com/tiny-http/tiny-http/pull/208) -* [Enable prompt responses, before the request has been fully read](https://github.com/tiny-http/tiny-http/pull/207) - - This isn't an API change, but does result in different behaviour to 0.8.2 and so justifies a minor version bump. - - HTTP requests now return a boxed `FusedReader` which drops the underlying - reader once it reaches EOF, such that the reader no longer needs to be - explicitly consumed and the server may now respond with e.g. a "413 Payload - too large" without waiting for the whole reader. - -* Bumped the minimum compiler version tested by CI to 1.48 (the version supported in Debian Bullseye) - -## 0.8.2 - -* [Add TestRequest for writing server tests more easily](https://github.com/tiny-http/tiny-http/pull/203) - -## 0.8.1 - -* [Don't set Transfer-Encoding for 1xx or 204 Responses](https://github.com/tiny-http/tiny-http/pull/198) - -## 0.8.0 - -* [Fix RUSTSEC-2020-0031](https://github.com/tiny-http/tiny-http/pull/190) -* [Filter out the same socket-closing errors on flush as on write](https://github.com/tiny-http/tiny-http/pull/192) -* [response: Drop the use of EqualReader for TransferEncoding::Identity](https://github.com/tiny-http/tiny-http/pull/183) -* [Add unblock method for graceful shutdown](https://github.com/tiny-http/tiny-http/pull/184) -* [Response: Don't forget `chunked_threshold`](https://github.com/tiny-http/tiny-http/pull/177) -* [Response: Allow manual handling of Range requests](https://github.com/tiny-http/tiny-http/pull/175) -* [Feature | Getters for Response Status Code & Data Length Properties](https://github.com/tiny-http/tiny-http/pull/186) - -## 0.7.0 - -* [Fix HTTPS deadlock](https://github.com/tiny-http/tiny-http/pull/151) -* [Relicense to MIT/Apache-2.0](https://github.com/tiny-http/tiny-http/pull/163) -* [Update `ascii` dependency](https://github.com/tiny-http/tiny-http/pull/165) -* [Fix typo in README](https://github.com/tiny-http/tiny-http/pull/171) -* [Fix compilation errors in benchmark](https://github.com/tiny-http/tiny-http/pull/170) -* [Update `url` dependency](https://github.com/tiny-http/tiny-http/pull/168) -* [Update `chunked_transfer` dependency](https://github.com/tiny-http/tiny-http/pull/166) - -## 0.6.2 - -* [Remove AsciiExt usage](https://github.com/tiny-http/tiny-http/pull/152) -* [Remove unused EncodingDecoder](https://github.com/tiny-http/tiny-http/pull/153) - -## 0.6.1 - -* [Fix documentation typo](https://github.com/tiny-http/tiny-http/pull/148) -* [Expose chunked_threshold on Response](https://github.com/tiny-http/tiny-http/pull/150) - -## 0.6.0 - -* [Bump dependencies](https://github.com/tiny-http/tiny-http/pull/142) -* [Fix `next_header_source` alignment](https://github.com/tiny-http/tiny-http/pull/140) - -## 0.5.9 - -* Expanded and changed status code description mapping according to IANA registry: - * https://github.com/tiny-http/tiny-http/pull/138 - -## 0.5.8 - -* Update links to reflect repository ownership change: https://github.com/frewsxcv/tiny-http -> https://github.com/tiny-http/tiny-http - -## 0.5.7 - -* Fix using Transfer-Encoding: identity with no content length - * https://github.com/tiny-http/tiny-http/pull/126 - -## 0.5.6 - -* Update link to documentation - * https://github.com/tiny-http/tiny-http/pull/123 -* Fix websockets - * https://github.com/tiny-http/tiny-http/pull/124 -* Drop the request reader earlier - * https://github.com/tiny-http/tiny-http/pull/125 - -## 0.5.5 - -* Start using the log crate - * https://github.com/tiny-http/tiny-http/pull/121 -* Unblock the accept thread on shutdown - * https://github.com/tiny-http/tiny-http/pull/120 - -## 0.5.4 - -* Fix compilation warnings - * https://github.com/tiny-http/tiny-http/pull/118 - -## 0.5.3 - -* Add try_recv_timeout function to the server - * https://github.com/tiny-http/tiny-http/pull/116 - -## 0.5.2 - -* Update ascii to version 0.7 - * https://github.com/tiny-http/tiny-http/pull/114 - -## 0.5.1 - -* Request::respond now returns an IoResult - * https://github.com/tiny-http/tiny-http/pull/110 - -## 0.5.0 - -* HTTPS support - * https://github.com/tiny-http/tiny-http/pull/107 -* Rework the server creation API - * https://github.com/tiny-http/tiny-http/pull/106 - -## 0.4.1 - -* Allow binding to a nic by specifying the socket address - * https://github.com/tiny-http/tiny-http/pull/103 - -## 0.4.0 - -* Make Method into an enum instead of a character string - * https://github.com/tiny-http/tiny-http/pull/102 diff --git a/anneal/vendor/tiny_http/Cargo.lock b/anneal/vendor/tiny_http/Cargo.lock deleted file mode 100644 index 1784e035ef..0000000000 --- a/anneal/vendor/tiny_http/Cargo.lock +++ /dev/null @@ -1,395 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "ascii" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbf56136a5198c7b01a49e3afcbef6cf84597273d298f54432926024107b0109" - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "base64" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bumpalo" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d" - -[[package]] -name = "cc" -version = "1.0.73" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chunked_transfer" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e" - -[[package]] -name = "fdlimit" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0da54a593b34c71b889ee45f5b5bb900c74148c5f7f8c6a9479ee7899f69603c" -dependencies = [ - "libc", -] - -[[package]] -name = "foreign-types" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" -dependencies = [ - "foreign-types-shared", -] - -[[package]] -name = "foreign-types-shared" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" - -[[package]] -name = "httpdate" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421" - -[[package]] -name = "js-sys" -version = "0.3.59" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "libc" -version = "0.2.132" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "once_cell" -version = "1.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0" - -[[package]] -name = "openssl" -version = "0.10.41" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "618febf65336490dfcf20b73f885f5651a0c89c64c2d4a8c3662585a70bf5bd0" -dependencies = [ - "bitflags", - "cfg-if", - "foreign-types", - "libc", - "once_cell", - "openssl-macros", - "openssl-sys", -] - -[[package]] -name = "openssl-macros" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "openssl-sys" -version = "0.9.75" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5f9bd0c2710541a3cda73d6f9ac4f1b240de4ae261065d309dbe73d9dceb42f" -dependencies = [ - "autocfg", - "cc", - "libc", - "pkg-config", - "vcpkg", -] - -[[package]] -name = "pkg-config" -version = "0.3.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae" - -[[package]] -name = "proc-macro2" -version = "1.0.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "ring" -version = "0.16.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" -dependencies = [ - "cc", - "libc", - "once_cell", - "spin", - "untrusted", - "web-sys", - "winapi", -] - -[[package]] -name = "rustc-serialize" -version = "0.3.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda" - -[[package]] -name = "rustls" -version = "0.20.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aab8ee6c7097ed6057f43c187a62418d0c05a4bd5f18b3571db50ee0f9ce033" -dependencies = [ - "log", - "ring", - "sct", - "webpki", -] - -[[package]] -name = "rustls-pemfile" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5eebeaeb360c87bfb72e84abdb3447159c0eaececf1bef2aecd65a8be949d1c9" -dependencies = [ - "base64", -] - -[[package]] -name = "sct" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "sha1" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1da05c97445caa12d05e848c4a4fcbbea29e748ac28f7e80e9b010392063770" -dependencies = [ - "sha1_smol", -] - -[[package]] -name = "sha1_smol" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012" - -[[package]] -name = "spin" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" - -[[package]] -name = "syn" -version = "1.0.99" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "tiny_http" -version = "0.12.0" -dependencies = [ - "ascii", - "chunked_transfer", - "fdlimit", - "httpdate", - "log", - "openssl", - "rustc-serialize", - "rustls", - "rustls-pemfile", - "sha1", - "zeroize", -] - -[[package]] -name = "unicode-ident" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" - -[[package]] -name = "untrusted" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" - -[[package]] -name = "vcpkg" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" - -[[package]] -name = "wasm-bindgen" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a" - -[[package]] -name = "web-sys" -version = "0.3.59" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed055ab27f941423197eb86b2035720b1a3ce40504df082cac2ecc6ed73335a1" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "webpki" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd" -dependencies = [ - "ring", - "untrusted", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "zeroize" -version = "1.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c394b5bd0c6f669e7275d9c20aa90ae064cb22e75a1cad54e1b34088034b149f" diff --git a/anneal/vendor/tiny_http/Cargo.toml b/anneal/vendor/tiny_http/Cargo.toml deleted file mode 100644 index 7f25f3a587..0000000000 --- a/anneal/vendor/tiny_http/Cargo.toml +++ /dev/null @@ -1,82 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -name = "tiny_http" -version = "0.12.0" -authors = [ - "pierre.krieger1708@gmail.com", - "Corey Farwell ", -] -description = "Low level HTTP server library" -documentation = "https://tiny-http.github.io/tiny-http/tiny_http/index.html" -readme = "README.md" -keywords = [ - "http", - "server", - "web", -] -license = "MIT OR Apache-2.0" -repository = "https://github.com/tiny-http/tiny-http" - -[package.metadata.docs.rs] -features = ["ssl-openssl"] - -[dependencies.ascii] -version = "1.0" - -[dependencies.chunked_transfer] -version = "1" - -[dependencies.httpdate] -version = "1.0.2" - -[dependencies.log] -version = "0.4.4" - -[dependencies.openssl] -version = "0.10" -optional = true - -[dependencies.rustls] -version = "0.20" -optional = true - -[dependencies.rustls-pemfile] -version = "0.2.1" -optional = true - -[dependencies.zeroize] -version = "1" -optional = true - -[dev-dependencies.fdlimit] -version = "0.1" - -[dev-dependencies.rustc-serialize] -version = "0.3" - -[dev-dependencies.sha1] -version = "0.6.0" - -[features] -default = [] -ssl = ["ssl-openssl"] -ssl-openssl = [ - "openssl", - "zeroize", -] -ssl-rustls = [ - "rustls", - "rustls-pemfile", - "zeroize", -] diff --git a/anneal/vendor/tiny_http/Cargo.toml.orig b/anneal/vendor/tiny_http/Cargo.toml.orig deleted file mode 100644 index 1bc6851366..0000000000 --- a/anneal/vendor/tiny_http/Cargo.toml.orig +++ /dev/null @@ -1,37 +0,0 @@ -[package] -name = "tiny_http" -version = "0.12.0" -authors = ["pierre.krieger1708@gmail.com", - "Corey Farwell "] -description = "Low level HTTP server library" -documentation = "https://tiny-http.github.io/tiny-http/tiny_http/index.html" -keywords = ["http", "server", "web"] -license = "MIT OR Apache-2.0" -repository = "https://github.com/tiny-http/tiny-http" -edition = "2018" - -[features] -default = [] -ssl = ["ssl-openssl"] -ssl-openssl = ["openssl", "zeroize"] -ssl-rustls = ["rustls", "rustls-pemfile", "zeroize"] - -[dependencies] -ascii = "1.0" -chunked_transfer = "1" -log = "0.4.4" -httpdate = "1.0.2" - -openssl = { version = "0.10", optional = true } -rustls = { version = "0.20", optional = true } -rustls-pemfile = { version = "0.2.1", optional = true } -zeroize = { version = "1", optional = true } - -[dev-dependencies] -rustc-serialize = "0.3" -sha1 = "0.6.0" -fdlimit = "0.1" - -[package.metadata.docs.rs] -# Enable just one SSL implementation -features = ["ssl-openssl"] diff --git a/anneal/vendor/tiny_http/LICENSE-APACHE b/anneal/vendor/tiny_http/LICENSE-APACHE deleted file mode 100644 index 16fe87b06e..0000000000 --- a/anneal/vendor/tiny_http/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/anneal/vendor/tiny_http/LICENSE-MIT b/anneal/vendor/tiny_http/LICENSE-MIT deleted file mode 100644 index 474b78857f..0000000000 --- a/anneal/vendor/tiny_http/LICENSE-MIT +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2014-2019 The tiny-http contributors - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/anneal/vendor/tiny_http/README.md b/anneal/vendor/tiny_http/README.md deleted file mode 100644 index 0d43793793..0000000000 --- a/anneal/vendor/tiny_http/README.md +++ /dev/null @@ -1,108 +0,0 @@ -# tiny-http - -[![Crate][crate_img]][crate] -[![Documentation][docs_img]][docs] -![License][license_img] -[![CI Status][ci_badge]][ci_link] - -[**Documentation**](https://docs.rs/tiny_http) - -Tiny but strong HTTP server in Rust. -Its main objectives are to be 100% compliant with the HTTP standard and to provide an easy way to create an HTTP server. - -What does **tiny-http** handle? - - Accepting and managing connections to the clients - - Parsing requests - - Requests pipelining - - HTTPS (using either OpenSSL or Rustls) - - Transfer-Encoding and Content-Encoding - - Turning user input (eg. POST input) into a contiguous UTF-8 string (**not implemented yet**) - - Ranges (**not implemented yet**) - - `Connection: upgrade` (used by websockets) - -Tiny-http handles everything that is related to client connections and data transfers and encoding. - -Everything else (parsing the values of the headers, multipart data, routing, etags, cache-control, HTML templates, etc.) must be handled by your code. -If you want to create a website in Rust, I strongly recommend using a framework instead of this library. - -### Installation - -Add this to the `Cargo.toml` file of your project: - -```toml -[dependencies] -tiny_http = "0.11" -``` - -### Usage - -```rust -use tiny_http::{Server, Response}; - -let server = Server::http("0.0.0.0:8000").unwrap(); - -for request in server.incoming_requests() { - println!("received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request.respond(response); -} -``` - -### Speed - -Tiny-http was designed with speed in mind: - - Each client connection will be dispatched to a thread pool. Each thread will handle one client. - If there is no thread available when a client connects, a new one is created. Threads that are idle - for a long time (currently 5 seconds) will automatically die. - - If multiple requests from the same client are being pipelined (ie. multiple requests - are sent without waiting for the answer), tiny-http will read them all at once and they will - all be available via `server.recv()`. Tiny-http will automatically rearrange the responses - so that they are sent in the right order. - - One exception to the previous statement exists when a request has a large body (currently > 1kB), - in which case the request handler will read the body directly from the stream and tiny-http - will wait for it to be read before processing the next request. Tiny-http will never wait for - a request to be answered to read the next one. - - When a client connection has sent its last request (by sending `Connection: close` header), - the thread will immediately stop reading from this client and can be reclaimed, even when the - request has not yet been answered. The reading part of the socket will also be immediately closed. - - Decoding the client's request is done lazily. If you don't read the request's body, it will not - be decoded. - -### Examples - -Examples of tiny-http in use: - -* [heroku-tiny-http-hello-world](https://github.com/frewsxcv/heroku-tiny-http-hello-world) - A simple web application demonstrating how to deploy tiny-http to Heroku -* [crate-deps](https://github.com/frewsxcv/crate-deps) - A web service that generates images of dependency graphs for crates hosted on crates.io -* [rouille](https://crates.io/crates/rouille) - Web framework built on tiny-http - -### License - -This project is licensed under either of - - * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or - http://www.apache.org/licenses/LICENSE-2.0) - * MIT license ([LICENSE-MIT](LICENSE-MIT) or - http://opensource.org/licenses/MIT) - -at your option. - -#### Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in tiny-http by you, as defined in the Apache-2.0 license, shall be -dual licensed as above, without any additional terms or conditions. - - -[crate_img]: https://img.shields.io/crates/v/tiny_http.svg?logo=rust "Crate Page" -[crate]: https://crates.io/crates/tiny_http "Crate Link" -[docs]: https://docs.rs/tiny_http "Documentation" -[docs_img]: https://docs.rs/tiny_http/badge.svg "Documentation" -[license_img]: https://img.shields.io/crates/l/tiny_http.svg "License" -[ci_badge]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml/badge.svg "CI Status" -[ci_link]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml "Workflow Link" diff --git a/anneal/vendor/tiny_http/benches/bench.rs b/anneal/vendor/tiny_http/benches/bench.rs deleted file mode 100644 index f011ad793d..0000000000 --- a/anneal/vendor/tiny_http/benches/bench.rs +++ /dev/null @@ -1,80 +0,0 @@ -#![feature(test)] - -extern crate fdlimit; -extern crate test; -extern crate tiny_http; - -use std::io::Write; -use std::process::Command; -use tiny_http::Method; - -#[test] -#[ignore] -// TODO: obtain time -fn curl_bench() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let num_requests = 10usize; - - match Command::new("curl") - .arg("-s") - .arg(format!("http://localhost:{}/?[1-{}]", port, num_requests)) - .output() - { - Ok(p) => p, - Err(_) => return, // ignoring test - }; - - drop(server); -} - -#[bench] -fn sequential_requests(bencher: &mut test::Bencher) { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - let mut stream = std::net::TcpStream::connect(("127.0.0.1", port)).unwrap(); - - bencher.iter(|| { - (write!(stream, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - - let request = server.recv().unwrap(); - - assert_eq!(request.method(), &Method::Get); - - request.respond(tiny_http::Response::new_empty(tiny_http::StatusCode(204))); - }); -} - -#[bench] -fn parallel_requests(bencher: &mut test::Bencher) { - fdlimit::raise_fd_limit(); - - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - bencher.iter(|| { - let mut streams = Vec::new(); - - for _ in 0..1000usize { - let mut stream = std::net::TcpStream::connect(("127.0.0.1", port)).unwrap(); - (write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - streams.push(stream); - } - - loop { - let request = match server.try_recv().unwrap() { - None => break, - Some(rq) => rq, - }; - - assert_eq!(request.method(), &Method::Get); - - request.respond(tiny_http::Response::new_empty(tiny_http::StatusCode(204))); - } - }); -} diff --git a/anneal/vendor/tiny_http/examples/hello-world.rs b/anneal/vendor/tiny_http/examples/hello-world.rs deleted file mode 100644 index bce1a4b96e..0000000000 --- a/anneal/vendor/tiny_http/examples/hello-world.rs +++ /dev/null @@ -1,26 +0,0 @@ -extern crate tiny_http; - -use std::sync::Arc; -use std::thread; - -fn main() { - let server = Arc::new(tiny_http::Server::http("0.0.0.0:9975").unwrap()); - println!("Now listening on port 9975"); - - let mut handles = Vec::new(); - - for _ in 0..4 { - let server = server.clone(); - - handles.push(thread::spawn(move || { - for rq in server.incoming_requests() { - let response = tiny_http::Response::from_string("hello world".to_string()); - let _ = rq.respond(response); - } - })); - } - - for h in handles { - h.join().unwrap(); - } -} diff --git a/anneal/vendor/tiny_http/examples/php-cgi-example.php b/anneal/vendor/tiny_http/examples/php-cgi-example.php deleted file mode 100644 index b19249f445..0000000000 --- a/anneal/vendor/tiny_http/examples/php-cgi-example.php +++ /dev/null @@ -1,3 +0,0 @@ - - -*/ - -fn handle(rq: tiny_http::Request, script: &str) { - use std::io::Write; - use std::process::Command; - - let php = Command::new("php-cgi") - .arg(script) - //.stdin(Ignored) - //.extra_io(Ignored) - .env("AUTH_TYPE", "") - .env( - "CONTENT_LENGTH", - format!("{}", rq.body_length().unwrap_or(0)), - ) - .env("CONTENT_TYPE", "") - .env("GATEWAY_INTERFACE", "CGI/1.1") - .env("PATH_INFO", "") - .env("PATH_TRANSLATED", "") - .env("QUERY_STRING", format!("{}", rq.url())) - .env("REMOTE_ADDR", format!("{}", rq.remote_addr().unwrap())) - .env("REMOTE_HOST", "") - .env("REMOTE_IDENT", "") - .env("REMOTE_USER", "") - .env("REQUEST_METHOD", format!("{}", rq.method())) - .env("SCRIPT_NAME", script) - .env("SERVER_NAME", "tiny-http php-cgi example") - .env("SERVER_PORT", format!("{}", rq.remote_addr().unwrap())) - .env("SERVER_PROTOCOL", "HTTP/1.1") - .env("SERVER_SOFTWARE", "tiny-http php-cgi example") - .output() - .unwrap(); - - // note: this is not a good implementation - // cgi returns the status code in the headers ; also many headers will be missing - // in the response - match php.status { - status if status.success() => { - let mut writer = rq.into_writer(); - let writer: &mut dyn Write = &mut *writer; - - (write!(writer, "HTTP/1.1 200 OK\r\n")).unwrap(); - (write!(writer, "{}", php.stdout.clone().as_ascii_str().unwrap())).unwrap(); - - writer.flush().unwrap(); - } - _ => { - println!( - "Error in script execution: {}", - php.stderr.clone().as_ascii_str().unwrap() - ); - } - } -} - -fn main() { - use std::env; - use std::sync::Arc; - use std::thread::spawn; - - let php_script = { - let mut args = env::args(); - if args.len() < 2 { - println!("Usage: php-cgi "); - return; - } - args.nth(1).unwrap() - }; - - let server = Arc::new(tiny_http::Server::http("0.0.0.0:9975").unwrap()); - println!("Now listening on port 9975"); - - let num_cpus = 4; // TODO: dynamically generate this value - for _ in 0..num_cpus { - let server = server.clone(); - let php_script = php_script.clone(); - - spawn(move || { - for rq in server.incoming_requests() { - handle(rq, &php_script); - } - }); - } -} diff --git a/anneal/vendor/tiny_http/examples/readme-example.rs b/anneal/vendor/tiny_http/examples/readme-example.rs deleted file mode 100644 index e093827d5a..0000000000 --- a/anneal/vendor/tiny_http/examples/readme-example.rs +++ /dev/null @@ -1,19 +0,0 @@ -extern crate tiny_http; - -fn main() { - use tiny_http::{Response, Server}; - - let server = Server::http("0.0.0.0:8000").unwrap(); - - for request in server.incoming_requests() { - println!( - "received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request.respond(response).expect("Responded"); - } -} diff --git a/anneal/vendor/tiny_http/examples/serve-root.rs b/anneal/vendor/tiny_http/examples/serve-root.rs deleted file mode 100644 index 5391c1b09c..0000000000 --- a/anneal/vendor/tiny_http/examples/serve-root.rs +++ /dev/null @@ -1,58 +0,0 @@ -use ascii::AsciiString; -use std::fs; -use std::path::Path; - -extern crate ascii; -extern crate tiny_http; - -fn get_content_type(path: &Path) -> &'static str { - let extension = match path.extension() { - None => return "text/plain", - Some(e) => e, - }; - - match extension.to_str().unwrap() { - "gif" => "image/gif", - "jpg" => "image/jpeg", - "jpeg" => "image/jpeg", - "png" => "image/png", - "pdf" => "application/pdf", - "htm" => "text/html; charset=utf8", - "html" => "text/html; charset=utf8", - "txt" => "text/plain; charset=utf8", - _ => "text/plain; charset=utf8", - } -} - -fn main() { - let server = tiny_http::Server::http("0.0.0.0:8000").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - println!("Now listening on port {}", port); - - loop { - let rq = match server.recv() { - Ok(rq) => rq, - Err(_) => break, - }; - - println!("{:?}", rq); - - let url = rq.url().to_string(); - let path = Path::new(&url); - let file = fs::File::open(&path); - - if file.is_ok() { - let response = tiny_http::Response::from_file(file.unwrap()); - - let response = response.with_header(tiny_http::Header { - field: "Content-Type".parse().unwrap(), - value: AsciiString::from_ascii(get_content_type(&path)).unwrap(), - }); - - let _ = rq.respond(response); - } else { - let rep = tiny_http::Response::new_empty(tiny_http::StatusCode(404)); - let _ = rq.respond(rep); - } - } -} diff --git a/anneal/vendor/tiny_http/examples/ssl-cert.pem b/anneal/vendor/tiny_http/examples/ssl-cert.pem deleted file mode 100644 index 6488a21970..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl-cert.pem +++ /dev/null @@ -1,23 +0,0 @@ ------BEGIN CERTIFICATE----- -MIIDxzCCAq+gAwIBAgIUVB6JBT6sYv0g4IGfZgjelceiqBQwDQYJKoZIhvcNAQEL -BQAwcjELMAkGA1UEBhMCTk8xDTALBgNVBAgMBE5vbmUxDTALBgNVBAcMBE5vbmUx -DTALBgNVBAoMBE5vbmUxDTALBgNVBAsMBE5vbmUxEjAQBgNVBAMMCWxvY2FsaG9z -dDETMBEGCSqGSIb3DQEJARYETm9uZTAgFw0yMjAxMjgyMDQzMjFaGA8yMDcyMDEx -NjIwNDMyMVowcjELMAkGA1UEBhMCTk8xDTALBgNVBAgMBE5vbmUxDTALBgNVBAcM -BE5vbmUxDTALBgNVBAoMBE5vbmUxDTALBgNVBAsMBE5vbmUxEjAQBgNVBAMMCWxv -Y2FsaG9zdDETMBEGCSqGSIb3DQEJARYETm9uZTCCASIwDQYJKoZIhvcNAQEBBQAD -ggEPADCCAQoCggEBANgjc9hZtEwve2usjNrc+2w4bT9fJi2uVQ3eHdtECirBxHrm -rSbSeOyhvTPmonyp81LQv52KzHDLxwVSmFoJkrIKrnqqSzw/ynuqBpykhV3TKPLK -SCZiyqQmGucTIxOXM9ZEB51zCvq+2jL4v2nBueibY2SzXG6MSAjRRC5ezDTYvIMH -12uH0U4a3UMICPTEMluy+mT4S1EGZLTj37+6JQA/1xYzZAifZAGEKRcCd0q5f9IU -V8GnnYjptFFswJJF7EBpExZIlxwTn7c4Un8yjYOTAj9Yw6OiAy6MVv8NSF1DeGmY -wUFHm6eUUmv+YO/T99sdt1dpdf1+807Fa62L1d8CAwEAAaNTMFEwHQYDVR0OBBYE -FCjWLWB1sdWiGdHT/PY4BcuqnJq0MB8GA1UdIwQYMBaAFCjWLWB1sdWiGdHT/PY4 -BcuqnJq0MA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAH+Gafl1 -/yhjg4wVniQRFKqdufMmaEkAgJGaB87/Cjb5dyf1ku3ZvM7SX9MyV2R3tw6hncBQ -E3XbPhOTJXcohGzpZ5hC043eY+/yAjKgbrSH4c0z/g9iSigX1B/F1hfF4Evx1eR6 -WD5CCpA/YLF8Ik09WU2HKFT85sDIygmv0hmuI0dF+9lpqfPguhx6iLOoFyXkbgqF -RDWe8V0/GtEnX4PckdyyYk/uFX5aKMeW5dBY6GL9YDRcZvTLsjJi1wj3OcDsr7n5 -ULkGWiWdQScpkrGWOPoM72r6yyFi5P/RCBI/p0LBseARXAAedgC8tTK6DpfRXe1M -BumieRdjmHDbE+4= ------END CERTIFICATE----- diff --git a/anneal/vendor/tiny_http/examples/ssl-key.pem b/anneal/vendor/tiny_http/examples/ssl-key.pem deleted file mode 100644 index c924759b6e..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl-key.pem +++ /dev/null @@ -1,28 +0,0 @@ ------BEGIN PRIVATE KEY----- -MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDYI3PYWbRML3tr -rIza3PtsOG0/XyYtrlUN3h3bRAoqwcR65q0m0njsob0z5qJ8qfNS0L+disxwy8cF -UphaCZKyCq56qks8P8p7qgacpIVd0yjyykgmYsqkJhrnEyMTlzPWRAedcwr6vtoy -+L9pwbnom2Nks1xujEgI0UQuXsw02LyDB9drh9FOGt1DCAj0xDJbsvpk+EtRBmS0 -49+/uiUAP9cWM2QIn2QBhCkXAndKuX/SFFfBp52I6bRRbMCSRexAaRMWSJccE5+3 -OFJ/Mo2DkwI/WMOjogMujFb/DUhdQ3hpmMFBR5unlFJr/mDv0/fbHbdXaXX9fvNO -xWuti9XfAgMBAAECggEBALRhyiHKo71dd0yigh96g96KrSpRV4SSVOuw7wv6md2b -P0Yu1F1tFHywcz4ogn02PRtlmjV6DCsq9ltL1lh2WtZ6MamwDAApYOyaNtBuQdvP -CgKurU5T7rjWEGe/QevsqddtiUlvJL+lnmch0GYLxwMJBAeb5U1hiBDLzXJBrX1/ -xstCJzYC1MO3zRNuoNudpZyMU18BCbk1E+XMu/yPyJJPm5VSxS3Qe0RIX0nqC3hd -RjwiTGYIqHX/hTFuZta+lNwVSx/8TJY6wTq69r6mGf0hudXz9A0SEhSVdkU77yFE -NLCTRGD8xkF1bJliT57dGofheSrn4+ATR6eMYzsGmYECgYEA/0Ao+dccjMgqiyhR -K3TTaikSSvvTOY/muISvovlpDe1U10+HIPMfGIJUVOE7p4oAbg9W70x8hMox+0hN -yERLp4Pq9skkwxfmGjA0ooKJt0e0Ux1A5LiboLUPGlBsHwNcLqno/vj4WK/TGdZu -51zG1zvBrSIMLtT5QChsy+zTtsECgYEA2MXlkgy8W7/9BRcdzCXj2Uan5L+H6KT3 -fXHYWc5yp0QBl6dqNCtPJ2lIpZ+qrNzJ1QZM56+qPEftOFOmhnz4+U6SAaKc/75n -bAL//ggMQwHzMus6ufhXJC3AYSduq9e1hnOC+K7Hc3dPLPkJGjVZVC2kXhACTwuL -aBbi5EmWVJ8CgYByk3BRRdgQ8cD3Gi/lW9mSq8EEW6njCs88QIM+msoncENHKvGz -Pq7Up5wHRdsrR20N+mDBpgm26bQp4bjYjp+PIE4WXQ/daxrk4oKd+A6tcMhnDpiU -krF5IA0ZeMQv36g/YhGucj+4P6R40qKRxDmVX8N+XewuEXeY7wx3NWWLgQKBgQC4 -DqA0eDfet49AqTYVxv5F2GZqJe5iLOAvVWDcMBzNxUKM4AufLD7TOeQDLSUgDYAa -LnVSK6eh83iKYQx+GNLV7E6wsMAZrjPmVE3EBlVS9+7lhzGgAisLfwVf+LlRk6B/ -/shwGwcjFWTWzMVbyXyFqxNrArDTKPw/b19LcugABQKBgQD8ARwEoZRyl8kuLyLh -33FRUAVTvuCU1KvEl9CU6BcmEDNcI/O/IYOeOUXYeIeNyATNH2L8A++i53EptpMd -wVxEIE2YBHD2t6+OcTjFSey7/6BejBUExxMVyWnUZMq3Xvf30ecfvacSb/DexqAG -yos+VoW4PIphdW3NBfE1hlLDZQ== ------END PRIVATE KEY----- diff --git a/anneal/vendor/tiny_http/examples/ssl.rs b/anneal/vendor/tiny_http/examples/ssl.rs deleted file mode 100644 index eef2c0521c..0000000000 --- a/anneal/vendor/tiny_http/examples/ssl.rs +++ /dev/null @@ -1,42 +0,0 @@ -extern crate tiny_http; - -#[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] -fn main() { - println!("This example requires one of the supported `ssl-*` features to be enabled"); -} - -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -fn main() { - use tiny_http::{Response, Server}; - - let server = Server::https( - "0.0.0.0:8000", - tiny_http::SslConfig { - certificate: include_bytes!("ssl-cert.pem").to_vec(), - private_key: include_bytes!("ssl-key.pem").to_vec(), - }, - ) - .unwrap(); - - println!( - "Note: connecting to this server will likely give you a warning from your browser \ - because the connection is unsecure. This is because the certificate used by this \ - example is self-signed. With a real certificate, you wouldn't get this warning." - ); - - for request in server.incoming_requests() { - assert!(request.secure()); - - println!( - "received request! method: {:?}, url: {:?}, headers: {:?}", - request.method(), - request.url(), - request.headers() - ); - - let response = Response::from_string("hello world"); - request - .respond(response) - .unwrap_or(println!("Failed to respond to request")); - } -} diff --git a/anneal/vendor/tiny_http/examples/websockets.rs b/anneal/vendor/tiny_http/examples/websockets.rs deleted file mode 100644 index acea4e4602..0000000000 --- a/anneal/vendor/tiny_http/examples/websockets.rs +++ /dev/null @@ -1,148 +0,0 @@ -extern crate rustc_serialize; -extern crate sha1; -extern crate tiny_http; - -use std::io::Cursor; -use std::io::Read; -use std::thread::spawn; - -use rustc_serialize::base64::{Config, Newline, Standard, ToBase64}; - -fn home_page(port: u16) -> tiny_http::Response>> { - tiny_http::Response::from_string(format!( - " - -

This example will receive "Hello" for each byte in the packet being sent. - Tiny-http doesn't support decoding websocket frames, so we can't do anything better.

-

-

-

Received:

-

- ", - port - )) - .with_header( - "Content-type: text/html" - .parse::() - .unwrap(), - ) -} - -/// Turns a Sec-WebSocket-Key into a Sec-WebSocket-Accept. -/// Feel free to copy-paste this function, but please use a better error handling. -fn convert_key(input: &str) -> String { - use sha1::Sha1; - - let mut input = input.to_string().into_bytes(); - let mut bytes = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" - .to_string() - .into_bytes(); - input.append(&mut bytes); - - let mut sha1 = Sha1::new(); - sha1.update(&input); - - sha1.digest().bytes().to_base64(Config { - char_set: Standard, - pad: true, - line_length: None, - newline: Newline::LF, - }) -} - -fn main() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - - println!("Server started"); - println!( - "To try this example, open a browser to http://localhost:{}/", - port - ); - - for request in server.incoming_requests() { - // we are handling this websocket connection in a new task - spawn(move || { - // checking the "Upgrade" header to check that it is a websocket - match request - .headers() - .iter() - .find(|h| h.field.equiv(&"Upgrade")) - .and_then(|hdr| { - if hdr.value == "websocket" { - Some(hdr) - } else { - None - } - }) { - None => { - // sending the HTML page - request.respond(home_page(port)).expect("Responded"); - return; - } - _ => (), - }; - - // getting the value of Sec-WebSocket-Key - let key = match request - .headers() - .iter() - .find(|h| h.field.equiv(&"Sec-WebSocket-Key")) - .map(|h| h.value.clone()) - { - None => { - let response = tiny_http::Response::new_empty(tiny_http::StatusCode(400)); - request.respond(response).expect("Responded"); - return; - } - Some(k) => k, - }; - - // building the "101 Switching Protocols" response - let response = tiny_http::Response::new_empty(tiny_http::StatusCode(101)) - .with_header("Upgrade: websocket".parse::().unwrap()) - .with_header("Connection: Upgrade".parse::().unwrap()) - .with_header( - "Sec-WebSocket-Protocol: ping" - .parse::() - .unwrap(), - ) - .with_header( - format!("Sec-WebSocket-Accept: {}", convert_key(key.as_str())) - .parse::() - .unwrap(), - ); - - // - let mut stream = request.upgrade("websocket", response); - - // - loop { - let mut out = Vec::new(); - match Read::by_ref(&mut stream).take(1).read_to_end(&mut out) { - Ok(n) if n >= 1 => { - // "Hello" frame - let data = [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]; - stream.write(&data).ok(); - stream.flush().ok(); - } - Ok(_) => panic!("eof ; should never happen"), - Err(e) => { - println!("closing connection because: {}", e); - return; - } - }; - } - }); - } -} diff --git a/anneal/vendor/tiny_http/src/client.rs b/anneal/vendor/tiny_http/src/client.rs deleted file mode 100644 index 68bbd469a2..0000000000 --- a/anneal/vendor/tiny_http/src/client.rs +++ /dev/null @@ -1,309 +0,0 @@ -use ascii::AsciiString; - -use std::io::Error as IoError; -use std::io::Result as IoResult; -use std::io::{BufReader, BufWriter, ErrorKind, Read}; - -use std::net::SocketAddr; -use std::str::FromStr; - -use crate::common::{HTTPVersion, Method}; -use crate::util::RefinedTcpStream; -use crate::util::{SequentialReader, SequentialReaderBuilder, SequentialWriterBuilder}; -use crate::Request; - -/// A ClientConnection is an object that will store a socket to a client -/// and return Request objects. -pub struct ClientConnection { - // address of the client - remote_addr: IoResult>, - - // sequence of Readers to the stream, so that the data is not read in - // the wrong order - source: SequentialReaderBuilder>, - - // sequence of Writers to the stream, to avoid writing response #2 before - // response #1 - sink: SequentialWriterBuilder>, - - // Reader to read the next header from - next_header_source: SequentialReader>, - - // set to true if we know that the previous request is the last one - no_more_requests: bool, - - // true if the connection goes through SSL - secure: bool, -} - -/// Error that can happen when reading a request. -#[derive(Debug)] -enum ReadError { - WrongRequestLine, - WrongHeader(HTTPVersion), - /// the client sent an unrecognized `Expect` header - ExpectationFailed(HTTPVersion), - ReadIoError(IoError), -} - -impl ClientConnection { - /// Creates a new `ClientConnection` that takes ownership of the `TcpStream`. - pub fn new( - write_socket: RefinedTcpStream, - mut read_socket: RefinedTcpStream, - ) -> ClientConnection { - let remote_addr = read_socket.peer_addr(); - let secure = read_socket.secure(); - - let mut source = SequentialReaderBuilder::new(BufReader::with_capacity(1024, read_socket)); - let first_header = source.next().unwrap(); - - ClientConnection { - source, - sink: SequentialWriterBuilder::new(BufWriter::with_capacity(1024, write_socket)), - remote_addr, - next_header_source: first_header, - no_more_requests: false, - secure, - } - } - - /// true if the connection is HTTPS - pub fn secure(&self) -> bool { - self.secure - } - - /// Reads the next line from self.next_header_source. - /// - /// Reads until `CRLF` is reached. The next read will start - /// at the first byte of the new line. - fn read_next_line(&mut self) -> IoResult { - let mut buf = Vec::new(); - let mut prev_byte_was_cr = false; - - loop { - let byte = self.next_header_source.by_ref().bytes().next(); - - let byte = match byte { - Some(b) => b?, - None => return Err(IoError::new(ErrorKind::ConnectionAborted, "Unexpected EOF")), - }; - - if byte == b'\n' && prev_byte_was_cr { - buf.pop(); // removing the '\r' - return AsciiString::from_ascii(buf) - .map_err(|_| IoError::new(ErrorKind::InvalidInput, "Header is not in ASCII")); - } - - prev_byte_was_cr = byte == b'\r'; - - buf.push(byte); - } - } - - /// Reads a request from the stream. - /// Blocks until the header has been read. - fn read(&mut self) -> Result { - let (method, path, version, headers) = { - // reading the request line - let (method, path, version) = { - let line = self.read_next_line().map_err(ReadError::ReadIoError)?; - - parse_request_line( - line.as_str().trim(), // TODO: remove this conversion - )? - }; - - // getting all headers - let headers = { - let mut headers = Vec::new(); - loop { - let line = self.read_next_line().map_err(ReadError::ReadIoError)?; - - if line.is_empty() { - break; - }; - headers.push(match FromStr::from_str(line.as_str().trim()) { - // TODO: remove this conversion - Ok(h) => h, - _ => return Err(ReadError::WrongHeader(version)), - }); - } - - headers - }; - - (method, path, version, headers) - }; - - // building the writer for the request - let writer = self.sink.next().unwrap(); - - // follow-up for next potential request - let mut data_source = self.source.next().unwrap(); - std::mem::swap(&mut self.next_header_source, &mut data_source); - - // building the next reader - let request = crate::request::new_request( - self.secure, - method, - path, - version.clone(), - headers, - *self.remote_addr.as_ref().unwrap(), - data_source, - writer, - ) - .map_err(|e| { - use crate::request; - match e { - request::RequestCreationError::CreationIoError(e) => ReadError::ReadIoError(e), - request::RequestCreationError::ExpectationFailed => { - ReadError::ExpectationFailed(version) - } - } - })?; - - // return the request - Ok(request) - } -} - -impl Iterator for ClientConnection { - type Item = Request; - - /// Blocks until the next Request is available. - /// Returns None when no new Requests will come from the client. - fn next(&mut self) -> Option { - use crate::{Response, StatusCode}; - - // the client sent a "connection: close" header in this previous request - // or is using HTTP 1.0, meaning that no new request will come - if self.no_more_requests { - return None; - } - - loop { - let rq = match self.read() { - Err(ReadError::WrongRequestLine) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(400)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - return None; // we don't know where the next request would start, - // se we have to close - } - - Err(ReadError::WrongHeader(ver)) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(400)); - response.raw_print(writer, ver, &[], false, None).ok(); - return None; // we don't know where the next request would start, - // se we have to close - } - - Err(ReadError::ReadIoError(ref err)) if err.kind() == ErrorKind::TimedOut => { - // request timeout - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(408)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - return None; // closing the connection - } - - Err(ReadError::ExpectationFailed(ver)) => { - let writer = self.sink.next().unwrap(); - let response = Response::new_empty(StatusCode(417)); - response.raw_print(writer, ver, &[], true, None).ok(); - return None; // TODO: should be recoverable, but needs handling in case of body - } - - Err(ReadError::ReadIoError(_)) => return None, - - Ok(rq) => rq, - }; - - // checking HTTP version - if *rq.http_version() > (1, 1) { - let writer = self.sink.next().unwrap(); - let response = Response::from_string( - "This server only supports HTTP versions 1.0 and 1.1".to_owned(), - ) - .with_status_code(StatusCode(505)); - response - .raw_print(writer, HTTPVersion(1, 1), &[], false, None) - .ok(); - continue; - } - - // updating the status of the connection - let connection_header = rq - .headers() - .iter() - .find(|h| h.field.equiv("Connection")) - .map(|h| h.value.as_str()); - - let lowercase = connection_header.map(|h| h.to_ascii_lowercase()); - - match lowercase { - Some(ref val) if val.contains("close") => self.no_more_requests = true, - Some(ref val) if val.contains("upgrade") => self.no_more_requests = true, - Some(ref val) - if !val.contains("keep-alive") && *rq.http_version() == HTTPVersion(1, 0) => - { - self.no_more_requests = true - } - None if *rq.http_version() == HTTPVersion(1, 0) => self.no_more_requests = true, - _ => (), - }; - - // returning the request - return Some(rq); - } - } -} - -/// Parses a "HTTP/1.1" string. -fn parse_http_version(version: &str) -> Result { - let (major, minor) = match version { - "HTTP/0.9" => (0, 9), - "HTTP/1.0" => (1, 0), - "HTTP/1.1" => (1, 1), - "HTTP/2.0" => (2, 0), - "HTTP/3.0" => (3, 0), - _ => return Err(ReadError::WrongRequestLine), - }; - - Ok(HTTPVersion(major, minor)) -} - -/// Parses the request line of the request. -/// eg. GET / HTTP/1.1 -fn parse_request_line(line: &str) -> Result<(Method, String, HTTPVersion), ReadError> { - let mut parts = line.split(' '); - - let method = parts.next().and_then(|w| w.parse().ok()); - let path = parts.next().map(ToOwned::to_owned); - let version = parts.next().and_then(|w| parse_http_version(w).ok()); - - method - .and_then(|method| Some((method, path?, version?))) - .ok_or(ReadError::WrongRequestLine) -} - -#[cfg(test)] -mod test { - #[test] - fn test_parse_request_line() { - let (method, path, ver) = super::parse_request_line("GET /hello HTTP/1.1").unwrap(); - - assert!(method == crate::Method::Get); - assert!(path == "/hello"); - assert!(ver == crate::common::HTTPVersion(1, 1)); - - assert!(super::parse_request_line("GET /hello").is_err()); - assert!(super::parse_request_line("qsd qsd qsd").is_err()); - } -} diff --git a/anneal/vendor/tiny_http/src/common.rs b/anneal/vendor/tiny_http/src/common.rs deleted file mode 100644 index 473fd8d488..0000000000 --- a/anneal/vendor/tiny_http/src/common.rs +++ /dev/null @@ -1,440 +0,0 @@ -use ascii::{AsciiStr, AsciiString, FromAsciiError}; -use std::cmp::Ordering; -use std::fmt::{self, Display, Formatter}; -use std::str::FromStr; - -/// Status code of a request or response. -#[derive(Eq, PartialEq, Copy, Clone, Debug, Ord, PartialOrd)] -pub struct StatusCode(pub u16); - -impl StatusCode { - /// Returns the default reason phrase for this status code. - /// For example the status code 404 corresponds to "Not Found". - pub fn default_reason_phrase(&self) -> &'static str { - match self.0 { - 100 => "Continue", - 101 => "Switching Protocols", - 102 => "Processing", - 103 => "Early Hints", - - 200 => "OK", - 201 => "Created", - 202 => "Accepted", - 203 => "Non-Authoritative Information", - 204 => "No Content", - 205 => "Reset Content", - 206 => "Partial Content", - 207 => "Multi-Status", - 208 => "Already Reported", - 226 => "IM Used", - - 300 => "Multiple Choices", - 301 => "Moved Permanently", - 302 => "Found", - 303 => "See Other", - 304 => "Not Modified", - 305 => "Use Proxy", - 307 => "Temporary Redirect", - 308 => "Permanent Redirect", - - 400 => "Bad Request", - 401 => "Unauthorized", - 402 => "Payment Required", - 403 => "Forbidden", - 404 => "Not Found", - 405 => "Method Not Allowed", - 406 => "Not Acceptable", - 407 => "Proxy Authentication Required", - 408 => "Request Timeout", - 409 => "Conflict", - 410 => "Gone", - 411 => "Length Required", - 412 => "Precondition Failed", - 413 => "Payload Too Large", - 414 => "URI Too Long", - 415 => "Unsupported Media Type", - 416 => "Range Not Satisfiable", - 417 => "Expectation Failed", - 421 => "Misdirected Request", - 422 => "Unprocessable Entity", - 423 => "Locked", - 424 => "Failed Dependency", - 426 => "Upgrade Required", - 428 => "Precondition Required", - 429 => "Too Many Requests", - 431 => "Request Header Fields Too Large", - 451 => "Unavailable For Legal Reasons", - - 500 => "Internal Server Error", - 501 => "Not Implemented", - 502 => "Bad Gateway", - 503 => "Service Unavailable", - 504 => "Gateway Timeout", - 505 => "HTTP Version Not Supported", - 506 => "Variant Also Negotiates", - 507 => "Insufficient Storage", - 508 => "Loop Detected", - 510 => "Not Extended", - 511 => "Network Authentication Required", - _ => "Unknown", - } - } -} - -impl From for StatusCode { - fn from(in_code: i8) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u8) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: i16) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u16) -> StatusCode { - StatusCode(in_code) - } -} - -impl From for StatusCode { - fn from(in_code: i32) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl From for StatusCode { - fn from(in_code: u32) -> StatusCode { - StatusCode(in_code as u16) - } -} - -impl AsRef for StatusCode { - fn as_ref(&self) -> &u16 { - &self.0 - } -} - -impl PartialEq for StatusCode { - fn eq(&self, other: &u16) -> bool { - &self.0 == other - } -} - -impl PartialEq for u16 { - fn eq(&self, other: &StatusCode) -> bool { - self == &other.0 - } -} - -impl PartialOrd for StatusCode { - fn partial_cmp(&self, other: &u16) -> Option { - self.0.partial_cmp(other) - } -} - -impl PartialOrd for u16 { - fn partial_cmp(&self, other: &StatusCode) -> Option { - self.partial_cmp(&other.0) - } -} - -/// Represents a HTTP header. -#[derive(Debug, Clone)] -pub struct Header { - pub field: HeaderField, - pub value: AsciiString, -} - -impl Header { - /// Builds a `Header` from two `Vec`s or two `&[u8]`s. - /// - /// Example: - /// - /// ``` - /// let header = tiny_http::Header::from_bytes(&b"Content-Type"[..], &b"text/plain"[..]).unwrap(); - /// ``` - #[allow(clippy::result_unit_err)] - pub fn from_bytes(header: B1, value: B2) -> Result - where - B1: Into> + AsRef<[u8]>, - B2: Into> + AsRef<[u8]>, - { - let header = HeaderField::from_bytes(header).or(Err(()))?; - let value = AsciiString::from_ascii(value).or(Err(()))?; - - Ok(Header { - field: header, - value, - }) - } -} - -impl FromStr for Header { - type Err = (); - - fn from_str(input: &str) -> Result { - let mut elems = input.splitn(2, ':'); - - let field = elems.next().and_then(|f| f.parse().ok()).ok_or(())?; - let value = elems - .next() - .and_then(|v| AsciiString::from_ascii(v.trim()).ok()) - .ok_or(())?; - - Ok(Header { field, value }) - } -} - -impl Display for Header { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}: {}", self.field, self.value.as_str()) - } -} - -/// Field of a header (eg. `Content-Type`, `Content-Length`, etc.) -/// -/// Comparison between two `HeaderField`s ignores case. -#[derive(Debug, Clone, Eq)] -pub struct HeaderField(AsciiString); - -impl HeaderField { - pub fn from_bytes(bytes: B) -> Result> - where - B: Into> + AsRef<[u8]>, - { - AsciiString::from_ascii(bytes).map(HeaderField) - } - - pub fn as_str(&self) -> &AsciiStr { - &self.0 - } - - pub fn equiv(&self, other: &'static str) -> bool { - other.eq_ignore_ascii_case(self.as_str().as_str()) - } -} - -impl FromStr for HeaderField { - type Err = (); - - fn from_str(s: &str) -> Result { - if s.contains(char::is_whitespace) { - Err(()) - } else { - AsciiString::from_ascii(s).map(HeaderField).map_err(|_| ()) - } - } -} - -impl Display for HeaderField { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}", self.0.as_str()) - } -} - -impl PartialEq for HeaderField { - fn eq(&self, other: &HeaderField) -> bool { - let self_str: &str = self.as_str().as_ref(); - let other_str = other.as_str().as_ref(); - self_str.eq_ignore_ascii_case(other_str) - } -} - -/// HTTP request methods -/// -/// As per [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.1) and -/// [RFC 5789](https://tools.ietf.org/html/rfc5789) -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Method { - /// `GET` - Get, - - /// `HEAD` - Head, - - /// `POST` - Post, - - /// `PUT` - Put, - - /// `DELETE` - Delete, - - /// `CONNECT` - Connect, - - /// `OPTIONS` - Options, - - /// `TRACE` - Trace, - - /// `PATCH` - Patch, - - /// Request methods not standardized by the IETF - NonStandard(AsciiString), -} - -impl Method { - pub fn as_str(&self) -> &str { - match *self { - Method::Get => "GET", - Method::Head => "HEAD", - Method::Post => "POST", - Method::Put => "PUT", - Method::Delete => "DELETE", - Method::Connect => "CONNECT", - Method::Options => "OPTIONS", - Method::Trace => "TRACE", - Method::Patch => "PATCH", - Method::NonStandard(ref s) => s.as_str(), - } - } -} - -impl FromStr for Method { - type Err = (); - - fn from_str(s: &str) -> Result { - Ok(match s { - "GET" => Method::Get, - "HEAD" => Method::Head, - "POST" => Method::Post, - "PUT" => Method::Put, - "DELETE" => Method::Delete, - "CONNECT" => Method::Connect, - "OPTIONS" => Method::Options, - "TRACE" => Method::Trace, - "PATCH" => Method::Patch, - s => { - let ascii_string = AsciiString::from_ascii(s).map_err(|_| ())?; - Method::NonStandard(ascii_string) - } - }) - } -} - -impl Display for Method { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}", self.as_str()) - } -} - -/// HTTP version (usually 1.0 or 1.1). -#[allow(clippy::upper_case_acronyms)] -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct HTTPVersion(pub u8, pub u8); - -impl Display for HTTPVersion { - fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), fmt::Error> { - write!(formatter, "{}.{}", self.0, self.1) - } -} - -impl Ord for HTTPVersion { - fn cmp(&self, other: &Self) -> Ordering { - let HTTPVersion(my_major, my_minor) = *self; - let HTTPVersion(other_major, other_minor) = *other; - - if my_major != other_major { - return my_major.cmp(&other_major); - } - - my_minor.cmp(&other_minor) - } -} - -impl PartialOrd for HTTPVersion { - fn partial_cmp(&self, other: &HTTPVersion) -> Option { - Some(self.cmp(other)) - } -} - -impl PartialEq<(u8, u8)> for HTTPVersion { - fn eq(&self, &(major, minor): &(u8, u8)) -> bool { - self.eq(&HTTPVersion(major, minor)) - } -} - -impl PartialEq for (u8, u8) { - fn eq(&self, other: &HTTPVersion) -> bool { - let &(major, minor) = self; - HTTPVersion(major, minor).eq(other) - } -} - -impl PartialOrd<(u8, u8)> for HTTPVersion { - fn partial_cmp(&self, &(major, minor): &(u8, u8)) -> Option { - self.partial_cmp(&HTTPVersion(major, minor)) - } -} - -impl PartialOrd for (u8, u8) { - fn partial_cmp(&self, other: &HTTPVersion) -> Option { - let &(major, minor) = self; - HTTPVersion(major, minor).partial_cmp(other) - } -} - -impl From<(u8, u8)> for HTTPVersion { - fn from((major, minor): (u8, u8)) -> HTTPVersion { - HTTPVersion(major, minor) - } -} - -#[cfg(test)] -mod test { - use super::Header; - use httpdate::HttpDate; - use std::time::{Duration, SystemTime}; - - #[test] - fn test_parse_header() { - let header: Header = "Content-Type: text/html".parse().unwrap(); - - assert!(header.field.equiv(&"content-type")); - assert!(header.value.as_str() == "text/html"); - - assert!("hello world".parse::
().is_err()); - } - - #[test] - fn formats_date_correctly() { - let http_date = HttpDate::from(SystemTime::UNIX_EPOCH + Duration::from_secs(420895020)); - - assert_eq!(http_date.to_string(), "Wed, 04 May 1983 11:17:00 GMT") - } - - #[test] - fn test_parse_header_with_doublecolon() { - let header: Header = "Time: 20: 34".parse().unwrap(); - - assert!(header.field.equiv(&"time")); - assert!(header.value.as_str() == "20: 34"); - } - - // This tests reslstance to RUSTSEC-2020-0031: "HTTP Request smuggling - // through malformed Transfer Encoding headers" - // (https://rustsec.org/advisories/RUSTSEC-2020-0031.html). - #[test] - fn test_strict_headers() { - assert!("Transfer-Encoding : chunked".parse::
().is_err()); - assert!(" Transfer-Encoding: chunked".parse::
().is_err()); - assert!("Transfer Encoding: chunked".parse::
().is_err()); - assert!(" Transfer\tEncoding : chunked".parse::
().is_err()); - assert!("Transfer-Encoding: chunked".parse::
().is_ok()); - assert!("Transfer-Encoding: chunked ".parse::
().is_ok()); - assert!("Transfer-Encoding: chunked ".parse::
().is_ok()); - } -} diff --git a/anneal/vendor/tiny_http/src/connection.rs b/anneal/vendor/tiny_http/src/connection.rs deleted file mode 100644 index 6d161cd35e..0000000000 --- a/anneal/vendor/tiny_http/src/connection.rs +++ /dev/null @@ -1,194 +0,0 @@ -//! Abstractions of Tcp and Unix socket types - -#[cfg(unix)] -use std::os::unix::net as unix_net; -use std::{ - net::{Shutdown, SocketAddr, TcpListener, TcpStream, ToSocketAddrs}, - path::PathBuf, -}; - -/// Unified listener. Either a [`TcpListener`] or [`std::os::unix::net::UnixListener`] -pub enum Listener { - Tcp(TcpListener), - #[cfg(unix)] - Unix(unix_net::UnixListener), -} -impl Listener { - pub(crate) fn local_addr(&self) -> std::io::Result { - match self { - Self::Tcp(l) => l.local_addr().map(ListenAddr::from), - #[cfg(unix)] - Self::Unix(l) => l.local_addr().map(ListenAddr::from), - } - } - - pub(crate) fn accept(&self) -> std::io::Result<(Connection, Option)> { - match self { - Self::Tcp(l) => l - .accept() - .map(|(conn, addr)| (Connection::from(conn), Some(addr))), - #[cfg(unix)] - Self::Unix(l) => l.accept().map(|(conn, _)| (Connection::from(conn), None)), - } - } -} -impl From for Listener { - fn from(s: TcpListener) -> Self { - Self::Tcp(s) - } -} -#[cfg(unix)] -impl From for Listener { - fn from(s: unix_net::UnixListener) -> Self { - Self::Unix(s) - } -} - -/// Unified connection. Either a [`TcpStream`] or [`std::os::unix::net::UnixStream`]. -#[derive(Debug)] -pub(crate) enum Connection { - Tcp(TcpStream), - #[cfg(unix)] - Unix(unix_net::UnixStream), -} -impl std::io::Read for Connection { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - match self { - Self::Tcp(s) => s.read(buf), - #[cfg(unix)] - Self::Unix(s) => s.read(buf), - } - } -} -impl std::io::Write for Connection { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - match self { - Self::Tcp(s) => s.write(buf), - #[cfg(unix)] - Self::Unix(s) => s.write(buf), - } - } - - fn flush(&mut self) -> std::io::Result<()> { - match self { - Self::Tcp(s) => s.flush(), - #[cfg(unix)] - Self::Unix(s) => s.flush(), - } - } -} -impl Connection { - /// Gets the peer's address. Some for TCP, None for Unix sockets. - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - match self { - Self::Tcp(s) => s.peer_addr().map(Some), - #[cfg(unix)] - Self::Unix(_) => Ok(None), - } - } - - pub(crate) fn shutdown(&self, how: Shutdown) -> std::io::Result<()> { - match self { - Self::Tcp(s) => s.shutdown(how), - #[cfg(unix)] - Self::Unix(s) => s.shutdown(how), - } - } - - pub(crate) fn try_clone(&self) -> std::io::Result { - match self { - Self::Tcp(s) => s.try_clone().map(Self::from), - #[cfg(unix)] - Self::Unix(s) => s.try_clone().map(Self::from), - } - } -} -impl From for Connection { - fn from(s: TcpStream) -> Self { - Self::Tcp(s) - } -} -#[cfg(unix)] -impl From for Connection { - fn from(s: unix_net::UnixStream) -> Self { - Self::Unix(s) - } -} - -#[derive(Debug, Clone)] -pub enum ConfigListenAddr { - IP(Vec), - #[cfg(unix)] - // TODO: use SocketAddr when bind_addr is stabilized - Unix(std::path::PathBuf), -} -impl ConfigListenAddr { - pub fn from_socket_addrs(addrs: A) -> std::io::Result { - addrs.to_socket_addrs().map(|it| Self::IP(it.collect())) - } - - #[cfg(unix)] - pub fn unix_from_path>(path: P) -> Self { - Self::Unix(path.into()) - } - - pub(crate) fn bind(&self) -> std::io::Result { - match self { - Self::IP(a) => TcpListener::bind(a.as_slice()).map(Listener::from), - #[cfg(unix)] - Self::Unix(a) => unix_net::UnixListener::bind(a).map(Listener::from), - } - } -} - -/// Unified listen socket address. Either a [`SocketAddr`] or [`std::os::unix::net::SocketAddr`]. -#[derive(Debug, Clone)] -pub enum ListenAddr { - IP(SocketAddr), - #[cfg(unix)] - Unix(unix_net::SocketAddr), -} -impl ListenAddr { - pub fn to_ip(self) -> Option { - match self { - Self::IP(s) => Some(s), - #[cfg(unix)] - Self::Unix(_) => None, - } - } - - /// Gets the Unix socket address. - /// - /// This is also available on non-Unix platforms, for ease of use, but always returns `None`. - #[cfg(unix)] - pub fn to_unix(self) -> Option { - match self { - Self::IP(_) => None, - Self::Unix(s) => Some(s), - } - } - #[cfg(not(unix))] - pub fn to_unix(self) -> Option { - None - } -} -impl From for ListenAddr { - fn from(s: SocketAddr) -> Self { - Self::IP(s) - } -} -#[cfg(unix)] -impl From for ListenAddr { - fn from(s: unix_net::SocketAddr) -> Self { - Self::Unix(s) - } -} -impl std::fmt::Display for ListenAddr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::IP(s) => s.fmt(f), - #[cfg(unix)] - Self::Unix(s) => std::fmt::Debug::fmt(s, f), - } - } -} diff --git a/anneal/vendor/tiny_http/src/lib.rs b/anneal/vendor/tiny_http/src/lib.rs deleted file mode 100644 index 5e4568ab8b..0000000000 --- a/anneal/vendor/tiny_http/src/lib.rs +++ /dev/null @@ -1,445 +0,0 @@ -//! # Simple usage -//! -//! ## Creating the server -//! -//! The easiest way to create a server is to call `Server::http()`. -//! -//! The `http()` function returns an `IoResult` which will return an error -//! in the case where the server creation fails (for example if the listening port is already -//! occupied). -//! -//! ```no_run -//! let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! ``` -//! -//! A newly-created `Server` will immediately start listening for incoming connections and HTTP -//! requests. -//! -//! ## Receiving requests -//! -//! Calling `server.recv()` will block until the next request is available. -//! This function returns an `IoResult`, so you need to handle the possible errors. -//! -//! ```no_run -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! -//! loop { -//! // blocks until the next request is received -//! let request = match server.recv() { -//! Ok(rq) => rq, -//! Err(e) => { println!("error: {}", e); break } -//! }; -//! -//! // do something with the request -//! // ... -//! } -//! ``` -//! -//! In a real-case scenario, you will probably want to spawn multiple worker tasks and call -//! `server.recv()` on all of them. Like this: -//! -//! ```no_run -//! # use std::sync::Arc; -//! # use std::thread; -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! let server = Arc::new(server); -//! let mut guards = Vec::with_capacity(4); -//! -//! for _ in (0 .. 4) { -//! let server = server.clone(); -//! -//! let guard = thread::spawn(move || { -//! loop { -//! let rq = server.recv().unwrap(); -//! -//! // ... -//! } -//! }); -//! -//! guards.push(guard); -//! } -//! ``` -//! -//! If you don't want to block, you can call `server.try_recv()` instead. -//! -//! ## Handling requests -//! -//! The `Request` object returned by `server.recv()` contains informations about the client's request. -//! The most useful methods are probably `request.method()` and `request.url()` which return -//! the requested method (`GET`, `POST`, etc.) and url. -//! -//! To handle a request, you need to create a `Response` object. See the docs of this object for -//! more infos. Here is an example of creating a `Response` from a file: -//! -//! ```no_run -//! # use std::fs::File; -//! # use std::path::Path; -//! let response = tiny_http::Response::from_file(File::open(&Path::new("image.png")).unwrap()); -//! ``` -//! -//! All that remains to do is call `request.respond()`: -//! -//! ```no_run -//! # use std::fs::File; -//! # use std::path::Path; -//! # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); -//! # let request = server.recv().unwrap(); -//! # let response = tiny_http::Response::from_file(File::open(&Path::new("image.png")).unwrap()); -//! let _ = request.respond(response); -//! ``` -#![forbid(unsafe_code)] -#![deny(rust_2018_idioms)] -#![allow(clippy::match_like_matches_macro)] - -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -use zeroize::Zeroizing; - -use std::error::Error; -use std::io::Error as IoError; -use std::io::ErrorKind as IoErrorKind; -use std::io::Result as IoResult; -use std::net::{Shutdown, TcpStream, ToSocketAddrs}; -use std::sync::atomic::AtomicBool; -use std::sync::atomic::Ordering::Relaxed; -use std::sync::mpsc; -use std::sync::Arc; -use std::thread; -use std::time::Duration; - -use client::ClientConnection; -use connection::Connection; -use util::MessagesQueue; - -pub use common::{HTTPVersion, Header, HeaderField, Method, StatusCode}; -pub use connection::{ConfigListenAddr, ListenAddr, Listener}; -pub use request::{ReadWrite, Request}; -pub use response::{Response, ResponseBox}; -pub use test::TestRequest; - -mod client; -mod common; -mod connection; -mod request; -mod response; -mod ssl; -mod test; -mod util; - -/// The main class of this library. -/// -/// Destroying this object will immediately close the listening socket and the reading -/// part of all the client's connections. Requests that have already been returned by -/// the `recv()` function will not close and the responses will be transferred to the client. -pub struct Server { - // should be false as long as the server exists - // when set to true, all the subtasks will close within a few hundreds ms - close: Arc, - - // queue for messages received by child threads - messages: Arc>, - - // result of TcpListener::local_addr() - listening_addr: ListenAddr, -} - -enum Message { - Error(IoError), - NewRequest(Request), -} - -impl From for Message { - fn from(e: IoError) -> Message { - Message::Error(e) - } -} - -impl From for Message { - fn from(rq: Request) -> Message { - Message::NewRequest(rq) - } -} - -// this trait is to make sure that Server implements Share and Send -#[doc(hidden)] -trait MustBeShareDummy: Sync + Send {} -#[doc(hidden)] -impl MustBeShareDummy for Server {} - -pub struct IncomingRequests<'a> { - server: &'a Server, -} - -/// Represents the parameters required to create a server. -#[derive(Debug, Clone)] -pub struct ServerConfig { - /// The addresses to try to listen to. - pub addr: ConfigListenAddr, - - /// If `Some`, then the server will use SSL to encode the communications. - pub ssl: Option, -} - -/// Configuration of the server for SSL. -#[derive(Debug, Clone)] -pub struct SslConfig { - /// Contains the public certificate to send to clients. - pub certificate: Vec, - /// Contains the ultra-secret private key used to decode communications. - pub private_key: Vec, -} - -impl Server { - /// Shortcut for a simple server on a specific address. - #[inline] - pub fn http(addr: A) -> Result> - where - A: ToSocketAddrs, - { - Server::new(ServerConfig { - addr: ConfigListenAddr::from_socket_addrs(addr)?, - ssl: None, - }) - } - - /// Shortcut for an HTTPS server on a specific address. - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - #[inline] - pub fn https( - addr: A, - config: SslConfig, - ) -> Result> - where - A: ToSocketAddrs, - { - Server::new(ServerConfig { - addr: ConfigListenAddr::from_socket_addrs(addr)?, - ssl: Some(config), - }) - } - - #[cfg(unix)] - #[inline] - /// Shortcut for a UNIX socket server at a specific path - pub fn http_unix( - path: &std::path::Path, - ) -> Result> { - Server::new(ServerConfig { - addr: ConfigListenAddr::unix_from_path(path), - ssl: None, - }) - } - - /// Builds a new server that listens on the specified address. - pub fn new(config: ServerConfig) -> Result> { - let listener = config.addr.bind()?; - Self::from_listener(listener, config.ssl) - } - - /// Builds a new server using the specified TCP listener. - /// - /// This is useful if you've constructed TcpListener using some less usual method - /// such as from systemd. For other cases, you probably want the `new()` function. - pub fn from_listener>( - listener: L, - ssl_config: Option, - ) -> Result> { - let listener = listener.into(); - // building the "close" variable - let close_trigger = Arc::new(AtomicBool::new(false)); - - // building the TcpListener - let (server, local_addr) = { - let local_addr = listener.local_addr()?; - log::debug!("Server listening on {}", local_addr); - (listener, local_addr) - }; - - // building the SSL capabilities - #[cfg(all(feature = "ssl-openssl", feature = "ssl-rustls"))] - compile_error!( - "Features 'ssl-openssl' and 'ssl-rustls' must not be enabled at the same time" - ); - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - type SslContext = (); - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - type SslContext = crate::ssl::SslContextImpl; - let ssl: Option = { - match ssl_config { - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Some(config) => Some(SslContext::from_pem( - config.certificate, - Zeroizing::new(config.private_key), - )?), - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - Some(_) => return Err( - "Building a server with SSL requires enabling the `ssl` feature in tiny-http" - .into(), - ), - None => None, - } - }; - - // creating a task where server.accept() is continuously called - // and ClientConnection objects are pushed in the messages queue - let messages = MessagesQueue::with_capacity(8); - - let inside_close_trigger = close_trigger.clone(); - let inside_messages = messages.clone(); - thread::spawn(move || { - // a tasks pool is used to dispatch the connections into threads - let tasks_pool = util::TaskPool::new(); - - log::debug!("Running accept thread"); - while !inside_close_trigger.load(Relaxed) { - let new_client = match server.accept() { - Ok((sock, _)) => { - use util::RefinedTcpStream; - let (read_closable, write_closable) = match ssl { - None => RefinedTcpStream::new(sock), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Some(ref ssl) => { - // trying to apply SSL over the connection - // if an error occurs, we just close the socket and resume listening - let sock = match ssl.accept(sock) { - Ok(s) => s, - Err(_) => continue, - }; - - RefinedTcpStream::new(sock) - } - #[cfg(not(any(feature = "ssl-openssl", feature = "ssl-rustls")))] - Some(ref _ssl) => unreachable!(), - }; - - Ok(ClientConnection::new(write_closable, read_closable)) - } - Err(e) => Err(e), - }; - - match new_client { - Ok(client) => { - let messages = inside_messages.clone(); - let mut client = Some(client); - tasks_pool.spawn(Box::new(move || { - if let Some(client) = client.take() { - // Synchronization is needed for HTTPS requests to avoid a deadlock - if client.secure() { - let (sender, receiver) = mpsc::channel(); - for rq in client { - messages.push(rq.with_notify_sender(sender.clone()).into()); - receiver.recv().unwrap(); - } - } else { - for rq in client { - messages.push(rq.into()); - } - } - } - })); - } - - Err(e) => { - log::error!("Error accepting new client: {}", e); - inside_messages.push(e.into()); - break; - } - } - } - log::debug!("Terminating accept thread"); - }); - - // result - Ok(Server { - messages, - close: close_trigger, - listening_addr: local_addr, - }) - } - - /// Returns an iterator for all the incoming requests. - /// - /// The iterator will return `None` if the server socket is shutdown. - #[inline] - pub fn incoming_requests(&self) -> IncomingRequests<'_> { - IncomingRequests { server: self } - } - - /// Returns the address the server is listening to. - #[inline] - pub fn server_addr(&self) -> ListenAddr { - self.listening_addr.clone() - } - - /// Returns the number of clients currently connected to the server. - pub fn num_connections(&self) -> usize { - unimplemented!() - //self.requests_receiver.lock().len() - } - - /// Blocks until an HTTP request has been submitted and returns it. - pub fn recv(&self) -> IoResult { - match self.messages.pop() { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(rq), - None => Err(IoError::new(IoErrorKind::Other, "thread unblocked")), - } - } - - /// Same as `recv()` but doesn't block longer than timeout - pub fn recv_timeout(&self, timeout: Duration) -> IoResult> { - match self.messages.pop_timeout(timeout) { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(Some(rq)), - None => Ok(None), - } - } - - /// Same as `recv()` but doesn't block. - pub fn try_recv(&self) -> IoResult> { - match self.messages.try_pop() { - Some(Message::Error(err)) => Err(err), - Some(Message::NewRequest(rq)) => Ok(Some(rq)), - None => Ok(None), - } - } - - /// Unblock thread stuck in recv() or incoming_requests(). - /// If there are several such threads, only one is unblocked. - /// This method allows graceful shutdown of server. - pub fn unblock(&self) { - self.messages.unblock(); - } -} - -impl Iterator for IncomingRequests<'_> { - type Item = Request; - fn next(&mut self) -> Option { - self.server.recv().ok() - } -} - -impl Drop for Server { - fn drop(&mut self) { - self.close.store(true, Relaxed); - // Connect briefly to ourselves to unblock the accept thread - let maybe_stream = match &self.listening_addr { - ListenAddr::IP(addr) => TcpStream::connect(addr).map(Connection::from), - #[cfg(unix)] - ListenAddr::Unix(addr) => { - // TODO: use connect_addr when its stabilized. - let path = addr.as_pathname().unwrap(); - std::os::unix::net::UnixStream::connect(path).map(Connection::from) - } - }; - if let Ok(stream) = maybe_stream { - let _ = stream.shutdown(Shutdown::Both); - } - - #[cfg(unix)] - if let ListenAddr::Unix(addr) = &self.listening_addr { - if let Some(path) = addr.as_pathname() { - let _ = std::fs::remove_file(path); - } - } - } -} diff --git a/anneal/vendor/tiny_http/src/request.rs b/anneal/vendor/tiny_http/src/request.rs deleted file mode 100644 index 531d6aa658..0000000000 --- a/anneal/vendor/tiny_http/src/request.rs +++ /dev/null @@ -1,518 +0,0 @@ -use std::io::Error as IoError; -use std::io::{self, Cursor, ErrorKind, Read, Write}; - -use std::fmt; -use std::net::SocketAddr; -use std::str::FromStr; - -use std::sync::mpsc::Sender; - -use crate::util::{EqualReader, FusedReader}; -use crate::{HTTPVersion, Header, Method, Response, StatusCode}; -use chunked_transfer::Decoder; - -/// Represents an HTTP request made by a client. -/// -/// A `Request` object is what is produced by the server, and is your what -/// your code must analyse and answer. -/// -/// This object implements the `Send` trait, therefore you can dispatch your requests to -/// worker threads. -/// -/// # Pipelining -/// -/// If a client sends multiple requests in a row (without waiting for the response), then you will -/// get multiple `Request` objects simultaneously. This is called *requests pipelining*. -/// Tiny-http automatically reorders the responses so that you don't need to worry about the order -/// in which you call `respond` or `into_writer`. -/// -/// This mechanic is disabled if: -/// -/// - The body of a request is large enough (handling requires pipelining requires storing the -/// body of the request in a buffer ; if the body is too big, tiny-http will avoid doing that) -/// - A request sends a `Expect: 100-continue` header (which means that the client waits to -/// know whether its body will be processed before sending it) -/// - A request sends a `Connection: close` header or `Connection: upgrade` header (used for -/// websockets), which indicates that this is the last request that will be received on this -/// connection -/// -/// # Automatic cleanup -/// -/// If a `Request` object is destroyed without `into_writer` or `respond` being called, -/// an empty response with a 500 status code (internal server error) will automatically be -/// sent back to the client. -/// This means that if your code fails during the handling of a request, this "internal server -/// error" response will automatically be sent during the stack unwinding. -/// -/// # Testing -/// -/// If you want to build fake requests to test your server, use [`TestRequest`](crate::test::TestRequest). -pub struct Request { - // where to read the body from - data_reader: Option>, - - // if this writer is empty, then the request has been answered - response_writer: Option>, - - remote_addr: Option, - - // true if HTTPS, false if HTTP - secure: bool, - - method: Method, - - path: String, - - http_version: HTTPVersion, - - headers: Vec
, - - body_length: Option, - - // true if a `100 Continue` response must be sent when `as_reader()` is called - must_send_continue: bool, - - // If Some, a message must be sent after responding - notify_when_responded: Option>, -} - -struct NotifyOnDrop { - sender: Sender<()>, - inner: R, -} - -impl Read for NotifyOnDrop { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - self.inner.read(buf) - } -} -impl Write for NotifyOnDrop { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.inner.write(buf) - } - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} -impl Drop for NotifyOnDrop { - fn drop(&mut self) { - self.sender.send(()).unwrap(); - } -} - -/// Error that can happen when building a `Request` object. -#[derive(Debug)] -pub enum RequestCreationError { - /// The client sent an `Expect` header that was not recognized by tiny-http. - ExpectationFailed, - - /// Error while reading data from the socket during the creation of the `Request`. - CreationIoError(IoError), -} - -impl From for RequestCreationError { - fn from(err: IoError) -> RequestCreationError { - RequestCreationError::CreationIoError(err) - } -} - -/// Builds a new request. -/// -/// After the request line and headers have been read from the socket, a new `Request` object -/// is built. -/// -/// You must pass a `Read` that will allow the `Request` object to read from the incoming data. -/// It is the responsibility of the `Request` to read only the data of the request and not further. -/// -/// The `Write` object will be used by the `Request` to write the response. -#[allow(clippy::too_many_arguments)] -pub fn new_request( - secure: bool, - method: Method, - path: String, - version: HTTPVersion, - headers: Vec
, - remote_addr: Option, - mut source_data: R, - writer: W, -) -> Result -where - R: Read + Send + 'static, - W: Write + Send + 'static, -{ - // finding the transfer-encoding header - let transfer_encoding = headers - .iter() - .find(|h: &&Header| h.field.equiv("Transfer-Encoding")) - .map(|h| h.value.clone()); - - // finding the content-length header - let content_length = if transfer_encoding.is_some() { - // if transfer-encoding is specified, the Content-Length - // header must be ignored (RFC2616 #4.4) - None - } else { - headers - .iter() - .find(|h: &&Header| h.field.equiv("Content-Length")) - .and_then(|h| FromStr::from_str(h.value.as_str()).ok()) - }; - - // true if the client sent a `Expect: 100-continue` header - let expects_continue = { - match headers - .iter() - .find(|h: &&Header| h.field.equiv("Expect")) - .map(|h| h.value.as_str()) - { - None => false, - Some(v) if v.eq_ignore_ascii_case("100-continue") => true, - _ => return Err(RequestCreationError::ExpectationFailed), - } - }; - - // true if the client sent a `Connection: upgrade` header - let connection_upgrade = { - match headers - .iter() - .find(|h: &&Header| h.field.equiv("Connection")) - .map(|h| h.value.as_str()) - { - Some(v) if v.to_ascii_lowercase().contains("upgrade") => true, - _ => false, - } - }; - - // we wrap `source_data` around a reading whose nature depends on the transfer-encoding and - // content-length headers - let reader = if connection_upgrade { - // if we have a `Connection: upgrade`, always keeping the whole reader - Box::new(source_data) as Box - } else if let Some(content_length) = content_length { - if content_length == 0 { - Box::new(io::empty()) as Box - } else if content_length <= 1024 && !expects_continue { - // if the content-length is small enough, we just read everything into a buffer - - let mut buffer = vec![0; content_length]; - let mut offset = 0; - - while offset != content_length { - let read = source_data.read(&mut buffer[offset..])?; - if read == 0 { - // the socket returned EOF, but we were before the expected content-length - // aborting - let info = "Connection has been closed before we received enough data"; - let err = IoError::new(ErrorKind::ConnectionAborted, info); - return Err(RequestCreationError::CreationIoError(err)); - } - - offset += read; - } - - Box::new(Cursor::new(buffer)) as Box - } else { - let (data_reader, _) = EqualReader::new(source_data, content_length); // TODO: - Box::new(FusedReader::new(data_reader)) as Box - } - } else if transfer_encoding.is_some() { - // if a transfer-encoding was specified, then "chunked" is ALWAYS applied - // over the message (RFC2616 #3.6) - Box::new(FusedReader::new(Decoder::new(source_data))) as Box - } else { - // if we have neither a Content-Length nor a Transfer-Encoding, - // assuming that we have no data - // TODO: could also be multipart/byteranges - Box::new(io::empty()) as Box - }; - - Ok(Request { - data_reader: Some(reader), - response_writer: Some(Box::new(writer) as Box), - remote_addr, - secure, - method, - path, - http_version: version, - headers, - body_length: content_length, - must_send_continue: expects_continue, - notify_when_responded: None, - }) -} - -impl Request { - /// Returns true if the request was made through HTTPS. - #[inline] - pub fn secure(&self) -> bool { - self.secure - } - - /// Returns the method requested by the client (eg. `GET`, `POST`, etc.). - #[inline] - pub fn method(&self) -> &Method { - &self.method - } - - /// Returns the resource requested by the client. - #[inline] - pub fn url(&self) -> &str { - &self.path - } - - /// Returns a list of all headers sent by the client. - #[inline] - pub fn headers(&self) -> &[Header] { - &self.headers - } - - /// Returns the HTTP version of the request. - #[inline] - pub fn http_version(&self) -> &HTTPVersion { - &self.http_version - } - - /// Returns the length of the body in bytes. - /// - /// Returns `None` if the length is unknown. - #[inline] - pub fn body_length(&self) -> Option { - self.body_length - } - - /// Returns the address of the client that sent this request. - /// - /// The address is always `Some` for TCP listeners, but always `None` for UNIX listeners - /// (as the remote address of a UNIX client is almost always unnamed). - /// - /// Note that this is gathered from the socket. If you receive the request from a proxy, - /// this function will return the address of the proxy and not the address of the actual - /// user. - #[inline] - pub fn remote_addr(&self) -> Option<&SocketAddr> { - self.remote_addr.as_ref() - } - - /// Sends a response with a `Connection: upgrade` header, then turns the `Request` into a `Stream`. - /// - /// The main purpose of this function is to support websockets. - /// If you detect that the request wants to use some kind of protocol upgrade, you can - /// call this function to obtain full control of the socket stream. - /// - /// If you call this on a non-websocket request, tiny-http will wait until this `Stream` object - /// is destroyed before continuing to read or write on the socket. Therefore you should always - /// destroy it as soon as possible. - pub fn upgrade( - mut self, - protocol: &str, - response: Response, - ) -> Box { - use crate::util::CustomStream; - - response - .raw_print( - self.response_writer.as_mut().unwrap().by_ref(), - self.http_version.clone(), - &self.headers, - false, - Some(protocol), - ) - .ok(); // TODO: unused result - - self.response_writer.as_mut().unwrap().flush().ok(); // TODO: unused result - - let stream = CustomStream::new(self.extract_reader_impl(), self.extract_writer_impl()); - if let Some(sender) = self.notify_when_responded.take() { - let stream = NotifyOnDrop { - sender, - inner: stream, - }; - Box::new(stream) as Box - } else { - Box::new(stream) as Box - } - } - - /// Allows to read the body of the request. - /// - /// # Example - /// - /// ```no_run - /// # extern crate rustc_serialize; - /// # extern crate tiny_http; - /// # use rustc_serialize::json::Json; - /// # use std::io::Read; - /// # fn get_content_type(_: &tiny_http::Request) -> &'static str { "" } - /// # fn main() { - /// # let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - /// let mut request = server.recv().unwrap(); - /// - /// if get_content_type(&request) == "application/json" { - /// let mut content = String::new(); - /// request.as_reader().read_to_string(&mut content).unwrap(); - /// let json: Json = content.parse().unwrap(); - /// } - /// # } - /// ``` - /// - /// If the client sent a `Expect: 100-continue` header with the request, calling this - /// function will send back a `100 Continue` response. - #[inline] - pub fn as_reader(&mut self) -> &mut dyn Read { - if self.must_send_continue { - let msg = Response::new_empty(StatusCode(100)); - msg.raw_print( - self.response_writer.as_mut().unwrap().by_ref(), - self.http_version.clone(), - &self.headers, - true, - None, - ) - .ok(); - self.response_writer.as_mut().unwrap().flush().ok(); - self.must_send_continue = false; - } - - self.data_reader.as_mut().unwrap() - } - - /// Turns the `Request` into a writer. - /// - /// The writer has a raw access to the stream to the user. - /// This function is useful for things like CGI. - /// - /// Note that the destruction of the `Writer` object may trigger - /// some events. For exemple if a client has sent multiple requests and the requests - /// have been processed in parallel, the destruction of a writer will trigger - /// the writing of the next response. - /// Therefore you should always destroy the `Writer` as soon as possible. - #[inline] - pub fn into_writer(mut self) -> Box { - let writer = self.extract_writer_impl(); - if let Some(sender) = self.notify_when_responded.take() { - let writer = NotifyOnDrop { - sender, - inner: writer, - }; - Box::new(writer) as Box - } else { - writer - } - } - - /// Extract the response `Writer` object from the Request, dropping this `Writer` has the same side effects - /// as the object returned by `into_writer` above. - /// - /// This may only be called once on a single request. - fn extract_writer_impl(&mut self) -> Box { - use std::mem; - - assert!(self.response_writer.is_some()); - - let mut writer = None; - mem::swap(&mut self.response_writer, &mut writer); - writer.unwrap() - } - - /// Extract the body `Reader` object from the Request. - /// - /// This may only be called once on a single request. - fn extract_reader_impl(&mut self) -> Box { - use std::mem; - - assert!(self.data_reader.is_some()); - - let mut reader = None; - mem::swap(&mut self.data_reader, &mut reader); - reader.unwrap() - } - - /// Sends a response to this request. - #[inline] - pub fn respond(mut self, response: Response) -> Result<(), IoError> - where - R: Read, - { - let res = self.respond_impl(response); - if let Some(sender) = self.notify_when_responded.take() { - sender.send(()).unwrap(); - } - res - } - - fn respond_impl(&mut self, response: Response) -> Result<(), IoError> - where - R: Read, - { - let mut writer = self.extract_writer_impl(); - - let do_not_send_body = self.method == Method::Head; - - Self::ignore_client_closing_errors(response.raw_print( - writer.by_ref(), - self.http_version.clone(), - &self.headers, - do_not_send_body, - None, - ))?; - - Self::ignore_client_closing_errors(writer.flush()) - } - - fn ignore_client_closing_errors(result: io::Result<()>) -> io::Result<()> { - result.or_else(|err| match err.kind() { - ErrorKind::BrokenPipe => Ok(()), - ErrorKind::ConnectionAborted => Ok(()), - ErrorKind::ConnectionRefused => Ok(()), - ErrorKind::ConnectionReset => Ok(()), - _ => Err(err), - }) - } - - pub(crate) fn with_notify_sender(mut self, sender: Sender<()>) -> Self { - self.notify_when_responded = Some(sender); - self - } -} - -impl fmt::Debug for Request { - fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { - write!( - formatter, - "Request({} {} from {:?})", - self.method, self.path, self.remote_addr - ) - } -} - -impl Drop for Request { - fn drop(&mut self) { - if self.response_writer.is_some() { - let response = Response::empty(500); - let _ = self.respond_impl(response); // ignoring any potential error - if let Some(sender) = self.notify_when_responded.take() { - sender.send(()).unwrap(); - } - } - } -} - -/// Dummy trait that regroups the `Read` and `Write` traits. -/// -/// Automatically implemented on all types that implement both `Read` and `Write`. -pub trait ReadWrite: Read + Write {} -impl ReadWrite for T where T: Read + Write {} - -#[cfg(test)] -mod tests { - use super::Request; - - #[test] - fn must_be_send() { - #![allow(dead_code)] - fn f(_: &T) {} - fn bar(rq: &Request) { - f(rq); - } - } -} diff --git a/anneal/vendor/tiny_http/src/response.rs b/anneal/vendor/tiny_http/src/response.rs deleted file mode 100644 index aaedf5c76b..0000000000 --- a/anneal/vendor/tiny_http/src/response.rs +++ /dev/null @@ -1,574 +0,0 @@ -use crate::common::{HTTPVersion, Header, StatusCode}; -use httpdate::HttpDate; -use std::cmp::Ordering; -use std::sync::mpsc::Receiver; - -use std::io::Result as IoResult; -use std::io::{self, Cursor, Read, Write}; - -use std::fs::File; - -use std::str::FromStr; -use std::time::SystemTime; - -/// Object representing an HTTP response whose purpose is to be given to a `Request`. -/// -/// Some headers cannot be changed. Trying to define the value -/// of one of these will have no effect: -/// -/// - `Connection` -/// - `Trailer` -/// - `Transfer-Encoding` -/// - `Upgrade` -/// -/// Some headers have special behaviors: -/// -/// - `Content-Encoding`: If you define this header, the library -/// will assume that the data from the `Read` object has the specified encoding -/// and will just pass-through. -/// -/// - `Content-Length`: The length of the data should be set manually -/// using the `Reponse` object's API. Attempting to set the value of this -/// header will be equivalent to modifying the size of the data but the header -/// itself may not be present in the final result. -/// -/// - `Content-Type`: You may only set this header to one value at a time. If you -/// try to set it more than once, the existing value will be overwritten. This -/// behavior differs from the default for most headers, which is to allow them to -/// be set multiple times in the same response. -/// -pub struct Response { - reader: R, - status_code: StatusCode, - headers: Vec
, - data_length: Option, - chunked_threshold: Option, -} - -/// A `Response` without a template parameter. -pub type ResponseBox = Response>; - -/// Transfer encoding to use when sending the message. -/// Note that only *supported* encoding are listed here. -#[derive(Copy, Clone)] -enum TransferEncoding { - Identity, - Chunked, -} - -impl FromStr for TransferEncoding { - type Err = (); - - fn from_str(input: &str) -> Result { - if input.eq_ignore_ascii_case("identity") { - Ok(TransferEncoding::Identity) - } else if input.eq_ignore_ascii_case("chunked") { - Ok(TransferEncoding::Chunked) - } else { - Err(()) - } - } -} - -/// Builds a Date: header with the current date. -fn build_date_header() -> Header { - let d = HttpDate::from(SystemTime::now()); - Header::from_bytes(&b"Date"[..], &d.to_string().into_bytes()[..]).unwrap() -} - -fn write_message_header( - mut writer: W, - http_version: &HTTPVersion, - status_code: &StatusCode, - headers: &[Header], -) -> IoResult<()> -where - W: Write, -{ - // writing status line - write!( - &mut writer, - "HTTP/{}.{} {} {}\r\n", - http_version.0, - http_version.1, - status_code.0, - status_code.default_reason_phrase() - )?; - - // writing headers - for header in headers.iter() { - writer.write_all(header.field.as_str().as_ref())?; - write!(&mut writer, ": ")?; - writer.write_all(header.value.as_str().as_ref())?; - write!(&mut writer, "\r\n")?; - } - - // separator between header and data - write!(&mut writer, "\r\n")?; - - Ok(()) -} - -fn choose_transfer_encoding( - status_code: StatusCode, - request_headers: &[Header], - http_version: &HTTPVersion, - entity_length: &Option, - has_additional_headers: bool, - chunked_threshold: usize, -) -> TransferEncoding { - use crate::util; - - // HTTP 1.0 doesn't support other encoding - if *http_version <= (1, 0) { - return TransferEncoding::Identity; - } - - // Per section 3.3.1 of RFC7230: - // A server MUST NOT send a Transfer-Encoding header field in any response with a status code - // of 1xx (Informational) or 204 (No Content). - if status_code.0 < 200 || status_code.0 == 204 { - return TransferEncoding::Identity; - } - - // parsing the request's TE header - let user_request = request_headers - .iter() - // finding TE - .find(|h| h.field.equiv("TE")) - // getting its value - .map(|h| h.value.clone()) - // getting the corresponding TransferEncoding - .and_then(|value| { - // getting list of requested elements - let mut parse = util::parse_header_value(value.as_str()); // TODO: remove conversion - - // sorting elements by most priority - parse.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(Ordering::Equal)); - - // trying to parse each requested encoding - for value in parse.iter() { - // q=0 are ignored - if value.1 <= 0.0 { - continue; - } - - if let Ok(te) = TransferEncoding::from_str(value.0) { - return Some(te); - } - } - - // encoding not found - None - }); - - if let Some(user_request) = user_request { - return user_request; - } - - // if we have additional headers, using chunked - if has_additional_headers { - return TransferEncoding::Chunked; - } - - // if we don't have a Content-Length, or if the Content-Length is too big, using chunks writer - if entity_length - .as_ref() - .map_or(true, |val| *val >= chunked_threshold) - { - return TransferEncoding::Chunked; - } - - // Identity by default - TransferEncoding::Identity -} - -impl Response -where - R: Read, -{ - /// Creates a new Response object. - /// - /// The `additional_headers` argument is a receiver that - /// may provide headers even after the response has been sent. - /// - /// All the other arguments are straight-forward. - pub fn new( - status_code: StatusCode, - headers: Vec
, - data: R, - data_length: Option, - additional_headers: Option>, - ) -> Response { - let mut response = Response { - reader: data, - status_code, - headers: Vec::with_capacity(16), - data_length, - chunked_threshold: None, - }; - - for h in headers { - response.add_header(h) - } - - // dummy implementation - if let Some(additional_headers) = additional_headers { - for h in additional_headers.iter() { - response.add_header(h) - } - } - - response - } - - /// Set a threshold for `Content-Length` where we chose chunked - /// transfer. Notice that chunked transfer might happen regardless of - /// this threshold, for instance when the request headers indicate - /// it is wanted or when there is no `Content-Length`. - pub fn with_chunked_threshold(mut self, length: usize) -> Response { - self.chunked_threshold = Some(length); - self - } - - /// Convert the response into the underlying `Read` type. - /// - /// This is mainly useful for testing as it must consume the `Response`. - pub fn into_reader(self) -> R { - self.reader - } - - /// The current `Content-Length` threshold for switching over to - /// chunked transfer. The default is 32768 bytes. Notice that - /// chunked transfer is mutually exclusive with sending a - /// `Content-Length` header as per the HTTP spec. - pub fn chunked_threshold(&self) -> usize { - self.chunked_threshold.unwrap_or(32768) - } - - /// Adds a header to the list. - /// Does all the checks. - pub fn add_header(&mut self, header: H) - where - H: Into
, - { - let header = header.into(); - - // ignoring forbidden headers - if header.field.equiv("Connection") - || header.field.equiv("Trailer") - || header.field.equiv("Transfer-Encoding") - || header.field.equiv("Upgrade") - { - return; - } - - // if the header is Content-Length, setting the data length - if header.field.equiv("Content-Length") { - if let Ok(val) = usize::from_str(header.value.as_str()) { - self.data_length = Some(val) - } - - return; - // if the header is Content-Type and it's already set, overwrite it - } else if header.field.equiv("Content-Type") { - if let Some(content_type_header) = self - .headers - .iter_mut() - .find(|h| h.field.equiv("Content-Type")) - { - content_type_header.value = header.value; - return; - } - } - - self.headers.push(header); - } - - /// Returns the same request, but with an additional header. - /// - /// Some headers cannot be modified and some other have a - /// special behavior. See the documentation above. - #[inline] - pub fn with_header(mut self, header: H) -> Response - where - H: Into
, - { - self.add_header(header.into()); - self - } - - /// Returns the same request, but with a different status code. - #[inline] - pub fn with_status_code(mut self, code: S) -> Response - where - S: Into, - { - self.status_code = code.into(); - self - } - - /// Returns the same request, but with different data. - pub fn with_data(self, reader: S, data_length: Option) -> Response - where - S: Read, - { - Response { - reader, - headers: self.headers, - status_code: self.status_code, - data_length, - chunked_threshold: self.chunked_threshold, - } - } - - /// Prints the HTTP response to a writer. - /// - /// This function is the one used to send the response to the client's socket. - /// Therefore you shouldn't expect anything pretty-printed or even readable. - /// - /// The HTTP version and headers passed as arguments are used to - /// decide which features (most notably, encoding) to use. - /// - /// Note: does not flush the writer. - pub fn raw_print( - mut self, - mut writer: W, - http_version: HTTPVersion, - request_headers: &[Header], - do_not_send_body: bool, - upgrade: Option<&str>, - ) -> IoResult<()> { - let mut transfer_encoding = Some(choose_transfer_encoding( - self.status_code, - request_headers, - &http_version, - &self.data_length, - false, /* TODO */ - self.chunked_threshold(), - )); - - // add `Date` if not in the headers - if !self.headers.iter().any(|h| h.field.equiv("Date")) { - self.headers.insert(0, build_date_header()); - } - - // add `Server` if not in the headers - if !self.headers.iter().any(|h| h.field.equiv("Server")) { - self.headers.insert( - 0, - Header::from_bytes(&b"Server"[..], &b"tiny-http (Rust)"[..]).unwrap(), - ); - } - - // handling upgrade - if let Some(upgrade) = upgrade { - self.headers.insert( - 0, - Header::from_bytes(&b"Upgrade"[..], upgrade.as_bytes()).unwrap(), - ); - self.headers.insert( - 0, - Header::from_bytes(&b"Connection"[..], &b"upgrade"[..]).unwrap(), - ); - transfer_encoding = None; - } - - // if the transfer encoding is identity, the content length must be known ; therefore if - // we don't know it, we buffer the entire response first here - // while this is an expensive operation, it is only ever needed for clients using HTTP 1.0 - let (mut reader, data_length): (Box, _) = - match (self.data_length, transfer_encoding) { - (Some(l), _) => (Box::new(self.reader), Some(l)), - (None, Some(TransferEncoding::Identity)) => { - let mut buf = Vec::new(); - self.reader.read_to_end(&mut buf)?; - let l = buf.len(); - (Box::new(Cursor::new(buf)), Some(l)) - } - _ => (Box::new(self.reader), None), - }; - - // checking whether to ignore the body of the response - let do_not_send_body = do_not_send_body - || match self.status_code.0 { - // status code 1xx, 204 and 304 MUST not include a body - 100..=199 | 204 | 304 => true, - _ => false, - }; - - // preparing headers for transfer - match transfer_encoding { - Some(TransferEncoding::Chunked) => self - .headers - .push(Header::from_bytes(&b"Transfer-Encoding"[..], &b"chunked"[..]).unwrap()), - - Some(TransferEncoding::Identity) => { - assert!(data_length.is_some()); - let data_length = data_length.unwrap(); - - self.headers.push( - Header::from_bytes( - &b"Content-Length"[..], - format!("{}", data_length).as_bytes(), - ) - .unwrap(), - ) - } - - _ => (), - }; - - // sending headers - write_message_header( - writer.by_ref(), - &http_version, - &self.status_code, - &self.headers, - )?; - - // sending the body - if !do_not_send_body { - match transfer_encoding { - Some(TransferEncoding::Chunked) => { - use chunked_transfer::Encoder; - - let mut writer = Encoder::new(writer); - io::copy(&mut reader, &mut writer)?; - } - - Some(TransferEncoding::Identity) => { - assert!(data_length.is_some()); - let data_length = data_length.unwrap(); - - if data_length >= 1 { - io::copy(&mut reader, &mut writer)?; - } - } - - _ => (), - } - } - - Ok(()) - } - - /// Retrieves the current value of the `Response` status code - pub fn status_code(&self) -> StatusCode { - self.status_code - } - - /// Retrieves the current value of the `Response` data length - pub fn data_length(&self) -> Option { - self.data_length - } - - /// Retrieves the current list of `Response` headers - pub fn headers(&self) -> &[Header] { - &self.headers - } -} - -impl Response -where - R: Read + Send + 'static, -{ - /// Turns this response into a `Response>`. - pub fn boxed(self) -> ResponseBox { - Response { - reader: Box::new(self.reader) as Box, - status_code: self.status_code, - headers: self.headers, - data_length: self.data_length, - chunked_threshold: self.chunked_threshold, - } - } -} - -impl Response { - /// Builds a new `Response` from a `File`. - /// - /// The `Content-Type` will **not** be automatically detected, - /// you must set it yourself. - pub fn from_file(file: File) -> Response { - let file_size = file.metadata().ok().map(|v| v.len() as usize); - - Response::new( - StatusCode(200), - Vec::with_capacity(0), - file, - file_size, - None, - ) - } -} - -impl Response>> { - pub fn from_data(data: D) -> Response>> - where - D: Into>, - { - let data = data.into(); - let data_len = data.len(); - - Response::new( - StatusCode(200), - Vec::with_capacity(0), - Cursor::new(data), - Some(data_len), - None, - ) - } - - pub fn from_string(data: S) -> Response>> - where - S: Into, - { - let data = data.into(); - let data_len = data.len(); - - Response::new( - StatusCode(200), - vec![ - Header::from_bytes(&b"Content-Type"[..], &b"text/plain; charset=UTF-8"[..]) - .unwrap(), - ], - Cursor::new(data.into_bytes()), - Some(data_len), - None, - ) - } -} - -impl Response { - /// Builds an empty `Response` with the given status code. - pub fn empty(status_code: S) -> Response - where - S: Into, - { - Response::new( - status_code.into(), - Vec::with_capacity(0), - io::empty(), - Some(0), - None, - ) - } - - /// DEPRECATED. Use `empty` instead. - pub fn new_empty(status_code: StatusCode) -> Response { - Response::empty(status_code) - } -} - -impl Clone for Response { - fn clone(&self) -> Response { - Response { - reader: io::empty(), - status_code: self.status_code, - headers: self.headers.clone(), - data_length: self.data_length, - chunked_threshold: self.chunked_threshold, - } - } -} diff --git a/anneal/vendor/tiny_http/src/ssl.rs b/anneal/vendor/tiny_http/src/ssl.rs deleted file mode 100644 index d4a8f1b914..0000000000 --- a/anneal/vendor/tiny_http/src/ssl.rs +++ /dev/null @@ -1,20 +0,0 @@ -//! Modules providing SSL/TLS implementations. For backwards compatibility, OpenSSL is the default -//! implementation, but Rustls is highly recommended as a pure Rust alternative. -//! -//! In order to simplify the swappable implementations these SSL/TLS modules adhere to an implicit -//! trait contract and specific implementations are re-exported as [`SslContextImpl`] and [`SslStream`]. -//! The concrete type of these aliases will depend on which module you enable in `Cargo.toml`. - -#[cfg(feature = "ssl-openssl")] -pub(crate) mod openssl; -#[cfg(feature = "ssl-openssl")] -pub(crate) use self::openssl::OpenSslContext as SslContextImpl; -#[cfg(feature = "ssl-openssl")] -pub(crate) use self::openssl::SplitOpenSslStream as SslStream; - -#[cfg(feature = "ssl-rustls")] -pub(crate) mod rustls; -#[cfg(feature = "ssl-rustls")] -pub(crate) use self::rustls::RustlsContext as SslContextImpl; -#[cfg(feature = "ssl-rustls")] -pub(crate) use self::rustls::RustlsStream as SslStream; diff --git a/anneal/vendor/tiny_http/src/ssl/openssl.rs b/anneal/vendor/tiny_http/src/ssl/openssl.rs deleted file mode 100644 index 55d4650096..0000000000 --- a/anneal/vendor/tiny_http/src/ssl/openssl.rs +++ /dev/null @@ -1,110 +0,0 @@ -use crate::connection::Connection; -use crate::util::refined_tcp_stream::Stream as RefinedStream; -use std::error::Error; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; -use std::sync::{Arc, Mutex}; -use zeroize::Zeroizing; - -pub(crate) struct OpenSslStream { - inner: openssl::ssl::SslStream, -} - -/// An OpenSSL stream which has been split into two mutually exclusive streams (e.g. for read / write) -pub(crate) struct SplitOpenSslStream(Arc>); - -// These struct methods form the implict contract for swappable TLS implementations -impl SplitOpenSslStream { - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - self.0.lock().unwrap().inner.get_mut().peer_addr() - } - - pub(crate) fn shutdown(&mut self, how: Shutdown) -> std::io::Result<()> { - self.0.lock().unwrap().inner.get_mut().shutdown(how) - } -} - -impl Clone for SplitOpenSslStream { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Read for SplitOpenSslStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.0.lock().unwrap().read(buf) - } -} - -impl Write for SplitOpenSslStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.0.lock().unwrap().write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.0.lock().unwrap().flush() - } -} - -impl Read for OpenSslStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.inner.read(buf) - } -} - -impl Write for OpenSslStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.inner.write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.inner.flush() - } -} - -pub(crate) struct OpenSslContext(openssl::ssl::SslContext); - -impl OpenSslContext { - pub fn from_pem( - certificates: Vec, - private_key: Zeroizing>, - ) -> Result> { - use openssl::pkey::PKey; - use openssl::ssl::{self, SslVerifyMode}; - use openssl::x509::X509; - - let mut ctx = openssl::ssl::SslContext::builder(ssl::SslMethod::tls())?; - ctx.set_cipher_list("DEFAULT")?; - let certificate_chain = X509::stack_from_pem(&certificates)?; - if certificate_chain.is_empty() { - return Err("Couldn't extract certificate chain from config.".into()); - } - // The leaf certificate must always be first in the PEM file - ctx.set_certificate(&certificate_chain[0])?; - for chain_cert in certificate_chain.into_iter().skip(1) { - ctx.add_extra_chain_cert(chain_cert)?; - } - let key = PKey::private_key_from_pem(&private_key)?; - ctx.set_private_key(&key)?; - ctx.set_verify(SslVerifyMode::NONE); - ctx.check_private_key()?; - - Ok(Self(ctx.build())) - } - - pub fn accept( - &self, - stream: Connection, - ) -> Result> { - use openssl::ssl::Ssl; - let session = Ssl::new(&self.0).expect("Failed to create new OpenSSL session"); - let stream = session.accept(stream)?; - Ok(OpenSslStream { inner: stream }) - } -} - -impl From for RefinedStream { - fn from(stream: OpenSslStream) -> Self { - RefinedStream::Https(SplitOpenSslStream(Arc::new(Mutex::new(stream)))) - } -} diff --git a/anneal/vendor/tiny_http/src/ssl/rustls.rs b/anneal/vendor/tiny_http/src/ssl/rustls.rs deleted file mode 100644 index ccc6fdf466..0000000000 --- a/anneal/vendor/tiny_http/src/ssl/rustls.rs +++ /dev/null @@ -1,120 +0,0 @@ -use crate::connection::Connection; -use crate::util::refined_tcp_stream::Stream as RefinedStream; -use std::error::Error; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; -use std::sync::{Arc, Mutex}; -use zeroize::Zeroizing; - -/// A wrapper around an owned Rustls connection and corresponding stream. -/// -/// Uses an internal Mutex to permit disparate reader & writer threads to access the stream independently. -pub(crate) struct RustlsStream( - Arc>>, -); - -impl RustlsStream { - pub(crate) fn peer_addr(&mut self) -> std::io::Result> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .sock - .peer_addr() - } - - pub(crate) fn shutdown(&mut self, how: Shutdown) -> std::io::Result<()> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .sock - .shutdown(how) - } -} - -impl Clone for RustlsStream { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Read for RustlsStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .read(buf) - } -} - -impl Write for RustlsStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .write(buf) - } - - fn flush(&mut self) -> std::io::Result<()> { - self.0 - .lock() - .expect("Failed to lock SSL stream mutex") - .flush() - } -} - -pub(crate) struct RustlsContext(Arc); - -impl RustlsContext { - pub(crate) fn from_pem( - certificates: Vec, - private_key: Zeroizing>, - ) -> Result> { - let certificate_chain: Vec = - rustls_pemfile::certs(&mut certificates.as_slice())? - .into_iter() - .map(|bytes| rustls::Certificate(bytes)) - .collect(); - - if certificate_chain.is_empty() { - return Err("Couldn't extract certificate chain from config.".into()); - } - - let private_key = rustls::PrivateKey({ - let pkcs8_keys = rustls_pemfile::pkcs8_private_keys( - &mut private_key.clone().as_slice(), - ) - .expect("file contains invalid pkcs8 private key (encrypted keys are not supported)"); - - if let Some(pkcs8_key) = pkcs8_keys.first() { - pkcs8_key.clone() - } else { - let rsa_keys = rustls_pemfile::rsa_private_keys(&mut private_key.as_slice()) - .expect("file contains invalid rsa private key"); - rsa_keys[0].clone() - } - }); - - let tls_conf = rustls::ServerConfig::builder() - .with_safe_defaults() - .with_no_client_auth() - .with_single_cert(certificate_chain, private_key)?; - - Ok(Self(Arc::new(tls_conf))) - } - - pub(crate) fn accept( - &self, - stream: Connection, - ) -> Result> { - let connection = rustls::ServerConnection::new(self.0.clone())?; - Ok(RustlsStream(Arc::new(Mutex::new( - rustls::StreamOwned::new(connection, stream), - )))) - } -} - -impl From for RefinedStream { - fn from(stream: RustlsStream) -> Self { - Self::Https(stream) - } -} diff --git a/anneal/vendor/tiny_http/src/test.rs b/anneal/vendor/tiny_http/src/test.rs deleted file mode 100644 index 996f025678..0000000000 --- a/anneal/vendor/tiny_http/src/test.rs +++ /dev/null @@ -1,127 +0,0 @@ -use crate::{request::new_request, HTTPVersion, Header, HeaderField, Method, Request}; -use ascii::AsciiString; -use std::net::SocketAddr; -use std::str::FromStr; - -/// A simpler version of [`Request`] that is useful for testing. No data actually goes anywhere. -/// -/// By default, `TestRequest` pretends to be an insecure GET request for the server root (`/`) -/// with no headers. To create a `TestRequest` with different parameters, use the builder pattern: -/// -/// ``` -/// # use tiny_http::{Method, TestRequest}; -/// let request = TestRequest::new() -/// .with_method(Method::Post) -/// .with_path("/api/widgets") -/// .with_body("42"); -/// ``` -/// -/// Then, convert the `TestRequest` into a real `Request` and pass it to the server under test: -/// -/// ``` -/// # use tiny_http::{Method, Request, Response, Server, StatusCode, TestRequest}; -/// # use std::io::Cursor; -/// # let request = TestRequest::new() -/// # .with_method(Method::Post) -/// # .with_path("/api/widgets") -/// # .with_body("42"); -/// # struct TestServer { -/// # listener: Server, -/// # } -/// # let server = TestServer { -/// # listener: Server::http("0.0.0.0:0").unwrap(), -/// # }; -/// # impl TestServer { -/// # fn handle_request(&self, request: Request) -> Response>> { -/// # Response::from_string("test") -/// # } -/// # } -/// let response = server.handle_request(request.into()); -/// assert_eq!(response.status_code(), StatusCode(200)); -/// ``` -pub struct TestRequest { - body: &'static str, - remote_addr: SocketAddr, - // true if HTTPS, false if HTTP - secure: bool, - method: Method, - path: String, - http_version: HTTPVersion, - headers: Vec
, -} - -impl From for Request { - fn from(mut mock: TestRequest) -> Request { - // if the user didn't set the Content-Length header, then set it for them - // otherwise, leave it alone (it may be under test) - if !mock - .headers - .iter_mut() - .any(|h| h.field.equiv("Content-Length")) - { - mock.headers.push(Header { - field: HeaderField::from_str("Content-Length").unwrap(), - value: AsciiString::from_ascii(mock.body.len().to_string()).unwrap(), - }); - } - new_request( - mock.secure, - mock.method, - mock.path, - mock.http_version, - mock.headers, - Some(mock.remote_addr), - mock.body.as_bytes(), - std::io::sink(), - ) - .unwrap() - } -} - -impl Default for TestRequest { - fn default() -> Self { - TestRequest { - body: "", - remote_addr: "127.0.0.1:23456".parse().unwrap(), - secure: false, - method: Method::Get, - path: "/".to_string(), - http_version: HTTPVersion::from((1, 1)), - headers: Vec::new(), - } - } -} - -impl TestRequest { - pub fn new() -> Self { - TestRequest::default() - } - pub fn with_body(mut self, body: &'static str) -> Self { - self.body = body; - self - } - pub fn with_remote_addr(mut self, remote_addr: SocketAddr) -> Self { - self.remote_addr = remote_addr; - self - } - pub fn with_https(mut self) -> Self { - self.secure = true; - self - } - pub fn with_method(mut self, method: Method) -> Self { - self.method = method; - self - } - pub fn with_path(mut self, path: &str) -> Self { - self.path = path.to_string(); - self - } - pub fn with_http_version(mut self, version: HTTPVersion) -> Self { - self.http_version = version; - self - } - pub fn with_header(mut self, header: Header) -> Self { - self.headers.push(header); - self - } -} diff --git a/anneal/vendor/tiny_http/src/util/custom_stream.rs b/anneal/vendor/tiny_http/src/util/custom_stream.rs deleted file mode 100644 index ac00b9efc7..0000000000 --- a/anneal/vendor/tiny_http/src/util/custom_stream.rs +++ /dev/null @@ -1,39 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; - -pub struct CustomStream { - reader: R, - writer: W, -} - -impl CustomStream -where - R: Read, - W: Write, -{ - pub fn new(reader: R, writer: W) -> CustomStream { - CustomStream { reader, writer } - } -} - -impl Read for CustomStream -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - self.reader.read(buf) - } -} - -impl Write for CustomStream -where - W: Write, -{ - fn write(&mut self, buf: &[u8]) -> IoResult { - self.writer.write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - self.writer.flush() - } -} diff --git a/anneal/vendor/tiny_http/src/util/equal_reader.rs b/anneal/vendor/tiny_http/src/util/equal_reader.rs deleted file mode 100644 index 1305bc5fd7..0000000000 --- a/anneal/vendor/tiny_http/src/util/equal_reader.rs +++ /dev/null @@ -1,131 +0,0 @@ -use std::io::Read; -use std::io::Result as IoResult; -use std::sync::mpsc::channel; -use std::sync::mpsc::{Receiver, Sender}; - -/// A `Reader` that reads exactly the number of bytes from a sub-reader. -/// -/// If the limit is reached, it returns EOF. If the limit is not reached -/// when the destructor is called, the remaining bytes will be read and -/// thrown away. -pub struct EqualReader -where - R: Read, -{ - reader: R, - size: usize, - last_read_signal: Sender>, -} - -impl EqualReader -where - R: Read, -{ - pub fn new(reader: R, size: usize) -> (EqualReader, Receiver>) { - let (tx, rx) = channel(); - - let r = EqualReader { - reader, - size, - last_read_signal: tx, - }; - - (r, rx) - } -} - -impl Read for EqualReader -where - R: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> IoResult { - if self.size == 0 { - return Ok(0); - } - - let buf = if buf.len() < self.size { - buf - } else { - &mut buf[..self.size] - }; - - match self.reader.read(buf) { - Ok(len) => { - self.size -= len; - Ok(len) - } - err @ Err(_) => err, - } - } -} - -impl Drop for EqualReader -where - R: Read, -{ - fn drop(&mut self) { - let mut remaining_to_read = self.size; - - while remaining_to_read > 0 { - let mut buf = vec![0; remaining_to_read]; - - match self.reader.read(&mut buf) { - Err(e) => { - self.last_read_signal.send(Err(e)).ok(); - break; - } - Ok(0) => { - self.last_read_signal.send(Ok(())).ok(); - break; - } - Ok(other) => { - remaining_to_read -= other; - } - } - } - } -} - -#[cfg(test)] -mod tests { - use super::EqualReader; - use std::io::Read; - - #[test] - fn test_limit() { - use std::io::Cursor; - - let mut org_reader = Cursor::new("hello world".to_string().into_bytes()); - - { - let (mut equal_reader, _) = EqualReader::new(org_reader.by_ref(), 5); - - let mut string = String::new(); - equal_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, "hello"); - } - - let mut string = String::new(); - org_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, " world"); - } - - #[test] - fn test_not_enough() { - use std::io::Cursor; - - let mut org_reader = Cursor::new("hello world".to_string().into_bytes()); - - { - let (mut equal_reader, _) = EqualReader::new(org_reader.by_ref(), 5); - - let mut vec = [0]; - equal_reader.read_exact(&mut vec).unwrap(); - assert_eq!(vec[0], b'h'); - } - - let mut string = String::new(); - org_reader.read_to_string(&mut string).unwrap(); - assert_eq!(string, " world"); - } -} diff --git a/anneal/vendor/tiny_http/src/util/fused_reader.rs b/anneal/vendor/tiny_http/src/util/fused_reader.rs deleted file mode 100644 index 6300387946..0000000000 --- a/anneal/vendor/tiny_http/src/util/fused_reader.rs +++ /dev/null @@ -1,48 +0,0 @@ -use std::io::{IoSliceMut, Read, Result as IoResult}; - -/// Wraps another reader and provides "fused" behavior. -/// When the underlying reader reaches EOF, it is dropped -/// and the fused reader becomes an empty stub. -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct FusedReader { - inner: Option, -} - -impl FusedReader { - pub fn new(inner: R) -> Self { - Self { inner: Some(inner) } - } - - #[allow(dead_code)] - pub fn into_inner(self) -> Option { - self.inner - } -} - -impl Read for FusedReader { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - match &mut self.inner { - Some(r) => { - let l = r.read(buf)?; - if l == 0 { - self.inner = None; - } - Ok(l) - } - None => Ok(0), - } - } - - fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> IoResult { - match &mut self.inner { - Some(r) => { - let l = r.read_vectored(bufs)?; - if l == 0 { - self.inner = None; - } - Ok(l) - } - None => Ok(0), - } - } -} diff --git a/anneal/vendor/tiny_http/src/util/messages_queue.rs b/anneal/vendor/tiny_http/src/util/messages_queue.rs deleted file mode 100644 index d94e7dbb74..0000000000 --- a/anneal/vendor/tiny_http/src/util/messages_queue.rs +++ /dev/null @@ -1,96 +0,0 @@ -use std::collections::VecDeque; -use std::sync::{Arc, Condvar, Mutex}; -use std::time::{Duration, Instant}; - -enum Control { - Elem(T), - Unblock, -} - -pub struct MessagesQueue -where - T: Send, -{ - queue: Mutex>>, - condvar: Condvar, -} - -impl MessagesQueue -where - T: Send, -{ - pub fn with_capacity(capacity: usize) -> Arc> { - Arc::new(MessagesQueue { - queue: Mutex::new(VecDeque::with_capacity(capacity)), - condvar: Condvar::new(), - }) - } - - /// Pushes an element to the queue. - pub fn push(&self, value: T) { - let mut queue = self.queue.lock().unwrap(); - queue.push_back(Control::Elem(value)); - self.condvar.notify_one(); - } - - /// Unblock one thread stuck in pop loop. - pub fn unblock(&self) { - let mut queue = self.queue.lock().unwrap(); - queue.push_back(Control::Unblock); - self.condvar.notify_one(); - } - - /// Pops an element. Blocks until one is available. - /// Returns None in case unblock() was issued. - pub fn pop(&self) -> Option { - let mut queue = self.queue.lock().unwrap(); - - loop { - match queue.pop_front() { - Some(Control::Elem(value)) => return Some(value), - Some(Control::Unblock) => return None, - None => (), - } - - queue = self.condvar.wait(queue).unwrap(); - } - } - - /// Tries to pop an element without blocking. - pub fn try_pop(&self) -> Option { - let mut queue = self.queue.lock().unwrap(); - match queue.pop_front() { - Some(Control::Elem(value)) => Some(value), - Some(Control::Unblock) | None => None, - } - } - - /// Tries to pop an element without blocking - /// more than the specified timeout duration - /// or unblock() was issued - pub fn pop_timeout(&self, timeout: Duration) -> Option { - let mut queue = self.queue.lock().unwrap(); - let mut duration = timeout; - loop { - match queue.pop_front() { - Some(Control::Elem(value)) => return Some(value), - Some(Control::Unblock) => return None, - None => (), - } - let now = Instant::now(); - let (_queue, result) = self.condvar.wait_timeout(queue, timeout).unwrap(); - queue = _queue; - let sleep_time = now.elapsed(); - duration = if duration > sleep_time { - duration - sleep_time - } else { - Duration::from_millis(0) - }; - if result.timed_out() - || (duration.as_secs() == 0 && duration.subsec_nanos() < 1_000_000) - { - return None; - } - } - } -} diff --git a/anneal/vendor/tiny_http/src/util/mod.rs b/anneal/vendor/tiny_http/src/util/mod.rs deleted file mode 100644 index 4fb2aca5c3..0000000000 --- a/anneal/vendor/tiny_http/src/util/mod.rs +++ /dev/null @@ -1,64 +0,0 @@ -pub use self::custom_stream::CustomStream; -pub use self::equal_reader::EqualReader; -pub use self::fused_reader::FusedReader; -pub use self::messages_queue::MessagesQueue; -pub use self::refined_tcp_stream::RefinedTcpStream; -pub use self::sequential::{SequentialReader, SequentialReaderBuilder}; -pub use self::sequential::{SequentialWriter, SequentialWriterBuilder}; -pub use self::task_pool::TaskPool; - -use std::str::FromStr; - -mod custom_stream; -mod equal_reader; -mod fused_reader; -mod messages_queue; -pub(crate) mod refined_tcp_stream; -mod sequential; -mod task_pool; - -/// Parses a the value of a header. -/// Suitable for `Accept-*`, `TE`, etc. -/// -/// For example with `text/plain, image/png; q=1.5` this function would -/// return `[ ("text/plain", 1.0), ("image/png", 1.5) ]` -pub fn parse_header_value(input: &str) -> Vec<(&str, f32)> { - input - .split(',') - .filter_map(|elem| { - let mut params = elem.split(';'); - - let t = params.next()?; - - let mut value = 1.0_f32; - - for p in params { - if p.trim_start().starts_with("q=") { - if let Ok(val) = f32::from_str(p.trim_start()[2..].trim()) { - value = val; - break; - } - } - } - - Some((t.trim(), value)) - }) - .collect() -} - -#[cfg(test)] -mod test { - #[test] - #[allow(clippy::float_cmp)] - fn test_parse_header() { - let result = super::parse_header_value("text/html, text/plain; q=1.5 , image/png ; q=2.0"); - - assert_eq!(result.len(), 3); - assert_eq!(result[0].0, "text/html"); - assert_eq!(result[0].1, 1.0); - assert_eq!(result[1].0, "text/plain"); - assert_eq!(result[1].1, 1.5); - assert_eq!(result[2].0, "image/png"); - assert_eq!(result[2].1, 2.0); - } -} diff --git a/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs b/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs deleted file mode 100644 index 875fbe2fba..0000000000 --- a/anneal/vendor/tiny_http/src/util/refined_tcp_stream.rs +++ /dev/null @@ -1,152 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; -use std::net::{Shutdown, SocketAddr}; - -use crate::connection::Connection; -#[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] -use crate::ssl::SslStream; - -pub(crate) enum Stream { - Http(Connection), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Https(SslStream), -} - -impl Clone for Stream { - fn clone(&self) -> Self { - match self { - Stream::Http(tcp_stream) => Stream::Http(tcp_stream.try_clone().unwrap()), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => Stream::Https(ssl_stream.clone()), - } - } -} - -impl From for Stream { - fn from(tcp_stream: Connection) -> Self { - Stream::Http(tcp_stream) - } -} - -impl Stream { - fn secure(&self) -> bool { - match self { - Stream::Http(_) => false, - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(_) => true, - } - } - - fn peer_addr(&mut self) -> IoResult> { - match self { - Stream::Http(tcp_stream) => tcp_stream.peer_addr(), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.peer_addr(), - } - } - - fn shutdown(&mut self, how: Shutdown) -> IoResult<()> { - match self { - Stream::Http(tcp_stream) => tcp_stream.shutdown(how), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.shutdown(how), - } - } -} - -impl Read for Stream { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - match self { - Stream::Http(tcp_stream) => tcp_stream.read(buf), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.read(buf), - } - } -} - -impl Write for Stream { - fn write(&mut self, buf: &[u8]) -> IoResult { - match self { - Stream::Http(tcp_stream) => tcp_stream.write(buf), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.write(buf), - } - } - - fn flush(&mut self) -> IoResult<()> { - match self { - Stream::Http(tcp_stream) => tcp_stream.flush(), - #[cfg(any(feature = "ssl-openssl", feature = "ssl-rustls"))] - Stream::Https(ssl_stream) => ssl_stream.flush(), - } - } -} - -pub struct RefinedTcpStream { - stream: Stream, - close_read: bool, - close_write: bool, -} - -impl RefinedTcpStream { - pub(crate) fn new(stream: S) -> (RefinedTcpStream, RefinedTcpStream) - where - S: Into, - { - let stream: Stream = stream.into(); - - let (read, write) = (stream.clone(), stream); - - let read = RefinedTcpStream { - stream: read, - close_read: true, - close_write: false, - }; - - let write = RefinedTcpStream { - stream: write, - close_read: false, - close_write: true, - }; - - (read, write) - } - - /// Returns true if this struct wraps around a secure connection. - #[inline] - pub(crate) fn secure(&self) -> bool { - self.stream.secure() - } - - pub(crate) fn peer_addr(&mut self) -> IoResult> { - self.stream.peer_addr() - } -} - -impl Drop for RefinedTcpStream { - fn drop(&mut self) { - if self.close_read { - self.stream.shutdown(Shutdown::Read).ok(); - } - - if self.close_write { - self.stream.shutdown(Shutdown::Write).ok(); - } - } -} - -impl Read for RefinedTcpStream { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - self.stream.read(buf) - } -} - -impl Write for RefinedTcpStream { - fn write(&mut self, buf: &[u8]) -> IoResult { - self.stream.write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - self.stream.flush() - } -} diff --git a/anneal/vendor/tiny_http/src/util/sequential.rs b/anneal/vendor/tiny_http/src/util/sequential.rs deleted file mode 100644 index 8ecc3b93fd..0000000000 --- a/anneal/vendor/tiny_http/src/util/sequential.rs +++ /dev/null @@ -1,174 +0,0 @@ -use std::io::Result as IoResult; -use std::io::{Read, Write}; - -use std::sync::mpsc::channel; -use std::sync::mpsc::{Receiver, Sender}; -use std::sync::{Arc, Mutex}; - -use std::mem; - -pub struct SequentialReaderBuilder -where - R: Read + Send, -{ - inner: SequentialReaderBuilderInner, -} - -enum SequentialReaderBuilderInner -where - R: Read + Send, -{ - First(R), - NotFirst(Receiver), -} - -pub struct SequentialReader -where - R: Read + Send, -{ - inner: SequentialReaderInner, - next: Sender, -} - -enum SequentialReaderInner -where - R: Read + Send, -{ - MyTurn(R), - Waiting(Receiver), - Empty, -} - -pub struct SequentialWriterBuilder -where - W: Write + Send, -{ - writer: Arc>, - next_trigger: Option>, -} - -pub struct SequentialWriter -where - W: Write + Send, -{ - trigger: Option>, - writer: Arc>, - on_finish: Sender<()>, -} - -impl SequentialReaderBuilder { - pub fn new(reader: R) -> SequentialReaderBuilder { - SequentialReaderBuilder { - inner: SequentialReaderBuilderInner::First(reader), - } - } -} - -impl SequentialWriterBuilder { - pub fn new(writer: W) -> SequentialWriterBuilder { - SequentialWriterBuilder { - writer: Arc::new(Mutex::new(writer)), - next_trigger: None, - } - } -} - -impl Iterator for SequentialReaderBuilder { - type Item = SequentialReader; - - fn next(&mut self) -> Option> { - let (tx, rx) = channel(); - - let inner = mem::replace(&mut self.inner, SequentialReaderBuilderInner::NotFirst(rx)); - - match inner { - SequentialReaderBuilderInner::First(reader) => Some(SequentialReader { - inner: SequentialReaderInner::MyTurn(reader), - next: tx, - }), - - SequentialReaderBuilderInner::NotFirst(previous) => Some(SequentialReader { - inner: SequentialReaderInner::Waiting(previous), - next: tx, - }), - } - } -} - -impl Iterator for SequentialWriterBuilder { - type Item = SequentialWriter; - fn next(&mut self) -> Option> { - let (tx, rx) = channel(); - let mut next_next_trigger = Some(rx); - ::std::mem::swap(&mut next_next_trigger, &mut self.next_trigger); - - Some(SequentialWriter { - trigger: next_next_trigger, - writer: self.writer.clone(), - on_finish: tx, - }) - } -} - -impl Read for SequentialReader { - fn read(&mut self, buf: &mut [u8]) -> IoResult { - let mut reader = match self.inner { - SequentialReaderInner::MyTurn(ref mut reader) => return reader.read(buf), - SequentialReaderInner::Waiting(ref mut recv) => recv.recv().unwrap(), - SequentialReaderInner::Empty => unreachable!(), - }; - - let result = reader.read(buf); - self.inner = SequentialReaderInner::MyTurn(reader); - result - } -} - -impl Write for SequentialWriter { - fn write(&mut self, buf: &[u8]) -> IoResult { - if let Some(v) = self.trigger.as_mut() { - v.recv().unwrap() - } - self.trigger = None; - - self.writer.lock().unwrap().write(buf) - } - - fn flush(&mut self) -> IoResult<()> { - if let Some(v) = self.trigger.as_mut() { - v.recv().unwrap() - } - self.trigger = None; - - self.writer.lock().unwrap().flush() - } -} - -impl Drop for SequentialReader -where - R: Read + Send, -{ - fn drop(&mut self) { - let inner = mem::replace(&mut self.inner, SequentialReaderInner::Empty); - - match inner { - SequentialReaderInner::MyTurn(reader) => { - self.next.send(reader).ok(); - } - SequentialReaderInner::Waiting(recv) => { - let reader = recv.recv().unwrap(); - self.next.send(reader).ok(); - } - SequentialReaderInner::Empty => (), - } - } -} - -impl Drop for SequentialWriter -where - W: Write + Send, -{ - fn drop(&mut self) { - self.on_finish.send(()).ok(); - } -} diff --git a/anneal/vendor/tiny_http/src/util/task_pool.rs b/anneal/vendor/tiny_http/src/util/task_pool.rs deleted file mode 100644 index 155a34d9cd..0000000000 --- a/anneal/vendor/tiny_http/src/util/task_pool.rs +++ /dev/null @@ -1,137 +0,0 @@ -use std::collections::VecDeque; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; -use std::time::Duration; - -/// Manages a collection of threads. -/// -/// A new thread is created every time all the existing threads are full. -/// Any idle thread will automatically die after a few seconds. -pub struct TaskPool { - sharing: Arc, -} - -struct Sharing { - // list of the tasks to be done by worker threads - todo: Mutex>>, - - // condvar that will be notified whenever a task is added to `todo` - condvar: Condvar, - - // number of total worker threads running - active_tasks: AtomicUsize, - - // number of idle worker threads - waiting_tasks: AtomicUsize, -} - -/// Minimum number of active threads. -static MIN_THREADS: usize = 4; - -struct Registration<'a> { - nb: &'a AtomicUsize, -} - -impl<'a> Registration<'a> { - fn new(nb: &'a AtomicUsize) -> Registration<'a> { - nb.fetch_add(1, Ordering::Release); - Registration { nb } - } -} - -impl<'a> Drop for Registration<'a> { - fn drop(&mut self) { - self.nb.fetch_sub(1, Ordering::Release); - } -} - -impl TaskPool { - pub fn new() -> TaskPool { - let pool = TaskPool { - sharing: Arc::new(Sharing { - todo: Mutex::new(VecDeque::new()), - condvar: Condvar::new(), - active_tasks: AtomicUsize::new(0), - waiting_tasks: AtomicUsize::new(0), - }), - }; - - for _ in 0..MIN_THREADS { - pool.add_thread(None) - } - - pool - } - - /// Executes a function in a thread. - /// If no thread is available, spawns a new one. - pub fn spawn(&self, code: Box) { - let mut queue = self.sharing.todo.lock().unwrap(); - - if self.sharing.waiting_tasks.load(Ordering::Acquire) == 0 { - self.add_thread(Some(code)); - } else { - queue.push_back(code); - self.sharing.condvar.notify_one(); - } - } - - fn add_thread(&self, initial_fn: Option>) { - let sharing = self.sharing.clone(); - - thread::spawn(move || { - let sharing = sharing; - let _active_guard = Registration::new(&sharing.active_tasks); - - if let Some(mut f) = initial_fn { - f(); - } - - loop { - let mut task: Box = { - let mut todo = sharing.todo.lock().unwrap(); - - let task; - loop { - if let Some(poped_task) = todo.pop_front() { - task = poped_task; - break; - } - let _waiting_guard = Registration::new(&sharing.waiting_tasks); - - let received = - if sharing.active_tasks.load(Ordering::Acquire) <= MIN_THREADS { - todo = sharing.condvar.wait(todo).unwrap(); - true - } else { - let (new_lock, waitres) = sharing - .condvar - .wait_timeout(todo, Duration::from_millis(5000)) - .unwrap(); - todo = new_lock; - !waitres.timed_out() - }; - - if !received && todo.is_empty() { - return; - } - } - - task - }; - - task(); - } - }); - } -} - -impl Drop for TaskPool { - fn drop(&mut self) { - self.sharing - .active_tasks - .store(999_999_999, Ordering::Release); - self.sharing.condvar.notify_all(); - } -} diff --git a/anneal/vendor/tiny_http/tests/input-tests.rs b/anneal/vendor/tiny_http/tests/input-tests.rs deleted file mode 100644 index 10974be78a..0000000000 --- a/anneal/vendor/tiny_http/tests/input-tests.rs +++ /dev/null @@ -1,122 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; -use std::net::Shutdown; -use std::sync::mpsc; -use std::thread; - -#[allow(dead_code)] -mod support; - -#[test] -fn basic_string_input() { - let (server, client) = support::new_one_server_one_client(); - - { - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 5\r\n\r\nhello")).unwrap(); - } - - let mut request = server.recv().unwrap(); - - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hello"); -} - -#[test] -fn wrong_content_length() { - let (server, client) = support::new_one_server_one_client(); - - { - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 3\r\n\r\nhello")).unwrap(); - } - - let mut request = server.recv().unwrap(); - - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hel"); -} - -#[test] -fn expect_100_continue() { - let (server, client) = support::new_one_server_one_client(); - - let mut client = client; - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nExpect: 100-continue\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length: 5\r\n\r\n")).unwrap(); - client.flush().unwrap(); - - let (tx, rx) = mpsc::channel(); - - thread::spawn(move || { - let mut request = server.recv().unwrap(); - let mut output = String::new(); - request.as_reader().read_to_string(&mut output).unwrap(); - assert_eq!(output, "hello"); - tx.send(()).unwrap(); - }); - - // client.set_keepalive(Some(3)).unwrap(); FIXME: reenable this - let mut content = vec![0; 12]; - client.read_exact(&mut content).unwrap(); - assert!(&content[9..].starts_with(b"100")); // 100 status code - - (write!(client, "hello")).unwrap(); - client.flush().unwrap(); - client.shutdown(Shutdown::Write).unwrap(); - - rx.recv().unwrap(); -} - -#[test] -fn unsupported_expect_header() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nExpect: 189-dummy\r\nContent-Type: text/plain; charset=utf8\r\n\r\n")).unwrap(); - - // client.set_keepalive(Some(3)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("417")); // 417 status code -} - -#[test] -fn invalid_header_name() { - let mut client = support::new_client_to_hello_world_server(); - - // note the space hidden in the Content-Length, which is invalid - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-Type: text/plain; charset=utf8\r\nContent-Length : 5\r\n\r\nhello")).unwrap(); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("400 Bad Request")); // 400 status code -} - -#[test] -fn custom_content_type_response_header() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - request - .respond( - tiny_http::Response::from_string("{\"custom\": \"Content-Type\"}").with_header( - "Content-Type: application/json" - .parse::() - .unwrap(), - ), - ) - .unwrap(); - - let mut content = String::new(); - stream.read_to_string(&mut content).unwrap(); - - assert!(content.ends_with("{\"custom\": \"Content-Type\"}")); - assert_ne!(content.find("Content-Type: application/json"), None); -} diff --git a/anneal/vendor/tiny_http/tests/network.rs b/anneal/vendor/tiny_http/tests/network.rs deleted file mode 100644 index d6c6e0540d..0000000000 --- a/anneal/vendor/tiny_http/tests/network.rs +++ /dev/null @@ -1,222 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; -use std::net::{Shutdown, TcpStream}; -use std::thread; -use std::time::Duration; - -#[allow(dead_code)] -mod support; - -#[test] -fn connection_close_header() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")).unwrap(); - thread::sleep(Duration::from_millis(1000)); - - (write!(client, "GET / HTTP/1.1\r\nConnection: close\r\n\r\n")).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn http_1_0_connection_close() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.0\r\nHost: localhost\r\n\r\n")).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn detect_connection_closed() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")).unwrap(); - thread::sleep(Duration::from_millis(1000)); - - client.shutdown(Shutdown::Write).unwrap(); - - // if the connection was not closed, this will err with timeout - // client.set_keepalive(Some(1)).unwrap(); FIXME: reenable this - let mut out = Vec::new(); - client.read_to_end(&mut out).unwrap(); -} - -#[test] -fn poor_network_test() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "G")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "ET /he")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "llo HT")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "TP/1.")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "1\r\nHo")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "st: localho")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "st\r\nConnec")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "tion: close\r")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (write!(client, "\n\r")).unwrap(); - thread::sleep(Duration::from_millis(100)); - (writeln!(client)).unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut data = String::new(); - client.read_to_string(&mut data).unwrap(); - assert!(data.ends_with("hello world")); -} - -#[test] -fn pipelining_test() { - let mut client = support::new_client_to_hello_world_server(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!(client, "GET /hello HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!( - client, - "GET /world HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut data = String::new(); - client.read_to_string(&mut data).unwrap(); - assert_eq!(data.split("hello world").count(), 4); -} - -#[test] -fn server_crash_results_in_response() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let mut client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - - thread::spawn(move || { - server.recv().unwrap(); - // oops, server crash - }); - - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with('5')); // 5xx status code -} - -#[test] -fn responses_reordered() { - let (server, mut client) = support::new_one_server_one_client(); - - (write!(client, "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")).unwrap(); - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - thread::spawn(move || { - let rq1 = server.recv().unwrap(); - let rq2 = server.recv().unwrap(); - - thread::spawn(move || { - rq2.respond(tiny_http::Response::from_string( - "second request".to_owned(), - )) - .unwrap(); - }); - - thread::sleep(Duration::from_millis(100)); - - thread::spawn(move || { - rq1.respond(tiny_http::Response::from_string("first request".to_owned())) - .unwrap(); - }); - }); - - // client.set_keepalive(Some(2)).unwrap(); FIXME: reenable this - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("second request")); -} - -#[test] -fn no_transfer_encoding_on_204() { - let (server, mut client) = support::new_one_server_one_client(); - - (write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nTE: chunked\r\nConnection: close\r\n\r\n" - )) - .unwrap(); - - thread::spawn(move || { - let rq = server.recv().unwrap(); - - let resp = tiny_http::Response::empty(tiny_http::StatusCode(204)); - rq.respond(resp).unwrap(); - }); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - - assert!(content.starts_with("HTTP/1.1 204")); - assert!(!content.contains("Transfer-Encoding: chunked")); -} - -/* FIXME: uncomment and fix -#[test] -fn connection_timeout() { - let (server, mut client) = { - let server = tiny_http::ServerBuilder::new() - .with_client_connections_timeout(3000) - .with_random_port().build().unwrap(); - let port = server.server_addr().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - (server, client) - }; - - let (tx_stop, rx_stop) = mpsc::channel(); - - // executing server in parallel - thread::spawn(move || { - loop { - server.try_recv(); - thread::sleep(Duration::from_millis(100)); - if rx_stop.try_recv().is_ok() { break } - } - }); - - // waiting for the 408 response - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(&content[9..].starts_with("408")); - - // stopping server - tx_stop.send(()); -} -*/ - -#[test] -fn chunked_threshold() { - let resp = tiny_http::Response::from_string("test".to_string()); - assert_eq!(resp.chunked_threshold(), 32768); - assert_eq!(resp.with_chunked_threshold(42).chunked_threshold(), 42); -} diff --git a/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs b/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs deleted file mode 100644 index 24a5d68002..0000000000 --- a/anneal/vendor/tiny_http/tests/non-chunked-buffering.rs +++ /dev/null @@ -1,103 +0,0 @@ -extern crate tiny_http; - -use std::io::{Cursor, Read, Write}; -use std::sync::{ - atomic::{ - AtomicUsize, - Ordering::{AcqRel, Acquire}, - }, - Arc, -}; - -#[allow(dead_code)] -mod support; - -struct MeteredReader { - inner: T, - position: Arc, -} - -impl Read for MeteredReader -where - T: Read, -{ - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - match self.inner.read(buf) { - Ok(read) => { - self.position.fetch_add(read, AcqRel); - Ok(read) - } - e => e, - } - } -} - -type Reader = MeteredReader>; - -fn big_response_reader() -> Reader { - let big_body = "ABCDEFGHIJKLMNOPQRSTUVXYZ".repeat(1024 * 1024 * 16); - MeteredReader { - inner: Cursor::new(big_body), - position: Arc::new(AtomicUsize::new(0)), - } -} - -fn identity_served(r: &mut Reader) -> tiny_http::Response<&mut Reader> { - let body_len = r.inner.get_ref().len(); - tiny_http::Response::empty(200) - .with_chunked_threshold(std::usize::MAX) - .with_data(r, Some(body_len)) -} - -/// Checks that a body-Read:er is not called when the client has disconnected -#[test] -fn responding_to_closed_client() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - - // Client already disconnected - drop(stream); - - let mut reader = big_response_reader(); - request - .respond(identity_served(&mut reader)) - .expect("Successful"); - - assert!(reader.position.load(Acquire) < 1024 * 1024); -} - -/// Checks that a slow client does not cause data to be consumed and buffered from a reader -#[test] -fn responding_to_non_consuming_client() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - - let mut reader = big_response_reader(); - let position = reader.position.clone(); - - // Client still connected, but not reading anything - std::thread::spawn(move || { - request - .respond(identity_served(&mut reader)) - .expect("Successful"); - }); - - std::thread::sleep(std::time::Duration::from_millis(100)); - - // It seems the client TCP socket can buffer quite a lot, so we need to be permissive - assert!(position.load(Acquire) < 8 * 1024 * 1024); - - drop(stream); -} diff --git a/anneal/vendor/tiny_http/tests/promptness.rs b/anneal/vendor/tiny_http/tests/promptness.rs deleted file mode 100644 index a621d3e585..0000000000 --- a/anneal/vendor/tiny_http/tests/promptness.rs +++ /dev/null @@ -1,207 +0,0 @@ -extern crate tiny_http; - -use std::io::{copy, Read, Write}; -use std::net::{Shutdown, TcpStream}; -use std::ops::Deref; -use std::sync::mpsc::channel; -use std::sync::Arc; -use std::thread::{sleep, spawn}; -use std::time::Duration; -use tiny_http::{Response, Server}; - -/// Stream that produces bytes very slowly -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -struct SlowByteSrc { - val: u8, - len: usize, -} -impl<'b> Read for SlowByteSrc { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - sleep(Duration::from_millis(100)); - let l = self.len.min(buf.len()).min(1000); - for v in buf[..l].iter_mut() { - *v = self.val; - } - self.len -= l; - Ok(l) - } -} - -/// crude impl of http `Transfer-Encoding: chunked` -fn encode_chunked(data: &mut dyn Read, output: &mut dyn Write) { - let mut buf = [0u8; 4096]; - loop { - let l = data.read(&mut buf).unwrap(); - write!(output, "{:X}\r\n", l).unwrap(); - output.write_all(&buf[..l]).unwrap(); - write!(output, "\r\n").unwrap(); - if l == 0 { - break; - } - } -} - -mod prompt_pipelining { - use super::*; - - /// Check that pipelined requests on the same connection are received promptly. - fn assert_requests_parsed_promptly( - req_cnt: usize, - req_body: &'static [u8], - timeout: Duration, - req_writer: impl FnOnce(&mut dyn Write) + Send + 'static, - ) { - let resp_body = SlowByteSrc { - val: 42, - len: 1000_000, - }; // very slow response body - - let server = Server::http("0.0.0.0:0").unwrap(); - let mut client = TcpStream::connect(server.server_addr().to_ip().unwrap()).unwrap(); - let (svr_send, svr_rcv) = channel(); - - spawn(move || { - for _ in 0..req_cnt { - let mut req = server.recv().unwrap(); - // read the whole body of the request - let mut body = Vec::new(); - req.as_reader().read_to_end(&mut body).unwrap(); - assert_eq!(req_body, body.as_slice()); - // The next pipelined request should now be available for parsing, - // while we send the (possibly slow) response in another thread - spawn(move || { - req.respond(Response::empty(200).with_data(resp_body, Some(resp_body.len))) - }); - } - svr_send.send(()).unwrap(); - }); - - spawn(move || req_writer(&mut client)); - - // requests must be sent and received quickly (before timeout expires) - svr_rcv - .recv_timeout(timeout) - .expect("Server did not finish reading pipelined requests quickly enough"); - } - - #[test] - fn empty() { - assert_requests_parsed_promptly(5, &[], Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n\r\n").unwrap(); - } - }); - } - - #[test] - fn content_length_short() { - let body = &[65u8; 100]; // short but not trivial - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", body.len()).unwrap(); - wr.write_all(body).unwrap(); - } - }); - } - - #[test] - fn content_length_long() { - let body = &[65u8; 10000]; // long enough that it won't be buffered - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", body.len()).unwrap(); - wr.write_all(body).unwrap(); - } - }); - } - - #[test] - fn chunked() { - let body = &[65u8; 10000]; - assert_requests_parsed_promptly(5, body, Duration::from_millis(200), move |wr| { - for _ in 0..5 { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Connection: keep-alive\r\n").unwrap(); - write!(wr, "Transfer-Encoding: chunked\r\n\r\n").unwrap(); - encode_chunked(&mut &body[..], wr); - } - }); - } -} - -mod prompt_responses { - use super::*; - - /// Check that response is sent promptly without waiting for full request body. - fn assert_responds_promptly( - timeout: Duration, - req_writer: impl FnOnce(&mut dyn Write) + Send + 'static, - ) { - let server = Server::http("0.0.0.0:0").unwrap(); - let client = TcpStream::connect(server.server_addr().to_ip().unwrap()).unwrap(); - - spawn(move || loop { - // server attempts to respond immediately - let req = server.recv().unwrap(); - req.respond(Response::empty(400)).unwrap(); - }); - - let client = Arc::new(client); - let client_write = Arc::clone(&client); - // request written (possibly very slowly) in another thread - spawn(move || req_writer(&mut client_write.deref())); - - // response should arrive quickly (before timeout expires) - client.set_read_timeout(Some(timeout)).unwrap(); - let resp = client.deref().read(&mut [0u8; 4096]); - client.shutdown(Shutdown::Both).unwrap(); - assert!(resp.is_ok(), "Server response was not sent promptly"); - } - - static SLOW_BODY: SlowByteSrc = SlowByteSrc { - val: 65, - len: 1000_000, - }; - - #[test] - fn content_length_http11() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn content_length_http10() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.0\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn expect_continue() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Expect: 100 continue\r\n").unwrap(); - write!(wr, "Content-Length: {}\r\n\r\n", SLOW_BODY.len).unwrap(); - copy(&mut SLOW_BODY.clone(), wr).unwrap(); - }); - } - - #[test] - fn chunked() { - assert_responds_promptly(Duration::from_millis(200), move |wr| { - write!(wr, "GET / HTTP/1.1\r\n").unwrap(); - write!(wr, "Transfer-Encoding: chunked\r\n\r\n").unwrap(); - encode_chunked(&mut SLOW_BODY.clone(), wr); - }); - } -} diff --git a/anneal/vendor/tiny_http/tests/simple-test.rs b/anneal/vendor/tiny_http/tests/simple-test.rs deleted file mode 100644 index 4375109d92..0000000000 --- a/anneal/vendor/tiny_http/tests/simple-test.rs +++ /dev/null @@ -1,29 +0,0 @@ -extern crate tiny_http; - -use std::io::{Read, Write}; - -#[allow(dead_code)] -mod support; - -#[test] -fn basic_handling() { - let (server, mut stream) = support::new_one_server_one_client(); - write!( - stream, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - assert!(*request.method() == tiny_http::Method::Get); - //assert!(request.url() == "/"); - request - .respond(tiny_http::Response::from_string("hello world".to_owned())) - .unwrap(); - - server.try_recv().unwrap(); - - let mut content = String::new(); - stream.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("hello world")); -} diff --git a/anneal/vendor/tiny_http/tests/support/mod.rs b/anneal/vendor/tiny_http/tests/support/mod.rs deleted file mode 100644 index 7a4dc587be..0000000000 --- a/anneal/vendor/tiny_http/tests/support/mod.rs +++ /dev/null @@ -1,40 +0,0 @@ -use std::net::TcpStream; -use std::thread; -use std::time::Duration; - -/// Creates a server and a client connected to the server. -pub fn new_one_server_one_client() -> (tiny_http::Server, TcpStream) { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - (server, client) -} - -/// Creates a "hello world" server with a client connected to the server. -/// -/// The server will automatically close after 3 seconds. -pub fn new_client_to_hello_world_server() -> TcpStream { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let port = server.server_addr().to_ip().unwrap().port(); - let client = TcpStream::connect(("127.0.0.1", port)).unwrap(); - - thread::spawn(move || { - let mut cycles = 3 * 1000 / 20; - - loop { - if let Some(rq) = server.try_recv().unwrap() { - let response = tiny_http::Response::from_string("hello world".to_string()); - rq.respond(response).unwrap(); - } - - thread::sleep(Duration::from_millis(20)); - - cycles -= 1; - if cycles == 0 { - break; - } - } - }); - - client -} diff --git a/anneal/vendor/tiny_http/tests/unblock-test.rs b/anneal/vendor/tiny_http/tests/unblock-test.rs deleted file mode 100644 index 001568a480..0000000000 --- a/anneal/vendor/tiny_http/tests/unblock-test.rs +++ /dev/null @@ -1,34 +0,0 @@ -extern crate tiny_http; - -use std::sync::Arc; -use std::thread; - -#[test] -fn unblock_server() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let s = Arc::new(server); - - let s1 = s.clone(); - thread::spawn(move || s1.unblock()); - - // Without unblock this would hang forever - for _rq in s.incoming_requests() {} -} - -#[test] -fn unblock_threads() { - let server = tiny_http::Server::http("0.0.0.0:0").unwrap(); - let s = Arc::new(server); - - let s1 = s.clone(); - let s2 = s.clone(); - let h1 = thread::spawn(move || for _rq in s1.incoming_requests() {}); - let h2 = thread::spawn(move || for _rq in s2.incoming_requests() {}); - - // Graceful shutdown; removing even one of the - // unblock calls prevents termination - s.unblock(); - s.unblock(); - h1.join().unwrap(); - h2.join().unwrap(); -} diff --git a/anneal/vendor/tiny_http/tests/unix-test.rs b/anneal/vendor/tiny_http/tests/unix-test.rs deleted file mode 100644 index 42d9476d05..0000000000 --- a/anneal/vendor/tiny_http/tests/unix-test.rs +++ /dev/null @@ -1,44 +0,0 @@ -#![cfg(unix)] - -extern crate tiny_http; - -use std::{ - io::{Read, Write}, - os::unix::net::UnixStream, - path::{Path, PathBuf}, -}; - -#[allow(dead_code)] -mod support; - -#[test] -fn unix_basic_handling() { - let server = tiny_http::Server::http_unix(Path::new("/tmp/tiny-http-test.sock")).unwrap(); - let path: PathBuf = server - .server_addr() - .to_unix() - .unwrap() - .as_pathname() - .unwrap() - .into(); - let mut client = UnixStream::connect(path).unwrap(); - - write!( - client, - "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n" - ) - .unwrap(); - - let request = server.recv().unwrap(); - assert!(*request.method() == tiny_http::Method::Get); - //assert!(request.url() == "/"); - request - .respond(tiny_http::Response::from_string("hello world".to_owned())) - .unwrap(); - - server.try_recv().unwrap(); - - let mut content = String::new(); - client.read_to_string(&mut content).unwrap(); - assert!(content.ends_with("hello world")); -} diff --git a/anneal/vendor/unicode-ident/.cargo-checksum.json b/anneal/vendor/unicode-ident/.cargo-checksum.json index c53c065861..973fb2b696 100644 --- a/anneal/vendor/unicode-ident/.cargo-checksum.json +++ b/anneal/vendor/unicode-ident/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"9900659dcf16d47a600102bbfd47cf554a0d4db40790983e570f9ecac9822c68",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"7cd19596c9178c43f442aeeaf808592bb0c3a118ce291aa2037bd22116045e61","Cargo.lock":"dac9e67ad7272c61e7b197143b696705ce4800ea0e010b3b1f0c8924a0c9701d","Cargo.toml":"0bb9c0e006a21355cb85c7df72e78dd8ba6fffbb7dc3f1e7a4c19af53cd354da","Cargo.toml.orig":"8d0abaf7ce10cb78f26edcd613dfe5a47faa4381e6e251c7d1c123608d2e037a","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"2fd3a0c6c9abd2c042fb319221f9ef2c95728a6e3725b0f067e4d315c5dbfe5a","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"078912e7c64ba3ea1081b88c2610deba31eeb057c28f9d78e929db4856b7774f","src/tables.rs":"369c476ba91a39fce55563b692a3f598daf7f026cfe0a3796cfed1102fb3b190","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"80c3ca7eeec2660f3f4f2efa8fecd6209b32ec8b547192cbfa37c0e67a5f14a0","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"9900659dcf16d47a600102bbfd47cf554a0d4db40790983e570f9ecac9822c68",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"7cd19596c9178c43f442aeeaf808592bb0c3a118ce291aa2037bd22116045e61","Cargo.lock":"dac9e67ad7272c61e7b197143b696705ce4800ea0e010b3b1f0c8924a0c9701d","Cargo.toml":"0bb9c0e006a21355cb85c7df72e78dd8ba6fffbb7dc3f1e7a4c19af53cd354da","Cargo.toml.orig":"8d0abaf7ce10cb78f26edcd613dfe5a47faa4381e6e251c7d1c123608d2e037a","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"2fd3a0c6c9abd2c042fb319221f9ef2c95728a6e3725b0f067e4d315c5dbfe5a","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"078912e7c64ba3ea1081b88c2610deba31eeb057c28f9d78e929db4856b7774f","src/tables.rs":"369c476ba91a39fce55563b692a3f598daf7f026cfe0a3796cfed1102fb3b190","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/.gitignore":"2cd419079c0a08bb15766520880998651dd1c72c55347a31f43357595b16ac10","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"80c3ca7eeec2660f3f4f2efa8fecd6209b32ec8b547192cbfa37c0e67a5f14a0","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"} \ No newline at end of file diff --git a/anneal/vendor/unicode-ident/tests/fst/.gitignore b/anneal/vendor/unicode-ident/tests/fst/.gitignore new file mode 100644 index 0000000000..0ebd2add95 --- /dev/null +++ b/anneal/vendor/unicode-ident/tests/fst/.gitignore @@ -0,0 +1 @@ +/prop_list.rs diff --git a/anneal/vendor/wasmparser/.cargo-checksum.json b/anneal/vendor/wasmparser/.cargo-checksum.json index e637aeaefa..ef9bd32832 100644 --- a/anneal/vendor/wasmparser/.cargo-checksum.json +++ b/anneal/vendor/wasmparser/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"57f74377f548fbafc63ed431ef9c63fc201cbdb7c8c96b2493d98766d3b12420","Cargo.lock":"5e68724753901d9d61ab1e95bd782fd5cd1d951cf052ee43330bfe43d45f6a8c","Cargo.toml":"44fa0c6cd610439798dadcd0b35cf3ddc05df8f300e3df62713317d4e111c659","Cargo.toml.orig":"6053243b73f71715f393a13873b5b847b43cbd85a705329d17ccc9093bf99ba0","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/benchmark.rs":"c69fd76e74644188f25d03beac288f094b22735db58daf00019f812f9400f604","examples/simple.rs":"dc847c55627d346cee20f1415fde9be36a8e93d0ba0929d3fd8eef9d69e3541f","src/arity.rs":"6f34da680d7d79b1606aceb460bb4b06565904821e992c69aad5bcab271321d1","src/binary_reader.rs":"790835b9439150bdf9047e7040379724d66139ca15d8f5d155f9291c74849364","src/collections/hash.rs":"4146765fe03ff2e3456ad713283713c8614d9605a0f9c22c710b95508de7da89","src/collections/index_map.rs":"70823e5d27ca3abd193e0f18a163e3cbcef6f969b212b870b439b341278f1c32","src/collections/index_map/detail.rs":"2e9c56ff3ebf0473704b8bf304d8cca4dd39fa6c5973e06b5493a45332bb656a","src/collections/index_map/tests.rs":"7761fda67a871bcef24579f0cbe4762e40fb8e7ca5147c67187da510c545c016","src/collections/index_set.rs":"f53bcbfbbeccd9bf62406f08565f5ac57af58cf962484a91d4efcd7431d37310","src/collections/map.rs":"f239038e622dd95eb5ee5dbbfb67cd0e4cafe18c750cc0c46b1013809e0ec643","src/collections/mod.rs":"b80b8f49039ef403b9515c994aa2512db5dc905f083c876a41d8ca705d7add6e","src/collections/set.rs":"b9680f5c2f0cb7c52a935ce80f1ec3f5c6239913c1b621556f289a708e0f373b","src/features.rs":"c0adc66a0ab32d0fe20f6831ac6f40639c5d3333496f1e13da32b0406e1eb9a2","src/lib.rs":"1a3d8c79f116527f3c4dcb4e256758acfe3096e87d96f4ec27bbcbd10b587ddf","src/limits.rs":"ac608007fb4e7c45c99159230230e0ab35739055980259920e3e4ad71b87ed61","src/parser.rs":"8abb0c08909f78418eb8a1a48b96185cdab67817afc5793dd1da7f87e57404ff","src/readers.rs":"bf43b91c1ad97d9d67eaa8fc63381428dc300c97b21ce1ede89ab6b628625da7","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"97398d9fdcb7b4227b8bb68a6677ebf09c62f6a43b9aa7591b37a2413848e759","src/readers/component/canonicals.rs":"4cffaf5ba1c4d74900ccefd82db50580057dc8d0651614c66177f69441e70a30","src/readers/component/exports.rs":"de6482715680b63fc0969225b6c634c5f5c2fa5b763511628a313af4748df347","src/readers/component/imports.rs":"8d2947817bd1a91956d33a8e723f5af325f73cc6eb2903264a6dd594b3deeb46","src/readers/component/instances.rs":"8ab1254ce1e66528d37a61bcde4cabb2c7c87ccc2740be03d539c064ed544d29","src/readers/component/names.rs":"1bfdffe04b15760ab573359c864ead0c45a0afe42811d16af535d9e19125daa6","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"a9729948af3f9f9e526498a5127788e816ecd179ea2a60f1dc9fcde7ef6175b6","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"29210720e08e3a558fd96ac857038c9b87732a265ff1bfbd7f0bf3312ea3e949","src/readers/core/code.rs":"96b4f12b666576100bfa9807e087792ec96b4d315317475180c086f18fe86b4d","src/readers/core/coredumps.rs":"75c1c5ad6a85cb90bc39eb4b22b22a512f5ee98b363565f7262c1c176a10bbef","src/readers/core/custom.rs":"f3c965fcd044576a2c0f3ee87c78e4f9f345ce87899a76d609e5a8709f5d7d9e","src/readers/core/data.rs":"da78898a19accca90f05ee762cf3388c0f8a40a3d60cb78acaa3f0eb71a0cb3c","src/readers/core/dylink0.rs":"c92d75e417eb444673408c00311da3f59427b6f966009f4830be8b518a8bda21","src/readers/core/elements.rs":"16342061fef1f04b68b99db7767e11608fec2922f07831df60922d6a9500e2dc","src/readers/core/exports.rs":"dd13793edf9edcbb857288c5adb273a8231ead5dbad2e39d0f9abd23ed189151","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"19ea22f5c4ae3c1d6d4c62dbd163c503f05117210fa4b029094a1927e2c30b7a","src/readers/core/imports.rs":"b8c9ad9a48211c4d1a076861a1f8b68905981100379f198e5152e79a294678eb","src/readers/core/init.rs":"53831f0d4b9e6c4de65816363787b863ce49850b32a821bd4b3891889b2e3ba6","src/readers/core/linking.rs":"02b1eb463b516fff4fa9f1ba06c623dd8e6b2ea3e632669415074d9ee4ac9968","src/readers/core/memories.rs":"a36d626d167569ee28feddbbfacd5d4211834bb2c8c3c522251a28ca15d229c0","src/readers/core/names.rs":"722dc47fcd523fb75987ae501fb893002978b207e31b3bc054901e66737540f6","src/readers/core/operators.rs":"8536dc584ce3769e6ac3aaa6ac636d65acb4aa681180f53564774657843a5b4a","src/readers/core/producers.rs":"25bbdd1385d26ba4dbc0814c516834f2ab7c0aad697a576b714d3dbe8dc2d7cc","src/readers/core/reloc.rs":"244f29411a0e4cceb09e0a9b9ec05a64bcc2d2c0f783f23227f33f91d2fbee3f","src/readers/core/tables.rs":"a0b3676cdd7c8a5f56ba7fcc0e5c0b3079755dc932e00caf5c37af176288d602","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"6083a67298dcd9ab48e76b06a92f694fdb46c91b99433c853e8be6935c3867f6","src/readers/core/types/matches.rs":"0df58b38f94f3281b91d1edbb568b9b1d3484ea717fcbc8e353459447ded2d13","src/resources.rs":"eaf203d9b99e167ead8fc8ed8861851bdc1288bc5fe6c435f1ee7cf69e8f9fa5","src/validator.rs":"8d52d96f8e5dd1020db4e33321703dcac3be7d295d37ad61166dba605863e263","src/validator/component.rs":"4d67ec6921af00f0946287719a6c509ee1f001ca607d93693968d449955c2b98","src/validator/component_types.rs":"acb39090c9f706c8bf79e521b7e6926b02880d097b0ad2c1f68c0281fc935e6f","src/validator/core.rs":"748c9f8a432cb3118229825e59d58d3d4faa7d13679fc79ad7205705c1d0d13e","src/validator/core/canonical.rs":"4316d75a9d730fd631815046a34ab4b97f1bba5161cdca130bb5fb3f865c64a5","src/validator/func.rs":"eb8109fc85295d35d7b30d343404c995c6314600086e533f5b85e6a9c1ad7de4","src/validator/names.rs":"8f75bef3ac6d1a3d025c8a74743b63820e67ae0f6779ca3e5254d1e0f6e9394a","src/validator/operators.rs":"88fec45af8c85404c6f9ff946379e3f90804ff86633a9adc81ac56d4cdb113f1","src/validator/operators/simd.rs":"a338d3f82be1246a14cb96e5d99a99de0c728256703be36e4caf8142042693a2","src/validator/types.rs":"802c04e769e01dd028803a22d0c07e0bca91781036f8cb38c36701841db7f62d","tests/big-module.rs":"114d250505a2a3daf2e778bd4b2c14b7fc6b6be842055fa6b9389167fa430dca"},"package":"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"57f74377f548fbafc63ed431ef9c63fc201cbdb7c8c96b2493d98766d3b12420","Cargo.lock":"5e68724753901d9d61ab1e95bd782fd5cd1d951cf052ee43330bfe43d45f6a8c","Cargo.toml":"44fa0c6cd610439798dadcd0b35cf3ddc05df8f300e3df62713317d4e111c659","Cargo.toml.orig":"6053243b73f71715f393a13873b5b847b43cbd85a705329d17ccc9093bf99ba0","README.md":"aabf3b5930893b2a89d0114d8cd97e9b980f3c6f758b960484e06b69a504b823","benches/.gitignore":"9207f6d87ac45bb48ebb4d879467485c692985481d0674d56121e2150a1e4671","benches/benchmark.rs":"c69fd76e74644188f25d03beac288f094b22735db58daf00019f812f9400f604","examples/simple.rs":"dc847c55627d346cee20f1415fde9be36a8e93d0ba0929d3fd8eef9d69e3541f","src/arity.rs":"6f34da680d7d79b1606aceb460bb4b06565904821e992c69aad5bcab271321d1","src/binary_reader.rs":"790835b9439150bdf9047e7040379724d66139ca15d8f5d155f9291c74849364","src/collections/hash.rs":"4146765fe03ff2e3456ad713283713c8614d9605a0f9c22c710b95508de7da89","src/collections/index_map.rs":"70823e5d27ca3abd193e0f18a163e3cbcef6f969b212b870b439b341278f1c32","src/collections/index_map/detail.rs":"2e9c56ff3ebf0473704b8bf304d8cca4dd39fa6c5973e06b5493a45332bb656a","src/collections/index_map/tests.rs":"7761fda67a871bcef24579f0cbe4762e40fb8e7ca5147c67187da510c545c016","src/collections/index_set.rs":"f53bcbfbbeccd9bf62406f08565f5ac57af58cf962484a91d4efcd7431d37310","src/collections/map.rs":"f239038e622dd95eb5ee5dbbfb67cd0e4cafe18c750cc0c46b1013809e0ec643","src/collections/mod.rs":"b80b8f49039ef403b9515c994aa2512db5dc905f083c876a41d8ca705d7add6e","src/collections/set.rs":"b9680f5c2f0cb7c52a935ce80f1ec3f5c6239913c1b621556f289a708e0f373b","src/features.rs":"c0adc66a0ab32d0fe20f6831ac6f40639c5d3333496f1e13da32b0406e1eb9a2","src/lib.rs":"1a3d8c79f116527f3c4dcb4e256758acfe3096e87d96f4ec27bbcbd10b587ddf","src/limits.rs":"ac608007fb4e7c45c99159230230e0ab35739055980259920e3e4ad71b87ed61","src/parser.rs":"8abb0c08909f78418eb8a1a48b96185cdab67817afc5793dd1da7f87e57404ff","src/readers.rs":"bf43b91c1ad97d9d67eaa8fc63381428dc300c97b21ce1ede89ab6b628625da7","src/readers/component.rs":"c259628ca3f09ff904f7e920aeec261b657f7a197c99b520a6a7d3e918b9fb3b","src/readers/component/aliases.rs":"97398d9fdcb7b4227b8bb68a6677ebf09c62f6a43b9aa7591b37a2413848e759","src/readers/component/canonicals.rs":"4cffaf5ba1c4d74900ccefd82db50580057dc8d0651614c66177f69441e70a30","src/readers/component/exports.rs":"de6482715680b63fc0969225b6c634c5f5c2fa5b763511628a313af4748df347","src/readers/component/imports.rs":"8d2947817bd1a91956d33a8e723f5af325f73cc6eb2903264a6dd594b3deeb46","src/readers/component/instances.rs":"8ab1254ce1e66528d37a61bcde4cabb2c7c87ccc2740be03d539c064ed544d29","src/readers/component/names.rs":"1bfdffe04b15760ab573359c864ead0c45a0afe42811d16af535d9e19125daa6","src/readers/component/start.rs":"9c37d1eea486ee951547a328693bcf9f2a27f48e2207478daf23c1cd9e9f95f3","src/readers/component/types.rs":"a9729948af3f9f9e526498a5127788e816ecd179ea2a60f1dc9fcde7ef6175b6","src/readers/core.rs":"f77e1eb46e1d05abeabb9be2bd7bdd66acadfc4c651912f2a67b7e5f7d29d041","src/readers/core/branch_hinting.rs":"29210720e08e3a558fd96ac857038c9b87732a265ff1bfbd7f0bf3312ea3e949","src/readers/core/code.rs":"96b4f12b666576100bfa9807e087792ec96b4d315317475180c086f18fe86b4d","src/readers/core/coredumps.rs":"75c1c5ad6a85cb90bc39eb4b22b22a512f5ee98b363565f7262c1c176a10bbef","src/readers/core/custom.rs":"f3c965fcd044576a2c0f3ee87c78e4f9f345ce87899a76d609e5a8709f5d7d9e","src/readers/core/data.rs":"da78898a19accca90f05ee762cf3388c0f8a40a3d60cb78acaa3f0eb71a0cb3c","src/readers/core/dylink0.rs":"c92d75e417eb444673408c00311da3f59427b6f966009f4830be8b518a8bda21","src/readers/core/elements.rs":"16342061fef1f04b68b99db7767e11608fec2922f07831df60922d6a9500e2dc","src/readers/core/exports.rs":"dd13793edf9edcbb857288c5adb273a8231ead5dbad2e39d0f9abd23ed189151","src/readers/core/functions.rs":"b5bbc7f7b7a429187376f63c695a9f1cbf92e515dba840ac876fa60f7290da34","src/readers/core/globals.rs":"19ea22f5c4ae3c1d6d4c62dbd163c503f05117210fa4b029094a1927e2c30b7a","src/readers/core/imports.rs":"b8c9ad9a48211c4d1a076861a1f8b68905981100379f198e5152e79a294678eb","src/readers/core/init.rs":"53831f0d4b9e6c4de65816363787b863ce49850b32a821bd4b3891889b2e3ba6","src/readers/core/linking.rs":"02b1eb463b516fff4fa9f1ba06c623dd8e6b2ea3e632669415074d9ee4ac9968","src/readers/core/memories.rs":"a36d626d167569ee28feddbbfacd5d4211834bb2c8c3c522251a28ca15d229c0","src/readers/core/names.rs":"722dc47fcd523fb75987ae501fb893002978b207e31b3bc054901e66737540f6","src/readers/core/operators.rs":"8536dc584ce3769e6ac3aaa6ac636d65acb4aa681180f53564774657843a5b4a","src/readers/core/producers.rs":"25bbdd1385d26ba4dbc0814c516834f2ab7c0aad697a576b714d3dbe8dc2d7cc","src/readers/core/reloc.rs":"244f29411a0e4cceb09e0a9b9ec05a64bcc2d2c0f783f23227f33f91d2fbee3f","src/readers/core/tables.rs":"a0b3676cdd7c8a5f56ba7fcc0e5c0b3079755dc932e00caf5c37af176288d602","src/readers/core/tags.rs":"c1dcfeb973195da9708549bcc2df4dd8ff282fe802c15a603bebc8a856f70949","src/readers/core/types.rs":"6083a67298dcd9ab48e76b06a92f694fdb46c91b99433c853e8be6935c3867f6","src/readers/core/types/matches.rs":"0df58b38f94f3281b91d1edbb568b9b1d3484ea717fcbc8e353459447ded2d13","src/resources.rs":"eaf203d9b99e167ead8fc8ed8861851bdc1288bc5fe6c435f1ee7cf69e8f9fa5","src/validator.rs":"8d52d96f8e5dd1020db4e33321703dcac3be7d295d37ad61166dba605863e263","src/validator/component.rs":"4d67ec6921af00f0946287719a6c509ee1f001ca607d93693968d449955c2b98","src/validator/component_types.rs":"acb39090c9f706c8bf79e521b7e6926b02880d097b0ad2c1f68c0281fc935e6f","src/validator/core.rs":"748c9f8a432cb3118229825e59d58d3d4faa7d13679fc79ad7205705c1d0d13e","src/validator/core/canonical.rs":"4316d75a9d730fd631815046a34ab4b97f1bba5161cdca130bb5fb3f865c64a5","src/validator/func.rs":"eb8109fc85295d35d7b30d343404c995c6314600086e533f5b85e6a9c1ad7de4","src/validator/names.rs":"8f75bef3ac6d1a3d025c8a74743b63820e67ae0f6779ca3e5254d1e0f6e9394a","src/validator/operators.rs":"88fec45af8c85404c6f9ff946379e3f90804ff86633a9adc81ac56d4cdb113f1","src/validator/operators/simd.rs":"a338d3f82be1246a14cb96e5d99a99de0c728256703be36e4caf8142042693a2","src/validator/types.rs":"802c04e769e01dd028803a22d0c07e0bca91781036f8cb38c36701841db7f62d","tests/big-module.rs":"114d250505a2a3daf2e778bd4b2c14b7fc6b6be842055fa6b9389167fa430dca"},"package":"47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"} \ No newline at end of file diff --git a/anneal/vendor/wasmparser/benches/.gitignore b/anneal/vendor/wasmparser/benches/.gitignore new file mode 100644 index 0000000000..45d4a47279 --- /dev/null +++ b/anneal/vendor/wasmparser/benches/.gitignore @@ -0,0 +1 @@ +!*.wasm diff --git a/anneal/vendor/wit-component/.cargo-checksum.json b/anneal/vendor/wit-component/.cargo-checksum.json index 9ed7ebda17..49f8090847 100644 --- a/anneal/vendor/wit-component/.cargo-checksum.json +++ b/anneal/vendor/wit-component/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"8456162b205395e1ccae297c7bff238bc11090019a7807fee70463494697bffa","Cargo.lock":"5fff8966384cc2e3f5f19866742d4b8fd536e64f4cf37963b965f000f3579440","Cargo.toml":"8142ea1fdeebc373aa1ef74dbf068351b2995b10ae9629a758dc6ece35f2fffd","Cargo.toml.orig":"eda00a1d5a187c31873aee6413503278a16d865a2d25c3872fdd7a4281b1c3ad","README.md":"00d3b7547efc420a28ce22afd6d9f29f996e2a972ee0f753f988ee26e54ac8ea","libdl.so":"6d6ea03a4a671db91be183077b6665866106a61c84739580773a7e5b6bd9f256","src/dummy.rs":"8ff563ef71fd4b090ef65b11d4311386e2d16c08769569ab2809d5c207d42f19","src/encoding.rs":"44026b8332e9fd8db97ccc4e685d8bb224fcbc63cb98e08ddc3928be4dffb901","src/encoding/dedupe.rs":"157abfde68d0c0e610acf399b0bb5efe7dce66197b513922cac85ea28004e9e5","src/encoding/types.rs":"b7f25629759c3786351fda2867409da8043be0ed4bfa8ff17d89ed285c8d2670","src/encoding/wit.rs":"dd8abb983f7a3e2499db41d6aa21733758e2cdae3805af5c058063adedcb4c2e","src/encoding/world.rs":"a8d2bf823a5fadf248cfe13e19ac56ad7a63974334518a1f2634251aa44ae2f9","src/gc.rs":"e731ef0b88c56c9cf99b83ee1a9fe6f085b8744c394f2bfc6503106390e6edb0","src/lib.rs":"25a5d6af36e1f9f6fa405e0c67a3736420b310e73f9eb7c03ed520a81515a2f7","src/linking.rs":"bfe049c0138b647a80cd4dbf1d8a926053e6c4f59a3bda702d82670a4cb62e7e","src/linking/metadata.rs":"33899abdc312ff16ea28f016406c2aae75fc24ccd5ef7b2e4bb62aec3af08102","src/metadata.rs":"ddfa0af7c35a410cd5c64ba81feef28dbcf078aad736508ed69c71d47394617c","src/printing.rs":"92311a35a001157f12212e41f21d3d559b7e8219bf38be4bf595f36777855c7f","src/semver_check.rs":"0f1b26ac481daab44aded3150ecc1d50f38d648ebf9c3221da89072f23a995f6","src/targets.rs":"74531ecd7e1b1afa30ed24bb6340b430f1b2e1679ed80bf61894b018b4eb5f8c","src/validation.rs":"870632e0223dd980669d1d75560962502163745f54d53d086df5b0796e2da2ec","tests/components.rs":"78ba10ec0049026d5aebd72b7f651c258626c5fe25cbde4c0015f16834ce1971","tests/components/adapt-empty-interface/adapt-old.wat":"3a6db296d593ac422b4132714267a678490528f5299e3b263291fdcbd7d35b1c","tests/components/adapt-empty-interface/adapt-old.wit":"c04b693fd79794d910e739efa5d8356cec96e0b68df00b3fc21945f68a57cc4f","tests/components/adapt-empty-interface/component.wat":"fca49ffd58ca913a5d740e2cca9b91028f994682ae89c4e3267c0e624c616316","tests/components/adapt-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-empty-interface/module.wat":"e2f2a12e798371295a81cb05092d9164b37545d89962891759e0bd4728c3866e","tests/components/adapt-empty-interface/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-default/adapt-old.wat":"fe2824af7a5061c880d378a418796db230831b7cf50704a42e15c6dd2c9e6258","tests/components/adapt-export-default/adapt-old.wit":"71084c4ee7c4940876553129fe1b519e8eadacfdd3cdbf1cc640d5f3c5aa8831","tests/components/adapt-export-default/component.wat":"976fe1e9be2de60268d70c31ea15f59fdf9824ed411cb14acf1aeebd09d3390a","tests/components/adapt-export-default/component.wit.print":"7898d8d83177c3b78be309e32203a439946ec2765ec849ba9593c7703efd54dd","tests/components/adapt-export-default/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-default/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-namespaced/adapt-old.wat":"a5ba577bd703bd03fa961655122b46d2ef4ceb06cf851a3ba05e235b477b3cdd","tests/components/adapt-export-namespaced/adapt-old.wit":"3efacadc9fc5ea5997f0a2b468588100a1af780a6f43f09027b1999b5f04bcc9","tests/components/adapt-export-namespaced/component.wat":"865312e1ef947db62bb1856c19650cb5dc7d36de55e9e0d79263cc68d9bc011d","tests/components/adapt-export-namespaced/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-namespaced/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-namespaced/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-reallocs/adapt-old.wat":"9db1b4fbaf190e7e7fdea1caf291ae0e833a687f37b396096c6f4b7735491109","tests/components/adapt-export-reallocs/adapt-old.wit":"9cc7430d32be94c362abe794a4b356c470d23ecb6971de030f9b411c612352c7","tests/components/adapt-export-reallocs/component.wat":"caaf9904ead980403b632431a38bb6e64a461a531d03162961f490890c8430c3","tests/components/adapt-export-reallocs/component.wit.print":"82b6fe5b0953b68beee20d7f31e53712ec76f9f5d7196a2dbc57ac59a68c4096","tests/components/adapt-export-reallocs/module.wat":"53c738018c3b15fc3c7f21f1b8b5443c7afe89c25b08e7c56fc45a81a90627a7","tests/components/adapt-export-reallocs/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-save-args/adapt-old.wat":"60a41275befb6be47a8618fed9f3e1cab5b0807864d83e25bd84abe17d7579dd","tests/components/adapt-export-save-args/adapt-old.wit":"ceab954d883cf0c7d8c4cb28ce0bc641b969f8d0fda0bc411bc6fed8e553d220","tests/components/adapt-export-save-args/component.wat":"67f09c119ef670e3d478081704470b057d10a5f7b82016df4870dcf5211b1099","tests/components/adapt-export-save-args/component.wit.print":"6f24d727c36366175e949619aa8655755c6fdea10dda4770a30d0b366c877326","tests/components/adapt-export-save-args/module.wat":"6c7d1c7ded2d891fbbc9b778523905240c63bdc281aa4736c13bc01213d31a8b","tests/components/adapt-export-save-args/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-with-post-return/adapt-old.wat":"86ef0da2b6687532011de1aaac54add6150a43309b3d61a4e31fe37a5df6765c","tests/components/adapt-export-with-post-return/adapt-old.wit":"db342b3d869e263bae40fee459ca55736449430b255e9ef5bf6062a1ae3b0275","tests/components/adapt-export-with-post-return/component.wat":"f5ee8419b25645958d64c78613590418c8704f7663a4858dee0bceee28bca9b1","tests/components/adapt-export-with-post-return/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-with-post-return/module.wat":"a4e32bd0b2fbf43172da21f77d747ca1d8bef7779e9f9827429bdc114e62d63f","tests/components/adapt-export-with-post-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wat":"74d4a3a10e95b0b9a40a5269d3c28cbbc1ea1ef0ba9414497d2b1fed8648e510","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wit":"9202e95a58f5d359c9c4f60dcbc5973fabc19915dcadf1d26e2324dda312f5e5","tests/components/adapt-import-only-used-in-adapter/component.wat":"74313f64cba93d7fe6afcea089730eefc24565976bb9bc9b9d71462ead3377c7","tests/components/adapt-import-only-used-in-adapter/component.wit.print":"9dbf66812387cd9f17ea903de18c0bf6ef6308bac6bd9db747f6cdd962b27497","tests/components/adapt-import-only-used-in-adapter/module.wat":"1920c02ae4d6c6c12ca57665e88ac039bf845e05f9b8628379cada9efff074ed","tests/components/adapt-import-only-used-in-adapter/module.wit":"ec9a35c247c4354e6960e3e8801c9aab4b9b5dd57a77fab348991b016b0f6017","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-adapt-realloc/component.wat":"a6ee87c556eac0f3d2c01ee2eb1f621e01e61abafe6b3f073507144ee3c4fa5a","tests/components/adapt-inject-stack-with-adapt-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-adapt-realloc/module.wat":"623ad5e85f4ad4ea9c3480df598dbf1e8d50d7d8bfee01aa9b425550434b0160","tests/components/adapt-inject-stack-with-adapt-realloc/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wat":"2102c5772be78a8a907be569aa0d185f0a1ad767e4d601a27a1b870151f892ba","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc-no-state/component.wat":"93c7d16960727e35915b81091c79c8f2906bc36a63cd21d64ee42e2a4caa0254","tests/components/adapt-inject-stack-with-realloc-no-state/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc-no-state/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc-no-state/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc/component.wat":"5e67becee53a51ae1613af0389c1952b12481b5527fffaed1d6f9ed7b72297bd","tests/components/adapt-inject-stack-with-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wat":"f45808f40cf534bc765895f472b8f6b9880c8cfa450dfa30d3b9c20cede292e1","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wat":"f86cc7688639f35f5c618affe960325a916c0b01e6ef828b44737a03d4d15f81","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack/adapt-old.wat":"4e61aa8171cbdbad0049d86bd37dc0c2ef1d983e245eab080b4006e453512e0e","tests/components/adapt-inject-stack/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack/component.wat":"63913d6860e01446c3b5340c6cc2d71b29e6a5e04cae3d38ae75288725382be6","tests/components/adapt-inject-stack/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack/module.wat":"7dd9f65faef528be9924ecdf40f0b05cd63b365f70761a31ff58afbe6629d98a","tests/components/adapt-inject-stack/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-list-return/adapt-old.wat":"d32ce421ec76960c676a09af5dbec9841d3b24d0dc8f8553f2b62d6b010707e0","tests/components/adapt-list-return/adapt-old.wit":"fedd6dc412b5980b85d901a02003239d23a6f5b935266f9e28278b0d09d66947","tests/components/adapt-list-return/component.wat":"1499ffc6fc636fc6560f01050c826a38d26120f9e501771714905143f12de04f","tests/components/adapt-list-return/component.wit.print":"3840662862e417d02278b78c1cee0913e95bec39416e29cf679e2868d8d52528","tests/components/adapt-list-return/module.wat":"73e71115facdc70bccaad35d84b1b7efe3c9ef1c53e554fcbb7cf6a47550621c","tests/components/adapt-list-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-memory-simple/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-memory-simple/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-memory-simple/component.wat":"d4d9a4ce50eb25fc7da3b9cbf0fcde90b9bfaedef4c184a7539501a1d4e88582","tests/components/adapt-memory-simple/component.wit.print":"a55daf78c190d92eef7b04a67a6115cb15a9aff7afe5f56311eb9463e72edf71","tests/components/adapt-memory-simple/module.wat":"5fc3894c9ed221c7d0059752e6f37610b37dc8452f9d08012cb62c93357d6f66","tests/components/adapt-memory-simple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-multiple/adapt-foo.wat":"360aac53ba20c06b70ccbb17e6bf0abbd6c4256169e63983e0e16179d1b36645","tests/components/adapt-multiple/adapt-foo.wit":"cd76acb12ae0816ce116c5bf5e58fb6fef2cc3443c9d02fb9f166d71c7012d31","tests/components/adapt-multiple/component.wat":"9b59aabb6c55164d8ae24cb2e53307a2041a287a5bc7c3863ddb03b5243320b5","tests/components/adapt-multiple/component.wit.print":"a692a4e2fad55770689c501f3ee858e0d6a82da6306ce8c1ae67b9384004e819","tests/components/adapt-multiple/module.wat":"09c98f0e426797ca22bac7c8597e2b2299162642a56f9cd11c1791b8990c92c9","tests/components/adapt-multiple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wat":"2d13becaad0a248f4b86b740e11c53b25e131c015a058cec83f35f03b1529552","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wit":"8b084967d2be4bbf24735fe204fd7a5141f6c8baf4939aa033563fd0643509df","tests/components/adapt-preview1/component.wat":"9dbe467777d360124849e44a6f11899ca69db4aeb155d7fd53f60aa1755bdd1f","tests/components/adapt-preview1/component.wit.print":"5d4f747617d4e49467d7ab1f831a859531f38ba8fdbf7bca6af91f1e3583086e","tests/components/adapt-preview1/module.wat":"6d3d0c452aaefde1fbdcab22b2207c3dfc91cf3b7ce2133414090fc770a16bd0","tests/components/adapt-preview1/module.wit":"0207b70f162393b9976640b7afb83470fc815ef69d58523a43e9ffd4997b0f67","tests/components/adapt-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/adapt-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/adapt-stub-wasip2/component.wat":"f64740e5a017765e3bc8e791127689aff0b47839eca137910491960dc421199a","tests/components/adapt-stub-wasip2/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/adapt-stub-wasip2/module.wat":"67ef212810041d77c3db6df7fabe3d52dbf063a963433a7a478b02f641f83323","tests/components/adapt-stub-wasip2/module.wit":"6e2cbac25c8c2d1120f26f1c04d01cbf3d7578ef759e0b599c6c23c535ddb20a","tests/components/adapt-unused/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-unused/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-unused/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/adapt-unused/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-unused/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/adapt-unused/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/async-builtins/component.wat":"1f480263d84e78f6bbd563eb6ff4469d4869e75f8ec129b3904316d0d662b88f","tests/components/async-builtins/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-builtins/module.wat":"bfd0ce1103f232f0593735b45f069d81ac006c0126ac2f16a970c50c5ee1d383","tests/components/async-builtins/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export-with-callback/component.wat":"58c5f7d4687125e5b0363373f322fa01f81531607fb95e33b493733ed33ee1eb","tests/components/async-export-with-callback/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export-with-callback/module.wat":"38d85c7293b53c0b6fe33192f048b78ee60251dc63106c9b74e0ea314e75f90a","tests/components/async-export-with-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export/component.wat":"fc439f383bf912477408772aa4a7fe130606921798fc690429ba263b4f63190e","tests/components/async-export/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export/module.wat":"f239da1438442af8f76ea2067cd25c7abd14af474e304584e92f749eb2c05e17","tests/components/async-export/module.wit":"bdf4e2c172d5eadd8f785e7e467655e3dec8eb98101cb84532c8eaace201b75f","tests/components/async-import-only-intrinsic/component.wat":"661f847e409d1dfd62694ec2c659731ab226078d2490a19f64de4799aa8cc60c","tests/components/async-import-only-intrinsic/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-only-intrinsic/module.wat":"d739e805be3be8e4594cf3551c6ab32f2550264047535e0dd00e96ab7303f886","tests/components/async-import-only-intrinsic/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import-tricky/component.wat":"59139c14308ce67e8b3348d1c77bb7826b1d5e744cb90d495b2e2012ee432dea","tests/components/async-import-tricky/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-tricky/module.wat":"6adce7213ac96e7fcae050279d5e7011b92aeb84fb8160565ef904bc167bf205","tests/components/async-import-tricky/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import/component.wat":"3276ebf1556e6715bceded460db3e4531c0fcaa305d0afcf212b26bdfea5b115","tests/components/async-import/component.wit.print":"f17ba3097a41cc0faefcc85611f316be96d7bfd4f67abbc93963daf2c04cf2d4","tests/components/async-import/module.wat":"5f5894e70f438a461441d85203a948f3e5accaf8cc0470195d5b18f8547129d8","tests/components/async-import/module.wit":"31a71ad2c3142b71c67e87c6149efadca1e9ef6262d79eadc88ee2ddd8407203","tests/components/async-streams-and-futures/component.wat":"40a857b7d40ec7046fe7773319393e8dcbb1f708f6ef7527744a12bde1267b4e","tests/components/async-streams-and-futures/component.wit.print":"fbf4aae8ea7d2c661f42b5508e7617eae0e369092941104e5b33d01df04520a0","tests/components/async-streams-and-futures/module.wat":"bacd5dfec7a79670bc135eeb42bc3da07835686156058e9337f2740ec9658028","tests/components/async-streams-and-futures/module.wit":"21bddc5f549b3886d0f2ba9cbc838e5ecd29b1fe2d6a559bf4f44dd634f6878a","tests/components/async-unit-builtins/component.wat":"a699b5191cb6c6e394e642fd194949fed3a5eec7ab908ab664902fc1d1b24f3a","tests/components/async-unit-builtins/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/async-unit-builtins/module.wat":"c75ea94e991400e50800712542c8655d038ad82f42eb87e8075f58e8d4bd22f6","tests/components/async-unit-builtins/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/bare-funcs/component.wat":"b1e1026a7e45f7944d426823cf162682776459fcbbb42590067fad56723f616e","tests/components/bare-funcs/component.wit.print":"44142a3e54179c58231b1406306664b56e708d091373d4c9d26f8a8836fb19d5","tests/components/bare-funcs/module.wat":"eeacf6a9a06818a3dc1938f3f7e70d49e34aed35b6ff3000194b83b310757bba","tests/components/bare-funcs/module.wit":"cfb306074d962ab1cd345b9146c19593efcab6a033b350f809eb28be53a5b709","tests/components/cm32-names/component.wat":"c4e1443a880ebe01ea12a930726c29f3f8f572cba802b0f849791fb0929876a2","tests/components/cm32-names/component.wit.print":"931313d8c16524f0a195235a8acb74332448679069f426535773aca17354c6e3","tests/components/cm32-names/module.wat":"2377a85fd01e55a6fdb6b91b8074967c86f00a565a4fccb0ae3f463dcafe2c03","tests/components/cm32-names/module.wit":"9512314374f9cbd23730915c09c154e48deaf6741013e8d32e22dedae556aaec","tests/components/custom-page-sizes/component.wat":"3eaa8c9790617a9026c077489ae93022ae6e970577e37ea5d850abe90137f22d","tests/components/custom-page-sizes/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/custom-page-sizes/module.wat":"735787796014137b07df0a6c8a5f07b6f9c202440111456ef4b2224b60583b1a","tests/components/custom-page-sizes/module.wit":"2e6ea2c38b49574cd8f8303204067e2977f695925f161c9e68002cd1fee842a0","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wat":"3d96dada383101358bd8985bcc1ff9956d8a50016607914182f205f777a4ebf2","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wit":"f4d3eef4cc15bc74a4d9d7d045aacc81be1991b4bcb184d587e2048a983035d4","tests/components/deduplicate-imports/component.wat":"41496495e2e28882e71d39822a7e8e798ea636e8b0050296320dd7f84eb497b0","tests/components/deduplicate-imports/component.wit.print":"bfc18ec3026ea7285c88bb8da1b4dd5d77db4e41fff8a8f0f26df9656a18ae8d","tests/components/deduplicate-imports/module.wat":"11693ac57d19f8388286897e8a3b3b4d2d18c9ac92ea9cee5e9559038818ad30","tests/components/deduplicate-imports/module.wit":"ebc9fa1a6bf412c67ce4dc481a1477500a902b56c5f395bf5618c4a14474485e","tests/components/empty/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/empty/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/empty/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/empty/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/ensure-default-type-exports/component.wat":"a7991c6b578b95b41de82514cac59c4aa19b46d6341f244eefb16f4bffc77491","tests/components/ensure-default-type-exports/component.wit.print":"baf9b735b1f9dbf8e247064d5735bb8b37fe53f6f1e9bd1bd154a991177e1b54","tests/components/ensure-default-type-exports/module.wat":"14a179f41e4e06a59b4e34f0815ea34e12ccf1f8500bccd83623deb84c71093a","tests/components/ensure-default-type-exports/module.wit":"36353bc5366252cae33912f215d77dc501384cc9606dbadf5fc831b33376f3de","tests/components/error-adapt-missing-memory/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-adapt-missing-memory/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-adapt-missing-memory/error.txt":"d8491054cdabd0359c1ece02710db9f5989eb58c43283e73dcd0401231fdeae3","tests/components/error-adapt-missing-memory/module.wat":"a09c5c2e4aea7fabae1df7f54791a87061018325968a3f9379d35e3ce2cc405c","tests/components/error-adapt-missing-memory/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-async-export-missing-callback/error.txt":"53956038fd6dc7921e06b1217ea0bb21ce8fb43f9dc6ca42ef5f069793d6d899","tests/components/error-async-export-missing-callback/module.wat":"89ced8e40f2175f16f59261807e23b05dfaf326231873a6f011fc4b765fa86b6","tests/components/error-async-export-missing-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/error-default-export-sig-mismatch/error.txt":"04dac125afd8c985269ced00b248d43cb7dc96f8a52dac2f3103c260aa86f856","tests/components/error-default-export-sig-mismatch/module.wat":"d61b464c502b1af9fd83b5ff5339ac45d2674c9455163bc7a89a02fb5454f878","tests/components/error-default-export-sig-mismatch/module.wit":"5d093bdde43c050d69d2df8b034d66ffa6c076ac4c83b26ad7e9cc78ef49dd68","tests/components/error-empty-module-import/error.txt":"98053ec5a972463d2c9411c82da5b2fa95e24099f6e6c61d355212d46444e8a4","tests/components/error-empty-module-import/module.wat":"a9e2a33d4affd7e94275daf7dd6475c71135de2359343ab0568a3fbe7204a527","tests/components/error-empty-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-export-sig-mismatch/error.txt":"a90a4c7f4f88369d8cd30673fa8cef6628f5eef68bc626a225fab11aef056d5e","tests/components/error-export-sig-mismatch/module.wat":"4d7dcefb19126be4325185e99fbd3f0f964947e8bce9cb4254dd153da60a4e39","tests/components/error-export-sig-mismatch/module.wit":"775d9b931e1644f29c0124edb264af4b6c9ef9417c3abcaa2711ec99b809b85c","tests/components/error-import-resource-rep/error.txt":"19991af81b6006ae5d7f1f92f945a8c4debf1e82069ee4a67420df4fd6de8f5c","tests/components/error-import-resource-rep/module.wat":"01c719d6eb94c6e3243e04425c6eee29f5afa86d7de59e0231412190385b3759","tests/components/error-import-resource-rep/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-resource-wrong-signature/error.txt":"3e2a1f3b231bd148cbfec7108af76d5f61d90edd5454c0974f0bc86c6049002c","tests/components/error-import-resource-wrong-signature/module.wat":"9f921559b46bffc7e412984c49395cbef1b723e616cfedb5ceea6784b70471e2","tests/components/error-import-resource-wrong-signature/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-sig-mismatch/error.txt":"b3364c1047649d851a0ae1d80332a6df1b34504a8519a132c68fc1855c7443b8","tests/components/error-import-sig-mismatch/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-import-sig-mismatch/module.wit":"d98bced030198058d8c1a6e77161ef9a1e3871f8f2c539a618aeccfd4cc19b1b","tests/components/error-invalid-module-import/error.txt":"f8359fe5bc543bda23293a6f8d40b1d96d9dd6d0d521e538113c0b69ad5a0d6b","tests/components/error-invalid-module-import/module.wat":"20b107a75357922999a6951562cb321ff63926ce1011cf724da12ed1b2c86ac9","tests/components/error-invalid-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-link-duplicate-initializers/error.txt":"05be0b8139892df6dac079ba7726fce46909ed661bc4367644c9c6ee7f7c8b3e","tests/components/error-link-duplicate-initializers/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/error-link-duplicate-initializers/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/error-link-duplicate-initializers/lib-foo.wat":"162307ee1bb2ee38b02d94e8dae7d0b367cbc7e66250286141e557db56b9816a","tests/components/error-link-duplicate-initializers/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-needed/error.txt":"75506d6c1244cd5d0abc95789f38036415599d737a0e34ea0894b23dc9598bad","tests/components/error-link-missing-needed/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/error-link-missing-needed/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-symbols/error.txt":"1b8771b7638f5ed476bbd54c5f613c144b36f74ef4f700940540a913f6960c3b","tests/components/error-link-missing-symbols/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/error-link-missing-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-missing-default-export/error.txt":"5a53be2c03ca12de39b6dd856ba0cb4b61ae41284c8970dd319f92458c3fc8d4","tests/components/error-missing-default-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-default-export/module.wit":"155bf2d1c7ee9ea2d284964c56c936f94ae987195787235350ced0dc6d6db305","tests/components/error-missing-export/error.txt":"878e7173e57fb0eb0df926bb43e7e0403f88462ea9e67c2412018712e6f9ed56","tests/components/error-missing-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-export/module.wit":"eb129f25552584be9360310178c70a65029de6b72a1440ed99ddbf38d0916c6b","tests/components/error-missing-import-func/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import-func/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import-func/module.wit":"4f0718445438c4dfc08950cdfdaebb4a4c5adf2d724d66bd145ed593c1592c1e","tests/components/error-missing-import/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-missing-module-metadata/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-missing-module-metadata/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-missing-module-metadata/error.txt":"993083f2635f4875169fbcab22b59bf416eaf09de7708cdb26f47918c615ace5","tests/components/error-missing-module-metadata/module.wat":"66a5907fa8f666c22e3f5cf88cc62a8567a777d750d76374de448e0f8e8ac7e0","tests/components/error-missing-module-metadata/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/export-interface-using-import/component.wat":"7d16e055fab6b2601aec5aa0618462d75106e29ad65a676ba31301403d7b0269","tests/components/export-interface-using-import/component.wit.print":"3cdf7896480bc68b7cb0b9c9ff4dc028eb7d435f58de7bfaaf403e426438fd19","tests/components/export-interface-using-import/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/export-interface-using-import/module.wit":"c6b8fc795e93412e9cc6e2ba335c20c89e0ba442f684bb0ab779ce052e715c32","tests/components/export-name-shuffling/component.wat":"abe1f435743fdd3690dac62d9b60ee7afcae762aa9e8e912fa8556fc83eedb5d","tests/components/export-name-shuffling/component.wit.print":"32e7124b8455a67f63c1071d9a5332dddec63c47472909222b351111e0146817","tests/components/export-name-shuffling/module.wat":"cdec922bed8d252248be323019e3d5fc83e0bfc9777fdc654b59348daeddfd19","tests/components/export-name-shuffling/module.wit":"99d470993cedf025e7c356ea8e5c6a041aba2968419193eea5f1947061b19750","tests/components/export-resource/component.wat":"8ad1eca01f2d26a7135898bbb123391da9827604f6900799894b281dabac3bba","tests/components/export-resource/component.wit.print":"9a6e09d0140a25319041d65333e58adf87a0231b5283c3bc768ccbdce83f9c24","tests/components/export-resource/module.wat":"35cf529d4838d0652bbd322e3498e72d02643a4d105c0b7dd801d3648621316d","tests/components/export-resource/module.wit":"ff43e87ba4fb913e5e239a5282f0f0acc33aed4fa04610be25a706791429b56f","tests/components/export-type-name-conflict/component.wat":"02a9d2e58bb5abeeced1fda8ea356bf2a288d27d8f376b0ef84c353804193b0f","tests/components/export-type-name-conflict/component.wit.print":"0039957ae8e5e8ddba28cb0f8c7831a33864e407c87550f578af5e36b5b9d97c","tests/components/export-type-name-conflict/module.wat":"b8703739f92ca2de5a1483eb2504fc082e690f514fb014c7e09b6e5b0348a3ec","tests/components/export-type-name-conflict/module.wit":"47b93fc6d44cd48c9ba768feef028a5dd9980088ac328ef965038f349a566b46","tests/components/export-with-type-alias/component.wat":"01261b62e3576b58c1105019e610e1377476dab64fa0d29830358ba5efd35906","tests/components/export-with-type-alias/component.wit.print":"35e7687bbeb38e07890e152ab3359c6ecb558ae513b44f41efe60be15d99c5cd","tests/components/export-with-type-alias/module.wat":"d0e73d5437af39f365675b5c516a12ffadd6844ab1a7cb36f63829716a823c10","tests/components/export-with-type-alias/module.wit":"22f298065ce8a2fdaf726cdb347c4bca9e56700fc6475bda9ef5ef8563ff0d89","tests/components/exports/component.wat":"acfce3dd26ac8a4bfdfeaf3b01d6c23773acfbb1674813b26eb0f3e1075d4d45","tests/components/exports/component.wit.print":"761c69439ac16484a2b210ff34d219db4afb2bcffad4f3868a2e76479feb7f19","tests/components/exports/module.wat":"324dbfc38fee5a442e7ce3a13eb2a4d25dc6a074ba81bffd4fb35268608f9d08","tests/components/exports/module.wit":"d41d5f8763da23fceeb773ff18c9960132a1e811ef194a47c900d21f48083d43","tests/components/fallible-constructor/component.wat":"1b42b21f2ffd5de0614188b285517732b0676801b2c9460a54908629722b8386","tests/components/fallible-constructor/component.wit.print":"a486e9bc2d393474b05ab915bf61a573e89ef09e3bf7bed24e16cb95a27df2b2","tests/components/fallible-constructor/module.wat":"9dd3bbf052d233572a70122e34ada7573252fe2e727c918bda87f44d62ac7efc","tests/components/fallible-constructor/module.wit":"310b82945183ab329679be7f832f0d8c11c59360e700f9646f87e881e612d0de","tests/components/import-and-export-resource/component.wat":"7fcd443bafed0b524f49c7fa27b371ceccd6b95249998f5c8787e481d4e7547d","tests/components/import-and-export-resource/component.wit.print":"fdb32e7784b0d908390a0d1b62e077294f5168cb46daa470ac5e078cbe8996c9","tests/components/import-and-export-resource/module.wat":"43b89c3fa07a24663af81eaddbd02778a0d9062ce65efa7f04dd10081cc8aba0","tests/components/import-and-export-resource/module.wit":"a9f3ee298ad42fcef0d80a34b6b58e1d18e438e492400463993508599d02adce","tests/components/import-conflict/component.wat":"f0008f711d6bde4eb701a08fa5c61c021e33c61501fe3fce25535a420be1d63f","tests/components/import-conflict/component.wit.print":"19bae900cafe77b7bacda385e23475154f90f0a8d8f063597496132e149867f0","tests/components/import-conflict/module.wat":"639633c3b575c976831d12d1d7e69826ee23165c8cbb6094940397c8359ddc6a","tests/components/import-conflict/module.wit":"d8fd770eb17db0c5e7adc23c41315cbfd77af9014b4514d65fe2f28a629b7b43","tests/components/import-empty-interface/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/import-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/import-empty-interface/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-empty-interface/module.wit":"f570a16495e584b54606fa6a50018cfd1ab21dc85c10deb7f869564db3d7450d","tests/components/import-export-same-iface-name/component.wat":"7e506c2d9bcd48d98b4fa2acfe4a7fa33f6ac8cffc764629d9fce27f2005b3b6","tests/components/import-export-same-iface-name/component.wit.print":"510d7b609e6714e7bfb7cbe9f57c42c9d2318ec17de0ece8522599dcdc7aa22e","tests/components/import-export-same-iface-name/deps/dep/foo.wit":"e53988c57720965219fa842f767cc30e31f3c18ee07ba9833432ca2084ed4fca","tests/components/import-export-same-iface-name/module.wat":"a951a5e947ef899087bbe377a97c06d4f742afdc97ecdb673dc3e0e60019f956","tests/components/import-export-same-iface-name/module.wit":"c9bbae4c071ea7fa7da77e422fcb93d48f14a6faf0adeba4ef94b3949cf1f9a8","tests/components/import-export/component.wat":"bd51d58f13dc0de6ae5b62eef53383064378f62172382b879659dd39c4128a51","tests/components/import-export/component.wit.print":"07735b330c59c0c01e604e0d4cfebf3d513beb24a547c3453f9e804a7f502819","tests/components/import-export/module.wat":"5e42ab263e87ae03d3649d839f86614ff580982033ce7022dbfe1c6c13e886aa","tests/components/import-export/module.wit":"c90a74db6e305afd8c8da8c4b9d1bcdb0e4dc575c28d1cb302e2c3ae1b087c21","tests/components/import-in-adapter-and-main-module/adapt-old.wat":"43d847aa6521beba5a478c3bbede7f255c47ab6ee31b4f34a1524b28dfa25df5","tests/components/import-in-adapter-and-main-module/adapt-old.wit":"3cf2e31d18b76f61c61958cbc7313290ff7fb323719d31e89c054b9f6b41615e","tests/components/import-in-adapter-and-main-module/component.wat":"c9d2c38b30c0731bcc8ffb555a38d501135ce2065de42e8c16020b3b87d2f4f7","tests/components/import-in-adapter-and-main-module/component.wit.print":"fb2791ae3aa119e2ef9aabaa811df8a84a5680bbf26a7cb7697403f8efee705b","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/doc.wit":"ba5a8f346d581ddcab0cddbcb00e976e54327920d4c7f98933a422f03e62339c","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/types.wit":"2aa8bf309a148128bf6ca4ccd86c8fae95e97953a73f2ee7d652613a4eceb5f7","tests/components/import-in-adapter-and-main-module/module.wat":"6995ee3ebbbab471d4b7a7d9973647e5a4b86851ed54fc019b6ce46b39c3849b","tests/components/import-in-adapter-and-main-module/module.wit":"d1e48a09fb9307185b79f5f200b54e906da5ad62eb57e841bea93e239a96b9ed","tests/components/import-only-resource-static-function/component.wat":"1bd74e7edbc1bc26bb6c24508a941b67d8aaa3c2fde5ac2ba3183a930ca917a5","tests/components/import-only-resource-static-function/component.wit.print":"392a1d0c73268c3e20bce45065b5618dc8ec498e280d54c226a7701c2c7d17c2","tests/components/import-only-resource-static-function/module.wat":"cf1e1ed8d03ed537c0cefd5261147933c78b85cd748c92f5f005642cdfb1a01c","tests/components/import-only-resource-static-function/module.wit":"c6cf4995b848915d6c99a90f3b2ff95c32ecc9c3cdc21ece827d0840035d64ba","tests/components/import-partial-export-full/component.wat":"55081ae4598055a3abb4ee4cd3676ba30e99a80a167f87e2226be278b8d59435","tests/components/import-partial-export-full/component.wit.print":"3ab4179ebc8dfa619f72f3b51517dd038ba0b2bb1ada2ab063c2cb8dda844b85","tests/components/import-partial-export-full/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-partial-export-full/module.wit":"d37ab68346e073666081684d84a94ce9de6c27fc50ccc3c774b902f13dd77e77","tests/components/import-resource-in-interface/component.wat":"9463d61a86d5eb0c4eeac4caad24e61ee406a8fdce569f4a22c972cebb09b345","tests/components/import-resource-in-interface/component.wit.print":"313207ca455eee8d5649b5901c2e7786b117761cb76626ffed15bdfc6efa743c","tests/components/import-resource-in-interface/module.wat":"dfab4bf8f2d634b2f8db1c452ba1cc9f9aa20da580fb8e5f520d9383d53aa614","tests/components/import-resource-in-interface/module.wit":"72d6d2861b7cef7939fd4af3c615db98cb29a08fde3cbb4e5a4ea6fc463993c2","tests/components/import-resource-simple/component.wat":"0a9a15caf8bc2c69375dd1f1f0fe571a9c139e84132039834c1728ba0a103cbe","tests/components/import-resource-simple/component.wit.print":"7d166ca48287419d030b9cd49cd69150fc3a534f1ffc5569cee934c002f1028d","tests/components/import-resource-simple/module.wat":"76206dd7ed5d0ca30f9db6085cc3d0908fba505bff097e5310e1e7eeb6cd3d7b","tests/components/import-resource-simple/module.wit":"81993bcaeb714767b9f5d040079bc2b71cda292861b5d1705d55010e809907b0","tests/components/imports/component.wat":"1cbf22691c0723e661184424d00c620126db8a338499dde7397f29aa75b028fd","tests/components/imports/component.wit.print":"db03bcc1e409cf7eda8abe72152b697bf2242696c9442480d427033a6ada15fe","tests/components/imports/module.wat":"726b52e97319350b0995edadb347404724f750b451515cca2998d6ea43fbff58","tests/components/imports/module.wit":"ae6f59d5a9862832e4393df2e066ab8bd671a0072922b720bd6a7da703bbce43","tests/components/initialize/component.wat":"55ef7b724f6dce61155262085d7d9f627ad3ef0647049f86d836964664f48eed","tests/components/initialize/component.wit.print":"c621c6ab874ea1463aadf38c9a9499772183c86580381c0af0ddda71379213c9","tests/components/initialize/module.wat":"d6b0dd9b619d3ea4f767cdbaee59abfa5cc429a7fde2dbf30d4b98bc1ca8abc6","tests/components/initialize/module.wit":"2ec1457ceac2774e5c0f8701c08ac63575017bdbf8b2f58551f3f946edbae839","tests/components/lift-options/component.wat":"8e7a0fd9998956377a8c4521c0795698245e5e1f4882ec427fb917e1c078e688","tests/components/lift-options/component.wit.print":"0efa031b0013f70c3c5092f53e40b10c0ae02398403320a28ba7c28533517f2e","tests/components/lift-options/module.wat":"7f74aba6c2e663bc2a7de94bfcdeea21cb9f837952a6b7d5473998ee65d8ae33","tests/components/lift-options/module.wit":"63ab644fd22c7cfcb0b9a6195065f0065abc01eb5545e18437c02e6a68e09bd2","tests/components/link-asyncify/component.wat":"8b989d3709a2dce7d8e8894ea83cf827f9b3eb7caee007eb9b059125ec7e3047","tests/components/link-asyncify/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-asyncify/lib-bar.wat":"159e0a9e578b652915a4a1c525d876ab78c76574edc757eed8f2d898231ef3eb","tests/components/link-asyncify/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-asyncify/lib-foo.wat":"d61a8d805cfa025d3be070564e8cd993a21307549af7fba1f2702ca5c4d083b8","tests/components/link-asyncify/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-bare-funcs/component.wat":"72c3bff4be47ed0a7f1bf2754c80665a2d20b292881891c0f5fd28732ba1fd4b","tests/components/link-bare-funcs/component.wit.print":"ffaa54c61b292fd93917c958eb7d4a2d6db224b5a30fbced6f07530c23486aa7","tests/components/link-bare-funcs/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-bare-funcs/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-bare-funcs/lib-foo.wat":"57eea96d26803de69e0a6a69314006251da4146416f658cc7447e5f4212d0ecb","tests/components/link-bare-funcs/lib-foo.wit":"ce1132f1f5d9df197a0326a2b608df671179d490dc537e9c1f8577bd25c57ddd","tests/components/link-circular/component.wat":"5e1b586bb766e1cf3a2cfa47bee8665e44d0eacd8c9332f08e52ee04da6aa4b0","tests/components/link-circular/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-circular/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/link-circular/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-circular/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-circular/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wat":"4444f536a9a97ea84a3822944ba48ec05e8d045ecb5ff86e67807f2106815bc2","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wat":"e02d2c79ff11af4334d7cf751750843102a4c2c40e1aa35686fd7d04b273cafc","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wat":"ef5b56730b4c79fbe9f9e10f462ae222ff18bfa2a960ae03a86e3152257fbe6a","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wat":"099904a1539e31d8ddd306553dacd0667ee221a76aea79a3861a269d9edfaedb","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-dl-openable-builtin-libdl-with-unused/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/component.wat":"6dd489bded8be0b711abb6129c927cf4d561979fbfc60dcb2317ac103287f32b","tests/components/link-dl-openable-builtin-libdl/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wat":"1183b069d484eefd7a030c9ab975d4ef5bf24fcb033d922148398bc5ecb0de89","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl/lib-c.wat":"e1988d4a8ff43aed730375fae50e601b9d3f5c28ffafa56f6be581be1517394e","tests/components/link-dl-openable-builtin-libdl/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable/component.wat":"f169770d4cc24e8ed2c010810e31d956f29374e029b9f2dfb563a6b2f499d919","tests/components/link-dl-openable/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable/dlopen-lib-foo.wat":"7047914692755e525a4049b7973c8328de2c19fe0f1b65a368228f654d14937d","tests/components/link-dl-openable/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-duplicate-symbols/component.wat":"f015b4fd73d2f0b694d4cf0c18be014a82a1dbfca0bdf92452d295bf8382ccc4","tests/components/link-duplicate-symbols/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-duplicate-symbols/lib-bar.wat":"346743798987c1a403b7e4941791c3dff77e6fbfd83afab14596b3efe81b5808","tests/components/link-duplicate-symbols/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-duplicate-symbols/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-duplicate-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-got-func/component.wat":"28f03634ebea0fe1b7d2b187ec472e806759999e6e338116bebabd45ce366db7","tests/components/link-got-func/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-got-func/lib-bar.wat":"b68db9e5915e6875477363893779792319e68e6c0b23411dec94ceb903f2844c","tests/components/link-got-func/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-got-func/lib-foo.wat":"02179e2a615fa830bf3c7b8d42ba1abc9e922b2cc163bf03f389c19fccd3e8c4","tests/components/link-got-func/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-initialize/component.wat":"dda1f4d706281526a986c2973dc2814d58fcc8d035b61de8547b88d968e74564","tests/components/link-initialize/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-initialize/lib-bar.wat":"acdc5991e4e0bcd1a8d681599326d903b47a8485ecaa341daa95d75a10dbc270","tests/components/link-initialize/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-initialize/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-initialize/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-initialize/lib-foo.wat":"230df7123dced23e7ed1e01f8ab4c0564d0784c27fb5f56432a9641bb74cd20f","tests/components/link-initialize/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-lib-with-async-export/component.wat":"2ccfbe257b2318b3de66c8023f9f8c57b41ac2af678ec4ad5ecf0f565aff4f67","tests/components/link-lib-with-async-export/component.wit.print":"0d42f40f1f6c38efc4d7c51660b69bfbc86abcbdec31c6350ca6862202d2fdb1","tests/components/link-lib-with-async-export/lib-c.wat":"b42be22217533ebb066b70b2bb36d0deadd5470e45b6ea272e54ccef6d8ab62c","tests/components/link-lib-with-async-export/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-lib-with-async-export/lib-foo.wat":"b3221090479c8732841d2e57583a49d60c16ac0aa7fe8f6e1205212939ade018","tests/components/link-lib-with-async-export/lib-foo.wit":"358a5c8eeb2eb91489109180f0372fa049ca51b03dc56761bafa8de593e26c78","tests/components/link-resources/component.wat":"a41b479bcebb05a75cd6c29c996f02d65920219c74ee5c3394167dada015014d","tests/components/link-resources/component.wit.print":"7c9bcd7d88669aba18c1ff9979d40fcbca7ed4616db8fdae221e75f49c30e863","tests/components/link-resources/lib-bar.wat":"a19533149c2054deeb209e902be84d472b72b6a69771ff7db7d6c881028e172a","tests/components/link-resources/lib-bar.wit":"c51af5e3a0b53612bd02b9cfcfb509145806703ba7591ae9562a324e261fc805","tests/components/link-resources/lib-foo.wat":"914b197c116ae12a47fd337fd0ef1160778479f619d38f958d8ccf6ec1e92020","tests/components/link-resources/lib-foo.wit":"98733c4a044f7ec1916a604bf4d78f1e0fc7432e9d170479c6d513ce33efb3b8","tests/components/link-stack-high-and-low/component.wat":"3e1c9ae6dbab0ccd91f92c372a9ab50f1d97899d5a8ec9797042ee9ad6422fdd","tests/components/link-stack-high-and-low/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-stack-high-and-low/lib-bar.wat":"3477c2c461c8bb6064072d4b278843906a3b3f513439cb2ee5738562c51dd99f","tests/components/link-stack-high-and-low/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-stack-high-and-low/lib-foo.wat":"d94339117228cb4b645b29fb4ce711e24f77aafb83b4579279353cd72d1ae94d","tests/components/link-stack-high-and-low/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/link-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/link-stub-wasip2/component.wat":"dba0ffa80c499bf9a2522d20af4904b3fd50da45afa94726e84bb7d0ba13ae5e","tests/components/link-stub-wasip2/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/link-stub-wasip2/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link-stub-wasip2/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-stub-wasip2/lib-c.wat":"ff30ef2aeb8c5503309ca521063086d4401b11d5fa42e787ae52c3ace024e6df","tests/components/link-stub-wasip2/lib-c.wit":"7b97c2b019fd47edcee51bb66c69b71a3124ce4ac77b81af0d40b1edd957e8dd","tests/components/link-stub-wasip2/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link-stub-wasip2/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link-stub-wasip2/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-stubs/component.wat":"58e7f8106945a291b8fd13e0997792248009c0cb7853b0874974c6fa61935f7c","tests/components/link-stubs/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stubs/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/link-stubs/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-stubs/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-tag/component.wat":"4cf16662ecc758a4bf730199fc91b5d2e06a7707ab3779389335bbe22c20bc1d","tests/components/link-tag/component.wit.print":"04b8975105d1093d4fb679d99999f103bf0b6801fae41dcb1fece2219453618c","tests/components/link-tag/lib-bar.wat":"4611125ab396c5d69f036f1b8f2e18a3aaaf81ffd5c44b52995cd712d64be3a1","tests/components/link-tag/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-tag/lib-foo.wat":"fb4e47576ad3d1cba844d7a03dedbcfac323d421108a04107db0863b6f44a519","tests/components/link-tag/lib-foo.wit":"bf62ea838d3ccbfdad20b1a51204262b9bd613c4646346ba7bf8e57a8c6f6052","tests/components/link-weak-cabi-realloc/component.wat":"762f3b5d9550d6a49ecae9e13e6ddb538519d049a7dd3efb5d5df77cc9b70211","tests/components/link-weak-cabi-realloc/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-weak-cabi-realloc/lib-foo.wat":"6357c1189cc178bb27c449d9a833da58aa9ff78c04936d5ad10f21e560ab70fb","tests/components/link-weak-cabi-realloc/lib-foo.wit":"903b843983ea9c9c22cea5383ea3fd607b8c1de49d1addd0197d38fe1aae9a69","tests/components/link-weak-import/component.wat":"8e00021d1f863c95e83fc8ebf5e7559aae4cb891def1b225555507f8da4a3a9a","tests/components/link-weak-import/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-weak-import/lib-foo.wat":"8163164df489b40ad2fe861c7621c60d80173b893f3108983306032f28f52b93","tests/components/link-weak-import/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link/component.wat":"344807b51f4f5267163173e2837b3ca9439650d3a70a0d3624a565fbf2a31809","tests/components/link/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/live-exports-dead-imports/component.wat":"33a32e651592e2f8499ef51c9bf4489e5c4b87a10f07892110f270c70fcb4a49","tests/components/live-exports-dead-imports/component.wit.print":"58c56bb216d91796f2ff53e2568000eba20cc4ac4a8e7315811fead63044d84c","tests/components/live-exports-dead-imports/module.wat":"82607855264e152a2899ccc7d23f068154e043c3522c205702df4b2a6c03e7f1","tests/components/live-exports-dead-imports/module.wit":"563494c0507f08ab4ed9c17032fa68a13837e3a9ad7eb3953a90136c2075e271","tests/components/lower-options/component.wat":"011a9e6c5bca14333185baefa7a6879413ebff21c952774cd057ae080ea055a5","tests/components/lower-options/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/lower-options/module.wat":"957cbf0c8a6687ecb0c76040480fdcc146ce5c61d01e4bd3ddcd894d395209f1","tests/components/lower-options/module.wit":"141d136241a64268b9f9fe18ca20956164ac9e8f47e2b2bb48cc1adef77be68c","tests/components/many-same-names/component.wat":"4c01d2694a24f39577beb93a2d18a4b37d8e13af76a640004abea902ed8df918","tests/components/many-same-names/component.wit.print":"04eb5ca446120ee977f058357f6d7a9967f34f596e4c0a5055a3ec1f51a49af4","tests/components/many-same-names/module.wat":"7a748bf12c36d8ed53f7e76194120df41102a81b52adbe9e6bb3682fab1333af","tests/components/many-same-names/module.wit":"bdc6c8ddf22997dc6505bab8bed04c2d93e45c21756d036b1b84790bb1e76156","tests/components/merge-import-versions-with-adapter/adapt-old.wat":"3c56d37587ab8193c5d63225ce84ff473c33c8f1bf75d6c4bed75bd7c30775ba","tests/components/merge-import-versions-with-adapter/adapt-old.wit":"ef42f0a58910c4cbb63bd8bd92a6634c511c6141850f6fc0694ed7c4a587a759","tests/components/merge-import-versions-with-adapter/component.wat":"edb6947344fc67b9a37527a25decdf813cffdd9437abe82bc111bacd66246fa5","tests/components/merge-import-versions-with-adapter/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions-with-adapter/module.wat":"9bdbdd6a7454dcaa8eaccd33696f0855b6a613cab4228663b547ced3a839d630","tests/components/merge-import-versions-with-adapter/module.wit":"a79e62d6f59e4cd8eed01ee0aa1f1dd7eb6cc4e057eae857e514c1b88c5f0196","tests/components/merge-import-versions/component.wat":"44b673bec8cd8b758921f711c20921833e2e1089e2b910c4c2e575a8f5abc994","tests/components/merge-import-versions/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions/module.wat":"abfdd39d50c8a4529af1636e0f6c10a4b4cae7103958480e4006a40573ab47a8","tests/components/merge-import-versions/module.wit":"92850e6dfaecb1d699c235bf43e980b410e002d5e9b49cf43d9102d5cb35703c","tests/components/multi-package/baz/qux/component.wat":"9cde15bcf420c2d39031abb8a802f575a756e52c2266738541f6f15c2613935a","tests/components/multi-package/baz/qux/component.wit.print":"b255c8747f2704e788d61a108eab228a7e6e02437ee665314cac38effbb4da36","tests/components/multi-package/baz/qux/module.wat":"2b1492c9015f1347557088a9bb19e61b79edafaa57aa8712bd911ba3921c5d3e","tests/components/multi-package/component.wat":"8ba4c759f3bee8b944e5a631ac4f8437016348ede8488b678bed671459578ad5","tests/components/multi-package/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/multi-package/foo/bar/component.wat":"134a96e6e491ed2e014a036cb56c9d4a196e4a850619be7ef6666b8ff65cd9e6","tests/components/multi-package/foo/bar/component.wit.print":"6b6f89526fe4793ce9085bedf8eb2c66725a92360dbafe920f8dc8f5147efdc3","tests/components/multi-package/foo/bar/module.wat":"ff8ba654ecd7125d49210c22ef349f37fa54b52badccec69f71fb062fd860f56","tests/components/multi-package/module.wit":"057f5c6f1500ba79cc57fcfb428614de419243c7a224e104d20415e518669da0","tests/components/no-realloc-required/component.wat":"3440a750b0c21813cf577ed5256f8dc46682e41f81594083bc1d25db50714fd9","tests/components/no-realloc-required/component.wit.print":"af82805774e5a261f885b97bd183708e86322bf121ce2528c05bd3ef7c3ffcbe","tests/components/no-realloc-required/module.wat":"d7515c3defbfd7288984e414417b6f9af6b4e9be6835ec5a79770079aaeed542","tests/components/no-realloc-required/module.wit":"d4fff6f58ec0f32157f5c17f0c44c9641dd063b0025972cad18af64f6e2de9b5","tests/components/post-return/component.wat":"f7c4867a341a2f5a1c31465462ae0971424b9be80f891a560681242373dbbb58","tests/components/post-return/component.wit.print":"dda1f7d5e2f6e49f6df046e881a8b5eebe2449c19aaf48a49121f426701a06e8","tests/components/post-return/module.wat":"3bbdd4c09686c2f7f61c6eb7d132345f7d8cb7037b3c259d22d1a8b295e67305","tests/components/post-return/module.wit":"b1fae8d17f70cbefed1036d5a44550473a08cbc2328fe1a923ddac4339d0cd0c","tests/components/rename-import-interface/component.wat":"0e1cdfc198539b6e68413048e9b276f7cc8d1784849583bd0cd85c06b042a625","tests/components/rename-import-interface/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/rename-import-interface/module.wat":"6d42f1ef7a8c3b10cfcd9af2052c8e08f47bf068f554013514f2702d3d714df5","tests/components/rename-import-interface/module.wit":"bfb05c599b4b556e11fcfd94a51090eb311972d9b5643b2fc1a4b786fe886d17","tests/components/rename-interface/component.wat":"8a4534c7b80fc412fa024a343927b53e6b804c489f1877c4ef46ebb65830a7cc","tests/components/rename-interface/component.wit.print":"61e6663c4a3e56091cedb85a6339a01006ab37fdadadd84d855f35c4e547afa9","tests/components/rename-interface/module.wat":"45fba53e30e8279c534f0a60e320f1c6a1422bb82f95460dd2bff27d09272e07","tests/components/rename-interface/module.wit":"d4c0aeb65e8de86ffcf651ffc2937d2dd0c15a394fd27fffb2aebc34337d06a3","tests/components/resource-intrinsics-with-just-import/component.wat":"38b11b9263711d8dc42c84e4c24f3ecf26c2e1a311aee4a40571219288ec0c92","tests/components/resource-intrinsics-with-just-import/component.wit.print":"1d1896462fc3ce15a0f79f753b7ff8b83b1b90fb41850b7a3b05afbf17064aba","tests/components/resource-intrinsics-with-just-import/module.wat":"f892c943bc508e188d746be4b31849792ea70e5b35dbb316a5bbb33b9604239c","tests/components/resource-intrinsics-with-just-import/module.wit":"41d2b456f11bd0005178edd868ad2675fed29c2ef4e36f9604383178a01bc707","tests/components/resource-used-through-import/component.wat":"4ee4514507461c97bddc711005bafc951c1337dfd942880707505d56181f92d8","tests/components/resource-used-through-import/component.wit.print":"016e2d6cad8f4d38f6ae9c64108ee475d9e479466caad186850e3e3e7ad0d4fe","tests/components/resource-used-through-import/module.wat":"5444f7ba822b2864e8ffb92a42b21674dbf6416bbe4c868d311db8a9d2ed5772","tests/components/resource-used-through-import/module.wit":"148d7d1dd61494e67dd1abe605731222be46e9c050a42632af85d65892378a1e","tests/components/resource-using-export/component.wat":"dc1ee332ff13e5361f1b60c8fa53db57137f9ef499288510d65c6f5bb7802672","tests/components/resource-using-export/component.wit.print":"81d2ecd76e78f9835ff0a1c201fc449dac6edb6cbc2390c37b3de7665e9c5e6e","tests/components/resource-using-export/module.wat":"a536f2f3270fc6e218e39b4d16c6a481051023c0aa26c4c2023f9ff90ef410d4","tests/components/resource-using-export/module.wit":"2b82098eea901f65cb65a9a079e470a1975b9192d5b5a227511ea25f8c32af85","tests/components/simple/component.wat":"3c2ce9adab9e033f1386da2143d3cbc38693ae6c277c4b003d3aa793d1e18d59","tests/components/simple/component.wit.print":"bc11e4896f9442ef9415b7f0796da9e22d9b07a2cb27d957c746f3be3142e7f7","tests/components/simple/module.wat":"3688a131da2f16901166d04f7fa0499f755a19f7d479a24a47921e94710ca86e","tests/components/simple/module.wit":"ab54b3883a5838519149b99347ab6ded6f494e0526eb16b774890044acf4a569","tests/components/threading/component.wat":"487085b1ddcdaa5c3d01745abd45d3537ef6bc55e0cd0166152ee0e8a58b5c86","tests/components/threading/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/threading/module.wat":"619203db7bf8392f8c66bab654bb5bc52566344c1d867af1e1b67794c9b6ca8e","tests/components/threading/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/tricky-order/component.wat":"e95a6c6fd66eae7ff0640539258a7b3bb48dc6ee047b51f5d3fabeb21a9d33d4","tests/components/tricky-order/component.wit.print":"3fc16dc48f01ab7dcbf933d5a04443abc22fb1f06800ef02668dd0040879e679","tests/components/tricky-order/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-order/module.wit":"2c5a879b53f07d5303797086792978783e84baf964e0edb09b0abc12139476f9","tests/components/tricky-resources/component.wat":"61c7f212f183dd1f1cb037100f58f4b4efe99556fcae1a3fe8c8aadacc859b80","tests/components/tricky-resources/component.wit.print":"856955fb41792fc9c38d19de23968f5a4f180f28b73f267808e0305bac5bb9b5","tests/components/tricky-resources/module.wat":"f71be4ce8c2d1fe8c83dc8b58cd7e794132f7cf03995d6ac498256dfca8973dc","tests/components/tricky-resources/module.wit":"50b61106dfef6d7b81671b95230b1adf3ef9ca4c028a5a4f932c84cdda260890","tests/components/tricky-resources2/component.wat":"62edd5121214c3c0247bd0705b1662f06a5cdc758e4a20cf786aeb63fa52ef69","tests/components/tricky-resources2/component.wit.print":"a9cfae01ec4574576148c54c917c0be547c0a9a80ba1c76bb313556b80eff2e1","tests/components/tricky-resources2/module.wat":"63fc3214c3d4e4b36def8417cbc3aac44428046c2f212e14c3ba42acb79e29cc","tests/components/tricky-resources2/module.wit":"24df1dba85c4c71a4b8138b9add9d47a7291a82331f2ed08c3841574c668d36a","tests/components/tricky-resources3/component.wat":"8fc170f04c9417a75735b5829115bcc8567010b11fea765c072b40233463ca8a","tests/components/tricky-resources3/component.wit.print":"acf40dce88c3f0ba8ec1eb7c0058745906af2546808b5f87979050645470b803","tests/components/tricky-resources3/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-resources3/module.wit":"f00e678465c06ac4fd1ff7dbd473934c796e9251fcc15c604ef8bdc9ac870220","tests/components/tricky-resources4/component.wat":"95772b98420903e117bb87d0fe8e4aef50a57032aad2256b677f8a2fcd0fc9e0","tests/components/tricky-resources4/component.wit.print":"0cf3e863909bbff0ffd80995608d50bac03e716531ebe4b9177997e313ef0cb0","tests/components/tricky-resources4/module.wat":"acf798ec37ef20f52b1ca55a2eee9ea428d8c3a134a8450293c77b8ccdf56a40","tests/components/tricky-resources4/module.wit":"411499bff6c68c79f523d061aea6eb7dd0124dff7f1102dd7fa3561eb1acbb09","tests/components/unused-import/component.wat":"fc5cfba85e31292151061680cd3c04ffb16b946aa0fdba0e922e419865003f66","tests/components/unused-import/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/unused-import/module.wat":"357c1e05f5fcb82e7df5958d9709a75d693f67a8b8d31ab4fe09c413dbe79d46","tests/components/unused-import/module.wit":"ee373cb080a5c563252c18da9928dcf8a835ffc1327a7c1b5db4e15f4c44cf94","tests/components/worlds-with-type-renamings/component.wat":"cfbf49f975bf0c10c58392b1fcc6180934efa6adc44abdfffb5134367f788c25","tests/components/worlds-with-type-renamings/component.wit.print":"9797ffdd1f55149336e49a3f3370ec4b052b0b48d094af34d2e305b1e807033e","tests/components/worlds-with-type-renamings/module.wat":"9e0cfa9735e10a42efa429bdfab4e39791673d26ec574722d3eeadf1ef6e2de9","tests/components/worlds-with-type-renamings/module.wit":"5fa4355c6ec3249c4afc32207a89fde9c10be783a4e259243d9bb7bc4d1b5052","tests/components/worlds-with-types/component.wat":"41f5ce7143555c17ddfe7e612f930c8b6f28cde7c2995ae4a342fd571ab390ea","tests/components/worlds-with-types/component.wit.print":"08ec721da023042af8478fc61bcdb441091ea3b6efd7c26567a497e15cea451c","tests/components/worlds-with-types/module.wat":"b08d3fb1390db5c4ab3dea54eb386708fe25f0e875f5e08c3cc5af387a4e6603","tests/components/worlds-with-types/module.wit":"b86cc880c1cb138a26883b9e1d706b8506ba1c8f39b9b2722c4cbd02154b00e1","tests/interfaces.rs":"78397eaace0ae7501995f51bc261198ce04b1e0a169023acaede831ea3a9d7c1","tests/interfaces/console.wat":"65648a08a3be183053434c19e75ff12d4e8ba7b80d12e15e9daf797a44c33690","tests/interfaces/console.wit":"ae4ecef964695f02aed6412aa33125eb25d667984c24053303c02842c6952d1e","tests/interfaces/console.wit.print":"88664e999c44984e3f6e9a33a3fb1c8455abe5d9486d977e1a3e38cd85cd2d1d","tests/interfaces/diamond-disambiguate.wat":"0aa80803e0ee5aaf9d9410dc03a4f9e12ebfabf287d590c563fa5603589da7b1","tests/interfaces/diamond-disambiguate/foo.wit.print":"8c99834e2dff8e984b07f567555c02e8379d6fe9a9e8903e09c0a71cd3e1c7f4","tests/interfaces/diamond-disambiguate/join.wit":"4d85308aa1fa9445db47274a21ea5305043a5fbd2cfd07bd05018503ab9f2f2f","tests/interfaces/diamond-disambiguate/shared1.wit":"12156cefb18c81870ba266446874354a10871389361810efac7830ea0686f96f","tests/interfaces/diamond-disambiguate/shared2.wit":"fc790ffe2a771a13819976d1c56392e96cfb693e1589c757e0ceb8ae8a360dba","tests/interfaces/diamond.wat":"2996d285b348597d0a6b980167fce74053808e794dd1df9e48cc6efb234ae801","tests/interfaces/diamond.wit":"151c0be378c2ca19cfc97e55d820be7e8451817ee16fbec25feaac1332d25c40","tests/interfaces/diamond.wit.print":"7a6dc57ea3283fa22b6d38e0765f38bdd54f0bad36fb417f632144f073ca66c0","tests/interfaces/doc-comments.wat":"174225e7e66146c2204cdf9503fbc3f8b034599b37fd65904a79bdf7a57ec76c","tests/interfaces/doc-comments/foo.wit":"1e7267a6d075105b613e8ccc9f936a0e3747132e5d53697bb93d6c8978f9f68e","tests/interfaces/doc-comments/foo.wit.print":"93065d74520287e3e25647c005a193808661f5ad0592c5a9c37f05b23cf308a8","tests/interfaces/empty.wat":"d6144d67081f7139868791b76ca9016cdd33e07f8f18a7d02b35675849de1f1b","tests/interfaces/empty.wit":"5b69d726e29aee24abc73e2008107fff6e19c7e91bfb892ce91aeb022447fd33","tests/interfaces/empty.wit.print":"f887bbe0d82c8f23d3fc4d5d7ae44f2f7fd86ccdfbfdb89356c0363767b8ab7e","tests/interfaces/export-other-packages-interface.wat":"2d95d60feafeb9447b9c4117c98206dec84800d22313e8d42c09f80d2df2c2fa","tests/interfaces/export-other-packages-interface/deps/the-dep/the-doc.wit":"4e1596c661a7fac18feaefd556d3c148bba76ef748dc64623ca0e711b9b6cefe","tests/interfaces/export-other-packages-interface/foo.wit":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/export-other-packages-interface/foo.wit.print":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/exports.wat":"b2b7a63e5b9ef42ca01a586656be4cde48d44a4197c18c034c090801b56a9bd7","tests/interfaces/exports.wit":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/exports.wit.print":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/flags.wat":"1895f39b12260e80d872e28521d37e3ba4ebb2ceb321af83f79d11b5a22dc200","tests/interfaces/flags.wit":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/flags.wit.print":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/floats.wat":"c8fb2f689753e1e594f2b08e48b58dec55e4b0001dee3c2a35383d373b782956","tests/interfaces/floats.wit":"d3538bc1ad734434bc4b2ec7c152c5371dd8ea7db11a44cdd15ccec2b650b60c","tests/interfaces/floats.wit.print":"5fd8f9f328b5219350e2e9fd6ec483066b67a62238e4463142def96032fe584a","tests/interfaces/foreign-use-chain.wat":"acae7a8f76a913bdbb646a06bebec8615da6a5bc1dcb047715d5328e1e9a3faf","tests/interfaces/foreign-use-chain/deps/bar/bar.wit":"dffa233e1e0a2b35dcdaca0b62539776dd3bfb9662ee4b8cf9d72f4cddd2b551","tests/interfaces/foreign-use-chain/foo.wit":"51251e98cc66f75464b436f1d838a873e89713deec482480ae13d70458cce288","tests/interfaces/foreign-use-chain/foo.wit.print":"8bfedf3ed5380fa5dd359a9a3896421f67ad49f1c7b8d806eb6064b55092d21e","tests/interfaces/import-and-export.wat":"8ce79bbdbac052ba39e2d2d731f72736f277d3b88e0f763cd9c3db84a7386cdc","tests/interfaces/import-and-export.wit":"1dcbf7c373ca0c352bd45f444037170de7af3435a217b94378694bfd33b608fa","tests/interfaces/import-and-export.wit.print":"a6418b0f7bcda1e6055344cf39a438f7af0f7a5e3e3c067976e81d3dd4dbf961","tests/interfaces/integers.wat":"0c11ca08bc17c757cca9d2e42487c8394dd960a56422dcb62f4989ba93971ae1","tests/interfaces/integers.wit":"37d266e41985507c1c93d6c26a59efbd81893106f6d41b8a311e7c7fbae8dca0","tests/interfaces/integers.wit.print":"ad6949f8c87a60dd7e52028fd4bde7c6e8143ffea368a09820b5546b21408941","tests/interfaces/lists.wat":"090e004df86db95af8724a785ab0e17601d26025ce6cd0ebf089be7665b7a722","tests/interfaces/lists.wit":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/lists.wit.print":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/maps.wat":"8a35bc0ba86761018f92ebec8633dd8ee2a6923f85df365ac4808d4e24066c6c","tests/interfaces/maps.wit":"fd4fb91fa11798dc163bf2f1cc287300d678e37c2d027a50887230d906181a14","tests/interfaces/maps.wit.print":"858a732922eeaa6c3479f892bd106256e3ca01e228d63e6c0c67210b4a1f31c6","tests/interfaces/multi-doc.wat":"d963c737bdac1ab843e197d81f27b71c3a5e310a3dc180f54d777dca44a27e57","tests/interfaces/multi-doc/a.wit":"e596872a740320ec0cc907db0a0514f8bd06bba396ccfa6f0fddb5063a6d2295","tests/interfaces/multi-doc/b.wit":"60c98779fc63ee8932956245f4f62a817df1873f73a6d38170481bd2e0933bbf","tests/interfaces/multi-doc/foo.wit.print":"94f244451d55c2bab71e4b3624fd0101afa5169c881580337e7d4af020bb8426","tests/interfaces/multiple-use.wat":"f47557d866df570c5ad02935468f170c4373233f80f0500c054258a724a23e98","tests/interfaces/multiple-use.wit":"7b3a8bc783bb588205ec8a4a4ec6b16786ac11632bd8a8af6989340d454a231c","tests/interfaces/multiple-use.wit.print":"720be46dc70779cb31985c505810dc9324511e6adb33e64cd7d51a6c061ba7f4","tests/interfaces/pkg-use-chain.wat":"d02d6bdd9d2c1bfb2f5897f616fb74e6bb51cd5ead90fd11fab08ededffe4e3b","tests/interfaces/pkg-use-chain/chain.wit.print":"fecf679bf3d5f6170e3752e70e3e6ff31a62c76af934310a8481cae26f826c7e","tests/interfaces/pkg-use-chain/def.wit":"e5926171db9b958a935cf7e6c9dfb19f352734d037371515d17384fd04b89422","tests/interfaces/pkg-use-chain/the-use.wit":"fa84d92dd7d863acca588c216df4825d9735ec521f2c8df2f0088efc43126457","tests/interfaces/pkg-use-chain2.wat":"3003789fb7591388e83f8a3a953b006b9561d2af7e0b033dde2d3152438f9a02","tests/interfaces/pkg-use-chain2/bar.wit":"f070c1a8bd8a278e04b0b774f5f2f4f658c281b139d1cc2a53a38771997f206c","tests/interfaces/pkg-use-chain2/foo.wit":"9cda1f4b74d669259f0d47c0b62aaa866d0fce95a2fa23e7ed01b445092af758","tests/interfaces/pkg-use-chain2/foo.wit.print":"234cbdb61a134682163a460f2d13e70dbed3a21fcbdff211af1bb875e49bb224","tests/interfaces/preserve-dep-type-order.wat":"d02789cfff3c031bc45a4c596be9d42a2925a670072b9b691e94b87404eb59cd","tests/interfaces/preserve-dep-type-order/deps/dep/foo.wit":"07d8a31043f7acbda52d2a81da2747125855fde991e2e81dc0a8090aec1b0824","tests/interfaces/preserve-dep-type-order/foo.wit":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-dep-type-order/foo.wit.print":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-foreign-reexport.wat":"80eeae235f01940ca94fec2c1b9c4c0603b9794ff39b486de019f5e4b6250e50","tests/interfaces/preserve-foreign-reexport/deps/my-dep/my-doc.wit":"a9e7687b2213e6432d316100c8f063334ffa91c312bbebf6e7b953a07a38887f","tests/interfaces/preserve-foreign-reexport/foo.wit":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/preserve-foreign-reexport/foo.wit.print":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/print-keyword.wat":"e35164a7c713261bac2b9eff4d378d0bbe0eee805ff2acbf109644b7eee32935","tests/interfaces/print-keyword.wit":"e56669492ec53c6bef1cd14561f81c85117fa05199241cc2911f697ad75de606","tests/interfaces/print-keyword.wit.print":"d65ce208703b66a5975194a0937dcbaeaac680ed1531397c19b8a898928c6c2e","tests/interfaces/records.wat":"f9e0d53435c7769248c794ab5020253b9373924502b9c91a57888e6d254e2839","tests/interfaces/records.wit":"f16376667373eebc30923f6ef498cd4c53da0aee19697538d5ce2201aac03726","tests/interfaces/records.wit.print":"ff31d9c044473edec440a84f57be7686ad7e188459e37b2e2a65e0ee66305793","tests/interfaces/reference-out-of-order.wat":"9db73dc664f876c7ecde018eccea5d5a492e625af1426eaadab3f70f2869c8cc","tests/interfaces/reference-out-of-order.wit":"5f0eeaeeb9e1920fadba1b372b213138eaf9847017721dbfbd865c6f6b735ede","tests/interfaces/reference-out-of-order.wit.print":"a030a7125086f47bdd47b0a1342c7f7021d8e1543ef98ed1b2ebe5d10e375369","tests/interfaces/resources.wat":"551e5b1f2a2ff21581828ed33d7363ee578f06765df35040c879dc6c7be933fb","tests/interfaces/resources.wit":"ed38925057e1dba87722675326536f3e6dee6b3e64ef3db98fbe5fa4811150c8","tests/interfaces/resources.wit.print":"531fb60a5000c349d45153e41df87fc75358c71545a883c98eb87658a949cf32","tests/interfaces/simple-deps.wat":"45794a5e6dd232f0bf8599e4630fd13b6e2391bdba3a3fe930cfa692e8545d4b","tests/interfaces/simple-deps/deps/some-dep/types.wit":"e4f4f705091fd22a378aaf25c1a37035fe1dc9e4f29be0783733d8bc091a907f","tests/interfaces/simple-deps/foo.wit":"76fd1d55c5faeba3157ada8be1c83853ae1e72d8360c84b0d1b8f8b96d1e0dc7","tests/interfaces/simple-deps/foo.wit.print":"c2f307fd4af86e70abb51cadaa5e51ac6bfd5f8c9a91eb61f1bbc67c17554a57","tests/interfaces/simple-multi.wat":"6b16a64f1f5555e6da647f290bcfc9153bebdb42b9f609b46f37792c39271a3e","tests/interfaces/simple-multi/bar.wit":"e3f98501dfb46f873022dac93af2c9aeb007ea5bf0235302b072bdf2b1b5aa9c","tests/interfaces/simple-multi/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/interfaces/simple-multi/foo.wit.print":"45cea7bb704ea1aa2251e2da314dc3b931b165b7c84596e16c5b4c12200cb5b7","tests/interfaces/simple-use.wat":"1da6ead3dd378c25b096c2a70d8846da0a1810c68ecfcedf0727bd6c792c0070","tests/interfaces/simple-use.wit":"d4e734dd1a51b2224ea1fa965b48f39433e60ada1c2619c9836b81e061beb0d5","tests/interfaces/simple-use.wit.print":"1c91e72769a7ef72633c3e82bdb2f97babbf51961e3d10d177076340241cd277","tests/interfaces/simple-world.wat":"8f023d1da8b20a605f04bde1587eff63a88e45e0240dbcdd4647a84f1e993a49","tests/interfaces/simple-world.wit":"b8c42bd20d951065611170b28538430c76dbd492ddca5a2b63f6d85b229a62a5","tests/interfaces/simple-world.wit.print":"cb5ea537abb70459959dafd9c6114f35404f3a23219206f6e196e452c3f63e5b","tests/interfaces/single-named-result.wat":"a9d03772334090d597a595f38611a67630bd2c637b1b2cab7a79c3662b3098f3","tests/interfaces/type-alias.wat":"3f041675d23c6859523a79a9911826dd9174bc1e8b7f4633c7d827403b5674a6","tests/interfaces/type-alias.wit":"6cac4692ce0c825afb6d16e51fd9ecb3a7aa19756269b9dbd73d601511b3be38","tests/interfaces/type-alias.wit.print":"ff3093d72793ffc05b9c2f4ea55eaa86d276a869a3897c58f822443cfd299636","tests/interfaces/type-alias2.wat":"c67254788da372381e84a78eab4ef65104a59aec422da51cfd86ef6a67410a18","tests/interfaces/type-alias2.wit":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/type-alias2.wit.print":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/upstream-deps-same-name.wat":"86b1ee906d85fcb499c8dd64a03235f3b722b7936d436099f01ed0a60a036077","tests/interfaces/upstream-deps-same-name/deps/a/the-name.wit":"067fd6d1ce097bf27dd260114da6f690f5c54142d7b83fe705b98675e83336aa","tests/interfaces/upstream-deps-same-name/deps/b/the-name.wit":"17db81ac295fdc326bc0960166aeba6d2a86ffe6ae9c493209964098057f4672","tests/interfaces/upstream-deps-same-name/foo.wit":"5634861c80a39d59e3c72e26884487bda2ff6123a5607eb72e6251138f43891d","tests/interfaces/upstream-deps-same-name/foo.wit.print":"76cdc49cd35068d9c6d693550c951db74f588eb0d1bef27b4193093a95a3b802","tests/interfaces/use-chain.wat":"3946c5b08f739f31a9f737480e00a027924723130746b325234693318fb79c96","tests/interfaces/use-chain.wit":"9199d5f59616d83e82aebe22a8652e72c711ec962f6c0b53379c998fe4f64675","tests/interfaces/use-chain.wit.print":"ff129506878efb4f9ec1a441845c645ac63f4006e1e1d641d44c1e5d1667a778","tests/interfaces/use-for-type.wat":"e50dff1dacde278b34144745af52c6337acf001ba393bed4f7f162c913c92e41","tests/interfaces/use-for-type.wit":"86178e6002f460c78b43d9a51ffd13dc5795da4aac54e5f4592dfa11a430b42c","tests/interfaces/use-for-type.wit.print":"c899fc7b4f4fffa41f3abea7c0589f268cd683e6c4c5637393173af949d9b379","tests/interfaces/variants.wat":"3c8f5474ff599463212767650e14e3508d95ae670c6b167cc68026699f27309f","tests/interfaces/variants.wit":"2345402856850aae5db913ac40f01d3bac1ffddd4f2d794d4b92b44850354741","tests/interfaces/variants.wit.print":"63a6847094f8687a7f1cafd8f26a5255272386ae04366b5d247bc893ffe45d73","tests/interfaces/wasi-http.wat":"5442500a42b914985e143ee44dd60dfdf2df949d0d455b731034d604ffbd465e","tests/interfaces/wasi-http/deps/cli/command.wit":"5faadd6c6593aac09a85e8e22b2c842c81b4b3d0a04827195c50e0080ac94a00","tests/interfaces/wasi-http/deps/cli/environment.wit":"8d4f13e628d2e8f029f6d668d8075db5e6c8867238c0436cc966dd9a535148e1","tests/interfaces/wasi-http/deps/cli/exit.wit":"337522eb41c89e660b1dabc1bae362acc462f9cbfdcb9546e790e371580175a2","tests/interfaces/wasi-http/deps/cli/imports.wit":"37f6621e37ad9b15c616ba4289cecb549429cdb25a3b4ee3f80c47a5f04bafa3","tests/interfaces/wasi-http/deps/cli/run.wit":"50815a16aaebae4b99d2e2f9de69ddf30fc27249f41ad3cf477c4e796edf5792","tests/interfaces/wasi-http/deps/cli/stdio.wit":"51ce71cb414d1288b404367b4c05e38ade8b72f54811647aae37d871fadadea1","tests/interfaces/wasi-http/deps/cli/terminal.wit":"ba00efd140adfce72e1368fd92b6fba93a550129d2c8587a9f82bccd96e9100a","tests/interfaces/wasi-http/deps/clocks/monotonic-clock.wit":"3d2605e145081885768e23e1b37f5f065e28f0681cc3764fdaa60c35e74d2984","tests/interfaces/wasi-http/deps/clocks/wall-clock.wit":"35ac466a63c310151c228a313665fb30061c13b1954a7d6dead4c80fbe9f5b1d","tests/interfaces/wasi-http/deps/clocks/world.wit":"e5262f7b911444b28a98cce07a224bc8e7e9c42c175bc4890cf9d458d1d7d638","tests/interfaces/wasi-http/deps/filesystem/preopens.wit":"3374e193f60b3ff89708e56b37871fdfc9bb08bcbd3648a4f7bf20b60fe85169","tests/interfaces/wasi-http/deps/filesystem/types.wit":"9fc998c1251c38ceae23851af0a4f46874b5c456ca3240b1ff6faeec5f101d8d","tests/interfaces/wasi-http/deps/filesystem/world.wit":"45ca19ee54e4a0c9e8eca1d73f1e1e37edf00339b5c3e0f393f444a92733e708","tests/interfaces/wasi-http/deps/io/error.wit":"df792be377ef1ae9dfc186a304ae2cbcc091adb83bfb5fa5b9015fc232a90a9c","tests/interfaces/wasi-http/deps/io/poll.wit":"d3062e06aef89c8a2999067ccbde0c638459a01f30ba2073ac2b6458e0b9ca29","tests/interfaces/wasi-http/deps/io/streams.wit":"2aac4f0b81ca892ef07e9df54125082e266afb9ee2948b3f3f134ef736b8e75f","tests/interfaces/wasi-http/deps/io/world.wit":"1a67af673d0874b5a291a2b86721b1e4c1243127e8b2f6fa4ed954b13cbe87c0","tests/interfaces/wasi-http/deps/random/insecure-seed.wit":"617e58cc9fb5ae0f32cd6db3e72f959ee50f6abb8b9a0e10a5867ca2319b804d","tests/interfaces/wasi-http/deps/random/insecure.wit":"db8c140b96a99ca6e11060e2bd46df3c132f5e16b188f11e2767149b860d46a1","tests/interfaces/wasi-http/deps/random/random.wit":"5319685d7ec484d72660092f8db07c584d361d5ed0abb2893bba6d0724c20f88","tests/interfaces/wasi-http/deps/random/world.wit":"f1cc4028ab9d2ce215122946136a05b14b63225943ed8df86aefd5500bbd3217","tests/interfaces/wasi-http/deps/sockets/instance-network.wit":"ad100127c74b967064cf5d8e1770f6f0d787ef55f07ba9f6b334bc4c98c82282","tests/interfaces/wasi-http/deps/sockets/ip-name-lookup.wit":"aa9d95e64edfb9e954bec156f5ede95560a82ebc9ce80c01d475edc2f371d62a","tests/interfaces/wasi-http/deps/sockets/network.wit":"65c428e7f0d29a4dfb785996e88507ec185ae174a67576d3c09f852683d95f82","tests/interfaces/wasi-http/deps/sockets/tcp-create-socket.wit":"5beb6d1d604227a8e93fa2e63ace7ddee55b4048399046a9fecaee9d4352f684","tests/interfaces/wasi-http/deps/sockets/tcp.wit":"408d55fb8a3cc6971a02ce08a53f2864ec16487ea9f33a3c63b40ad90ee8acc3","tests/interfaces/wasi-http/deps/sockets/udp-create-socket.wit":"1e741a57683f834b12bca49c448cea4080e91b9667d50e28c8a823e2d6ca3829","tests/interfaces/wasi-http/deps/sockets/udp.wit":"01f359eeebb86826ea8f40d885feeb329a3272e439034aafab1e0a1e64ffa813","tests/interfaces/wasi-http/deps/sockets/world.wit":"9944b7b13f9933c0fed0768919ac4c8a8156943d0e82061277a28e0893f761f9","tests/interfaces/wasi-http/handler.wit":"96882590ae9934ca52f031eccc91704d0caf80c6b3227b6e1177e947ce135b24","tests/interfaces/wasi-http/http.wit.print":"c2f9bc786bbd0f91a8e38537df2437aa435867b2b9271808c562dd42b0e5487c","tests/interfaces/wasi-http/proxy.wit":"14f5c16f8c9f82965825fb138c2e317fa87afcfa731f9bfbaa5a02f9f3ebb1dc","tests/interfaces/wasi-http/types.wit":"b48cec546a901b55ed334edad747fb1298121a8e60cddb2e8141ff2187cdcdc8","tests/interfaces/world-inline-interface.wat":"d2c133fe41eca77fae870f5d912c17cad86ab9120419e2beaa7a20fe2c6233f6","tests/interfaces/world-inline-interface.wit":"929f431c2e5e14195de9645d75c79d243e65ee4c55a8e30a5ee1ae4c2e6014a7","tests/interfaces/world-inline-interface.wit.print":"36929a8a8a27296e3a183fa33fe95d243a6d20c4df055d9e5bbdc3bbce85bc0b","tests/interfaces/world-pkg-conflict.wat":"105a5cd5b89df94659c910e7511947c51f49f120f803b665cf69940c5f1c26f0","tests/interfaces/world-pkg-conflict/bar.wit":"4f05ba606e0c32c900fa8e9f9d75b137eedcb80999f454161492f52a452e8dad","tests/interfaces/world-pkg-conflict/foo.wit":"4be2c763fa6801e869aeb8da05cd647931f5f8f7775329555cd9cfd880dfe45d","tests/interfaces/world-pkg-conflict/foo.wit.print":"2ea3a7bc96c6493334d49893bc194a86f9e8fa7d592feac394c20678c5c1b288","tests/interfaces/world-top-level.wat":"80f160c0a98dd0003cf634d9d61899723c71ceda6c7f4ca330f791279154291f","tests/interfaces/world-top-level.wit":"10d04b8d9e0cabf534294ca5987f7523c042f3078048b5ebdf0b20f162ff9194","tests/interfaces/world-top-level.wit.print":"cf23c15ec84ad2c86d7124302c370661d13ab93bbd29e5456677a72148079339","tests/interfaces/worlds-with-types.wat":"e6e4a4527933316268841efe6dff6422212668a79077b43ab476f984ab4c7b19","tests/interfaces/worlds-with-types.wit":"cfa2f8bc82383337e9ae80d2bf7f7c59160642b38137367d8e8bca61d24fad3a","tests/interfaces/worlds-with-types.wit.print":"35a5376b6ad4c17ecee2b99fae6be4ffbddc766e891a4012eabc6a303cb0e1d5","tests/linking.rs":"e23feee175162d6758ba35706e92558546603fa5ed370bbee69cfd76d49c7b5e","tests/merge.rs":"5679426b2585a0b57597d2204c9b46e0b05b8f016dc9f438a7dd3eaa0bc7ba49","tests/merge/bad-interface1/error.txt":"98c2b73a27df07fe64cf3cbee106a82f863ff01c9bd7aab19345d2e33bf9971a","tests/merge/bad-interface1/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-interface1/from/deps/foo/a.wit":"8846a4d47a3a4ea7adec3c75dbfe5f7d95a33f550384d60f5ba57c986cebb0f2","tests/merge/bad-interface1/into/a.wit":"3bdc7af80295ca1761b46d4088bfe63323d87b5ce34ba91a5f86b74dd9daf381","tests/merge/bad-interface1/into/deps/foo/a.wit":"94b2dfe771053f49b3da8acdc65b2e0cd9d6b62c9ace43d7e383f67c3258ccd5","tests/merge/bad-interface2/error.txt":"9bc249e46b3bb5c88cdc9b560b83cd83cd22ef7816fc4f271bdff6627db16b0e","tests/merge/bad-interface2/from/a.wit":"a6647eda48b26b8815a5c96c0d2f492751c50575a61a1b5370f631a1dbd6d6c1","tests/merge/bad-interface2/from/deps/foo/a.wit":"de74c812c40393d061efd768601f8747bd61f7d06d59ed260d9c7da5767eaef5","tests/merge/bad-interface2/into/a.wit":"dfe8e3f49c0e9392a85ce7d852d359728e62465d923e296d4594130110864861","tests/merge/bad-interface2/into/deps/foo/a.wit":"faa98d1f0516dc30b55a1d7c3187a4de73985aac1952d275f21476451310335e","tests/merge/bad-world1/error.txt":"6db444c11f4be2e33e0c2cc6ae98a3d59711e0957c291861eb23908edc65b06a","tests/merge/bad-world1/from/a.wit":"d8ab0c1f6d0a4e566442e4af8ad10d44b033ad928232e3e769862a0091af31ed","tests/merge/bad-world1/from/deps/foo/a.wit":"e49da20e2cfa3484864737126b569e4724fac826ac83e0bb418b801336b37062","tests/merge/bad-world1/into/a.wit":"6f6bd76d039cdc1754c88dcbc57f83cd75ca514481930c013cdb1536add4d78e","tests/merge/bad-world1/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world2/error.txt":"82ea5309efcff50f4b73843f46c28c45ea17d9f3b74415578fd0449445ee8a4e","tests/merge/bad-world2/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world2/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world2/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world2/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world3/error.txt":"7ce381053e15ac8978fb690eb0eb9f0d9680e6ecad007b3ae5ac273ae2e2755b","tests/merge/bad-world3/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world3/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world3/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world3/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world4/error.txt":"b87d169ad53a2cb5de0aaa38e365085d5ba472f3a5593cd448d1d2aba76e2df4","tests/merge/bad-world4/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world4/from/deps/foo/a.wit":"9af9c4ed27a130ce0ea282613888d4bff0a8d6d1c36d91ac45ac9528e2b74284","tests/merge/bad-world4/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world4/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world5/error.txt":"5cdeb66fda055177c3a3acd8070e891476e12759204cc9288ca89beb0cce1cc8","tests/merge/bad-world5/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world5/from/deps/foo/a.wit":"88c8bdbdcd401558214342070b09bbc8454593d682b43de8d7ba6fec98512d42","tests/merge/bad-world5/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world5/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/success/from/a.wit":"9ba239a15824020109d3b7b1b09ff2463a91ee83f174c85acbf08dacaeeabe90","tests/merge/success/from/deps/foo/only-from.wit":"3cb85cffd8f2060149fc6dd2c42259be0af125602cd1f56ca6aa7b3fe5d101b9","tests/merge/success/from/deps/foo/shared.wit":"d75dcff4825dee46320dc97ae6b005c5b43cca83a48bd9c932d2f662e29793d9","tests/merge/success/from/deps/only-from-dep/a.wit":"013b417cdcf40b3203ad2c4a4b2c3d3fdc0930eb05b5095eb03adda5888c6c12","tests/merge/success/into/b.wit":"d46f59c41f4a1f0deb7ba9dc4a30fd68946e4dd228520d0aa94e53771ac58b2f","tests/merge/success/into/deps/foo/only-into.wit":"afd48df694fd9f6be69f123ef0054ebdf54fe40f9de27d3ebd4829f6d3ce2a4d","tests/merge/success/into/deps/foo/shared.wit":"0a2dc3ef6f40a80c125c88a1ef50f7a29ceafafe0a33e6276fda021b43339557","tests/merge/success/merge/foo.wit":"a31a3fb1eee5ba150eff17968de545939a75cf62216f1e634bc319ab0e5eca69","tests/merge/success/merge/from.wit":"5d4ae81da25de51544367675d0d35447959b9ffd38d1addc71b3de43cec2256b","tests/merge/success/merge/into.wit":"f634f6316a61eb8353062dc590bafbdc382b5b660ff47a2fe57a096d37027aa6","tests/merge/success/merge/only-from-dep.wit":"bb258879aa337563aca3efadef46d4267bcc6a364fab0f7b0c83b1ca40646eef","tests/targets.rs":"817c3fea4f0a13f5a162989daa3e77cfe840c61e23039a66874a413bc17f2d76","tests/targets/error-missing-export/error.txt":"5c4f40d87595312b19585b2aaca07212c99a382228c309684c1911b3599572b6","tests/targets/error-missing-export/test.wat":"ecb067df02eb0320a0fdca517e1ed718449f33d6f374bc0c7663e5f142edc074","tests/targets/error-missing-export/test.wit":"3cc01dbf799565f81074bdb2ed9d274ed682c19baeabed5a5422abad55825fa1","tests/targets/error-missing-import/error.txt":"3a666ba746184ad3a04c2f0b7212b26eb4073ded44e887cbb9afcf4c19ede11d","tests/targets/error-missing-import/test.wat":"ba8745404917b9a0900d70377212510d57d90d700002811a826779acd39cba19","tests/targets/error-missing-import/test.wit":"621baefee52d35a98e0459b53abed57ff75969e0dd95c6e7866949e215503c3e","tests/targets/success-empty/test.wat":"fa69abd0e355ea21aeaf9cd3b36e1bf6a4944ee9df0be50d1c764b43eaa1dce6","tests/targets/success-empty/test.wit":"457c6efac7f9d666c5fbb4111fa91b26cb38548be1da2c7c1c0ea89d33cfd5b1","tests/targets/success/test.wat":"bff481f132e976f3ff757f5816e58c79ba7ffabca76184452e048cf75028896e","tests/targets/success/test.wit":"467f876c7e3b3b698517c2df8076bfd1f27cf4764841ec7b1f91f143c8589da4","tests/wit.rs":"160fc7aa322c26d2e6eb58d2eff8eb06f583f34a5f2c6b101bcea67d200910a7","tests/wit/parse-dir/wit/deps/bar/bar.wit":"2319c45fbe264470daeff5718eb5e6cac02ffbbe59af4c14cb1120e401c9dffe","tests/wit/parse-dir/wit/world.wit":"10cddf5af787eb1d0e67e46cca8cab5c3d407ff9cc75f377641dc831153163e7"},"package":"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"8456162b205395e1ccae297c7bff238bc11090019a7807fee70463494697bffa","Cargo.lock":"5fff8966384cc2e3f5f19866742d4b8fd536e64f4cf37963b965f000f3579440","Cargo.toml":"8142ea1fdeebc373aa1ef74dbf068351b2995b10ae9629a758dc6ece35f2fffd","Cargo.toml.orig":"eda00a1d5a187c31873aee6413503278a16d865a2d25c3872fdd7a4281b1c3ad","README.md":"00d3b7547efc420a28ce22afd6d9f29f996e2a972ee0f753f988ee26e54ac8ea","libdl.so":"6d6ea03a4a671db91be183077b6665866106a61c84739580773a7e5b6bd9f256","src/dummy.rs":"8ff563ef71fd4b090ef65b11d4311386e2d16c08769569ab2809d5c207d42f19","src/encoding.rs":"44026b8332e9fd8db97ccc4e685d8bb224fcbc63cb98e08ddc3928be4dffb901","src/encoding/dedupe.rs":"157abfde68d0c0e610acf399b0bb5efe7dce66197b513922cac85ea28004e9e5","src/encoding/types.rs":"b7f25629759c3786351fda2867409da8043be0ed4bfa8ff17d89ed285c8d2670","src/encoding/wit.rs":"dd8abb983f7a3e2499db41d6aa21733758e2cdae3805af5c058063adedcb4c2e","src/encoding/world.rs":"a8d2bf823a5fadf248cfe13e19ac56ad7a63974334518a1f2634251aa44ae2f9","src/gc.rs":"e731ef0b88c56c9cf99b83ee1a9fe6f085b8744c394f2bfc6503106390e6edb0","src/lib.rs":"25a5d6af36e1f9f6fa405e0c67a3736420b310e73f9eb7c03ed520a81515a2f7","src/linking.rs":"bfe049c0138b647a80cd4dbf1d8a926053e6c4f59a3bda702d82670a4cb62e7e","src/linking/metadata.rs":"33899abdc312ff16ea28f016406c2aae75fc24ccd5ef7b2e4bb62aec3af08102","src/metadata.rs":"ddfa0af7c35a410cd5c64ba81feef28dbcf078aad736508ed69c71d47394617c","src/printing.rs":"92311a35a001157f12212e41f21d3d559b7e8219bf38be4bf595f36777855c7f","src/semver_check.rs":"0f1b26ac481daab44aded3150ecc1d50f38d648ebf9c3221da89072f23a995f6","src/targets.rs":"74531ecd7e1b1afa30ed24bb6340b430f1b2e1679ed80bf61894b018b4eb5f8c","src/validation.rs":"870632e0223dd980669d1d75560962502163745f54d53d086df5b0796e2da2ec","tests/.gitignore":"56290c87f8681b45f1bc1842ae3943204a6d40e03915268c99359c59c5a5cb5d","tests/components.rs":"78ba10ec0049026d5aebd72b7f651c258626c5fe25cbde4c0015f16834ce1971","tests/components/adapt-empty-interface/adapt-old.wat":"3a6db296d593ac422b4132714267a678490528f5299e3b263291fdcbd7d35b1c","tests/components/adapt-empty-interface/adapt-old.wit":"c04b693fd79794d910e739efa5d8356cec96e0b68df00b3fc21945f68a57cc4f","tests/components/adapt-empty-interface/component.wat":"fca49ffd58ca913a5d740e2cca9b91028f994682ae89c4e3267c0e624c616316","tests/components/adapt-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-empty-interface/module.wat":"e2f2a12e798371295a81cb05092d9164b37545d89962891759e0bd4728c3866e","tests/components/adapt-empty-interface/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-default/adapt-old.wat":"fe2824af7a5061c880d378a418796db230831b7cf50704a42e15c6dd2c9e6258","tests/components/adapt-export-default/adapt-old.wit":"71084c4ee7c4940876553129fe1b519e8eadacfdd3cdbf1cc640d5f3c5aa8831","tests/components/adapt-export-default/component.wat":"976fe1e9be2de60268d70c31ea15f59fdf9824ed411cb14acf1aeebd09d3390a","tests/components/adapt-export-default/component.wit.print":"7898d8d83177c3b78be309e32203a439946ec2765ec849ba9593c7703efd54dd","tests/components/adapt-export-default/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-default/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-namespaced/adapt-old.wat":"a5ba577bd703bd03fa961655122b46d2ef4ceb06cf851a3ba05e235b477b3cdd","tests/components/adapt-export-namespaced/adapt-old.wit":"3efacadc9fc5ea5997f0a2b468588100a1af780a6f43f09027b1999b5f04bcc9","tests/components/adapt-export-namespaced/component.wat":"865312e1ef947db62bb1856c19650cb5dc7d36de55e9e0d79263cc68d9bc011d","tests/components/adapt-export-namespaced/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-namespaced/module.wat":"8318fb33e37e0e6272ca8d25175c22db8d8c585cde1eb04210474b72bdb561d9","tests/components/adapt-export-namespaced/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-reallocs/adapt-old.wat":"9db1b4fbaf190e7e7fdea1caf291ae0e833a687f37b396096c6f4b7735491109","tests/components/adapt-export-reallocs/adapt-old.wit":"9cc7430d32be94c362abe794a4b356c470d23ecb6971de030f9b411c612352c7","tests/components/adapt-export-reallocs/component.wat":"caaf9904ead980403b632431a38bb6e64a461a531d03162961f490890c8430c3","tests/components/adapt-export-reallocs/component.wit.print":"82b6fe5b0953b68beee20d7f31e53712ec76f9f5d7196a2dbc57ac59a68c4096","tests/components/adapt-export-reallocs/module.wat":"53c738018c3b15fc3c7f21f1b8b5443c7afe89c25b08e7c56fc45a81a90627a7","tests/components/adapt-export-reallocs/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-export-save-args/adapt-old.wat":"60a41275befb6be47a8618fed9f3e1cab5b0807864d83e25bd84abe17d7579dd","tests/components/adapt-export-save-args/adapt-old.wit":"ceab954d883cf0c7d8c4cb28ce0bc641b969f8d0fda0bc411bc6fed8e553d220","tests/components/adapt-export-save-args/component.wat":"67f09c119ef670e3d478081704470b057d10a5f7b82016df4870dcf5211b1099","tests/components/adapt-export-save-args/component.wit.print":"6f24d727c36366175e949619aa8655755c6fdea10dda4770a30d0b366c877326","tests/components/adapt-export-save-args/module.wat":"6c7d1c7ded2d891fbbc9b778523905240c63bdc281aa4736c13bc01213d31a8b","tests/components/adapt-export-save-args/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-export-with-post-return/adapt-old.wat":"86ef0da2b6687532011de1aaac54add6150a43309b3d61a4e31fe37a5df6765c","tests/components/adapt-export-with-post-return/adapt-old.wit":"db342b3d869e263bae40fee459ca55736449430b255e9ef5bf6062a1ae3b0275","tests/components/adapt-export-with-post-return/component.wat":"f5ee8419b25645958d64c78613590418c8704f7663a4858dee0bceee28bca9b1","tests/components/adapt-export-with-post-return/component.wit.print":"869261a145f6337aee4fdfdadc22f123784b8cf1839deecebda0607f5883f24d","tests/components/adapt-export-with-post-return/module.wat":"a4e32bd0b2fbf43172da21f77d747ca1d8bef7779e9f9827429bdc114e62d63f","tests/components/adapt-export-with-post-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wat":"74d4a3a10e95b0b9a40a5269d3c28cbbc1ea1ef0ba9414497d2b1fed8648e510","tests/components/adapt-import-only-used-in-adapter/adapt-unused.wit":"9202e95a58f5d359c9c4f60dcbc5973fabc19915dcadf1d26e2324dda312f5e5","tests/components/adapt-import-only-used-in-adapter/component.wat":"74313f64cba93d7fe6afcea089730eefc24565976bb9bc9b9d71462ead3377c7","tests/components/adapt-import-only-used-in-adapter/component.wit.print":"9dbf66812387cd9f17ea903de18c0bf6ef6308bac6bd9db747f6cdd962b27497","tests/components/adapt-import-only-used-in-adapter/module.wat":"1920c02ae4d6c6c12ca57665e88ac039bf845e05f9b8628379cada9efff074ed","tests/components/adapt-import-only-used-in-adapter/module.wit":"ec9a35c247c4354e6960e3e8801c9aab4b9b5dd57a77fab348991b016b0f6017","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-adapt-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-adapt-realloc/component.wat":"a6ee87c556eac0f3d2c01ee2eb1f621e01e61abafe6b3f073507144ee3c4fa5a","tests/components/adapt-inject-stack-with-adapt-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-adapt-realloc/module.wat":"623ad5e85f4ad4ea9c3480df598dbf1e8d50d7d8bfee01aa9b425550434b0160","tests/components/adapt-inject-stack-with-adapt-realloc/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wat":"2102c5772be78a8a907be569aa0d185f0a1ad767e4d601a27a1b870151f892ba","tests/components/adapt-inject-stack-with-realloc-no-state/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc-no-state/component.wat":"93c7d16960727e35915b81091c79c8f2906bc36a63cd21d64ee42e2a4caa0254","tests/components/adapt-inject-stack-with-realloc-no-state/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc-no-state/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc-no-state/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-realloc/adapt-old.wat":"d7d78f6a6faa80d753c3652e9f7308691b9865435bb58338cb5479a66531b32c","tests/components/adapt-inject-stack-with-realloc/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-realloc/component.wat":"5e67becee53a51ae1613af0389c1952b12481b5527fffaed1d6f9ed7b72297bd","tests/components/adapt-inject-stack-with-realloc/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-realloc/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-realloc/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wat":"f45808f40cf534bc765895f472b8f6b9880c8cfa450dfa30d3b9c20cede292e1","tests/components/adapt-inject-stack-with-reallocing-adapter/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wat":"f86cc7688639f35f5c618affe960325a916c0b01e6ef828b44737a03d4d15f81","tests/components/adapt-inject-stack-with-reallocing-adapter/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wat":"e621bdfa14156e5a2e56caa490199210d7c52fa36dd45358a770fb9ea6ccedad","tests/components/adapt-inject-stack-with-reallocing-adapter/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-inject-stack/adapt-old.wat":"4e61aa8171cbdbad0049d86bd37dc0c2ef1d983e245eab080b4006e453512e0e","tests/components/adapt-inject-stack/adapt-old.wit":"1a7aba0f1fcde496e270312e2bdb2698ef2294e08e6fde76a020b93384208d38","tests/components/adapt-inject-stack/component.wat":"63913d6860e01446c3b5340c6cc2d71b29e6a5e04cae3d38ae75288725382be6","tests/components/adapt-inject-stack/component.wit.print":"6d62ef9cee468203d47d75233ed693b7205eb582da5af1872d61989def1826ba","tests/components/adapt-inject-stack/module.wat":"7dd9f65faef528be9924ecdf40f0b05cd63b365f70761a31ff58afbe6629d98a","tests/components/adapt-inject-stack/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-list-return/adapt-old.wat":"d32ce421ec76960c676a09af5dbec9841d3b24d0dc8f8553f2b62d6b010707e0","tests/components/adapt-list-return/adapt-old.wit":"fedd6dc412b5980b85d901a02003239d23a6f5b935266f9e28278b0d09d66947","tests/components/adapt-list-return/component.wat":"1499ffc6fc636fc6560f01050c826a38d26120f9e501771714905143f12de04f","tests/components/adapt-list-return/component.wit.print":"3840662862e417d02278b78c1cee0913e95bec39416e29cf679e2868d8d52528","tests/components/adapt-list-return/module.wat":"73e71115facdc70bccaad35d84b1b7efe3c9ef1c53e554fcbb7cf6a47550621c","tests/components/adapt-list-return/module.wit":"ab7cd817d0529de0e1d809a3e1ab8f22208697730f4f1c1e6daf6d73b49762c2","tests/components/adapt-memory-simple/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-memory-simple/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-memory-simple/component.wat":"d4d9a4ce50eb25fc7da3b9cbf0fcde90b9bfaedef4c184a7539501a1d4e88582","tests/components/adapt-memory-simple/component.wit.print":"a55daf78c190d92eef7b04a67a6115cb15a9aff7afe5f56311eb9463e72edf71","tests/components/adapt-memory-simple/module.wat":"5fc3894c9ed221c7d0059752e6f37610b37dc8452f9d08012cb62c93357d6f66","tests/components/adapt-memory-simple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-multiple/adapt-foo.wat":"360aac53ba20c06b70ccbb17e6bf0abbd6c4256169e63983e0e16179d1b36645","tests/components/adapt-multiple/adapt-foo.wit":"cd76acb12ae0816ce116c5bf5e58fb6fef2cc3443c9d02fb9f166d71c7012d31","tests/components/adapt-multiple/component.wat":"9b59aabb6c55164d8ae24cb2e53307a2041a287a5bc7c3863ddb03b5243320b5","tests/components/adapt-multiple/component.wit.print":"a692a4e2fad55770689c501f3ee858e0d6a82da6306ce8c1ae67b9384004e819","tests/components/adapt-multiple/module.wat":"09c98f0e426797ca22bac7c8597e2b2299162642a56f9cd11c1791b8990c92c9","tests/components/adapt-multiple/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wat":"2d13becaad0a248f4b86b740e11c53b25e131c015a058cec83f35f03b1529552","tests/components/adapt-preview1/adapt-wasi-snapshot-preview1.wit":"8b084967d2be4bbf24735fe204fd7a5141f6c8baf4939aa033563fd0643509df","tests/components/adapt-preview1/component.wat":"9dbe467777d360124849e44a6f11899ca69db4aeb155d7fd53f60aa1755bdd1f","tests/components/adapt-preview1/component.wit.print":"5d4f747617d4e49467d7ab1f831a859531f38ba8fdbf7bca6af91f1e3583086e","tests/components/adapt-preview1/module.wat":"6d3d0c452aaefde1fbdcab22b2207c3dfc91cf3b7ce2133414090fc770a16bd0","tests/components/adapt-preview1/module.wit":"0207b70f162393b9976640b7afb83470fc815ef69d58523a43e9ffd4997b0f67","tests/components/adapt-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/adapt-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/adapt-stub-wasip2/component.wat":"f64740e5a017765e3bc8e791127689aff0b47839eca137910491960dc421199a","tests/components/adapt-stub-wasip2/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/adapt-stub-wasip2/module.wat":"67ef212810041d77c3db6df7fabe3d52dbf063a963433a7a478b02f641f83323","tests/components/adapt-stub-wasip2/module.wit":"6e2cbac25c8c2d1120f26f1c04d01cbf3d7578ef759e0b599c6c23c535ddb20a","tests/components/adapt-unused/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/adapt-unused/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/adapt-unused/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/adapt-unused/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/adapt-unused/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/adapt-unused/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/async-builtins/component.wat":"1f480263d84e78f6bbd563eb6ff4469d4869e75f8ec129b3904316d0d662b88f","tests/components/async-builtins/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-builtins/module.wat":"bfd0ce1103f232f0593735b45f069d81ac006c0126ac2f16a970c50c5ee1d383","tests/components/async-builtins/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export-with-callback/component.wat":"58c5f7d4687125e5b0363373f322fa01f81531607fb95e33b493733ed33ee1eb","tests/components/async-export-with-callback/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export-with-callback/module.wat":"38d85c7293b53c0b6fe33192f048b78ee60251dc63106c9b74e0ea314e75f90a","tests/components/async-export-with-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/async-export/component.wat":"fc439f383bf912477408772aa4a7fe130606921798fc690429ba263b4f63190e","tests/components/async-export/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/async-export/module.wat":"f239da1438442af8f76ea2067cd25c7abd14af474e304584e92f749eb2c05e17","tests/components/async-export/module.wit":"bdf4e2c172d5eadd8f785e7e467655e3dec8eb98101cb84532c8eaace201b75f","tests/components/async-import-only-intrinsic/component.wat":"661f847e409d1dfd62694ec2c659731ab226078d2490a19f64de4799aa8cc60c","tests/components/async-import-only-intrinsic/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-only-intrinsic/module.wat":"d739e805be3be8e4594cf3551c6ab32f2550264047535e0dd00e96ab7303f886","tests/components/async-import-only-intrinsic/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import-tricky/component.wat":"59139c14308ce67e8b3348d1c77bb7826b1d5e744cb90d495b2e2012ee432dea","tests/components/async-import-tricky/component.wit.print":"d72c0077b57005a82a04181f4de5a19d0a13f342e51f8ae39c16df0200ca4e2e","tests/components/async-import-tricky/module.wat":"6adce7213ac96e7fcae050279d5e7011b92aeb84fb8160565ef904bc167bf205","tests/components/async-import-tricky/module.wit":"a67e614f426d01595a5908748223980e6b71e7ae71e9bb55c7954503a4fa5883","tests/components/async-import/component.wat":"3276ebf1556e6715bceded460db3e4531c0fcaa305d0afcf212b26bdfea5b115","tests/components/async-import/component.wit.print":"f17ba3097a41cc0faefcc85611f316be96d7bfd4f67abbc93963daf2c04cf2d4","tests/components/async-import/module.wat":"5f5894e70f438a461441d85203a948f3e5accaf8cc0470195d5b18f8547129d8","tests/components/async-import/module.wit":"31a71ad2c3142b71c67e87c6149efadca1e9ef6262d79eadc88ee2ddd8407203","tests/components/async-streams-and-futures/component.wat":"40a857b7d40ec7046fe7773319393e8dcbb1f708f6ef7527744a12bde1267b4e","tests/components/async-streams-and-futures/component.wit.print":"fbf4aae8ea7d2c661f42b5508e7617eae0e369092941104e5b33d01df04520a0","tests/components/async-streams-and-futures/module.wat":"bacd5dfec7a79670bc135eeb42bc3da07835686156058e9337f2740ec9658028","tests/components/async-streams-and-futures/module.wit":"21bddc5f549b3886d0f2ba9cbc838e5ecd29b1fe2d6a559bf4f44dd634f6878a","tests/components/async-unit-builtins/component.wat":"a699b5191cb6c6e394e642fd194949fed3a5eec7ab908ab664902fc1d1b24f3a","tests/components/async-unit-builtins/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/async-unit-builtins/module.wat":"c75ea94e991400e50800712542c8655d038ad82f42eb87e8075f58e8d4bd22f6","tests/components/async-unit-builtins/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/bare-funcs/component.wat":"b1e1026a7e45f7944d426823cf162682776459fcbbb42590067fad56723f616e","tests/components/bare-funcs/component.wit.print":"44142a3e54179c58231b1406306664b56e708d091373d4c9d26f8a8836fb19d5","tests/components/bare-funcs/module.wat":"eeacf6a9a06818a3dc1938f3f7e70d49e34aed35b6ff3000194b83b310757bba","tests/components/bare-funcs/module.wit":"cfb306074d962ab1cd345b9146c19593efcab6a033b350f809eb28be53a5b709","tests/components/cm32-names/component.wat":"c4e1443a880ebe01ea12a930726c29f3f8f572cba802b0f849791fb0929876a2","tests/components/cm32-names/component.wit.print":"931313d8c16524f0a195235a8acb74332448679069f426535773aca17354c6e3","tests/components/cm32-names/module.wat":"2377a85fd01e55a6fdb6b91b8074967c86f00a565a4fccb0ae3f463dcafe2c03","tests/components/cm32-names/module.wit":"9512314374f9cbd23730915c09c154e48deaf6741013e8d32e22dedae556aaec","tests/components/custom-page-sizes/component.wat":"3eaa8c9790617a9026c077489ae93022ae6e970577e37ea5d850abe90137f22d","tests/components/custom-page-sizes/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/custom-page-sizes/module.wat":"735787796014137b07df0a6c8a5f07b6f9c202440111456ef4b2224b60583b1a","tests/components/custom-page-sizes/module.wit":"2e6ea2c38b49574cd8f8303204067e2977f695925f161c9e68002cd1fee842a0","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wat":"3d96dada383101358bd8985bcc1ff9956d8a50016607914182f205f777a4ebf2","tests/components/deduplicate-imports/adapt-wasi-snapshot-preview1.wit":"f4d3eef4cc15bc74a4d9d7d045aacc81be1991b4bcb184d587e2048a983035d4","tests/components/deduplicate-imports/component.wat":"41496495e2e28882e71d39822a7e8e798ea636e8b0050296320dd7f84eb497b0","tests/components/deduplicate-imports/component.wit.print":"bfc18ec3026ea7285c88bb8da1b4dd5d77db4e41fff8a8f0f26df9656a18ae8d","tests/components/deduplicate-imports/module.wat":"11693ac57d19f8388286897e8a3b3b4d2d18c9ac92ea9cee5e9559038818ad30","tests/components/deduplicate-imports/module.wit":"ebc9fa1a6bf412c67ce4dc481a1477500a902b56c5f395bf5618c4a14474485e","tests/components/empty/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/empty/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/empty/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/empty/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/ensure-default-type-exports/component.wat":"a7991c6b578b95b41de82514cac59c4aa19b46d6341f244eefb16f4bffc77491","tests/components/ensure-default-type-exports/component.wit.print":"baf9b735b1f9dbf8e247064d5735bb8b37fe53f6f1e9bd1bd154a991177e1b54","tests/components/ensure-default-type-exports/module.wat":"14a179f41e4e06a59b4e34f0815ea34e12ccf1f8500bccd83623deb84c71093a","tests/components/ensure-default-type-exports/module.wit":"36353bc5366252cae33912f215d77dc501384cc9606dbadf5fc831b33376f3de","tests/components/error-adapt-missing-memory/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-adapt-missing-memory/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-adapt-missing-memory/error.txt":"d8491054cdabd0359c1ece02710db9f5989eb58c43283e73dcd0401231fdeae3","tests/components/error-adapt-missing-memory/module.wat":"a09c5c2e4aea7fabae1df7f54791a87061018325968a3f9379d35e3ce2cc405c","tests/components/error-adapt-missing-memory/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-async-export-missing-callback/error.txt":"53956038fd6dc7921e06b1217ea0bb21ce8fb43f9dc6ca42ef5f069793d6d899","tests/components/error-async-export-missing-callback/module.wat":"89ced8e40f2175f16f59261807e23b05dfaf326231873a6f011fc4b765fa86b6","tests/components/error-async-export-missing-callback/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/error-default-export-sig-mismatch/error.txt":"04dac125afd8c985269ced00b248d43cb7dc96f8a52dac2f3103c260aa86f856","tests/components/error-default-export-sig-mismatch/module.wat":"d61b464c502b1af9fd83b5ff5339ac45d2674c9455163bc7a89a02fb5454f878","tests/components/error-default-export-sig-mismatch/module.wit":"5d093bdde43c050d69d2df8b034d66ffa6c076ac4c83b26ad7e9cc78ef49dd68","tests/components/error-empty-module-import/error.txt":"98053ec5a972463d2c9411c82da5b2fa95e24099f6e6c61d355212d46444e8a4","tests/components/error-empty-module-import/module.wat":"a9e2a33d4affd7e94275daf7dd6475c71135de2359343ab0568a3fbe7204a527","tests/components/error-empty-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-export-sig-mismatch/error.txt":"a90a4c7f4f88369d8cd30673fa8cef6628f5eef68bc626a225fab11aef056d5e","tests/components/error-export-sig-mismatch/module.wat":"4d7dcefb19126be4325185e99fbd3f0f964947e8bce9cb4254dd153da60a4e39","tests/components/error-export-sig-mismatch/module.wit":"775d9b931e1644f29c0124edb264af4b6c9ef9417c3abcaa2711ec99b809b85c","tests/components/error-import-resource-rep/error.txt":"19991af81b6006ae5d7f1f92f945a8c4debf1e82069ee4a67420df4fd6de8f5c","tests/components/error-import-resource-rep/module.wat":"01c719d6eb94c6e3243e04425c6eee29f5afa86d7de59e0231412190385b3759","tests/components/error-import-resource-rep/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-resource-wrong-signature/error.txt":"3e2a1f3b231bd148cbfec7108af76d5f61d90edd5454c0974f0bc86c6049002c","tests/components/error-import-resource-wrong-signature/module.wat":"9f921559b46bffc7e412984c49395cbef1b723e616cfedb5ceea6784b70471e2","tests/components/error-import-resource-wrong-signature/module.wit":"9dbf3ad66ed4cd913521b98dcc1eb51780671de15a1d2f3da86fffcc59a9a906","tests/components/error-import-sig-mismatch/error.txt":"b3364c1047649d851a0ae1d80332a6df1b34504a8519a132c68fc1855c7443b8","tests/components/error-import-sig-mismatch/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-import-sig-mismatch/module.wit":"d98bced030198058d8c1a6e77161ef9a1e3871f8f2c539a618aeccfd4cc19b1b","tests/components/error-invalid-module-import/error.txt":"f8359fe5bc543bda23293a6f8d40b1d96d9dd6d0d521e538113c0b69ad5a0d6b","tests/components/error-invalid-module-import/module.wat":"20b107a75357922999a6951562cb321ff63926ce1011cf724da12ed1b2c86ac9","tests/components/error-invalid-module-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-link-duplicate-initializers/error.txt":"05be0b8139892df6dac079ba7726fce46909ed661bc4367644c9c6ee7f7c8b3e","tests/components/error-link-duplicate-initializers/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/error-link-duplicate-initializers/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/error-link-duplicate-initializers/lib-foo.wat":"162307ee1bb2ee38b02d94e8dae7d0b367cbc7e66250286141e557db56b9816a","tests/components/error-link-duplicate-initializers/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-needed/error.txt":"75506d6c1244cd5d0abc95789f38036415599d737a0e34ea0894b23dc9598bad","tests/components/error-link-missing-needed/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/error-link-missing-needed/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-link-missing-symbols/error.txt":"1b8771b7638f5ed476bbd54c5f613c144b36f74ef4f700940540a913f6960c3b","tests/components/error-link-missing-symbols/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/error-link-missing-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/error-missing-default-export/error.txt":"5a53be2c03ca12de39b6dd856ba0cb4b61ae41284c8970dd319f92458c3fc8d4","tests/components/error-missing-default-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-default-export/module.wit":"155bf2d1c7ee9ea2d284964c56c936f94ae987195787235350ced0dc6d6db305","tests/components/error-missing-export/error.txt":"878e7173e57fb0eb0df926bb43e7e0403f88462ea9e67c2412018712e6f9ed56","tests/components/error-missing-export/module.wat":"1885772b94ca41b360d9bd07535547f4c8ef16cbe7e49d2c8e9780247e26c4de","tests/components/error-missing-export/module.wit":"eb129f25552584be9360310178c70a65029de6b72a1440ed99ddbf38d0916c6b","tests/components/error-missing-import-func/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import-func/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import-func/module.wit":"4f0718445438c4dfc08950cdfdaebb4a4c5adf2d724d66bd145ed593c1592c1e","tests/components/error-missing-import/error.txt":"be530862604920bc57c09726e1c33d9b19f998c34d41b0fc92e1da9a21c5b4fe","tests/components/error-missing-import/module.wat":"8de2d70020a9077cb551ef2696b4b47a4f56f20ed8694b6b74ecd3844fd64639","tests/components/error-missing-import/module.wit":"377e5ec849247e26a266ac22827499db26acc3a1c8d42eba3c996769763e8e05","tests/components/error-missing-module-metadata/adapt-old.wat":"9deeede24b802e548c69996251b1a6af19aece55b982890809275d1ef2b09bfc","tests/components/error-missing-module-metadata/adapt-old.wit":"a9041eb2e762260cb69be1c27a6bcf497337c86e356b0142fe97dae3c1e32a0e","tests/components/error-missing-module-metadata/error.txt":"993083f2635f4875169fbcab22b59bf416eaf09de7708cdb26f47918c615ace5","tests/components/error-missing-module-metadata/module.wat":"66a5907fa8f666c22e3f5cf88cc62a8567a777d750d76374de448e0f8e8ac7e0","tests/components/error-missing-module-metadata/module.wit":"62887f2f27236202880a9116dcb8bb0d082ce1d1842f3c247c437f6bf9f12413","tests/components/export-interface-using-import/component.wat":"7d16e055fab6b2601aec5aa0618462d75106e29ad65a676ba31301403d7b0269","tests/components/export-interface-using-import/component.wit.print":"3cdf7896480bc68b7cb0b9c9ff4dc028eb7d435f58de7bfaaf403e426438fd19","tests/components/export-interface-using-import/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/export-interface-using-import/module.wit":"c6b8fc795e93412e9cc6e2ba335c20c89e0ba442f684bb0ab779ce052e715c32","tests/components/export-name-shuffling/component.wat":"abe1f435743fdd3690dac62d9b60ee7afcae762aa9e8e912fa8556fc83eedb5d","tests/components/export-name-shuffling/component.wit.print":"32e7124b8455a67f63c1071d9a5332dddec63c47472909222b351111e0146817","tests/components/export-name-shuffling/module.wat":"cdec922bed8d252248be323019e3d5fc83e0bfc9777fdc654b59348daeddfd19","tests/components/export-name-shuffling/module.wit":"99d470993cedf025e7c356ea8e5c6a041aba2968419193eea5f1947061b19750","tests/components/export-resource/component.wat":"8ad1eca01f2d26a7135898bbb123391da9827604f6900799894b281dabac3bba","tests/components/export-resource/component.wit.print":"9a6e09d0140a25319041d65333e58adf87a0231b5283c3bc768ccbdce83f9c24","tests/components/export-resource/module.wat":"35cf529d4838d0652bbd322e3498e72d02643a4d105c0b7dd801d3648621316d","tests/components/export-resource/module.wit":"ff43e87ba4fb913e5e239a5282f0f0acc33aed4fa04610be25a706791429b56f","tests/components/export-type-name-conflict/component.wat":"02a9d2e58bb5abeeced1fda8ea356bf2a288d27d8f376b0ef84c353804193b0f","tests/components/export-type-name-conflict/component.wit.print":"0039957ae8e5e8ddba28cb0f8c7831a33864e407c87550f578af5e36b5b9d97c","tests/components/export-type-name-conflict/module.wat":"b8703739f92ca2de5a1483eb2504fc082e690f514fb014c7e09b6e5b0348a3ec","tests/components/export-type-name-conflict/module.wit":"47b93fc6d44cd48c9ba768feef028a5dd9980088ac328ef965038f349a566b46","tests/components/export-with-type-alias/component.wat":"01261b62e3576b58c1105019e610e1377476dab64fa0d29830358ba5efd35906","tests/components/export-with-type-alias/component.wit.print":"35e7687bbeb38e07890e152ab3359c6ecb558ae513b44f41efe60be15d99c5cd","tests/components/export-with-type-alias/module.wat":"d0e73d5437af39f365675b5c516a12ffadd6844ab1a7cb36f63829716a823c10","tests/components/export-with-type-alias/module.wit":"22f298065ce8a2fdaf726cdb347c4bca9e56700fc6475bda9ef5ef8563ff0d89","tests/components/exports/component.wat":"acfce3dd26ac8a4bfdfeaf3b01d6c23773acfbb1674813b26eb0f3e1075d4d45","tests/components/exports/component.wit.print":"761c69439ac16484a2b210ff34d219db4afb2bcffad4f3868a2e76479feb7f19","tests/components/exports/module.wat":"324dbfc38fee5a442e7ce3a13eb2a4d25dc6a074ba81bffd4fb35268608f9d08","tests/components/exports/module.wit":"d41d5f8763da23fceeb773ff18c9960132a1e811ef194a47c900d21f48083d43","tests/components/fallible-constructor/component.wat":"1b42b21f2ffd5de0614188b285517732b0676801b2c9460a54908629722b8386","tests/components/fallible-constructor/component.wit.print":"a486e9bc2d393474b05ab915bf61a573e89ef09e3bf7bed24e16cb95a27df2b2","tests/components/fallible-constructor/module.wat":"9dd3bbf052d233572a70122e34ada7573252fe2e727c918bda87f44d62ac7efc","tests/components/fallible-constructor/module.wit":"310b82945183ab329679be7f832f0d8c11c59360e700f9646f87e881e612d0de","tests/components/import-and-export-resource/component.wat":"7fcd443bafed0b524f49c7fa27b371ceccd6b95249998f5c8787e481d4e7547d","tests/components/import-and-export-resource/component.wit.print":"fdb32e7784b0d908390a0d1b62e077294f5168cb46daa470ac5e078cbe8996c9","tests/components/import-and-export-resource/module.wat":"43b89c3fa07a24663af81eaddbd02778a0d9062ce65efa7f04dd10081cc8aba0","tests/components/import-and-export-resource/module.wit":"a9f3ee298ad42fcef0d80a34b6b58e1d18e438e492400463993508599d02adce","tests/components/import-conflict/component.wat":"f0008f711d6bde4eb701a08fa5c61c021e33c61501fe3fce25535a420be1d63f","tests/components/import-conflict/component.wit.print":"19bae900cafe77b7bacda385e23475154f90f0a8d8f063597496132e149867f0","tests/components/import-conflict/module.wat":"639633c3b575c976831d12d1d7e69826ee23165c8cbb6094940397c8359ddc6a","tests/components/import-conflict/module.wit":"d8fd770eb17db0c5e7adc23c41315cbfd77af9014b4514d65fe2f28a629b7b43","tests/components/import-empty-interface/component.wat":"fc08c1fbc0799a76e42dfe91b6e51f4e9567795a3987c1dd70b47cad2cf60f30","tests/components/import-empty-interface/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/import-empty-interface/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-empty-interface/module.wit":"f570a16495e584b54606fa6a50018cfd1ab21dc85c10deb7f869564db3d7450d","tests/components/import-export-same-iface-name/component.wat":"7e506c2d9bcd48d98b4fa2acfe4a7fa33f6ac8cffc764629d9fce27f2005b3b6","tests/components/import-export-same-iface-name/component.wit.print":"510d7b609e6714e7bfb7cbe9f57c42c9d2318ec17de0ece8522599dcdc7aa22e","tests/components/import-export-same-iface-name/deps/dep/foo.wit":"e53988c57720965219fa842f767cc30e31f3c18ee07ba9833432ca2084ed4fca","tests/components/import-export-same-iface-name/module.wat":"a951a5e947ef899087bbe377a97c06d4f742afdc97ecdb673dc3e0e60019f956","tests/components/import-export-same-iface-name/module.wit":"c9bbae4c071ea7fa7da77e422fcb93d48f14a6faf0adeba4ef94b3949cf1f9a8","tests/components/import-export/component.wat":"bd51d58f13dc0de6ae5b62eef53383064378f62172382b879659dd39c4128a51","tests/components/import-export/component.wit.print":"07735b330c59c0c01e604e0d4cfebf3d513beb24a547c3453f9e804a7f502819","tests/components/import-export/module.wat":"5e42ab263e87ae03d3649d839f86614ff580982033ce7022dbfe1c6c13e886aa","tests/components/import-export/module.wit":"c90a74db6e305afd8c8da8c4b9d1bcdb0e4dc575c28d1cb302e2c3ae1b087c21","tests/components/import-in-adapter-and-main-module/adapt-old.wat":"43d847aa6521beba5a478c3bbede7f255c47ab6ee31b4f34a1524b28dfa25df5","tests/components/import-in-adapter-and-main-module/adapt-old.wit":"3cf2e31d18b76f61c61958cbc7313290ff7fb323719d31e89c054b9f6b41615e","tests/components/import-in-adapter-and-main-module/component.wat":"c9d2c38b30c0731bcc8ffb555a38d501135ce2065de42e8c16020b3b87d2f4f7","tests/components/import-in-adapter-and-main-module/component.wit.print":"fb2791ae3aa119e2ef9aabaa811df8a84a5680bbf26a7cb7697403f8efee705b","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/doc.wit":"ba5a8f346d581ddcab0cddbcb00e976e54327920d4c7f98933a422f03e62339c","tests/components/import-in-adapter-and-main-module/deps/shared-dependency/types.wit":"2aa8bf309a148128bf6ca4ccd86c8fae95e97953a73f2ee7d652613a4eceb5f7","tests/components/import-in-adapter-and-main-module/module.wat":"6995ee3ebbbab471d4b7a7d9973647e5a4b86851ed54fc019b6ce46b39c3849b","tests/components/import-in-adapter-and-main-module/module.wit":"d1e48a09fb9307185b79f5f200b54e906da5ad62eb57e841bea93e239a96b9ed","tests/components/import-only-resource-static-function/component.wat":"1bd74e7edbc1bc26bb6c24508a941b67d8aaa3c2fde5ac2ba3183a930ca917a5","tests/components/import-only-resource-static-function/component.wit.print":"392a1d0c73268c3e20bce45065b5618dc8ec498e280d54c226a7701c2c7d17c2","tests/components/import-only-resource-static-function/module.wat":"cf1e1ed8d03ed537c0cefd5261147933c78b85cd748c92f5f005642cdfb1a01c","tests/components/import-only-resource-static-function/module.wit":"c6cf4995b848915d6c99a90f3b2ff95c32ecc9c3cdc21ece827d0840035d64ba","tests/components/import-partial-export-full/component.wat":"55081ae4598055a3abb4ee4cd3676ba30e99a80a167f87e2226be278b8d59435","tests/components/import-partial-export-full/component.wit.print":"3ab4179ebc8dfa619f72f3b51517dd038ba0b2bb1ada2ab063c2cb8dda844b85","tests/components/import-partial-export-full/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/import-partial-export-full/module.wit":"d37ab68346e073666081684d84a94ce9de6c27fc50ccc3c774b902f13dd77e77","tests/components/import-resource-in-interface/component.wat":"9463d61a86d5eb0c4eeac4caad24e61ee406a8fdce569f4a22c972cebb09b345","tests/components/import-resource-in-interface/component.wit.print":"313207ca455eee8d5649b5901c2e7786b117761cb76626ffed15bdfc6efa743c","tests/components/import-resource-in-interface/module.wat":"dfab4bf8f2d634b2f8db1c452ba1cc9f9aa20da580fb8e5f520d9383d53aa614","tests/components/import-resource-in-interface/module.wit":"72d6d2861b7cef7939fd4af3c615db98cb29a08fde3cbb4e5a4ea6fc463993c2","tests/components/import-resource-simple/component.wat":"0a9a15caf8bc2c69375dd1f1f0fe571a9c139e84132039834c1728ba0a103cbe","tests/components/import-resource-simple/component.wit.print":"7d166ca48287419d030b9cd49cd69150fc3a534f1ffc5569cee934c002f1028d","tests/components/import-resource-simple/module.wat":"76206dd7ed5d0ca30f9db6085cc3d0908fba505bff097e5310e1e7eeb6cd3d7b","tests/components/import-resource-simple/module.wit":"81993bcaeb714767b9f5d040079bc2b71cda292861b5d1705d55010e809907b0","tests/components/imports/component.wat":"1cbf22691c0723e661184424d00c620126db8a338499dde7397f29aa75b028fd","tests/components/imports/component.wit.print":"db03bcc1e409cf7eda8abe72152b697bf2242696c9442480d427033a6ada15fe","tests/components/imports/module.wat":"726b52e97319350b0995edadb347404724f750b451515cca2998d6ea43fbff58","tests/components/imports/module.wit":"ae6f59d5a9862832e4393df2e066ab8bd671a0072922b720bd6a7da703bbce43","tests/components/initialize/component.wat":"55ef7b724f6dce61155262085d7d9f627ad3ef0647049f86d836964664f48eed","tests/components/initialize/component.wit.print":"c621c6ab874ea1463aadf38c9a9499772183c86580381c0af0ddda71379213c9","tests/components/initialize/module.wat":"d6b0dd9b619d3ea4f767cdbaee59abfa5cc429a7fde2dbf30d4b98bc1ca8abc6","tests/components/initialize/module.wit":"2ec1457ceac2774e5c0f8701c08ac63575017bdbf8b2f58551f3f946edbae839","tests/components/lift-options/component.wat":"8e7a0fd9998956377a8c4521c0795698245e5e1f4882ec427fb917e1c078e688","tests/components/lift-options/component.wit.print":"0efa031b0013f70c3c5092f53e40b10c0ae02398403320a28ba7c28533517f2e","tests/components/lift-options/module.wat":"7f74aba6c2e663bc2a7de94bfcdeea21cb9f837952a6b7d5473998ee65d8ae33","tests/components/lift-options/module.wit":"63ab644fd22c7cfcb0b9a6195065f0065abc01eb5545e18437c02e6a68e09bd2","tests/components/link-asyncify/component.wat":"8b989d3709a2dce7d8e8894ea83cf827f9b3eb7caee007eb9b059125ec7e3047","tests/components/link-asyncify/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-asyncify/lib-bar.wat":"159e0a9e578b652915a4a1c525d876ab78c76574edc757eed8f2d898231ef3eb","tests/components/link-asyncify/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-asyncify/lib-foo.wat":"d61a8d805cfa025d3be070564e8cd993a21307549af7fba1f2702ca5c4d083b8","tests/components/link-asyncify/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-bare-funcs/component.wat":"72c3bff4be47ed0a7f1bf2754c80665a2d20b292881891c0f5fd28732ba1fd4b","tests/components/link-bare-funcs/component.wit.print":"ffaa54c61b292fd93917c958eb7d4a2d6db224b5a30fbced6f07530c23486aa7","tests/components/link-bare-funcs/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-bare-funcs/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-bare-funcs/lib-foo.wat":"57eea96d26803de69e0a6a69314006251da4146416f658cc7447e5f4212d0ecb","tests/components/link-bare-funcs/lib-foo.wit":"ce1132f1f5d9df197a0326a2b608df671179d490dc537e9c1f8577bd25c57ddd","tests/components/link-circular/component.wat":"5e1b586bb766e1cf3a2cfa47bee8665e44d0eacd8c9332f08e52ee04da6aa4b0","tests/components/link-circular/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-circular/lib-bar.wat":"7039053f316ef76c2f5e47e266a950bdab536c90b558f408edc43560f215eed5","tests/components/link-circular/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-circular/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-circular/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wat":"4444f536a9a97ea84a3822944ba48ec05e8d045ecb5ff86e67807f2106815bc2","tests/components/link-dl-openable-builtin-libdl-with-unused/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wat":"e02d2c79ff11af4334d7cf751750843102a4c2c40e1aa35686fd7d04b273cafc","tests/components/link-dl-openable-builtin-libdl-with-unused/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wat":"ef5b56730b4c79fbe9f9e10f462ae222ff18bfa2a960ae03a86e3152257fbe6a","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wat":"099904a1539e31d8ddd306553dacd0667ee221a76aea79a3861a269d9edfaedb","tests/components/link-dl-openable-builtin-libdl-with-unused/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-dl-openable-builtin-libdl-with-unused/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/component.wat":"6dd489bded8be0b711abb6129c927cf4d561979fbfc60dcb2317ac103287f32b","tests/components/link-dl-openable-builtin-libdl/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wat":"1183b069d484eefd7a030c9ab975d4ef5bf24fcb033d922148398bc5ecb0de89","tests/components/link-dl-openable-builtin-libdl/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-dl-openable-builtin-libdl/lib-c.wat":"e1988d4a8ff43aed730375fae50e601b9d3f5c28ffafa56f6be581be1517394e","tests/components/link-dl-openable-builtin-libdl/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-dl-openable-builtin-libdl/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable-builtin-libdl/use-built-in-libdl":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-dl-openable/component.wat":"f169770d4cc24e8ed2c010810e31d956f29374e029b9f2dfb563a6b2f499d919","tests/components/link-dl-openable/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-dl-openable/dlopen-lib-foo.wat":"7047914692755e525a4049b7973c8328de2c19fe0f1b65a368228f654d14937d","tests/components/link-dl-openable/dlopen-lib-foo.wit":"09d6ac573b3bf00503b5f21ca23004938e5b3f24842ce6e776d91a0e48278f64","tests/components/link-duplicate-symbols/component.wat":"f015b4fd73d2f0b694d4cf0c18be014a82a1dbfca0bdf92452d295bf8382ccc4","tests/components/link-duplicate-symbols/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-duplicate-symbols/lib-bar.wat":"346743798987c1a403b7e4941791c3dff77e6fbfd83afab14596b3efe81b5808","tests/components/link-duplicate-symbols/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-duplicate-symbols/lib-foo.wat":"8b2a79cbb9ff4bc7988632026b956ff4b6984750a3388b7c2c7cd3c924fa2386","tests/components/link-duplicate-symbols/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-got-func/component.wat":"28f03634ebea0fe1b7d2b187ec472e806759999e6e338116bebabd45ce366db7","tests/components/link-got-func/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-got-func/lib-bar.wat":"b68db9e5915e6875477363893779792319e68e6c0b23411dec94ceb903f2844c","tests/components/link-got-func/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-got-func/lib-foo.wat":"02179e2a615fa830bf3c7b8d42ba1abc9e922b2cc163bf03f389c19fccd3e8c4","tests/components/link-got-func/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-initialize/component.wat":"dda1f4d706281526a986c2973dc2814d58fcc8d035b61de8547b88d968e74564","tests/components/link-initialize/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-initialize/lib-bar.wat":"acdc5991e4e0bcd1a8d681599326d903b47a8485ecaa341daa95d75a10dbc270","tests/components/link-initialize/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-initialize/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link-initialize/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-initialize/lib-foo.wat":"230df7123dced23e7ed1e01f8ab4c0564d0784c27fb5f56432a9641bb74cd20f","tests/components/link-initialize/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-lib-with-async-export/component.wat":"2ccfbe257b2318b3de66c8023f9f8c57b41ac2af678ec4ad5ecf0f565aff4f67","tests/components/link-lib-with-async-export/component.wit.print":"0d42f40f1f6c38efc4d7c51660b69bfbc86abcbdec31c6350ca6862202d2fdb1","tests/components/link-lib-with-async-export/lib-c.wat":"b42be22217533ebb066b70b2bb36d0deadd5470e45b6ea272e54ccef6d8ab62c","tests/components/link-lib-with-async-export/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link-lib-with-async-export/lib-foo.wat":"b3221090479c8732841d2e57583a49d60c16ac0aa7fe8f6e1205212939ade018","tests/components/link-lib-with-async-export/lib-foo.wit":"358a5c8eeb2eb91489109180f0372fa049ca51b03dc56761bafa8de593e26c78","tests/components/link-resources/component.wat":"a41b479bcebb05a75cd6c29c996f02d65920219c74ee5c3394167dada015014d","tests/components/link-resources/component.wit.print":"7c9bcd7d88669aba18c1ff9979d40fcbca7ed4616db8fdae221e75f49c30e863","tests/components/link-resources/lib-bar.wat":"a19533149c2054deeb209e902be84d472b72b6a69771ff7db7d6c881028e172a","tests/components/link-resources/lib-bar.wit":"c51af5e3a0b53612bd02b9cfcfb509145806703ba7591ae9562a324e261fc805","tests/components/link-resources/lib-foo.wat":"914b197c116ae12a47fd337fd0ef1160778479f619d38f958d8ccf6ec1e92020","tests/components/link-resources/lib-foo.wit":"98733c4a044f7ec1916a604bf4d78f1e0fc7432e9d170479c6d513ce33efb3b8","tests/components/link-stack-high-and-low/component.wat":"3e1c9ae6dbab0ccd91f92c372a9ab50f1d97899d5a8ec9797042ee9ad6422fdd","tests/components/link-stack-high-and-low/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-stack-high-and-low/lib-bar.wat":"3477c2c461c8bb6064072d4b278843906a3b3f513439cb2ee5738562c51dd99f","tests/components/link-stack-high-and-low/lib-bar.wit":"2314b69344e6938e980366d4a2f912cceecebedb03783199a1827f641fa8aedc","tests/components/link-stack-high-and-low/lib-foo.wat":"d94339117228cb4b645b29fb4ce711e24f77aafb83b4579279353cd72d1ae94d","tests/components/link-stack-high-and-low/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/adapt-wasip2.wat":"c18d8a24f5c8b2e88b16b50a3104357755b788930ad9a1ce42f2c1fd56539c46","tests/components/link-stub-wasip2/adapt-wasip2.wit":"25d97f7ad800690ce2b90446b0c7c953b99ba4546203dc3de6687175b210776d","tests/components/link-stub-wasip2/component.wat":"dba0ffa80c499bf9a2522d20af4904b3fd50da45afa94726e84bb7d0ba13ae5e","tests/components/link-stub-wasip2/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stub-wasip2/deps/cli/environment.wit":"b6350bc0c8d1e916d0ec7ddec44bd702f4419fe6e8fb97878d725d7db55f2937","tests/components/link-stub-wasip2/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link-stub-wasip2/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link-stub-wasip2/lib-c.wat":"ff30ef2aeb8c5503309ca521063086d4401b11d5fa42e787ae52c3ace024e6df","tests/components/link-stub-wasip2/lib-c.wit":"7b97c2b019fd47edcee51bb66c69b71a3124ce4ac77b81af0d40b1edd957e8dd","tests/components/link-stub-wasip2/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link-stub-wasip2/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link-stub-wasip2/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link-stub-wasip2/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/link-stubs/component.wat":"58e7f8106945a291b8fd13e0997792248009c0cb7853b0874974c6fa61935f7c","tests/components/link-stubs/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-stubs/lib-foo.wat":"d0b8b5ff95b5b4008cfa306d4af74bbca75bf07bd42ec897b711eb3064b1108d","tests/components/link-stubs/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link-stubs/stub-missing-functions":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/components/link-tag/component.wat":"4cf16662ecc758a4bf730199fc91b5d2e06a7707ab3779389335bbe22c20bc1d","tests/components/link-tag/component.wit.print":"04b8975105d1093d4fb679d99999f103bf0b6801fae41dcb1fece2219453618c","tests/components/link-tag/lib-bar.wat":"4611125ab396c5d69f036f1b8f2e18a3aaaf81ffd5c44b52995cd712d64be3a1","tests/components/link-tag/lib-bar.wit":"af916bc909f9845e7be9615afc555545d150ccf2981e5ca3b9e440ea9901e942","tests/components/link-tag/lib-foo.wat":"fb4e47576ad3d1cba844d7a03dedbcfac323d421108a04107db0863b6f44a519","tests/components/link-tag/lib-foo.wit":"bf62ea838d3ccbfdad20b1a51204262b9bd613c4646346ba7bf8e57a8c6f6052","tests/components/link-weak-cabi-realloc/component.wat":"762f3b5d9550d6a49ecae9e13e6ddb538519d049a7dd3efb5d5df77cc9b70211","tests/components/link-weak-cabi-realloc/component.wit.print":"6a66e397b0e9c8c7d70fe806f4e11b9d87c4ab645ac56aa1834b455fc18ec48c","tests/components/link-weak-cabi-realloc/lib-foo.wat":"6357c1189cc178bb27c449d9a833da58aa9ff78c04936d5ad10f21e560ab70fb","tests/components/link-weak-cabi-realloc/lib-foo.wit":"903b843983ea9c9c22cea5383ea3fd607b8c1de49d1addd0197d38fe1aae9a69","tests/components/link-weak-import/component.wat":"8e00021d1f863c95e83fc8ebf5e7559aae4cb891def1b225555507f8da4a3a9a","tests/components/link-weak-import/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link-weak-import/lib-foo.wat":"8163164df489b40ad2fe861c7621c60d80173b893f3108983306032f28f52b93","tests/components/link-weak-import/lib-foo.wit":"5907cec7ab882f66a42aa64ec4d6b805dc7128481c7ca35199948316f654245f","tests/components/link/component.wat":"344807b51f4f5267163173e2837b3ca9439650d3a70a0d3624a565fbf2a31809","tests/components/link/component.wit.print":"49a45fcb30c66112b053ee9cf5f813f3f1276e44e448a4239eb9d45de505e2d7","tests/components/link/lib-bar.wat":"ac236a5b648468d6b729bbcfac2d8d3c2991125a0652d9a6fb62a7327a3c5fa1","tests/components/link/lib-bar.wit":"0dbb3958f2140ef6a8d1266fcb484137775ba9c3df9284eb87b2bc9e471b5e25","tests/components/link/lib-c.wat":"219127ae35d4798e3ea9217a264934591590751abff3f8cf6bf29a2ebe638d3c","tests/components/link/lib-c.wit":"e04d770fc41d2402bea0357ca87d60dcb0edb65b58b524fb4e38e8312ac5ea15","tests/components/link/lib-foo.wat":"f46165ea11b30f70136d932c8a34a7492e03f2f51c694100a9bf35312f5ca502","tests/components/link/lib-foo.wit":"a9278cd6d1480e9f04ac55d9e0cbda60bac01f1e12cd2d13eb45cdf9b43ad765","tests/components/link/lib-unused.wat":"dea738cec100835e590712df21717de33392d74a576957daf170b04efdb970d3","tests/components/link/lib-unused.wit":"a183f3a48381aaa6e1b83c5991bdca5e977af61de119fda865fc83c7d1f8b42a","tests/components/live-exports-dead-imports/component.wat":"33a32e651592e2f8499ef51c9bf4489e5c4b87a10f07892110f270c70fcb4a49","tests/components/live-exports-dead-imports/component.wit.print":"58c56bb216d91796f2ff53e2568000eba20cc4ac4a8e7315811fead63044d84c","tests/components/live-exports-dead-imports/module.wat":"82607855264e152a2899ccc7d23f068154e043c3522c205702df4b2a6c03e7f1","tests/components/live-exports-dead-imports/module.wit":"563494c0507f08ab4ed9c17032fa68a13837e3a9ad7eb3953a90136c2075e271","tests/components/lower-options/component.wat":"011a9e6c5bca14333185baefa7a6879413ebff21c952774cd057ae080ea055a5","tests/components/lower-options/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/lower-options/module.wat":"957cbf0c8a6687ecb0c76040480fdcc146ce5c61d01e4bd3ddcd894d395209f1","tests/components/lower-options/module.wit":"141d136241a64268b9f9fe18ca20956164ac9e8f47e2b2bb48cc1adef77be68c","tests/components/many-same-names/component.wat":"4c01d2694a24f39577beb93a2d18a4b37d8e13af76a640004abea902ed8df918","tests/components/many-same-names/component.wit.print":"04eb5ca446120ee977f058357f6d7a9967f34f596e4c0a5055a3ec1f51a49af4","tests/components/many-same-names/module.wat":"7a748bf12c36d8ed53f7e76194120df41102a81b52adbe9e6bb3682fab1333af","tests/components/many-same-names/module.wit":"bdc6c8ddf22997dc6505bab8bed04c2d93e45c21756d036b1b84790bb1e76156","tests/components/merge-import-versions-with-adapter/adapt-old.wat":"3c56d37587ab8193c5d63225ce84ff473c33c8f1bf75d6c4bed75bd7c30775ba","tests/components/merge-import-versions-with-adapter/adapt-old.wit":"ef42f0a58910c4cbb63bd8bd92a6634c511c6141850f6fc0694ed7c4a587a759","tests/components/merge-import-versions-with-adapter/component.wat":"edb6947344fc67b9a37527a25decdf813cffdd9437abe82bc111bacd66246fa5","tests/components/merge-import-versions-with-adapter/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions-with-adapter/module.wat":"9bdbdd6a7454dcaa8eaccd33696f0855b6a613cab4228663b547ced3a839d630","tests/components/merge-import-versions-with-adapter/module.wit":"a79e62d6f59e4cd8eed01ee0aa1f1dd7eb6cc4e057eae857e514c1b88c5f0196","tests/components/merge-import-versions/component.wat":"44b673bec8cd8b758921f711c20921833e2e1089e2b910c4c2e575a8f5abc994","tests/components/merge-import-versions/component.wit.print":"cd24a288951083401d8b01e0ada1e870c28da544c142d468500147e64c7c6e66","tests/components/merge-import-versions/module.wat":"abfdd39d50c8a4529af1636e0f6c10a4b4cae7103958480e4006a40573ab47a8","tests/components/merge-import-versions/module.wit":"92850e6dfaecb1d699c235bf43e980b410e002d5e9b49cf43d9102d5cb35703c","tests/components/multi-package/baz/qux/component.wat":"9cde15bcf420c2d39031abb8a802f575a756e52c2266738541f6f15c2613935a","tests/components/multi-package/baz/qux/component.wit.print":"b255c8747f2704e788d61a108eab228a7e6e02437ee665314cac38effbb4da36","tests/components/multi-package/baz/qux/module.wat":"2b1492c9015f1347557088a9bb19e61b79edafaa57aa8712bd911ba3921c5d3e","tests/components/multi-package/component.wat":"8ba4c759f3bee8b944e5a631ac4f8437016348ede8488b678bed671459578ad5","tests/components/multi-package/component.wit.print":"a7343b25ef27cc71c14ae2f275747d1b5023e9931839a11d0303733bb785975b","tests/components/multi-package/foo/bar/component.wat":"134a96e6e491ed2e014a036cb56c9d4a196e4a850619be7ef6666b8ff65cd9e6","tests/components/multi-package/foo/bar/component.wit.print":"6b6f89526fe4793ce9085bedf8eb2c66725a92360dbafe920f8dc8f5147efdc3","tests/components/multi-package/foo/bar/module.wat":"ff8ba654ecd7125d49210c22ef349f37fa54b52badccec69f71fb062fd860f56","tests/components/multi-package/module.wit":"057f5c6f1500ba79cc57fcfb428614de419243c7a224e104d20415e518669da0","tests/components/no-realloc-required/component.wat":"3440a750b0c21813cf577ed5256f8dc46682e41f81594083bc1d25db50714fd9","tests/components/no-realloc-required/component.wit.print":"af82805774e5a261f885b97bd183708e86322bf121ce2528c05bd3ef7c3ffcbe","tests/components/no-realloc-required/module.wat":"d7515c3defbfd7288984e414417b6f9af6b4e9be6835ec5a79770079aaeed542","tests/components/no-realloc-required/module.wit":"d4fff6f58ec0f32157f5c17f0c44c9641dd063b0025972cad18af64f6e2de9b5","tests/components/post-return/component.wat":"f7c4867a341a2f5a1c31465462ae0971424b9be80f891a560681242373dbbb58","tests/components/post-return/component.wit.print":"dda1f7d5e2f6e49f6df046e881a8b5eebe2449c19aaf48a49121f426701a06e8","tests/components/post-return/module.wat":"3bbdd4c09686c2f7f61c6eb7d132345f7d8cb7037b3c259d22d1a8b295e67305","tests/components/post-return/module.wit":"b1fae8d17f70cbefed1036d5a44550473a08cbc2328fe1a923ddac4339d0cd0c","tests/components/rename-import-interface/component.wat":"0e1cdfc198539b6e68413048e9b276f7cc8d1784849583bd0cd85c06b042a625","tests/components/rename-import-interface/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/rename-import-interface/module.wat":"6d42f1ef7a8c3b10cfcd9af2052c8e08f47bf068f554013514f2702d3d714df5","tests/components/rename-import-interface/module.wit":"bfb05c599b4b556e11fcfd94a51090eb311972d9b5643b2fc1a4b786fe886d17","tests/components/rename-interface/component.wat":"8a4534c7b80fc412fa024a343927b53e6b804c489f1877c4ef46ebb65830a7cc","tests/components/rename-interface/component.wit.print":"61e6663c4a3e56091cedb85a6339a01006ab37fdadadd84d855f35c4e547afa9","tests/components/rename-interface/module.wat":"45fba53e30e8279c534f0a60e320f1c6a1422bb82f95460dd2bff27d09272e07","tests/components/rename-interface/module.wit":"d4c0aeb65e8de86ffcf651ffc2937d2dd0c15a394fd27fffb2aebc34337d06a3","tests/components/resource-intrinsics-with-just-import/component.wat":"38b11b9263711d8dc42c84e4c24f3ecf26c2e1a311aee4a40571219288ec0c92","tests/components/resource-intrinsics-with-just-import/component.wit.print":"1d1896462fc3ce15a0f79f753b7ff8b83b1b90fb41850b7a3b05afbf17064aba","tests/components/resource-intrinsics-with-just-import/module.wat":"f892c943bc508e188d746be4b31849792ea70e5b35dbb316a5bbb33b9604239c","tests/components/resource-intrinsics-with-just-import/module.wit":"41d2b456f11bd0005178edd868ad2675fed29c2ef4e36f9604383178a01bc707","tests/components/resource-used-through-import/component.wat":"4ee4514507461c97bddc711005bafc951c1337dfd942880707505d56181f92d8","tests/components/resource-used-through-import/component.wit.print":"016e2d6cad8f4d38f6ae9c64108ee475d9e479466caad186850e3e3e7ad0d4fe","tests/components/resource-used-through-import/module.wat":"5444f7ba822b2864e8ffb92a42b21674dbf6416bbe4c868d311db8a9d2ed5772","tests/components/resource-used-through-import/module.wit":"148d7d1dd61494e67dd1abe605731222be46e9c050a42632af85d65892378a1e","tests/components/resource-using-export/component.wat":"dc1ee332ff13e5361f1b60c8fa53db57137f9ef499288510d65c6f5bb7802672","tests/components/resource-using-export/component.wit.print":"81d2ecd76e78f9835ff0a1c201fc449dac6edb6cbc2390c37b3de7665e9c5e6e","tests/components/resource-using-export/module.wat":"a536f2f3270fc6e218e39b4d16c6a481051023c0aa26c4c2023f9ff90ef410d4","tests/components/resource-using-export/module.wit":"2b82098eea901f65cb65a9a079e470a1975b9192d5b5a227511ea25f8c32af85","tests/components/simple/component.wat":"3c2ce9adab9e033f1386da2143d3cbc38693ae6c277c4b003d3aa793d1e18d59","tests/components/simple/component.wit.print":"bc11e4896f9442ef9415b7f0796da9e22d9b07a2cb27d957c746f3be3142e7f7","tests/components/simple/module.wat":"3688a131da2f16901166d04f7fa0499f755a19f7d479a24a47921e94710ca86e","tests/components/simple/module.wit":"ab54b3883a5838519149b99347ab6ded6f494e0526eb16b774890044acf4a569","tests/components/threading/component.wat":"487085b1ddcdaa5c3d01745abd45d3537ef6bc55e0cd0166152ee0e8a58b5c86","tests/components/threading/component.wit.print":"fc1c195686a3c6ac139ad4dd8b9387aa1bf691608a36f1d6d9ac1e8fffb9e1ee","tests/components/threading/module.wat":"619203db7bf8392f8c66bab654bb5bc52566344c1d867af1e1b67794c9b6ca8e","tests/components/threading/module.wit":"9d6569b3f91e41a268906f09e879c49bf2b1befc46cde19f7425b58c00c8a605","tests/components/tricky-order/component.wat":"e95a6c6fd66eae7ff0640539258a7b3bb48dc6ee047b51f5d3fabeb21a9d33d4","tests/components/tricky-order/component.wit.print":"3fc16dc48f01ab7dcbf933d5a04443abc22fb1f06800ef02668dd0040879e679","tests/components/tricky-order/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-order/module.wit":"2c5a879b53f07d5303797086792978783e84baf964e0edb09b0abc12139476f9","tests/components/tricky-resources/component.wat":"61c7f212f183dd1f1cb037100f58f4b4efe99556fcae1a3fe8c8aadacc859b80","tests/components/tricky-resources/component.wit.print":"856955fb41792fc9c38d19de23968f5a4f180f28b73f267808e0305bac5bb9b5","tests/components/tricky-resources/module.wat":"f71be4ce8c2d1fe8c83dc8b58cd7e794132f7cf03995d6ac498256dfca8973dc","tests/components/tricky-resources/module.wit":"50b61106dfef6d7b81671b95230b1adf3ef9ca4c028a5a4f932c84cdda260890","tests/components/tricky-resources2/component.wat":"62edd5121214c3c0247bd0705b1662f06a5cdc758e4a20cf786aeb63fa52ef69","tests/components/tricky-resources2/component.wit.print":"a9cfae01ec4574576148c54c917c0be547c0a9a80ba1c76bb313556b80eff2e1","tests/components/tricky-resources2/module.wat":"63fc3214c3d4e4b36def8417cbc3aac44428046c2f212e14c3ba42acb79e29cc","tests/components/tricky-resources2/module.wit":"24df1dba85c4c71a4b8138b9add9d47a7291a82331f2ed08c3841574c668d36a","tests/components/tricky-resources3/component.wat":"8fc170f04c9417a75735b5829115bcc8567010b11fea765c072b40233463ca8a","tests/components/tricky-resources3/component.wit.print":"acf40dce88c3f0ba8ec1eb7c0058745906af2546808b5f87979050645470b803","tests/components/tricky-resources3/module.wat":"3584af5e1ab0b1da09b5326237be4b178de0bb388d6093efd94e6aec56c20a74","tests/components/tricky-resources3/module.wit":"f00e678465c06ac4fd1ff7dbd473934c796e9251fcc15c604ef8bdc9ac870220","tests/components/tricky-resources4/component.wat":"95772b98420903e117bb87d0fe8e4aef50a57032aad2256b677f8a2fcd0fc9e0","tests/components/tricky-resources4/component.wit.print":"0cf3e863909bbff0ffd80995608d50bac03e716531ebe4b9177997e313ef0cb0","tests/components/tricky-resources4/module.wat":"acf798ec37ef20f52b1ca55a2eee9ea428d8c3a134a8450293c77b8ccdf56a40","tests/components/tricky-resources4/module.wit":"411499bff6c68c79f523d061aea6eb7dd0124dff7f1102dd7fa3561eb1acbb09","tests/components/unused-import/component.wat":"fc5cfba85e31292151061680cd3c04ffb16b946aa0fdba0e922e419865003f66","tests/components/unused-import/component.wit.print":"dd88fb45583dd974aa9d84861f206b26329c0ac92e8ad99e4992b1b6f8a8eb96","tests/components/unused-import/module.wat":"357c1e05f5fcb82e7df5958d9709a75d693f67a8b8d31ab4fe09c413dbe79d46","tests/components/unused-import/module.wit":"ee373cb080a5c563252c18da9928dcf8a835ffc1327a7c1b5db4e15f4c44cf94","tests/components/worlds-with-type-renamings/component.wat":"cfbf49f975bf0c10c58392b1fcc6180934efa6adc44abdfffb5134367f788c25","tests/components/worlds-with-type-renamings/component.wit.print":"9797ffdd1f55149336e49a3f3370ec4b052b0b48d094af34d2e305b1e807033e","tests/components/worlds-with-type-renamings/module.wat":"9e0cfa9735e10a42efa429bdfab4e39791673d26ec574722d3eeadf1ef6e2de9","tests/components/worlds-with-type-renamings/module.wit":"5fa4355c6ec3249c4afc32207a89fde9c10be783a4e259243d9bb7bc4d1b5052","tests/components/worlds-with-types/component.wat":"41f5ce7143555c17ddfe7e612f930c8b6f28cde7c2995ae4a342fd571ab390ea","tests/components/worlds-with-types/component.wit.print":"08ec721da023042af8478fc61bcdb441091ea3b6efd7c26567a497e15cea451c","tests/components/worlds-with-types/module.wat":"b08d3fb1390db5c4ab3dea54eb386708fe25f0e875f5e08c3cc5af387a4e6603","tests/components/worlds-with-types/module.wit":"b86cc880c1cb138a26883b9e1d706b8506ba1c8f39b9b2722c4cbd02154b00e1","tests/interfaces.rs":"78397eaace0ae7501995f51bc261198ce04b1e0a169023acaede831ea3a9d7c1","tests/interfaces/console.wat":"65648a08a3be183053434c19e75ff12d4e8ba7b80d12e15e9daf797a44c33690","tests/interfaces/console.wit":"ae4ecef964695f02aed6412aa33125eb25d667984c24053303c02842c6952d1e","tests/interfaces/console.wit.print":"88664e999c44984e3f6e9a33a3fb1c8455abe5d9486d977e1a3e38cd85cd2d1d","tests/interfaces/diamond-disambiguate.wat":"0aa80803e0ee5aaf9d9410dc03a4f9e12ebfabf287d590c563fa5603589da7b1","tests/interfaces/diamond-disambiguate/foo.wit.print":"8c99834e2dff8e984b07f567555c02e8379d6fe9a9e8903e09c0a71cd3e1c7f4","tests/interfaces/diamond-disambiguate/join.wit":"4d85308aa1fa9445db47274a21ea5305043a5fbd2cfd07bd05018503ab9f2f2f","tests/interfaces/diamond-disambiguate/shared1.wit":"12156cefb18c81870ba266446874354a10871389361810efac7830ea0686f96f","tests/interfaces/diamond-disambiguate/shared2.wit":"fc790ffe2a771a13819976d1c56392e96cfb693e1589c757e0ceb8ae8a360dba","tests/interfaces/diamond.wat":"2996d285b348597d0a6b980167fce74053808e794dd1df9e48cc6efb234ae801","tests/interfaces/diamond.wit":"151c0be378c2ca19cfc97e55d820be7e8451817ee16fbec25feaac1332d25c40","tests/interfaces/diamond.wit.print":"7a6dc57ea3283fa22b6d38e0765f38bdd54f0bad36fb417f632144f073ca66c0","tests/interfaces/doc-comments.wat":"174225e7e66146c2204cdf9503fbc3f8b034599b37fd65904a79bdf7a57ec76c","tests/interfaces/doc-comments/foo.wit":"1e7267a6d075105b613e8ccc9f936a0e3747132e5d53697bb93d6c8978f9f68e","tests/interfaces/doc-comments/foo.wit.print":"93065d74520287e3e25647c005a193808661f5ad0592c5a9c37f05b23cf308a8","tests/interfaces/empty.wat":"d6144d67081f7139868791b76ca9016cdd33e07f8f18a7d02b35675849de1f1b","tests/interfaces/empty.wit":"5b69d726e29aee24abc73e2008107fff6e19c7e91bfb892ce91aeb022447fd33","tests/interfaces/empty.wit.print":"f887bbe0d82c8f23d3fc4d5d7ae44f2f7fd86ccdfbfdb89356c0363767b8ab7e","tests/interfaces/export-other-packages-interface.wat":"2d95d60feafeb9447b9c4117c98206dec84800d22313e8d42c09f80d2df2c2fa","tests/interfaces/export-other-packages-interface/deps/the-dep/the-doc.wit":"4e1596c661a7fac18feaefd556d3c148bba76ef748dc64623ca0e711b9b6cefe","tests/interfaces/export-other-packages-interface/foo.wit":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/export-other-packages-interface/foo.wit.print":"6039d5381dede8af1fdc2969384f5b8fb96dfb7e14316bcc74bc13f4f4771fb6","tests/interfaces/exports.wat":"b2b7a63e5b9ef42ca01a586656be4cde48d44a4197c18c034c090801b56a9bd7","tests/interfaces/exports.wit":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/exports.wit.print":"c998656f0d5e86df7eeb195c4b8cb7601cb9278acf738547e9aba12cf95b5d32","tests/interfaces/flags.wat":"1895f39b12260e80d872e28521d37e3ba4ebb2ceb321af83f79d11b5a22dc200","tests/interfaces/flags.wit":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/flags.wit.print":"67348d8dfe2215374681dda98530c9049f57b5bf7a57155218256336a39a8ea2","tests/interfaces/floats.wat":"c8fb2f689753e1e594f2b08e48b58dec55e4b0001dee3c2a35383d373b782956","tests/interfaces/floats.wit":"d3538bc1ad734434bc4b2ec7c152c5371dd8ea7db11a44cdd15ccec2b650b60c","tests/interfaces/floats.wit.print":"5fd8f9f328b5219350e2e9fd6ec483066b67a62238e4463142def96032fe584a","tests/interfaces/foreign-use-chain.wat":"acae7a8f76a913bdbb646a06bebec8615da6a5bc1dcb047715d5328e1e9a3faf","tests/interfaces/foreign-use-chain/deps/bar/bar.wit":"dffa233e1e0a2b35dcdaca0b62539776dd3bfb9662ee4b8cf9d72f4cddd2b551","tests/interfaces/foreign-use-chain/foo.wit":"51251e98cc66f75464b436f1d838a873e89713deec482480ae13d70458cce288","tests/interfaces/foreign-use-chain/foo.wit.print":"8bfedf3ed5380fa5dd359a9a3896421f67ad49f1c7b8d806eb6064b55092d21e","tests/interfaces/import-and-export.wat":"8ce79bbdbac052ba39e2d2d731f72736f277d3b88e0f763cd9c3db84a7386cdc","tests/interfaces/import-and-export.wit":"1dcbf7c373ca0c352bd45f444037170de7af3435a217b94378694bfd33b608fa","tests/interfaces/import-and-export.wit.print":"a6418b0f7bcda1e6055344cf39a438f7af0f7a5e3e3c067976e81d3dd4dbf961","tests/interfaces/integers.wat":"0c11ca08bc17c757cca9d2e42487c8394dd960a56422dcb62f4989ba93971ae1","tests/interfaces/integers.wit":"37d266e41985507c1c93d6c26a59efbd81893106f6d41b8a311e7c7fbae8dca0","tests/interfaces/integers.wit.print":"ad6949f8c87a60dd7e52028fd4bde7c6e8143ffea368a09820b5546b21408941","tests/interfaces/lists.wat":"090e004df86db95af8724a785ab0e17601d26025ce6cd0ebf089be7665b7a722","tests/interfaces/lists.wit":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/lists.wit.print":"2b4022cfda4485cbbd8ed25b78da23d74ac18acf7bc4ef2e0f10a47a4b647a39","tests/interfaces/maps.wat":"8a35bc0ba86761018f92ebec8633dd8ee2a6923f85df365ac4808d4e24066c6c","tests/interfaces/maps.wit":"fd4fb91fa11798dc163bf2f1cc287300d678e37c2d027a50887230d906181a14","tests/interfaces/maps.wit.print":"858a732922eeaa6c3479f892bd106256e3ca01e228d63e6c0c67210b4a1f31c6","tests/interfaces/multi-doc.wat":"d963c737bdac1ab843e197d81f27b71c3a5e310a3dc180f54d777dca44a27e57","tests/interfaces/multi-doc/a.wit":"e596872a740320ec0cc907db0a0514f8bd06bba396ccfa6f0fddb5063a6d2295","tests/interfaces/multi-doc/b.wit":"60c98779fc63ee8932956245f4f62a817df1873f73a6d38170481bd2e0933bbf","tests/interfaces/multi-doc/foo.wit.print":"94f244451d55c2bab71e4b3624fd0101afa5169c881580337e7d4af020bb8426","tests/interfaces/multiple-use.wat":"f47557d866df570c5ad02935468f170c4373233f80f0500c054258a724a23e98","tests/interfaces/multiple-use.wit":"7b3a8bc783bb588205ec8a4a4ec6b16786ac11632bd8a8af6989340d454a231c","tests/interfaces/multiple-use.wit.print":"720be46dc70779cb31985c505810dc9324511e6adb33e64cd7d51a6c061ba7f4","tests/interfaces/pkg-use-chain.wat":"d02d6bdd9d2c1bfb2f5897f616fb74e6bb51cd5ead90fd11fab08ededffe4e3b","tests/interfaces/pkg-use-chain/chain.wit.print":"fecf679bf3d5f6170e3752e70e3e6ff31a62c76af934310a8481cae26f826c7e","tests/interfaces/pkg-use-chain/def.wit":"e5926171db9b958a935cf7e6c9dfb19f352734d037371515d17384fd04b89422","tests/interfaces/pkg-use-chain/the-use.wit":"fa84d92dd7d863acca588c216df4825d9735ec521f2c8df2f0088efc43126457","tests/interfaces/pkg-use-chain2.wat":"3003789fb7591388e83f8a3a953b006b9561d2af7e0b033dde2d3152438f9a02","tests/interfaces/pkg-use-chain2/bar.wit":"f070c1a8bd8a278e04b0b774f5f2f4f658c281b139d1cc2a53a38771997f206c","tests/interfaces/pkg-use-chain2/foo.wit":"9cda1f4b74d669259f0d47c0b62aaa866d0fce95a2fa23e7ed01b445092af758","tests/interfaces/pkg-use-chain2/foo.wit.print":"234cbdb61a134682163a460f2d13e70dbed3a21fcbdff211af1bb875e49bb224","tests/interfaces/preserve-dep-type-order.wat":"d02789cfff3c031bc45a4c596be9d42a2925a670072b9b691e94b87404eb59cd","tests/interfaces/preserve-dep-type-order/deps/dep/foo.wit":"07d8a31043f7acbda52d2a81da2747125855fde991e2e81dc0a8090aec1b0824","tests/interfaces/preserve-dep-type-order/foo.wit":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-dep-type-order/foo.wit.print":"cf4b5e08d9c2e7cc6260c97af2397a0116f1c8b20af7f278b62eac20d7f4d910","tests/interfaces/preserve-foreign-reexport.wat":"80eeae235f01940ca94fec2c1b9c4c0603b9794ff39b486de019f5e4b6250e50","tests/interfaces/preserve-foreign-reexport/deps/my-dep/my-doc.wit":"a9e7687b2213e6432d316100c8f063334ffa91c312bbebf6e7b953a07a38887f","tests/interfaces/preserve-foreign-reexport/foo.wit":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/preserve-foreign-reexport/foo.wit.print":"08f924eaf5925d79dea11da53a98fa712462b2693267855f1ba7f8af23976a67","tests/interfaces/print-keyword.wat":"e35164a7c713261bac2b9eff4d378d0bbe0eee805ff2acbf109644b7eee32935","tests/interfaces/print-keyword.wit":"e56669492ec53c6bef1cd14561f81c85117fa05199241cc2911f697ad75de606","tests/interfaces/print-keyword.wit.print":"d65ce208703b66a5975194a0937dcbaeaac680ed1531397c19b8a898928c6c2e","tests/interfaces/records.wat":"f9e0d53435c7769248c794ab5020253b9373924502b9c91a57888e6d254e2839","tests/interfaces/records.wit":"f16376667373eebc30923f6ef498cd4c53da0aee19697538d5ce2201aac03726","tests/interfaces/records.wit.print":"ff31d9c044473edec440a84f57be7686ad7e188459e37b2e2a65e0ee66305793","tests/interfaces/reference-out-of-order.wat":"9db73dc664f876c7ecde018eccea5d5a492e625af1426eaadab3f70f2869c8cc","tests/interfaces/reference-out-of-order.wit":"5f0eeaeeb9e1920fadba1b372b213138eaf9847017721dbfbd865c6f6b735ede","tests/interfaces/reference-out-of-order.wit.print":"a030a7125086f47bdd47b0a1342c7f7021d8e1543ef98ed1b2ebe5d10e375369","tests/interfaces/resources.wat":"551e5b1f2a2ff21581828ed33d7363ee578f06765df35040c879dc6c7be933fb","tests/interfaces/resources.wit":"ed38925057e1dba87722675326536f3e6dee6b3e64ef3db98fbe5fa4811150c8","tests/interfaces/resources.wit.print":"531fb60a5000c349d45153e41df87fc75358c71545a883c98eb87658a949cf32","tests/interfaces/simple-deps.wat":"45794a5e6dd232f0bf8599e4630fd13b6e2391bdba3a3fe930cfa692e8545d4b","tests/interfaces/simple-deps/deps/some-dep/types.wit":"e4f4f705091fd22a378aaf25c1a37035fe1dc9e4f29be0783733d8bc091a907f","tests/interfaces/simple-deps/foo.wit":"76fd1d55c5faeba3157ada8be1c83853ae1e72d8360c84b0d1b8f8b96d1e0dc7","tests/interfaces/simple-deps/foo.wit.print":"c2f307fd4af86e70abb51cadaa5e51ac6bfd5f8c9a91eb61f1bbc67c17554a57","tests/interfaces/simple-multi.wat":"6b16a64f1f5555e6da647f290bcfc9153bebdb42b9f609b46f37792c39271a3e","tests/interfaces/simple-multi/bar.wit":"e3f98501dfb46f873022dac93af2c9aeb007ea5bf0235302b072bdf2b1b5aa9c","tests/interfaces/simple-multi/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/interfaces/simple-multi/foo.wit.print":"45cea7bb704ea1aa2251e2da314dc3b931b165b7c84596e16c5b4c12200cb5b7","tests/interfaces/simple-use.wat":"1da6ead3dd378c25b096c2a70d8846da0a1810c68ecfcedf0727bd6c792c0070","tests/interfaces/simple-use.wit":"d4e734dd1a51b2224ea1fa965b48f39433e60ada1c2619c9836b81e061beb0d5","tests/interfaces/simple-use.wit.print":"1c91e72769a7ef72633c3e82bdb2f97babbf51961e3d10d177076340241cd277","tests/interfaces/simple-world.wat":"8f023d1da8b20a605f04bde1587eff63a88e45e0240dbcdd4647a84f1e993a49","tests/interfaces/simple-world.wit":"b8c42bd20d951065611170b28538430c76dbd492ddca5a2b63f6d85b229a62a5","tests/interfaces/simple-world.wit.print":"cb5ea537abb70459959dafd9c6114f35404f3a23219206f6e196e452c3f63e5b","tests/interfaces/single-named-result.wat":"a9d03772334090d597a595f38611a67630bd2c637b1b2cab7a79c3662b3098f3","tests/interfaces/type-alias.wat":"3f041675d23c6859523a79a9911826dd9174bc1e8b7f4633c7d827403b5674a6","tests/interfaces/type-alias.wit":"6cac4692ce0c825afb6d16e51fd9ecb3a7aa19756269b9dbd73d601511b3be38","tests/interfaces/type-alias.wit.print":"ff3093d72793ffc05b9c2f4ea55eaa86d276a869a3897c58f822443cfd299636","tests/interfaces/type-alias2.wat":"c67254788da372381e84a78eab4ef65104a59aec422da51cfd86ef6a67410a18","tests/interfaces/type-alias2.wit":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/type-alias2.wit.print":"d0821ab9de64a96f24b90c3fe6d6188e9073444ecba789212c206050b3ae02fb","tests/interfaces/upstream-deps-same-name.wat":"86b1ee906d85fcb499c8dd64a03235f3b722b7936d436099f01ed0a60a036077","tests/interfaces/upstream-deps-same-name/deps/a/the-name.wit":"067fd6d1ce097bf27dd260114da6f690f5c54142d7b83fe705b98675e83336aa","tests/interfaces/upstream-deps-same-name/deps/b/the-name.wit":"17db81ac295fdc326bc0960166aeba6d2a86ffe6ae9c493209964098057f4672","tests/interfaces/upstream-deps-same-name/foo.wit":"5634861c80a39d59e3c72e26884487bda2ff6123a5607eb72e6251138f43891d","tests/interfaces/upstream-deps-same-name/foo.wit.print":"76cdc49cd35068d9c6d693550c951db74f588eb0d1bef27b4193093a95a3b802","tests/interfaces/use-chain.wat":"3946c5b08f739f31a9f737480e00a027924723130746b325234693318fb79c96","tests/interfaces/use-chain.wit":"9199d5f59616d83e82aebe22a8652e72c711ec962f6c0b53379c998fe4f64675","tests/interfaces/use-chain.wit.print":"ff129506878efb4f9ec1a441845c645ac63f4006e1e1d641d44c1e5d1667a778","tests/interfaces/use-for-type.wat":"e50dff1dacde278b34144745af52c6337acf001ba393bed4f7f162c913c92e41","tests/interfaces/use-for-type.wit":"86178e6002f460c78b43d9a51ffd13dc5795da4aac54e5f4592dfa11a430b42c","tests/interfaces/use-for-type.wit.print":"c899fc7b4f4fffa41f3abea7c0589f268cd683e6c4c5637393173af949d9b379","tests/interfaces/variants.wat":"3c8f5474ff599463212767650e14e3508d95ae670c6b167cc68026699f27309f","tests/interfaces/variants.wit":"2345402856850aae5db913ac40f01d3bac1ffddd4f2d794d4b92b44850354741","tests/interfaces/variants.wit.print":"63a6847094f8687a7f1cafd8f26a5255272386ae04366b5d247bc893ffe45d73","tests/interfaces/wasi-http.wat":"5442500a42b914985e143ee44dd60dfdf2df949d0d455b731034d604ffbd465e","tests/interfaces/wasi-http/deps/cli/command.wit":"5faadd6c6593aac09a85e8e22b2c842c81b4b3d0a04827195c50e0080ac94a00","tests/interfaces/wasi-http/deps/cli/environment.wit":"8d4f13e628d2e8f029f6d668d8075db5e6c8867238c0436cc966dd9a535148e1","tests/interfaces/wasi-http/deps/cli/exit.wit":"337522eb41c89e660b1dabc1bae362acc462f9cbfdcb9546e790e371580175a2","tests/interfaces/wasi-http/deps/cli/imports.wit":"37f6621e37ad9b15c616ba4289cecb549429cdb25a3b4ee3f80c47a5f04bafa3","tests/interfaces/wasi-http/deps/cli/run.wit":"50815a16aaebae4b99d2e2f9de69ddf30fc27249f41ad3cf477c4e796edf5792","tests/interfaces/wasi-http/deps/cli/stdio.wit":"51ce71cb414d1288b404367b4c05e38ade8b72f54811647aae37d871fadadea1","tests/interfaces/wasi-http/deps/cli/terminal.wit":"ba00efd140adfce72e1368fd92b6fba93a550129d2c8587a9f82bccd96e9100a","tests/interfaces/wasi-http/deps/clocks/monotonic-clock.wit":"3d2605e145081885768e23e1b37f5f065e28f0681cc3764fdaa60c35e74d2984","tests/interfaces/wasi-http/deps/clocks/wall-clock.wit":"35ac466a63c310151c228a313665fb30061c13b1954a7d6dead4c80fbe9f5b1d","tests/interfaces/wasi-http/deps/clocks/world.wit":"e5262f7b911444b28a98cce07a224bc8e7e9c42c175bc4890cf9d458d1d7d638","tests/interfaces/wasi-http/deps/filesystem/preopens.wit":"3374e193f60b3ff89708e56b37871fdfc9bb08bcbd3648a4f7bf20b60fe85169","tests/interfaces/wasi-http/deps/filesystem/types.wit":"9fc998c1251c38ceae23851af0a4f46874b5c456ca3240b1ff6faeec5f101d8d","tests/interfaces/wasi-http/deps/filesystem/world.wit":"45ca19ee54e4a0c9e8eca1d73f1e1e37edf00339b5c3e0f393f444a92733e708","tests/interfaces/wasi-http/deps/io/error.wit":"df792be377ef1ae9dfc186a304ae2cbcc091adb83bfb5fa5b9015fc232a90a9c","tests/interfaces/wasi-http/deps/io/poll.wit":"d3062e06aef89c8a2999067ccbde0c638459a01f30ba2073ac2b6458e0b9ca29","tests/interfaces/wasi-http/deps/io/streams.wit":"2aac4f0b81ca892ef07e9df54125082e266afb9ee2948b3f3f134ef736b8e75f","tests/interfaces/wasi-http/deps/io/world.wit":"1a67af673d0874b5a291a2b86721b1e4c1243127e8b2f6fa4ed954b13cbe87c0","tests/interfaces/wasi-http/deps/random/insecure-seed.wit":"617e58cc9fb5ae0f32cd6db3e72f959ee50f6abb8b9a0e10a5867ca2319b804d","tests/interfaces/wasi-http/deps/random/insecure.wit":"db8c140b96a99ca6e11060e2bd46df3c132f5e16b188f11e2767149b860d46a1","tests/interfaces/wasi-http/deps/random/random.wit":"5319685d7ec484d72660092f8db07c584d361d5ed0abb2893bba6d0724c20f88","tests/interfaces/wasi-http/deps/random/world.wit":"f1cc4028ab9d2ce215122946136a05b14b63225943ed8df86aefd5500bbd3217","tests/interfaces/wasi-http/deps/sockets/instance-network.wit":"ad100127c74b967064cf5d8e1770f6f0d787ef55f07ba9f6b334bc4c98c82282","tests/interfaces/wasi-http/deps/sockets/ip-name-lookup.wit":"aa9d95e64edfb9e954bec156f5ede95560a82ebc9ce80c01d475edc2f371d62a","tests/interfaces/wasi-http/deps/sockets/network.wit":"65c428e7f0d29a4dfb785996e88507ec185ae174a67576d3c09f852683d95f82","tests/interfaces/wasi-http/deps/sockets/tcp-create-socket.wit":"5beb6d1d604227a8e93fa2e63ace7ddee55b4048399046a9fecaee9d4352f684","tests/interfaces/wasi-http/deps/sockets/tcp.wit":"408d55fb8a3cc6971a02ce08a53f2864ec16487ea9f33a3c63b40ad90ee8acc3","tests/interfaces/wasi-http/deps/sockets/udp-create-socket.wit":"1e741a57683f834b12bca49c448cea4080e91b9667d50e28c8a823e2d6ca3829","tests/interfaces/wasi-http/deps/sockets/udp.wit":"01f359eeebb86826ea8f40d885feeb329a3272e439034aafab1e0a1e64ffa813","tests/interfaces/wasi-http/deps/sockets/world.wit":"9944b7b13f9933c0fed0768919ac4c8a8156943d0e82061277a28e0893f761f9","tests/interfaces/wasi-http/handler.wit":"96882590ae9934ca52f031eccc91704d0caf80c6b3227b6e1177e947ce135b24","tests/interfaces/wasi-http/http.wit.print":"c2f9bc786bbd0f91a8e38537df2437aa435867b2b9271808c562dd42b0e5487c","tests/interfaces/wasi-http/proxy.wit":"14f5c16f8c9f82965825fb138c2e317fa87afcfa731f9bfbaa5a02f9f3ebb1dc","tests/interfaces/wasi-http/types.wit":"b48cec546a901b55ed334edad747fb1298121a8e60cddb2e8141ff2187cdcdc8","tests/interfaces/world-inline-interface.wat":"d2c133fe41eca77fae870f5d912c17cad86ab9120419e2beaa7a20fe2c6233f6","tests/interfaces/world-inline-interface.wit":"929f431c2e5e14195de9645d75c79d243e65ee4c55a8e30a5ee1ae4c2e6014a7","tests/interfaces/world-inline-interface.wit.print":"36929a8a8a27296e3a183fa33fe95d243a6d20c4df055d9e5bbdc3bbce85bc0b","tests/interfaces/world-pkg-conflict.wat":"105a5cd5b89df94659c910e7511947c51f49f120f803b665cf69940c5f1c26f0","tests/interfaces/world-pkg-conflict/bar.wit":"4f05ba606e0c32c900fa8e9f9d75b137eedcb80999f454161492f52a452e8dad","tests/interfaces/world-pkg-conflict/foo.wit":"4be2c763fa6801e869aeb8da05cd647931f5f8f7775329555cd9cfd880dfe45d","tests/interfaces/world-pkg-conflict/foo.wit.print":"2ea3a7bc96c6493334d49893bc194a86f9e8fa7d592feac394c20678c5c1b288","tests/interfaces/world-top-level.wat":"80f160c0a98dd0003cf634d9d61899723c71ceda6c7f4ca330f791279154291f","tests/interfaces/world-top-level.wit":"10d04b8d9e0cabf534294ca5987f7523c042f3078048b5ebdf0b20f162ff9194","tests/interfaces/world-top-level.wit.print":"cf23c15ec84ad2c86d7124302c370661d13ab93bbd29e5456677a72148079339","tests/interfaces/worlds-with-types.wat":"e6e4a4527933316268841efe6dff6422212668a79077b43ab476f984ab4c7b19","tests/interfaces/worlds-with-types.wit":"cfa2f8bc82383337e9ae80d2bf7f7c59160642b38137367d8e8bca61d24fad3a","tests/interfaces/worlds-with-types.wit.print":"35a5376b6ad4c17ecee2b99fae6be4ffbddc766e891a4012eabc6a303cb0e1d5","tests/linking.rs":"e23feee175162d6758ba35706e92558546603fa5ed370bbee69cfd76d49c7b5e","tests/merge.rs":"5679426b2585a0b57597d2204c9b46e0b05b8f016dc9f438a7dd3eaa0bc7ba49","tests/merge/bad-interface1/error.txt":"98c2b73a27df07fe64cf3cbee106a82f863ff01c9bd7aab19345d2e33bf9971a","tests/merge/bad-interface1/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-interface1/from/deps/foo/a.wit":"8846a4d47a3a4ea7adec3c75dbfe5f7d95a33f550384d60f5ba57c986cebb0f2","tests/merge/bad-interface1/into/a.wit":"3bdc7af80295ca1761b46d4088bfe63323d87b5ce34ba91a5f86b74dd9daf381","tests/merge/bad-interface1/into/deps/foo/a.wit":"94b2dfe771053f49b3da8acdc65b2e0cd9d6b62c9ace43d7e383f67c3258ccd5","tests/merge/bad-interface2/error.txt":"9bc249e46b3bb5c88cdc9b560b83cd83cd22ef7816fc4f271bdff6627db16b0e","tests/merge/bad-interface2/from/a.wit":"a6647eda48b26b8815a5c96c0d2f492751c50575a61a1b5370f631a1dbd6d6c1","tests/merge/bad-interface2/from/deps/foo/a.wit":"de74c812c40393d061efd768601f8747bd61f7d06d59ed260d9c7da5767eaef5","tests/merge/bad-interface2/into/a.wit":"dfe8e3f49c0e9392a85ce7d852d359728e62465d923e296d4594130110864861","tests/merge/bad-interface2/into/deps/foo/a.wit":"faa98d1f0516dc30b55a1d7c3187a4de73985aac1952d275f21476451310335e","tests/merge/bad-world1/error.txt":"6db444c11f4be2e33e0c2cc6ae98a3d59711e0957c291861eb23908edc65b06a","tests/merge/bad-world1/from/a.wit":"d8ab0c1f6d0a4e566442e4af8ad10d44b033ad928232e3e769862a0091af31ed","tests/merge/bad-world1/from/deps/foo/a.wit":"e49da20e2cfa3484864737126b569e4724fac826ac83e0bb418b801336b37062","tests/merge/bad-world1/into/a.wit":"6f6bd76d039cdc1754c88dcbc57f83cd75ca514481930c013cdb1536add4d78e","tests/merge/bad-world1/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world2/error.txt":"82ea5309efcff50f4b73843f46c28c45ea17d9f3b74415578fd0449445ee8a4e","tests/merge/bad-world2/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world2/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world2/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world2/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/bad-world3/error.txt":"7ce381053e15ac8978fb690eb0eb9f0d9680e6ecad007b3ae5ac273ae2e2755b","tests/merge/bad-world3/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world3/from/deps/foo/a.wit":"548c3bb37a685be2e833e62877d7b453ed05ffcc6c51a5fbdae9ab770d1c1a1a","tests/merge/bad-world3/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world3/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world4/error.txt":"b87d169ad53a2cb5de0aaa38e365085d5ba472f3a5593cd448d1d2aba76e2df4","tests/merge/bad-world4/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world4/from/deps/foo/a.wit":"9af9c4ed27a130ce0ea282613888d4bff0a8d6d1c36d91ac45ac9528e2b74284","tests/merge/bad-world4/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world4/into/deps/foo/a.wit":"f4af2d9b3ea3aeb7d9cd1663e54e526d3dba474a1ae5f66227b7be2433234a3d","tests/merge/bad-world5/error.txt":"5cdeb66fda055177c3a3acd8070e891476e12759204cc9288ca89beb0cce1cc8","tests/merge/bad-world5/from/a.wit":"c81669ef375ad5ea148bf37321b6204f589ac34d5cb4b3efddfcc5840f3a45a1","tests/merge/bad-world5/from/deps/foo/a.wit":"88c8bdbdcd401558214342070b09bbc8454593d682b43de8d7ba6fec98512d42","tests/merge/bad-world5/into/a.wit":"67ed3cb9be491b97919384a8229eff5b9549865e74a8fc3f11ae0169cdc7f653","tests/merge/bad-world5/into/deps/foo/a.wit":"55cc77a9e18c9cc3162d4c5aa982590773d009b3c4307d002298d96fe24f1f14","tests/merge/success/from/a.wit":"9ba239a15824020109d3b7b1b09ff2463a91ee83f174c85acbf08dacaeeabe90","tests/merge/success/from/deps/foo/only-from.wit":"3cb85cffd8f2060149fc6dd2c42259be0af125602cd1f56ca6aa7b3fe5d101b9","tests/merge/success/from/deps/foo/shared.wit":"d75dcff4825dee46320dc97ae6b005c5b43cca83a48bd9c932d2f662e29793d9","tests/merge/success/from/deps/only-from-dep/a.wit":"013b417cdcf40b3203ad2c4a4b2c3d3fdc0930eb05b5095eb03adda5888c6c12","tests/merge/success/into/b.wit":"d46f59c41f4a1f0deb7ba9dc4a30fd68946e4dd228520d0aa94e53771ac58b2f","tests/merge/success/into/deps/foo/only-into.wit":"afd48df694fd9f6be69f123ef0054ebdf54fe40f9de27d3ebd4829f6d3ce2a4d","tests/merge/success/into/deps/foo/shared.wit":"0a2dc3ef6f40a80c125c88a1ef50f7a29ceafafe0a33e6276fda021b43339557","tests/merge/success/merge/foo.wit":"a31a3fb1eee5ba150eff17968de545939a75cf62216f1e634bc319ab0e5eca69","tests/merge/success/merge/from.wit":"5d4ae81da25de51544367675d0d35447959b9ffd38d1addc71b3de43cec2256b","tests/merge/success/merge/into.wit":"f634f6316a61eb8353062dc590bafbdc382b5b660ff47a2fe57a096d37027aa6","tests/merge/success/merge/only-from-dep.wit":"bb258879aa337563aca3efadef46d4267bcc6a364fab0f7b0c83b1ca40646eef","tests/targets.rs":"817c3fea4f0a13f5a162989daa3e77cfe840c61e23039a66874a413bc17f2d76","tests/targets/error-missing-export/error.txt":"5c4f40d87595312b19585b2aaca07212c99a382228c309684c1911b3599572b6","tests/targets/error-missing-export/test.wat":"ecb067df02eb0320a0fdca517e1ed718449f33d6f374bc0c7663e5f142edc074","tests/targets/error-missing-export/test.wit":"3cc01dbf799565f81074bdb2ed9d274ed682c19baeabed5a5422abad55825fa1","tests/targets/error-missing-import/error.txt":"3a666ba746184ad3a04c2f0b7212b26eb4073ded44e887cbb9afcf4c19ede11d","tests/targets/error-missing-import/test.wat":"ba8745404917b9a0900d70377212510d57d90d700002811a826779acd39cba19","tests/targets/error-missing-import/test.wit":"621baefee52d35a98e0459b53abed57ff75969e0dd95c6e7866949e215503c3e","tests/targets/success-empty/test.wat":"fa69abd0e355ea21aeaf9cd3b36e1bf6a4944ee9df0be50d1c764b43eaa1dce6","tests/targets/success-empty/test.wit":"457c6efac7f9d666c5fbb4111fa91b26cb38548be1da2c7c1c0ea89d33cfd5b1","tests/targets/success/test.wat":"bff481f132e976f3ff757f5816e58c79ba7ffabca76184452e048cf75028896e","tests/targets/success/test.wit":"467f876c7e3b3b698517c2df8076bfd1f27cf4764841ec7b1f91f143c8589da4","tests/wit.rs":"160fc7aa322c26d2e6eb58d2eff8eb06f583f34a5f2c6b101bcea67d200910a7","tests/wit/parse-dir/wit/deps/bar/bar.wit":"2319c45fbe264470daeff5718eb5e6cac02ffbbe59af4c14cb1120e401c9dffe","tests/wit/parse-dir/wit/world.wit":"10cddf5af787eb1d0e67e46cca8cab5c3d407ff9cc75f377641dc831153163e7"},"package":"9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"} \ No newline at end of file diff --git a/anneal/vendor/wit-component/tests/.gitignore b/anneal/vendor/wit-component/tests/.gitignore new file mode 100644 index 0000000000..9365962f41 --- /dev/null +++ b/anneal/vendor/wit-component/tests/.gitignore @@ -0,0 +1,2 @@ +!*.wasm +!*.wat diff --git a/anneal/vendor/wit-parser/.cargo-checksum.json b/anneal/vendor/wit-parser/.cargo-checksum.json index e616aedbc7..b888eb8e66 100644 --- a/anneal/vendor/wit-parser/.cargo-checksum.json +++ b/anneal/vendor/wit-parser/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo_vcs_info.json":"e701d7ace82ec8996103713a5ba11137b8188a7084ce2200d5250f7180c21c4a","Cargo.lock":"4d9db2a27e3e642d9ab03ecc1927e06ae2b88fa5900fb424a990bce136e86ed1","Cargo.toml":"d7bcbbfa75bb0ee12fb76a45b75af7f4f92af9c3ed6046866a2315efb65773fe","Cargo.toml.orig":"57732a62b5239a8d7bc42c142b2dd6b332850cf91d9e039203a3272d7a41bdc9","README.md":"fb3e25cd96468cb3ca6b40dfa684504b316ea5b261f14109eb229c4f82442ef1","src/abi.rs":"3b441a5d5ffc5bca83e5c5fcdf808da6d0bf8cbf31b159013b3e063c35489554","src/ast.rs":"834c8c865f35002e2346549903e3f64563e9aed2530f0eda3e1ee4f8e9a35031","src/ast/lex.rs":"6ccd888e92b36d4404142f55e494d1388f06ef0c6875de5d79f2f300f6ee6a27","src/ast/resolve.rs":"4b3bd0a7ed7340b341e90556ee27a9e5b230be481fc68b6347e4e4f75840c15e","src/ast/toposort.rs":"a71e3fe53836645b71b1eb8152314418bfe7ddaa19e1dba259b1534f55711739","src/decoding.rs":"472d64a3688d2910689f51db6e9da1c39796b0af9e33f17b6b39c9a8ca4d2c12","src/lib.rs":"a5fc6f547d5b65696892622604085974bec2cf47fa95aa49afd242a14d447375","src/live.rs":"12d789a63367f4a9b3581a475e854b36ca0592c95cb5f0404dab11bd9ef92232","src/metadata.rs":"fb580e48681dd88c66b7bb915d90383cb4f1a99df8d2a6654aa97a95d1f5435d","src/resolve.rs":"dee35ee2a393239f8089cf7a2fa8c237a9091b29834750b607d34e55b7aedb32","src/resolve/clone.rs":"9c30b89ecdd03f5269590bc628ffdc698f555c7f3627e4d6ec988b939153ae9c","src/serde_.rs":"619855c4049e83b9dfeac2fdc373e72c7b7eab66e39a06ff643b319b2e442de1","src/sizealign.rs":"8d690ade0227f358682b908abb4309060959cc71e29d3deab8d4563e4c47ee17","tests/all.rs":"6545772c9541c29c66c24b316b1c9e2e01f3fda7ae2e5e6e30dd8f3b6a111ffc","tests/ui/async.wit":"e02dcde5e58db33f6a4cba9ef56d2e23f25ff66becd438bea4a3e44a3b708982","tests/ui/async.wit.json":"ada678ed4ef39e8a15a653da9f327327702e00c84aaec49cb6ae2293bc072430","tests/ui/comments.wit":"475f3c841e96ff3d5b845c889382eb65501ed5937e1cafde2fb1cca22eb6af76","tests/ui/comments.wit.json":"8f1b6361031a0d6d462f64e0a0e5d982e758459388b38cd91d2e20d4c40c95da","tests/ui/complex-include.wit.json":"3fe8649db3e11c4fd377534af39930670e7f56ddac550edf30b38d9b796b71ad","tests/ui/complex-include/deps/bar/root.wit":"847bfc51da81c575d28a11c87ba4d1a4c7af4ef4797bff569df1ba7180186cfa","tests/ui/complex-include/deps/baz/root.wit":"f698fdb5d167e91c5c200b72d590ca6efc47b252340ea686a6a6c5b68b32850b","tests/ui/complex-include/root.wit":"1ccb363347433a31d1e72408a7e2581ad428a602dd77c19d2c38a4bdb3011cad","tests/ui/cross-package-resource.wit.json":"88cd432a64f97b22ce3ce0d947236b7c6dab05710746e99117f7d78dfcd73107","tests/ui/cross-package-resource/deps/foo/foo.wit":"a17fa1d030e1e136d0a78e72f1236f945676bf95a6ac269f1c8279fc5891c7d0","tests/ui/cross-package-resource/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/diamond1.wit.json":"65ca1157767b651d093ff7e0578adc71f384f0eb10f6c5f0df7d9d6c7a65a714","tests/ui/diamond1/deps/dep1/types.wit":"0e88c7dea0e75ee462e9580bcab9f95cea6d47ce465b8e3686c579c871fac70a","tests/ui/diamond1/deps/dep2/types.wit":"a0550fd230ae08e270008582a58e369dfa2959d64e35b47b3267c5e66d5dfd9d","tests/ui/diamond1/join.wit":"9dbe89b4a1db3f48c7fddc35bb0f5624d5a7993b9045110e273483eada067037","tests/ui/disambiguate-diamond.wit.json":"e67b1ef121406dafe3e700c7b26542b089b836a5b8b4c0f88e85b59001297d8d","tests/ui/disambiguate-diamond/shared1.wit":"29c7b86eb0b325007093ddc5cd6bac442f2770222552c2578b3df92b27141ffc","tests/ui/disambiguate-diamond/shared2.wit":"9cb9d0ccffc9d0400da97af00f0c6ca65c0b71bf7eba152ce4c17a94befa04f0","tests/ui/disambiguate-diamond/world.wit":"dc44c49f1f8a1831e183efab5705a9b24d1e03d57b24c59d70eb404ed5783ab7","tests/ui/empty.wit":"180aebeccf365462475063f210fc0e2fffd16d415b40c710112daa478fc05d2c","tests/ui/empty.wit.json":"f6e88371fc423cf186127ced701cef2e6a2d1408554be53bea33fc96b50c660a","tests/ui/error-context.wit":"bc6f8bf716ccd78f58d35ce867b3c516b7b9a00129a8e42a3b4284070081ec12","tests/ui/error-context.wit.json":"62d25fc35388148abf493577414247b90d3285c2f1f6a0d5b97f314afdbc4de7","tests/ui/feature-gates.wit":"6421b98446ab4de927677a37455163faafb8ccbe039c9dec9ea3edf601f62c3e","tests/ui/feature-gates.wit.json":"815eae0d8923390b821fdddbe1ba1492b9fc058a8f36f43c4645a84fc775b542","tests/ui/feature-types.wit":"42907c1e0228a5f5046cc977c0cf9fed6bdd2c7aa3df78ff8ed77fb4db9e96e1","tests/ui/feature-types.wit.json":"c44485247c77e2025c24b01acdb5b3b560fa2d6fc18deeac0242ad0ca1ab5797","tests/ui/foreign-deps-union.wit.json":"5d1400e9c28a3180dc934857151408b4d1bc0819b3d76b40690531834c40b608","tests/ui/foreign-deps-union/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps-union/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps-union/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps-union/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps-union/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps-union/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps-union/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps-union/deps/wasi/wasi.wit":"992be12ee11207ddefc2ac531016a9e9519af214341af718972fb653924ce231","tests/ui/foreign-deps-union/root.wit":"4856bf403caea6403cd98b73c44a6277c9af52b7e3c16c756f6cc0e4711e3c3f","tests/ui/foreign-deps.wit.json":"e894a9c94e877c2f92592aaf5e51d71541d7c1d36dcf8d6db27d435ffc0126c2","tests/ui/foreign-deps/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps/root.wit":"532f52d31c706b5ce3dea9869b0aa8fa0c0353309ab2fa9752d29a2aecd7aef0","tests/ui/foreign-interface-dep-gated.wit":"a4e2e64a17b2d145897ddf3280a47df60c80101124c13323bc25485a9cd9057b","tests/ui/foreign-interface-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/foreign-world-dep-gated.wit":"b1f4c36d604270c079a645242690e60083bc39ad9d9a507cef89243fd848f579","tests/ui/foreign-world-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/functions.wit":"909502792a27bcd571e1e4344fb6f0d03412d44a4afa1468f67896cc9ff479a6","tests/ui/functions.wit.json":"4e374a1fb01d7537a76c781e42bf59435babdbd3c3d3f323f886652707688fe6","tests/ui/gated-include.wit":"292d684e8413242ab91efded4e21ad779f3d11c4c48cf42ec2f37a17ce881f2d","tests/ui/gated-include.wit.json":"12139e81b9b0aee7f1f2a8263ec2ce05d8b3b9cf273e53337b67dcc36ee26e63","tests/ui/gated-use.wit":"792fbc77feeed4544311df936c0068335658d3b28b62880ee0f2c4b9027123bc","tests/ui/gated-use.wit.json":"da18c6d1e6902846e17f42c4b3c21c0bbdb4127f0d7ab965e5051ff847fbe9a5","tests/ui/ignore-files-deps.wit.json":"0a65f0ec2fc58a7429f6ef6d45276726e0900c989628bb3c390219db906d6f01","tests/ui/ignore-files-deps/deps/bar/types.wit":"3f6c58f614a5eb6e92dad08c37faf9a7a0ee3ca6bf0fccfa286b94d768375a60","tests/ui/ignore-files-deps/deps/ignore-me.txt":"4636723dbfd9d2967060094fb248e8121fe1620ec8e0e5ea505e66cf1e2781c2","tests/ui/ignore-files-deps/world.wit":"1e3baa2b60d49e5607534fa3d3069e1e2fe6d5084c8c83ca7e5135927ea9f53f","tests/ui/import-export-overlap1.wit":"1228074dc8caf72beecb3c6281e183769b8367d7162832cb9d0647d314a9b2ac","tests/ui/import-export-overlap1.wit.json":"67d8028378a4dc9365242b2b7f1f8bfea1bfec71a2c5df22ce87a62c3d75122a","tests/ui/import-export-overlap2.wit":"23f35f40aaf4b13e2745d201394add251746d523eb553b246f801715d9d79705","tests/ui/import-export-overlap2.wit.json":"087e6e1dd2d2901ed0c4ba31b61d6032859754ecd0abefb947fb2be314ffc9f3","tests/ui/include-reps.wit":"18b45384f26dd1660e721f00fa25bb45fcae247f91925b37b68b96c95d5a1983","tests/ui/include-reps.wit.json":"7fc06783fa6eefc29be483732ff0a07c2cdaee4028640d1c8d194e9d3d2fdf2c","tests/ui/kebab-name-include-with.wit":"e3018a921e3767a5f546713d8dd56801667d69b18353eff2f057b2e10c820273","tests/ui/kebab-name-include-with.wit.json":"eb626e1a2584eb5402ef71241fdc9be07f15a2502fd46dc45c2a03e1252358ab","tests/ui/kinds-of-deps.wit.json":"1b1ca68b2442b696d5afe8bc64094dd101ffe60729b67e9fd0d01fc873357c7c","tests/ui/kinds-of-deps/a.wit":"55532d4e836d80efd73ebda0d942adead4d6caec33076fe54a30edfc337a7703","tests/ui/kinds-of-deps/deps/b/root.wit":"10e833b051706c4882d451f7f66c7152880b5a4e60d75233a4709177cd45ddfb","tests/ui/kinds-of-deps/deps/c.wit":"4d6a716fabf7fe56efdd3de95afc2f520efa6592b10921d8b177b3640ff90d94","tests/ui/kinds-of-deps/deps/d.wat":"91deb49abbe77e312305d6e14ca746ebeeeed99207f099df49e26956add260ed","tests/ui/kinds-of-deps/deps/e.wasm":"33fc738466bf4d6e8dde7ff530a23831e3a42519d30e6f5d63269c292cd7255f","tests/ui/many-names.wit.json":"a15ab09ba624a77d24173f4e3cd2c7044e406e72eb128afa41933964e455bac7","tests/ui/many-names/a.wit":"9381b4e20f448e02d7cb27fe5db24c3f5f37e9ec1425561172edffc6c79f0a93","tests/ui/many-names/b.wit":"e5a20aa53d8673e38465e74f739a5c8cc4789da211fa43490222433c6131e43d","tests/ui/maps.wit":"245328c5953648a8068d0cd1b84cdd342590fd7ea066d650f40dfd7e5fd381a7","tests/ui/maps.wit.json":"6cd99c802177790f07f6708469b0db44f1e7478afdfa963dade9ccc96a1d489d","tests/ui/multi-file-multi-package.wit.json":"5fdfa45865f31de3c648614277721d86539c3e4c34d0c1ab0ff6ef79ddb3d1f2","tests/ui/multi-file-multi-package/a.wit":"4a996c8b1920aeb34f441d44131b3a7870f9769da5579bcbfd4b608e4a675fb5","tests/ui/multi-file-multi-package/b.wit":"b3f940591bd7adbcd1f61cc1606149c4019666efaf8dc76344bf8df89d138e90","tests/ui/multi-file.wit.json":"c64b219ea422ef8d73648ac2485079a7e1a9002ce5e35e2d67b8fe20590a0dc4","tests/ui/multi-file/bar.wit":"5e8d03741204f1e40e7a0f5bd2c043f31a3356c8de296762e2ddb38cfa89cfb4","tests/ui/multi-file/cycle-a.wit":"90612ed5fa9d552068c9c32a0b179355dc92d475c2d1b6521fec494bd9434738","tests/ui/multi-file/cycle-b.wit":"eecc7ed7ce638740ff1cf9fe20914f03b8c3920ddd247c2d80902914c7a4f8c7","tests/ui/multi-file/foo.wit":"ce81ee2316a34b064e2a37e01fa94ac982a663b1c3fc5be55b4723b6643b2970","tests/ui/multi-package-deps.wit.json":"f5d632858f6d4fc02a7c0713daa3555ffb88eed4d8a424dbcac9516291eb07a8","tests/ui/multi-package-deps/deps/dep.wit":"9d66626b787cd5d12b74354bf47e8d5b7e811f208cc512a4b985304ab7856dde","tests/ui/multi-package-deps/root.wit":"62338e53a74a0ca51e6fe81b8fe001a2fda456e64d1779e398525fbec8f236aa","tests/ui/multi-package-gated-include.wit":"109631bf21f46c17c146927e70579661934c28b0e42484378ccb07f65ffc084a","tests/ui/multi-package-gated-include.wit.json":"b5b5c7c2ce63ac25223a5d01ae42f69e6cbb326fb54073d3f58a1b4c904deffa","tests/ui/multi-package-shared-deps.wit.json":"a5a0cdd60e4b8ae10f5b9feff728faef8a81224880af5cc06f73b30757c733c1","tests/ui/multi-package-shared-deps/deps/dep1/types.wit":"b9cbbfcc38f90cd09b1ba9c9b474db0f858f596c054dda59d0de35fbabb26fa9","tests/ui/multi-package-shared-deps/deps/dep2/types.wit":"4f3bd8ecb0e14c6ff670192145dc4b24e20648176634338f7d9aa93ff5863db3","tests/ui/multi-package-shared-deps/packages.wit":"fb9a1bee65922b9d6372e07717899521a129919a23d6700f49b9f953f32df581","tests/ui/multi-package-transitive-deps.wit.json":"466bebe32e6a390148f4b6c9697148f87bacf65454a4825b8c48e565b217d4fa","tests/ui/multi-package-transitive-deps/deps/dep1/types.wit":"58a8ed5ed904dc9d04b7d0f84c400beeb262b79dd63258e66473ce4f36420b4e","tests/ui/multi-package-transitive-deps/deps/dep2/types.wit":"c2b7e5747fba9fbd25ce19b2a8b4fe7fc96831138f68c96e4af4ccc424cb1efe","tests/ui/multi-package-transitive-deps/packages.wit":"d5adbb7f4c6a9f182ee42155475aba911ddc21aea0ef619dfd68f7d4c7ff006c","tests/ui/name-both-resource-and-type.wit.json":"2345a2b52803a70dc14c3a97c5574b49ff23451c10a4036ed2bf6d682fadfb1f","tests/ui/name-both-resource-and-type/deps/dep/foo.wit":"1ff8e2a03e86e0676ed0459b6400b1f92957ce9e88424c91ef20dc2ce98414e3","tests/ui/name-both-resource-and-type/foo.wit":"b8338da8c7e942580d0654de494d68977f459f9e0fef2ffffc164380ea3293b9","tests/ui/package-syntax1.wit":"090709e7f0f85fb60f6a104c7b0ec325d11fc58fcc69a6c20b02f454a0636eee","tests/ui/package-syntax1.wit.json":"dcf5bf4334dc9ca156dc0a9a62d3dccf27ea1ebbe9525ab0b1b992599513fdb2","tests/ui/package-syntax3.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/package-syntax3.wit.json":"e517e1ddee9cc8e123729f3e36cb85fba4328828421415150c99f6dc851c9e00","tests/ui/package-syntax4.wit":"516e3e21f7768a4ee479c0b52b68d3947b6983d0a0c04bba6044c05d784a2f41","tests/ui/package-syntax4.wit.json":"b7b65aeb4a33616707bbffc952e8b94b4d3f32e98a2cd3bcc2bf219db4a41850","tests/ui/packages-multiple-nested.wit":"feedd1dc072442d0183ff04562e5107c3081612e60939c1475a25dcb09c0d448","tests/ui/packages-multiple-nested.wit.json":"7ea283985310c900b7009e6c0c6f68be3d370cf71c831e68d5238dc1bb7ff637","tests/ui/packages-nested-colliding-decl-names.wit":"0875563840447d685523542c20262fb6b181bd0c77f56d4460a56211ce79fcac","tests/ui/packages-nested-colliding-decl-names.wit.json":"eab533e2b31ad4c86dc49ba98ae03e7f74730b01ff97296039b315517c4999e8","tests/ui/packages-nested-internal-references.wit":"8d60a92f19097442d2c17de549d41ca48b1d58025714ec9886153d636747ec30","tests/ui/packages-nested-internal-references.wit.json":"e2537174d20e50c7ce041dca4f1e4ac7a9c08ae16779141f6e9bc16db3b17c62","tests/ui/packages-nested-with-semver.wit":"bded1bf70c7d27493eb53571cecace850bf7e05b559f72b010d431c4a812900e","tests/ui/packages-nested-with-semver.wit.json":"d88a57595b4b70e3365dc3dfe8a387900d68663942b2a27c79b3c56403e314e9","tests/ui/packages-single-nested.wit":"b3c438ef0c0f467ec0dd15202d8b48636860921ce1c313968bbd0fdf4451c746","tests/ui/packages-single-nested.wit.json":"5341b377d4eae34b6acd116ca4d60ccc40aeac5da79d0b47d9c7fdb4cf94ad36","tests/ui/parse-fail/alias-no-type.wit":"6d717f638138d6536c634773058484f26bf1696630ccee86cbd98f20ef000185","tests/ui/parse-fail/alias-no-type.wit.result":"149e701639f259bc16082e7fd84542ac20a11480b8ebe6909788c78f42c9e6a6","tests/ui/parse-fail/async-bad-world.wit":"a5f91bfd0e6eb3d67392ba0be97fa037d73b6193f8014df64313d08e8d8dd233","tests/ui/parse-fail/async-bad-world.wit.result":"c326e18dd5737be4718a428cedbcc2dd177a3603fd91ba3b1bee8578bc65f3b0","tests/ui/parse-fail/async-bad-world2.wit":"110a4409ee12bbf9f1ba2e8264a694220ddc52cf6d236940cd6989d8a907b925","tests/ui/parse-fail/async-bad-world2.wit.result":"8fe7d414eb32a321b3e9b48b3f3ac269a9fa9f186e8cad87fe0fc6f1fd058e02","tests/ui/parse-fail/async-bad-world3.wit":"6f30f04652ab9a126f264540db6b63172e959fc1a189fcd0381605a7f4f103a4","tests/ui/parse-fail/async-bad-world3.wit.result":"ac9b153a9eb50546f14c22b737e45176a1dfdd70514fd53b3c0d277b529b1b00","tests/ui/parse-fail/async-bad-world4.wit":"d607651508ad944f22338e86b9226dfa58b83e7796e4c6af1c5fb65683640997","tests/ui/parse-fail/async-bad-world4.wit.result":"e320b3b7d91e7defab11693f6d316bf6b0d6ed5d7ba58d81cae79e5fa900305c","tests/ui/parse-fail/async-bad1.wit":"8c11bac371904041a93d4f04489e1f0fc2e731a1950a1f4a69d1d6a56fadcdea","tests/ui/parse-fail/async-bad1.wit.result":"55b81beea66b26a65c87e2c779f6b80f9fbc6a53a5f53c325e4bd9e5fb9e8a44","tests/ui/parse-fail/async-bad2.wit":"b779614996ac1c6ce2d5d3867e4c8772c66b093e5274807a83d0bb385b09a0d5","tests/ui/parse-fail/async-bad2.wit.result":"d20e721a50d13841ecc069795026e8ded6cd22735a4007a1748e2e3bf231042c","tests/ui/parse-fail/async.wit.result":"67ccac26d7fe73e8410404092b30398a778aa5bc2b460409c9de50d83f721c33","tests/ui/parse-fail/async1.wit.result":"3a04ed56850e4e60e05f72bd1a7d7646fa14bfa81b049e2d8d6a9dfd4837b3ad","tests/ui/parse-fail/bad-deprecated1.wit":"d792904a2c146aa5f247c23fd420e85565431b6f7975616de32bf78cabb78582","tests/ui/parse-fail/bad-deprecated1.wit.result":"0fa750df748b21c74a9ba10a318c21dd6fdd2f25497abbbda4fb36c2a25b82c3","tests/ui/parse-fail/bad-deprecated2.wit":"d333c32a598d23e0decad6f1f5d9278296bfca1320aca4e12291bc113d6e567c","tests/ui/parse-fail/bad-deprecated2.wit.result":"b808b7fe316cccbb96718b7f1f73ea0746af074d0305b6bd47f762e70732ba6c","tests/ui/parse-fail/bad-deprecated3.wit":"f72813a037e8718a7315fee317a080dbe73f3e44df0bc42408c0b9ccab1041f1","tests/ui/parse-fail/bad-deprecated3.wit.result":"e96dcb21216a1a2ae5e0ff3d063ba88dfbb610f5ae09b51853fe69ebdc44f96e","tests/ui/parse-fail/bad-deprecated4.wit":"96ad0d172b69432598acd101e2de83a6b36ef6c6980075d994d3961becc7ffe8","tests/ui/parse-fail/bad-deprecated4.wit.result":"443b255aed5611c14cf1751cd4da2dcde6d875c93599a5ae1bf999e913eb5a4c","tests/ui/parse-fail/bad-function.wit":"ebdaa7b0c3fb7713bd869b510c222e10e0fbe6b5e3c93b3ba8f077b59a9cdee2","tests/ui/parse-fail/bad-function.wit.result":"3480be5e024671f00c1a1d49b0b394dbe145b58d8100f89dff0912d7c39545d1","tests/ui/parse-fail/bad-function2.wit":"e501d5d676b0647999c3e508c4a494ba652cbd16c275be17583ae5fa02bf5e7f","tests/ui/parse-fail/bad-function2.wit.result":"a1c0b324816fd854dd85e9b2f29f9d3e09ad6a7f670244851032a734c96ed67e","tests/ui/parse-fail/bad-gate1.wit":"d427d68abe2e93f488569af3fecd08d5c6bb984ec461fac4f184a2b977d903a5","tests/ui/parse-fail/bad-gate1.wit.result":"21393b47dc8d07dd405941a137f55d94e6598efd449404aa3c42b57a3665b147","tests/ui/parse-fail/bad-gate2.wit":"dd536d413c6b7a0a59a15d39fdd1a52d7a4810d3900c59f8132fbf14d32da3e4","tests/ui/parse-fail/bad-gate2.wit.result":"ba82c990dbd4fa001d4ecfa46bd8730ccfc49a6c873265b0b81cc8454c9a58ab","tests/ui/parse-fail/bad-gate3.wit":"5e0d76a3029a0520b121f2ec6823ca39c3d3adfc57556c849898f69240f83a44","tests/ui/parse-fail/bad-gate3.wit.result":"b70ac740092d59b2d1e56c00e20c5bcaa9843f7a3072cd9f3c0a769818c15b78","tests/ui/parse-fail/bad-gate4.wit":"f5fbb50ad5087d0bb5401d290f05e733ee425bbffc514db3a2ed4d0a0dd366db","tests/ui/parse-fail/bad-gate4.wit.result":"8cc9f8a27b97f5861bacea7462002f3d351ea2038f54632d245385b0e9b95b68","tests/ui/parse-fail/bad-gate5.wit":"52b068c1f00f38174f53927cd7729b78648be636e2a7e2544397a8ea9ea8569e","tests/ui/parse-fail/bad-gate5.wit.result":"5fd577243fad4e78350484c79126566649b25a3744ede72e522baa138dca5034","tests/ui/parse-fail/bad-include1.wit":"05ec00177052bacfe2eef6ee2631abfd373a822d100f8d38d7178845cf3d2908","tests/ui/parse-fail/bad-include1.wit.result":"454bef60e7a0eb813b80b9e31187cef96bdbb389389b4238cc1ed45788eaa351","tests/ui/parse-fail/bad-include2.wit":"32d2bfa14dd78c78aecd93b31b28ba7013701411abd8d67e8c5277f1b8efd1a9","tests/ui/parse-fail/bad-include2.wit.result":"70e86e41d76100601131e14ce54df803ea699f4f7941a84e4a56ccd6c2f28d2b","tests/ui/parse-fail/bad-include3.wit":"44995ec365758dc52f7dc6824587df97777dd874f5d010c62222881a5b3ed929","tests/ui/parse-fail/bad-include3.wit.result":"fbe950700e42783b2126d0dddeb08a2fef837b76de2aa62e8f70c62fda7359f0","tests/ui/parse-fail/bad-list.wit":"20255af34f429589b311fd29367e4f7679eb8f1667538522b048ec5d9e5886e0","tests/ui/parse-fail/bad-list.wit.result":"b8323d11bf88203feee59ae6cb0f67a017ee75183e635269cec9a37b4518e38c","tests/ui/parse-fail/bad-list2.wit":"8325a40a06f2c29c0f106e39652b2519ff40a11f0829da3d32e2c91fd05dee81","tests/ui/parse-fail/bad-list2.wit.result":"7dd98a2e45abaa0fc1c97133df251aa57f855c112f46cd99f2c948e9a425b8c8","tests/ui/parse-fail/bad-list3.wit":"070c1d4580008679e693d5748069c67738620f36958bd71533aaa0813516edd1","tests/ui/parse-fail/bad-list3.wit.result":"460b21d80f73f1d518ae7723c436092bcae56d036c84cc6aee9c6cb616e4e3d3","tests/ui/parse-fail/bad-list4.wit":"474d295829f1303800b0e52ad5e9ff1f997c8f6db5a33028cc0a8502310e310d","tests/ui/parse-fail/bad-list4.wit.result":"74df59ff1e7058f1be49457c7eb8b77dcdf5fa06c007b6e5e7167990fad30b0b","tests/ui/parse-fail/bad-pkg1.wit.result":"8a63ad8c4e708640df5a2a7a064bc26d4ed64a3338215c5cae52518dc0a0f3a7","tests/ui/parse-fail/bad-pkg1/root.wit":"45df62dc512d8f9ead7982c32ea95318253fc243db73cf3b25aaefbe05778c4d","tests/ui/parse-fail/bad-pkg2.wit.result":"9423d8216ca764758513f53bef83fa053e49835f0bdb5b8bb77136b1d391a50f","tests/ui/parse-fail/bad-pkg2/deps/bar/empty.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/parse-fail/bad-pkg2/root.wit":"3f04dc4f6d4c4adcf178cfeccba312f75439c3bf6a14f9f4d0bbc7d83e259582","tests/ui/parse-fail/bad-pkg3.wit.result":"444c65ff4abf7fa1c37a5403461539013c139ce49dc3ba0cf098683e4870d373","tests/ui/parse-fail/bad-pkg3/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg3/deps/bar/baz.wit":"f521c75f8fea0201278adcba4457115de7eb856a3338ec03dd4df223febe7409","tests/ui/parse-fail/bad-pkg3/root.wit":"3c1725bb749c1ace117e290e0085358bc6cceb4aaf9a6fc1e29c82c5a581ad24","tests/ui/parse-fail/bad-pkg4.wit.result":"cfa526440ae834e59214dfa67f92b0a1f013b4e54d705ec56a4f5341fe9853d3","tests/ui/parse-fail/bad-pkg4/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg4/deps/bar/baz.wit":"f0d7f373a2981f747ff15f994d10abdb7c5d9dc7181daf8e4b4610f98807658d","tests/ui/parse-fail/bad-pkg4/root.wit":"2b060a7ce9da4b0cd8960a28f069f046902633fdcd5dbac2f827658ab674f5d7","tests/ui/parse-fail/bad-pkg5.wit.result":"63d5877b3bf734e1900472a219ef4f20411bdf4d6608eb582ee342a0de5ce8fd","tests/ui/parse-fail/bad-pkg5/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg5/deps/bar/baz.wit":"43ba055c268fbdd4686b141395ce8582e1cddb6699b9564b10793a603abbcd37","tests/ui/parse-fail/bad-pkg5/root.wit":"8fe9c00d8a56e994c9914997d926013e43e01f6b610b27bb3311a9c89566bfbe","tests/ui/parse-fail/bad-pkg6.wit.result":"4c3238fe2df05329d6475277d73dc1731affa5b62717904b536f0609ac9c7341","tests/ui/parse-fail/bad-pkg6/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg6/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/bad-pkg6/root.wit":"62abc0d5005b2bc46c039978a056e3525c165c29449bf617ca2f4afdb6ebaa98","tests/ui/parse-fail/bad-resource1.wit":"d3783f455c501334f2ae8d132490afffee5142ad1e94ceb3fb0e576299419147","tests/ui/parse-fail/bad-resource1.wit.result":"63fe0c9f4045c9d1643a328d007807f34e495ed8b25c429b65f5721147e842cf","tests/ui/parse-fail/bad-resource10.wit":"4158f1b360360ea4e4429720b34e91b9d259eada8e574733af3c83393552fd38","tests/ui/parse-fail/bad-resource10.wit.result":"f4ed54d9da0802ab22cd25f00f300f8d9bfd1a34820b610ddb37336e210cc40b","tests/ui/parse-fail/bad-resource11.wit":"24459fbe029d94febe36a6823d5992a59732bc8b5436c4bedf2c5192e2c20be2","tests/ui/parse-fail/bad-resource11.wit.result":"54cd069d5119f632d36c4167a7ea9032ac9daa3564691aefd25473d474ab32fb","tests/ui/parse-fail/bad-resource12.wit":"da12b00ae70ece5df5faf295a75b484e89ef3bd5edb07bd7b76bf7dadb04dc45","tests/ui/parse-fail/bad-resource12.wit.result":"0fbb864a5ebb00a53afb87524a534a77de5fa5122d95bf33b7f92e217326fc44","tests/ui/parse-fail/bad-resource13.wit":"e01ae82c5dc83a1f201fb9942b01f469eddd63741a12e14c4b97510cd0b74daa","tests/ui/parse-fail/bad-resource13.wit.result":"f937ab865f5cf26b0302bb94126c2482323fb31d3c4ce606cd10d5750600f8c4","tests/ui/parse-fail/bad-resource14.wit":"ed4450c13763dbe83921828ae23f8900ed88de70ca0bf989874c31e88e929cba","tests/ui/parse-fail/bad-resource14.wit.result":"ac54d2dae60e13d89f6f1532ee4629a9dff3d410be0e9bcb37025d77da8d9176","tests/ui/parse-fail/bad-resource15.wit.result":"8234ca2888cd2ca50708c41de82461bbf64997269032e9a221b6b66ebcbeaa30","tests/ui/parse-fail/bad-resource15/deps/foo/foo.wit":"19b517ce45a205776724b53a0296780751b757e80b4836a0c1230f1238ec2f69","tests/ui/parse-fail/bad-resource15/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/parse-fail/bad-resource16.wit":"c1b3724b5a2d0689db57521fb35f0e8f47302fff277e5fac4e077712b8d06ed5","tests/ui/parse-fail/bad-resource16.wit.result":"6684499b5f7745fbdefd81ae2b9507125364adc3799650f1ed9acb551daad264","tests/ui/parse-fail/bad-resource17.wit":"e3da1cf497d48033f3a91d25ae2f7129de54c004c9b448e5e810ceb2304364c9","tests/ui/parse-fail/bad-resource17.wit.result":"03cf4d36938c5ab1b0656e3ee0e0c0de66707cb0791cb7fb969723d042c40dc9","tests/ui/parse-fail/bad-resource2.wit":"78f8e65877b7254aaf8f448f7f5f4e50774d797fc3eb64ca2793532ff16a62ff","tests/ui/parse-fail/bad-resource2.wit.result":"d0d968ebf8a06cda2946fd4b30595826a6db0ffa40f71ba5472884e75601313e","tests/ui/parse-fail/bad-resource3.wit":"e8620477d3cc02bc3b130d2fc14f2431fffac0cf516cbc05aff2dda37740f2fb","tests/ui/parse-fail/bad-resource3.wit.result":"b19b0a6f8ba99e738504c433afb19e7f17081db14d10dc01506ade5c31b11cb9","tests/ui/parse-fail/bad-resource4.wit":"31537bd0d09e58dee09ea9b93054c8cbb3cfd39bc4a1fa9330bd7b945bd81681","tests/ui/parse-fail/bad-resource4.wit.result":"bca647b5172c6c0bceea3de7ac2dfc7426b68e55468d081beade9b4ff2b0b0fc","tests/ui/parse-fail/bad-resource5.wit":"854fac37c2b7c8edae5276aa1c7c6cc726a348ae757c0f9cc5cd4103d75dc640","tests/ui/parse-fail/bad-resource5.wit.result":"db20186fc1b39c832acedadcaebf2d1f7f803253a2df5eb57b7fd6f66f8d7b38","tests/ui/parse-fail/bad-resource6.wit":"a5f798328cbf777cce00069a637f1dc7d79423c685ebe11a21f7f8ead1bccef4","tests/ui/parse-fail/bad-resource6.wit.result":"1955db627b4a2db9dd86d37974567454572b222bcb33e70664393b31e244a0a9","tests/ui/parse-fail/bad-resource7.wit":"7d09275525b419858d26533211b6a9d3a7b67639e8aa1fc28eabd713dfff4eb1","tests/ui/parse-fail/bad-resource7.wit.result":"c62958d5564b25268b662677cd35b24c4131d985d906c2d61a80bc61ba11267d","tests/ui/parse-fail/bad-resource8.wit":"da8489525fe75a197731293d384c151da204fbb2a278b9ab7a6c30fee45efcdb","tests/ui/parse-fail/bad-resource8.wit.result":"eb657e7afedd3fd1b849780564c5b0350888531fb19092961181d11e31659499","tests/ui/parse-fail/bad-resource9.wit":"5bdde3d51bf8f3e86752a21a31d93776a6b390e41ae9aeedaf7b829e7afd8f19","tests/ui/parse-fail/bad-resource9.wit.result":"d2e74db311d6ddb2796837e9426a58b7a02e8140d72a6a681eea6f54a8731f9d","tests/ui/parse-fail/bad-since1.wit":"8180c2632f6d75ee675528f4e9fad184ea5c9675ba09f34f61d7bca5ced38344","tests/ui/parse-fail/bad-since1.wit.result":"b6023204b3da7c1f58491609dfe5016b05bb8b8cd61b5b38114591c01b24e1f4","tests/ui/parse-fail/bad-since3.wit":"477408c0e355c1383103aecbd4bd4769df5ce251bae1ae5405183dac9a920c6d","tests/ui/parse-fail/bad-since3.wit.result":"07a4d9d40e6fb85da01062a72e6dc0e3cab81fc6a9b5223796957fff492ded90","tests/ui/parse-fail/bad-world-type1.wit":"c04002fdb48270e72f804642932b84f8a0a6acdf03d335e7b809c61b9e5efe64","tests/ui/parse-fail/bad-world-type1.wit.result":"2073c4406bba9ab314d172840c8b43f2e505bee7f823a21abb0f7c649d81a504","tests/ui/parse-fail/case-insensitive-duplicates.wit":"0517099b9586ef9a1a22e4a340e00b3f9088891e5203906ee2303e5e47cf9a49","tests/ui/parse-fail/case-insensitive-duplicates.wit.result":"6404ed765277711fe927b011daf90c20a69942ed2578458a0df285424e6d0cf8","tests/ui/parse-fail/conflicting-package.wit.result":"7577d7f04ab4ecd2401b2b546d46cf42f3951d30f8a118ab843c043194599b33","tests/ui/parse-fail/conflicting-package/a.wit":"20fd778f4594d89d4b3282ed2b4e005cd3e7a377eedbd9a05ba9b96468f53d55","tests/ui/parse-fail/conflicting-package/b.wit":"05ce70a45e9d19c833579bdd20a4fbbc98cc2f2ce737e1030e41f35cab4f0066","tests/ui/parse-fail/cycle.wit":"6940cebea92951af95a7a352f76ec8c79326005a0698e977ec362923ddbddb8e","tests/ui/parse-fail/cycle.wit.result":"09ab288a56c511e8cea5cae9b72f474a4f2cc6ad4bf2840ee10d10e45a144d0b","tests/ui/parse-fail/cycle2.wit":"5c7d28994b1fd872236a03238d9d1b757eefed741a1e540a4bc55e0c2ad0fde2","tests/ui/parse-fail/cycle2.wit.result":"eba74322800b7476a356ad73d8eb40aa5165389624c555d58616144e11b7672c","tests/ui/parse-fail/cycle3.wit":"0f4c613e93478afad6065642b60b5979a8df4ec1e13359f0c9824a218c966de6","tests/ui/parse-fail/cycle3.wit.result":"d98f5432924f5feee6f1a60ace1c0dd82b555a260502b166ab51bad0312e82ec","tests/ui/parse-fail/cycle4.wit":"74fab6b8fff3e176bc1499f3e0acc46f1746e8664a7b0307389645e7ef03b696","tests/ui/parse-fail/cycle4.wit.result":"4b4c4b912e4363eae23b6ae92cb4e499f0582d24299912aedcc0ab78b6ba0e67","tests/ui/parse-fail/cycle5.wit":"c21c064e42ec81544a0ae5cfa0081313b8023fc4cc6725b27a8307ea0acc43cb","tests/ui/parse-fail/cycle5.wit.result":"155993cd465deceded417e0eeac9c04a50adadd6a521786e3a0d3b33b352c062","tests/ui/parse-fail/dangling-type.wit":"61ab6f89a622be1f4003dd4c6841d780646b78f314c0759b77dcf6b2bb91e355","tests/ui/parse-fail/dangling-type.wit.result":"d5d60bd20198bf6fee5066f0bb1bd1a6129a7b23ee28fd623a540f6830267e13","tests/ui/parse-fail/duplicate-function-params.wit":"7c86f5515793538b821a4797f4a8456930329a0fcd054d29e1b7b1117a29d295","tests/ui/parse-fail/duplicate-function-params.wit.result":"614f85899af13a69cf98d762c61d3e607dcfb3d3ed7e4ada211ed1eb7af8a9c9","tests/ui/parse-fail/duplicate-functions.wit":"9ff1bc0093dbe55b961e8a5f4b528c145c1d975bea619b2936cd6cf839edf0e6","tests/ui/parse-fail/duplicate-functions.wit.result":"aff563662f466c0bdaaec5bb197f0aeba8b31c7e962f84a6a1a26c3944601ffc","tests/ui/parse-fail/duplicate-interface.wit":"3acb5212bebafe8eb10e0176f74ffe999b20d9cdb7ce82f09672584a043f90eb","tests/ui/parse-fail/duplicate-interface.wit.result":"8ae55ae32e250a01caca352d9ab03e4a062060095f6e728011b8677fdff86de2","tests/ui/parse-fail/duplicate-interface2.wit.result":"f4f24a6a163cbe68f74613708cdd1b409fd55c775967c0983e466c5b1542a25a","tests/ui/parse-fail/duplicate-interface2/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-interface2/foo2.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-type.wit":"0d1623865f9cb358f8344fa954becf249e948ee37bb22004c1405602c2f083b4","tests/ui/parse-fail/duplicate-type.wit.result":"de1f41c3125a8ef52719b845bb685b1e735c504b3c7b63e39374f826d7315055","tests/ui/parse-fail/empty-enum.wit":"4d345214cf0ee46c4b4108fc0e9f7b8aaeb7eff82171400aaf45c1fb283e558b","tests/ui/parse-fail/empty-enum.wit.result":"6338ac28789456fe02aa133185e8c3d9896812df9377d2211da2dc0f23076c67","tests/ui/parse-fail/empty-variant1.wit":"1f56da64ab09a7f282b1785241dae5bfd8ecb4bbd055a22dcdebed33971f1522","tests/ui/parse-fail/empty-variant1.wit.result":"d67d08b7b070a59b0f803d3e118dfad4ae0cfbdc404965a5cfc5c5198fde5fa9","tests/ui/parse-fail/export-twice.wit":"a3a7cf6e7cbbe513c5561a93e32f030364c622b5123118392e9e2aa6ae44dfef","tests/ui/parse-fail/export-twice.wit.result":"01bed0e73b437ccbc213a389a512a7dafb9a336eeb38d151cdfc8e14e98f450e","tests/ui/parse-fail/import-and-export1.wit":"626f705beb7506cd30d2adea9b339199f9e6d8ac6f62f5f7778e2e2d683b0230","tests/ui/parse-fail/import-and-export1.wit.result":"330a6ed19e4c4e0e89358e599110f5d62bed823e6e5982f576a23e0b25034ee8","tests/ui/parse-fail/import-and-export2.wit":"617a1b3d8e0b227eb4fbf74101133deb537ab5723811e9cc658d8bcb942425a1","tests/ui/parse-fail/import-and-export2.wit.result":"ec0b14b07e21bb21157155e9d056e1cc303affe16fc1536aaae5c948021ce6fd","tests/ui/parse-fail/import-and-export3.wit":"adc857f5752dbf55460be01bbdd19fb54dffedeb1781ea8f842a05041ae6bab5","tests/ui/parse-fail/import-and-export3.wit.result":"9a99411b891ffe302d8070cc8ad280cfb815a17c1d0cd4b72bba3e65df20dd6a","tests/ui/parse-fail/import-and-export4.wit":"9fd002997b30219720270a8c5399bfe45d55737d9052306c992f6eec30c4aad1","tests/ui/parse-fail/import-and-export4.wit.result":"6cd95a14a1eca775006c558013ef3179e715dc913f5d6a95e23cfd3f4bf4cfd9","tests/ui/parse-fail/import-and-export5.wit":"343bf3eeb13507dc168f1478ca452cf36964f002aad051f0283ff8a95ea40747","tests/ui/parse-fail/import-and-export5.wit.result":"ac812b21785e1f0244bd8ab5b59e94b57e29c5fac5db56c2fe339c92362e324a","tests/ui/parse-fail/import-twice.wit":"ba1975d057920962bf325b034b4ca2cfa7587e2fa79ff0b2bca4a0f950e0806e","tests/ui/parse-fail/import-twice.wit.result":"cfc3f8da5f3e65c73992dd7d39f5e3ef9b9154a883183bb7f3cae7339cef7c65","tests/ui/parse-fail/include-cycle.wit":"0c51410fa39f6afa1465696c4ff97b1496c6870dc8fc5a2a2f3c2a4826c24685","tests/ui/parse-fail/include-cycle.wit.result":"95e03934ed9695bbd1856fdbf4b588a429ee41ade3447e664edadda5c8c01256","tests/ui/parse-fail/include-foreign.wit.result":"5662f77092ae988280c0c1eb1f76a81297fcd2c23823f1cfe0904584bf1a36e8","tests/ui/parse-fail/include-foreign/deps/bar/empty.wit":"348f61ad0f69954f7438ebde4cd03acf45ee8a83fe7ac53f9f52576de2fbb30c","tests/ui/parse-fail/include-foreign/root.wit":"d436297400495dd1236cbf0b6268f3663722660e140f1ae68b3ba600399adcef","tests/ui/parse-fail/include-with-id.wit":"3f50cfcbeb23cf182941e6b273136d83b57531224230f47edf4ba6dc16ce40ce","tests/ui/parse-fail/include-with-id.wit.result":"03fa45329b179073500e002fbe014ea48e564ae7a274dbcbb0bc3b5d39959c89","tests/ui/parse-fail/include-with-on-id.wit":"64dcce8aef4c9fcc30376218696070d8f6a3d0d767fd00abb8c2f6672a99cc60","tests/ui/parse-fail/include-with-on-id.wit.result":"cd893a62379128b37045d0c81364e43c8c8fdf372811183c6aa95c6d17a7ad3d","tests/ui/parse-fail/invalid-toplevel.wit":"c292a6cf02880d580b76ebcb0aafbab2bf6c6f8545299016f9a0bc55dab16624","tests/ui/parse-fail/invalid-toplevel.wit.result":"23c34234dd7ba5af3c135487c7607442c6b45b9a328973ddd1bb3bf841ec2148","tests/ui/parse-fail/invalid-type-reference.wit":"61f8a73ee71a39489ff37a41967cdfe011889c25c1623af939cce809562b1915","tests/ui/parse-fail/invalid-type-reference.wit.result":"d0169e51f599096c65186211656e9b007f01698d2004d4ddc9ae26cbc78bcb57","tests/ui/parse-fail/invalid-type-reference2.wit":"9e1b00da3e1d7d39720c41cda330c3ffa338eeb6ab2faa25ab64332108a0e06f","tests/ui/parse-fail/invalid-type-reference2.wit.result":"a9b2a4a2b69b966e3a3d2ffa4a7f94abd775a02fba877f7c7ddb9ebc76a136ab","tests/ui/parse-fail/kebab-name-include-not-found.wit":"ac48583cf9bf4716cbbf22d6356dd897bbdc657530b9e02168b920da2928bd72","tests/ui/parse-fail/kebab-name-include-not-found.wit.result":"f56ed9f900ad4371561fc149bd0429261e10bb26ee76cff57c527febc502cd25","tests/ui/parse-fail/kebab-name-include.wit":"f81884221b5f20a69015ba9f94915785f9a7fbb5eaf8a02883ddabca510b7961","tests/ui/parse-fail/kebab-name-include.wit.result":"4c48c8a2b849e53ead974720172a4de0881a426a8717a024202a2329cdf74a3f","tests/ui/parse-fail/keyword.wit":"cd46fd9b045e79e0f5f8ace13a6327ae83e26951f699b25d6e0a872fcac71010","tests/ui/parse-fail/keyword.wit.result":"ef1b6510fb56e899c6bb38592a1953d165e01c5a46bc02249c33b73f99f28740","tests/ui/parse-fail/map-invalid-key.wit":"612eba223b7882277f74826312dd61958dea73443dc95ef1f6ddd8b5f4680c91","tests/ui/parse-fail/map-invalid-key.wit.result":"51555d75fa2b8b8897be3a7136829c35513a896344992d7543986a5ec4fa021b","tests/ui/parse-fail/missing-main-declaration-initial-main.wit":"208a8e0aea83d0aaf50edb322181a1b35728ee972bc7929b63f881ab3a923cfa","tests/ui/parse-fail/missing-main-declaration-initial-main.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit":"eafc130098a084cebb71ed07c84432bbe8269d92e5c999728136cd90b99e3bb1","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-package.wit":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/missing-package.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/multi-file-missing-delimiter.wit.result":"0d5af4fc565143f116b46ab61e6a4b5fe4d74325af8c6b6180c3ee6a44516ea8","tests/ui/parse-fail/multi-file-missing-delimiter/observe.wit":"bea33af0bfc096aa7058a5d670322f67688b2927d0fcb1eed856593cb5c93b97","tests/ui/parse-fail/multi-file-missing-delimiter/world.wit":"d78271de8c919905008fb0192328770738f31cf2edf9310e7824bad487492c3d","tests/ui/parse-fail/multi-package-deps-share-nest.wit.result":"f4c43b6c9abefe4e13b6224c057276f30a8355363936e0c1c2b1292808f61147","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep1/types.wit":"dccf32826372acf61a4132d118d1759874c83b5e3032dcedb91fb283489bbf28","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep2/types.wit":"ccb04fe89839748a7cd9c09d333acd549c4900d84ea1d57cb8890d12ec4303c8","tests/ui/parse-fail/multi-package-deps-share-nest/root.wit":"7b874fb105af381d5361283b115d7d38885e6a055fa5af6867a85f03207ae7f6","tests/ui/parse-fail/multiple-package-docs.wit.result":"db1231691632699274fbdf8a94cbb52a3ddfd429870ddeb8eb15b11ebea0def5","tests/ui/parse-fail/multiple-package-docs/a.wit":"456ace15e375131385fa74f93d676b80ff9179a77b2a8c4cdf01e4cfeca80527","tests/ui/parse-fail/multiple-package-docs/b.wit":"9ad7758e29c6b08f0f072c8ab7ecedde3718abd161b2e05c284d46f95e68b208","tests/ui/parse-fail/multiple-package-inline-cycle.wit":"4c993b0b8a83f68090b85db4d95872145069d5bcd946dcab8a878770726e0b24","tests/ui/parse-fail/multiple-package-inline-cycle.wit.result":"a624984751c8f0674b50c4e297720b104658b5d9ebb15098717fe443ca3d0197","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit":"a45426e4136e28663f40278e268a390a7562027d6cb6f27168576e3853d66b25","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit.result":"1a416a1576e387ecc0d34b9a922ba7e5f536b6c48c46a881950e0100c1f569f6","tests/ui/parse-fail/nested-packages-colliding-names.wit":"a528b3e1dacab79c7aa2c7ad6ed42da2f0061c242f178d42152c25f45ead1baa","tests/ui/parse-fail/nested-packages-colliding-names.wit.result":"f2d637675a851babb091b4f6dfe8410bc48b5505499b65ef3519f714cc5d9ba6","tests/ui/parse-fail/nested-packages-with-error.wit":"f8d310644b61d2b0eb4641a003d8c1dbbbf8ec3f98752b3b5ec791d2a0fa7f58","tests/ui/parse-fail/nested-packages-with-error.wit.result":"973d5a905fa8c6149d03978458a2c63a4646a37b9541c5f045abfb1742ece093","tests/ui/parse-fail/no-access-to-sibling-use.wit.result":"3b640ef3569ac8602f155fdbbaa503203dd9f9d01c53c7b6c693787dea408d2f","tests/ui/parse-fail/no-access-to-sibling-use/bar.wit":"e52d3b5ce50a6c3260a367256406d67401d9a48c3aa9bdbb5c9dde30712951cd","tests/ui/parse-fail/no-access-to-sibling-use/foo.wit":"5c4d88f6af280b678722f265775abec5c577eae47e5be275d9bb2ae2b3092a99","tests/ui/parse-fail/non-existance-world-include.wit.result":"8179176b5d30fa1d472cf7269277753ae8f28d2337fd3d4d9409256df24391f7","tests/ui/parse-fail/non-existance-world-include/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/non-existance-world-include/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/non-existance-world-include/root.wit":"758be0657b943a7718ea8b8f6b68e39a71264f6ea55ae1602ea993352b7ca939","tests/ui/parse-fail/old-float-types.wit":"a331d50c87423e3ff6683e2a43b514d404e7c7920a4951e99bf7dd60b9a8e53a","tests/ui/parse-fail/old-float-types.wit.result":"1131f9caaf4efbe23923c836b71621c3a8c3b3b3293a1e4c6e1a8c589fd34ce2","tests/ui/parse-fail/pkg-cycle.wit.result":"9331660c2b320ad8e2b8477b1797769ed119137df99db9482c2ead7ad18dc573","tests/ui/parse-fail/pkg-cycle/deps/a1/root.wit":"a401664c52777f3542a756eb79a2344ef4d569908df54e15a0243c31aa77b58b","tests/ui/parse-fail/pkg-cycle/root.wit":"4d42e9e04ba377787b944aec6cb44e3ead0088d7130647db5ca67b4cca7be490","tests/ui/parse-fail/pkg-cycle2.wit.result":"048547c47dd0e85ae7df58f3492090c699b271b326f632900ae1e20ef81db276","tests/ui/parse-fail/pkg-cycle2/deps/a1/root.wit":"122dd6e3f2f3f4569b44533ed967b5facd458c38116bdcce3f936f3642005180","tests/ui/parse-fail/pkg-cycle2/deps/a2/root.wit":"b16a1b33f2525e49d3f3691fd1d43598a0e4cf0015bdc7a9979b73737085a830","tests/ui/parse-fail/pkg-cycle2/root.wit":"60bf50dbc32c8b2e702e042358884c293372689fb0a8a34866897fe995ccccd9","tests/ui/parse-fail/resources-multiple-returns-borrow.wit":"79b3bcb55c4df39cd2037e547aaa2200f920591722517db34652e7ad4e766b50","tests/ui/parse-fail/resources-multiple-returns-borrow.wit.result":"d4c6f5075e50d48dc277c5940d34f58640e8d78b2dad6f9a2f5827d975a11328","tests/ui/parse-fail/resources-return-borrow.wit":"7be90d00f626f87b85990a97d26862f5a00352d67acf4a89045c197cb555e6b8","tests/ui/parse-fail/resources-return-borrow.wit.result":"e43f5d3e7c577d8162b255cb0ec3ea0731634dc63801996fc9f7c328cbb36942","tests/ui/parse-fail/return-borrow1.wit":"1e76d092f4919748bac9db9907a638c26a6ca92ab599f026261511f8c2a662cf","tests/ui/parse-fail/return-borrow1.wit.result":"ff77a7717f0baa3b440edf0f9ab5d2a515c99d19a7f159db6f0d11dce06f18bb","tests/ui/parse-fail/return-borrow2.wit":"f707a3ae6de39ed0db7746410506040dcaa2621324b996708d54aba02c9c49bf","tests/ui/parse-fail/return-borrow2.wit.result":"f64b3af5d0c3e7ff1e8f8f773950aac6d4d5ba2169de1a6e998d3dd05f72dfe0","tests/ui/parse-fail/return-borrow3.wit":"5a5760e399143ba937e5d3d773fbf8920ef826397d63175c794488960c602256","tests/ui/parse-fail/return-borrow3.wit.result":"87e650418893bc64d7712873ff8ef86e32bb0337d73c5c87dcdf78ebbad2ae03","tests/ui/parse-fail/return-borrow4.wit":"3e26cf4beedfb48ef6cb449cfefb4977a9ce0e56afbbef96b01c9279eed9c7ba","tests/ui/parse-fail/return-borrow4.wit.result":"45dc8b37c04ff614222096a1060b84c837947d3e7598daa241706c00b55c8d88","tests/ui/parse-fail/return-borrow5.wit":"fc0883c45f58f9febce715c622cdacc4c7a30d8e7acf16e7862969910a621cd3","tests/ui/parse-fail/return-borrow5.wit.result":"73afcb04f4f80c7d8a30928f47843f6524e15e0c0f1a9d3ebe74b4a9a32a5003","tests/ui/parse-fail/return-borrow6.wit":"f7b0b935f130bf810cb4fd21b96ecdf95993d20da8b8d82522d18e5051633726","tests/ui/parse-fail/return-borrow6.wit.result":"a32b28110a8fff2f999491ffcc7aa6d918094abd361be6d2ba4aa0da73c82921","tests/ui/parse-fail/return-borrow7.wit":"63626a382d1213cae263363950c9a64d6d54099b9ac535c594ab6926cb1233bf","tests/ui/parse-fail/return-borrow7.wit.result":"f13777e7b0536fd025f84e6bd8d8a01d47d85d8fa94fa428537213541ae691b2","tests/ui/parse-fail/return-borrow8.wit.result":"9fb553cd5e9541f8624c06204f79ab75c8840c7dcb38a356615f105bc73a9b93","tests/ui/parse-fail/return-borrow8/deps/baz.wit":"62b2638655b890dcc9d7be49bac7ff4689a3ca553293ba1b577f197c6fc91afc","tests/ui/parse-fail/return-borrow8/foo.wit":"f7915c3b37ce20432539b9e7a0662cc773f00a24dd8c5f8e9924392e522c940b","tests/ui/parse-fail/type-and-resource-same-name.wit.result":"28f2c298385dd152ad21a5be43ee86518368fb003ca79985c301b22774e3a778","tests/ui/parse-fail/type-and-resource-same-name/deps/dep/foo.wit":"e209e375ac3c8a02332abadf1112b6ee88a36c0b78bec82141927b8209aeb793","tests/ui/parse-fail/type-and-resource-same-name/foo.wit":"1edf7997100c89b9e299693ef9d0021ffe43d041a39540e193b11d616bbfab35","tests/ui/parse-fail/undefined-typed.wit":"a5c783ac0da51d15526b0104a0d468bd72e6726706ecef1fbbd5cf6aa413e53d","tests/ui/parse-fail/undefined-typed.wit.result":"794055fa5bd2101d289b55236dd813ea1428bbac89133020bbf2270d2c707c30","tests/ui/parse-fail/unknown-interface.wit":"4813d741cead7412e6f453e728627407069ab17922445dd67acfb80cdf463deb","tests/ui/parse-fail/unknown-interface.wit.result":"545c3a6eee6e89b51a46145bd6609cae3f03ac65df0ebc735e439cef0541bacc","tests/ui/parse-fail/unresolved-interface1.wit":"aa48ae74e1dc3165f05a0d216fcc02b5a22e2cd8cab1c1d3fd9b4ec09da5a47f","tests/ui/parse-fail/unresolved-interface1.wit.result":"b4adf53a899553e08ed1e76457970a15753cad66147c39d40a2f2397734238d5","tests/ui/parse-fail/unresolved-interface2.wit":"0fea9d7ff4592d723e4a9c3dbf341357a4902509996d8eb30a6f520735d0a41e","tests/ui/parse-fail/unresolved-interface2.wit.result":"66b21536fd06f55c737bea8d783e11f707003f988d23764cab478eda8afa6555","tests/ui/parse-fail/unresolved-interface3.wit":"ca7dbd14ec8ee5d01ab2bb7c28b7a3713f31db8c092511b3233b46bc5c353c10","tests/ui/parse-fail/unresolved-interface3.wit.result":"6cd94000e5678a2fde3234638b510ce3bed9f0a2f1cfe589527ba0cfa4e9ba14","tests/ui/parse-fail/unresolved-interface4.wit":"cbb042a9274076b17b7e0c42fc971da6fecfe2e6707a1d7026dd4f647ce5426f","tests/ui/parse-fail/unresolved-interface4.wit.result":"4093b50bcb7aeb9d776139290c723a5979cd5c9b5240c3d4fff127755740675c","tests/ui/parse-fail/unresolved-use1.wit":"f6b32002e7060026cd91e879d11d5f55d1fd0abcd8cb89a37325f8816bde9a9a","tests/ui/parse-fail/unresolved-use1.wit.result":"c5347149bf31d2dae55360c12b266292e4e96a49bb1a3494877cc7c031841f8d","tests/ui/parse-fail/unresolved-use10.wit.result":"551a761df6989b52b2e042924bb1b3b0055f3ec7f451d1b0c70dd4b49e2e5f2c","tests/ui/parse-fail/unresolved-use10/bar.wit":"7dad62091e741838831396f8fd31846a26ef6de0fbcadc350ade8fff0bf575ee","tests/ui/parse-fail/unresolved-use10/foo.wit":"feecb9606feec3ea7f499a1e9d97a86185c861eeef81c6e31c4d3805752d099b","tests/ui/parse-fail/unresolved-use2.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use2.wit.result":"a62b50fe39176b748df8fcfbcc28c099e801762f1e099d65f751e95c92afabbf","tests/ui/parse-fail/unresolved-use3.wit":"47fd4331dd9f76416230f2b4236a1837d1fba2e17603b25376306d2afb72bf24","tests/ui/parse-fail/unresolved-use3.wit.result":"ebf46f8ec011c0a98a0593ad217c1fb90ad142898b76385ca6c02d01a34d883f","tests/ui/parse-fail/unresolved-use7.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use7.wit.result":"7be5ab3f67d7b0df5ef2d0df1f66c2f2995bf247042bc89ea90089c05d254f84","tests/ui/parse-fail/unresolved-use8.wit":"9208e402aa194d8d0fd3c04f5c3a63e070a6fba35aeb3ee6deb620bdbe825be6","tests/ui/parse-fail/unresolved-use8.wit.result":"0f326c857f8ef05ed3687fc35816318931e9a189a5d3730b8437a0d967f354ba","tests/ui/parse-fail/unresolved-use9.wit":"a55be65d32510b790f687a8cd1a17cc78d66fc348a73c202786ccfc73ef80cda","tests/ui/parse-fail/unresolved-use9.wit.result":"a2479c0725a0e882c20999e0f194d4054777292b5fd3e08115b28d87b6d1217d","tests/ui/parse-fail/unterminated-string.wit.result":"ad1667fb37e169ae458c86c87154fcc2c25c1194578812dfb83c8a941c2ed002","tests/ui/parse-fail/use-and-include-world.wit.result":"5817300629cfa4fc8275c63f2012f2328f27375b771d2da2a14a76d520dcc4e8","tests/ui/parse-fail/use-and-include-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-and-include-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-and-include-world/root.wit":"78da4438e0a957af1421dc8c503593f3e675c5179eda0e1671c856b3cdcb6af2","tests/ui/parse-fail/use-conflict.wit":"034cccb48e6d9a80967c432bb1590c753c12d483aec6fa6d0da96eb6dd95636d","tests/ui/parse-fail/use-conflict.wit.result":"27bbdcde0151687d6a785e785824b458eb8f3393266e16146641a0c6062fb6ac","tests/ui/parse-fail/use-conflict2.wit":"fae3ffc85bea2e71f6427442516a93346a1c078db321ff1d9c79f3aa803a8a80","tests/ui/parse-fail/use-conflict2.wit.result":"a10548056049674ab161e6c63bd34aa17388ccd01ed7afdf765d98a40cf42cac","tests/ui/parse-fail/use-conflict3.wit":"c7d3fec48232c0fac946535509b6da609454b8d167040c2545ac3a21f88d9daa","tests/ui/parse-fail/use-conflict3.wit.result":"fed3b72eeee230b2d7866e9eb8feca2481006ee1847ca52df1c535ca34314f97","tests/ui/parse-fail/use-cycle1.wit":"221c299f701cb74b83aca20e869d2c0aefb813fe24cabdc2e911a2c957eb7852","tests/ui/parse-fail/use-cycle1.wit.result":"33d47e1ea89d5fb0bae32e036c98b3d5399196207207c208f195bf509c186ffb","tests/ui/parse-fail/use-cycle4.wit":"e2be0e1404e32463030ca188fbc73e33b0742890b15dcfb49d958aefebd2c3f4","tests/ui/parse-fail/use-cycle4.wit.result":"382267390c78b50f7f88145e5d14535d2cf63bc666770e6bd059fa7354340671","tests/ui/parse-fail/use-shadow1.wit":"0aaecccbbb79cf9472ba313e2d46c05bf3880c45f653fae7b0c78f4b22a295df","tests/ui/parse-fail/use-shadow1.wit.result":"a773e07251372341385395796eadb1fed6c9874ad24da54695556189162a18cf","tests/ui/parse-fail/use-world.wit.result":"15bed7cfaa1a4f59221761ddf8aa7eac1663e17c24951cff8f6d4e18d90954a5","tests/ui/parse-fail/use-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-world/root.wit":"8acc2f7d198aac787e288e81bdfb1a088014f4a4d1afac464e2cf3f42845d6bd","tests/ui/parse-fail/very-nested-packages.wit":"634d9ea887eb80da7207f942d5ddc53fe6d2b06e7098e6766e4430dc8ead7742","tests/ui/parse-fail/very-nested-packages.wit.result":"ca58759135852a95265d4d55ddde1d43098c307de3423288462932451a5b3e89","tests/ui/parse-fail/world-interface-clash.wit":"6584c79206067af3dc3647f38deb9e5bbd7ea030b7a26f267e10db0b3243bb5b","tests/ui/parse-fail/world-interface-clash.wit.result":"a75d15d2d1eee8078553abbbadacc665c08de9a2a7ab098cf6916ff6bb2b9092","tests/ui/parse-fail/world-same-fields2.wit":"99e6297c3566e8d0df7d4a953b2d816303999fe040776956a8215de6f86a4c0a","tests/ui/parse-fail/world-same-fields2.wit.result":"421bff8bef32cec8f401c7c769c41775db49f10d31497eb66dd573503d342239","tests/ui/parse-fail/world-same-fields3.wit":"179e96948f1bd9b85b3fd53ccd932e1a5828c2ff6ce20f3f69a40295c9d3142c","tests/ui/parse-fail/world-same-fields3.wit.result":"6ae7d531dd1e711f54c3f367424a834da4834f7b1d0d1f0b851b8fdb36def6aa","tests/ui/parse-fail/world-top-level-func.wit":"25198b3e596b399f6724288ec81e7cb5a2b138db575ff2854e3263e4c1d345ea","tests/ui/parse-fail/world-top-level-func.wit.result":"3842657363ed9453b394f6cce0278a6b8cd0b7fb9c4c7044060b2a5a5a6ef093","tests/ui/parse-fail/world-top-level-func2.wit":"05ac462fe2731f3b4b3e0b16cfee74457302d376d14df35f22337016ba49df43","tests/ui/parse-fail/world-top-level-func2.wit.result":"da74d6cadafbea0711f432d1a0813615d8779784337d440f56391d77ebc66ef3","tests/ui/random.wit":"a308df65c57e4848930795bc110f1b2dde102c6e9963570a404c648b2b0be33a","tests/ui/random.wit.json":"7469b9e378f13f111e78657feeb3ef9873c6bcc3099260ae4e6090bdab28d85b","tests/ui/resources-empty.wit":"a7ad4630c28f52b6ed054520613feb8b11d632fcaa80c21ef5b84343cf649659","tests/ui/resources-empty.wit.json":"088c997de81f3366ef77ae83190d6d530810eabdd7f8c7aac4e4014cad90b5e0","tests/ui/resources-multiple-returns-own.wit":"7c665e511dbd2992fb6efcb6412241d1bda0074da78d394ead1070cf6be7f187","tests/ui/resources-multiple-returns-own.wit.json":"95a404930f7eb64112f9a661dcd0f047b6eb33d12f2e1de500e196c9d5b51edf","tests/ui/resources-multiple.wit":"98724d3b6a1d0d192970d9ae149e31694bd9c3f86bfe2e89c520e1a063724921","tests/ui/resources-multiple.wit.json":"265d1bd3914243d782d5c9b0fda62d285655ab5f43196ceeb32fba791909f116","tests/ui/resources-return-own.wit":"29d9f53bd39d0c2263c7260508a1f954e59b28923994f94bda0184cf037c4210","tests/ui/resources-return-own.wit.json":"8b60ee12530bab3e0643ddc7ed4e757b57f395e397b834a53eac2958c95824c7","tests/ui/resources.wit":"3535fc8c8381779d33082f54384362c0e3ab23cfe675562333e6840682d71ebe","tests/ui/resources.wit.json":"ba8fff6d19dcb72e277c925e52646f68b0e6e0b15eff6334de9d770a6f04465f","tests/ui/resources1.wit":"9eb5d63717f20c6801c6c71f6306ae3e2c37790bfe8a89659c11cce85797d128","tests/ui/resources1.wit.json":"090fa9e402168d2a157e7abdda3d450c48b90e2cc325bcc0be30447682ace656","tests/ui/same-name-import-export.wit":"95ba4578908c29d2af14fcdd8970362c8bafb2174916c0f0772b09437e8d57a4","tests/ui/same-name-import-export.wit.json":"c3d2c9fd7a219ffe2fe094233c369916ce0fee0a2efcebfac008a45bc7c5f8dd","tests/ui/shared-types.wit":"d145c035d916f453a7eeb034bf2a59c2e24f14061d8385ab39cc1f076c9265ae","tests/ui/shared-types.wit.json":"70be131e2e80cdf62ba7a2a20418f71f7480428e2e05e1c387dc1a24667dd652","tests/ui/simple-wasm-text.wat":"10e7380158502c5ca3a1ac9d4195b0455cc02438fed0fb3f7188674354c25c2c","tests/ui/simple-wasm-text.wit.json":"0f91dec1e13fb9e0c30b4e1ad6b4335ea22fdc435ff526e3549dc19a8af97443","tests/ui/since-and-unstable.wit":"312fe8ecc9f22c083f3e59ea306731c198b4d1dd8e2bc1b3d868e90b184163a6","tests/ui/since-and-unstable.wit.json":"6147a7d1ef4dd8dcd8572ade33e7423ace0eea398586cbd75bab5be2cd361e60","tests/ui/streams-and-futures.wit":"2d4d378de4dab66aebc90d4dcfec58b3afccc646f83491801d51999fb612cbe4","tests/ui/streams-and-futures.wit.json":"3e180d6002e03e72797e45bfd4003c4dbebcfbecfded930c646cd8837054a6b1","tests/ui/stress-export-elaborate.wit":"7d62775daf1c0e35c7576abd726077e45cde2f693cc21d8cadd542e88271590c","tests/ui/stress-export-elaborate.wit.json":"6930a623e84d06da7fbd49ec1e6d10b43f3821ee191cb7ff56902597210b4c06","tests/ui/type-then-eof.wit":"79610cbf6fe3e2d13ce1fd8c06e53fee6c81d42469ef56e1dd61c46bf5f57ca3","tests/ui/type-then-eof.wit.json":"bcffeaf61ef6ae2ad4752ef83fd5057ff5eeb649d00e797138aefeaedcf39d06","tests/ui/types.wit":"1da7140aa66c3de1867313e5071f18d6814e44d90ae650be25b86dbf58214afa","tests/ui/types.wit.json":"c981cdc0a58a7e500915497eb856a32f37015ca1bfb09b453e3e0bc3fd5b3edf","tests/ui/union-fuzz-1.wit":"c4f60248204707f8dfe134bf4d6ec3385ae343abc4dfa39239798dc9f3991753","tests/ui/union-fuzz-1.wit.json":"5599236aaea5ab475ce9c224bbba3a40de45d5d5a20f75eec23b09e723d14a01","tests/ui/union-fuzz-2.wit":"5e00d73b1b562fb3cb24067fb0b8ba4edf28b6cd71d914dd6b8716f58272f266","tests/ui/union-fuzz-2.wit.json":"5593decd80a12ef08a0937b429ce3414964cadd2eb9138ebd6961a87f0eaa6c8","tests/ui/unstable-resource.wit":"304a4e8cf205f6f7afdc9af0f2756931c1e2875ab7bb70323cd6f1414fb462e8","tests/ui/unstable-resource.wit.json":"98da87f01953568427e36b6676a527cd5b9d54d3a1d5838b65772a58c6ff34cb","tests/ui/use-chain.wit":"3daee8a895e3bfb7c0bd0252f095554a85d07baed2c569c1b7fba5592a1fb675","tests/ui/use-chain.wit.json":"8098e7e6cafb3b22d117a31b1b721d5bda895fd984fa415fdd5cb4490364166f","tests/ui/use.wit":"4c920ba13211fdeeabdb53341c983f002263c464f4bae2829b0dadae3308cbe8","tests/ui/use.wit.json":"0ca15c4eb705f51f0b499f78ce40a45e243f6af040878f9be9697589fb62b99c","tests/ui/version-syntax.wit":"18e83b2246c0271bc3da0bfe004e69ee7699fcfcb6a986ec970dfaab7ec315bb","tests/ui/version-syntax.wit.json":"1722a38926d815646f64ab37ab3181d3cb70d937665a416112bcb7ac50ce31b1","tests/ui/versions.wit.json":"6a2b4f5d9b1cea003a2c3d25cb91116249c02ff307a04109e554457cca2f139e","tests/ui/versions/deps/a1/foo.wit":"407bd32b2274c8b5c0cac5582097d797e1455926c069496a6d5964ebc571b291","tests/ui/versions/deps/a2/foo.wit":"b32843bb65739073b450cef6fd528b2a72bc7fe92fa0953883663a1bf7ced1c4","tests/ui/versions/foo.wit":"4da61a67927a401e08adecd5c1f0d7eb7894982d3beb356184149da458a9f553","tests/ui/wasi.wit":"7227877525a5b0e2fc9ebd6e312d29d110e398126e4706a7fdb07e2d3fa05ff6","tests/ui/wasi.wit.json":"96631c1e2b029e2e15cbc51d2649a8be20e53c0666e8a9a3debed7fffa95bbe4","tests/ui/with-resource-as.wit":"bfc965bbeee53ff610639bef7f6e70057771812395f4328b7025dc6005a5d334","tests/ui/with-resource-as.wit.json":"f230c8a309a799c31759e1e8bc69aa3692e1a8b9fc8eb167f8b5df177b5594f4","tests/ui/world-diamond.wit":"82ca9865f586a5839adee9d8d90a519aead5ead715c2607125e878286f0ce847","tests/ui/world-diamond.wit.json":"5d92d94856aeaca6f73a185c242cfeaadd7afd59a285b6c47ac8997ab5b8db72","tests/ui/world-iface-no-collide.wit":"f1bb804dc568a94c6aa467c8d720a26c4a47a00f3374f4fe045502686eea3d7b","tests/ui/world-iface-no-collide.wit.json":"9c26c5fc05be082e85d37cf928f0bf45750f020a6c1176c92ce8dcdd56cb1d2e","tests/ui/world-implicit-import1.wit":"59515a6a268a6329bcf4e0a6e74b8ed1f77a61638ba8fad5fae935eb0ab59a50","tests/ui/world-implicit-import1.wit.json":"ae22442a9da3bee72efca9bc3adb49df3af510aadf3eda999d6d7b0a21f65a8b","tests/ui/world-implicit-import2.wit":"14bb046b3bf18a2b02ab47ed8be2947f3f911ded88dd2410225ac08e02df8ede","tests/ui/world-implicit-import2.wit.json":"c8a5023cd0159301ac3b415a00a0c349149606f349a7447778f2478f3292182f","tests/ui/world-implicit-import3.wit":"0faf9a3afa61ffab3d3d5e2f869d35d92a39406d65b228865f4871035b93f2d7","tests/ui/world-implicit-import3.wit.json":"488978218df83a17c18274591777d89b8ad18f6958692e50d87483d0d2cd3f5f","tests/ui/world-same-fields4.wit":"8686e463450b6880f1572b0fcb9ac78dfa78c1bf7c1124e255aa79959a49ef7e","tests/ui/world-same-fields4.wit.json":"831f2370d2c565a9f5b9bce32cd05769cb8b1034967051e57d883055157a95c3","tests/ui/world-top-level-funcs.wit":"1ef7498d5c9cae3e8da77bf4af98b2fec439f56387d130b54109b0f16d156d0d","tests/ui/world-top-level-funcs.wit.json":"f3b894996007ca6c370a3f383947ad16c920446a8ea84a32b2082750616d6117","tests/ui/world-top-level-resources.wit":"61267d096998b68bfd72845854f6a2d5391d68f6a0094887fc05cf97cb54410e","tests/ui/world-top-level-resources.wit.json":"35e2342c86841c2b861b5547c6d0cde83bf6ac7af35f7e09af99b209887d19e1","tests/ui/worlds-union-dedup.wit":"1f9ac2813774c0fe1676734bd6e1779f4870091d0d6a8aa061643e865528be10","tests/ui/worlds-union-dedup.wit.json":"254ef09ce95718b658d109cacda832c7dfdc5b7e0420ce1da8fe56589e400dfd","tests/ui/worlds-with-types.wit":"a2e6d00eafed8d6c6278dc9cddbc2ab2542f836869f564cf449625fddc9476e8","tests/ui/worlds-with-types.wit.json":"6d3afdfc4192bc6b6cf8b3507a942d5e63dc5adae26fafed62d5ced0889f6f69"},"package":"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"} \ No newline at end of file +{"files":{".cargo_vcs_info.json":"e701d7ace82ec8996103713a5ba11137b8188a7084ce2200d5250f7180c21c4a","Cargo.lock":"4d9db2a27e3e642d9ab03ecc1927e06ae2b88fa5900fb424a990bce136e86ed1","Cargo.toml":"d7bcbbfa75bb0ee12fb76a45b75af7f4f92af9c3ed6046866a2315efb65773fe","Cargo.toml.orig":"57732a62b5239a8d7bc42c142b2dd6b332850cf91d9e039203a3272d7a41bdc9","README.md":"fb3e25cd96468cb3ca6b40dfa684504b316ea5b261f14109eb229c4f82442ef1","src/abi.rs":"3b441a5d5ffc5bca83e5c5fcdf808da6d0bf8cbf31b159013b3e063c35489554","src/ast.rs":"834c8c865f35002e2346549903e3f64563e9aed2530f0eda3e1ee4f8e9a35031","src/ast/lex.rs":"6ccd888e92b36d4404142f55e494d1388f06ef0c6875de5d79f2f300f6ee6a27","src/ast/resolve.rs":"4b3bd0a7ed7340b341e90556ee27a9e5b230be481fc68b6347e4e4f75840c15e","src/ast/toposort.rs":"a71e3fe53836645b71b1eb8152314418bfe7ddaa19e1dba259b1534f55711739","src/decoding.rs":"472d64a3688d2910689f51db6e9da1c39796b0af9e33f17b6b39c9a8ca4d2c12","src/lib.rs":"a5fc6f547d5b65696892622604085974bec2cf47fa95aa49afd242a14d447375","src/live.rs":"12d789a63367f4a9b3581a475e854b36ca0592c95cb5f0404dab11bd9ef92232","src/metadata.rs":"fb580e48681dd88c66b7bb915d90383cb4f1a99df8d2a6654aa97a95d1f5435d","src/resolve.rs":"dee35ee2a393239f8089cf7a2fa8c237a9091b29834750b607d34e55b7aedb32","src/resolve/clone.rs":"9c30b89ecdd03f5269590bc628ffdc698f555c7f3627e4d6ec988b939153ae9c","src/serde_.rs":"619855c4049e83b9dfeac2fdc373e72c7b7eab66e39a06ff643b319b2e442de1","src/sizealign.rs":"8d690ade0227f358682b908abb4309060959cc71e29d3deab8d4563e4c47ee17","tests/.gitignore":"56290c87f8681b45f1bc1842ae3943204a6d40e03915268c99359c59c5a5cb5d","tests/all.rs":"6545772c9541c29c66c24b316b1c9e2e01f3fda7ae2e5e6e30dd8f3b6a111ffc","tests/ui/async.wit":"e02dcde5e58db33f6a4cba9ef56d2e23f25ff66becd438bea4a3e44a3b708982","tests/ui/async.wit.json":"ada678ed4ef39e8a15a653da9f327327702e00c84aaec49cb6ae2293bc072430","tests/ui/comments.wit":"475f3c841e96ff3d5b845c889382eb65501ed5937e1cafde2fb1cca22eb6af76","tests/ui/comments.wit.json":"8f1b6361031a0d6d462f64e0a0e5d982e758459388b38cd91d2e20d4c40c95da","tests/ui/complex-include.wit.json":"3fe8649db3e11c4fd377534af39930670e7f56ddac550edf30b38d9b796b71ad","tests/ui/complex-include/deps/bar/root.wit":"847bfc51da81c575d28a11c87ba4d1a4c7af4ef4797bff569df1ba7180186cfa","tests/ui/complex-include/deps/baz/root.wit":"f698fdb5d167e91c5c200b72d590ca6efc47b252340ea686a6a6c5b68b32850b","tests/ui/complex-include/root.wit":"1ccb363347433a31d1e72408a7e2581ad428a602dd77c19d2c38a4bdb3011cad","tests/ui/cross-package-resource.wit.json":"88cd432a64f97b22ce3ce0d947236b7c6dab05710746e99117f7d78dfcd73107","tests/ui/cross-package-resource/deps/foo/foo.wit":"a17fa1d030e1e136d0a78e72f1236f945676bf95a6ac269f1c8279fc5891c7d0","tests/ui/cross-package-resource/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/diamond1.wit.json":"65ca1157767b651d093ff7e0578adc71f384f0eb10f6c5f0df7d9d6c7a65a714","tests/ui/diamond1/deps/dep1/types.wit":"0e88c7dea0e75ee462e9580bcab9f95cea6d47ce465b8e3686c579c871fac70a","tests/ui/diamond1/deps/dep2/types.wit":"a0550fd230ae08e270008582a58e369dfa2959d64e35b47b3267c5e66d5dfd9d","tests/ui/diamond1/join.wit":"9dbe89b4a1db3f48c7fddc35bb0f5624d5a7993b9045110e273483eada067037","tests/ui/disambiguate-diamond.wit.json":"e67b1ef121406dafe3e700c7b26542b089b836a5b8b4c0f88e85b59001297d8d","tests/ui/disambiguate-diamond/shared1.wit":"29c7b86eb0b325007093ddc5cd6bac442f2770222552c2578b3df92b27141ffc","tests/ui/disambiguate-diamond/shared2.wit":"9cb9d0ccffc9d0400da97af00f0c6ca65c0b71bf7eba152ce4c17a94befa04f0","tests/ui/disambiguate-diamond/world.wit":"dc44c49f1f8a1831e183efab5705a9b24d1e03d57b24c59d70eb404ed5783ab7","tests/ui/empty.wit":"180aebeccf365462475063f210fc0e2fffd16d415b40c710112daa478fc05d2c","tests/ui/empty.wit.json":"f6e88371fc423cf186127ced701cef2e6a2d1408554be53bea33fc96b50c660a","tests/ui/error-context.wit":"bc6f8bf716ccd78f58d35ce867b3c516b7b9a00129a8e42a3b4284070081ec12","tests/ui/error-context.wit.json":"62d25fc35388148abf493577414247b90d3285c2f1f6a0d5b97f314afdbc4de7","tests/ui/feature-gates.wit":"6421b98446ab4de927677a37455163faafb8ccbe039c9dec9ea3edf601f62c3e","tests/ui/feature-gates.wit.json":"815eae0d8923390b821fdddbe1ba1492b9fc058a8f36f43c4645a84fc775b542","tests/ui/feature-types.wit":"42907c1e0228a5f5046cc977c0cf9fed6bdd2c7aa3df78ff8ed77fb4db9e96e1","tests/ui/feature-types.wit.json":"c44485247c77e2025c24b01acdb5b3b560fa2d6fc18deeac0242ad0ca1ab5797","tests/ui/foreign-deps-union.wit.json":"5d1400e9c28a3180dc934857151408b4d1bc0819b3d76b40690531834c40b608","tests/ui/foreign-deps-union/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps-union/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps-union/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps-union/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps-union/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps-union/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps-union/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps-union/deps/wasi/wasi.wit":"992be12ee11207ddefc2ac531016a9e9519af214341af718972fb653924ce231","tests/ui/foreign-deps-union/root.wit":"4856bf403caea6403cd98b73c44a6277c9af52b7e3c16c756f6cc0e4711e3c3f","tests/ui/foreign-deps.wit.json":"e894a9c94e877c2f92592aaf5e51d71541d7c1d36dcf8d6db27d435ffc0126c2","tests/ui/foreign-deps/deps/another-pkg/other-doc.wit":"c9423fbe1a1122a74d7bade1ba92f768e402a815ebb6b904b8a10ad45fd1c98f","tests/ui/foreign-deps/deps/corp/saas.wit":"386928373ef82518259896404073bbc78efd0682c87e84db7946ee2cae9a6a25","tests/ui/foreign-deps/deps/different-pkg/the-doc.wit":"f13b9d7a0bb19e2d01b6376d4d24f62a5f1fd0383b28425c1aad8b2d3edba20a","tests/ui/foreign-deps/deps/foreign-pkg/the-doc.wit":"beb4afb21df52eeaa553260af4eec19caa91f17125943e220c53f38f53e815a7","tests/ui/foreign-deps/deps/some-pkg/some-doc.wit":"999d52ebb0be65f4bc181e98a396579fe58e084c11eeafb354bea9469c1a9119","tests/ui/foreign-deps/deps/wasi/clocks.wit":"105e3f217725547b1d4097003d4d4793f7b8b5233f10126078d3b78e6f73373f","tests/ui/foreign-deps/deps/wasi/filesystem.wit":"f3591626529a6ca7ede789909090cb6d59377f0374d7a474e94f47fab80bdd2b","tests/ui/foreign-deps/root.wit":"532f52d31c706b5ce3dea9869b0aa8fa0c0353309ab2fa9752d29a2aecd7aef0","tests/ui/foreign-interface-dep-gated.wit":"a4e2e64a17b2d145897ddf3280a47df60c80101124c13323bc25485a9cd9057b","tests/ui/foreign-interface-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/foreign-world-dep-gated.wit":"b1f4c36d604270c079a645242690e60083bc39ad9d9a507cef89243fd848f579","tests/ui/foreign-world-dep-gated.wit.json":"bc2ef7bf9cdbc2ca1ba1c446a2d57714d65faa155b8f126816ed8c8370bb39e6","tests/ui/functions.wit":"909502792a27bcd571e1e4344fb6f0d03412d44a4afa1468f67896cc9ff479a6","tests/ui/functions.wit.json":"4e374a1fb01d7537a76c781e42bf59435babdbd3c3d3f323f886652707688fe6","tests/ui/gated-include.wit":"292d684e8413242ab91efded4e21ad779f3d11c4c48cf42ec2f37a17ce881f2d","tests/ui/gated-include.wit.json":"12139e81b9b0aee7f1f2a8263ec2ce05d8b3b9cf273e53337b67dcc36ee26e63","tests/ui/gated-use.wit":"792fbc77feeed4544311df936c0068335658d3b28b62880ee0f2c4b9027123bc","tests/ui/gated-use.wit.json":"da18c6d1e6902846e17f42c4b3c21c0bbdb4127f0d7ab965e5051ff847fbe9a5","tests/ui/ignore-files-deps.wit.json":"0a65f0ec2fc58a7429f6ef6d45276726e0900c989628bb3c390219db906d6f01","tests/ui/ignore-files-deps/deps/bar/types.wit":"3f6c58f614a5eb6e92dad08c37faf9a7a0ee3ca6bf0fccfa286b94d768375a60","tests/ui/ignore-files-deps/deps/ignore-me.txt":"4636723dbfd9d2967060094fb248e8121fe1620ec8e0e5ea505e66cf1e2781c2","tests/ui/ignore-files-deps/world.wit":"1e3baa2b60d49e5607534fa3d3069e1e2fe6d5084c8c83ca7e5135927ea9f53f","tests/ui/import-export-overlap1.wit":"1228074dc8caf72beecb3c6281e183769b8367d7162832cb9d0647d314a9b2ac","tests/ui/import-export-overlap1.wit.json":"67d8028378a4dc9365242b2b7f1f8bfea1bfec71a2c5df22ce87a62c3d75122a","tests/ui/import-export-overlap2.wit":"23f35f40aaf4b13e2745d201394add251746d523eb553b246f801715d9d79705","tests/ui/import-export-overlap2.wit.json":"087e6e1dd2d2901ed0c4ba31b61d6032859754ecd0abefb947fb2be314ffc9f3","tests/ui/include-reps.wit":"18b45384f26dd1660e721f00fa25bb45fcae247f91925b37b68b96c95d5a1983","tests/ui/include-reps.wit.json":"7fc06783fa6eefc29be483732ff0a07c2cdaee4028640d1c8d194e9d3d2fdf2c","tests/ui/kebab-name-include-with.wit":"e3018a921e3767a5f546713d8dd56801667d69b18353eff2f057b2e10c820273","tests/ui/kebab-name-include-with.wit.json":"eb626e1a2584eb5402ef71241fdc9be07f15a2502fd46dc45c2a03e1252358ab","tests/ui/kinds-of-deps.wit.json":"1b1ca68b2442b696d5afe8bc64094dd101ffe60729b67e9fd0d01fc873357c7c","tests/ui/kinds-of-deps/a.wit":"55532d4e836d80efd73ebda0d942adead4d6caec33076fe54a30edfc337a7703","tests/ui/kinds-of-deps/deps/b/root.wit":"10e833b051706c4882d451f7f66c7152880b5a4e60d75233a4709177cd45ddfb","tests/ui/kinds-of-deps/deps/c.wit":"4d6a716fabf7fe56efdd3de95afc2f520efa6592b10921d8b177b3640ff90d94","tests/ui/kinds-of-deps/deps/d.wat":"91deb49abbe77e312305d6e14ca746ebeeeed99207f099df49e26956add260ed","tests/ui/kinds-of-deps/deps/e.wasm":"33fc738466bf4d6e8dde7ff530a23831e3a42519d30e6f5d63269c292cd7255f","tests/ui/many-names.wit.json":"a15ab09ba624a77d24173f4e3cd2c7044e406e72eb128afa41933964e455bac7","tests/ui/many-names/a.wit":"9381b4e20f448e02d7cb27fe5db24c3f5f37e9ec1425561172edffc6c79f0a93","tests/ui/many-names/b.wit":"e5a20aa53d8673e38465e74f739a5c8cc4789da211fa43490222433c6131e43d","tests/ui/maps.wit":"245328c5953648a8068d0cd1b84cdd342590fd7ea066d650f40dfd7e5fd381a7","tests/ui/maps.wit.json":"6cd99c802177790f07f6708469b0db44f1e7478afdfa963dade9ccc96a1d489d","tests/ui/multi-file-multi-package.wit.json":"5fdfa45865f31de3c648614277721d86539c3e4c34d0c1ab0ff6ef79ddb3d1f2","tests/ui/multi-file-multi-package/a.wit":"4a996c8b1920aeb34f441d44131b3a7870f9769da5579bcbfd4b608e4a675fb5","tests/ui/multi-file-multi-package/b.wit":"b3f940591bd7adbcd1f61cc1606149c4019666efaf8dc76344bf8df89d138e90","tests/ui/multi-file.wit.json":"c64b219ea422ef8d73648ac2485079a7e1a9002ce5e35e2d67b8fe20590a0dc4","tests/ui/multi-file/bar.wit":"5e8d03741204f1e40e7a0f5bd2c043f31a3356c8de296762e2ddb38cfa89cfb4","tests/ui/multi-file/cycle-a.wit":"90612ed5fa9d552068c9c32a0b179355dc92d475c2d1b6521fec494bd9434738","tests/ui/multi-file/cycle-b.wit":"eecc7ed7ce638740ff1cf9fe20914f03b8c3920ddd247c2d80902914c7a4f8c7","tests/ui/multi-file/foo.wit":"ce81ee2316a34b064e2a37e01fa94ac982a663b1c3fc5be55b4723b6643b2970","tests/ui/multi-package-deps.wit.json":"f5d632858f6d4fc02a7c0713daa3555ffb88eed4d8a424dbcac9516291eb07a8","tests/ui/multi-package-deps/deps/dep.wit":"9d66626b787cd5d12b74354bf47e8d5b7e811f208cc512a4b985304ab7856dde","tests/ui/multi-package-deps/root.wit":"62338e53a74a0ca51e6fe81b8fe001a2fda456e64d1779e398525fbec8f236aa","tests/ui/multi-package-gated-include.wit":"109631bf21f46c17c146927e70579661934c28b0e42484378ccb07f65ffc084a","tests/ui/multi-package-gated-include.wit.json":"b5b5c7c2ce63ac25223a5d01ae42f69e6cbb326fb54073d3f58a1b4c904deffa","tests/ui/multi-package-shared-deps.wit.json":"a5a0cdd60e4b8ae10f5b9feff728faef8a81224880af5cc06f73b30757c733c1","tests/ui/multi-package-shared-deps/deps/dep1/types.wit":"b9cbbfcc38f90cd09b1ba9c9b474db0f858f596c054dda59d0de35fbabb26fa9","tests/ui/multi-package-shared-deps/deps/dep2/types.wit":"4f3bd8ecb0e14c6ff670192145dc4b24e20648176634338f7d9aa93ff5863db3","tests/ui/multi-package-shared-deps/packages.wit":"fb9a1bee65922b9d6372e07717899521a129919a23d6700f49b9f953f32df581","tests/ui/multi-package-transitive-deps.wit.json":"466bebe32e6a390148f4b6c9697148f87bacf65454a4825b8c48e565b217d4fa","tests/ui/multi-package-transitive-deps/deps/dep1/types.wit":"58a8ed5ed904dc9d04b7d0f84c400beeb262b79dd63258e66473ce4f36420b4e","tests/ui/multi-package-transitive-deps/deps/dep2/types.wit":"c2b7e5747fba9fbd25ce19b2a8b4fe7fc96831138f68c96e4af4ccc424cb1efe","tests/ui/multi-package-transitive-deps/packages.wit":"d5adbb7f4c6a9f182ee42155475aba911ddc21aea0ef619dfd68f7d4c7ff006c","tests/ui/name-both-resource-and-type.wit.json":"2345a2b52803a70dc14c3a97c5574b49ff23451c10a4036ed2bf6d682fadfb1f","tests/ui/name-both-resource-and-type/deps/dep/foo.wit":"1ff8e2a03e86e0676ed0459b6400b1f92957ce9e88424c91ef20dc2ce98414e3","tests/ui/name-both-resource-and-type/foo.wit":"b8338da8c7e942580d0654de494d68977f459f9e0fef2ffffc164380ea3293b9","tests/ui/package-syntax1.wit":"090709e7f0f85fb60f6a104c7b0ec325d11fc58fcc69a6c20b02f454a0636eee","tests/ui/package-syntax1.wit.json":"dcf5bf4334dc9ca156dc0a9a62d3dccf27ea1ebbe9525ab0b1b992599513fdb2","tests/ui/package-syntax3.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/package-syntax3.wit.json":"e517e1ddee9cc8e123729f3e36cb85fba4328828421415150c99f6dc851c9e00","tests/ui/package-syntax4.wit":"516e3e21f7768a4ee479c0b52b68d3947b6983d0a0c04bba6044c05d784a2f41","tests/ui/package-syntax4.wit.json":"b7b65aeb4a33616707bbffc952e8b94b4d3f32e98a2cd3bcc2bf219db4a41850","tests/ui/packages-multiple-nested.wit":"feedd1dc072442d0183ff04562e5107c3081612e60939c1475a25dcb09c0d448","tests/ui/packages-multiple-nested.wit.json":"7ea283985310c900b7009e6c0c6f68be3d370cf71c831e68d5238dc1bb7ff637","tests/ui/packages-nested-colliding-decl-names.wit":"0875563840447d685523542c20262fb6b181bd0c77f56d4460a56211ce79fcac","tests/ui/packages-nested-colliding-decl-names.wit.json":"eab533e2b31ad4c86dc49ba98ae03e7f74730b01ff97296039b315517c4999e8","tests/ui/packages-nested-internal-references.wit":"8d60a92f19097442d2c17de549d41ca48b1d58025714ec9886153d636747ec30","tests/ui/packages-nested-internal-references.wit.json":"e2537174d20e50c7ce041dca4f1e4ac7a9c08ae16779141f6e9bc16db3b17c62","tests/ui/packages-nested-with-semver.wit":"bded1bf70c7d27493eb53571cecace850bf7e05b559f72b010d431c4a812900e","tests/ui/packages-nested-with-semver.wit.json":"d88a57595b4b70e3365dc3dfe8a387900d68663942b2a27c79b3c56403e314e9","tests/ui/packages-single-nested.wit":"b3c438ef0c0f467ec0dd15202d8b48636860921ce1c313968bbd0fdf4451c746","tests/ui/packages-single-nested.wit.json":"5341b377d4eae34b6acd116ca4d60ccc40aeac5da79d0b47d9c7fdb4cf94ad36","tests/ui/parse-fail/alias-no-type.wit":"6d717f638138d6536c634773058484f26bf1696630ccee86cbd98f20ef000185","tests/ui/parse-fail/alias-no-type.wit.result":"149e701639f259bc16082e7fd84542ac20a11480b8ebe6909788c78f42c9e6a6","tests/ui/parse-fail/async-bad-world.wit":"a5f91bfd0e6eb3d67392ba0be97fa037d73b6193f8014df64313d08e8d8dd233","tests/ui/parse-fail/async-bad-world.wit.result":"c326e18dd5737be4718a428cedbcc2dd177a3603fd91ba3b1bee8578bc65f3b0","tests/ui/parse-fail/async-bad-world2.wit":"110a4409ee12bbf9f1ba2e8264a694220ddc52cf6d236940cd6989d8a907b925","tests/ui/parse-fail/async-bad-world2.wit.result":"8fe7d414eb32a321b3e9b48b3f3ac269a9fa9f186e8cad87fe0fc6f1fd058e02","tests/ui/parse-fail/async-bad-world3.wit":"6f30f04652ab9a126f264540db6b63172e959fc1a189fcd0381605a7f4f103a4","tests/ui/parse-fail/async-bad-world3.wit.result":"ac9b153a9eb50546f14c22b737e45176a1dfdd70514fd53b3c0d277b529b1b00","tests/ui/parse-fail/async-bad-world4.wit":"d607651508ad944f22338e86b9226dfa58b83e7796e4c6af1c5fb65683640997","tests/ui/parse-fail/async-bad-world4.wit.result":"e320b3b7d91e7defab11693f6d316bf6b0d6ed5d7ba58d81cae79e5fa900305c","tests/ui/parse-fail/async-bad1.wit":"8c11bac371904041a93d4f04489e1f0fc2e731a1950a1f4a69d1d6a56fadcdea","tests/ui/parse-fail/async-bad1.wit.result":"55b81beea66b26a65c87e2c779f6b80f9fbc6a53a5f53c325e4bd9e5fb9e8a44","tests/ui/parse-fail/async-bad2.wit":"b779614996ac1c6ce2d5d3867e4c8772c66b093e5274807a83d0bb385b09a0d5","tests/ui/parse-fail/async-bad2.wit.result":"d20e721a50d13841ecc069795026e8ded6cd22735a4007a1748e2e3bf231042c","tests/ui/parse-fail/async.wit.result":"67ccac26d7fe73e8410404092b30398a778aa5bc2b460409c9de50d83f721c33","tests/ui/parse-fail/async1.wit.result":"3a04ed56850e4e60e05f72bd1a7d7646fa14bfa81b049e2d8d6a9dfd4837b3ad","tests/ui/parse-fail/bad-deprecated1.wit":"d792904a2c146aa5f247c23fd420e85565431b6f7975616de32bf78cabb78582","tests/ui/parse-fail/bad-deprecated1.wit.result":"0fa750df748b21c74a9ba10a318c21dd6fdd2f25497abbbda4fb36c2a25b82c3","tests/ui/parse-fail/bad-deprecated2.wit":"d333c32a598d23e0decad6f1f5d9278296bfca1320aca4e12291bc113d6e567c","tests/ui/parse-fail/bad-deprecated2.wit.result":"b808b7fe316cccbb96718b7f1f73ea0746af074d0305b6bd47f762e70732ba6c","tests/ui/parse-fail/bad-deprecated3.wit":"f72813a037e8718a7315fee317a080dbe73f3e44df0bc42408c0b9ccab1041f1","tests/ui/parse-fail/bad-deprecated3.wit.result":"e96dcb21216a1a2ae5e0ff3d063ba88dfbb610f5ae09b51853fe69ebdc44f96e","tests/ui/parse-fail/bad-deprecated4.wit":"96ad0d172b69432598acd101e2de83a6b36ef6c6980075d994d3961becc7ffe8","tests/ui/parse-fail/bad-deprecated4.wit.result":"443b255aed5611c14cf1751cd4da2dcde6d875c93599a5ae1bf999e913eb5a4c","tests/ui/parse-fail/bad-function.wit":"ebdaa7b0c3fb7713bd869b510c222e10e0fbe6b5e3c93b3ba8f077b59a9cdee2","tests/ui/parse-fail/bad-function.wit.result":"3480be5e024671f00c1a1d49b0b394dbe145b58d8100f89dff0912d7c39545d1","tests/ui/parse-fail/bad-function2.wit":"e501d5d676b0647999c3e508c4a494ba652cbd16c275be17583ae5fa02bf5e7f","tests/ui/parse-fail/bad-function2.wit.result":"a1c0b324816fd854dd85e9b2f29f9d3e09ad6a7f670244851032a734c96ed67e","tests/ui/parse-fail/bad-gate1.wit":"d427d68abe2e93f488569af3fecd08d5c6bb984ec461fac4f184a2b977d903a5","tests/ui/parse-fail/bad-gate1.wit.result":"21393b47dc8d07dd405941a137f55d94e6598efd449404aa3c42b57a3665b147","tests/ui/parse-fail/bad-gate2.wit":"dd536d413c6b7a0a59a15d39fdd1a52d7a4810d3900c59f8132fbf14d32da3e4","tests/ui/parse-fail/bad-gate2.wit.result":"ba82c990dbd4fa001d4ecfa46bd8730ccfc49a6c873265b0b81cc8454c9a58ab","tests/ui/parse-fail/bad-gate3.wit":"5e0d76a3029a0520b121f2ec6823ca39c3d3adfc57556c849898f69240f83a44","tests/ui/parse-fail/bad-gate3.wit.result":"b70ac740092d59b2d1e56c00e20c5bcaa9843f7a3072cd9f3c0a769818c15b78","tests/ui/parse-fail/bad-gate4.wit":"f5fbb50ad5087d0bb5401d290f05e733ee425bbffc514db3a2ed4d0a0dd366db","tests/ui/parse-fail/bad-gate4.wit.result":"8cc9f8a27b97f5861bacea7462002f3d351ea2038f54632d245385b0e9b95b68","tests/ui/parse-fail/bad-gate5.wit":"52b068c1f00f38174f53927cd7729b78648be636e2a7e2544397a8ea9ea8569e","tests/ui/parse-fail/bad-gate5.wit.result":"5fd577243fad4e78350484c79126566649b25a3744ede72e522baa138dca5034","tests/ui/parse-fail/bad-include1.wit":"05ec00177052bacfe2eef6ee2631abfd373a822d100f8d38d7178845cf3d2908","tests/ui/parse-fail/bad-include1.wit.result":"454bef60e7a0eb813b80b9e31187cef96bdbb389389b4238cc1ed45788eaa351","tests/ui/parse-fail/bad-include2.wit":"32d2bfa14dd78c78aecd93b31b28ba7013701411abd8d67e8c5277f1b8efd1a9","tests/ui/parse-fail/bad-include2.wit.result":"70e86e41d76100601131e14ce54df803ea699f4f7941a84e4a56ccd6c2f28d2b","tests/ui/parse-fail/bad-include3.wit":"44995ec365758dc52f7dc6824587df97777dd874f5d010c62222881a5b3ed929","tests/ui/parse-fail/bad-include3.wit.result":"fbe950700e42783b2126d0dddeb08a2fef837b76de2aa62e8f70c62fda7359f0","tests/ui/parse-fail/bad-list.wit":"20255af34f429589b311fd29367e4f7679eb8f1667538522b048ec5d9e5886e0","tests/ui/parse-fail/bad-list.wit.result":"b8323d11bf88203feee59ae6cb0f67a017ee75183e635269cec9a37b4518e38c","tests/ui/parse-fail/bad-list2.wit":"8325a40a06f2c29c0f106e39652b2519ff40a11f0829da3d32e2c91fd05dee81","tests/ui/parse-fail/bad-list2.wit.result":"7dd98a2e45abaa0fc1c97133df251aa57f855c112f46cd99f2c948e9a425b8c8","tests/ui/parse-fail/bad-list3.wit":"070c1d4580008679e693d5748069c67738620f36958bd71533aaa0813516edd1","tests/ui/parse-fail/bad-list3.wit.result":"460b21d80f73f1d518ae7723c436092bcae56d036c84cc6aee9c6cb616e4e3d3","tests/ui/parse-fail/bad-list4.wit":"474d295829f1303800b0e52ad5e9ff1f997c8f6db5a33028cc0a8502310e310d","tests/ui/parse-fail/bad-list4.wit.result":"74df59ff1e7058f1be49457c7eb8b77dcdf5fa06c007b6e5e7167990fad30b0b","tests/ui/parse-fail/bad-pkg1.wit.result":"8a63ad8c4e708640df5a2a7a064bc26d4ed64a3338215c5cae52518dc0a0f3a7","tests/ui/parse-fail/bad-pkg1/root.wit":"45df62dc512d8f9ead7982c32ea95318253fc243db73cf3b25aaefbe05778c4d","tests/ui/parse-fail/bad-pkg2.wit.result":"9423d8216ca764758513f53bef83fa053e49835f0bdb5b8bb77136b1d391a50f","tests/ui/parse-fail/bad-pkg2/deps/bar/empty.wit":"ccadb54a828f5e200f6f2ca40d3e5bfca9431ab59b375e7dfde91a149b34fa7b","tests/ui/parse-fail/bad-pkg2/root.wit":"3f04dc4f6d4c4adcf178cfeccba312f75439c3bf6a14f9f4d0bbc7d83e259582","tests/ui/parse-fail/bad-pkg3.wit.result":"444c65ff4abf7fa1c37a5403461539013c139ce49dc3ba0cf098683e4870d373","tests/ui/parse-fail/bad-pkg3/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg3/deps/bar/baz.wit":"f521c75f8fea0201278adcba4457115de7eb856a3338ec03dd4df223febe7409","tests/ui/parse-fail/bad-pkg3/root.wit":"3c1725bb749c1ace117e290e0085358bc6cceb4aaf9a6fc1e29c82c5a581ad24","tests/ui/parse-fail/bad-pkg4.wit.result":"cfa526440ae834e59214dfa67f92b0a1f013b4e54d705ec56a4f5341fe9853d3","tests/ui/parse-fail/bad-pkg4/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg4/deps/bar/baz.wit":"f0d7f373a2981f747ff15f994d10abdb7c5d9dc7181daf8e4b4610f98807658d","tests/ui/parse-fail/bad-pkg4/root.wit":"2b060a7ce9da4b0cd8960a28f069f046902633fdcd5dbac2f827658ab674f5d7","tests/ui/parse-fail/bad-pkg5.wit.result":"63d5877b3bf734e1900472a219ef4f20411bdf4d6608eb582ee342a0de5ce8fd","tests/ui/parse-fail/bad-pkg5/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg5/deps/bar/baz.wit":"43ba055c268fbdd4686b141395ce8582e1cddb6699b9564b10793a603abbcd37","tests/ui/parse-fail/bad-pkg5/root.wit":"8fe9c00d8a56e994c9914997d926013e43e01f6b610b27bb3311a9c89566bfbe","tests/ui/parse-fail/bad-pkg6.wit.result":"4c3238fe2df05329d6475277d73dc1731affa5b62717904b536f0609ac9c7341","tests/ui/parse-fail/bad-pkg6/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/bad-pkg6/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/bad-pkg6/root.wit":"62abc0d5005b2bc46c039978a056e3525c165c29449bf617ca2f4afdb6ebaa98","tests/ui/parse-fail/bad-resource1.wit":"d3783f455c501334f2ae8d132490afffee5142ad1e94ceb3fb0e576299419147","tests/ui/parse-fail/bad-resource1.wit.result":"63fe0c9f4045c9d1643a328d007807f34e495ed8b25c429b65f5721147e842cf","tests/ui/parse-fail/bad-resource10.wit":"4158f1b360360ea4e4429720b34e91b9d259eada8e574733af3c83393552fd38","tests/ui/parse-fail/bad-resource10.wit.result":"f4ed54d9da0802ab22cd25f00f300f8d9bfd1a34820b610ddb37336e210cc40b","tests/ui/parse-fail/bad-resource11.wit":"24459fbe029d94febe36a6823d5992a59732bc8b5436c4bedf2c5192e2c20be2","tests/ui/parse-fail/bad-resource11.wit.result":"54cd069d5119f632d36c4167a7ea9032ac9daa3564691aefd25473d474ab32fb","tests/ui/parse-fail/bad-resource12.wit":"da12b00ae70ece5df5faf295a75b484e89ef3bd5edb07bd7b76bf7dadb04dc45","tests/ui/parse-fail/bad-resource12.wit.result":"0fbb864a5ebb00a53afb87524a534a77de5fa5122d95bf33b7f92e217326fc44","tests/ui/parse-fail/bad-resource13.wit":"e01ae82c5dc83a1f201fb9942b01f469eddd63741a12e14c4b97510cd0b74daa","tests/ui/parse-fail/bad-resource13.wit.result":"f937ab865f5cf26b0302bb94126c2482323fb31d3c4ce606cd10d5750600f8c4","tests/ui/parse-fail/bad-resource14.wit":"ed4450c13763dbe83921828ae23f8900ed88de70ca0bf989874c31e88e929cba","tests/ui/parse-fail/bad-resource14.wit.result":"ac54d2dae60e13d89f6f1532ee4629a9dff3d410be0e9bcb37025d77da8d9176","tests/ui/parse-fail/bad-resource15.wit.result":"8234ca2888cd2ca50708c41de82461bbf64997269032e9a221b6b66ebcbeaa30","tests/ui/parse-fail/bad-resource15/deps/foo/foo.wit":"19b517ce45a205776724b53a0296780751b757e80b4836a0c1230f1238ec2f69","tests/ui/parse-fail/bad-resource15/foo.wit":"92a38c0eef30ffdb5a314889e127532289afc03d5c6a66d38fc6763869285a80","tests/ui/parse-fail/bad-resource16.wit":"c1b3724b5a2d0689db57521fb35f0e8f47302fff277e5fac4e077712b8d06ed5","tests/ui/parse-fail/bad-resource16.wit.result":"6684499b5f7745fbdefd81ae2b9507125364adc3799650f1ed9acb551daad264","tests/ui/parse-fail/bad-resource17.wit":"e3da1cf497d48033f3a91d25ae2f7129de54c004c9b448e5e810ceb2304364c9","tests/ui/parse-fail/bad-resource17.wit.result":"03cf4d36938c5ab1b0656e3ee0e0c0de66707cb0791cb7fb969723d042c40dc9","tests/ui/parse-fail/bad-resource2.wit":"78f8e65877b7254aaf8f448f7f5f4e50774d797fc3eb64ca2793532ff16a62ff","tests/ui/parse-fail/bad-resource2.wit.result":"d0d968ebf8a06cda2946fd4b30595826a6db0ffa40f71ba5472884e75601313e","tests/ui/parse-fail/bad-resource3.wit":"e8620477d3cc02bc3b130d2fc14f2431fffac0cf516cbc05aff2dda37740f2fb","tests/ui/parse-fail/bad-resource3.wit.result":"b19b0a6f8ba99e738504c433afb19e7f17081db14d10dc01506ade5c31b11cb9","tests/ui/parse-fail/bad-resource4.wit":"31537bd0d09e58dee09ea9b93054c8cbb3cfd39bc4a1fa9330bd7b945bd81681","tests/ui/parse-fail/bad-resource4.wit.result":"bca647b5172c6c0bceea3de7ac2dfc7426b68e55468d081beade9b4ff2b0b0fc","tests/ui/parse-fail/bad-resource5.wit":"854fac37c2b7c8edae5276aa1c7c6cc726a348ae757c0f9cc5cd4103d75dc640","tests/ui/parse-fail/bad-resource5.wit.result":"db20186fc1b39c832acedadcaebf2d1f7f803253a2df5eb57b7fd6f66f8d7b38","tests/ui/parse-fail/bad-resource6.wit":"a5f798328cbf777cce00069a637f1dc7d79423c685ebe11a21f7f8ead1bccef4","tests/ui/parse-fail/bad-resource6.wit.result":"1955db627b4a2db9dd86d37974567454572b222bcb33e70664393b31e244a0a9","tests/ui/parse-fail/bad-resource7.wit":"7d09275525b419858d26533211b6a9d3a7b67639e8aa1fc28eabd713dfff4eb1","tests/ui/parse-fail/bad-resource7.wit.result":"c62958d5564b25268b662677cd35b24c4131d985d906c2d61a80bc61ba11267d","tests/ui/parse-fail/bad-resource8.wit":"da8489525fe75a197731293d384c151da204fbb2a278b9ab7a6c30fee45efcdb","tests/ui/parse-fail/bad-resource8.wit.result":"eb657e7afedd3fd1b849780564c5b0350888531fb19092961181d11e31659499","tests/ui/parse-fail/bad-resource9.wit":"5bdde3d51bf8f3e86752a21a31d93776a6b390e41ae9aeedaf7b829e7afd8f19","tests/ui/parse-fail/bad-resource9.wit.result":"d2e74db311d6ddb2796837e9426a58b7a02e8140d72a6a681eea6f54a8731f9d","tests/ui/parse-fail/bad-since1.wit":"8180c2632f6d75ee675528f4e9fad184ea5c9675ba09f34f61d7bca5ced38344","tests/ui/parse-fail/bad-since1.wit.result":"b6023204b3da7c1f58491609dfe5016b05bb8b8cd61b5b38114591c01b24e1f4","tests/ui/parse-fail/bad-since3.wit":"477408c0e355c1383103aecbd4bd4769df5ce251bae1ae5405183dac9a920c6d","tests/ui/parse-fail/bad-since3.wit.result":"07a4d9d40e6fb85da01062a72e6dc0e3cab81fc6a9b5223796957fff492ded90","tests/ui/parse-fail/bad-world-type1.wit":"c04002fdb48270e72f804642932b84f8a0a6acdf03d335e7b809c61b9e5efe64","tests/ui/parse-fail/bad-world-type1.wit.result":"2073c4406bba9ab314d172840c8b43f2e505bee7f823a21abb0f7c649d81a504","tests/ui/parse-fail/case-insensitive-duplicates.wit":"0517099b9586ef9a1a22e4a340e00b3f9088891e5203906ee2303e5e47cf9a49","tests/ui/parse-fail/case-insensitive-duplicates.wit.result":"6404ed765277711fe927b011daf90c20a69942ed2578458a0df285424e6d0cf8","tests/ui/parse-fail/conflicting-package.wit.result":"7577d7f04ab4ecd2401b2b546d46cf42f3951d30f8a118ab843c043194599b33","tests/ui/parse-fail/conflicting-package/a.wit":"20fd778f4594d89d4b3282ed2b4e005cd3e7a377eedbd9a05ba9b96468f53d55","tests/ui/parse-fail/conflicting-package/b.wit":"05ce70a45e9d19c833579bdd20a4fbbc98cc2f2ce737e1030e41f35cab4f0066","tests/ui/parse-fail/cycle.wit":"6940cebea92951af95a7a352f76ec8c79326005a0698e977ec362923ddbddb8e","tests/ui/parse-fail/cycle.wit.result":"09ab288a56c511e8cea5cae9b72f474a4f2cc6ad4bf2840ee10d10e45a144d0b","tests/ui/parse-fail/cycle2.wit":"5c7d28994b1fd872236a03238d9d1b757eefed741a1e540a4bc55e0c2ad0fde2","tests/ui/parse-fail/cycle2.wit.result":"eba74322800b7476a356ad73d8eb40aa5165389624c555d58616144e11b7672c","tests/ui/parse-fail/cycle3.wit":"0f4c613e93478afad6065642b60b5979a8df4ec1e13359f0c9824a218c966de6","tests/ui/parse-fail/cycle3.wit.result":"d98f5432924f5feee6f1a60ace1c0dd82b555a260502b166ab51bad0312e82ec","tests/ui/parse-fail/cycle4.wit":"74fab6b8fff3e176bc1499f3e0acc46f1746e8664a7b0307389645e7ef03b696","tests/ui/parse-fail/cycle4.wit.result":"4b4c4b912e4363eae23b6ae92cb4e499f0582d24299912aedcc0ab78b6ba0e67","tests/ui/parse-fail/cycle5.wit":"c21c064e42ec81544a0ae5cfa0081313b8023fc4cc6725b27a8307ea0acc43cb","tests/ui/parse-fail/cycle5.wit.result":"155993cd465deceded417e0eeac9c04a50adadd6a521786e3a0d3b33b352c062","tests/ui/parse-fail/dangling-type.wit":"61ab6f89a622be1f4003dd4c6841d780646b78f314c0759b77dcf6b2bb91e355","tests/ui/parse-fail/dangling-type.wit.result":"d5d60bd20198bf6fee5066f0bb1bd1a6129a7b23ee28fd623a540f6830267e13","tests/ui/parse-fail/duplicate-function-params.wit":"7c86f5515793538b821a4797f4a8456930329a0fcd054d29e1b7b1117a29d295","tests/ui/parse-fail/duplicate-function-params.wit.result":"614f85899af13a69cf98d762c61d3e607dcfb3d3ed7e4ada211ed1eb7af8a9c9","tests/ui/parse-fail/duplicate-functions.wit":"9ff1bc0093dbe55b961e8a5f4b528c145c1d975bea619b2936cd6cf839edf0e6","tests/ui/parse-fail/duplicate-functions.wit.result":"aff563662f466c0bdaaec5bb197f0aeba8b31c7e962f84a6a1a26c3944601ffc","tests/ui/parse-fail/duplicate-interface.wit":"3acb5212bebafe8eb10e0176f74ffe999b20d9cdb7ce82f09672584a043f90eb","tests/ui/parse-fail/duplicate-interface.wit.result":"8ae55ae32e250a01caca352d9ab03e4a062060095f6e728011b8677fdff86de2","tests/ui/parse-fail/duplicate-interface2.wit.result":"f4f24a6a163cbe68f74613708cdd1b409fd55c775967c0983e466c5b1542a25a","tests/ui/parse-fail/duplicate-interface2/foo.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-interface2/foo2.wit":"a8b52734e2c6998d07e2222dafe28b40f136b4c2f3315955d4b1885e1d0ced8b","tests/ui/parse-fail/duplicate-type.wit":"0d1623865f9cb358f8344fa954becf249e948ee37bb22004c1405602c2f083b4","tests/ui/parse-fail/duplicate-type.wit.result":"de1f41c3125a8ef52719b845bb685b1e735c504b3c7b63e39374f826d7315055","tests/ui/parse-fail/empty-enum.wit":"4d345214cf0ee46c4b4108fc0e9f7b8aaeb7eff82171400aaf45c1fb283e558b","tests/ui/parse-fail/empty-enum.wit.result":"6338ac28789456fe02aa133185e8c3d9896812df9377d2211da2dc0f23076c67","tests/ui/parse-fail/empty-variant1.wit":"1f56da64ab09a7f282b1785241dae5bfd8ecb4bbd055a22dcdebed33971f1522","tests/ui/parse-fail/empty-variant1.wit.result":"d67d08b7b070a59b0f803d3e118dfad4ae0cfbdc404965a5cfc5c5198fde5fa9","tests/ui/parse-fail/export-twice.wit":"a3a7cf6e7cbbe513c5561a93e32f030364c622b5123118392e9e2aa6ae44dfef","tests/ui/parse-fail/export-twice.wit.result":"01bed0e73b437ccbc213a389a512a7dafb9a336eeb38d151cdfc8e14e98f450e","tests/ui/parse-fail/import-and-export1.wit":"626f705beb7506cd30d2adea9b339199f9e6d8ac6f62f5f7778e2e2d683b0230","tests/ui/parse-fail/import-and-export1.wit.result":"330a6ed19e4c4e0e89358e599110f5d62bed823e6e5982f576a23e0b25034ee8","tests/ui/parse-fail/import-and-export2.wit":"617a1b3d8e0b227eb4fbf74101133deb537ab5723811e9cc658d8bcb942425a1","tests/ui/parse-fail/import-and-export2.wit.result":"ec0b14b07e21bb21157155e9d056e1cc303affe16fc1536aaae5c948021ce6fd","tests/ui/parse-fail/import-and-export3.wit":"adc857f5752dbf55460be01bbdd19fb54dffedeb1781ea8f842a05041ae6bab5","tests/ui/parse-fail/import-and-export3.wit.result":"9a99411b891ffe302d8070cc8ad280cfb815a17c1d0cd4b72bba3e65df20dd6a","tests/ui/parse-fail/import-and-export4.wit":"9fd002997b30219720270a8c5399bfe45d55737d9052306c992f6eec30c4aad1","tests/ui/parse-fail/import-and-export4.wit.result":"6cd95a14a1eca775006c558013ef3179e715dc913f5d6a95e23cfd3f4bf4cfd9","tests/ui/parse-fail/import-and-export5.wit":"343bf3eeb13507dc168f1478ca452cf36964f002aad051f0283ff8a95ea40747","tests/ui/parse-fail/import-and-export5.wit.result":"ac812b21785e1f0244bd8ab5b59e94b57e29c5fac5db56c2fe339c92362e324a","tests/ui/parse-fail/import-twice.wit":"ba1975d057920962bf325b034b4ca2cfa7587e2fa79ff0b2bca4a0f950e0806e","tests/ui/parse-fail/import-twice.wit.result":"cfc3f8da5f3e65c73992dd7d39f5e3ef9b9154a883183bb7f3cae7339cef7c65","tests/ui/parse-fail/include-cycle.wit":"0c51410fa39f6afa1465696c4ff97b1496c6870dc8fc5a2a2f3c2a4826c24685","tests/ui/parse-fail/include-cycle.wit.result":"95e03934ed9695bbd1856fdbf4b588a429ee41ade3447e664edadda5c8c01256","tests/ui/parse-fail/include-foreign.wit.result":"5662f77092ae988280c0c1eb1f76a81297fcd2c23823f1cfe0904584bf1a36e8","tests/ui/parse-fail/include-foreign/deps/bar/empty.wit":"348f61ad0f69954f7438ebde4cd03acf45ee8a83fe7ac53f9f52576de2fbb30c","tests/ui/parse-fail/include-foreign/root.wit":"d436297400495dd1236cbf0b6268f3663722660e140f1ae68b3ba600399adcef","tests/ui/parse-fail/include-with-id.wit":"3f50cfcbeb23cf182941e6b273136d83b57531224230f47edf4ba6dc16ce40ce","tests/ui/parse-fail/include-with-id.wit.result":"03fa45329b179073500e002fbe014ea48e564ae7a274dbcbb0bc3b5d39959c89","tests/ui/parse-fail/include-with-on-id.wit":"64dcce8aef4c9fcc30376218696070d8f6a3d0d767fd00abb8c2f6672a99cc60","tests/ui/parse-fail/include-with-on-id.wit.result":"cd893a62379128b37045d0c81364e43c8c8fdf372811183c6aa95c6d17a7ad3d","tests/ui/parse-fail/invalid-toplevel.wit":"c292a6cf02880d580b76ebcb0aafbab2bf6c6f8545299016f9a0bc55dab16624","tests/ui/parse-fail/invalid-toplevel.wit.result":"23c34234dd7ba5af3c135487c7607442c6b45b9a328973ddd1bb3bf841ec2148","tests/ui/parse-fail/invalid-type-reference.wit":"61f8a73ee71a39489ff37a41967cdfe011889c25c1623af939cce809562b1915","tests/ui/parse-fail/invalid-type-reference.wit.result":"d0169e51f599096c65186211656e9b007f01698d2004d4ddc9ae26cbc78bcb57","tests/ui/parse-fail/invalid-type-reference2.wit":"9e1b00da3e1d7d39720c41cda330c3ffa338eeb6ab2faa25ab64332108a0e06f","tests/ui/parse-fail/invalid-type-reference2.wit.result":"a9b2a4a2b69b966e3a3d2ffa4a7f94abd775a02fba877f7c7ddb9ebc76a136ab","tests/ui/parse-fail/kebab-name-include-not-found.wit":"ac48583cf9bf4716cbbf22d6356dd897bbdc657530b9e02168b920da2928bd72","tests/ui/parse-fail/kebab-name-include-not-found.wit.result":"f56ed9f900ad4371561fc149bd0429261e10bb26ee76cff57c527febc502cd25","tests/ui/parse-fail/kebab-name-include.wit":"f81884221b5f20a69015ba9f94915785f9a7fbb5eaf8a02883ddabca510b7961","tests/ui/parse-fail/kebab-name-include.wit.result":"4c48c8a2b849e53ead974720172a4de0881a426a8717a024202a2329cdf74a3f","tests/ui/parse-fail/keyword.wit":"cd46fd9b045e79e0f5f8ace13a6327ae83e26951f699b25d6e0a872fcac71010","tests/ui/parse-fail/keyword.wit.result":"ef1b6510fb56e899c6bb38592a1953d165e01c5a46bc02249c33b73f99f28740","tests/ui/parse-fail/map-invalid-key.wit":"612eba223b7882277f74826312dd61958dea73443dc95ef1f6ddd8b5f4680c91","tests/ui/parse-fail/map-invalid-key.wit.result":"51555d75fa2b8b8897be3a7136829c35513a896344992d7543986a5ec4fa021b","tests/ui/parse-fail/missing-main-declaration-initial-main.wit":"208a8e0aea83d0aaf50edb322181a1b35728ee972bc7929b63f881ab3a923cfa","tests/ui/parse-fail/missing-main-declaration-initial-main.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit":"eafc130098a084cebb71ed07c84432bbe8269d92e5c999728136cd90b99e3bb1","tests/ui/parse-fail/missing-main-declaration-initial-nested.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/missing-package.wit":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/missing-package.wit.result":"cc8bb114b28ac32a95191a250afbc656e057e6f775822715f99a06c5e036da80","tests/ui/parse-fail/multi-file-missing-delimiter.wit.result":"0d5af4fc565143f116b46ab61e6a4b5fe4d74325af8c6b6180c3ee6a44516ea8","tests/ui/parse-fail/multi-file-missing-delimiter/observe.wit":"bea33af0bfc096aa7058a5d670322f67688b2927d0fcb1eed856593cb5c93b97","tests/ui/parse-fail/multi-file-missing-delimiter/world.wit":"d78271de8c919905008fb0192328770738f31cf2edf9310e7824bad487492c3d","tests/ui/parse-fail/multi-package-deps-share-nest.wit.result":"f4c43b6c9abefe4e13b6224c057276f30a8355363936e0c1c2b1292808f61147","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep1/types.wit":"dccf32826372acf61a4132d118d1759874c83b5e3032dcedb91fb283489bbf28","tests/ui/parse-fail/multi-package-deps-share-nest/deps/dep2/types.wit":"ccb04fe89839748a7cd9c09d333acd549c4900d84ea1d57cb8890d12ec4303c8","tests/ui/parse-fail/multi-package-deps-share-nest/root.wit":"7b874fb105af381d5361283b115d7d38885e6a055fa5af6867a85f03207ae7f6","tests/ui/parse-fail/multiple-package-docs.wit.result":"db1231691632699274fbdf8a94cbb52a3ddfd429870ddeb8eb15b11ebea0def5","tests/ui/parse-fail/multiple-package-docs/a.wit":"456ace15e375131385fa74f93d676b80ff9179a77b2a8c4cdf01e4cfeca80527","tests/ui/parse-fail/multiple-package-docs/b.wit":"9ad7758e29c6b08f0f072c8ab7ecedde3718abd161b2e05c284d46f95e68b208","tests/ui/parse-fail/multiple-package-inline-cycle.wit":"4c993b0b8a83f68090b85db4d95872145069d5bcd946dcab8a878770726e0b24","tests/ui/parse-fail/multiple-package-inline-cycle.wit.result":"a624984751c8f0674b50c4e297720b104658b5d9ebb15098717fe443ca3d0197","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit":"a45426e4136e28663f40278e268a390a7562027d6cb6f27168576e3853d66b25","tests/ui/parse-fail/multiple-packages-no-scope-blocks.wit.result":"1a416a1576e387ecc0d34b9a922ba7e5f536b6c48c46a881950e0100c1f569f6","tests/ui/parse-fail/nested-packages-colliding-names.wit":"a528b3e1dacab79c7aa2c7ad6ed42da2f0061c242f178d42152c25f45ead1baa","tests/ui/parse-fail/nested-packages-colliding-names.wit.result":"f2d637675a851babb091b4f6dfe8410bc48b5505499b65ef3519f714cc5d9ba6","tests/ui/parse-fail/nested-packages-with-error.wit":"f8d310644b61d2b0eb4641a003d8c1dbbbf8ec3f98752b3b5ec791d2a0fa7f58","tests/ui/parse-fail/nested-packages-with-error.wit.result":"973d5a905fa8c6149d03978458a2c63a4646a37b9541c5f045abfb1742ece093","tests/ui/parse-fail/no-access-to-sibling-use.wit.result":"3b640ef3569ac8602f155fdbbaa503203dd9f9d01c53c7b6c693787dea408d2f","tests/ui/parse-fail/no-access-to-sibling-use/bar.wit":"e52d3b5ce50a6c3260a367256406d67401d9a48c3aa9bdbb5c9dde30712951cd","tests/ui/parse-fail/no-access-to-sibling-use/foo.wit":"5c4d88f6af280b678722f265775abec5c577eae47e5be275d9bb2ae2b3092a99","tests/ui/parse-fail/non-existance-world-include.wit.result":"8179176b5d30fa1d472cf7269277753ae8f28d2337fd3d4d9409256df24391f7","tests/ui/parse-fail/non-existance-world-include/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/non-existance-world-include/deps/bar/baz.wit":"e0417499e5a97b2a5dedf83f881eb85830bdad3a2f2724cb07bf3bcd13e4a01e","tests/ui/parse-fail/non-existance-world-include/root.wit":"758be0657b943a7718ea8b8f6b68e39a71264f6ea55ae1602ea993352b7ca939","tests/ui/parse-fail/old-float-types.wit":"a331d50c87423e3ff6683e2a43b514d404e7c7920a4951e99bf7dd60b9a8e53a","tests/ui/parse-fail/old-float-types.wit.result":"1131f9caaf4efbe23923c836b71621c3a8c3b3b3293a1e4c6e1a8c589fd34ce2","tests/ui/parse-fail/pkg-cycle.wit.result":"9331660c2b320ad8e2b8477b1797769ed119137df99db9482c2ead7ad18dc573","tests/ui/parse-fail/pkg-cycle/deps/a1/root.wit":"a401664c52777f3542a756eb79a2344ef4d569908df54e15a0243c31aa77b58b","tests/ui/parse-fail/pkg-cycle/root.wit":"4d42e9e04ba377787b944aec6cb44e3ead0088d7130647db5ca67b4cca7be490","tests/ui/parse-fail/pkg-cycle2.wit.result":"048547c47dd0e85ae7df58f3492090c699b271b326f632900ae1e20ef81db276","tests/ui/parse-fail/pkg-cycle2/deps/a1/root.wit":"122dd6e3f2f3f4569b44533ed967b5facd458c38116bdcce3f936f3642005180","tests/ui/parse-fail/pkg-cycle2/deps/a2/root.wit":"b16a1b33f2525e49d3f3691fd1d43598a0e4cf0015bdc7a9979b73737085a830","tests/ui/parse-fail/pkg-cycle2/root.wit":"60bf50dbc32c8b2e702e042358884c293372689fb0a8a34866897fe995ccccd9","tests/ui/parse-fail/resources-multiple-returns-borrow.wit":"79b3bcb55c4df39cd2037e547aaa2200f920591722517db34652e7ad4e766b50","tests/ui/parse-fail/resources-multiple-returns-borrow.wit.result":"d4c6f5075e50d48dc277c5940d34f58640e8d78b2dad6f9a2f5827d975a11328","tests/ui/parse-fail/resources-return-borrow.wit":"7be90d00f626f87b85990a97d26862f5a00352d67acf4a89045c197cb555e6b8","tests/ui/parse-fail/resources-return-borrow.wit.result":"e43f5d3e7c577d8162b255cb0ec3ea0731634dc63801996fc9f7c328cbb36942","tests/ui/parse-fail/return-borrow1.wit":"1e76d092f4919748bac9db9907a638c26a6ca92ab599f026261511f8c2a662cf","tests/ui/parse-fail/return-borrow1.wit.result":"ff77a7717f0baa3b440edf0f9ab5d2a515c99d19a7f159db6f0d11dce06f18bb","tests/ui/parse-fail/return-borrow2.wit":"f707a3ae6de39ed0db7746410506040dcaa2621324b996708d54aba02c9c49bf","tests/ui/parse-fail/return-borrow2.wit.result":"f64b3af5d0c3e7ff1e8f8f773950aac6d4d5ba2169de1a6e998d3dd05f72dfe0","tests/ui/parse-fail/return-borrow3.wit":"5a5760e399143ba937e5d3d773fbf8920ef826397d63175c794488960c602256","tests/ui/parse-fail/return-borrow3.wit.result":"87e650418893bc64d7712873ff8ef86e32bb0337d73c5c87dcdf78ebbad2ae03","tests/ui/parse-fail/return-borrow4.wit":"3e26cf4beedfb48ef6cb449cfefb4977a9ce0e56afbbef96b01c9279eed9c7ba","tests/ui/parse-fail/return-borrow4.wit.result":"45dc8b37c04ff614222096a1060b84c837947d3e7598daa241706c00b55c8d88","tests/ui/parse-fail/return-borrow5.wit":"fc0883c45f58f9febce715c622cdacc4c7a30d8e7acf16e7862969910a621cd3","tests/ui/parse-fail/return-borrow5.wit.result":"73afcb04f4f80c7d8a30928f47843f6524e15e0c0f1a9d3ebe74b4a9a32a5003","tests/ui/parse-fail/return-borrow6.wit":"f7b0b935f130bf810cb4fd21b96ecdf95993d20da8b8d82522d18e5051633726","tests/ui/parse-fail/return-borrow6.wit.result":"a32b28110a8fff2f999491ffcc7aa6d918094abd361be6d2ba4aa0da73c82921","tests/ui/parse-fail/return-borrow7.wit":"63626a382d1213cae263363950c9a64d6d54099b9ac535c594ab6926cb1233bf","tests/ui/parse-fail/return-borrow7.wit.result":"f13777e7b0536fd025f84e6bd8d8a01d47d85d8fa94fa428537213541ae691b2","tests/ui/parse-fail/return-borrow8.wit.result":"9fb553cd5e9541f8624c06204f79ab75c8840c7dcb38a356615f105bc73a9b93","tests/ui/parse-fail/return-borrow8/deps/baz.wit":"62b2638655b890dcc9d7be49bac7ff4689a3ca553293ba1b577f197c6fc91afc","tests/ui/parse-fail/return-borrow8/foo.wit":"f7915c3b37ce20432539b9e7a0662cc773f00a24dd8c5f8e9924392e522c940b","tests/ui/parse-fail/type-and-resource-same-name.wit.result":"28f2c298385dd152ad21a5be43ee86518368fb003ca79985c301b22774e3a778","tests/ui/parse-fail/type-and-resource-same-name/deps/dep/foo.wit":"e209e375ac3c8a02332abadf1112b6ee88a36c0b78bec82141927b8209aeb793","tests/ui/parse-fail/type-and-resource-same-name/foo.wit":"1edf7997100c89b9e299693ef9d0021ffe43d041a39540e193b11d616bbfab35","tests/ui/parse-fail/undefined-typed.wit":"a5c783ac0da51d15526b0104a0d468bd72e6726706ecef1fbbd5cf6aa413e53d","tests/ui/parse-fail/undefined-typed.wit.result":"794055fa5bd2101d289b55236dd813ea1428bbac89133020bbf2270d2c707c30","tests/ui/parse-fail/unknown-interface.wit":"4813d741cead7412e6f453e728627407069ab17922445dd67acfb80cdf463deb","tests/ui/parse-fail/unknown-interface.wit.result":"545c3a6eee6e89b51a46145bd6609cae3f03ac65df0ebc735e439cef0541bacc","tests/ui/parse-fail/unresolved-interface1.wit":"aa48ae74e1dc3165f05a0d216fcc02b5a22e2cd8cab1c1d3fd9b4ec09da5a47f","tests/ui/parse-fail/unresolved-interface1.wit.result":"b4adf53a899553e08ed1e76457970a15753cad66147c39d40a2f2397734238d5","tests/ui/parse-fail/unresolved-interface2.wit":"0fea9d7ff4592d723e4a9c3dbf341357a4902509996d8eb30a6f520735d0a41e","tests/ui/parse-fail/unresolved-interface2.wit.result":"66b21536fd06f55c737bea8d783e11f707003f988d23764cab478eda8afa6555","tests/ui/parse-fail/unresolved-interface3.wit":"ca7dbd14ec8ee5d01ab2bb7c28b7a3713f31db8c092511b3233b46bc5c353c10","tests/ui/parse-fail/unresolved-interface3.wit.result":"6cd94000e5678a2fde3234638b510ce3bed9f0a2f1cfe589527ba0cfa4e9ba14","tests/ui/parse-fail/unresolved-interface4.wit":"cbb042a9274076b17b7e0c42fc971da6fecfe2e6707a1d7026dd4f647ce5426f","tests/ui/parse-fail/unresolved-interface4.wit.result":"4093b50bcb7aeb9d776139290c723a5979cd5c9b5240c3d4fff127755740675c","tests/ui/parse-fail/unresolved-use1.wit":"f6b32002e7060026cd91e879d11d5f55d1fd0abcd8cb89a37325f8816bde9a9a","tests/ui/parse-fail/unresolved-use1.wit.result":"c5347149bf31d2dae55360c12b266292e4e96a49bb1a3494877cc7c031841f8d","tests/ui/parse-fail/unresolved-use10.wit.result":"551a761df6989b52b2e042924bb1b3b0055f3ec7f451d1b0c70dd4b49e2e5f2c","tests/ui/parse-fail/unresolved-use10/bar.wit":"7dad62091e741838831396f8fd31846a26ef6de0fbcadc350ade8fff0bf575ee","tests/ui/parse-fail/unresolved-use10/foo.wit":"feecb9606feec3ea7f499a1e9d97a86185c861eeef81c6e31c4d3805752d099b","tests/ui/parse-fail/unresolved-use2.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use2.wit.result":"a62b50fe39176b748df8fcfbcc28c099e801762f1e099d65f751e95c92afabbf","tests/ui/parse-fail/unresolved-use3.wit":"47fd4331dd9f76416230f2b4236a1837d1fba2e17603b25376306d2afb72bf24","tests/ui/parse-fail/unresolved-use3.wit.result":"ebf46f8ec011c0a98a0593ad217c1fb90ad142898b76385ca6c02d01a34d883f","tests/ui/parse-fail/unresolved-use7.wit":"b57684da212586ce720cf3161f9a659d3abaec989a4081172a5cd05425777a9a","tests/ui/parse-fail/unresolved-use7.wit.result":"7be5ab3f67d7b0df5ef2d0df1f66c2f2995bf247042bc89ea90089c05d254f84","tests/ui/parse-fail/unresolved-use8.wit":"9208e402aa194d8d0fd3c04f5c3a63e070a6fba35aeb3ee6deb620bdbe825be6","tests/ui/parse-fail/unresolved-use8.wit.result":"0f326c857f8ef05ed3687fc35816318931e9a189a5d3730b8437a0d967f354ba","tests/ui/parse-fail/unresolved-use9.wit":"a55be65d32510b790f687a8cd1a17cc78d66fc348a73c202786ccfc73ef80cda","tests/ui/parse-fail/unresolved-use9.wit.result":"a2479c0725a0e882c20999e0f194d4054777292b5fd3e08115b28d87b6d1217d","tests/ui/parse-fail/unterminated-string.wit.result":"ad1667fb37e169ae458c86c87154fcc2c25c1194578812dfb83c8a941c2ed002","tests/ui/parse-fail/use-and-include-world.wit.result":"5817300629cfa4fc8275c63f2012f2328f27375b771d2da2a14a76d520dcc4e8","tests/ui/parse-fail/use-and-include-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-and-include-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-and-include-world/root.wit":"78da4438e0a957af1421dc8c503593f3e675c5179eda0e1671c856b3cdcb6af2","tests/ui/parse-fail/use-conflict.wit":"034cccb48e6d9a80967c432bb1590c753c12d483aec6fa6d0da96eb6dd95636d","tests/ui/parse-fail/use-conflict.wit.result":"27bbdcde0151687d6a785e785824b458eb8f3393266e16146641a0c6062fb6ac","tests/ui/parse-fail/use-conflict2.wit":"fae3ffc85bea2e71f6427442516a93346a1c078db321ff1d9c79f3aa803a8a80","tests/ui/parse-fail/use-conflict2.wit.result":"a10548056049674ab161e6c63bd34aa17388ccd01ed7afdf765d98a40cf42cac","tests/ui/parse-fail/use-conflict3.wit":"c7d3fec48232c0fac946535509b6da609454b8d167040c2545ac3a21f88d9daa","tests/ui/parse-fail/use-conflict3.wit.result":"fed3b72eeee230b2d7866e9eb8feca2481006ee1847ca52df1c535ca34314f97","tests/ui/parse-fail/use-cycle1.wit":"221c299f701cb74b83aca20e869d2c0aefb813fe24cabdc2e911a2c957eb7852","tests/ui/parse-fail/use-cycle1.wit.result":"33d47e1ea89d5fb0bae32e036c98b3d5399196207207c208f195bf509c186ffb","tests/ui/parse-fail/use-cycle4.wit":"e2be0e1404e32463030ca188fbc73e33b0742890b15dcfb49d958aefebd2c3f4","tests/ui/parse-fail/use-cycle4.wit.result":"382267390c78b50f7f88145e5d14535d2cf63bc666770e6bd059fa7354340671","tests/ui/parse-fail/use-shadow1.wit":"0aaecccbbb79cf9472ba313e2d46c05bf3880c45f653fae7b0c78f4b22a295df","tests/ui/parse-fail/use-shadow1.wit.result":"a773e07251372341385395796eadb1fed6c9874ad24da54695556189162a18cf","tests/ui/parse-fail/use-world.wit.result":"15bed7cfaa1a4f59221761ddf8aa7eac1663e17c24951cff8f6d4e18d90954a5","tests/ui/parse-fail/use-world/deps/bar/.gitkeep":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","tests/ui/parse-fail/use-world/deps/bar/baz.wit":"a3bdbdbec31db5c6ae2d898c5d82e1513e39bec7d887b199e648595ed7845102","tests/ui/parse-fail/use-world/root.wit":"8acc2f7d198aac787e288e81bdfb1a088014f4a4d1afac464e2cf3f42845d6bd","tests/ui/parse-fail/very-nested-packages.wit":"634d9ea887eb80da7207f942d5ddc53fe6d2b06e7098e6766e4430dc8ead7742","tests/ui/parse-fail/very-nested-packages.wit.result":"ca58759135852a95265d4d55ddde1d43098c307de3423288462932451a5b3e89","tests/ui/parse-fail/world-interface-clash.wit":"6584c79206067af3dc3647f38deb9e5bbd7ea030b7a26f267e10db0b3243bb5b","tests/ui/parse-fail/world-interface-clash.wit.result":"a75d15d2d1eee8078553abbbadacc665c08de9a2a7ab098cf6916ff6bb2b9092","tests/ui/parse-fail/world-same-fields2.wit":"99e6297c3566e8d0df7d4a953b2d816303999fe040776956a8215de6f86a4c0a","tests/ui/parse-fail/world-same-fields2.wit.result":"421bff8bef32cec8f401c7c769c41775db49f10d31497eb66dd573503d342239","tests/ui/parse-fail/world-same-fields3.wit":"179e96948f1bd9b85b3fd53ccd932e1a5828c2ff6ce20f3f69a40295c9d3142c","tests/ui/parse-fail/world-same-fields3.wit.result":"6ae7d531dd1e711f54c3f367424a834da4834f7b1d0d1f0b851b8fdb36def6aa","tests/ui/parse-fail/world-top-level-func.wit":"25198b3e596b399f6724288ec81e7cb5a2b138db575ff2854e3263e4c1d345ea","tests/ui/parse-fail/world-top-level-func.wit.result":"3842657363ed9453b394f6cce0278a6b8cd0b7fb9c4c7044060b2a5a5a6ef093","tests/ui/parse-fail/world-top-level-func2.wit":"05ac462fe2731f3b4b3e0b16cfee74457302d376d14df35f22337016ba49df43","tests/ui/parse-fail/world-top-level-func2.wit.result":"da74d6cadafbea0711f432d1a0813615d8779784337d440f56391d77ebc66ef3","tests/ui/random.wit":"a308df65c57e4848930795bc110f1b2dde102c6e9963570a404c648b2b0be33a","tests/ui/random.wit.json":"7469b9e378f13f111e78657feeb3ef9873c6bcc3099260ae4e6090bdab28d85b","tests/ui/resources-empty.wit":"a7ad4630c28f52b6ed054520613feb8b11d632fcaa80c21ef5b84343cf649659","tests/ui/resources-empty.wit.json":"088c997de81f3366ef77ae83190d6d530810eabdd7f8c7aac4e4014cad90b5e0","tests/ui/resources-multiple-returns-own.wit":"7c665e511dbd2992fb6efcb6412241d1bda0074da78d394ead1070cf6be7f187","tests/ui/resources-multiple-returns-own.wit.json":"95a404930f7eb64112f9a661dcd0f047b6eb33d12f2e1de500e196c9d5b51edf","tests/ui/resources-multiple.wit":"98724d3b6a1d0d192970d9ae149e31694bd9c3f86bfe2e89c520e1a063724921","tests/ui/resources-multiple.wit.json":"265d1bd3914243d782d5c9b0fda62d285655ab5f43196ceeb32fba791909f116","tests/ui/resources-return-own.wit":"29d9f53bd39d0c2263c7260508a1f954e59b28923994f94bda0184cf037c4210","tests/ui/resources-return-own.wit.json":"8b60ee12530bab3e0643ddc7ed4e757b57f395e397b834a53eac2958c95824c7","tests/ui/resources.wit":"3535fc8c8381779d33082f54384362c0e3ab23cfe675562333e6840682d71ebe","tests/ui/resources.wit.json":"ba8fff6d19dcb72e277c925e52646f68b0e6e0b15eff6334de9d770a6f04465f","tests/ui/resources1.wit":"9eb5d63717f20c6801c6c71f6306ae3e2c37790bfe8a89659c11cce85797d128","tests/ui/resources1.wit.json":"090fa9e402168d2a157e7abdda3d450c48b90e2cc325bcc0be30447682ace656","tests/ui/same-name-import-export.wit":"95ba4578908c29d2af14fcdd8970362c8bafb2174916c0f0772b09437e8d57a4","tests/ui/same-name-import-export.wit.json":"c3d2c9fd7a219ffe2fe094233c369916ce0fee0a2efcebfac008a45bc7c5f8dd","tests/ui/shared-types.wit":"d145c035d916f453a7eeb034bf2a59c2e24f14061d8385ab39cc1f076c9265ae","tests/ui/shared-types.wit.json":"70be131e2e80cdf62ba7a2a20418f71f7480428e2e05e1c387dc1a24667dd652","tests/ui/simple-wasm-text.wat":"10e7380158502c5ca3a1ac9d4195b0455cc02438fed0fb3f7188674354c25c2c","tests/ui/simple-wasm-text.wit.json":"0f91dec1e13fb9e0c30b4e1ad6b4335ea22fdc435ff526e3549dc19a8af97443","tests/ui/since-and-unstable.wit":"312fe8ecc9f22c083f3e59ea306731c198b4d1dd8e2bc1b3d868e90b184163a6","tests/ui/since-and-unstable.wit.json":"6147a7d1ef4dd8dcd8572ade33e7423ace0eea398586cbd75bab5be2cd361e60","tests/ui/streams-and-futures.wit":"2d4d378de4dab66aebc90d4dcfec58b3afccc646f83491801d51999fb612cbe4","tests/ui/streams-and-futures.wit.json":"3e180d6002e03e72797e45bfd4003c4dbebcfbecfded930c646cd8837054a6b1","tests/ui/stress-export-elaborate.wit":"7d62775daf1c0e35c7576abd726077e45cde2f693cc21d8cadd542e88271590c","tests/ui/stress-export-elaborate.wit.json":"6930a623e84d06da7fbd49ec1e6d10b43f3821ee191cb7ff56902597210b4c06","tests/ui/type-then-eof.wit":"79610cbf6fe3e2d13ce1fd8c06e53fee6c81d42469ef56e1dd61c46bf5f57ca3","tests/ui/type-then-eof.wit.json":"bcffeaf61ef6ae2ad4752ef83fd5057ff5eeb649d00e797138aefeaedcf39d06","tests/ui/types.wit":"1da7140aa66c3de1867313e5071f18d6814e44d90ae650be25b86dbf58214afa","tests/ui/types.wit.json":"c981cdc0a58a7e500915497eb856a32f37015ca1bfb09b453e3e0bc3fd5b3edf","tests/ui/union-fuzz-1.wit":"c4f60248204707f8dfe134bf4d6ec3385ae343abc4dfa39239798dc9f3991753","tests/ui/union-fuzz-1.wit.json":"5599236aaea5ab475ce9c224bbba3a40de45d5d5a20f75eec23b09e723d14a01","tests/ui/union-fuzz-2.wit":"5e00d73b1b562fb3cb24067fb0b8ba4edf28b6cd71d914dd6b8716f58272f266","tests/ui/union-fuzz-2.wit.json":"5593decd80a12ef08a0937b429ce3414964cadd2eb9138ebd6961a87f0eaa6c8","tests/ui/unstable-resource.wit":"304a4e8cf205f6f7afdc9af0f2756931c1e2875ab7bb70323cd6f1414fb462e8","tests/ui/unstable-resource.wit.json":"98da87f01953568427e36b6676a527cd5b9d54d3a1d5838b65772a58c6ff34cb","tests/ui/use-chain.wit":"3daee8a895e3bfb7c0bd0252f095554a85d07baed2c569c1b7fba5592a1fb675","tests/ui/use-chain.wit.json":"8098e7e6cafb3b22d117a31b1b721d5bda895fd984fa415fdd5cb4490364166f","tests/ui/use.wit":"4c920ba13211fdeeabdb53341c983f002263c464f4bae2829b0dadae3308cbe8","tests/ui/use.wit.json":"0ca15c4eb705f51f0b499f78ce40a45e243f6af040878f9be9697589fb62b99c","tests/ui/version-syntax.wit":"18e83b2246c0271bc3da0bfe004e69ee7699fcfcb6a986ec970dfaab7ec315bb","tests/ui/version-syntax.wit.json":"1722a38926d815646f64ab37ab3181d3cb70d937665a416112bcb7ac50ce31b1","tests/ui/versions.wit.json":"6a2b4f5d9b1cea003a2c3d25cb91116249c02ff307a04109e554457cca2f139e","tests/ui/versions/deps/a1/foo.wit":"407bd32b2274c8b5c0cac5582097d797e1455926c069496a6d5964ebc571b291","tests/ui/versions/deps/a2/foo.wit":"b32843bb65739073b450cef6fd528b2a72bc7fe92fa0953883663a1bf7ced1c4","tests/ui/versions/foo.wit":"4da61a67927a401e08adecd5c1f0d7eb7894982d3beb356184149da458a9f553","tests/ui/wasi.wit":"7227877525a5b0e2fc9ebd6e312d29d110e398126e4706a7fdb07e2d3fa05ff6","tests/ui/wasi.wit.json":"96631c1e2b029e2e15cbc51d2649a8be20e53c0666e8a9a3debed7fffa95bbe4","tests/ui/with-resource-as.wit":"bfc965bbeee53ff610639bef7f6e70057771812395f4328b7025dc6005a5d334","tests/ui/with-resource-as.wit.json":"f230c8a309a799c31759e1e8bc69aa3692e1a8b9fc8eb167f8b5df177b5594f4","tests/ui/world-diamond.wit":"82ca9865f586a5839adee9d8d90a519aead5ead715c2607125e878286f0ce847","tests/ui/world-diamond.wit.json":"5d92d94856aeaca6f73a185c242cfeaadd7afd59a285b6c47ac8997ab5b8db72","tests/ui/world-iface-no-collide.wit":"f1bb804dc568a94c6aa467c8d720a26c4a47a00f3374f4fe045502686eea3d7b","tests/ui/world-iface-no-collide.wit.json":"9c26c5fc05be082e85d37cf928f0bf45750f020a6c1176c92ce8dcdd56cb1d2e","tests/ui/world-implicit-import1.wit":"59515a6a268a6329bcf4e0a6e74b8ed1f77a61638ba8fad5fae935eb0ab59a50","tests/ui/world-implicit-import1.wit.json":"ae22442a9da3bee72efca9bc3adb49df3af510aadf3eda999d6d7b0a21f65a8b","tests/ui/world-implicit-import2.wit":"14bb046b3bf18a2b02ab47ed8be2947f3f911ded88dd2410225ac08e02df8ede","tests/ui/world-implicit-import2.wit.json":"c8a5023cd0159301ac3b415a00a0c349149606f349a7447778f2478f3292182f","tests/ui/world-implicit-import3.wit":"0faf9a3afa61ffab3d3d5e2f869d35d92a39406d65b228865f4871035b93f2d7","tests/ui/world-implicit-import3.wit.json":"488978218df83a17c18274591777d89b8ad18f6958692e50d87483d0d2cd3f5f","tests/ui/world-same-fields4.wit":"8686e463450b6880f1572b0fcb9ac78dfa78c1bf7c1124e255aa79959a49ef7e","tests/ui/world-same-fields4.wit.json":"831f2370d2c565a9f5b9bce32cd05769cb8b1034967051e57d883055157a95c3","tests/ui/world-top-level-funcs.wit":"1ef7498d5c9cae3e8da77bf4af98b2fec439f56387d130b54109b0f16d156d0d","tests/ui/world-top-level-funcs.wit.json":"f3b894996007ca6c370a3f383947ad16c920446a8ea84a32b2082750616d6117","tests/ui/world-top-level-resources.wit":"61267d096998b68bfd72845854f6a2d5391d68f6a0094887fc05cf97cb54410e","tests/ui/world-top-level-resources.wit.json":"35e2342c86841c2b861b5547c6d0cde83bf6ac7af35f7e09af99b209887d19e1","tests/ui/worlds-union-dedup.wit":"1f9ac2813774c0fe1676734bd6e1779f4870091d0d6a8aa061643e865528be10","tests/ui/worlds-union-dedup.wit.json":"254ef09ce95718b658d109cacda832c7dfdc5b7e0420ce1da8fe56589e400dfd","tests/ui/worlds-with-types.wit":"a2e6d00eafed8d6c6278dc9cddbc2ab2542f836869f564cf449625fddc9476e8","tests/ui/worlds-with-types.wit.json":"6d3afdfc4192bc6b6cf8b3507a942d5e63dc5adae26fafed62d5ced0889f6f69"},"package":"ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"} \ No newline at end of file diff --git a/anneal/vendor/wit-parser/tests/.gitignore b/anneal/vendor/wit-parser/tests/.gitignore new file mode 100644 index 0000000000..9365962f41 --- /dev/null +++ b/anneal/vendor/wit-parser/tests/.gitignore @@ -0,0 +1,2 @@ +!*.wasm +!*.wat