Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

35 files changed, 15554 insertions, 0 deletions

diff --git a/vendor/flume/.cargo-checksum.json b/vendor/flume/.cargo-checksum.json
new file mode 100644
index 0000000..b254421
--- /dev/null
+++ b/vendor/flume/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"378edfec4dde51dee9c0d1e8285d88b3d218cb9b8b42ffa3e27405661c23b0b6","Cargo.lock":"cc14608e4a0c130f6f898cc6187e3b8964639f6c960bc9c08589dcac06506526","Cargo.toml":"6246515094dda94c71890606c39275b555aed886b5f4c789eb362ce7b1eea40f","LICENSE-APACHE":"d8621ec2eee5b9ca3c65f8492505f3590de8574fac0fdf5132a77232dba47abc","LICENSE-MIT":"30fefc3a7d6a0041541858293bcbea2dde4caa4c0a5802f996a7f7e8c0085652","README.md":"48f7ca4326cfcd3440931e5c82fc21f7b8a6f40041bc94be817c291ad71b6c5b","benches/basic.rs":"61ecb5f7c092b82382cc20e73ca84677dd4973cc358ea6bff15f92fda227b481","examples/async.rs":"7a0bb8848d94bd1fa9a857ffba0b3fbea6d57d7058ed65d2a7cbcf8518ec8652","examples/perf.rs":"52b67c619932a283ad9109c5fe5b47d32f7d3e7533356170047b686dfac330c9","examples/select.rs":"7659b015889545a59b9bce046fc353fea7bcaa9d54cb59f6bd5c002e15872909","examples/simple.rs":"f96d308b808b5fd66ca03dac9f09c13e5f13141992698551503415a411f6596a","src/async.rs":"851b0db2f8115eb222a9eb3c39d3dcdd8699c5b8e757580f26a03ca71c88d0e4","src/lib.rs":"36f84973b6bb45e54161dfb8eb574b30bace69d4b382e7fe8669d5636473d9ea","src/select.rs":"940cbdfbb26b9a2811bf42df3b26f1a619bd71896b8a6b6f2cdbb350c4fab270","src/signal.rs":"20a1732fdbfe888b9a25438bf16a185393f18fb1ad795926fae969c6817fe43b","tests/after.rs":"53e17263eab8eb733f575e4d1d43e054c6d22556d36e105f3f87c4cfb891880c","tests/array.rs":"2b071429d678e07ca52b79b4792120816a1ec7e64afd29c5781ddddbbbd7888b","tests/async.rs":"45bce43e990694578cf03c27dcf112df8d9ec1806e7c1be866885d76bb5abf85","tests/basic.rs":"0606408fe5ff1512839d43cc5c5f6a98c1e09fe919b5ad843643b5019926100b","tests/check_same_channel.rs":"e9e313d1ada50ac0ab0b9bcf19b901efd8cc226902edac62a8d573cea54e06ca","tests/golang.rs":"9e821cefd322a2353b288c7368902028daca643648da2e223ec1174c0e93e4ef","tests/iter.rs":"82d4f7acd20c9b10d2623211e71f5b6c37e4dafda2e13c871008c03995d76ced","tests/list.rs":"5885ee800d5c93b410d3bfa12d834fd817fd3362bca15a08b0aa7f84de58432e","tests/method_sharing.rs":"4d6c867e689254840ecbb1ae8a70ab3226d45bf92282e3bd2681c83726983ffa","tests/mpsc.rs":"965e18abbfcdebec09380f8ec9bb62e5556ad2aa0176ed088ce091994c1d2500","tests/never.rs":"cb838011c6f39c150c67e6836eb880300d53c22a2ea0312cdec999efb779ca29","tests/ready.rs":"5e1234ce49e8cbf89ec4f28bd2f4fe10641891bf6a7915d2fef6f9ab0c343997","tests/same_channel.rs":"71524e90dc364cc2c8085a9517757abe55f59a25b95600029abb283bc8677ad9","tests/select.rs":"67f8a647a7976f0d77673f4cc8d03b74690f3e8578c47e1bc64caeab68dd7df7","tests/select_macro.rs":"32793ac9775879e72ae3ce3975aa87f7407c6e7023d3d85f50f06a3ac5e308a3","tests/stream.rs":"c6d9500813d7216fd514f35dadb1b7b58282def553f40d76b37032221bb05cd6","tests/thread_locals.rs":"ad92e07a4ef5c3dd8b6ff8620161ab93963b3de241a680db551f2be60c8e3853","tests/tick.rs":"35fabd118073decf0cd830e9245c77a1a2e19227f7b4f73d239589728a591601","tests/zero.rs":"23a15a51681596716d5882242cd2c8cd0925c6ea2d0ef289f80775f3f2d6d10c"},"package":"55ac459de2512911e4b674ce33cf20befaba382d05b62b008afc1c8b57cbf181"}
\ No newline at end of file
diff --git a/vendor/flume/CHANGELOG.md b/vendor/flume/CHANGELOG.md
new file mode 100644
index 0000000..14a604f
--- /dev/null
+++ b/vendor/flume/CHANGELOG.md
@@ -0,0 +1,134 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+# Unreleased
+
+### Added
+
+### Removed
+
+### Changed
+
+### Fixed
+
+# [0.11.0] - 2023-08-16
+
+### Added
+
+- `WeakSender`, a sender that doesn't keep the channel open
+- `Sender/Receiver::sender_count/receiver_count`, a way to query the number of senders and receivers attached to a channel
+- `Sender/Receiver::same_channel`, a way to determine whether senders and receivers are attached to the same channel
+
+### Changed
+
+- Relaxed some API features
+- Make all remaining spinlocks opt-in
+
+### Fixed
+
+- Fixed a rare race condition in the async implementation
+
+# [0.10.14] - 2022-07-21
+
+### Fixed
+
+- Fixed unbounded memory usage in `RecvFut::poll_inner`
+
+# [0.10.13] - 2022-06-10
+
+### Added
+
+- `SendSink::sender`, to get the sender of a `SendSink`
+
+# [0.10.12] - 2022-03-10
+
+### Changed
+
+- Updated `nanorand` to 0.7
+
+# [0.10.11] - 2022-02-14
+
+### Fixed
+
+- Out-of-order bug when using channels asynchronously
+
+# [0.10.10] - 2022-01-11
+
+### Added
+
+- `From<SendError>` and `From<RecvError>` impls for other error types
+- Marked futures as `#[must_use]`
+
+### Changes
+
+- Switched to scheduler-driven locking by default, with a `spin` feature to reenable the old behaviour
+- Minor doc improvements
+
+# [0.10.9] - 2021-08-25
+
+### Changed
+
+- Switched from `spinning_top` to `spin`
+
+# [0.10.8] - 2021-08-06
+
+### Changed
+
+- Updated `nanorand` to `0.6`
+
+# [0.10.7] - 2021-06-10
+
+### Fixed
+
+- Removed accidental nightly-only syntax
+
+# [0.10.6] - 2021-06-10
+
+### Added
+
+- `fn into_inner(self) -> T` for send errors, allowing for easy access to the unsent message
+
+# [0.10.5] - 2021-04-26
+
+### Added
+
+- `is_disconnected`, `is_empty`, `is_full`, `len`, and `capacity` on future types
+
+# [0.10.4] - 2021-04-12
+
+### Fixed
+
+- Shutdown-related race condition with async recv that caused spurious errors
+
+# [0.10.3] - 2021-04-09
+
+### Fixed
+
+- Compilation error when enabling `select` without `eventual_fairness`
+
+# [0.10.2] - 2021-02-07
+
+### Fixed
+
+- Incorrect pointer comparison in `Selector` causing missing receives
+
+# [0.10.1] - 2020-12-30
+
+### Removed
+
+- Removed `T: Unpin` requirement from async traits using `pin_project`
+
+# [0.10.0] - 2020-12-09
+
+### Changed
+
+- Renamed `SendFuture` to `SendFut` to be consistent with `RecvFut`
+- Improved async-related documentation
+
+### Fixed
+
+- Updated `nanorand` to address security advisory
diff --git a/vendor/flume/Cargo.lock b/vendor/flume/Cargo.lock
new file mode 100644
index 0000000..43921dd
--- /dev/null
+++ b/vendor/flume/Cargo.lock
@@ -0,0 +1,1312 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4fa78e18c64fce05e902adecd7a5eed15a5e0a3439f7b0e169f0252214865e3"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aho-corasick"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "async-attributes"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3203e79f4dd9bdda415ed03cf14dae5a2bf775c683a00f94e9cd1faf0f596e5"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "async-channel"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fa3dc5f2a8564f07759c008b9109dc0d39de92a88d5588b8a5036d286383afb"
+dependencies = [
+ "async-lock",
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-global-executor"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "blocking",
+ "futures-lite",
+ "once_cell",
+]
+
+[[package]]
+name = "async-io"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af"
+dependencies = [
+ "async-lock",
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-lite",
+ "log",
+ "parking",
+ "polling",
+ "rustix",
+ "slab",
+ "socket2",
+ "waker-fn",
+]
+
+[[package]]
+name = "async-lock"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b"
+dependencies = [
+ "event-listener",
+]
+
+[[package]]
+name = "async-process"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a9d28b1d97e08915212e2e45310d47854eafa69600756fc735fb788f75199c9"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "autocfg",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix",
+ "signal-hook",
+ "windows-sys",
+]
+
+[[package]]
+name = "async-std"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"
+dependencies = [
+ "async-attributes",
+ "async-channel",
+ "async-global-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "crossbeam-utils",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-lite",
+ "gloo-timers",
+ "kv-log-macro",
+ "log",
+ "memchr",
+ "once_cell",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "async-task"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc7ab41815b3c653ccd2978ec3255c81349336702dfdf62ee6f7069b12a3aae"
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1181e1e0d1fce796a03db1ae795d67167da795f9cf4a39c37589e85ef57f26d3"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "backtrace"
+version = "0.3.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4319208da049c43661739c5fade2ba182f09d1dc2299b32298d3a31692b17e12"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "blocking"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77231a1c8f801696fc0123ec6150ce92cffb8e164a02afb9c8ddee0e9b65ad65"
+dependencies = [
+ "async-channel",
+ "async-lock",
+ "async-task",
+ "atomic-waker",
+ "fastrand",
+ "futures-lite",
+ "log",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "305fe645edc1442a0fa8b6726ba61d422798d37a52e12eaecf4b022ebbb88f01"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clap"
+version = "2.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
+dependencies = [
+ "bitflags",
+ "textwrap",
+ "unicode-width",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62ec6771ecfa0762d24683ee5a32ad78487a3d3afdc0fb8cae19d2c5deb50b7c"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "criterion"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f"
+dependencies = [
+ "atty",
+ "cast",
+ "clap",
+ "criterion-plot",
+ "csv",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_cbor",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "626ae34994d3d8d668f4269922248239db4ae42d538b14c398b74a52208e8086"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "errno"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b30f669a7961ef1631673d2766cc92f52d64f7ef354d4fe0ddfd30ed52f0f4f"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "fastrand"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.0"
+dependencies = [
+ "async-std",
+ "criterion",
+ "crossbeam-channel",
+ "crossbeam-utils",
+ "futures",
+ "futures-core",
+ "futures-sink",
+ "nanorand",
+ "rand",
+ "spin",
+ "tokio",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+
+[[package]]
+name = "futures-lite"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+
+[[package]]
+name = "futures-task"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+
+[[package]]
+name = "futures-util"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "gimli"
+version = "0.27.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c80984affa11d98d1b88b66ac8853f143217b399d3c74116778ff8fdb4ed2e"
+
+[[package]]
+name = "gloo-timers"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "io-lifetimes"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
+dependencies = [
+ "hermit-abi 0.3.2",
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "js-sys"
+version = "0.3.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kv-log-macro"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.147"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+
+[[package]]
+name = "lock_api"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+dependencies = [
+ "value-bag",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "memoffset"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "nanorand"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.2",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bda667d9f2b5051b8833f59f3bf748b28ef54f850f4fcb389a252aa383866d1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "parking"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14f2252c834a40ed9bb5422029649578e63aa341ac401f74e719dd1afda8394e"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12cc1b0bf1727a77a54b6654e7b5f1af8604923edc8b81885f8ec92f9e3f0a05"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "plotters"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "polling"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b2d323e8ca7996b3e23126511a523f7e62924d93ecd5ae73b333815b0eb3dce"
+dependencies = [
+ "autocfg",
+ "bitflags",
+ "cfg-if",
+ "concurrent-queue",
+ "libc",
+ "log",
+ "pin-project-lite",
+ "windows-sys",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rayon"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "num_cpus",
+]
+
+[[package]]
+name = "regex"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
+name = "rustix"
+version = "0.37.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32ac8da02677876d532745a130fc9d8e6edfa81a269b107c5b00829b91d8eb3c"
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aafe972d60b0b9bee71a91b92fee2d4fb3c9d7e8f6b179aa99f27203d99a4816"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "socket2"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tokio"
+version = "1.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40de3a2ba249dcb097e01be5e67a5ff53cf250397715a071a81543e8a832a920"
+dependencies = [
+ "backtrace",
+ "pin-project-lite",
+ "tokio-macros",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
+[[package]]
+name = "value-bag"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d92ccd67fb88503048c01b59152a04effd0782d035a83a6d256ce6085f08f4a3"
+
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
+[[package]]
+name = "walkdir"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.87"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+
+[[package]]
+name = "web-sys"
+version = "0.3.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[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-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[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 = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1eeca1c172a285ee6c2c84c341ccea837e7c01b12fbb2d0fe3c9e550ce49ec8"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b10d0c968ba7f6166195e13d593af609ec2e3d24f916f081690695cf5eaffb2f"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "571d8d4e62f26d4932099a9efe89660e8bd5087775a2ab5cdd8b747b811f1058"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2229ad223e178db5fbbc8bd8d3835e51e566b8474bfca58d2e6150c48bb723cd"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "600956e2d840c194eedfc5d18f8242bc2e17c7775b6684488af3a9fff6fe3287"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea99ff3f8b49fb7a8e0d305e5aec485bd068c2ba691b6e277d29eaeac945868a"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1a05a1ece9a7a0d5a7ccf30ba2c33e3a61a30e042ffd247567d1de1d94120d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d419259aba16b663966e29e6d7c6ecfa0bb8425818bb96f6f1f3c3eb71a6e7b9"
diff --git a/vendor/flume/Cargo.toml b/vendor/flume/Cargo.toml
new file mode 100644
index 0000000..4b4eca4
--- /dev/null
+++ b/vendor/flume/Cargo.toml
@@ -0,0 +1,110 @@
+# 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 = "flume"
+version = "0.11.0"
+authors = ["Joshua Barretto <joshua.s.barretto@gmail.com>"]
+exclude = [
+    "/.github",
+    "/misc",
+]
+description = "A blazingly fast multi-producer channel"
+documentation = "https://docs.rs/flume"
+readme = "README.md"
+keywords = [
+    "mpsc",
+    "fifo",
+    "channel",
+    "thread",
+    "mpmc",
+]
+categories = [
+    "concurrency",
+    "data-structures",
+]
+license = "Apache-2.0/MIT"
+repository = "https://github.com/zesterer/flume"
+
+[[bench]]
+name = "basic"
+harness = false
+
+[dependencies.futures-core]
+version = "0.3"
+optional = true
+default_features = false
+
+[dependencies.futures-sink]
+version = "0.3"
+optional = true
+default_features = false
+
+[dependencies.nanorand]
+version = "0.7"
+features = ["getrandom"]
+optional = true
+
+[dependencies.spin1]
+version = "0.9.8"
+features = ["mutex"]
+package = "spin"
+
+[dev-dependencies.async-std]
+version = "1.9.0"
+features = [
+    "attributes",
+    "unstable",
+]
+
+[dev-dependencies.criterion]
+version = "0.3.4"
+
+[dev-dependencies.crossbeam-channel]
+version = "0.5.5"
+
+[dev-dependencies.crossbeam-utils]
+version = "0.8.10"
+
+[dev-dependencies.futures]
+version = "^0.3"
+features = ["std"]
+
+[dev-dependencies.rand]
+version = "0.8.3"
+
+[dev-dependencies.tokio]
+version = "^1.16.1"
+features = [
+    "rt",
+    "macros",
+]
+
+[dev-dependencies.waker-fn]
+version = "1.1.0"
+
+[features]
+async = [
+    "futures-sink",
+    "futures-core",
+]
+default = [
+    "async",
+    "select",
+    "eventual-fairness",
+]
+eventual-fairness = [
+    "select",
+    "nanorand",
+]
+select = []
+spin = []
diff --git a/vendor/flume/LICENSE-APACHE b/vendor/flume/LICENSE-APACHE
new file mode 100644
index 0000000..f474855
--- /dev/null
+++ b/vendor/flume/LICENSE-APACHE
@@ -0,0 +1,201 @@
+   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.
\ No newline at end of file
diff --git a/vendor/flume/LICENSE-MIT b/vendor/flume/LICENSE-MIT
new file mode 100644
index 0000000..468cd79
--- /dev/null
+++ b/vendor/flume/LICENSE-MIT
@@ -0,0 +1,23 @@
+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.
\ No newline at end of file
diff --git a/vendor/flume/README.md b/vendor/flume/README.md
new file mode 100644
index 0000000..d61155d
--- /dev/null
+++ b/vendor/flume/README.md
@@ -0,0 +1,86 @@
+# Flume
+
+A blazingly fast multi-producer, multi-consumer channel.
+
+[![Cargo](https://img.shields.io/crates/v/flume.svg)](
+https://crates.io/crates/flume)
+[![Documentation](https://docs.rs/flume/badge.svg)](
+https://docs.rs/flume)
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](
+https://github.com/zesterer/flume)
+![actions-badge](https://github.com/zesterer/flume/workflows/Rust/badge.svg?branch=master)
+
+```rust
+use std::thread;
+
+fn main() {
+    println!("Hello, world!");
+
+    let (tx, rx) = flume::unbounded();
+
+    thread::spawn(move || {
+        (0..10).for_each(|i| {
+            tx.send(i).unwrap();
+        })
+    });
+
+    let received: u32 = rx.iter().sum();
+
+    assert_eq!((0..10).sum::<u32>(), received);
+}
+```
+
+## Why Flume?
+
+- **Featureful**: Unbounded, bounded and rendezvous queues
+- **Fast**: Always faster than `std::sync::mpsc` and sometimes `crossbeam-channel`
+- **Safe**: No `unsafe` code anywhere in the codebase!
+- **Flexible**: `Sender` and `Receiver` both implement `Send + Sync + Clone`
+- **Familiar**: Drop-in replacement for `std::sync::mpsc`
+- **Capable**: Additional features like MPMC support and send timeouts/deadlines
+- **Simple**: Few dependencies, minimal codebase, fast to compile
+- **Asynchronous**: `async` support, including mix 'n match with sync code
+- **Ergonomic**: Powerful `select`-like interface
+
+## Usage
+
+To use Flume, place the following line under the `[dependencies]` section in your `Cargo.toml`:
+
+```toml
+flume = "x.y"
+```
+
+## Cargo Features
+
+Flume comes with several optional features:
+
+- `spin`: use spinlocks instead of OS-level synchronisation primitives internally for some kind of data access (may be more performant on a small number of platforms for specific workloads)
+
+- `select`: Adds support for the [`Selector`](https://docs.rs/flume/latest/flume/select/struct.Selector.html) API, allowing a thread to wait on several channels/operations at once
+
+- `async`: Adds support for the [async API](https://docs.rs/flume/latest/flume/async/index.html), including on otherwise synchronous channels
+
+- `eventual-fairness`: Use randomness in the implementation of `Selector` to avoid biasing/saturating certain events over others
+
+You can enable these features by changing the dependency in your `Cargo.toml` like so:
+
+```toml
+flume = { version = "x.y", default-features = false, features = ["async", "select"] }
+```
+
+## [Benchmarks](https://what-if.xkcd.com/147/)
+
+Although Flume has its own extensive benchmarks, don't take it from here that Flume is quick.
+The following graph is from the `crossbeam-channel` benchmark suite.
+
+Tests were performed on an AMD Ryzen 7 3700x with 8/16 cores running Linux kernel 5.11.2 with the bfq scheduler.
+
+# <img src="misc/benchmarks.png" alt="Flume benchmarks (crossbeam benchmark suite)" width="100%"/>
+
+## License
+
+Flume is licensed under either of:
+
+- Apache License 2.0, (http://www.apache.org/licenses/LICENSE-2.0)
+
+- MIT license (http://opensource.org/licenses/MIT)
diff --git a/vendor/flume/benches/basic.rs b/vendor/flume/benches/basic.rs
new file mode 100644
index 0000000..bbc4fc2
--- /dev/null
+++ b/vendor/flume/benches/basic.rs
@@ -0,0 +1,474 @@
+#[macro_use]
+extern crate criterion;
+
+use std::{
+    sync::mpsc,
+    thread,
+    fmt::Debug,
+};
+use criterion::{Criterion, Bencher, black_box};
+use std::time::Instant;
+
+trait Sender: Clone + Send + Sized + 'static {
+    type Item: Debug + Default;
+    type BoundedSender: Sender<Item=Self::Item>;
+    type Receiver: Receiver<Item=Self::Item>;
+
+    fn unbounded() -> (Self, Self::Receiver);
+    fn bounded(n: usize) -> (Self::BoundedSender, Self::Receiver);
+    fn send(&self, msg: Self::Item);
+}
+
+trait Receiver: Send + Sized + 'static {
+    type Item: Default;
+    fn recv(&self) -> Self::Item;
+    fn iter(&self) -> Box<dyn Iterator<Item=Self::Item> + '_>;
+}
+
+impl<T: Send + Debug + Default + 'static> Sender for flume::Sender<T> {
+    type Item = T;
+    type BoundedSender = Self;
+    type Receiver = flume::Receiver<T>;
+
+    fn unbounded() -> (Self, Self::Receiver) {
+        flume::unbounded()
+    }
+
+    fn bounded(n: usize) -> (Self::BoundedSender, Self::Receiver) {
+        flume::bounded(n)
+    }
+
+    fn send(&self, msg: T) {
+        flume::Sender::send(self, msg).unwrap();
+    }
+}
+
+impl<T: Send + Default + 'static> Receiver for flume::Receiver<T> {
+    type Item = T;
+
+    fn recv(&self) -> Self::Item {
+        flume::Receiver::recv(self).unwrap()
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item=T> + '_> {
+        Box::new(std::iter::from_fn(move || flume::Receiver::recv(self).ok()))
+    }
+}
+
+impl<T: Send + Debug + Default + 'static> Sender for crossbeam_channel::Sender<T> {
+    type Item = T;
+    type BoundedSender = Self;
+    type Receiver = crossbeam_channel::Receiver<T>;
+
+    fn unbounded() -> (Self, Self::Receiver) {
+        crossbeam_channel::unbounded()
+    }
+
+    fn bounded(n: usize) -> (Self::BoundedSender, Self::Receiver) {
+        crossbeam_channel::bounded(n)
+    }
+
+    fn send(&self, msg: T) {
+        crossbeam_channel::Sender::send(self, msg).unwrap();
+    }
+}
+
+impl<T: Send + Default + 'static> Receiver for crossbeam_channel::Receiver<T> {
+    type Item = T;
+
+    fn recv(&self) -> Self::Item {
+        crossbeam_channel::Receiver::recv(self).unwrap()
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item=T> + '_> {
+        Box::new(crossbeam_channel::Receiver::iter(self))
+    }
+}
+
+impl<T: Send + Debug + Default + 'static> Sender for mpsc::Sender<T> {
+    type Item = T;
+    type BoundedSender = mpsc::SyncSender<T>;
+    type Receiver = mpsc::Receiver<T>;
+
+    fn unbounded() -> (Self, Self::Receiver) {
+        mpsc::channel()
+    }
+
+    fn bounded(n: usize) -> (Self::BoundedSender, Self::Receiver) {
+        mpsc::sync_channel(n)
+    }
+
+    fn send(&self, msg: T) {
+        mpsc::Sender::send(self, msg).unwrap();
+    }
+}
+
+impl<T: Send + Debug + Default + 'static> Sender for mpsc::SyncSender<T> {
+    type Item = T;
+    type BoundedSender = Self;
+    type Receiver = mpsc::Receiver<T>;
+
+    fn unbounded() -> (Self, Self::Receiver) { unimplemented!() }
+    fn bounded(_: usize) -> (Self::BoundedSender, Self::Receiver) { unimplemented!() }
+
+    fn send(&self, msg: T) {
+        mpsc::SyncSender::send(self, msg).unwrap();
+    }
+}
+
+impl<T: Send + Default + 'static> Receiver for mpsc::Receiver<T> {
+    type Item = T;
+
+    fn recv(&self) -> Self::Item {
+        mpsc::Receiver::recv(self).unwrap()
+    }
+
+    fn iter(&self) -> Box<dyn Iterator<Item=T> + '_> {
+        Box::new(mpsc::Receiver::iter(self))
+    }
+}
+
+fn test_create<S: Sender>(b: &mut Bencher) {
+    b.iter(|| S::unbounded());
+}
+
+fn test_oneshot<S: Sender>(b: &mut Bencher) {
+    b.iter(|| {
+        let (tx, rx) = S::unbounded();
+        tx.send(Default::default());
+        black_box(rx.recv());
+    });
+}
+
+fn test_inout<S: Sender>(b: &mut Bencher) {
+    let (tx, rx) = S::unbounded();
+    b.iter(|| {
+        tx.send(Default::default());
+        black_box(rx.recv());
+    });
+}
+
+fn test_hydra<S: Sender>(b: &mut Bencher, thread_num: usize, msg_num: usize) {
+    let (main_tx, main_rx) = S::unbounded();
+
+    let mut txs = Vec::new();
+    for _ in 0..thread_num {
+        let main_tx = main_tx.clone();
+        let (tx, rx) = S::unbounded();
+        txs.push(tx);
+
+        thread::spawn(move || {
+            for msg in rx.iter() {
+                main_tx.send(msg);
+            }
+        });
+    }
+
+    drop(main_tx);
+
+    b.iter(|| {
+        for tx in &txs {
+            for _ in 0..msg_num {
+                tx.send(Default::default());
+            }
+        }
+
+        for _ in 0..thread_num {
+            for _ in 0..msg_num {
+                black_box(main_rx.recv());
+            }
+        }
+    });
+}
+
+fn test_kitsune<S: Sender>(b: &mut Bencher, thread_num: usize, msg_num: usize)
+    where S::Receiver: Clone
+{
+    let (out_tx, out_rx) = S::unbounded();
+    let (in_tx, in_rx) = S::unbounded();
+
+    for _ in 0..thread_num {
+        let in_tx = in_tx.clone();
+        let out_rx = out_rx.clone();
+
+        thread::spawn(move || {
+            for msg in out_rx.iter() {
+                in_tx.send(msg);
+            }
+        });
+    }
+
+    b.iter(|| {
+        for _ in 0..thread_num {
+            for _ in 0..msg_num {
+                out_tx.send(Default::default());
+            }
+        }
+
+        for _ in 0..thread_num {
+            for _ in 0..msg_num {
+                black_box(in_rx.recv());
+            }
+        }
+    });
+}
+
+fn test_robin_u<S: Sender>(b: &mut Bencher, thread_num: usize, msg_num: usize) {
+    let (mut main_tx, main_rx) = S::unbounded();
+
+    for _ in 0..thread_num {
+        let (mut tx, rx) = S::unbounded();
+        std::mem::swap(&mut tx, &mut main_tx);
+
+        thread::spawn(move || {
+            for msg in rx.iter() {
+                tx.send(msg);
+            }
+        });
+    }
+
+    b.iter(|| {
+        for _ in 0..msg_num {
+            main_tx.send(Default::default());
+        }
+
+        for _ in 0..msg_num {
+            black_box(main_rx.recv());
+        }
+    });
+}
+
+fn test_robin_b<S: Sender>(b: &mut Bencher, thread_num: usize, msg_num: usize) {
+    let (mut main_tx, main_rx) = S::bounded(1);
+
+    for _ in 0..thread_num {
+        let (mut tx, rx) = S::bounded(1);
+        std::mem::swap(&mut tx, &mut main_tx);
+
+        thread::spawn(move || {
+            for msg in rx.iter() {
+                tx.send(msg);
+            }
+        });
+    }
+
+    b.iter(|| {
+        let main_tx = main_tx.clone();
+        thread::spawn(move || {
+            for _ in 0..msg_num {
+                main_tx.send(Default::default());
+            }
+        });
+
+        for _ in 0..msg_num {
+            black_box(main_rx.recv());
+        }
+    });
+}
+
+fn test_mpsc_bounded_no_wait<S: Sender>(b: &mut Bencher, thread_num: u64) {
+    b.iter_custom(|iters| {
+        let iters = iters * 1000;
+        let (tx, rx) = S::bounded(iters as usize);
+        let start = Instant::now();
+
+        crossbeam_utils::thread::scope(|scope| {
+            for _ in 0..thread_num {
+                let tx = tx.clone();
+                scope.spawn(move |_| {
+                    for _ in 0..iters / thread_num {
+                        tx.send(Default::default());
+                    }
+                });
+            }
+
+            for _ in 0..iters - ((iters / thread_num) * thread_num) {
+                tx.send(Default::default());
+            }
+
+            for _ in 0..iters {
+                black_box(rx.recv());
+            }
+        })
+            .unwrap();
+
+        start.elapsed()
+    })
+}
+
+fn test_mpsc_bounded<S: Sender>(b: &mut Bencher, bound: usize, thread_num: usize) {
+    b.iter_custom(|iters| {
+        let (tx, rx) = S::bounded(bound);
+        let start = Instant::now();
+
+        crossbeam_utils::thread::scope(|scope| {
+            let msgs = iters as usize * bound.max(1);
+
+            for _ in 0..thread_num {
+                let tx = tx.clone();
+                scope.spawn(move |_| {
+                    for _ in 0..msgs / thread_num as usize {
+                        tx.send(Default::default());
+                    }
+                });
+            }
+
+            scope.spawn(move |_| {
+                // Remainder
+                for _ in 0..msgs - (msgs / thread_num as usize * thread_num)  {
+                    tx.send(Default::default());
+                }
+            });
+
+            for _ in 0..msgs {
+                black_box(rx.recv());
+            }
+        })
+            .unwrap();
+
+        start.elapsed()
+    })
+}
+
+fn create(b: &mut Criterion) {
+    b.bench_function("create-flume", |b| test_create::<flume::Sender<u32>>(b));
+    b.bench_function("create-crossbeam", |b| test_create::<crossbeam_channel::Sender<u32>>(b));
+    b.bench_function("create-std", |b| test_create::<mpsc::Sender<u32>>(b));
+}
+
+fn oneshot(b: &mut Criterion) {
+    b.bench_function("oneshot-flume", |b| test_oneshot::<flume::Sender<u32>>(b));
+    b.bench_function("oneshot-crossbeam", |b| test_oneshot::<crossbeam_channel::Sender<u32>>(b));
+    b.bench_function("oneshot-std", |b| test_oneshot::<mpsc::Sender<u32>>(b));
+}
+
+fn inout(b: &mut Criterion) {
+    b.bench_function("inout-flume", |b| test_inout::<flume::Sender<u32>>(b));
+    b.bench_function("inout-crossbeam", |b| test_inout::<crossbeam_channel::Sender<u32>>(b));
+    b.bench_function("inout-std", |b| test_inout::<mpsc::Sender<u32>>(b));
+}
+
+fn hydra_32t_1m(b: &mut Criterion) {
+    b.bench_function("hydra-32t-1m-flume", |b| test_hydra::<flume::Sender<u32>>(b, 32, 1));
+    b.bench_function("hydra-32t-1m-crossbeam", |b| test_hydra::<crossbeam_channel::Sender<u32>>(b, 32, 1));
+    b.bench_function("hydra-32t-1m-std", |b| test_hydra::<mpsc::Sender<u32>>(b, 32, 1));
+}
+
+fn hydra_32t_1000m(b: &mut Criterion) {
+    b.bench_function("hydra-32t-1000m-flume", |b| test_hydra::<flume::Sender<u32>>(b, 32, 1000));
+    b.bench_function("hydra-32t-1000m-crossbeam", |b| test_hydra::<crossbeam_channel::Sender<u32>>(b, 32, 1000));
+    b.bench_function("hydra-32t-1000m-std", |b| test_hydra::<mpsc::Sender<u32>>(b, 32, 1000));
+}
+
+fn hydra_256t_1m(b: &mut Criterion) {
+    b.bench_function("hydra-256t-1m-flume", |b| test_hydra::<flume::Sender<u32>>(b, 256, 1));
+    b.bench_function("hydra-256t-1m-crossbeam", |b| test_hydra::<crossbeam_channel::Sender<u32>>(b, 256, 1));
+    b.bench_function("hydra-256t-1m-std", |b| test_hydra::<mpsc::Sender<u32>>(b, 256, 1));
+}
+
+fn hydra_1t_1000m(b: &mut Criterion) {
+    b.bench_function("hydra-1t-1000m-flume", |b| test_hydra::<flume::Sender<u32>>(b, 1, 1000));
+    b.bench_function("hydra-1t-1000m-crossbeam", |b| test_hydra::<crossbeam_channel::Sender<u32>>(b, 1, 1000));
+    b.bench_function("hydra-1t-1000m-std", |b| test_hydra::<mpsc::Sender<u32>>(b, 1, 1000));
+}
+
+fn hydra_4t_10000m(b: &mut Criterion) {
+    b.bench_function("hydra-4t-10000m-flume", |b| test_hydra::<flume::Sender<u32>>(b, 4, 10000));
+    b.bench_function("hydra-4t-10000m-crossbeam", |b| test_hydra::<crossbeam_channel::Sender<u32>>(b, 4, 10000));
+    b.bench_function("hydra-4t-10000m-std", |b| test_hydra::<mpsc::Sender<u32>>(b, 4, 10000));
+}
+
+fn kitsune_32t_1m(b: &mut Criterion) {
+    b.bench_function("kitsune-32t-1m-flume", |b| test_kitsune::<flume::Sender<u32>>(b, 32, 1));
+    b.bench_function("kitsune-32t-1m-crossbeam", |b| test_kitsune::<crossbeam_channel::Sender<u32>>(b, 32, 1));
+    //b.bench_function("kitsune-32t-1m-std", |b| test_kitsune::<mpsc::Sender<u32>>(b, 32, 1));
+}
+
+fn kitsune_32t_1000m(b: &mut Criterion) {
+    b.bench_function("kitsune-32t-1000m-flume", |b| test_kitsune::<flume::Sender<u32>>(b, 32, 1000));
+    b.bench_function("kitsune-32t-1000m-crossbeam", |b| test_kitsune::<crossbeam_channel::Sender<u32>>(b, 32, 1000));
+    //b.bench_function("kitsune-32t-1000m-std", |b| test_kitsune::<mpsc::Sender<u32>>(b, 32, 1000));
+}
+
+fn kitsune_256t_1m(b: &mut Criterion) {
+    b.bench_function("kitsune-256t-1m-flume", |b| test_kitsune::<flume::Sender<u32>>(b, 256, 1));
+    b.bench_function("kitsune-256t-1m-crossbeam", |b| test_kitsune::<crossbeam_channel::Sender<u32>>(b, 256, 1));
+    //b.bench_function("kitsune-256t-1m-std", |b| test_kitsune::<mpsc::Sender<u32>>(b, 256, 1));
+}
+
+fn kitsune_1t_1000m(b: &mut Criterion) {
+    b.bench_function("kitsune-1t-1000m-flume", |b| test_kitsune::<flume::Sender<u32>>(b, 1, 1000));
+    b.bench_function("kitsune-1t-1000m-crossbeam", |b| test_kitsune::<crossbeam_channel::Sender<u32>>(b, 1, 1000));
+    //b.bench_function("kitsune-1t-1000m-std", |b| test_kitsune::<mpsc::Sender<u32>>(b, 1, 1000));
+}
+
+fn kitsune_4t_10000m(b: &mut Criterion) {
+    b.bench_function("kitsune-4t-10000m-flume", |b| test_kitsune::<flume::Sender<u32>>(b, 4, 10000));
+    b.bench_function("kitsune-4t-10000m-crossbeam", |b| test_kitsune::<crossbeam_channel::Sender<u32>>(b, 4, 10000));
+    //b.bench_function("kitsune-4t-10000m-std", |b| test_kitsune::<mpsc::Sender<u32>>(b, 4, 10000));
+}
+
+fn robin_u_32t_1m(b: &mut Criterion) {
+    b.bench_function("robin-u-32t-1m-flume", |b| test_robin_u::<flume::Sender<u32>>(b, 32, 1));
+    b.bench_function("robin-u-32t-1m-crossbeam", |b| test_robin_u::<crossbeam_channel::Sender<u32>>(b, 32, 1));
+    b.bench_function("robin-u-32t-1m-std", |b| test_robin_u::<mpsc::Sender<u32>>(b, 32, 1));
+}
+
+fn robin_u_4t_1000m(b: &mut Criterion) {
+    b.bench_function("robin-u-4t-1000m-flume", |b| test_robin_u::<flume::Sender<u32>>(b, 4, 1000));
+    b.bench_function("robin-u-4t-1000m-crossbeam", |b| test_robin_u::<crossbeam_channel::Sender<u32>>(b, 4, 1000));
+    b.bench_function("robin-u-4t-1000m-std", |b| test_robin_u::<mpsc::Sender<u32>>(b, 4, 1000));
+}
+
+fn robin_b_32t_16m(b: &mut Criterion) {
+    b.bench_function("robin-b-32t-16m-flume", |b| test_robin_b::<flume::Sender<u32>>(b, 32, 16));
+    b.bench_function("robin-b-32t-16m-crossbeam", |b| test_robin_b::<crossbeam_channel::Sender<u32>>(b, 32, 16));
+    b.bench_function("robin-b-32t-16m-std", |b| test_robin_b::<mpsc::Sender<u32>>(b, 32, 16));
+}
+
+fn robin_b_4t_1000m(b: &mut Criterion) {
+    b.bench_function("robin-b-4t-1000m-flume", |b| test_robin_b::<flume::Sender<u32>>(b, 4, 1000));
+    b.bench_function("robin-b-4t-1000m-crossbeam", |b| test_robin_b::<crossbeam_channel::Sender<u32>>(b, 4, 1000));
+    b.bench_function("robin-b-4t-1000m-std", |b| test_robin_b::<mpsc::Sender<u32>>(b, 4, 1000));
+}
+
+fn mpsc_bounded_no_wait_4t(b: &mut Criterion) {
+    b.bench_function("mpsc-bounded-no-wait-4t-flume", |b| test_mpsc_bounded_no_wait::<flume::Sender<u32>>(b, 4));
+    b.bench_function("mpsc-bounded-no-wait-4t-crossbeam", |b| test_mpsc_bounded_no_wait::<crossbeam_channel::Sender<u32>>(b, 4));
+    b.bench_function("mpsc-bounded-no-wait-4t-std", |b| test_mpsc_bounded_no_wait::<mpsc::Sender<u32>>(b, 4));
+}
+
+fn mpsc_bounded_4t(b: &mut Criterion) {
+    for bound in &[0, 1, 10, 50, 10_000] {
+        let text = format!("mpsc-bounded-small-4t-{}m-", bound);
+        let bound = *bound;
+
+        b.bench_function(&format!("{}{}", text, "flume"), |b| test_mpsc_bounded::<flume::Sender<u32>>(b, bound, 4));
+        b.bench_function(&format!("{}{}", text, "crossbeam"), |b| test_mpsc_bounded::<crossbeam_channel::Sender<u32>>(b, bound, 4));
+        b.bench_function(&format!("{}{}", text, "std"), |b| test_mpsc_bounded::<mpsc::Sender<u32>>(b, bound, 4));
+    }
+}
+
+criterion_group!(
+    compare,
+    create,
+    oneshot,
+    inout,
+    hydra_32t_1m,
+    hydra_32t_1000m,
+    hydra_256t_1m,
+    hydra_1t_1000m,
+    hydra_4t_10000m,
+    robin_b_32t_16m,
+    robin_b_4t_1000m,
+    robin_u_32t_1m,
+    robin_u_4t_1000m,
+    mpsc_bounded_no_wait_4t,
+    mpsc_bounded_4t,
+    kitsune_32t_1m,
+    kitsune_32t_1000m,
+    kitsune_256t_1m,
+    kitsune_1t_1000m,
+    kitsune_4t_10000m,
+);
+criterion_main!(compare);
diff --git a/vendor/flume/examples/async.rs b/vendor/flume/examples/async.rs
new file mode 100644
index 0000000..a562700
--- /dev/null
+++ b/vendor/flume/examples/async.rs
@@ -0,0 +1,21 @@
+#[cfg(feature = "async")]
+#[async_std::main]
+async fn main() {
+    let (tx, rx) = flume::bounded(1);
+
+    let t = async_std::task::spawn(async move {
+        while let Ok(msg) = rx.recv_async().await {
+            println!("Received: {}", msg);
+        }
+    });
+
+    tx.send_async("Hello, world!").await.unwrap();
+    tx.send_async("How are you today?").await.unwrap();
+
+    drop(tx);
+
+    t.await;
+}
+
+#[cfg(not(feature = "async"))]
+fn main() {}
diff --git a/vendor/flume/examples/perf.rs b/vendor/flume/examples/perf.rs
new file mode 100644
index 0000000..054dcbd
--- /dev/null
+++ b/vendor/flume/examples/perf.rs
@@ -0,0 +1,30 @@
+fn main() {
+    let thread_num = 32;
+    let msg_num = 16;
+
+    let (mut main_tx, main_rx) = flume::bounded::<()>(1);
+
+    for _ in 0..thread_num {
+        let (mut tx, rx) = flume::bounded(1);
+        std::mem::swap(&mut tx, &mut main_tx);
+
+        std::thread::spawn(move || {
+            for msg in rx.iter() {
+                tx.send(msg).unwrap();
+            }
+        });
+    }
+
+    for _ in 0..1000 {
+        let main_tx = main_tx.clone();
+        std::thread::spawn(move || {
+            for _ in 0..msg_num {
+                main_tx.send(Default::default()).unwrap();
+            }
+        });
+
+        for _ in 0..msg_num {
+            main_rx.recv().unwrap();
+        }
+    }
+}
diff --git a/vendor/flume/examples/select.rs b/vendor/flume/examples/select.rs
new file mode 100644
index 0000000..bbe957b
--- /dev/null
+++ b/vendor/flume/examples/select.rs
@@ -0,0 +1,25 @@
+#[cfg(feature = "select")]
+use flume::Selector;
+
+#[cfg(feature = "select")]
+fn main() {
+    // Create two channels
+    let (red_tx, red_rx) = flume::unbounded();
+    let (blue_tx, blue_rx) = flume::unbounded();
+
+    // Spawn two threads that each send a message into their respective channel
+    std::thread::spawn(move || { let _ = red_tx.send("Red"); });
+    std::thread::spawn(move || { let _ = blue_tx.send("Blue"); });
+
+    // Race them to see which one sends their message first
+    let winner = Selector::new()
+        .recv(&red_rx, |msg| msg)
+        .recv(&blue_rx, |msg| msg)
+        .wait()
+        .unwrap();
+
+    println!("{} won!", winner);
+}
+
+#[cfg(not(feature = "select"))]
+fn main() {}
diff --git a/vendor/flume/examples/simple.rs b/vendor/flume/examples/simple.rs
new file mode 100644
index 0000000..39cb1bd
--- /dev/null
+++ b/vendor/flume/examples/simple.rs
@@ -0,0 +1,18 @@
+use std::thread;
+
+fn main() {
+    let (tx, rx) = flume::unbounded();
+
+    let t = thread::spawn(move || {
+        for msg in rx.iter() {
+            println!("Received: {}", msg);
+        }
+    });
+
+    tx.send("Hello, world!").unwrap();
+    tx.send("How are you today?").unwrap();
+
+    drop(tx);
+
+    t.join().unwrap();
+}
diff --git a/vendor/flume/src/async.rs b/vendor/flume/src/async.rs
new file mode 100644
index 0000000..fae44d4
--- /dev/null
+++ b/vendor/flume/src/async.rs
@@ -0,0 +1,543 @@
+//! Futures and other types that allow asynchronous interaction with channels.
+
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll, Waker},
+    any::Any,
+    ops::Deref,
+};
+use crate::*;
+use futures_core::{stream::{Stream, FusedStream}, future::FusedFuture};
+use futures_sink::Sink;
+use spin1::Mutex as Spinlock;
+
+struct AsyncSignal {
+    waker: Spinlock<Waker>,
+    woken: AtomicBool,
+    stream: bool,
+}
+
+impl AsyncSignal {
+    fn new(cx: &Context, stream: bool) -> Self {
+        AsyncSignal {
+            waker: Spinlock::new(cx.waker().clone()),
+            woken: AtomicBool::new(false),
+            stream,
+        }
+    }
+}
+
+impl Signal for AsyncSignal {
+    fn fire(&self) -> bool {
+        self.woken.store(true, Ordering::SeqCst);
+        self.waker.lock().wake_by_ref();
+        self.stream
+    }
+
+    fn as_any(&self) -> &(dyn Any + 'static) { self }
+    fn as_ptr(&self) -> *const () { self as *const _ as *const () }
+}
+
+impl<T> Hook<T, AsyncSignal> {
+    // Update the hook to point to the given Waker.
+    // Returns whether the hook has been previously awakened
+    fn update_waker(&self, cx_waker: &Waker) -> bool {
+        let mut waker = self.1.waker.lock();
+        let woken = self.1.woken.load(Ordering::SeqCst);
+        if !waker.will_wake(cx_waker) {
+            *waker = cx_waker.clone();
+
+            // Avoid the edge case where the waker was woken just before the wakers were
+            // swapped.
+            if woken {
+                cx_waker.wake_by_ref();
+            }
+        }
+        woken
+    }
+}
+
+#[derive(Clone)]
+enum OwnedOrRef<'a, T> {
+    Owned(T),
+    Ref(&'a T),
+}
+
+impl<'a, T> Deref for OwnedOrRef<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        match self {
+            OwnedOrRef::Owned(arc) => &arc,
+            OwnedOrRef::Ref(r) => r,
+        }
+    }
+}
+
+impl<T> Sender<T> {
+    /// Asynchronously send a value into the channel, returning an error if all receivers have been
+    /// dropped. If the channel is bounded and is full, the returned future will yield to the async
+    /// runtime.
+    ///
+    /// In the current implementation, the returned future will not yield to the async runtime if the
+    /// channel is unbounded. This may change in later versions.
+    pub fn send_async(&self, item: T) -> SendFut<T> {
+        SendFut {
+            sender: OwnedOrRef::Ref(&self),
+            hook: Some(SendState::NotYetSent(item)),
+        }
+    }
+
+    /// Convert this sender into a future that asynchronously sends a single message into the channel,
+    /// returning an error if all receivers have been dropped. If the channel is bounded and is full,
+    /// this future will yield to the async runtime.
+    ///
+    /// In the current implementation, the returned future will not yield to the async runtime if the
+    /// channel is unbounded. This may change in later versions.
+    pub fn into_send_async<'a>(self, item: T) -> SendFut<'a, T> {
+        SendFut {
+            sender: OwnedOrRef::Owned(self),
+            hook: Some(SendState::NotYetSent(item)),
+        }
+    }
+
+    /// Create an asynchronous sink that uses this sender to asynchronously send messages into the
+    /// channel. The sender will continue to be usable after the sink has been dropped.
+    ///
+    /// In the current implementation, the returned sink will not yield to the async runtime if the
+    /// channel is unbounded. This may change in later versions.
+    pub fn sink(&self) -> SendSink<'_, T> {
+        SendSink(SendFut {
+            sender: OwnedOrRef::Ref(&self),
+            hook: None,
+        })
+    }
+
+    /// Convert this sender into a sink that allows asynchronously sending messages into the channel.
+    ///
+    /// In the current implementation, the returned sink will not yield to the async runtime if the
+    /// channel is unbounded. This may change in later versions.
+    pub fn into_sink<'a>(self) -> SendSink<'a, T> {
+        SendSink(SendFut {
+            sender: OwnedOrRef::Owned(self),
+            hook: None,
+        })
+    }
+}
+
+enum SendState<T> {
+    NotYetSent(T),
+    QueuedItem(Arc<Hook<T, AsyncSignal>>),
+}
+
+/// A future that sends a value into a channel.
+///
+/// Can be created via [`Sender::send_async`] or [`Sender::into_send_async`].
+#[must_use = "futures/streams/sinks do nothing unless you `.await` or poll them"]
+pub struct SendFut<'a, T> {
+    sender: OwnedOrRef<'a, Sender<T>>,
+    // Only none after dropping
+    hook: Option<SendState<T>>,
+}
+
+impl<T> std::marker::Unpin for SendFut<'_, T> {}
+
+impl<'a, T> SendFut<'a, T> {
+    /// Reset the hook, clearing it and removing it from the waiting sender's queue. This is called
+    /// on drop and just before `start_send` in the `Sink` implementation.
+    fn reset_hook(&mut self) {
+        if let Some(SendState::QueuedItem(hook)) = self.hook.take() {
+            let hook: Arc<Hook<T, dyn Signal>> = hook;
+            wait_lock(&self.sender.shared.chan).sending
+                .as_mut()
+                .unwrap().1
+                .retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+        }
+    }
+
+    /// See [`Sender::is_disconnected`].
+    pub fn is_disconnected(&self) -> bool {
+        self.sender.is_disconnected()
+    }
+
+    /// See [`Sender::is_empty`].
+    pub fn is_empty(&self) -> bool {
+        self.sender.is_empty()
+    }
+
+    /// See [`Sender::is_full`].
+    pub fn is_full(&self) -> bool {
+        self.sender.is_full()
+    }
+
+    /// See [`Sender::len`].
+    pub fn len(&self) -> usize {
+        self.sender.len()
+    }
+
+    /// See [`Sender::capacity`].
+    pub fn capacity(&self) -> Option<usize> {
+        self.sender.capacity()
+    }
+}
+
+impl<'a, T> Drop for SendFut<'a, T> {
+    fn drop(&mut self) {
+        self.reset_hook()
+    }
+}
+
+
+impl<'a, T> Future for SendFut<'a, T> {
+    type Output = Result<(), SendError<T>>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if let Some(SendState::QueuedItem(hook)) = self.hook.as_ref() {
+            if hook.is_empty() {
+                Poll::Ready(Ok(()))
+            } else if self.sender.shared.is_disconnected() {
+                let item = hook.try_take();
+                self.hook = None;
+                match item {
+                    Some(item) => Poll::Ready(Err(SendError(item))),
+                    None => Poll::Ready(Ok(())),
+                }
+            } else {
+                hook.update_waker(cx.waker());
+                Poll::Pending
+            }
+        } else if let Some(SendState::NotYetSent(item)) = self.hook.take() {
+            let this = self.get_mut();
+            let (shared, this_hook) = (&this.sender.shared, &mut this.hook);
+
+            shared.send(
+                // item
+                item,
+                // should_block
+                true,
+                // make_signal
+                |msg| Hook::slot(Some(msg), AsyncSignal::new(cx, false)),
+                // do_block
+                |hook| {
+                    *this_hook = Some(SendState::QueuedItem(hook));
+                    Poll::Pending
+                },
+            )
+                .map(|r| r.map_err(|err| match err {
+                    TrySendTimeoutError::Disconnected(msg) => SendError(msg),
+                    _ => unreachable!(),
+                }))
+        } else { // Nothing to do
+            Poll::Ready(Ok(()))
+        }
+    }
+}
+
+impl<'a, T> FusedFuture for SendFut<'a, T> {
+    fn is_terminated(&self) -> bool {
+        self.sender.shared.is_disconnected()
+    }
+}
+
+/// A sink that allows sending values into a channel.
+///
+/// Can be created via [`Sender::sink`] or [`Sender::into_sink`].
+pub struct SendSink<'a, T>(SendFut<'a, T>);
+
+impl<'a, T> SendSink<'a, T> {
+    /// Returns a clone of a sending half of the channel of this sink.
+    pub fn sender(&self) -> &Sender<T> {
+        &self.0.sender
+    }
+
+    /// See [`Sender::is_disconnected`].
+    pub fn is_disconnected(&self) -> bool {
+        self.0.is_disconnected()
+    }
+
+    /// See [`Sender::is_empty`].
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// See [`Sender::is_full`].
+    pub fn is_full(&self) -> bool {
+        self.0.is_full()
+    }
+
+    /// See [`Sender::len`].
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// See [`Sender::capacity`].
+    pub fn capacity(&self) -> Option<usize> {
+        self.0.capacity()
+    }
+
+    /// Returns whether the SendSinks are belong to the same channel.
+    pub fn same_channel(&self, other: &Self) -> bool {
+        self.sender().same_channel(other.sender())
+    }
+}
+
+impl<'a, T> Sink<T> for SendSink<'a, T> {
+    type Error = SendError<T>;
+
+    fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.0).poll(cx)
+    }
+
+    fn start_send(mut self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
+        self.0.reset_hook();
+        self.0.hook = Some(SendState::NotYetSent(item));
+
+        Ok(())
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.0).poll(cx) // TODO: A different strategy here?
+    }
+
+    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Pin::new(&mut self.0).poll(cx) // TODO: A different strategy here?
+    }
+}
+
+impl<'a, T> Clone for SendSink<'a, T> {
+    fn clone(&self) -> SendSink<'a, T> {
+        SendSink(SendFut {
+            sender: self.0.sender.clone(),
+            hook: None,
+        })
+    }
+}
+
+impl<T> Receiver<T> {
+    /// Asynchronously receive a value from the channel, returning an error if all senders have been
+    /// dropped. If the channel is empty, the returned future will yield to the async runtime.
+    pub fn recv_async(&self) -> RecvFut<'_, T> {
+        RecvFut::new(OwnedOrRef::Ref(self))
+    }
+
+    /// Convert this receiver into a future that asynchronously receives a single message from the
+    /// channel, returning an error if all senders have been dropped. If the channel is empty, this
+    /// future will yield to the async runtime.
+    pub fn into_recv_async<'a>(self) -> RecvFut<'a, T> {
+        RecvFut::new(OwnedOrRef::Owned(self))
+    }
+
+    /// Create an asynchronous stream that uses this receiver to asynchronously receive messages
+    /// from the channel. The receiver will continue to be usable after the stream has been dropped.
+    pub fn stream(&self) -> RecvStream<'_, T> {
+        RecvStream(RecvFut::new(OwnedOrRef::Ref(self)))
+    }
+
+    /// Convert this receiver into a stream that allows asynchronously receiving messages from the channel.
+    pub fn into_stream<'a>(self) -> RecvStream<'a, T> {
+        RecvStream(RecvFut::new(OwnedOrRef::Owned(self)))
+    }
+}
+
+/// A future which allows asynchronously receiving a message.
+///
+/// Can be created via [`Receiver::recv_async`] or [`Receiver::into_recv_async`].
+#[must_use = "futures/streams/sinks do nothing unless you `.await` or poll them"]
+pub struct RecvFut<'a, T> {
+    receiver: OwnedOrRef<'a, Receiver<T>>,
+    hook: Option<Arc<Hook<T, AsyncSignal>>>,
+}
+
+impl<'a, T> RecvFut<'a, T> {
+    fn new(receiver: OwnedOrRef<'a, Receiver<T>>) -> Self {
+        Self {
+            receiver,
+            hook: None,
+        }
+    }
+
+    /// Reset the hook, clearing it and removing it from the waiting receivers queue and waking
+    /// another receiver if this receiver has been woken, so as not to cause any missed wakeups.
+    /// This is called on drop and after a new item is received in `Stream::poll_next`.
+    fn reset_hook(&mut self) {
+        if let Some(hook) = self.hook.take() {
+            let hook: Arc<Hook<T, dyn Signal>> = hook;
+            let mut chan = wait_lock(&self.receiver.shared.chan);
+            // We'd like to use `Arc::ptr_eq` here but it doesn't seem to work consistently with wide pointers?
+            chan.waiting.retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+            if hook.signal().as_any().downcast_ref::<AsyncSignal>().unwrap().woken.load(Ordering::SeqCst) {
+                // If this signal has been fired, but we're being dropped (and so not listening to it),
+                // pass the signal on to another receiver
+                chan.try_wake_receiver_if_pending();
+            }
+        }
+    }
+
+    fn poll_inner(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        stream: bool,
+    ) -> Poll<Result<T, RecvError>> {
+        if self.hook.is_some() {
+            match self.receiver.shared.recv_sync(None) {
+                Ok(msg) => return Poll::Ready(Ok(msg)),
+                Err(TryRecvTimeoutError::Disconnected) => {
+                    return Poll::Ready(Err(RecvError::Disconnected))
+                }
+                _ => (),
+            }
+
+            let hook = self.hook.as_ref().map(Arc::clone).unwrap();
+            if hook.update_waker(cx.waker()) {
+                // If the previous hook was awakened, we need to insert it back to the
+                // queue, otherwise, it remains valid.
+                wait_lock(&self.receiver.shared.chan)
+                    .waiting
+                    .push_back(hook);
+            }
+            // To avoid a missed wakeup, re-check disconnect status here because the channel might have
+            // gotten shut down before we had a chance to push our hook
+            if self.receiver.shared.is_disconnected() {
+                // And now, to avoid a race condition between the first recv attempt and the disconnect check we
+                // just performed, attempt to recv again just in case we missed something.
+                Poll::Ready(
+                    self.receiver
+                        .shared
+                        .recv_sync(None)
+                        .map(Ok)
+                        .unwrap_or(Err(RecvError::Disconnected)),
+                )
+            } else {
+                Poll::Pending
+            }
+        } else {
+            let mut_self = self.get_mut();
+            let (shared, this_hook) = (&mut_self.receiver.shared, &mut mut_self.hook);
+
+            shared.recv(
+                // should_block
+                true,
+                // make_signal
+                || Hook::trigger(AsyncSignal::new(cx, stream)),
+                // do_block
+                |hook| {
+                    *this_hook = Some(hook);
+                    Poll::Pending
+                },
+            )
+                .map(|r| r.map_err(|err| match err {
+                    TryRecvTimeoutError::Disconnected => RecvError::Disconnected,
+                    _ => unreachable!(),
+                }))
+        }
+    }
+
+    /// See [`Receiver::is_disconnected`].
+    pub fn is_disconnected(&self) -> bool {
+        self.receiver.is_disconnected()
+    }
+
+    /// See [`Receiver::is_empty`].
+    pub fn is_empty(&self) -> bool {
+        self.receiver.is_empty()
+    }
+
+    /// See [`Receiver::is_full`].
+    pub fn is_full(&self) -> bool {
+        self.receiver.is_full()
+    }
+
+    /// See [`Receiver::len`].
+    pub fn len(&self) -> usize {
+        self.receiver.len()
+    }
+
+    /// See [`Receiver::capacity`].
+    pub fn capacity(&self) -> Option<usize> {
+        self.receiver.capacity()
+    }
+}
+
+impl<'a, T> Drop for RecvFut<'a, T> {
+    fn drop(&mut self) {
+        self.reset_hook();
+    }
+}
+
+impl<'a, T> Future for RecvFut<'a, T> {
+    type Output = Result<T, RecvError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.poll_inner(cx, false) // stream = false
+    }
+}
+
+impl<'a, T> FusedFuture for RecvFut<'a, T> {
+    fn is_terminated(&self) -> bool {
+        self.receiver.shared.is_disconnected() && self.receiver.shared.is_empty()
+    }
+}
+
+/// A stream which allows asynchronously receiving messages.
+///
+/// Can be created via [`Receiver::stream`] or [`Receiver::into_stream`].
+pub struct RecvStream<'a, T>(RecvFut<'a, T>);
+
+impl<'a, T> RecvStream<'a, T> {
+    /// See [`Receiver::is_disconnected`].
+    pub fn is_disconnected(&self) -> bool {
+        self.0.is_disconnected()
+    }
+
+    /// See [`Receiver::is_empty`].
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// See [`Receiver::is_full`].
+    pub fn is_full(&self) -> bool {
+        self.0.is_full()
+    }
+
+    /// See [`Receiver::len`].
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// See [`Receiver::capacity`].
+    pub fn capacity(&self) -> Option<usize> {
+        self.0.capacity()
+    }
+
+    /// Returns whether the SendSinks are belong to the same channel.
+    pub fn same_channel(&self, other: &Self) -> bool {
+        self.0.receiver.same_channel(&*other.0.receiver)
+    }
+}
+
+impl<'a, T> Clone for RecvStream<'a, T> {
+    fn clone(&self) -> RecvStream<'a, T> {
+        RecvStream(RecvFut::new(self.0.receiver.clone()))
+    }
+}
+
+impl<'a, T> Stream for RecvStream<'a, T> {
+    type Item = T;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        match Pin::new(&mut self.0).poll_inner(cx, true) { // stream = true
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(item) => {
+                self.0.reset_hook();
+                Poll::Ready(item.ok())
+            }
+        }
+    }
+}
+
+impl<'a, T> FusedStream for RecvStream<'a, T> {
+    fn is_terminated(&self) -> bool {
+        self.0.is_terminated()
+    }
+}
diff --git a/vendor/flume/src/lib.rs b/vendor/flume/src/lib.rs
new file mode 100644
index 0000000..c9bb3ee
--- /dev/null
+++ b/vendor/flume/src/lib.rs
@@ -0,0 +1,1142 @@
+//! # Flume
+//!
+//! A blazingly fast multi-producer, multi-consumer channel.
+//!
+//! *"Do not communicate by sharing memory; instead, share memory by communicating."*
+//!
+//! ## Why Flume?
+//!
+//! - **Featureful**: Unbounded, bounded and rendezvous queues
+//! - **Fast**: Always faster than `std::sync::mpsc` and sometimes `crossbeam-channel`
+//! - **Safe**: No `unsafe` code anywhere in the codebase!
+//! - **Flexible**: `Sender` and `Receiver` both implement `Send + Sync + Clone`
+//! - **Familiar**: Drop-in replacement for `std::sync::mpsc`
+//! - **Capable**: Additional features like MPMC support and send timeouts/deadlines
+//! - **Simple**: Few dependencies, minimal codebase, fast to compile
+//! - **Asynchronous**: `async` support, including mix 'n match with sync code
+//! - **Ergonomic**: Powerful `select`-like interface
+//!
+//! ## Example
+//!
+//! ```
+//! let (tx, rx) = flume::unbounded();
+//!
+//! tx.send(42).unwrap();
+//! assert_eq!(rx.recv().unwrap(), 42);
+//! ```
+
+#![deny(missing_docs)]
+
+#[cfg(feature = "select")]
+pub mod select;
+#[cfg(feature = "async")]
+pub mod r#async;
+
+mod signal;
+
+// Reexports
+#[cfg(feature = "select")]
+pub use select::Selector;
+
+use std::{
+    collections::VecDeque,
+    sync::{Arc, atomic::{AtomicUsize, AtomicBool, Ordering}, Weak},
+    time::{Duration, Instant},
+    marker::PhantomData,
+    thread,
+    fmt,
+};
+
+#[cfg(feature = "spin")]
+use spin1::{Mutex as Spinlock, MutexGuard as SpinlockGuard};
+use crate::signal::{Signal, SyncSignal};
+
+/// An error that may be emitted when attempting to send a value into a channel on a sender when
+/// all receivers are dropped.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct SendError<T>(pub T);
+
+impl<T> SendError<T> {
+    /// Consume the error, yielding the message that failed to send.
+    pub fn into_inner(self) -> T { self.0 }
+}
+
+impl<T> fmt::Debug for SendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "SendError(..)".fmt(f)
+    }
+}
+
+impl<T> fmt::Display for SendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "sending on a closed channel".fmt(f)
+    }
+}
+
+impl<T> std::error::Error for SendError<T> {}
+
+/// An error that may be emitted when attempting to send a value into a channel on a sender when
+/// the channel is full or all receivers are dropped.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum TrySendError<T> {
+    /// The channel the message is sent on has a finite capacity and was full when the send was attempted.
+    Full(T),
+    /// All channel receivers were dropped and so the message has nobody to receive it.
+    Disconnected(T),
+}
+
+impl<T> TrySendError<T> {
+    /// Consume the error, yielding the message that failed to send.
+    pub fn into_inner(self) -> T {
+        match self {
+            Self::Full(msg) | Self::Disconnected(msg) => msg,
+        }
+    }
+}
+
+impl<T> fmt::Debug for TrySendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            TrySendError::Full(..) => "Full(..)".fmt(f),
+            TrySendError::Disconnected(..) => "Disconnected(..)".fmt(f),
+        }
+    }
+}
+
+impl<T> fmt::Display for TrySendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TrySendError::Full(..) => "sending on a full channel".fmt(f),
+            TrySendError::Disconnected(..) => "sending on a closed channel".fmt(f),
+        }
+    }
+}
+
+impl<T> std::error::Error for TrySendError<T> {}
+
+impl<T> From<SendError<T>> for TrySendError<T> {
+    fn from(err: SendError<T>) -> Self {
+        match err {
+            SendError(item) => Self::Disconnected(item),
+        }
+    }
+}
+
+/// An error that may be emitted when sending a value into a channel on a sender with a timeout when
+/// the send operation times out or all receivers are dropped.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum SendTimeoutError<T> {
+    /// A timeout occurred when attempting to send the message.
+    Timeout(T),
+    /// All channel receivers were dropped and so the message has nobody to receive it.
+    Disconnected(T),
+}
+
+impl<T> SendTimeoutError<T> {
+    /// Consume the error, yielding the message that failed to send.
+    pub fn into_inner(self) -> T {
+        match self {
+            Self::Timeout(msg) | Self::Disconnected(msg) => msg,
+        }
+    }
+}
+
+impl<T> fmt::Debug for SendTimeoutError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "SendTimeoutError(..)".fmt(f)
+    }
+}
+
+impl<T> fmt::Display for SendTimeoutError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SendTimeoutError::Timeout(..) => "timed out sending on a full channel".fmt(f),
+            SendTimeoutError::Disconnected(..) => "sending on a closed channel".fmt(f),
+        }
+    }
+}
+
+impl<T> std::error::Error for SendTimeoutError<T> {}
+
+impl<T> From<SendError<T>> for SendTimeoutError<T> {
+    fn from(err: SendError<T>) -> Self {
+        match err {
+            SendError(item) => Self::Disconnected(item),
+        }
+    }
+}
+
+enum TrySendTimeoutError<T> {
+    Full(T),
+    Disconnected(T),
+    Timeout(T),
+}
+
+/// An error that may be emitted when attempting to wait for a value on a receiver when all senders
+/// are dropped and there are no more messages in the channel.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum RecvError {
+    /// All senders were dropped and no messages are waiting in the channel, so no further messages can be received.
+    Disconnected,
+}
+
+impl fmt::Display for RecvError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RecvError::Disconnected => "receiving on a closed channel".fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for RecvError {}
+
+/// An error that may be emitted when attempting to fetch a value on a receiver when there are no
+/// messages in the channel. If there are no messages in the channel and all senders are dropped,
+/// then `TryRecvError::Disconnected` will be returned.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum TryRecvError {
+    /// The channel was empty when the receive was attempted.
+    Empty,
+    /// All senders were dropped and no messages are waiting in the channel, so no further messages can be received.
+    Disconnected,
+}
+
+impl fmt::Display for TryRecvError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TryRecvError::Empty => "receiving on an empty channel".fmt(f),
+            TryRecvError::Disconnected => "channel is empty and closed".fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for TryRecvError {}
+
+impl From<RecvError> for TryRecvError {
+    fn from(err: RecvError) -> Self {
+        match err {
+            RecvError::Disconnected => Self::Disconnected,
+        }
+    }
+}
+
+/// An error that may be emitted when attempting to wait for a value on a receiver with a timeout
+/// when the receive operation times out or all senders are dropped and there are no values left
+/// in the channel.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum RecvTimeoutError {
+    /// A timeout occurred when attempting to receive a message.
+    Timeout,
+    /// All senders were dropped and no messages are waiting in the channel, so no further messages can be received.
+    Disconnected,
+}
+
+impl fmt::Display for RecvTimeoutError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RecvTimeoutError::Timeout => "timed out waiting on a channel".fmt(f),
+            RecvTimeoutError::Disconnected => "channel is empty and closed".fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for RecvTimeoutError {}
+
+impl From<RecvError> for RecvTimeoutError {
+    fn from(err: RecvError) -> Self {
+        match err {
+            RecvError::Disconnected => Self::Disconnected,
+        }
+    }
+}
+
+enum TryRecvTimeoutError {
+    Empty,
+    Timeout,
+    Disconnected,
+}
+
+// TODO: Investigate some sort of invalidation flag for timeouts
+#[cfg(feature = "spin")]
+struct Hook<T, S: ?Sized>(Option<Spinlock<Option<T>>>, S);
+
+#[cfg(not(feature = "spin"))]
+struct Hook<T, S: ?Sized>(Option<Mutex<Option<T>>>, S);
+
+#[cfg(feature = "spin")]
+impl<T, S: ?Sized + Signal> Hook<T, S> {
+    pub fn slot(msg: Option<T>, signal: S) -> Arc<Self>
+    where
+        S: Sized,
+    {
+        Arc::new(Self(Some(Spinlock::new(msg)), signal))
+    }
+
+    fn lock(&self) -> Option<SpinlockGuard<'_, Option<T>>> {
+        self.0.as_ref().map(|s| s.lock())
+    }
+}
+
+#[cfg(not(feature = "spin"))]
+impl<T, S: ?Sized + Signal> Hook<T, S> {
+    pub fn slot(msg: Option<T>, signal: S) -> Arc<Self>
+    where
+        S: Sized,
+    {
+        Arc::new(Self(Some(Mutex::new(msg)), signal))
+    }
+
+    fn lock(&self) -> Option<MutexGuard<'_, Option<T>>> {
+        self.0.as_ref().map(|s| s.lock().unwrap())
+    }
+}
+
+impl<T, S: ?Sized + Signal> Hook<T, S> {
+    pub fn fire_recv(&self) -> (T, &S) {
+        let msg = self.lock().unwrap().take().unwrap();
+        (msg, self.signal())
+    }
+
+    pub fn fire_send(&self, msg: T) -> (Option<T>, &S) {
+        let ret = match self.lock() {
+            Some(mut lock) => {
+                *lock = Some(msg);
+                None
+            }
+            None => Some(msg),
+        };
+        (ret, self.signal())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.lock().map(|s| s.is_none()).unwrap_or(true)
+    }
+
+    pub fn try_take(&self) -> Option<T> {
+        self.lock().unwrap().take()
+    }
+
+    pub fn trigger(signal: S) -> Arc<Self>
+    where
+        S: Sized,
+    {
+        Arc::new(Self(None, signal))
+    }
+
+    pub fn signal(&self) -> &S {
+        &self.1
+    }
+
+    pub fn fire_nothing(&self) -> bool {
+        self.signal().fire()
+    }
+}
+
+impl<T> Hook<T, SyncSignal> {
+    pub fn wait_recv(&self, abort: &AtomicBool) -> Option<T> {
+        loop {
+            let disconnected = abort.load(Ordering::SeqCst); // Check disconnect *before* msg
+            let msg = self.lock().unwrap().take();
+            if let Some(msg) = msg {
+                break Some(msg);
+            } else if disconnected {
+                break None;
+            } else {
+                self.signal().wait()
+            }
+        }
+    }
+
+    // Err(true) if timeout
+    pub fn wait_deadline_recv(&self, abort: &AtomicBool, deadline: Instant) -> Result<T, bool> {
+        loop {
+            let disconnected = abort.load(Ordering::SeqCst); // Check disconnect *before* msg
+            let msg = self.lock().unwrap().take();
+            if let Some(msg) = msg {
+                break Ok(msg);
+            } else if disconnected {
+                break Err(false);
+            } else if let Some(dur) = deadline.checked_duration_since(Instant::now()) {
+                self.signal().wait_timeout(dur);
+            } else {
+                break Err(true);
+            }
+        }
+    }
+
+    pub fn wait_send(&self, abort: &AtomicBool) {
+        loop {
+            let disconnected = abort.load(Ordering::SeqCst); // Check disconnect *before* msg
+            if disconnected || self.lock().unwrap().is_none() {
+                break;
+            }
+
+            self.signal().wait();
+        }
+    }
+
+    // Err(true) if timeout
+    pub fn wait_deadline_send(&self, abort: &AtomicBool, deadline: Instant) -> Result<(), bool> {
+        loop {
+            let disconnected = abort.load(Ordering::SeqCst); // Check disconnect *before* msg
+            if self.lock().unwrap().is_none() {
+                break Ok(());
+            } else if disconnected {
+                break Err(false);
+            } else if let Some(dur) = deadline.checked_duration_since(Instant::now()) {
+                self.signal().wait_timeout(dur);
+            } else {
+                break Err(true);
+            }
+        }
+    }
+}
+
+#[cfg(feature = "spin")]
+#[inline]
+fn wait_lock<T>(lock: &Spinlock<T>) -> SpinlockGuard<T> {
+    let mut i = 4;
+    loop {
+        for _ in 0..10 {
+            if let Some(guard) = lock.try_lock() {
+                return guard;
+            }
+            thread::yield_now();
+        }
+        // Sleep for at most ~1 ms
+        thread::sleep(Duration::from_nanos(1 << i.min(20)));
+        i += 1;
+    }
+}
+
+#[cfg(not(feature = "spin"))]
+#[inline]
+fn wait_lock<'a, T>(lock: &'a Mutex<T>) -> MutexGuard<'a, T> {
+    lock.lock().unwrap()
+}
+
+#[cfg(not(feature = "spin"))]
+use std::sync::{Mutex, MutexGuard};
+
+#[cfg(feature = "spin")]
+type ChanLock<T> = Spinlock<T>;
+#[cfg(not(feature = "spin"))]
+type ChanLock<T> = Mutex<T>;
+
+
+type SignalVec<T> = VecDeque<Arc<Hook<T, dyn signal::Signal>>>;
+struct Chan<T> {
+    sending: Option<(usize, SignalVec<T>)>,
+    queue: VecDeque<T>,
+    waiting: SignalVec<T>,
+}
+
+impl<T> Chan<T> {
+    fn pull_pending(&mut self, pull_extra: bool) {
+        if let Some((cap, sending)) = &mut self.sending {
+            let effective_cap = *cap + pull_extra as usize;
+
+            while self.queue.len() < effective_cap {
+                if let Some(s) = sending.pop_front() {
+                    let (msg, signal) = s.fire_recv();
+                    signal.fire();
+                    self.queue.push_back(msg);
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    fn try_wake_receiver_if_pending(&mut self) {
+        if !self.queue.is_empty() {
+            while Some(false) == self.waiting.pop_front().map(|s| s.fire_nothing()) {}
+        }
+    }
+}
+
+struct Shared<T> {
+    chan: ChanLock<Chan<T>>,
+    disconnected: AtomicBool,
+    sender_count: AtomicUsize,
+    receiver_count: AtomicUsize,
+}
+
+impl<T> Shared<T> {
+    fn new(cap: Option<usize>) -> Self {
+        Self {
+            chan: ChanLock::new(Chan {
+                sending: cap.map(|cap| (cap, VecDeque::new())),
+                queue: VecDeque::new(),
+                waiting: VecDeque::new(),
+            }),
+            disconnected: AtomicBool::new(false),
+            sender_count: AtomicUsize::new(1),
+            receiver_count: AtomicUsize::new(1),
+        }
+    }
+
+    fn send<S: Signal, R: From<Result<(), TrySendTimeoutError<T>>>>(
+        &self,
+        msg: T,
+        should_block: bool,
+        make_signal: impl FnOnce(T) -> Arc<Hook<T, S>>,
+        do_block: impl FnOnce(Arc<Hook<T, S>>) -> R,
+    ) -> R {
+        let mut chan = wait_lock(&self.chan);
+
+        if self.is_disconnected() {
+            Err(TrySendTimeoutError::Disconnected(msg)).into()
+        } else if !chan.waiting.is_empty() {
+            let mut msg = Some(msg);
+
+            loop {
+                let slot = chan.waiting.pop_front();
+                match slot.as_ref().map(|r| r.fire_send(msg.take().unwrap())) {
+                    // No more waiting receivers and msg in queue, so break out of the loop
+                    None if msg.is_none() => break,
+                    // No more waiting receivers, so add msg to queue and break out of the loop
+                    None => {
+                        chan.queue.push_back(msg.unwrap());
+                        break;
+                    }
+                    Some((Some(m), signal)) => {
+                        if signal.fire() {
+                            // Was async and a stream, so didn't acquire the message. Wake another
+                            // receiver, and do not yet push the message.
+                            msg.replace(m);
+                            continue;
+                        } else {
+                            // Was async and not a stream, so it did acquire the message. Push the
+                            // message to the queue for it to be received.
+                            chan.queue.push_back(m);
+                            drop(chan);
+                            break;
+                        }
+                    },
+                    Some((None, signal)) => {
+                        drop(chan);
+                        signal.fire();
+                        break; // Was sync, so it has acquired the message
+                    },
+                }
+            }
+
+            Ok(()).into()
+        } else if chan.sending.as_ref().map(|(cap, _)| chan.queue.len() < *cap).unwrap_or(true) {
+            chan.queue.push_back(msg);
+            Ok(()).into()
+        } else if should_block { // Only bounded from here on
+            let hook = make_signal(msg);
+            chan.sending.as_mut().unwrap().1.push_back(hook.clone());
+            drop(chan);
+
+            do_block(hook)
+        } else {
+            Err(TrySendTimeoutError::Full(msg)).into()
+        }
+    }
+
+    fn send_sync(
+        &self,
+        msg: T,
+        block: Option<Option<Instant>>,
+    ) -> Result<(), TrySendTimeoutError<T>> {
+        self.send(
+            // msg
+            msg,
+            // should_block
+            block.is_some(),
+            // make_signal
+            |msg| Hook::slot(Some(msg), SyncSignal::default()),
+            // do_block
+            |hook| if let Some(deadline) = block.unwrap() {
+                hook.wait_deadline_send(&self.disconnected, deadline)
+                    .or_else(|timed_out| {
+                        if timed_out { // Remove our signal
+                            let hook: Arc<Hook<T, dyn signal::Signal>> = hook.clone();
+                            wait_lock(&self.chan).sending
+                                .as_mut()
+                                .unwrap().1
+                                .retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+                        }
+                        hook.try_take().map(|msg| if self.is_disconnected() {
+                            Err(TrySendTimeoutError::Disconnected(msg))
+                        } else {
+                            Err(TrySendTimeoutError::Timeout(msg))
+                        })
+                        .unwrap_or(Ok(()))
+                    })
+            } else {
+                hook.wait_send(&self.disconnected);
+
+                match hook.try_take() {
+                    Some(msg) => Err(TrySendTimeoutError::Disconnected(msg)),
+                    None => Ok(()),
+                }
+            },
+        )
+    }
+
+    fn recv<S: Signal, R: From<Result<T, TryRecvTimeoutError>>>(
+        &self,
+        should_block: bool,
+        make_signal: impl FnOnce() -> Arc<Hook<T, S>>,
+        do_block: impl FnOnce(Arc<Hook<T, S>>) -> R,
+    ) -> R {
+        let mut chan = wait_lock(&self.chan);
+        chan.pull_pending(true);
+
+        if let Some(msg) = chan.queue.pop_front() {
+            drop(chan);
+            Ok(msg).into()
+        } else if self.is_disconnected() {
+            drop(chan);
+            Err(TryRecvTimeoutError::Disconnected).into()
+        } else if should_block {
+            let hook = make_signal();
+            chan.waiting.push_back(hook.clone());
+            drop(chan);
+
+            do_block(hook)
+        } else {
+            drop(chan);
+            Err(TryRecvTimeoutError::Empty).into()
+        }
+    }
+
+    fn recv_sync(&self, block: Option<Option<Instant>>) -> Result<T, TryRecvTimeoutError> {
+        self.recv(
+            // should_block
+            block.is_some(),
+            // make_signal
+            || Hook::slot(None, SyncSignal::default()),
+            // do_block
+            |hook| if let Some(deadline) = block.unwrap() {
+                hook.wait_deadline_recv(&self.disconnected, deadline)
+                    .or_else(|timed_out| {
+                        if timed_out { // Remove our signal
+                            let hook: Arc<Hook<T, dyn Signal>> = hook.clone();
+                            wait_lock(&self.chan).waiting
+                                .retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+                        }
+                        match hook.try_take() {
+                            Some(msg) => Ok(msg),
+                            None => {
+                                let disconnected = self.is_disconnected(); // Check disconnect *before* msg
+                                if let Some(msg) = wait_lock(&self.chan).queue.pop_front() {
+                                    Ok(msg)
+                                } else if disconnected {
+                                    Err(TryRecvTimeoutError::Disconnected)
+                                } else {
+                                    Err(TryRecvTimeoutError::Timeout)
+                                }
+                            },
+                        }
+                    })
+            } else {
+                hook.wait_recv(&self.disconnected)
+                    .or_else(|| wait_lock(&self.chan).queue.pop_front())
+                    .ok_or(TryRecvTimeoutError::Disconnected)
+            },
+        )
+    }
+
+    /// Disconnect anything listening on this channel (this will not prevent receivers receiving
+    /// msgs that have already been sent)
+    fn disconnect_all(&self) {
+        self.disconnected.store(true, Ordering::Relaxed);
+
+        let mut chan = wait_lock(&self.chan);
+        chan.pull_pending(false);
+        if let Some((_, sending)) = chan.sending.as_ref() {
+            sending.iter().for_each(|hook| {
+                hook.signal().fire();
+            })
+        }
+        chan.waiting.iter().for_each(|hook| {
+            hook.signal().fire();
+        });
+    }
+
+    fn is_disconnected(&self) -> bool {
+        self.disconnected.load(Ordering::SeqCst)
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    fn is_full(&self) -> bool {
+        self.capacity().map(|cap| cap == self.len()).unwrap_or(false)
+    }
+
+    fn len(&self) -> usize {
+        let mut chan = wait_lock(&self.chan);
+        chan.pull_pending(false);
+        chan.queue.len()
+    }
+
+    fn capacity(&self) -> Option<usize> {
+        wait_lock(&self.chan).sending.as_ref().map(|(cap, _)| *cap)
+    }
+
+    fn sender_count(&self) -> usize {
+        self.sender_count.load(Ordering::Relaxed)
+    }
+
+    fn receiver_count(&self) -> usize {
+        self.receiver_count.load(Ordering::Relaxed)
+    }
+}
+
+/// A transmitting end of a channel.
+pub struct Sender<T> {
+    shared: Arc<Shared<T>>,
+}
+
+impl<T> Sender<T> {
+    /// Attempt to send a value into the channel. If the channel is bounded and full, or all
+    /// receivers have been dropped, an error is returned. If the channel associated with this
+    /// sender is unbounded, this method has the same behaviour as [`Sender::send`].
+    pub fn try_send(&self, msg: T) -> Result<(), TrySendError<T>> {
+        self.shared.send_sync(msg, None).map_err(|err| match err {
+            TrySendTimeoutError::Full(msg) => TrySendError::Full(msg),
+            TrySendTimeoutError::Disconnected(msg) => TrySendError::Disconnected(msg),
+            _ => unreachable!(),
+        })
+    }
+
+    /// Send a value into the channel, returning an error if all receivers have been dropped.
+    /// If the channel is bounded and is full, this method will block until space is available
+    /// or all receivers have been dropped. If the channel is unbounded, this method will not
+    /// block.
+    pub fn send(&self, msg: T) -> Result<(), SendError<T>> {
+        self.shared.send_sync(msg, Some(None)).map_err(|err| match err {
+            TrySendTimeoutError::Disconnected(msg) => SendError(msg),
+            _ => unreachable!(),
+        })
+    }
+
+    /// Send a value into the channel, returning an error if all receivers have been dropped
+    /// or the deadline has passed. If the channel is bounded and is full, this method will
+    /// block until space is available, the deadline is reached, or all receivers have been
+    /// dropped.
+    pub fn send_deadline(&self, msg: T, deadline: Instant) -> Result<(), SendTimeoutError<T>> {
+        self.shared.send_sync(msg, Some(Some(deadline))).map_err(|err| match err {
+            TrySendTimeoutError::Disconnected(msg) => SendTimeoutError::Disconnected(msg),
+            TrySendTimeoutError::Timeout(msg) => SendTimeoutError::Timeout(msg),
+            _ => unreachable!(),
+        })
+    }
+
+    /// Send a value into the channel, returning an error if all receivers have been dropped
+    /// or the timeout has expired. If the channel is bounded and is full, this method will
+    /// block until space is available, the timeout has expired, or all receivers have been
+    /// dropped.
+    pub fn send_timeout(&self, msg: T, dur: Duration) -> Result<(), SendTimeoutError<T>> {
+        self.send_deadline(msg, Instant::now().checked_add(dur).unwrap())
+    }
+
+    /// Returns true if all receivers for this channel have been dropped.
+    pub fn is_disconnected(&self) -> bool {
+        self.shared.is_disconnected()
+    }
+
+    /// Returns true if the channel is empty.
+    /// Note: Zero-capacity channels are always empty.
+    pub fn is_empty(&self) -> bool {
+        self.shared.is_empty()
+    }
+
+    /// Returns true if the channel is full.
+    /// Note: Zero-capacity channels are always full.
+    pub fn is_full(&self) -> bool {
+        self.shared.is_full()
+    }
+
+    /// Returns the number of messages in the channel
+    pub fn len(&self) -> usize {
+        self.shared.len()
+    }
+
+    /// If the channel is bounded, returns its capacity.
+    pub fn capacity(&self) -> Option<usize> {
+        self.shared.capacity()
+    }
+
+    /// Get the number of senders that currently exist, including this one.
+    pub fn sender_count(&self) -> usize {
+        self.shared.sender_count()
+    }
+
+    /// Get the number of receivers that currently exist.
+    ///
+    /// Note that this method makes no guarantees that a subsequent send will succeed; it's
+    /// possible that between `receiver_count()` being called and a `send()`, all open receivers
+    /// could drop.
+    pub fn receiver_count(&self) -> usize {
+        self.shared.receiver_count()
+    }
+
+    /// Creates a [`WeakSender`] that does not keep the channel open.
+    ///
+    /// The channel is closed once all `Sender`s are dropped, even if there
+    /// are still active `WeakSender`s.
+    pub fn downgrade(&self) -> WeakSender<T> {
+        WeakSender {
+            shared: Arc::downgrade(&self.shared),
+        }
+    }
+
+    /// Returns whether the senders are belong to the same channel.
+    pub fn same_channel(&self, other: &Sender<T>) -> bool {
+        Arc::ptr_eq(&self.shared, &other.shared)
+    }
+}
+
+impl<T> Clone for Sender<T> {
+    /// Clone this sender. [`Sender`] acts as a handle to the ending a channel. Remaining channel
+    /// contents will only be cleaned up when all senders and the receiver have been dropped.
+    fn clone(&self) -> Self {
+        self.shared.sender_count.fetch_add(1, Ordering::Relaxed);
+        Self { shared: self.shared.clone() }
+    }
+}
+
+impl<T> fmt::Debug for Sender<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Sender").finish()
+    }
+}
+
+impl<T> Drop for Sender<T> {
+    fn drop(&mut self) {
+        // Notify receivers that all senders have been dropped if the number of senders drops to 0.
+        if self.shared.sender_count.fetch_sub(1, Ordering::Relaxed) == 1 {
+            self.shared.disconnect_all();
+        }
+    }
+}
+
+/// A sender that does not prevent the channel from being closed.
+///
+/// Weak senders do not count towards the number of active senders on the channel. As soon as
+/// all normal [`Sender`]s are dropped, the channel is closed, even if there is still a
+/// `WeakSender`.
+///
+/// To send messages, a `WeakSender` must first be upgraded to a `Sender` using the [`upgrade`]
+/// method.
+pub struct WeakSender<T> {
+    shared: Weak<Shared<T>>,
+}
+
+impl<T> WeakSender<T> {
+    /// Tries to upgrade the `WeakSender` to a [`Sender`], in order to send messages.
+    ///
+    /// Returns `None` if the channel was closed already. Note that a `Some` return value
+    /// does not guarantee that the channel is still open.
+    pub fn upgrade(&self) -> Option<Sender<T>> {
+        self.shared
+            .upgrade()
+            // check that there are still live senders
+            .filter(|shared| {
+                shared
+                    .sender_count
+                    .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |count| {
+                        if count == 0 {
+                            // all senders are closed already -> don't increase the sender count
+                            None
+                        } else {
+                            // there is still at least one active sender
+                            Some(count + 1)
+                        }
+                    })
+                    .is_ok()
+            })
+            .map(|shared| Sender { shared })
+    }
+}
+
+/// The receiving end of a channel.
+///
+/// Note: Cloning the receiver *does not* turn this channel into a broadcast channel.
+/// Each message will only be received by a single receiver. This is useful for
+/// implementing work stealing for concurrent programs.
+pub struct Receiver<T> {
+    shared: Arc<Shared<T>>,
+}
+
+impl<T> Receiver<T> {
+    /// Attempt to fetch an incoming value from the channel associated with this receiver,
+    /// returning an error if the channel is empty or if all senders have been dropped.
+    pub fn try_recv(&self) -> Result<T, TryRecvError> {
+        self.shared.recv_sync(None).map_err(|err| match err {
+            TryRecvTimeoutError::Disconnected => TryRecvError::Disconnected,
+            TryRecvTimeoutError::Empty => TryRecvError::Empty,
+            _ => unreachable!(),
+        })
+    }
+
+    /// Wait for an incoming value from the channel associated with this receiver, returning an
+    /// error if all senders have been dropped.
+    pub fn recv(&self) -> Result<T, RecvError> {
+        self.shared.recv_sync(Some(None)).map_err(|err| match err {
+            TryRecvTimeoutError::Disconnected => RecvError::Disconnected,
+            _ => unreachable!(),
+        })
+    }
+
+    /// Wait for an incoming value from the channel associated with this receiver, returning an
+    /// error if all senders have been dropped or the deadline has passed.
+    pub fn recv_deadline(&self, deadline: Instant) -> Result<T, RecvTimeoutError> {
+        self.shared.recv_sync(Some(Some(deadline))).map_err(|err| match err {
+            TryRecvTimeoutError::Disconnected => RecvTimeoutError::Disconnected,
+            TryRecvTimeoutError::Timeout => RecvTimeoutError::Timeout,
+            _ => unreachable!(),
+        })
+    }
+
+    /// Wait for an incoming value from the channel associated with this receiver, returning an
+    /// error if all senders have been dropped or the timeout has expired.
+    pub fn recv_timeout(&self, dur: Duration) -> Result<T, RecvTimeoutError> {
+        self.recv_deadline(Instant::now().checked_add(dur).unwrap())
+    }
+
+    /// Create a blocking iterator over the values received on the channel that finishes iteration
+    /// when all senders have been dropped.
+    ///
+    /// You can also create a self-owned iterator with [`Receiver::into_iter`].
+    pub fn iter(&self) -> Iter<T> {
+        Iter { receiver: &self }
+    }
+
+    /// A non-blocking iterator over the values received on the channel that finishes iteration
+    /// when all senders have been dropped or the channel is empty.
+    pub fn try_iter(&self) -> TryIter<T> {
+        TryIter { receiver: &self }
+    }
+
+    /// Take all msgs currently sitting in the channel and produce an iterator over them. Unlike
+    /// `try_iter`, the iterator will not attempt to fetch any more values from the channel once
+    /// the function has been called.
+    pub fn drain(&self) -> Drain<T> {
+        let mut chan = wait_lock(&self.shared.chan);
+        chan.pull_pending(false);
+        let queue = std::mem::take(&mut chan.queue);
+
+        Drain { queue, _phantom: PhantomData }
+    }
+
+    /// Returns true if all senders for this channel have been dropped.
+    pub fn is_disconnected(&self) -> bool {
+        self.shared.is_disconnected()
+    }
+
+    /// Returns true if the channel is empty.
+    /// Note: Zero-capacity channels are always empty.
+    pub fn is_empty(&self) -> bool {
+        self.shared.is_empty()
+    }
+
+    /// Returns true if the channel is full.
+    /// Note: Zero-capacity channels are always full.
+    pub fn is_full(&self) -> bool {
+        self.shared.is_full()
+    }
+
+    /// Returns the number of messages in the channel.
+    pub fn len(&self) -> usize {
+        self.shared.len()
+    }
+
+    /// If the channel is bounded, returns its capacity.
+    pub fn capacity(&self) -> Option<usize> {
+        self.shared.capacity()
+    }
+
+    /// Get the number of senders that currently exist.
+    pub fn sender_count(&self) -> usize {
+        self.shared.sender_count()
+    }
+
+    /// Get the number of receivers that currently exist, including this one.
+    pub fn receiver_count(&self) -> usize {
+        self.shared.receiver_count()
+    }
+
+    /// Returns whether the receivers are belong to the same channel.
+    pub fn same_channel(&self, other: &Receiver<T>) -> bool {
+        Arc::ptr_eq(&self.shared, &other.shared)
+    }
+}
+
+impl<T> Clone for Receiver<T> {
+    /// Clone this receiver. [`Receiver`] acts as a handle to the ending a channel. Remaining
+    /// channel contents will only be cleaned up when all senders and the receiver have been
+    /// dropped.
+    ///
+    /// Note: Cloning the receiver *does not* turn this channel into a broadcast channel.
+    /// Each message will only be received by a single receiver. This is useful for
+    /// implementing work stealing for concurrent programs.
+    fn clone(&self) -> Self {
+        self.shared.receiver_count.fetch_add(1, Ordering::Relaxed);
+        Self { shared: self.shared.clone() }
+    }
+}
+
+impl<T> fmt::Debug for Receiver<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Receiver").finish()
+    }
+}
+
+impl<T> Drop for Receiver<T> {
+    fn drop(&mut self) {
+        // Notify senders that all receivers have been dropped if the number of receivers drops
+        // to 0.
+        if self.shared.receiver_count.fetch_sub(1, Ordering::Relaxed) == 1 {
+            self.shared.disconnect_all();
+        }
+    }
+}
+
+/// This exists as a shorthand for [`Receiver::iter`].
+impl<'a, T> IntoIterator for &'a Receiver<T> {
+    type Item = T;
+    type IntoIter = Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter { receiver: self }
+    }
+}
+
+impl<T> IntoIterator for Receiver<T> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    /// Creates a self-owned but semantically equivalent alternative to [`Receiver::iter`].
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter { receiver: self }
+    }
+}
+
+/// An iterator over the msgs received from a channel.
+pub struct Iter<'a, T> {
+    receiver: &'a Receiver<T>,
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.receiver.recv().ok()
+    }
+}
+
+/// An non-blocking iterator over the msgs received from a channel.
+pub struct TryIter<'a, T> {
+    receiver: &'a Receiver<T>,
+}
+
+impl<'a, T> Iterator for TryIter<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.receiver.try_recv().ok()
+    }
+}
+
+/// An fixed-sized iterator over the msgs drained from a channel.
+#[derive(Debug)]
+pub struct Drain<'a, T> {
+    queue: VecDeque<T>,
+    /// A phantom field used to constrain the lifetime of this iterator. We do this because the
+    /// implementation may change and we don't want to unintentionally constrain it. Removing this
+    /// lifetime later is a possibility.
+    _phantom: PhantomData<&'a ()>,
+}
+
+impl<'a, T> Iterator for Drain<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.queue.pop_front()
+    }
+}
+
+impl<'a, T> ExactSizeIterator for Drain<'a, T> {
+    fn len(&self) -> usize {
+        self.queue.len()
+    }
+}
+
+/// An owned iterator over the msgs received from a channel.
+pub struct IntoIter<T> {
+    receiver: Receiver<T>,
+}
+
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.receiver.recv().ok()
+    }
+}
+
+/// Create a channel with no maximum capacity.
+///
+/// Create an unbounded channel with a [`Sender`] and [`Receiver`] connected to each end respectively. Values sent in
+/// one end of the channel will be received on the other end. The channel is thread-safe, and both [`Sender`] and
+/// [`Receiver`] may be sent to or shared between threads as necessary. In addition, both [`Sender`] and [`Receiver`]
+/// may be cloned.
+///
+/// # Examples
+/// ```
+/// let (tx, rx) = flume::unbounded();
+///
+/// tx.send(42).unwrap();
+/// assert_eq!(rx.recv().unwrap(), 42);
+/// ```
+pub fn unbounded<T>() -> (Sender<T>, Receiver<T>) {
+    let shared = Arc::new(Shared::new(None));
+    (
+        Sender { shared: shared.clone() },
+        Receiver { shared },
+    )
+}
+
+/// Create a channel with a maximum capacity.
+///
+/// Create a bounded channel with a [`Sender`] and [`Receiver`] connected to each end respectively. Values sent in one
+/// end of the channel will be received on the other end. The channel is thread-safe, and both [`Sender`] and
+/// [`Receiver`] may be sent to or shared between threads as necessary. In addition, both [`Sender`] and [`Receiver`]
+/// may be cloned.
+///
+/// Unlike an [`unbounded`] channel, if there is no space left for new messages, calls to
+/// [`Sender::send`] will block (unblocking once a receiver has made space). If blocking behaviour
+/// is not desired, [`Sender::try_send`] may be used.
+///
+/// Like `std::sync::mpsc`, `flume` supports 'rendezvous' channels. A bounded queue with a maximum capacity of zero
+/// will block senders until a receiver is available to take the value. You can imagine a rendezvous channel as a
+/// ['Glienicke Bridge'](https://en.wikipedia.org/wiki/Glienicke_Bridge)-style location at which senders and receivers
+/// perform a handshake and transfer ownership of a value.
+///
+/// # Examples
+/// ```
+/// let (tx, rx) = flume::bounded(32);
+///
+/// for i in 1..33 {
+///     tx.send(i).unwrap();
+/// }
+/// assert!(tx.try_send(33).is_err());
+///
+/// assert_eq!(rx.try_iter().sum::<u32>(), (1..33).sum());
+/// ```
+pub fn bounded<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
+    let shared = Arc::new(Shared::new(Some(cap)));
+    (
+        Sender { shared: shared.clone() },
+        Receiver { shared },
+    )
+}
diff --git a/vendor/flume/src/select.rs b/vendor/flume/src/select.rs
new file mode 100644
index 0000000..cef15aa
--- /dev/null
+++ b/vendor/flume/src/select.rs
@@ -0,0 +1,405 @@
+//! Types that permit waiting upon multiple blocking operations using the [`Selector`] interface.
+
+use crate::*;
+use spin1::Mutex as Spinlock;
+use std::{any::Any, marker::PhantomData};
+
+#[cfg(feature = "eventual-fairness")]
+use nanorand::Rng;
+
+// A unique token corresponding to an event in a selector
+type Token = usize;
+
+struct SelectSignal(
+    thread::Thread,
+    Token,
+    AtomicBool,
+    Arc<Spinlock<VecDeque<Token>>>,
+);
+
+impl Signal for SelectSignal {
+    fn fire(&self) -> bool {
+        self.2.store(true, Ordering::SeqCst);
+        self.3.lock().push_back(self.1);
+        self.0.unpark();
+        false
+    }
+
+    fn as_any(&self) -> &(dyn Any + 'static) {
+        self
+    }
+    fn as_ptr(&self) -> *const () {
+        self as *const _ as *const ()
+    }
+}
+
+trait Selection<'a, T> {
+    fn init(&mut self) -> Option<T>;
+    fn poll(&mut self) -> Option<T>;
+    fn deinit(&mut self);
+}
+
+/// An error that may be emitted when attempting to wait for a value on a receiver.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum SelectError {
+    /// A timeout occurred when waiting on a `Selector`.
+    Timeout,
+}
+
+impl fmt::Display for SelectError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SelectError::Timeout => "timeout occurred".fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for SelectError {}
+
+/// A type used to wait upon multiple blocking operations at once.
+///
+/// A [`Selector`] implements [`select`](https://en.wikipedia.org/wiki/Select_(Unix))-like behaviour,
+/// allowing a thread to wait upon the result of more than one operation at once.
+///
+/// # Examples
+/// ```
+/// let (tx0, rx0) = flume::unbounded();
+/// let (tx1, rx1) = flume::unbounded();
+///
+/// std::thread::spawn(move || {
+///     tx0.send(true).unwrap();
+///     tx1.send(42).unwrap();
+/// });
+///
+/// flume::Selector::new()
+///     .recv(&rx0, |b| println!("Received {:?}", b))
+///     .recv(&rx1, |n| println!("Received {:?}", n))
+///     .wait();
+/// ```
+pub struct Selector<'a, T: 'a> {
+    selections: Vec<Box<dyn Selection<'a, T> + 'a>>,
+    next_poll: usize,
+    signalled: Arc<Spinlock<VecDeque<Token>>>,
+    #[cfg(feature = "eventual-fairness")]
+    rng: nanorand::WyRand,
+    phantom: PhantomData<*const ()>,
+}
+
+impl<'a, T: 'a> Default for Selector<'a, T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a, T: 'a> fmt::Debug for Selector<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Selector").finish()
+    }
+}
+
+impl<'a, T> Selector<'a, T> {
+    /// Create a new selector.
+    pub fn new() -> Self {
+        Self {
+            selections: Vec::new(),
+            next_poll: 0,
+            signalled: Arc::default(),
+            phantom: PhantomData::default(),
+            #[cfg(feature = "eventual-fairness")]
+            rng: nanorand::WyRand::new(),
+        }
+    }
+
+    /// Add a send operation to the selector that sends the provided value.
+    ///
+    /// Once added, the selector can be used to run the provided handler function on completion of this operation.
+    pub fn send<U, F: FnMut(Result<(), SendError<U>>) -> T + 'a>(
+        mut self,
+        sender: &'a Sender<U>,
+        msg: U,
+        mapper: F,
+    ) -> Self {
+        struct SendSelection<'a, T, F, U> {
+            sender: &'a Sender<U>,
+            msg: Option<U>,
+            token: Token,
+            signalled: Arc<Spinlock<VecDeque<Token>>>,
+            hook: Option<Arc<Hook<U, SelectSignal>>>,
+            mapper: F,
+            phantom: PhantomData<T>,
+        }
+
+        impl<'a, T, F, U> Selection<'a, T> for SendSelection<'a, T, F, U>
+        where
+            F: FnMut(Result<(), SendError<U>>) -> T,
+        {
+            fn init(&mut self) -> Option<T> {
+                let token = self.token;
+                let signalled = self.signalled.clone();
+                let r = self.sender.shared.send(
+                    self.msg.take().unwrap(),
+                    true,
+                    |msg| {
+                        Hook::slot(
+                            Some(msg),
+                            SelectSignal(
+                                thread::current(),
+                                token,
+                                AtomicBool::new(false),
+                                signalled,
+                            ),
+                        )
+                    },
+                    // Always runs
+                    |h| {
+                        self.hook = Some(h);
+                        Ok(())
+                    },
+                );
+
+                if self.hook.is_none() {
+                    Some((self.mapper)(match r {
+                        Ok(()) => Ok(()),
+                        Err(TrySendTimeoutError::Disconnected(msg)) => Err(SendError(msg)),
+                        _ => unreachable!(),
+                    }))
+                } else {
+                    None
+                }
+            }
+
+            fn poll(&mut self) -> Option<T> {
+                let res = if self.sender.shared.is_disconnected() {
+                    // Check the hook one last time
+                    if let Some(msg) = self.hook.as_ref()?.try_take() {
+                        Err(SendError(msg))
+                    } else {
+                        Ok(())
+                    }
+                } else if self.hook.as_ref().unwrap().is_empty() {
+                    // The message was sent
+                    Ok(())
+                } else {
+                    return None;
+                };
+
+                Some((&mut self.mapper)(res))
+            }
+
+            fn deinit(&mut self) {
+                if let Some(hook) = self.hook.take() {
+                    // Remove hook
+                    let hook: Arc<Hook<U, dyn Signal>> = hook;
+                    wait_lock(&self.sender.shared.chan)
+                        .sending
+                        .as_mut()
+                        .unwrap()
+                        .1
+                        .retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+                }
+            }
+        }
+
+        let token = self.selections.len();
+        self.selections.push(Box::new(SendSelection {
+            sender,
+            msg: Some(msg),
+            token,
+            signalled: self.signalled.clone(),
+            hook: None,
+            mapper,
+            phantom: Default::default(),
+        }));
+
+        self
+    }
+
+    /// Add a receive operation to the selector.
+    ///
+    /// Once added, the selector can be used to run the provided handler function on completion of this operation.
+    pub fn recv<U, F: FnMut(Result<U, RecvError>) -> T + 'a>(
+        mut self,
+        receiver: &'a Receiver<U>,
+        mapper: F,
+    ) -> Self {
+        struct RecvSelection<'a, T, F, U> {
+            receiver: &'a Receiver<U>,
+            token: Token,
+            signalled: Arc<Spinlock<VecDeque<Token>>>,
+            hook: Option<Arc<Hook<U, SelectSignal>>>,
+            mapper: F,
+            received: bool,
+            phantom: PhantomData<T>,
+        }
+
+        impl<'a, T, F, U> Selection<'a, T> for RecvSelection<'a, T, F, U>
+        where
+            F: FnMut(Result<U, RecvError>) -> T,
+        {
+            fn init(&mut self) -> Option<T> {
+                let token = self.token;
+                let signalled = self.signalled.clone();
+                let r = self.receiver.shared.recv(
+                    true,
+                    || {
+                        Hook::trigger(SelectSignal(
+                            thread::current(),
+                            token,
+                            AtomicBool::new(false),
+                            signalled,
+                        ))
+                    },
+                    // Always runs
+                    |h| {
+                        self.hook = Some(h);
+                        Err(TryRecvTimeoutError::Timeout)
+                    },
+                );
+
+                if self.hook.is_none() {
+                    Some((self.mapper)(match r {
+                        Ok(msg) => Ok(msg),
+                        Err(TryRecvTimeoutError::Disconnected) => Err(RecvError::Disconnected),
+                        _ => unreachable!(),
+                    }))
+                } else {
+                    None
+                }
+            }
+
+            fn poll(&mut self) -> Option<T> {
+                let res = if let Ok(msg) = self.receiver.try_recv() {
+                    self.received = true;
+                    Ok(msg)
+                } else if self.receiver.shared.is_disconnected() {
+                    Err(RecvError::Disconnected)
+                } else {
+                    return None;
+                };
+
+                Some((&mut self.mapper)(res))
+            }
+
+            fn deinit(&mut self) {
+                if let Some(hook) = self.hook.take() {
+                    // Remove hook
+                    let hook: Arc<Hook<U, dyn Signal>> = hook;
+                    wait_lock(&self.receiver.shared.chan)
+                        .waiting
+                        .retain(|s| s.signal().as_ptr() != hook.signal().as_ptr());
+                    // If we were woken, but never polled, wake up another
+                    if !self.received
+                        && hook
+                            .signal()
+                            .as_any()
+                            .downcast_ref::<SelectSignal>()
+                            .unwrap()
+                            .2
+                            .load(Ordering::SeqCst)
+                    {
+                        wait_lock(&self.receiver.shared.chan).try_wake_receiver_if_pending();
+                    }
+                }
+            }
+        }
+
+        let token = self.selections.len();
+        self.selections.push(Box::new(RecvSelection {
+            receiver,
+            token,
+            signalled: self.signalled.clone(),
+            hook: None,
+            mapper,
+            received: false,
+            phantom: Default::default(),
+        }));
+
+        self
+    }
+
+    fn wait_inner(mut self, deadline: Option<Instant>) -> Option<T> {
+        #[cfg(feature = "eventual-fairness")]
+        {
+            self.next_poll = self.rng.generate_range(0..self.selections.len());
+        }
+
+        let res = 'outer: loop {
+            // Init signals
+            for _ in 0..self.selections.len() {
+                if let Some(val) = self.selections[self.next_poll].init() {
+                    break 'outer Some(val);
+                }
+                self.next_poll = (self.next_poll + 1) % self.selections.len();
+            }
+
+            // Speculatively poll
+            if let Some(msg) = self.poll() {
+                break 'outer Some(msg);
+            }
+
+            loop {
+                if let Some(deadline) = deadline {
+                    if let Some(dur) = deadline.checked_duration_since(Instant::now()) {
+                        thread::park_timeout(dur);
+                    }
+                } else {
+                    thread::park();
+                }
+
+                if deadline.map(|d| Instant::now() >= d).unwrap_or(false) {
+                    break 'outer self.poll();
+                }
+
+                let token = if let Some(token) = self.signalled.lock().pop_front() {
+                    token
+                } else {
+                    // Spurious wakeup, park again
+                    continue;
+                };
+
+                // Attempt to receive a message
+                if let Some(msg) = self.selections[token].poll() {
+                    break 'outer Some(msg);
+                }
+            }
+        };
+
+        // Deinit signals
+        for s in &mut self.selections {
+            s.deinit();
+        }
+
+        res
+    }
+
+    fn poll(&mut self) -> Option<T> {
+        for _ in 0..self.selections.len() {
+            if let Some(val) = self.selections[self.next_poll].poll() {
+                return Some(val);
+            }
+            self.next_poll = (self.next_poll + 1) % self.selections.len();
+        }
+        None
+    }
+
+    /// Wait until one of the events associated with this [`Selector`] has completed. If the `eventual-fairness`
+    /// feature flag is enabled, this method is fair and will handle a random event of those that are ready.
+    pub fn wait(self) -> T {
+        self.wait_inner(None).unwrap()
+    }
+
+    /// Wait until one of the events associated with this [`Selector`] has completed or the timeout has expired. If the
+    /// `eventual-fairness` feature flag is enabled, this method is fair and will handle a random event of those that
+    /// are ready.
+    pub fn wait_timeout(self, dur: Duration) -> Result<T, SelectError> {
+        self.wait_inner(Some(Instant::now() + dur))
+            .ok_or(SelectError::Timeout)
+    }
+
+    /// Wait until one of the events associated with this [`Selector`] has completed or the deadline has been reached.
+    /// If the `eventual-fairness` feature flag is enabled, this method is fair and will handle a random event of those
+    /// that are ready.
+    pub fn wait_deadline(self, deadline: Instant) -> Result<T, SelectError> {
+        self.wait_inner(Some(deadline)).ok_or(SelectError::Timeout)
+    }
+}
diff --git a/vendor/flume/src/signal.rs b/vendor/flume/src/signal.rs
new file mode 100644
index 0000000..89395a3
--- /dev/null
+++ b/vendor/flume/src/signal.rs
@@ -0,0 +1,33 @@
+use std::{thread::{self, Thread}, time::Duration, any::Any};
+
+pub trait Signal: Send + Sync + 'static {
+    /// Fire the signal, returning whether it is a stream signal. This is because streams do not
+    /// acquire a message when woken, so signals must be fired until one that does acquire a message
+    /// is fired, otherwise a wakeup could be missed, leading to a lost message until one is eagerly
+    /// grabbed by a receiver.
+    fn fire(&self) -> bool;
+    fn as_any(&self) -> &(dyn Any + 'static);
+    fn as_ptr(&self) -> *const ();
+}
+
+pub struct SyncSignal(Thread);
+
+impl Default for SyncSignal {
+    fn default() -> Self {
+        Self(thread::current())
+    }
+}
+
+impl Signal for SyncSignal {
+    fn fire(&self) -> bool {
+        self.0.unpark();
+        false
+    }
+    fn as_any(&self) -> &(dyn Any + 'static) { self }
+    fn as_ptr(&self) -> *const () { self as *const _ as *const () }
+}
+
+impl SyncSignal {
+    pub fn wait(&self) { thread::park(); }
+    pub fn wait_timeout(&self, dur: Duration) { thread::park_timeout(dur); }
+}
diff --git a/vendor/flume/tests/after.rs b/vendor/flume/tests/after.rs
new file mode 100644
index 0000000..6d25108
--- /dev/null
+++ b/vendor/flume/tests/after.rs
@@ -0,0 +1,339 @@
+// //! Tests for the after channel flavor.
+
+// #[macro_use]
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+// extern crate rand;
+
+// use std::sync::atomic::AtomicUsize;
+// use std::sync::atomic::Ordering;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, Select, TryRecvError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn fire() {
+//     let start = Instant::now();
+//     let r = after(ms(50));
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+//     thread::sleep(ms(100));
+
+//     let fired = r.try_recv().unwrap();
+//     assert!(start < fired);
+//     assert!(fired - start >= ms(50));
+
+//     let now = Instant::now();
+//     assert!(fired < now);
+//     assert!(now - fired >= ms(50));
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+
+//     select! {
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+
+//     select! {
+//         recv(r) -> _ => panic!(),
+//         recv(after(ms(200))) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn capacity() {
+//     const COUNT: usize = 10;
+
+//     for i in 0..COUNT {
+//         let r = after(ms(i as u64));
+//         assert_eq!(r.capacity(), Some(1));
+//     }
+// }
+
+// #[test]
+// fn len_empty_full() {
+//     let r = after(ms(50));
+
+//     assert_eq!(r.len(), 0);
+//     assert_eq!(r.is_empty(), true);
+//     assert_eq!(r.is_full(), false);
+
+//     thread::sleep(ms(100));
+
+//     assert_eq!(r.len(), 1);
+//     assert_eq!(r.is_empty(), false);
+//     assert_eq!(r.is_full(), true);
+
+//     r.try_recv().unwrap();
+
+//     assert_eq!(r.len(), 0);
+//     assert_eq!(r.is_empty(), true);
+//     assert_eq!(r.is_full(), false);
+// }
+
+// #[test]
+// fn try_recv() {
+//     let r = after(ms(200));
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(100));
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(200));
+//     assert!(r.try_recv().is_ok());
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(200));
+//     assert!(r.try_recv().is_err());
+// }
+
+// #[test]
+// fn recv() {
+//     let start = Instant::now();
+//     let r = after(ms(50));
+
+//     let fired = r.recv().unwrap();
+//     assert!(start < fired);
+//     assert!(fired - start >= ms(50));
+
+//     let now = Instant::now();
+//     assert!(fired < now);
+//     assert!(now - fired < fired - start);
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn recv_timeout() {
+//     let start = Instant::now();
+//     let r = after(ms(200));
+
+//     assert!(r.recv_timeout(ms(100)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(100));
+//     assert!(now - start <= ms(150));
+
+//     let fired = r.recv_timeout(ms(200)).unwrap();
+//     assert!(fired - start >= ms(200));
+//     assert!(fired - start <= ms(250));
+
+//     assert!(r.recv_timeout(ms(200)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(400));
+//     assert!(now - start <= ms(450));
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn recv_two() {
+//     let r1 = after(ms(50));
+//     let r2 = after(ms(50));
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             select! {
+//                 recv(r1) -> _ => {}
+//                 recv(r2) -> _ => {}
+//             }
+//         });
+//         scope.spawn(|_| {
+//             select! {
+//                 recv(r1) -> _ => {}
+//                 recv(r2) -> _ => {}
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv_race() {
+//     select! {
+//         recv(after(ms(50))) -> _ => {}
+//         recv(after(ms(100))) -> _ => panic!(),
+//     }
+
+//     select! {
+//         recv(after(ms(100))) -> _ => panic!(),
+//         recv(after(ms(50))) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn stress_default() {
+//     const COUNT: usize = 10;
+
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(after(ms(0))) -> _ => {}
+//             default => panic!(),
+//         }
+//     }
+
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(after(ms(100))) -> _ => panic!(),
+//             default => {}
+//         }
+//     }
+// }
+
+// #[test]
+// fn select() {
+//     const THREADS: usize = 4;
+//     const COUNT: usize = 1000;
+//     const TIMEOUT_MS: u64 = 100;
+
+//     let v = (0..COUNT)
+//         .map(|i| after(ms(i as u64 / TIMEOUT_MS / 2)))
+//         .collect::<Vec<_>>();
+//     let hits = AtomicUsize::new(0);
+
+//     scope(|scope| {
+//         for _ in 0..THREADS {
+//             scope.spawn(|_| {
+//                 let v: Vec<&_> = v.iter().collect();
+
+//                 loop {
+//                     let timeout = after(ms(TIMEOUT_MS));
+//                     let mut sel = Select::new();
+//                     for r in &v {
+//                         sel.recv(r);
+//                     }
+//                     let oper_timeout = sel.recv(&timeout);
+
+//                     let oper = sel.select();
+//                     match oper.index() {
+//                         i if i == oper_timeout => {
+//                             oper.recv(&timeout).unwrap();
+//                             break;
+//                         }
+//                         i => {
+//                             oper.recv(&v[i]).unwrap();
+//                             hits.fetch_add(1, Ordering::SeqCst);
+//                         }
+//                     }
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(hits.load(Ordering::SeqCst), COUNT);
+// }
+
+// #[test]
+// fn ready() {
+//     const THREADS: usize = 4;
+//     const COUNT: usize = 1000;
+//     const TIMEOUT_MS: u64 = 100;
+
+//     let v = (0..COUNT)
+//         .map(|i| after(ms(i as u64 / TIMEOUT_MS / 2)))
+//         .collect::<Vec<_>>();
+//     let hits = AtomicUsize::new(0);
+
+//     scope(|scope| {
+//         for _ in 0..THREADS {
+//             scope.spawn(|_| {
+//                 let v: Vec<&_> = v.iter().collect();
+
+//                 loop {
+//                     let timeout = after(ms(TIMEOUT_MS));
+//                     let mut sel = Select::new();
+//                     for r in &v {
+//                         sel.recv(r);
+//                     }
+//                     let oper_timeout = sel.recv(&timeout);
+
+//                     loop {
+//                         let i = sel.ready();
+//                         if i == oper_timeout {
+//                             timeout.try_recv().unwrap();
+//                             return;
+//                         } else if v[i].try_recv().is_ok() {
+//                             hits.fetch_add(1, Ordering::SeqCst);
+//                             break;
+//                         }
+//                     }
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(hits.load(Ordering::SeqCst), COUNT);
+// }
+
+// #[test]
+// fn stress_clone() {
+//     const RUNS: usize = 1000;
+//     const THREADS: usize = 10;
+//     const COUNT: usize = 50;
+
+//     for i in 0..RUNS {
+//         let r = after(ms(i as u64));
+
+//         scope(|scope| {
+//             for _ in 0..THREADS {
+//                 scope.spawn(|_| {
+//                     let r = r.clone();
+//                     let _ = r.try_recv();
+
+//                     for _ in 0..COUNT {
+//                         drop(r.clone());
+//                         thread::yield_now();
+//                     }
+//                 });
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn fairness() {
+//     const COUNT: usize = 1000;
+
+//     for &dur in &[0, 1] {
+//         let mut hits = [0usize; 2];
+
+//         for _ in 0..COUNT {
+//             select! {
+//                 recv(after(ms(dur))) -> _ => hits[0] += 1,
+//                 recv(after(ms(dur))) -> _ => hits[1] += 1,
+//             }
+//         }
+
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     }
+// }
+
+// #[test]
+// fn fairness_duplicates() {
+//     const COUNT: usize = 1000;
+
+//     for &dur in &[0, 1] {
+//         let mut hits = [0usize; 5];
+
+//         for _ in 0..COUNT {
+//             let r = after(ms(dur));
+//             select! {
+//                 recv(r) -> _ => hits[0] += 1,
+//                 recv(r) -> _ => hits[1] += 1,
+//                 recv(r) -> _ => hits[2] += 1,
+//                 recv(r) -> _ => hits[3] += 1,
+//                 recv(r) -> _ => hits[4] += 1,
+//             }
+//         }
+
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     }
+// }
diff --git a/vendor/flume/tests/array.rs b/vendor/flume/tests/array.rs
new file mode 100644
index 0000000..a72bbe3
--- /dev/null
+++ b/vendor/flume/tests/array.rs
@@ -0,0 +1,657 @@
+//! Tests for the array channel flavor.
+
+extern crate crossbeam_utils;
+extern crate rand;
+
+use std::any::Any;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::thread;
+use std::time::Duration;
+
+use flume::{bounded, Receiver};
+use flume::{RecvError, RecvTimeoutError, TryRecvError};
+use flume::{SendError, SendTimeoutError, TrySendError};
+use crossbeam_utils::thread::scope;
+use rand::{thread_rng, Rng};
+
+fn ms(ms: u64) -> Duration {
+    Duration::from_millis(ms)
+}
+
+#[test]
+fn smoke() {
+    let (s, r) = bounded(1);
+    s.send(7).unwrap();
+    assert_eq!(r.try_recv(), Ok(7));
+
+    s.send(8).unwrap();
+    assert_eq!(r.recv(), Ok(8));
+
+    assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+    assert_eq!(r.recv_timeout(ms(1000)), Err(RecvTimeoutError::Timeout));
+}
+
+#[test]
+fn capacity() {
+    for i in 1..10 {
+        let (s, r) = bounded::<()>(i);
+        assert_eq!(s.capacity(), Some(i));
+        assert_eq!(r.capacity(), Some(i));
+    }
+}
+
+#[test]
+fn len_empty_full() {
+    let (s, r) = bounded(2);
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(s.is_empty(), true);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 0);
+    assert_eq!(r.is_empty(), true);
+    assert_eq!(r.is_full(), false);
+
+    s.send(()).unwrap();
+
+    assert_eq!(s.len(), 1);
+    assert_eq!(s.is_empty(), false);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 1);
+    assert_eq!(r.is_empty(), false);
+    assert_eq!(r.is_full(), false);
+
+    s.send(()).unwrap();
+
+    assert_eq!(s.len(), 2);
+    assert_eq!(s.is_empty(), false);
+    assert_eq!(s.is_full(), true);
+    assert_eq!(r.len(), 2);
+    assert_eq!(r.is_empty(), false);
+    assert_eq!(r.is_full(), true);
+
+    r.recv().unwrap();
+
+    assert_eq!(s.len(), 1);
+    assert_eq!(s.is_empty(), false);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 1);
+    assert_eq!(r.is_empty(), false);
+    assert_eq!(r.is_full(), false);
+}
+
+#[test]
+fn try_recv() {
+    let (s, r) = bounded(100);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+            thread::sleep(ms(1500));
+            assert_eq!(r.try_recv(), Ok(7));
+            thread::sleep(ms(500));
+            assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv() {
+    let (s, r) = bounded(100);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv(), Ok(7));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(8));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(9));
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+            s.send(8).unwrap();
+            s.send(9).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_timeout() {
+    let (s, r) = bounded::<i32>(100);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv_timeout(ms(1000)), Err(RecvTimeoutError::Timeout));
+            assert_eq!(r.recv_timeout(ms(1000)), Ok(7));
+            assert_eq!(
+                r.recv_timeout(ms(1000)),
+                Err(RecvTimeoutError::Disconnected)
+            );
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn try_send() {
+    let (s, r) = bounded(1);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(s.try_send(1), Ok(()));
+            assert_eq!(s.try_send(2), Err(TrySendError::Full(2)));
+            thread::sleep(ms(1500));
+            assert_eq!(s.try_send(3), Ok(()));
+            thread::sleep(ms(500));
+            assert_eq!(s.try_send(4), Err(TrySendError::Disconnected(4)));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            assert_eq!(r.try_recv(), Ok(1));
+            assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+            assert_eq!(r.recv(), Ok(3));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn send() {
+    let (s, r) = bounded(1);
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            s.send(7).unwrap();
+            thread::sleep(ms(1000));
+            s.send(8).unwrap();
+            thread::sleep(ms(1000));
+            s.send(9).unwrap();
+            thread::sleep(ms(1000));
+            s.send(10).unwrap();
+        });
+        scope.spawn(|_| {
+            thread::sleep(ms(1500));
+            assert_eq!(r.recv(), Ok(7));
+            assert_eq!(r.recv(), Ok(8));
+            assert_eq!(r.recv(), Ok(9));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn send_timeout() {
+    let (s, r) = bounded(2);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(s.send_timeout(1, ms(1000)), Ok(()));
+            assert_eq!(s.send_timeout(2, ms(1000)), Ok(()));
+            assert_eq!(
+                s.send_timeout(3, ms(500)),
+                Err(SendTimeoutError::Timeout(3))
+            );
+            thread::sleep(ms(1000));
+            assert_eq!(s.send_timeout(4, ms(1000)), Ok(()));
+            thread::sleep(ms(1000));
+            assert_eq!(s.send(5), Err(SendError(5)));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(1));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(2));
+            assert_eq!(r.recv(), Ok(4));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn send_after_disconnect() {
+    let (s, r) = bounded(100);
+
+    s.send(1).unwrap();
+    s.send(2).unwrap();
+    s.send(3).unwrap();
+
+    drop(r);
+
+    assert_eq!(s.send(4), Err(SendError(4)));
+    assert_eq!(s.try_send(5), Err(TrySendError::Disconnected(5)));
+    assert_eq!(
+        s.send_timeout(6, ms(500)),
+        Err(SendTimeoutError::Disconnected(6))
+    );
+}
+
+#[test]
+fn recv_after_disconnect() {
+    let (s, r) = bounded(100);
+
+    s.send(1).unwrap();
+    s.send(2).unwrap();
+    s.send(3).unwrap();
+
+    drop(s);
+
+    assert_eq!(r.recv(), Ok(1));
+    assert_eq!(r.recv(), Ok(2));
+    assert_eq!(r.recv(), Ok(3));
+    assert!(r.recv().is_err());
+}
+
+#[test]
+fn len() {
+    const COUNT: usize = 25_000;
+    const CAP: usize = 1000;
+
+    let (s, r) = bounded(CAP);
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+
+    for _ in 0..CAP / 10 {
+        for i in 0..50 {
+            s.send(i).unwrap();
+            assert_eq!(s.len(), i + 1);
+        }
+
+        for i in 0..50 {
+            r.recv().unwrap();
+            assert_eq!(r.len(), 50 - i - 1);
+        }
+    }
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+
+    for i in 0..CAP {
+        s.send(i).unwrap();
+        assert_eq!(s.len(), i + 1);
+    }
+
+    for _ in 0..CAP {
+        r.recv().unwrap();
+    }
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                assert_eq!(r.recv(), Ok(i));
+                let len = r.len();
+                assert!(len <= CAP);
+            }
+        });
+
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                s.send(i).unwrap();
+                let len = s.len();
+                assert!(len <= CAP);
+            }
+        });
+    })
+    .unwrap();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+}
+
+#[test]
+fn disconnect_wakes_sender() {
+    let (s, r) = bounded(1);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(s.send(()), Ok(()));
+            assert_eq!(s.send(()), Err(SendError(())));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            drop(r);
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn disconnect_wakes_receiver() {
+    let (s, r) = bounded::<()>(1);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            drop(s);
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn spsc() {
+    const COUNT: usize = 100_000;
+
+    let (s, r) = bounded(3);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                assert_eq!(r.recv(), Ok(i));
+            }
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                s.send(i).unwrap();
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn mpmc() {
+    const COUNT: usize = 25_000;
+    const THREADS: usize = 4;
+
+    let (s, r) = bounded::<usize>(3);
+    let v = (0..COUNT).map(|_| AtomicUsize::new(0)).collect::<Vec<_>>();
+
+    scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for _ in 0..COUNT {
+                    let n = r.recv().unwrap();
+                    v[n].fetch_add(1, Ordering::SeqCst);
+                }
+            });
+        }
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for i in 0..COUNT {
+                    s.send(i).unwrap();
+                }
+            });
+        }
+    })
+    .unwrap();
+
+    for c in v {
+        assert_eq!(c.load(Ordering::SeqCst), THREADS);
+    }
+}
+
+#[test]
+fn stress_oneshot() {
+    const COUNT: usize = 10_000;
+
+    for _ in 0..COUNT {
+        let (s, r) = bounded(1);
+
+        scope(|scope| {
+            scope.spawn(|_| r.recv().unwrap());
+            scope.spawn(|_| s.send(0).unwrap());
+        })
+        .unwrap();
+    }
+}
+
+#[test]
+fn stress_iter() {
+    const COUNT: usize = 100_000;
+
+    let (request_s, request_r) = bounded(1);
+    let (response_s, response_r) = bounded(1);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut count = 0;
+            loop {
+                for x in response_r.try_iter() {
+                    count += x;
+                    if count == COUNT {
+                        return;
+                    }
+                }
+                request_s.send(()).unwrap();
+            }
+        });
+
+        for _ in request_r.iter() {
+            if response_s.send(1).is_err() {
+                break;
+            }
+        }
+    })
+    .unwrap();
+}
+
+#[test]
+fn stress_timeout_two_threads() {
+    const COUNT: usize = 100;
+
+    let (s, r) = bounded(2);
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                loop {
+                    if let Ok(()) = s.send_timeout(i, ms(10)) {
+                        break;
+                    }
+                }
+            }
+        });
+
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                loop {
+                    if let Ok(x) = r.recv_timeout(ms(10)) {
+                        assert_eq!(x, i);
+                        break;
+                    }
+                }
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn drops() {
+    const RUNS: usize = 100;
+
+    static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+    #[derive(Debug, PartialEq)]
+    struct DropCounter;
+
+    impl Drop for DropCounter {
+        fn drop(&mut self) {
+            DROPS.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    let mut rng = thread_rng();
+
+    for _ in 0..RUNS {
+        let steps = rng.gen_range(0..10_000);
+        let additional = rng.gen_range(0..50);
+
+        DROPS.store(0, Ordering::SeqCst);
+        let (s, r) = bounded::<DropCounter>(50);
+
+        scope(|scope| {
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    r.recv().unwrap();
+                }
+            });
+
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    s.send(DropCounter).unwrap();
+                }
+            });
+        })
+        .unwrap();
+
+        for _ in 0..additional {
+            s.send(DropCounter).unwrap();
+        }
+
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps);
+        drop(s);
+        drop(r);
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps + additional);
+    }
+}
+
+#[test]
+fn linearizable() {
+    const COUNT: usize = 25_000;
+    const THREADS: usize = 4;
+
+    let (s, r) = bounded(THREADS);
+
+    scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for _ in 0..COUNT {
+                    s.send(0).unwrap();
+                    r.try_recv().unwrap();
+                }
+            });
+        }
+    })
+    .unwrap();
+}
+
+// #[test]
+// fn fairness() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = bounded::<()>(COUNT);
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 2];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r1) -> _  => hits[0] += 1,
+//             recv(r2) -> _  => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness_duplicates() {
+//     const COUNT: usize = 10_000;
+
+//     let (s, r) = bounded::<()>(COUNT);
+
+//     for _ in 0..COUNT {
+//         s.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 5];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r) -> _ => hits[0] += 1,
+//             recv(r) -> _ => hits[1] += 1,
+//             recv(r) -> _ => hits[2] += 1,
+//             recv(r) -> _ => hits[3] += 1,
+//             recv(r) -> _ => hits[4] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn recv_in_send() {
+//     let (s, _r) = bounded(1);
+//     s.send(()).unwrap();
+
+//     #[allow(unreachable_code)]
+//     {
+//         select! {
+//             send(s, panic!()) -> _ => panic!(),
+//             default => {}
+//         }
+//     }
+
+//     let (s, r) = bounded(2);
+//     s.send(()).unwrap();
+
+//     select! {
+//         send(s, assert_eq!(r.recv(), Ok(()))) -> _ => {}
+//     }
+// }
+
+#[test]
+fn channel_through_channel() {
+    const COUNT: usize = 1000;
+
+    type T = Box<dyn Any + Send>;
+
+    let (s, r) = bounded::<T>(1);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut s = s;
+
+            for _ in 0..COUNT {
+                let (new_s, new_r) = bounded(1);
+                let new_r: T = Box::new(Some(new_r));
+
+                s.send(new_r).unwrap();
+                s = new_s;
+            }
+        });
+
+        scope.spawn(move |_| {
+            let mut r = r;
+
+            for _ in 0..COUNT {
+                r = r
+                    .recv()
+                    .unwrap()
+                    .downcast_mut::<Option<Receiver<T>>>()
+                    .unwrap()
+                    .take()
+                    .unwrap()
+            }
+        });
+    })
+    .unwrap();
+}
diff --git a/vendor/flume/tests/async.rs b/vendor/flume/tests/async.rs
new file mode 100644
index 0000000..6c2c7f2
--- /dev/null
+++ b/vendor/flume/tests/async.rs
@@ -0,0 +1,276 @@
+#[cfg(feature = "async")]
+use {
+    flume::*,
+    futures::{stream::FuturesUnordered, StreamExt, TryFutureExt, Future},
+    futures::task::{Context, Waker, Poll},
+    async_std::prelude::FutureExt,
+    std::{time::Duration, sync::{atomic::{AtomicUsize, Ordering}, Arc}},
+};
+
+#[cfg(feature = "async")]
+#[test]
+fn r#async_recv() {
+    let (tx, rx) = unbounded();
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        tx.send(42u32).unwrap();
+    });
+
+    async_std::task::block_on(async {
+        assert_eq!(rx.recv_async().await.unwrap(), 42);
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn r#async_send() {
+    let (tx, rx) = bounded(1);
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        assert_eq!(rx.recv(), Ok(42));
+    });
+
+    async_std::task::block_on(async {
+        tx.send_async(42u32).await.unwrap();
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn r#async_recv_disconnect() {
+    let (tx, rx) = bounded::<i32>(0);
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        drop(tx)
+    });
+
+    async_std::task::block_on(async {
+        assert_eq!(rx.recv_async().await, Err(RecvError::Disconnected));
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn r#async_send_disconnect() {
+    let (tx, rx) = bounded(0);
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        drop(rx)
+    });
+
+    async_std::task::block_on(async {
+        assert_eq!(tx.send_async(42u32).await, Err(SendError(42)));
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn r#async_recv_drop_recv() {
+    let (tx, rx) = bounded::<i32>(10);
+
+    let recv_fut = rx.recv_async();
+
+    async_std::task::block_on(async {
+        let res = async_std::future::timeout(std::time::Duration::from_millis(500), rx.recv_async()).await;
+        assert!(res.is_err());
+    });
+
+    let rx2 = rx.clone();
+    let t = std::thread::spawn(move || {
+        async_std::task::block_on(async {
+            rx2.recv_async().await
+        })
+    });
+
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    tx.send(42).unwrap();
+
+    drop(recv_fut);
+
+    assert_eq!(t.join().unwrap(), Ok(42))
+}
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn r#async_send_1_million_no_drop_or_reorder() {
+    #[derive(Debug)]
+    enum Message {
+        Increment {
+            old: u64,
+        },
+        ReturnCount,
+    }
+
+    let (tx, rx) = unbounded();
+
+    let t = async_std::task::spawn(async move {
+        let mut count = 0u64;
+
+        while let Ok(Message::Increment { old }) = rx.recv_async().await {
+            assert_eq!(old, count);
+            count += 1;
+        }
+
+        count
+    });
+
+    for next in 0..1_000_000 {
+        tx.send(Message::Increment { old: next }).unwrap();
+    }
+
+    tx.send(Message::ReturnCount).unwrap();
+
+    let count = t.await;
+    assert_eq!(count, 1_000_000)
+}
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn parallel_async_receivers() {
+    let (tx, rx) = flume::unbounded();
+    let send_fut = async move {
+        let n_sends: usize = 100000;
+        for _ in 0..n_sends {
+            tx.send_async(()).await.unwrap();
+        }
+    };
+
+    async_std::task::spawn(
+        send_fut
+            .timeout(Duration::from_secs(5))
+            .map_err(|_| panic!("Send timed out!"))
+    );
+
+    let mut futures_unordered = (0..250)
+        .map(|_| async {
+            while let Ok(()) = rx.recv_async().await
+            /* rx.recv() is OK */
+            {}
+        })
+        .collect::<FuturesUnordered<_>>();
+
+    let recv_fut = async {
+        while futures_unordered.next().await.is_some() {}
+    };
+
+    recv_fut
+        .timeout(Duration::from_secs(5))
+        .map_err(|_| panic!("Receive timed out!"))
+        .await
+        .unwrap();
+
+    println!("recv end");
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn change_waker() {
+    let (tx, rx) = flume::bounded(1);
+    tx.send(()).unwrap();
+
+    struct DebugWaker(Arc<AtomicUsize>, Waker);
+
+    impl DebugWaker {
+        fn new() -> Self {
+            let woken = Arc::new(AtomicUsize::new(0));
+            let woken_cloned = woken.clone();
+            let waker = waker_fn::waker_fn(move || {
+                woken.fetch_add(1, Ordering::SeqCst);
+            });
+            DebugWaker(woken_cloned, waker)
+        }
+
+        fn woken(&self) -> usize {
+            self.0.load(Ordering::SeqCst)
+        }
+
+        fn ctx(&self) -> Context {
+            Context::from_waker(&self.1)
+        }
+    }
+
+    // Check that the waker is correctly updated when sending tasks change their wakers
+    {
+        let send_fut = tx.send_async(());
+        futures::pin_mut!(send_fut);
+
+        let (waker1, waker2) = (DebugWaker::new(), DebugWaker::new());
+
+        // Set the waker to waker1
+        assert_eq!(send_fut.as_mut().poll(&mut waker1.ctx()), Poll::Pending);
+
+        // Change the waker to waker2
+        assert_eq!(send_fut.poll(&mut waker2.ctx()), Poll::Pending);
+
+        // Wake the future
+        rx.recv().unwrap();
+
+        // Check that waker2 was woken and waker1 was not
+        assert_eq!(waker1.woken(), 0);
+        assert_eq!(waker2.woken(), 1);
+    }
+
+    // Check that the waker is correctly updated when receiving tasks change their wakers
+    {
+        rx.recv().unwrap();
+        let recv_fut = rx.recv_async();
+        futures::pin_mut!(recv_fut);
+
+        let (waker1, waker2) = (DebugWaker::new(), DebugWaker::new());
+
+        // Set the waker to waker1
+        assert_eq!(recv_fut.as_mut().poll(&mut waker1.ctx()), Poll::Pending);
+
+        // Change the waker to waker2
+        assert_eq!(recv_fut.poll(&mut waker2.ctx()), Poll::Pending);
+
+        // Wake the future
+        tx.send(()).unwrap();
+
+        // Check that waker2 was woken and waker1 was not
+        assert_eq!(waker1.woken(), 0);
+        assert_eq!(waker2.woken(), 1);
+    }
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn spsc_single_threaded_value_ordering() {
+    async fn test() {
+        let (tx, rx) = flume::bounded(4);
+        tokio::select! {
+        _ = producer(tx) => {},
+        _ = consumer(rx) => {},
+    }
+    }
+
+    async fn producer(tx: flume::Sender<usize>) {
+        for i in 0..100 {
+            tx.send_async(i).await.unwrap();
+        }
+    }
+
+    async fn consumer(rx: flume::Receiver<usize>) {
+        let mut expected = 0;
+        while let Ok(value) = rx.recv_async().await {
+            assert_eq!(value, expected);
+            expected += 1;
+        }
+    }
+
+    let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
+    rt.block_on(test());
+}
diff --git a/vendor/flume/tests/basic.rs b/vendor/flume/tests/basic.rs
new file mode 100644
index 0000000..b937436
--- /dev/null
+++ b/vendor/flume/tests/basic.rs
@@ -0,0 +1,428 @@
+use std::time::{Instant, Duration};
+use flume::*;
+
+#[test]
+fn send_recv() {
+    let (tx, rx) = unbounded();
+    for i in 0..1000 { tx.send(i).unwrap(); }
+    for i in 0..1000 { assert_eq!(rx.try_recv().unwrap(), i); }
+    assert!(rx.try_recv().is_err());
+}
+
+#[test]
+fn iter() {
+    let (tx, rx) = unbounded();
+    for i in 0..1000 { tx.send(i).unwrap(); }
+    drop(tx);
+    assert_eq!(rx.iter().sum::<u32>(), (0..1000).sum());
+}
+
+#[test]
+fn try_iter() {
+    let (tx, rx) = unbounded();
+    for i in 0..1000 { tx.send(i).unwrap(); }
+    assert_eq!(rx.try_iter().sum::<u32>(), (0..1000).sum());
+}
+
+#[test]
+fn iter_threaded() {
+    let (tx, rx) = unbounded();
+    for i in 0..1000 {
+        let tx = tx.clone();
+        std::thread::spawn(move || tx.send(i).unwrap());
+    }
+    drop(tx);
+    assert_eq!(rx.iter().sum::<u32>(), (0..1000).sum());
+}
+
+#[cfg_attr(any(target_os = "macos", windows), ignore)] // FIXME #41
+#[test]
+fn send_timeout() {
+    let dur = Duration::from_millis(350);
+    let max_error = Duration::from_millis(5);
+    let dur_min = dur.checked_sub(max_error).unwrap();
+    let dur_max = dur.checked_add(max_error).unwrap();
+
+    let (tx, rx) = bounded(1);
+
+    assert!(tx.send_timeout(42, dur).is_ok());
+
+    let then = Instant::now();
+    assert!(tx.send_timeout(43, dur).is_err());
+    let now = Instant::now();
+
+    let this = now.duration_since(then);
+    if !(dur_min < this && this < dur_max) {
+        panic!("timeout exceeded: {:?}", this);
+    }
+
+    assert_eq!(rx.drain().count(), 1);
+
+    drop(rx);
+
+    assert!(tx.send_timeout(42, Duration::from_millis(350)).is_err());
+}
+
+#[cfg_attr(any(target_os = "macos", windows), ignore)] // FIXME #41
+#[test]
+fn recv_timeout() {
+    let dur = Duration::from_millis(350);
+    let max_error = Duration::from_millis(5);
+    let dur_min = dur.checked_sub(max_error).unwrap();
+    let dur_max = dur.checked_add(max_error).unwrap();
+
+    let (tx, rx) = unbounded();
+    let then = Instant::now();
+    assert!(rx.recv_timeout(dur).is_err());
+    let now = Instant::now();
+
+    let this = now.duration_since(then);
+    if !(dur_min < this && this < dur_max) {
+        panic!("timeout exceeded: {:?}", this);
+    }
+
+    tx.send(42).unwrap();
+    assert_eq!(rx.recv_timeout(dur), Ok(42));
+    assert!(Instant::now().duration_since(now) < max_error);
+}
+
+#[cfg_attr(any(target_os = "macos", windows), ignore)] // FIXME #41
+#[test]
+fn recv_deadline() {
+    let dur = Duration::from_millis(350);
+    let max_error = Duration::from_millis(5);
+    let dur_min = dur.checked_sub(max_error).unwrap();
+    let dur_max = dur.checked_add(max_error).unwrap();
+
+    let (tx, rx) = unbounded();
+    let then = Instant::now();
+    assert!(rx.recv_deadline(then.checked_add(dur).unwrap()).is_err());
+    let now = Instant::now();
+
+    let this = now.duration_since(then);
+    if !(dur_min < this && this < dur_max) {
+        panic!("timeout exceeded: {:?}", this);
+    }
+
+    tx.send(42).unwrap();
+    assert_eq!(rx.recv_deadline(now.checked_add(dur).unwrap()), Ok(42));
+    assert!(Instant::now().duration_since(now) < max_error);
+}
+
+#[test]
+fn recv_timeout_missed_send() {
+    let (tx, rx) = bounded(10);
+
+    assert!(rx.recv_timeout(Duration::from_millis(100)).is_err());
+
+    tx.send(42).unwrap();
+
+    assert_eq!(rx.recv(), Ok(42));
+}
+
+#[test]
+fn disconnect_tx() {
+    let (tx, rx) = unbounded::<()>();
+    drop(tx);
+    assert!(rx.recv().is_err());
+}
+
+#[test]
+fn disconnect_rx() {
+    let (tx, rx) = unbounded();
+    drop(rx);
+    assert!(tx.send(0).is_err());
+}
+
+#[test]
+fn drain() {
+    let (tx, rx) = unbounded();
+
+    for i in 0..100 {
+        tx.send(i).unwrap();
+    }
+
+    assert_eq!(rx.drain().sum::<u32>(), (0..100).sum());
+
+    for i in 0..100 {
+        tx.send(i).unwrap();
+    }
+
+    for i in 0..100 {
+        tx.send(i).unwrap();
+    }
+
+    rx.recv().unwrap();
+
+    (1u32..100).chain(0..100).zip(rx).for_each(|(l, r)| assert_eq!(l, r));
+}
+
+#[test]
+fn try_send() {
+    let (tx, rx) = bounded(5);
+
+    for i in 0..5 {
+        tx.try_send(i).unwrap();
+    }
+
+    assert!(tx.try_send(42).is_err());
+
+    assert_eq!(rx.recv(), Ok(0));
+
+    assert_eq!(tx.try_send(42), Ok(()));
+
+    assert_eq!(rx.recv(), Ok(1));
+    drop(rx);
+
+    assert!(tx.try_send(42).is_err());
+}
+
+#[test]
+fn send_bounded() {
+    let (tx, rx) = bounded(5);
+
+    for _ in 0..5 {
+        tx.send(42).unwrap();
+    }
+
+    let _ = rx.recv().unwrap();
+
+    tx.send(42).unwrap();
+
+    assert!(tx.try_send(42).is_err());
+
+    rx.drain();
+
+    let mut ts = Vec::new();
+    for _ in 0..100 {
+        let tx = tx.clone();
+        ts.push(std::thread::spawn(move || {
+            for i in 0..10000 {
+                tx.send(i).unwrap();
+            }
+        }));
+    }
+
+    drop(tx);
+
+    assert_eq!(rx.iter().sum::<u64>(), (0..10000).sum::<u64>() * 100);
+
+    for t in ts {
+        t.join().unwrap();
+    }
+
+    assert!(rx.recv().is_err());
+}
+
+#[test]
+fn rendezvous() {
+    let (tx, rx) = bounded(0);
+
+    for i in 0..5 {
+        let tx = tx.clone();
+        let t = std::thread::spawn(move || {
+            assert!(tx.try_send(()).is_err());
+
+            let then = Instant::now();
+            tx.send(()).unwrap();
+            let now = Instant::now();
+
+            assert!(now.duration_since(then) > Duration::from_millis(100), "iter = {}", i);
+        });
+
+        std::thread::sleep(Duration::from_millis(1000));
+        rx.recv().unwrap();
+
+        t.join().unwrap();
+    }
+}
+
+#[test]
+fn hydra() {
+    let thread_num = 32;
+    let msg_num = 1000;
+
+    let (main_tx, main_rx) = unbounded::<()>();
+
+    let mut txs = Vec::new();
+    for _ in 0..thread_num {
+        let main_tx = main_tx.clone();
+        let (tx, rx) = unbounded();
+        txs.push(tx);
+
+        std::thread::spawn(move || {
+            for msg in rx.iter() {
+                main_tx.send(msg).unwrap();
+            }
+        });
+    }
+
+    drop(main_tx);
+
+    for _ in 0..10 {
+        for tx in &txs {
+            for _ in 0..msg_num {
+                tx.send(Default::default()).unwrap();
+            }
+        }
+
+        for _ in 0..thread_num {
+            for _ in 0..msg_num {
+                main_rx.recv().unwrap();
+            }
+        }
+    }
+
+    drop(txs);
+    assert!(main_rx.recv().is_err());
+}
+
+#[test]
+fn robin() {
+    let thread_num = 32;
+    let msg_num = 10;
+
+    let (mut main_tx, main_rx) = bounded::<()>(1);
+
+    for _ in 0..thread_num {
+        let (mut tx, rx) = bounded(100);
+        std::mem::swap(&mut tx, &mut main_tx);
+
+        std::thread::spawn(move || {
+            for msg in rx.iter() {
+                tx.send(msg).unwrap();
+            }
+        });
+    }
+
+    for _ in 0..10 {
+        let main_tx = main_tx.clone();
+        std::thread::spawn(move || {
+            for _ in 0..msg_num {
+                main_tx.send(Default::default()).unwrap();
+            }
+        });
+
+        for _ in 0..msg_num {
+            main_rx.recv().unwrap();
+        }
+    }
+}
+
+#[cfg(feature = "select")]
+#[test]
+fn select_general() {
+    #[derive(Debug, PartialEq)]
+    struct Foo(usize);
+
+    let (tx0, rx0) = bounded(1);
+    let (tx1, rx1) = unbounded();
+
+    for (i, t) in vec![tx0.clone(), tx1].into_iter().enumerate() {
+        std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_millis(250));
+            let _ = t.send(Foo(i));
+        });
+    }
+
+    let x = Selector::new()
+        .recv(&rx0, |x| x)
+        .recv(&rx1, |x| x)
+        .wait()
+        .unwrap();
+
+    if x == Foo(0) {
+        assert!(rx1.recv().unwrap() == Foo(1));
+    } else {
+        assert!(rx0.recv().unwrap() == Foo(0));
+    }
+
+    tx0.send(Foo(42)).unwrap();
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(100));
+        assert_eq!(rx0.recv().unwrap(), Foo(42));
+        assert_eq!(rx0.recv().unwrap(), Foo(43));
+
+    });
+
+    Selector::new()
+        .send(&tx0, Foo(43), |x| x)
+        .wait()
+        .unwrap();
+
+    t.join().unwrap();
+}
+
+struct MessageWithoutDebug(u32);
+
+#[test]
+// This is a 'does it build' test, to make sure that the error types can turn
+// into a std::error::Error without requiring the payload (which is not used
+// there) to impl Debug.
+fn std_error_without_debug() {
+    let (tx, rx) = unbounded::<MessageWithoutDebug>();
+
+    match tx.send(MessageWithoutDebug(1)) {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+
+    match rx.recv() {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+
+    match tx.try_send(MessageWithoutDebug(2)) {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+
+    match rx.try_recv() {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+
+    match tx.send_timeout(MessageWithoutDebug(3), Duration::from_secs(1000000)) {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+
+    match rx.recv_timeout(Duration::from_secs(10000000)) {
+        Ok(_) => {}
+        Err(e) => {
+            let _std_err: &dyn std::error::Error = &e;
+        }
+    }
+}
+
+#[test]
+fn weak_close() {
+    let (tx, rx) = unbounded::<()>();
+    let weak = tx.downgrade();
+    drop(tx);
+    assert!(weak.upgrade().is_none());
+    assert!(rx.is_disconnected());
+    assert!(rx.try_recv().is_err());
+}
+
+#[test]
+fn weak_upgrade() {
+    let (tx, rx) = unbounded();
+    let weak = tx.downgrade();
+    let tx2 = weak.upgrade().unwrap();
+    drop(tx);
+    assert!(!rx.is_disconnected());
+    tx2.send(()).unwrap();
+    assert!(rx.try_recv().is_ok());
+}
diff --git a/vendor/flume/tests/check_same_channel.rs b/vendor/flume/tests/check_same_channel.rs
new file mode 100644
index 0000000..edb82c3
--- /dev/null
+++ b/vendor/flume/tests/check_same_channel.rs
@@ -0,0 +1,57 @@
+#[test]
+fn same_sender() {
+    let (tx1, _rx) = flume::unbounded::<()>();
+    let tx2 = tx1.clone();
+
+    assert!(tx1.same_channel(&tx2));
+
+    let (tx3, _rx) = flume::unbounded::<()>();
+
+    assert!(!tx1.same_channel(&tx3));
+    assert!(!tx2.same_channel(&tx3));
+}
+
+#[test]
+fn same_receiver() {
+    let (_tx, rx1) = flume::unbounded::<()>();
+    let rx2 = rx1.clone();
+
+    assert!(rx1.same_channel(&rx2));
+
+    let (_tx, rx3) = flume::unbounded::<()>();
+
+    assert!(!rx1.same_channel(&rx3));
+    assert!(!rx2.same_channel(&rx3));
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn same_send_sink() {
+    let (tx1, _rx) = flume::unbounded::<()>();
+    let tx1 = tx1.into_sink();
+    let tx2 = tx1.clone();
+
+    assert!(tx1.same_channel(&tx2));
+
+    let (tx3, _rx) = flume::unbounded::<()>();
+    let tx3 = tx3.into_sink();
+
+    assert!(!tx1.same_channel(&tx3));
+    assert!(!tx2.same_channel(&tx3));
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn same_recv_stream() {
+    let (_tx, rx1) = flume::unbounded::<()>();
+    let rx1 = rx1.into_stream();
+    let rx2 = rx1.clone();
+
+    assert!(rx1.same_channel(&rx2));
+
+    let (_tx, rx3) = flume::unbounded::<()>();
+    let rx3 = rx3.into_stream();
+
+    assert!(!rx1.same_channel(&rx3));
+    assert!(!rx2.same_channel(&rx3));
+}
diff --git a/vendor/flume/tests/golang.rs b/vendor/flume/tests/golang.rs
new file mode 100644
index 0000000..ca00840
--- /dev/null
+++ b/vendor/flume/tests/golang.rs
@@ -0,0 +1,1445 @@
+// //! Tests copied from Go and manually rewritten in Rust.
+// //!
+// //! Source:
+// //!   - https://github.com/golang/go
+// //!
+// //! Copyright & License:
+// //!   - Copyright (c) 2009 The Go Authors
+// //!   - https://golang.org/AUTHORS
+// //!   - https://golang.org/LICENSE
+// //!   - https://golang.org/PATENTS
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::collections::HashMap;
+// use std::sync::{Arc, Condvar, Mutex};
+// use std::thread;
+// use std::time::Duration;
+
+// use flume::{bounded, tick, Receiver, Select, Sender};
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// struct Chan<T> {
+//     inner: Arc<Mutex<ChanInner<T>>>,
+// }
+
+// struct ChanInner<T> {
+//     s: Option<Sender<T>>,
+//     r: Receiver<T>,
+// }
+
+// impl<T> Clone for Chan<T> {
+//     fn clone(&self) -> Chan<T> {
+//         Chan {
+//             inner: self.inner.clone(),
+//         }
+//     }
+// }
+
+// impl<T> Chan<T> {
+//     fn send(&self, msg: T) {
+//         let s = self
+//             .inner
+//             .lock()
+//             .unwrap()
+//             .s
+//             .as_ref()
+//             .expect("sending into closed channel")
+//             .clone();
+//         let _ = s.send(msg);
+//     }
+
+//     fn try_recv(&self) -> Option<T> {
+//         let r = self.inner.lock().unwrap().r.clone();
+//         r.try_recv().ok()
+//     }
+
+//     fn recv(&self) -> Option<T> {
+//         let r = self.inner.lock().unwrap().r.clone();
+//         r.recv().ok()
+//     }
+
+//     fn close(&self) {
+//         self.inner
+//             .lock()
+//             .unwrap()
+//             .s
+//             .take()
+//             .expect("channel already closed");
+//     }
+
+//     fn rx(&self) -> Receiver<T> {
+//         self.inner.lock().unwrap().r.clone()
+//     }
+
+//     fn tx(&self) -> Sender<T> {
+//         match self.inner.lock().unwrap().s.as_ref() {
+//             None => {
+//                 let (s, r) = bounded(0);
+//                 std::mem::forget(r);
+//                 s
+//             }
+//             Some(s) => s.clone(),
+//         }
+//     }
+// }
+
+// impl<T> Iterator for Chan<T> {
+//     type Item = T;
+
+//     fn next(&mut self) -> Option<Self::Item> {
+//         self.recv()
+//     }
+// }
+
+// impl<'a, T> IntoIterator for &'a Chan<T> {
+//     type Item = T;
+//     type IntoIter = Chan<T>;
+
+//     fn into_iter(self) -> Self::IntoIter {
+//         self.clone()
+//     }
+// }
+
+// fn make<T>(cap: usize) -> Chan<T> {
+//     let (s, r) = bounded(cap);
+//     Chan {
+//         inner: Arc::new(Mutex::new(ChanInner { s: Some(s), r })),
+//     }
+// }
+
+// #[derive(Clone)]
+// struct WaitGroup(Arc<WaitGroupInner>);
+
+// struct WaitGroupInner {
+//     cond: Condvar,
+//     count: Mutex<i32>,
+// }
+
+// impl WaitGroup {
+//     fn new() -> WaitGroup {
+//         WaitGroup(Arc::new(WaitGroupInner {
+//             cond: Condvar::new(),
+//             count: Mutex::new(0),
+//         }))
+//     }
+
+//     fn add(&self, delta: i32) {
+//         let mut count = self.0.count.lock().unwrap();
+//         *count += delta;
+//         assert!(*count >= 0);
+//         self.0.cond.notify_all();
+//     }
+
+//     fn done(&self) {
+//         self.add(-1);
+//     }
+
+//     fn wait(&self) {
+//         let mut count = self.0.count.lock().unwrap();
+//         while *count > 0 {
+//             count = self.0.cond.wait(count).unwrap();
+//         }
+//     }
+// }
+
+// struct Defer<F: FnOnce()> {
+//     f: Option<Box<F>>,
+// }
+
+// impl<F: FnOnce()> Drop for Defer<F> {
+//     fn drop(&mut self) {
+//         let f = self.f.take().unwrap();
+//         let mut f = Some(f);
+//         let mut f = move || f.take().unwrap()();
+//         f();
+//     }
+// }
+
+// macro_rules! defer {
+//     ($body:expr) => {
+//         let _defer = Defer {
+//             f: Some(Box::new(|| $body)),
+//         };
+//     };
+// }
+
+// macro_rules! go {
+//     (@parse ref $v:ident, $($tail:tt)*) => {{
+//         let ref $v = $v;
+//         go!(@parse $($tail)*)
+//     }};
+//     (@parse move $v:ident, $($tail:tt)*) => {{
+//         let $v = $v;
+//         go!(@parse $($tail)*)
+//     }};
+//     (@parse $v:ident, $($tail:tt)*) => {{
+//         let $v = $v.clone();
+//         go!(@parse $($tail)*)
+//     }};
+//     (@parse $body:expr) => {
+//         ::std::thread::spawn(move || {
+//             let res = ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| {
+//                 $body
+//             }));
+//             if res.is_err() {
+//                 eprintln!("goroutine panicked: {:?}", res);
+//                 ::std::process::abort();
+//             }
+//         })
+//     };
+//     (@parse $($tail:tt)*) => {
+//         compile_error!("invalid `go!` syntax")
+//     };
+//     ($($tail:tt)*) => {{
+//         go!(@parse $($tail)*)
+//     }};
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/doubleselect.go
+// mod doubleselect {
+//     use super::*;
+
+//     const ITERATIONS: i32 = 10_000;
+
+//     fn sender(n: i32, c1: Chan<i32>, c2: Chan<i32>, c3: Chan<i32>, c4: Chan<i32>) {
+//         defer! { c1.close() }
+//         defer! { c2.close() }
+//         defer! { c3.close() }
+//         defer! { c4.close() }
+
+//         for i in 0..n {
+//             select! {
+//                 send(c1.tx(), i) -> _ => {}
+//                 send(c2.tx(), i) -> _ => {}
+//                 send(c3.tx(), i) -> _ => {}
+//                 send(c4.tx(), i) -> _ => {}
+//             }
+//         }
+//     }
+
+//     fn mux(out: Chan<i32>, inp: Chan<i32>, done: Chan<bool>) {
+//         for v in inp {
+//             out.send(v);
+//         }
+//         done.send(true);
+//     }
+
+//     fn recver(inp: Chan<i32>) {
+//         let mut seen = HashMap::new();
+
+//         for v in &inp {
+//             if seen.contains_key(&v) {
+//                 panic!("got duplicate value for {}", v);
+//             }
+//             seen.insert(v, true);
+//         }
+//     }
+
+//     #[test]
+//     fn main() {
+//         let c1 = make::<i32>(0);
+//         let c2 = make::<i32>(0);
+//         let c3 = make::<i32>(0);
+//         let c4 = make::<i32>(0);
+//         let done = make::<bool>(0);
+//         let cmux = make::<i32>(0);
+
+//         go!(c1, c2, c3, c4, sender(ITERATIONS, c1, c2, c3, c4));
+//         go!(cmux, c1, done, mux(cmux, c1, done));
+//         go!(cmux, c2, done, mux(cmux, c2, done));
+//         go!(cmux, c3, done, mux(cmux, c3, done));
+//         go!(cmux, c4, done, mux(cmux, c4, done));
+//         go!(done, cmux, {
+//             done.recv();
+//             done.recv();
+//             done.recv();
+//             done.recv();
+//             cmux.close();
+//         });
+//         recver(cmux);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/fifo.go
+// mod fifo {
+//     use super::*;
+
+//     const N: i32 = 10;
+
+//     #[test]
+//     fn asynch_fifo() {
+//         let ch = make::<i32>(N as usize);
+//         for i in 0..N {
+//             ch.send(i);
+//         }
+//         for i in 0..N {
+//             if ch.recv() != Some(i) {
+//                 panic!("bad receive");
+//             }
+//         }
+//     }
+
+//     fn chain(ch: Chan<i32>, val: i32, inp: Chan<i32>, out: Chan<i32>) {
+//         inp.recv();
+//         if ch.recv() != Some(val) {
+//             panic!(val);
+//         }
+//         out.send(1);
+//     }
+
+//     #[test]
+//     fn synch_fifo() {
+//         let ch = make::<i32>(0);
+//         let mut inp = make::<i32>(0);
+//         let start = inp.clone();
+
+//         for i in 0..N {
+//             let out = make::<i32>(0);
+//             go!(ch, i, inp, out, chain(ch, i, inp, out));
+//             inp = out;
+//         }
+
+//         start.send(0);
+//         for i in 0..N {
+//             ch.send(i);
+//         }
+//         inp.recv();
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/goroutines.go
+// mod goroutines {
+//     use super::*;
+
+//     fn f(left: Chan<i32>, right: Chan<i32>) {
+//         left.send(right.recv().unwrap());
+//     }
+
+//     #[test]
+//     fn main() {
+//         let n = 100i32;
+
+//         let leftmost = make::<i32>(0);
+//         let mut right = leftmost.clone();
+//         let mut left = leftmost.clone();
+
+//         for _ in 0..n {
+//             right = make::<i32>(0);
+//             go!(left, right, f(left, right));
+//             left = right.clone();
+//         }
+
+//         go!(right, right.send(1));
+//         leftmost.recv().unwrap();
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/nonblock.go
+// mod nonblock {
+//     use super::*;
+
+//     fn i32receiver(c: Chan<i32>, strobe: Chan<bool>) {
+//         if c.recv().unwrap() != 123 {
+//             panic!("i32 value");
+//         }
+//         strobe.send(true);
+//     }
+
+//     fn i32sender(c: Chan<i32>, strobe: Chan<bool>) {
+//         c.send(234);
+//         strobe.send(true);
+//     }
+
+//     fn i64receiver(c: Chan<i64>, strobe: Chan<bool>) {
+//         if c.recv().unwrap() != 123456 {
+//             panic!("i64 value");
+//         }
+//         strobe.send(true);
+//     }
+
+//     fn i64sender(c: Chan<i64>, strobe: Chan<bool>) {
+//         c.send(234567);
+//         strobe.send(true);
+//     }
+
+//     fn breceiver(c: Chan<bool>, strobe: Chan<bool>) {
+//         if !c.recv().unwrap() {
+//             panic!("b value");
+//         }
+//         strobe.send(true);
+//     }
+
+//     fn bsender(c: Chan<bool>, strobe: Chan<bool>) {
+//         c.send(true);
+//         strobe.send(true);
+//     }
+
+//     fn sreceiver(c: Chan<String>, strobe: Chan<bool>) {
+//         if c.recv().unwrap() != "hello" {
+//             panic!("x value");
+//         }
+//         strobe.send(true);
+//     }
+
+//     fn ssender(c: Chan<String>, strobe: Chan<bool>) {
+//         c.send("hello again".to_string());
+//         strobe.send(true);
+//     }
+
+//     const MAX_TRIES: usize = 10000; // Up to 100ms per test.
+
+//     #[test]
+//     fn main() {
+//         let ticker = tick(Duration::new(0, 10_000)); // 10 us
+//         let sleep = || {
+//             ticker.recv().unwrap();
+//             ticker.recv().unwrap();
+//             thread::yield_now();
+//             thread::yield_now();
+//             thread::yield_now();
+//         };
+
+//         let sync = make::<bool>(0);
+
+//         for buffer in 0..2 {
+//             let c32 = make::<i32>(buffer);
+//             let c64 = make::<i64>(buffer);
+//             let cb = make::<bool>(buffer);
+//             let cs = make::<String>(buffer);
+
+//             select! {
+//                 recv(c32.rx()) -> _ => panic!("blocked i32sender"),
+//                 default => {}
+//             }
+
+//             select! {
+//                 recv(c64.rx()) -> _ => panic!("blocked i64sender"),
+//                 default => {}
+//             }
+
+//             select! {
+//                 recv(cb.rx()) -> _ => panic!("blocked bsender"),
+//                 default => {}
+//             }
+
+//             select! {
+//                 recv(cs.rx()) -> _ => panic!("blocked ssender"),
+//                 default => {}
+//             }
+
+//             go!(c32, sync, i32receiver(c32, sync));
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     send(c32.tx(), 123) -> _ => break,
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("i32receiver buffer={}", buffer);
+//                             panic!("fail")
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             sync.recv();
+//             go!(c32, sync, i32sender(c32, sync));
+//             if buffer > 0 {
+//                 sync.recv();
+//             }
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     recv(c32.rx()) -> v => {
+//                         if v != Ok(234) {
+//                             panic!("i32sender value");
+//                         }
+//                         break;
+//                     }
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("i32sender buffer={}", buffer);
+//                             panic!("fail");
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             if buffer == 0 {
+//                 sync.recv();
+//             }
+
+//             go!(c64, sync, i64receiver(c64, sync));
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     send(c64.tx(), 123456) -> _ => break,
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("i64receiver buffer={}", buffer);
+//                             panic!("fail")
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             sync.recv();
+//             go!(c64, sync, i64sender(c64, sync));
+//             if buffer > 0 {
+//                 sync.recv();
+//             }
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     recv(c64.rx()) -> v => {
+//                         if v != Ok(234567) {
+//                             panic!("i64sender value");
+//                         }
+//                         break;
+//                     }
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("i64sender buffer={}", buffer);
+//                             panic!("fail");
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             if buffer == 0 {
+//                 sync.recv();
+//             }
+
+//             go!(cb, sync, breceiver(cb, sync));
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     send(cb.tx(), true) -> _ => break,
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("breceiver buffer={}", buffer);
+//                             panic!("fail")
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             sync.recv();
+//             go!(cb, sync, bsender(cb, sync));
+//             if buffer > 0 {
+//                 sync.recv();
+//             }
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     recv(cb.rx()) -> v => {
+//                         if v != Ok(true) {
+//                             panic!("bsender value");
+//                         }
+//                         break;
+//                     }
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("bsender buffer={}", buffer);
+//                             panic!("fail");
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             if buffer == 0 {
+//                 sync.recv();
+//             }
+
+//             go!(cs, sync, sreceiver(cs, sync));
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     send(cs.tx(), "hello".to_string()) -> _ => break,
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("sreceiver buffer={}", buffer);
+//                             panic!("fail")
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             sync.recv();
+//             go!(cs, sync, ssender(cs, sync));
+//             if buffer > 0 {
+//                 sync.recv();
+//             }
+//             let mut try = 0;
+//             loop {
+//                 select! {
+//                     recv(cs.rx()) -> v => {
+//                         if v != Ok("hello again".to_string()) {
+//                             panic!("ssender value");
+//                         }
+//                         break;
+//                     }
+//                     default => {
+//                         try += 1;
+//                         if try > MAX_TRIES {
+//                             println!("ssender buffer={}", buffer);
+//                             panic!("fail");
+//                         }
+//                         sleep();
+//                     }
+//                 }
+//             }
+//             if buffer == 0 {
+//                 sync.recv();
+//             }
+//         }
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select.go
+// mod select {
+//     use super::*;
+
+//     #[test]
+//     fn main() {
+//         let shift = Cell::new(0);
+//         let counter = Cell::new(0);
+
+//         let get_value = || {
+//             counter.set(counter.get() + 1);
+//             1 << shift.get()
+//         };
+
+//         let send = |mut a: Option<&Chan<u32>>, mut b: Option<&Chan<u32>>| {
+//             let mut i = 0;
+//             let never = make::<u32>(0);
+//             loop {
+//                 let nil1 = never.tx();
+//                 let nil2 = never.tx();
+//                 let v1 = get_value();
+//                 let v2 = get_value();
+//                 select! {
+//                     send(a.map(|c| c.tx()).unwrap_or(nil1), v1) -> _ => {
+//                         i += 1;
+//                         a = None;
+//                     }
+//                     send(b.map(|c| c.tx()).unwrap_or(nil2), v2) -> _ => {
+//                         i += 1;
+//                         b = None;
+//                     }
+//                     default => break,
+//                 }
+//                 shift.set(shift.get() + 1);
+//             }
+//             i
+//         };
+
+//         let a = make::<u32>(1);
+//         let b = make::<u32>(1);
+
+//         assert_eq!(send(Some(&a), Some(&b)), 2);
+
+//         let av = a.recv().unwrap();
+//         let bv = b.recv().unwrap();
+//         assert_eq!(av | bv, 3);
+
+//         assert_eq!(send(Some(&a), None), 1);
+//         assert_eq!(counter.get(), 10);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select2.go
+// mod select2 {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select3.go
+// mod select3 {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select4.go
+// mod select4 {
+//     use super::*;
+
+//     #[test]
+//     fn main() {
+//         let c = make::<i32>(1);
+//         let c1 = make::<i32>(0);
+//         c.send(42);
+//         select! {
+//             recv(c1.rx()) -> _ => panic!("BUG"),
+//             recv(c.rx()) -> v => assert_eq!(v, Ok(42)),
+//         }
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select6.go
+// mod select6 {
+//     use super::*;
+
+//     #[test]
+//     fn main() {
+//         let c1 = make::<bool>(0);
+//         let c2 = make::<bool>(0);
+//         let c3 = make::<bool>(0);
+
+//         go!(c1, c1.recv());
+//         go!(c1, c2, c3, {
+//             select! {
+//                 recv(c1.rx()) -> _ => panic!("dummy"),
+//                 recv(c2.rx()) -> _ => c3.send(true),
+//             }
+//             c1.recv();
+//         });
+//         go!(c2, c2.send(true));
+
+//         c3.recv();
+//         c1.send(true);
+//         c1.send(true);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/select7.go
+// mod select7 {
+//     use super::*;
+
+//     fn recv1(c: Chan<i32>) {
+//         c.recv().unwrap();
+//     }
+
+//     fn recv2(c: Chan<i32>) {
+//         select! {
+//             recv(c.rx()) -> _ => ()
+//         }
+//     }
+
+//     fn recv3(c: Chan<i32>) {
+//         let c2 = make::<i32>(1);
+//         select! {
+//             recv(c.rx()) -> _ => (),
+//             recv(c2.rx()) -> _ => ()
+//         }
+//     }
+
+//     fn send1(recv: fn(Chan<i32>)) {
+//         let c = make::<i32>(1);
+//         go!(c, recv(c));
+//         thread::yield_now();
+//         c.send(1);
+//     }
+
+//     fn send2(recv: fn(Chan<i32>)) {
+//         let c = make::<i32>(1);
+//         go!(c, recv(c));
+//         thread::yield_now();
+//         select! {
+//             send(c.tx(), 1) -> _ => ()
+//         }
+//     }
+
+//     fn send3(recv: fn(Chan<i32>)) {
+//         let c = make::<i32>(1);
+//         go!(c, recv(c));
+//         thread::yield_now();
+//         let c2 = make::<i32>(1);
+//         select! {
+//             send(c.tx(), 1) -> _ => (),
+//             send(c2.tx(), 1) -> _ => ()
+//         }
+//     }
+
+//     #[test]
+//     fn main() {
+//         send1(recv1);
+//         send2(recv1);
+//         send3(recv1);
+//         send1(recv2);
+//         send2(recv2);
+//         send3(recv2);
+//         send1(recv3);
+//         send2(recv3);
+//         send3(recv3);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/sieve1.go
+// mod sieve1 {
+//     use super::*;
+
+//     fn generate(ch: Chan<i32>) {
+//         let mut i = 2;
+//         loop {
+//             ch.send(i);
+//             i += 1;
+//         }
+//     }
+
+//     fn filter(in_ch: Chan<i32>, out_ch: Chan<i32>, prime: i32) {
+//         for i in in_ch {
+//             if i % prime != 0 {
+//                 out_ch.send(i);
+//             }
+//         }
+//     }
+
+//     fn sieve(primes: Chan<i32>) {
+//         let mut ch = make::<i32>(1);
+//         go!(ch, generate(ch));
+//         loop {
+//             let prime = ch.recv().unwrap();
+//             primes.send(prime);
+
+//             let ch1 = make::<i32>(1);
+//             go!(ch, ch1, prime, filter(ch, ch1, prime));
+//             ch = ch1;
+//         }
+//     }
+
+//     #[test]
+//     fn main() {
+//         let primes = make::<i32>(1);
+//         go!(primes, sieve(primes));
+
+//         let a = [
+//             2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
+//             89, 97,
+//         ];
+//         for item in a.iter() {
+//             let x = primes.recv().unwrap();
+//             if x != *item {
+//                 println!("{} != {}", x, item);
+//                 panic!("fail");
+//             }
+//         }
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/chan/zerosize.go
+// mod zerosize {
+//     use super::*;
+
+//     #[test]
+//     fn zero_size_struct() {
+//         struct ZeroSize;
+//         let _ = make::<ZeroSize>(0);
+//     }
+
+//     #[test]
+//     fn zero_size_array() {
+//         let _ = make::<[u8; 0]>(0);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/src/runtime/chan_test.go
+// mod chan_test {
+//     use super::*;
+
+//     #[test]
+//     fn test_chan() {
+//         const N: i32 = 200;
+
+//         for cap in 0..N {
+//             {
+//                 // Ensure that receive from empty chan blocks.
+//                 let c = make::<i32>(cap as usize);
+
+//                 let recv1 = Arc::new(Mutex::new(false));
+//                 go!(c, recv1, {
+//                     c.recv();
+//                     *recv1.lock().unwrap() = true;
+//                 });
+
+//                 let recv2 = Arc::new(Mutex::new(false));
+//                 go!(c, recv2, {
+//                     c.recv();
+//                     *recv2.lock().unwrap() = true;
+//                 });
+
+//                 thread::sleep(ms(1));
+
+//                 if *recv1.lock().unwrap() || *recv2.lock().unwrap() {
+//                     panic!();
+//                 }
+
+//                 // Ensure that non-blocking receive does not block.
+//                 select! {
+//                     recv(c.rx()) -> _ => panic!(),
+//                     default => {}
+//                 }
+//                 select! {
+//                     recv(c.rx()) -> _ => panic!(),
+//                     default => {}
+//                 }
+
+//                 c.send(0);
+//                 c.send(0);
+//             }
+
+//             {
+//                 // Ensure that send to full chan blocks.
+//                 let c = make::<i32>(cap as usize);
+//                 for i in 0..cap {
+//                     c.send(i);
+//                 }
+
+//                 let sent = Arc::new(Mutex::new(0));
+//                 go!(sent, c, {
+//                     c.send(0);
+//                     *sent.lock().unwrap() = 1;
+//                 });
+
+//                 thread::sleep(ms(1));
+
+//                 if *sent.lock().unwrap() != 0 {
+//                     panic!();
+//                 }
+
+//                 // Ensure that non-blocking send does not block.
+//                 select! {
+//                     send(c.tx(), 0) -> _ => panic!(),
+//                     default => {}
+//                 }
+//                 c.recv();
+//             }
+
+//             {
+//                 // Ensure that we receive 0 from closed chan.
+//                 let c = make::<i32>(cap as usize);
+//                 for i in 0..cap {
+//                     c.send(i);
+//                 }
+//                 c.close();
+
+//                 for i in 0..cap {
+//                     let v = c.recv();
+//                     if v != Some(i) {
+//                         panic!();
+//                     }
+//                 }
+
+//                 if c.recv() != None {
+//                     panic!();
+//                 }
+//                 if c.try_recv() != None {
+//                     panic!();
+//                 }
+//             }
+
+//             {
+//                 // Ensure that close unblocks receive.
+//                 let c = make::<i32>(cap as usize);
+//                 let done = make::<bool>(0);
+
+//                 go!(c, done, {
+//                     let v = c.try_recv();
+//                     done.send(v.is_some());
+//                 });
+
+//                 thread::sleep(ms(1));
+//                 c.close();
+
+//                 if !done.recv().unwrap() {
+//                     // panic!();
+//                 }
+//             }
+
+//             {
+//                 // Send 100 integers,
+//                 // ensure that we receive them non-corrupted in FIFO order.
+//                 let c = make::<i32>(cap as usize);
+//                 go!(c, {
+//                     for i in 0..100 {
+//                         c.send(i);
+//                     }
+//                 });
+//                 for i in 0..100 {
+//                     if c.recv() != Some(i) {
+//                         panic!();
+//                     }
+//                 }
+
+//                 // Same, but using recv2.
+//                 go!(c, {
+//                     for i in 0..100 {
+//                         c.send(i);
+//                     }
+//                 });
+//                 for i in 0..100 {
+//                     if c.recv() != Some(i) {
+//                         panic!();
+//                     }
+//                 }
+//             }
+//         }
+//     }
+
+//     #[test]
+//     fn test_nonblock_recv_race() {
+//         const N: usize = 1000;
+
+//         for _ in 0..N {
+//             let c = make::<i32>(1);
+//             c.send(1);
+
+//             let t = go!(c, {
+//                 select! {
+//                     recv(c.rx()) -> _ => {}
+//                     default => panic!("chan is not ready"),
+//                 }
+//             });
+
+//             c.close();
+//             c.recv();
+//             t.join().unwrap();
+//         }
+//     }
+
+//     #[test]
+//     fn test_nonblock_select_race() {
+//         const N: usize = 1000;
+
+//         let done = make::<bool>(1);
+//         for _ in 0..N {
+//             let c1 = make::<i32>(1);
+//             let c2 = make::<i32>(1);
+//             c1.send(1);
+
+//             go!(c1, c2, done, {
+//                 select! {
+//                     recv(c1.rx()) -> _ => {}
+//                     recv(c2.rx()) -> _ => {}
+//                     default => {
+//                         done.send(false);
+//                         return;
+//                     }
+//                 }
+//                 done.send(true);
+//             });
+
+//             c2.send(1);
+//             select! {
+//                 recv(c1.rx()) -> _ => {}
+//                 default => {}
+//             }
+//             if !done.recv().unwrap() {
+//                 panic!("no chan is ready");
+//             }
+//         }
+//     }
+
+//     #[test]
+//     fn test_nonblock_select_race2() {
+//         const N: usize = 1000;
+
+//         let done = make::<bool>(1);
+//         for _ in 0..N {
+//             let c1 = make::<i32>(1);
+//             let c2 = make::<i32>(0);
+//             c1.send(1);
+
+//             go!(c1, c2, done, {
+//                 select! {
+//                     recv(c1.rx()) -> _ => {}
+//                     recv(c2.rx()) -> _ => {}
+//                     default => {
+//                         done.send(false);
+//                         return;
+//                     }
+//                 }
+//                 done.send(true);
+//             });
+
+//             c2.close();
+//             select! {
+//                 recv(c1.rx()) -> _ => {}
+//                 default => {}
+//             }
+//             if !done.recv().unwrap() {
+//                 panic!("no chan is ready");
+//             }
+//         }
+//     }
+
+//     #[test]
+//     fn test_self_select() {
+//         // Ensure that send/recv on the same chan in select
+//         // does not crash nor deadlock.
+
+//         for &cap in &[0, 10] {
+//             let wg = WaitGroup::new();
+//             wg.add(2);
+//             let c = make::<i32>(cap);
+
+//             for p in 0..2 {
+//                 let p = p;
+//                 go!(wg, p, c, {
+//                     defer! { wg.done() }
+//                     for i in 0..1000 {
+//                         if p == 0 || i % 2 == 0 {
+//                             select! {
+//                                 send(c.tx(), p) -> _ => {}
+//                                 recv(c.rx()) -> v => {
+//                                     if cap == 0 && v.ok() == Some(p) {
+//                                         panic!("self receive");
+//                                     }
+//                                 }
+//                             }
+//                         } else {
+//                             select! {
+//                                 recv(c.rx()) -> v => {
+//                                     if cap == 0 && v.ok() == Some(p) {
+//                                         panic!("self receive");
+//                                     }
+//                                 }
+//                                 send(c.tx(), p) -> _ => {}
+//                             }
+//                         }
+//                     }
+//                 });
+//             }
+//             wg.wait();
+//         }
+//     }
+
+//     #[test]
+//     fn test_select_stress() {
+//         let c = vec![
+//             make::<i32>(0),
+//             make::<i32>(0),
+//             make::<i32>(2),
+//             make::<i32>(3),
+//         ];
+
+//         const N: usize = 10000;
+
+//         // There are 4 goroutines that send N values on each of the chans,
+//         // + 4 goroutines that receive N values on each of the chans,
+//         // + 1 goroutine that sends N values on each of the chans in a single select,
+//         // + 1 goroutine that receives N values on each of the chans in a single select.
+//         // All these sends, receives and selects interact chaotically at runtime,
+//         // but we are careful that this whole construct does not deadlock.
+//         let wg = WaitGroup::new();
+//         wg.add(10);
+
+//         for k in 0..4 {
+//             go!(k, c, wg, {
+//                 for _ in 0..N {
+//                     c[k].send(0);
+//                 }
+//                 wg.done();
+//             });
+//             go!(k, c, wg, {
+//                 for _ in 0..N {
+//                     c[k].recv();
+//                 }
+//                 wg.done();
+//             });
+//         }
+
+//         go!(c, wg, {
+//             let mut n = [0; 4];
+//             let mut c1 = c.iter().map(|c| Some(c.rx().clone())).collect::<Vec<_>>();
+
+//             for _ in 0..4 * N {
+//                 let index = {
+//                     let mut sel = Select::new();
+//                     let mut opers = [!0; 4];
+//                     for &i in &[3, 2, 0, 1] {
+//                         if let Some(c) = &c1[i] {
+//                             opers[i] = sel.recv(c);
+//                         }
+//                     }
+
+//                     let oper = sel.select();
+//                     let mut index = !0;
+//                     for i in 0..4 {
+//                         if opers[i] == oper.index() {
+//                             index = i;
+//                             let _ = oper.recv(c1[i].as_ref().unwrap());
+//                             break;
+//                         }
+//                     }
+//                     index
+//                 };
+
+//                 n[index] += 1;
+//                 if n[index] == N {
+//                     c1[index] = None;
+//                 }
+//             }
+//             wg.done();
+//         });
+
+//         go!(c, wg, {
+//             let mut n = [0; 4];
+//             let mut c1 = c.iter().map(|c| Some(c.tx().clone())).collect::<Vec<_>>();
+
+//             for _ in 0..4 * N {
+//                 let index = {
+//                     let mut sel = Select::new();
+//                     let mut opers = [!0; 4];
+//                     for &i in &[0, 1, 2, 3] {
+//                         if let Some(c) = &c1[i] {
+//                             opers[i] = sel.send(c);
+//                         }
+//                     }
+
+//                     let oper = sel.select();
+//                     let mut index = !0;
+//                     for i in 0..4 {
+//                         if opers[i] == oper.index() {
+//                             index = i;
+//                             let _ = oper.send(c1[i].as_ref().unwrap(), 0);
+//                             break;
+//                         }
+//                     }
+//                     index
+//                 };
+
+//                 n[index] += 1;
+//                 if n[index] == N {
+//                     c1[index] = None;
+//                 }
+//             }
+//             wg.done();
+//         });
+
+//         wg.wait();
+//     }
+
+//     #[test]
+//     fn test_select_fairness() {
+//         const TRIALS: usize = 10000;
+
+//         let c1 = make::<u8>(TRIALS + 1);
+//         let c2 = make::<u8>(TRIALS + 1);
+
+//         for _ in 0..TRIALS + 1 {
+//             c1.send(1);
+//             c2.send(2);
+//         }
+
+//         let c3 = make::<u8>(0);
+//         let c4 = make::<u8>(0);
+//         let out = make::<u8>(0);
+//         let done = make::<u8>(0);
+//         let wg = WaitGroup::new();
+
+//         wg.add(1);
+//         go!(wg, c1, c2, c3, c4, out, done, {
+//             defer! { wg.done() };
+//             loop {
+//                 let b;
+//                 select! {
+//                     recv(c3.rx()) -> m => b = m.unwrap(),
+//                     recv(c4.rx()) -> m => b = m.unwrap(),
+//                     recv(c1.rx()) -> m => b = m.unwrap(),
+//                     recv(c2.rx()) -> m => b = m.unwrap(),
+//                 }
+//                 select! {
+//                     send(out.tx(), b) -> _ => {}
+//                     recv(done.rx()) -> _ => return,
+//                 }
+//             }
+//         });
+
+//         let (mut cnt1, mut cnt2) = (0, 0);
+//         for _ in 0..TRIALS {
+//             match out.recv() {
+//                 Some(1) => cnt1 += 1,
+//                 Some(2) => cnt2 += 1,
+//                 b => panic!("unexpected value {:?} on channel", b),
+//             }
+//         }
+
+//         // If the select in the goroutine is fair,
+//         // cnt1 and cnt2 should be about the same value.
+//         // With 10,000 trials, the expected margin of error at
+//         // a confidence level of five nines is 4.4172 / (2 * Sqrt(10000)).
+
+//         let r = cnt1 as f64 / TRIALS as f64;
+//         let e = (r - 0.5).abs();
+
+//         if e > 4.4172 / (2.0 * (TRIALS as f64).sqrt()) {
+//             panic!(
+//                 "unfair select: in {} trials, results were {}, {}",
+//                 TRIALS, cnt1, cnt2,
+//             );
+//         }
+
+//         done.close();
+//         wg.wait();
+//     }
+
+//     #[test]
+//     fn test_chan_send_interface() {
+//         struct Mt;
+
+//         let c = make::<Box<dyn Any>>(1);
+//         c.send(Box::new(Mt));
+
+//         select! {
+//             send(c.tx(), Box::new(Mt)) -> _ => {}
+//             default => {}
+//         }
+
+//         select! {
+//             send(c.tx(), Box::new(Mt)) -> _ => {}
+//             send(c.tx(), Box::new(Mt)) -> _ => {}
+//             default => {}
+//         }
+//     }
+
+//     #[test]
+//     fn test_pseudo_random_send() {
+//         const N: usize = 100;
+
+//         for cap in 0..N {
+//             let c = make::<i32>(cap);
+//             let l = Arc::new(Mutex::new(vec![0i32; N]));
+//             let done = make::<bool>(0);
+
+//             go!(c, done, l, {
+//                 let mut l = l.lock().unwrap();
+//                 for i in 0..N {
+//                     thread::yield_now();
+//                     l[i] = c.recv().unwrap();
+//                 }
+//                 done.send(true);
+//             });
+
+//             for _ in 0..N {
+//                 select! {
+//                     send(c.tx(), 1) -> _ => {}
+//                     send(c.tx(), 0) -> _ => {}
+//                 }
+//             }
+//             done.recv();
+
+//             let mut n0 = 0;
+//             let mut n1 = 0;
+//             for &i in l.lock().unwrap().iter() {
+//                 n0 += (i + 1) % 2;
+//                 n1 += i;
+//             }
+
+//             if n0 <= N as i32 / 10 || n1 <= N as i32 / 10 {
+//                 panic!(
+//                     "Want pseudorandom, got {} zeros and {} ones (chan cap {})",
+//                     n0, n1, cap,
+//                 );
+//             }
+//         }
+//     }
+
+//     #[test]
+//     fn test_multi_consumer() {
+//         const NWORK: usize = 23;
+//         const NITER: usize = 271828;
+
+//         let pn = [2, 3, 7, 11, 13, 17, 19, 23, 27, 31];
+
+//         let q = make::<i32>(NWORK * 3);
+//         let r = make::<i32>(NWORK * 3);
+
+//         let wg = WaitGroup::new();
+//         for i in 0..NWORK {
+//             wg.add(1);
+//             let w = i;
+//             go!(q, r, wg, pn, {
+//                 for v in &q {
+//                     if pn[w % pn.len()] == v {
+//                         thread::yield_now();
+//                     }
+//                     r.send(v);
+//                 }
+//                 wg.done();
+//             });
+//         }
+
+//         let expect = Arc::new(Mutex::new(0));
+//         go!(q, r, expect, wg, pn, {
+//             for i in 0..NITER {
+//                 let v = pn[i % pn.len()];
+//                 *expect.lock().unwrap() += v;
+//                 q.send(v);
+//             }
+//             q.close();
+//             wg.wait();
+//             r.close();
+//         });
+
+//         let mut n = 0;
+//         let mut s = 0;
+//         for v in &r {
+//             n += 1;
+//             s += v;
+//         }
+
+//         if n != NITER || s != *expect.lock().unwrap() {
+//             panic!();
+//         }
+//     }
+
+//     #[test]
+//     fn test_select_duplicate_channel() {
+//         // This test makes sure we can queue a G on
+//         // the same channel multiple times.
+//         let c = make::<i32>(0);
+//         let d = make::<i32>(0);
+//         let e = make::<i32>(0);
+
+//         go!(c, d, e, {
+//             select! {
+//                 recv(c.rx()) -> _ => {}
+//                 recv(d.rx()) -> _ => {}
+//                 recv(e.rx()) -> _ => {}
+//             }
+//             e.send(9);
+//         });
+//         thread::sleep(ms(1));
+
+//         go!(c, c.recv());
+//         thread::sleep(ms(1));
+
+//         d.send(7);
+//         e.recv();
+//         c.send(8);
+//     }
+// }
+
+// // https://github.com/golang/go/blob/master/test/closedchan.go
+// mod closedchan {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/src/runtime/chanbarrier_test.go
+// mod chanbarrier_test {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/src/runtime/race/testdata/chan_test.go
+// mod race_chan_test {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/test/ken/chan.go
+// mod chan {
+//     // TODO
+// }
+
+// // https://github.com/golang/go/blob/master/test/ken/chan1.go
+// mod chan1 {
+//     // TODO
+// }
diff --git a/vendor/flume/tests/iter.rs b/vendor/flume/tests/iter.rs
new file mode 100644
index 0000000..4d69adb
--- /dev/null
+++ b/vendor/flume/tests/iter.rs
@@ -0,0 +1,112 @@
+//! Tests for iteration over receivers.
+
+extern crate crossbeam_utils;
+
+use flume::unbounded;
+use crossbeam_utils::thread::scope;
+
+#[test]
+fn nested_recv_iter() {
+    let (s, r) = unbounded::<i32>();
+    let (total_s, total_r) = unbounded::<i32>();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut acc = 0;
+            for x in r.iter() {
+                acc += x;
+            }
+            total_s.send(acc).unwrap();
+        });
+
+        s.send(3).unwrap();
+        s.send(1).unwrap();
+        s.send(2).unwrap();
+        drop(s);
+        assert_eq!(total_r.recv().unwrap(), 6);
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_iter_break() {
+    let (s, r) = unbounded::<i32>();
+    let (count_s, count_r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut count = 0;
+            for x in r.iter() {
+                if count >= 3 {
+                    break;
+                } else {
+                    count += x;
+                }
+            }
+            count_s.send(count).unwrap();
+        });
+
+        s.send(2).unwrap();
+        s.send(2).unwrap();
+        s.send(2).unwrap();
+        let _ = s.send(2);
+        drop(s);
+        assert_eq!(count_r.recv().unwrap(), 4);
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_try_iter() {
+    let (request_s, request_r) = unbounded();
+    let (response_s, response_r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut count = 0;
+            loop {
+                for x in response_r.try_iter() {
+                    count += x;
+                    if count == 6 {
+                        return;
+                    }
+                }
+                request_s.send(()).unwrap();
+            }
+        });
+
+        for _ in request_r.iter() {
+            if response_s.send(2).is_err() {
+                break;
+            }
+        }
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_into_iter_owned() {
+    let mut iter = {
+        let (s, r) = unbounded::<i32>();
+        s.send(1).unwrap();
+        s.send(2).unwrap();
+        r.into_iter()
+    };
+
+    assert_eq!(iter.next().unwrap(), 1);
+    assert_eq!(iter.next().unwrap(), 2);
+    assert_eq!(iter.next().is_none(), true);
+}
+
+#[test]
+fn recv_into_iter_borrowed() {
+    let (s, r) = unbounded::<i32>();
+    s.send(1).unwrap();
+    s.send(2).unwrap();
+    drop(s);
+
+    let mut iter = (&r).into_iter();
+    assert_eq!(iter.next().unwrap(), 1);
+    assert_eq!(iter.next().unwrap(), 2);
+    assert_eq!(iter.next().is_none(), true);
+}
diff --git a/vendor/flume/tests/list.rs b/vendor/flume/tests/list.rs
new file mode 100644
index 0000000..851af88
--- /dev/null
+++ b/vendor/flume/tests/list.rs
@@ -0,0 +1,536 @@
+//! Tests for the list channel flavor.
+
+extern crate crossbeam_utils;
+extern crate rand;
+
+use std::any::Any;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::thread;
+use std::time::Duration;
+
+use flume::{unbounded, Receiver};
+use flume::{RecvError, RecvTimeoutError, TryRecvError};
+use flume::{SendError, SendTimeoutError, TrySendError};
+use crossbeam_utils::thread::scope;
+use rand::{thread_rng, Rng};
+
+fn ms(ms: u64) -> Duration {
+    Duration::from_millis(ms)
+}
+
+#[test]
+fn smoke() {
+    let (s, r) = unbounded();
+    s.try_send(7).unwrap();
+    assert_eq!(r.try_recv(), Ok(7));
+
+    s.send(8).unwrap();
+    assert_eq!(r.recv(), Ok(8));
+
+    assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+    assert_eq!(r.recv_timeout(ms(1000)), Err(RecvTimeoutError::Timeout));
+}
+
+#[test]
+fn capacity() {
+    let (s, r) = unbounded::<()>();
+    assert_eq!(s.capacity(), None);
+    assert_eq!(r.capacity(), None);
+}
+
+#[test]
+fn len_empty_full() {
+    let (s, r) = unbounded();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(s.is_empty(), true);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 0);
+    assert_eq!(r.is_empty(), true);
+    assert_eq!(r.is_full(), false);
+
+    s.send(()).unwrap();
+
+    assert_eq!(s.len(), 1);
+    assert_eq!(s.is_empty(), false);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 1);
+    assert_eq!(r.is_empty(), false);
+    assert_eq!(r.is_full(), false);
+
+    r.recv().unwrap();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(s.is_empty(), true);
+    assert_eq!(s.is_full(), false);
+    assert_eq!(r.len(), 0);
+    assert_eq!(r.is_empty(), true);
+    assert_eq!(r.is_full(), false);
+}
+
+#[test]
+fn try_recv() {
+    let (s, r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+            thread::sleep(ms(1500));
+            assert_eq!(r.try_recv(), Ok(7));
+            thread::sleep(ms(500));
+            assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv() {
+    let (s, r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv(), Ok(7));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(8));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(9));
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+            s.send(8).unwrap();
+            s.send(9).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_timeout() {
+    let (s, r) = unbounded::<i32>();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv_timeout(ms(1000)), Err(RecvTimeoutError::Timeout));
+            assert_eq!(r.recv_timeout(ms(1000)), Ok(7));
+            assert_eq!(
+                r.recv_timeout(ms(1000)),
+                Err(RecvTimeoutError::Disconnected)
+            );
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn try_send() {
+    let (s, r) = unbounded();
+    for i in 0..1000 {
+        assert_eq!(s.try_send(i), Ok(()));
+    }
+
+    drop(r);
+    assert_eq!(s.try_send(777), Err(TrySendError::Disconnected(777)));
+}
+
+#[test]
+fn send() {
+    let (s, r) = unbounded();
+    for i in 0..1000 {
+        assert_eq!(s.send(i), Ok(()));
+    }
+
+    drop(r);
+    assert_eq!(s.send(777), Err(SendError(777)));
+}
+
+#[test]
+fn send_timeout() {
+    let (s, r) = unbounded();
+    for i in 0..1000 {
+        assert_eq!(s.send_timeout(i, ms(i as u64)), Ok(()));
+    }
+
+    drop(r);
+    assert_eq!(
+        s.send_timeout(777, ms(0)),
+        Err(SendTimeoutError::Disconnected(777))
+    );
+}
+
+#[test]
+fn send_after_disconnect() {
+    let (s, r) = unbounded();
+
+    s.send(1).unwrap();
+    s.send(2).unwrap();
+    s.send(3).unwrap();
+
+    drop(r);
+
+    assert_eq!(s.send(4), Err(SendError(4)));
+    assert_eq!(s.try_send(5), Err(TrySendError::Disconnected(5)));
+    assert_eq!(
+        s.send_timeout(6, ms(0)),
+        Err(SendTimeoutError::Disconnected(6))
+    );
+}
+
+#[test]
+fn recv_after_disconnect() {
+    let (s, r) = unbounded();
+
+    s.send(1).unwrap();
+    s.send(2).unwrap();
+    s.send(3).unwrap();
+
+    drop(s);
+
+    assert_eq!(r.recv(), Ok(1));
+    assert_eq!(r.recv(), Ok(2));
+    assert_eq!(r.recv(), Ok(3));
+    assert!(r.recv().is_err());
+}
+
+#[test]
+fn len() {
+    let (s, r) = unbounded();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+
+    for i in 0..50 {
+        s.send(i).unwrap();
+        assert_eq!(s.len(), i + 1);
+    }
+
+    for i in 0..50 {
+        r.recv().unwrap();
+        assert_eq!(r.len(), 50 - i - 1);
+    }
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+}
+
+#[test]
+fn disconnect_wakes_receiver() {
+    let (s, r) = unbounded::<()>();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            drop(s);
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn spsc() {
+    const COUNT: usize = 100_000;
+
+    let (s, r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                assert_eq!(r.recv(), Ok(i));
+            }
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                s.send(i).unwrap();
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn mpmc() {
+    const COUNT: usize = 25_000;
+    const THREADS: usize = 4;
+
+    let (s, r) = unbounded::<usize>();
+    let v = (0..COUNT).map(|_| AtomicUsize::new(0)).collect::<Vec<_>>();
+
+    scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for _ in 0..COUNT {
+                    let n = r.recv().unwrap();
+                    v[n].fetch_add(1, Ordering::SeqCst);
+                }
+            });
+        }
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for i in 0..COUNT {
+                    s.send(i).unwrap();
+                }
+            });
+        }
+    })
+    .unwrap();
+
+    assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+
+    for c in v {
+        assert_eq!(c.load(Ordering::SeqCst), THREADS);
+    }
+}
+
+#[test]
+fn stress_oneshot() {
+    const COUNT: usize = 10_000;
+
+    for _ in 0..COUNT {
+        let (s, r) = unbounded();
+
+        scope(|scope| {
+            scope.spawn(|_| r.recv().unwrap());
+            scope.spawn(|_| s.send(0).unwrap());
+        })
+        .unwrap();
+    }
+}
+
+#[test]
+fn stress_iter() {
+    const COUNT: usize = 100_000;
+
+    let (request_s, request_r) = unbounded();
+    let (response_s, response_r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut count = 0;
+            loop {
+                for x in response_r.try_iter() {
+                    count += x;
+                    if count == COUNT {
+                        return;
+                    }
+                }
+                request_s.send(()).unwrap();
+            }
+        });
+
+        for _ in request_r.iter() {
+            if response_s.send(1).is_err() {
+                break;
+            }
+        }
+    })
+    .unwrap();
+}
+
+#[test]
+fn stress_timeout_two_threads() {
+    const COUNT: usize = 100;
+
+    let (s, r) = unbounded();
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                s.send(i).unwrap();
+            }
+        });
+
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                loop {
+                    if let Ok(x) = r.recv_timeout(ms(10)) {
+                        assert_eq!(x, i);
+                        break;
+                    }
+                }
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn drops() {
+    static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+    #[derive(Debug, PartialEq)]
+    struct DropCounter;
+
+    impl Drop for DropCounter {
+        fn drop(&mut self) {
+            DROPS.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    let mut rng = thread_rng();
+
+    for _ in 0..100 {
+        let steps = rng.gen_range(0..10_000);
+        let additional = rng.gen_range(0..1000);
+
+        DROPS.store(0, Ordering::SeqCst);
+        let (s, r) = unbounded::<DropCounter>();
+
+        scope(|scope| {
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    r.recv().unwrap();
+                }
+            });
+
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    s.send(DropCounter).unwrap();
+                }
+            });
+        })
+        .unwrap();
+
+        for _ in 0..additional {
+            s.try_send(DropCounter).unwrap();
+        }
+
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps);
+        drop(s);
+        drop(r);
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps + additional);
+    }
+}
+
+#[test]
+fn linearizable() {
+    const COUNT: usize = 25_000;
+    const THREADS: usize = 4;
+
+    let (s, r) = unbounded();
+
+    scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for _ in 0..COUNT {
+                    s.send(0).unwrap();
+                    r.try_recv().unwrap();
+                }
+            });
+        }
+    })
+    .unwrap();
+}
+
+// #[test]
+// fn fairness() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 2];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r1) -> _ => hits[0] += 1,
+//             recv(r2) -> _ => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness_duplicates() {
+//     const COUNT: usize = 10_000;
+
+//     let (s, r) = unbounded();
+
+//     for _ in 0..COUNT {
+//         s.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 5];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r) -> _ => hits[0] += 1,
+//             recv(r) -> _ => hits[1] += 1,
+//             recv(r) -> _ => hits[2] += 1,
+//             recv(r) -> _ => hits[3] += 1,
+//             recv(r) -> _ => hits[4] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn recv_in_send() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     select! {
+//         send(s, assert_eq!(r.recv(), Ok(()))) -> _ => {}
+//     }
+// }
+
+#[test]
+fn channel_through_channel() {
+    const COUNT: usize = 1000;
+
+    type T = Box<dyn Any + Send>;
+
+    let (s, r) = unbounded::<T>();
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut s = s;
+
+            for _ in 0..COUNT {
+                let (new_s, new_r) = unbounded();
+                let new_r: T = Box::new(Some(new_r));
+
+                s.send(new_r).unwrap();
+                s = new_s;
+            }
+        });
+
+        scope.spawn(move |_| {
+            let mut r = r;
+
+            for _ in 0..COUNT {
+                r = r
+                    .recv()
+                    .unwrap()
+                    .downcast_mut::<Option<Receiver<T>>>()
+                    .unwrap()
+                    .take()
+                    .unwrap()
+            }
+        });
+    })
+    .unwrap();
+}
diff --git a/vendor/flume/tests/method_sharing.rs b/vendor/flume/tests/method_sharing.rs
new file mode 100644
index 0000000..24173ea
--- /dev/null
+++ b/vendor/flume/tests/method_sharing.rs
@@ -0,0 +1,39 @@
+#[cfg(feature = "async")]
+use flume::*;
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn sender() {
+    let (sender, receiver) = bounded(1);
+
+    let sender_fut = sender.send_async(());
+    assert_eq!(sender.is_disconnected(), sender_fut.is_disconnected());
+    assert_eq!(sender.is_empty(), sender_fut.is_empty());
+    assert_eq!(sender.is_full(), sender_fut.is_full());
+    assert_eq!(sender.len(), sender_fut.len());
+    assert_eq!(sender.capacity(), sender_fut.capacity());
+
+    let sender_sink = sender.sink();
+    assert_eq!(sender.is_disconnected(), sender_sink.is_disconnected());
+    assert_eq!(sender.is_empty(), sender_sink.is_empty());
+    assert_eq!(sender.is_full(), sender_sink.is_full());
+    assert_eq!(sender.len(), sender_sink.len());
+    assert_eq!(sender.capacity(), sender_sink.capacity());
+
+    let receiver_fut = receiver.recv_async();
+    assert_eq!(receiver.is_disconnected(), receiver_fut.is_disconnected());
+    assert_eq!(receiver.is_empty(), receiver_fut.is_empty());
+    assert_eq!(receiver.is_full(), receiver_fut.is_full());
+    assert_eq!(receiver.len(), receiver_fut.len());
+    assert_eq!(receiver.capacity(), receiver_fut.capacity());
+
+    let receiver_stream = receiver.stream();
+    assert_eq!(
+        receiver.is_disconnected(),
+        receiver_stream.is_disconnected()
+    );
+    assert_eq!(receiver.is_empty(), receiver_stream.is_empty());
+    assert_eq!(receiver.is_full(), receiver_stream.is_full());
+    assert_eq!(receiver.len(), receiver_stream.len());
+    assert_eq!(receiver.capacity(), receiver_stream.capacity());
+}
diff --git a/vendor/flume/tests/mpsc.rs b/vendor/flume/tests/mpsc.rs
new file mode 100644
index 0000000..213b9d8
--- /dev/null
+++ b/vendor/flume/tests/mpsc.rs
@@ -0,0 +1,2095 @@
+//! Tests copied from `std::sync::mpsc`.
+//!
+//! This is a copy of tests for the `std::sync::mpsc` channels from the standard library, but
+//! modified to work with `crossbeam-channel` instead.
+//!
+//! Minor tweaks were needed to make the tests compile:
+//!
+//! - Replace `box` syntax with `Box::new`.
+//! - Replace all uses of `Select` with `select!`.
+//! - Change the imports.
+//! - Join all spawned threads.
+//! - Removed assertion from oneshot_multi_thread_send_close_stress tests.
+//!
+//! Source:
+//!   - https://github.com/rust-lang/rust/tree/master/src/libstd/sync/mpsc
+//!
+//! Copyright & License:
+//!   - Copyright 2013-2014 The Rust Project Developers
+//!   - Apache License, Version 2.0 or MIT license, at your option
+//!   - https://github.com/rust-lang/rust/blob/master/COPYRIGHT
+//!   - https://www.rust-lang.org/en-US/legal.html
+
+#[macro_use]
+extern crate crossbeam_channel as cc;
+
+use std::sync::mpsc::{RecvError, RecvTimeoutError, TryRecvError};
+use std::sync::mpsc::{SendError, TrySendError};
+use std::thread::JoinHandle;
+use std::time::Duration;
+
+pub struct Sender<T> {
+    pub inner: cc::Sender<T>,
+}
+
+impl<T> Sender<T> {
+    pub fn send(&self, t: T) -> Result<(), SendError<T>> {
+        self.inner.send(t).map_err(|cc::SendError(m)| SendError(m))
+    }
+}
+
+impl<T> Clone for Sender<T> {
+    fn clone(&self) -> Sender<T> {
+        Sender {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+pub struct SyncSender<T> {
+    pub inner: cc::Sender<T>,
+}
+
+impl<T> SyncSender<T> {
+    pub fn send(&self, t: T) -> Result<(), SendError<T>> {
+        self.inner.send(t).map_err(|cc::SendError(m)| SendError(m))
+    }
+
+    pub fn try_send(&self, t: T) -> Result<(), TrySendError<T>> {
+        self.inner.try_send(t).map_err(|err| match err {
+            cc::TrySendError::Full(m) => TrySendError::Full(m),
+            cc::TrySendError::Disconnected(m) => TrySendError::Disconnected(m),
+        })
+    }
+}
+
+impl<T> Clone for SyncSender<T> {
+    fn clone(&self) -> SyncSender<T> {
+        SyncSender {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+pub struct Receiver<T> {
+    pub inner: cc::Receiver<T>,
+}
+
+impl<T> Receiver<T> {
+    pub fn try_recv(&self) -> Result<T, TryRecvError> {
+        self.inner.try_recv().map_err(|err| match err {
+            cc::TryRecvError::Empty => TryRecvError::Empty,
+            cc::TryRecvError::Disconnected => TryRecvError::Disconnected,
+        })
+    }
+
+    pub fn recv(&self) -> Result<T, RecvError> {
+        self.inner.recv().map_err(|_| RecvError)
+    }
+
+    pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError> {
+        self.inner.recv_timeout(timeout).map_err(|err| match err {
+            cc::RecvTimeoutError::Timeout => RecvTimeoutError::Timeout,
+            cc::RecvTimeoutError::Disconnected => RecvTimeoutError::Disconnected,
+        })
+    }
+
+    pub fn iter(&self) -> Iter<T> {
+        Iter { inner: self }
+    }
+
+    pub fn try_iter(&self) -> TryIter<T> {
+        TryIter { inner: self }
+    }
+}
+
+impl<'a, T> IntoIterator for &'a Receiver<T> {
+    type Item = T;
+    type IntoIter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<T> IntoIterator for Receiver<T> {
+    type Item = T;
+    type IntoIter = IntoIter<T>;
+
+    fn into_iter(self) -> IntoIter<T> {
+        IntoIter { inner: self }
+    }
+}
+
+pub struct TryIter<'a, T: 'a> {
+    inner: &'a Receiver<T>,
+}
+
+impl<'a, T> Iterator for TryIter<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        self.inner.try_recv().ok()
+    }
+}
+
+pub struct Iter<'a, T: 'a> {
+    inner: &'a Receiver<T>,
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        self.inner.recv().ok()
+    }
+}
+
+pub struct IntoIter<T> {
+    inner: Receiver<T>,
+}
+
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        self.inner.recv().ok()
+    }
+}
+
+pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
+    let (s, r) = cc::unbounded();
+    let s = Sender { inner: s };
+    let r = Receiver { inner: r };
+    (s, r)
+}
+
+pub fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>) {
+    let (s, r) = cc::bounded(bound);
+    let s = SyncSender { inner: s };
+    let r = Receiver { inner: r };
+    (s, r)
+}
+
+macro_rules! select {
+    (
+        $($name:pat = $rx:ident.$meth:ident() => $code:expr),+
+    ) => ({
+        crossbeam_channel_internal! {
+            $(
+                recv(($rx).inner) -> res => {
+                    let $name = res.map_err(|_| ::std::sync::mpsc::RecvError);
+                    $code
+                }
+            )+
+        }
+    })
+}
+
+// Source: https://github.com/rust-lang/rust/blob/master/src/libstd/sync/mpsc/mod.rs
+mod channel_tests {
+    use super::*;
+
+    use std::env;
+    use std::thread;
+    use std::time::{Duration, Instant};
+
+    pub fn stress_factor() -> usize {
+        match env::var("RUST_TEST_STRESS") {
+            Ok(val) => val.parse().unwrap(),
+            Err(..) => 1,
+        }
+    }
+
+    #[test]
+    fn smoke() {
+        let (tx, rx) = channel::<i32>();
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+    }
+
+    #[test]
+    fn drop_full() {
+        let (tx, _rx) = channel::<Box<isize>>();
+        tx.send(Box::new(1)).unwrap();
+    }
+
+    #[test]
+    fn drop_full_shared() {
+        let (tx, _rx) = channel::<Box<isize>>();
+        drop(tx.clone());
+        drop(tx.clone());
+        tx.send(Box::new(1)).unwrap();
+    }
+
+    #[test]
+    fn smoke_shared() {
+        let (tx, rx) = channel::<i32>();
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+        let tx = tx.clone();
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+    }
+
+    #[test]
+    fn smoke_threads() {
+        let (tx, rx) = channel::<i32>();
+        let t = thread::spawn(move || {
+            tx.send(1).unwrap();
+        });
+        assert_eq!(rx.recv().unwrap(), 1);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn smoke_port_gone() {
+        let (tx, rx) = channel::<i32>();
+        drop(rx);
+        assert!(tx.send(1).is_err());
+    }
+
+    #[test]
+    fn smoke_shared_port_gone() {
+        let (tx, rx) = channel::<i32>();
+        drop(rx);
+        assert!(tx.send(1).is_err())
+    }
+
+    #[test]
+    fn smoke_shared_port_gone2() {
+        let (tx, rx) = channel::<i32>();
+        drop(rx);
+        let tx2 = tx.clone();
+        drop(tx);
+        assert!(tx2.send(1).is_err());
+    }
+
+    #[test]
+    fn port_gone_concurrent() {
+        let (tx, rx) = channel::<i32>();
+        let t = thread::spawn(move || {
+            rx.recv().unwrap();
+        });
+        while tx.send(1).is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn port_gone_concurrent_shared() {
+        let (tx, rx) = channel::<i32>();
+        let tx2 = tx.clone();
+        let t = thread::spawn(move || {
+            rx.recv().unwrap();
+        });
+        while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn smoke_chan_gone() {
+        let (tx, rx) = channel::<i32>();
+        drop(tx);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn smoke_chan_gone_shared() {
+        let (tx, rx) = channel::<()>();
+        let tx2 = tx.clone();
+        drop(tx);
+        drop(tx2);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn chan_gone_concurrent() {
+        let (tx, rx) = channel::<i32>();
+        let t = thread::spawn(move || {
+            tx.send(1).unwrap();
+            tx.send(1).unwrap();
+        });
+        while rx.recv().is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress() {
+        let (tx, rx) = channel::<i32>();
+        let t = thread::spawn(move || {
+            for _ in 0..10000 {
+                tx.send(1).unwrap();
+            }
+        });
+        for _ in 0..10000 {
+            assert_eq!(rx.recv().unwrap(), 1);
+        }
+        t.join().ok().unwrap();
+    }
+
+    #[test]
+    fn stress_shared() {
+        const AMT: u32 = 10000;
+        const NTHREADS: u32 = 8;
+        let (tx, rx) = channel::<i32>();
+
+        let t = thread::spawn(move || {
+            for _ in 0..AMT * NTHREADS {
+                assert_eq!(rx.recv().unwrap(), 1);
+            }
+            match rx.try_recv() {
+                Ok(..) => panic!(),
+                _ => {}
+            }
+        });
+
+        let mut ts = Vec::with_capacity(NTHREADS as usize);
+        for _ in 0..NTHREADS {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                for _ in 0..AMT {
+                    tx.send(1).unwrap();
+                }
+            });
+            ts.push(t);
+        }
+        drop(tx);
+        t.join().ok().unwrap();
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn send_from_outside_runtime() {
+        let (tx1, rx1) = channel::<()>();
+        let (tx2, rx2) = channel::<i32>();
+        let t1 = thread::spawn(move || {
+            tx1.send(()).unwrap();
+            for _ in 0..40 {
+                assert_eq!(rx2.recv().unwrap(), 1);
+            }
+        });
+        rx1.recv().unwrap();
+        let t2 = thread::spawn(move || {
+            for _ in 0..40 {
+                tx2.send(1).unwrap();
+            }
+        });
+        t1.join().ok().unwrap();
+        t2.join().ok().unwrap();
+    }
+
+    #[test]
+    fn recv_from_outside_runtime() {
+        let (tx, rx) = channel::<i32>();
+        let t = thread::spawn(move || {
+            for _ in 0..40 {
+                assert_eq!(rx.recv().unwrap(), 1);
+            }
+        });
+        for _ in 0..40 {
+            tx.send(1).unwrap();
+        }
+        t.join().ok().unwrap();
+    }
+
+    #[test]
+    fn no_runtime() {
+        let (tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<i32>();
+        let t1 = thread::spawn(move || {
+            assert_eq!(rx1.recv().unwrap(), 1);
+            tx2.send(2).unwrap();
+        });
+        let t2 = thread::spawn(move || {
+            tx1.send(1).unwrap();
+            assert_eq!(rx2.recv().unwrap(), 2);
+        });
+        t1.join().ok().unwrap();
+        t2.join().ok().unwrap();
+    }
+
+    #[test]
+    fn oneshot_single_thread_close_port_first() {
+        // Simple test of closing without sending
+        let (_tx, rx) = channel::<i32>();
+        drop(rx);
+    }
+
+    #[test]
+    fn oneshot_single_thread_close_chan_first() {
+        // Simple test of closing without sending
+        let (tx, _rx) = channel::<i32>();
+        drop(tx);
+    }
+
+    #[test]
+    fn oneshot_single_thread_send_port_close() {
+        // Testing that the sender cleans up the payload if receiver is closed
+        let (tx, rx) = channel::<Box<i32>>();
+        drop(rx);
+        assert!(tx.send(Box::new(0)).is_err());
+    }
+
+    #[test]
+    fn oneshot_single_thread_recv_chan_close() {
+        let (tx, rx) = channel::<i32>();
+        drop(tx);
+        assert_eq!(rx.recv(), Err(RecvError));
+    }
+
+    #[test]
+    fn oneshot_single_thread_send_then_recv() {
+        let (tx, rx) = channel::<Box<i32>>();
+        tx.send(Box::new(10)).unwrap();
+        assert!(*rx.recv().unwrap() == 10);
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_send_open() {
+        let (tx, rx) = channel::<i32>();
+        assert!(tx.send(10).is_ok());
+        assert!(rx.recv().unwrap() == 10);
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_send_closed() {
+        let (tx, rx) = channel::<i32>();
+        drop(rx);
+        assert!(tx.send(10).is_err());
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_recv_open() {
+        let (tx, rx) = channel::<i32>();
+        tx.send(10).unwrap();
+        assert!(rx.recv() == Ok(10));
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_recv_closed() {
+        let (tx, rx) = channel::<i32>();
+        drop(tx);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_data() {
+        let (tx, rx) = channel::<i32>();
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+        tx.send(10).unwrap();
+        assert_eq!(rx.try_recv(), Ok(10));
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_close() {
+        let (tx, rx) = channel::<i32>();
+        drop(tx);
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_open() {
+        let (_tx, rx) = channel::<i32>();
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+    }
+
+    #[test]
+    fn oneshot_multi_task_recv_then_send() {
+        let (tx, rx) = channel::<Box<i32>>();
+        let t = thread::spawn(move || {
+            assert!(*rx.recv().unwrap() == 10);
+        });
+
+        tx.send(Box::new(10)).unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn oneshot_multi_task_recv_then_close() {
+        let (tx, rx) = channel::<Box<i32>>();
+        let t = thread::spawn(move || {
+            drop(tx);
+        });
+        thread::spawn(move || {
+            assert_eq!(rx.recv(), Err(RecvError));
+        })
+        .join()
+        .unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn oneshot_multi_thread_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = channel::<i32>();
+            let t = thread::spawn(move || {
+                drop(rx);
+            });
+            ts.push(t);
+            drop(tx);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_send_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(2 * stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = channel::<i32>();
+            let t = thread::spawn(move || {
+                drop(rx);
+            });
+            ts.push(t);
+            thread::spawn(move || {
+                let _ = tx.send(1);
+            })
+            .join()
+            .unwrap();
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_recv_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(2 * stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = channel::<i32>();
+            let t = thread::spawn(move || {
+                thread::spawn(move || {
+                    assert_eq!(rx.recv(), Err(RecvError));
+                })
+                .join()
+                .unwrap();
+            });
+            ts.push(t);
+            let t2 = thread::spawn(move || {
+                let t = thread::spawn(move || {
+                    drop(tx);
+                });
+                t.join().unwrap();
+            });
+            ts.push(t2);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_send_recv_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = channel::<Box<isize>>();
+            let t = thread::spawn(move || {
+                tx.send(Box::new(10)).unwrap();
+            });
+            ts.push(t);
+            assert!(*rx.recv().unwrap() == 10);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn stream_send_recv_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(2 * stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = channel();
+
+            if let Some(t) = send(tx, 0) {
+                ts.push(t);
+            }
+            if let Some(t2) = recv(rx, 0) {
+                ts.push(t2);
+            }
+
+            fn send(tx: Sender<Box<i32>>, i: i32) -> Option<JoinHandle<()>> {
+                if i == 10 {
+                    return None;
+                }
+
+                Some(thread::spawn(move || {
+                    tx.send(Box::new(i)).unwrap();
+                    send(tx, i + 1);
+                }))
+            }
+
+            fn recv(rx: Receiver<Box<i32>>, i: i32) -> Option<JoinHandle<()>> {
+                if i == 10 {
+                    return None;
+                }
+
+                Some(thread::spawn(move || {
+                    assert!(*rx.recv().unwrap() == i);
+                    recv(rx, i + 1);
+                }))
+            }
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_single_thread_recv_timeout() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        assert_eq!(rx.recv_timeout(Duration::from_millis(1)), Ok(()));
+        assert_eq!(
+            rx.recv_timeout(Duration::from_millis(1)),
+            Err(RecvTimeoutError::Timeout)
+        );
+        tx.send(()).unwrap();
+        assert_eq!(rx.recv_timeout(Duration::from_millis(1)), Ok(()));
+    }
+
+    #[test]
+    fn stress_recv_timeout_two_threads() {
+        let (tx, rx) = channel();
+        let stress = stress_factor() + 100;
+        let timeout = Duration::from_millis(100);
+
+        let t = thread::spawn(move || {
+            for i in 0..stress {
+                if i % 2 == 0 {
+                    thread::sleep(timeout * 2);
+                }
+                tx.send(1usize).unwrap();
+            }
+        });
+
+        let mut recv_count = 0;
+        loop {
+            match rx.recv_timeout(timeout) {
+                Ok(n) => {
+                    assert_eq!(n, 1usize);
+                    recv_count += 1;
+                }
+                Err(RecvTimeoutError::Timeout) => continue,
+                Err(RecvTimeoutError::Disconnected) => break,
+            }
+        }
+
+        assert_eq!(recv_count, stress);
+        t.join().unwrap()
+    }
+
+    #[test]
+    fn recv_timeout_upgrade() {
+        let (tx, rx) = channel::<()>();
+        let timeout = Duration::from_millis(1);
+        let _tx_clone = tx.clone();
+
+        let start = Instant::now();
+        assert_eq!(rx.recv_timeout(timeout), Err(RecvTimeoutError::Timeout));
+        assert!(Instant::now() >= start + timeout);
+    }
+
+    #[test]
+    fn stress_recv_timeout_shared() {
+        let (tx, rx) = channel();
+        let stress = stress_factor() + 100;
+
+        let mut ts = Vec::with_capacity(stress);
+        for i in 0..stress {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                thread::sleep(Duration::from_millis(i as u64 * 10));
+                tx.send(1usize).unwrap();
+            });
+            ts.push(t);
+        }
+
+        drop(tx);
+
+        let mut recv_count = 0;
+        loop {
+            match rx.recv_timeout(Duration::from_millis(10)) {
+                Ok(n) => {
+                    assert_eq!(n, 1usize);
+                    recv_count += 1;
+                }
+                Err(RecvTimeoutError::Timeout) => continue,
+                Err(RecvTimeoutError::Disconnected) => break,
+            }
+        }
+
+        assert_eq!(recv_count, stress);
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn recv_a_lot() {
+        // Regression test that we don't run out of stack in scheduler context
+        let (tx, rx) = channel();
+        for _ in 0..10000 {
+            tx.send(()).unwrap();
+        }
+        for _ in 0..10000 {
+            rx.recv().unwrap();
+        }
+    }
+
+    #[test]
+    fn shared_recv_timeout() {
+        let (tx, rx) = channel();
+        let total = 5;
+        let mut ts = Vec::with_capacity(total);
+        for _ in 0..total {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                tx.send(()).unwrap();
+            });
+            ts.push(t);
+        }
+
+        for _ in 0..total {
+            rx.recv().unwrap();
+        }
+
+        assert_eq!(
+            rx.recv_timeout(Duration::from_millis(1)),
+            Err(RecvTimeoutError::Timeout)
+        );
+        tx.send(()).unwrap();
+        assert_eq!(rx.recv_timeout(Duration::from_millis(1)), Ok(()));
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn shared_chan_stress() {
+        let (tx, rx) = channel();
+        let total = stress_factor() + 100;
+        let mut ts = Vec::with_capacity(total);
+        for _ in 0..total {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                tx.send(()).unwrap();
+            });
+            ts.push(t);
+        }
+
+        for _ in 0..total {
+            rx.recv().unwrap();
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn test_nested_recv_iter() {
+        let (tx, rx) = channel::<i32>();
+        let (total_tx, total_rx) = channel::<i32>();
+
+        let t = thread::spawn(move || {
+            let mut acc = 0;
+            for x in rx.iter() {
+                acc += x;
+            }
+            total_tx.send(acc).unwrap();
+        });
+
+        tx.send(3).unwrap();
+        tx.send(1).unwrap();
+        tx.send(2).unwrap();
+        drop(tx);
+        assert_eq!(total_rx.recv().unwrap(), 6);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn test_recv_iter_break() {
+        let (tx, rx) = channel::<i32>();
+        let (count_tx, count_rx) = channel();
+
+        let t = thread::spawn(move || {
+            let mut count = 0;
+            for x in rx.iter() {
+                if count >= 3 {
+                    break;
+                } else {
+                    count += x;
+                }
+            }
+            count_tx.send(count).unwrap();
+        });
+
+        tx.send(2).unwrap();
+        tx.send(2).unwrap();
+        tx.send(2).unwrap();
+        let _ = tx.send(2);
+        drop(tx);
+        assert_eq!(count_rx.recv().unwrap(), 4);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn test_recv_try_iter() {
+        let (request_tx, request_rx) = channel();
+        let (response_tx, response_rx) = channel();
+
+        // Request `x`s until we have `6`.
+        let t = thread::spawn(move || {
+            let mut count = 0;
+            loop {
+                for x in response_rx.try_iter() {
+                    count += x;
+                    if count == 6 {
+                        return count;
+                    }
+                }
+                request_tx.send(()).unwrap();
+            }
+        });
+
+        for _ in request_rx.iter() {
+            if response_tx.send(2).is_err() {
+                break;
+            }
+        }
+
+        assert_eq!(t.join().unwrap(), 6);
+    }
+
+    #[test]
+    fn test_recv_into_iter_owned() {
+        let mut iter = {
+            let (tx, rx) = channel::<i32>();
+            tx.send(1).unwrap();
+            tx.send(2).unwrap();
+
+            rx.into_iter()
+        };
+        assert_eq!(iter.next().unwrap(), 1);
+        assert_eq!(iter.next().unwrap(), 2);
+        assert_eq!(iter.next().is_none(), true);
+    }
+
+    #[test]
+    fn test_recv_into_iter_borrowed() {
+        let (tx, rx) = channel::<i32>();
+        tx.send(1).unwrap();
+        tx.send(2).unwrap();
+        drop(tx);
+        let mut iter = (&rx).into_iter();
+        assert_eq!(iter.next().unwrap(), 1);
+        assert_eq!(iter.next().unwrap(), 2);
+        assert_eq!(iter.next().is_none(), true);
+    }
+
+    #[test]
+    fn try_recv_states() {
+        let (tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<()>();
+        let (tx3, rx3) = channel::<()>();
+        let t = thread::spawn(move || {
+            rx2.recv().unwrap();
+            tx1.send(1).unwrap();
+            tx3.send(()).unwrap();
+            rx2.recv().unwrap();
+            drop(tx1);
+            tx3.send(()).unwrap();
+        });
+
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+        tx2.send(()).unwrap();
+        rx3.recv().unwrap();
+        assert_eq!(rx1.try_recv(), Ok(1));
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+        tx2.send(()).unwrap();
+        rx3.recv().unwrap();
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Disconnected));
+        t.join().unwrap();
+    }
+
+    // This bug used to end up in a livelock inside of the Receiver destructor
+    // because the internal state of the Shared packet was corrupted
+    #[test]
+    fn destroy_upgraded_shared_port_when_sender_still_active() {
+        let (tx, rx) = channel();
+        let (tx2, rx2) = channel();
+        let t = thread::spawn(move || {
+            rx.recv().unwrap(); // wait on a oneshot
+            drop(rx); // destroy a shared
+            tx2.send(()).unwrap();
+        });
+        // make sure the other thread has gone to sleep
+        for _ in 0..5000 {
+            thread::yield_now();
+        }
+
+        // upgrade to a shared chan and send a message
+        let tx2 = tx.clone();
+        drop(tx);
+        tx2.send(()).unwrap();
+
+        // wait for the child thread to exit before we exit
+        rx2.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn issue_32114() {
+        let (tx, _) = channel();
+        let _ = tx.send(123);
+        assert_eq!(tx.send(123), Err(SendError(123)));
+    }
+}
+
+// Source: https://github.com/rust-lang/rust/blob/master/src/libstd/sync/mpsc/mod.rs
+mod sync_channel_tests {
+    use super::*;
+
+    use std::env;
+    use std::thread;
+    use std::time::Duration;
+
+    pub fn stress_factor() -> usize {
+        match env::var("RUST_TEST_STRESS") {
+            Ok(val) => val.parse().unwrap(),
+            Err(..) => 1,
+        }
+    }
+
+    #[test]
+    fn smoke() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+    }
+
+    #[test]
+    fn drop_full() {
+        let (tx, _rx) = sync_channel::<Box<isize>>(1);
+        tx.send(Box::new(1)).unwrap();
+    }
+
+    #[test]
+    fn smoke_shared() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+        let tx = tx.clone();
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv().unwrap(), 1);
+    }
+
+    #[test]
+    fn recv_timeout() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        assert_eq!(
+            rx.recv_timeout(Duration::from_millis(1)),
+            Err(RecvTimeoutError::Timeout)
+        );
+        tx.send(1).unwrap();
+        assert_eq!(rx.recv_timeout(Duration::from_millis(1)), Ok(1));
+    }
+
+    #[test]
+    fn smoke_threads() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            tx.send(1).unwrap();
+        });
+        assert_eq!(rx.recv().unwrap(), 1);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn smoke_port_gone() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(rx);
+        assert!(tx.send(1).is_err());
+    }
+
+    #[test]
+    fn smoke_shared_port_gone2() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(rx);
+        let tx2 = tx.clone();
+        drop(tx);
+        assert!(tx2.send(1).is_err());
+    }
+
+    #[test]
+    fn port_gone_concurrent() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            rx.recv().unwrap();
+        });
+        while tx.send(1).is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn port_gone_concurrent_shared() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let tx2 = tx.clone();
+        let t = thread::spawn(move || {
+            rx.recv().unwrap();
+        });
+        while tx.send(1).is_ok() && tx2.send(1).is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn smoke_chan_gone() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(tx);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn smoke_chan_gone_shared() {
+        let (tx, rx) = sync_channel::<()>(0);
+        let tx2 = tx.clone();
+        drop(tx);
+        drop(tx2);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn chan_gone_concurrent() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            tx.send(1).unwrap();
+            tx.send(1).unwrap();
+        });
+        while rx.recv().is_ok() {}
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            for _ in 0..10000 {
+                tx.send(1).unwrap();
+            }
+        });
+        for _ in 0..10000 {
+            assert_eq!(rx.recv().unwrap(), 1);
+        }
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress_recv_timeout_two_threads() {
+        let (tx, rx) = sync_channel::<i32>(0);
+
+        let t = thread::spawn(move || {
+            for _ in 0..10000 {
+                tx.send(1).unwrap();
+            }
+        });
+
+        let mut recv_count = 0;
+        loop {
+            match rx.recv_timeout(Duration::from_millis(1)) {
+                Ok(v) => {
+                    assert_eq!(v, 1);
+                    recv_count += 1;
+                }
+                Err(RecvTimeoutError::Timeout) => continue,
+                Err(RecvTimeoutError::Disconnected) => break,
+            }
+        }
+
+        assert_eq!(recv_count, 10000);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress_recv_timeout_shared() {
+        const AMT: u32 = 1000;
+        const NTHREADS: u32 = 8;
+        let (tx, rx) = sync_channel::<i32>(0);
+        let (dtx, drx) = sync_channel::<()>(0);
+
+        let t = thread::spawn(move || {
+            let mut recv_count = 0;
+            loop {
+                match rx.recv_timeout(Duration::from_millis(10)) {
+                    Ok(v) => {
+                        assert_eq!(v, 1);
+                        recv_count += 1;
+                    }
+                    Err(RecvTimeoutError::Timeout) => continue,
+                    Err(RecvTimeoutError::Disconnected) => break,
+                }
+            }
+
+            assert_eq!(recv_count, AMT * NTHREADS);
+            assert!(rx.try_recv().is_err());
+
+            dtx.send(()).unwrap();
+        });
+
+        let mut ts = Vec::with_capacity(NTHREADS as usize);
+        for _ in 0..NTHREADS {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                for _ in 0..AMT {
+                    tx.send(1).unwrap();
+                }
+            });
+            ts.push(t);
+        }
+
+        drop(tx);
+
+        drx.recv().unwrap();
+        for t in ts {
+            t.join().unwrap();
+        }
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress_shared() {
+        const AMT: u32 = 1000;
+        const NTHREADS: u32 = 8;
+        let (tx, rx) = sync_channel::<i32>(0);
+        let (dtx, drx) = sync_channel::<()>(0);
+
+        let t = thread::spawn(move || {
+            for _ in 0..AMT * NTHREADS {
+                assert_eq!(rx.recv().unwrap(), 1);
+            }
+            match rx.try_recv() {
+                Ok(..) => panic!(),
+                _ => {}
+            }
+            dtx.send(()).unwrap();
+        });
+
+        let mut ts = Vec::with_capacity(NTHREADS as usize);
+        for _ in 0..NTHREADS {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                for _ in 0..AMT {
+                    tx.send(1).unwrap();
+                }
+            });
+            ts.push(t);
+        }
+        drop(tx);
+        drx.recv().unwrap();
+        for t in ts {
+            t.join().unwrap();
+        }
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn oneshot_single_thread_close_port_first() {
+        // Simple test of closing without sending
+        let (_tx, rx) = sync_channel::<i32>(0);
+        drop(rx);
+    }
+
+    #[test]
+    fn oneshot_single_thread_close_chan_first() {
+        // Simple test of closing without sending
+        let (tx, _rx) = sync_channel::<i32>(0);
+        drop(tx);
+    }
+
+    #[test]
+    fn oneshot_single_thread_send_port_close() {
+        // Testing that the sender cleans up the payload if receiver is closed
+        let (tx, rx) = sync_channel::<Box<i32>>(0);
+        drop(rx);
+        assert!(tx.send(Box::new(0)).is_err());
+    }
+
+    #[test]
+    fn oneshot_single_thread_recv_chan_close() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(tx);
+        assert_eq!(rx.recv(), Err(RecvError));
+    }
+
+    #[test]
+    fn oneshot_single_thread_send_then_recv() {
+        let (tx, rx) = sync_channel::<Box<i32>>(1);
+        tx.send(Box::new(10)).unwrap();
+        assert!(*rx.recv().unwrap() == 10);
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_send_open() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        assert_eq!(tx.try_send(10), Ok(()));
+        assert!(rx.recv().unwrap() == 10);
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_send_closed() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(rx);
+        assert_eq!(tx.try_send(10), Err(TrySendError::Disconnected(10)));
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_send_closed2() {
+        let (tx, _rx) = sync_channel::<i32>(0);
+        assert_eq!(tx.try_send(10), Err(TrySendError::Full(10)));
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_recv_open() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        tx.send(10).unwrap();
+        assert!(rx.recv() == Ok(10));
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_recv_closed() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(tx);
+        assert!(rx.recv().is_err());
+    }
+
+    #[test]
+    fn oneshot_single_thread_try_recv_closed_with_data() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        tx.send(10).unwrap();
+        drop(tx);
+        assert_eq!(rx.try_recv(), Ok(10));
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_data() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+        tx.send(10).unwrap();
+        assert_eq!(rx.try_recv(), Ok(10));
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_close() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        drop(tx);
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected));
+    }
+
+    #[test]
+    fn oneshot_single_thread_peek_open() {
+        let (_tx, rx) = sync_channel::<i32>(0);
+        assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
+    }
+
+    #[test]
+    fn oneshot_multi_task_recv_then_send() {
+        let (tx, rx) = sync_channel::<Box<i32>>(0);
+        let t = thread::spawn(move || {
+            assert!(*rx.recv().unwrap() == 10);
+        });
+
+        tx.send(Box::new(10)).unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn oneshot_multi_task_recv_then_close() {
+        let (tx, rx) = sync_channel::<Box<i32>>(0);
+        let t = thread::spawn(move || {
+            drop(tx);
+        });
+        thread::spawn(move || {
+            assert_eq!(rx.recv(), Err(RecvError));
+        })
+        .join()
+        .unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn oneshot_multi_thread_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = sync_channel::<i32>(0);
+            let t = thread::spawn(move || {
+                drop(rx);
+            });
+            ts.push(t);
+            drop(tx);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_send_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = sync_channel::<i32>(0);
+            let t = thread::spawn(move || {
+                drop(rx);
+            });
+            ts.push(t);
+            thread::spawn(move || {
+                let _ = tx.send(1);
+            })
+            .join()
+            .unwrap();
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_recv_close_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(2 * stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = sync_channel::<i32>(0);
+            let t = thread::spawn(move || {
+                thread::spawn(move || {
+                    assert_eq!(rx.recv(), Err(RecvError));
+                })
+                .join()
+                .unwrap();
+            });
+            ts.push(t);
+            let t2 = thread::spawn(move || {
+                thread::spawn(move || {
+                    drop(tx);
+                });
+            });
+            ts.push(t2);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn oneshot_multi_thread_send_recv_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = sync_channel::<Box<i32>>(0);
+            let t = thread::spawn(move || {
+                tx.send(Box::new(10)).unwrap();
+            });
+            ts.push(t);
+            assert!(*rx.recv().unwrap() == 10);
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn stream_send_recv_stress() {
+        let stress_factor = stress_factor();
+        let mut ts = Vec::with_capacity(2 * stress_factor);
+        for _ in 0..stress_factor {
+            let (tx, rx) = sync_channel::<Box<i32>>(0);
+
+            if let Some(t) = send(tx, 0) {
+                ts.push(t);
+            }
+            if let Some(t) = recv(rx, 0) {
+                ts.push(t);
+            }
+
+            fn send(tx: SyncSender<Box<i32>>, i: i32) -> Option<JoinHandle<()>> {
+                if i == 10 {
+                    return None;
+                }
+
+                Some(thread::spawn(move || {
+                    tx.send(Box::new(i)).unwrap();
+                    send(tx, i + 1);
+                }))
+            }
+
+            fn recv(rx: Receiver<Box<i32>>, i: i32) -> Option<JoinHandle<()>> {
+                if i == 10 {
+                    return None;
+                }
+
+                Some(thread::spawn(move || {
+                    assert!(*rx.recv().unwrap() == i);
+                    recv(rx, i + 1);
+                }))
+            }
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn recv_a_lot() {
+        // Regression test that we don't run out of stack in scheduler context
+        let (tx, rx) = sync_channel(10000);
+        for _ in 0..10000 {
+            tx.send(()).unwrap();
+        }
+        for _ in 0..10000 {
+            rx.recv().unwrap();
+        }
+    }
+
+    #[test]
+    fn shared_chan_stress() {
+        let (tx, rx) = sync_channel(0);
+        let total = stress_factor() + 100;
+        let mut ts = Vec::with_capacity(total);
+        for _ in 0..total {
+            let tx = tx.clone();
+            let t = thread::spawn(move || {
+                tx.send(()).unwrap();
+            });
+            ts.push(t);
+        }
+
+        for _ in 0..total {
+            rx.recv().unwrap();
+        }
+        for t in ts {
+            t.join().unwrap();
+        }
+    }
+
+    #[test]
+    fn test_nested_recv_iter() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let (total_tx, total_rx) = sync_channel::<i32>(0);
+
+        let t = thread::spawn(move || {
+            let mut acc = 0;
+            for x in rx.iter() {
+                acc += x;
+            }
+            total_tx.send(acc).unwrap();
+        });
+
+        tx.send(3).unwrap();
+        tx.send(1).unwrap();
+        tx.send(2).unwrap();
+        drop(tx);
+        assert_eq!(total_rx.recv().unwrap(), 6);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn test_recv_iter_break() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let (count_tx, count_rx) = sync_channel(0);
+
+        let t = thread::spawn(move || {
+            let mut count = 0;
+            for x in rx.iter() {
+                if count >= 3 {
+                    break;
+                } else {
+                    count += x;
+                }
+            }
+            count_tx.send(count).unwrap();
+        });
+
+        tx.send(2).unwrap();
+        tx.send(2).unwrap();
+        tx.send(2).unwrap();
+        let _ = tx.try_send(2);
+        drop(tx);
+        assert_eq!(count_rx.recv().unwrap(), 4);
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn try_recv_states() {
+        let (tx1, rx1) = sync_channel::<i32>(1);
+        let (tx2, rx2) = sync_channel::<()>(1);
+        let (tx3, rx3) = sync_channel::<()>(1);
+        let t = thread::spawn(move || {
+            rx2.recv().unwrap();
+            tx1.send(1).unwrap();
+            tx3.send(()).unwrap();
+            rx2.recv().unwrap();
+            drop(tx1);
+            tx3.send(()).unwrap();
+        });
+
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+        tx2.send(()).unwrap();
+        rx3.recv().unwrap();
+        assert_eq!(rx1.try_recv(), Ok(1));
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+        tx2.send(()).unwrap();
+        rx3.recv().unwrap();
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Disconnected));
+        t.join().unwrap();
+    }
+
+    // This bug used to end up in a livelock inside of the Receiver destructor
+    // because the internal state of the Shared packet was corrupted
+    #[test]
+    fn destroy_upgraded_shared_port_when_sender_still_active() {
+        let (tx, rx) = sync_channel::<()>(0);
+        let (tx2, rx2) = sync_channel::<()>(0);
+        let t = thread::spawn(move || {
+            rx.recv().unwrap(); // wait on a oneshot
+            drop(rx); // destroy a shared
+            tx2.send(()).unwrap();
+        });
+        // make sure the other thread has gone to sleep
+        for _ in 0..5000 {
+            thread::yield_now();
+        }
+
+        // upgrade to a shared chan and send a message
+        let tx2 = tx.clone();
+        drop(tx);
+        tx2.send(()).unwrap();
+
+        // wait for the child thread to exit before we exit
+        rx2.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn send1() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            rx.recv().unwrap();
+        });
+        assert_eq!(tx.send(1), Ok(()));
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn send2() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            drop(rx);
+        });
+        assert!(tx.send(1).is_err());
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn send3() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        assert_eq!(tx.send(1), Ok(()));
+        let t = thread::spawn(move || {
+            drop(rx);
+        });
+        assert!(tx.send(1).is_err());
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn send4() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let tx2 = tx.clone();
+        let (done, donerx) = channel();
+        let done2 = done.clone();
+        let t = thread::spawn(move || {
+            assert!(tx.send(1).is_err());
+            done.send(()).unwrap();
+        });
+        let t2 = thread::spawn(move || {
+            assert!(tx2.send(2).is_err());
+            done2.send(()).unwrap();
+        });
+        drop(rx);
+        donerx.recv().unwrap();
+        donerx.recv().unwrap();
+        t.join().unwrap();
+        t2.join().unwrap();
+    }
+
+    #[test]
+    fn try_send1() {
+        let (tx, _rx) = sync_channel::<i32>(0);
+        assert_eq!(tx.try_send(1), Err(TrySendError::Full(1)));
+    }
+
+    #[test]
+    fn try_send2() {
+        let (tx, _rx) = sync_channel::<i32>(1);
+        assert_eq!(tx.try_send(1), Ok(()));
+        assert_eq!(tx.try_send(1), Err(TrySendError::Full(1)));
+    }
+
+    #[test]
+    fn try_send3() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        assert_eq!(tx.try_send(1), Ok(()));
+        drop(rx);
+        assert_eq!(tx.try_send(1), Err(TrySendError::Disconnected(1)));
+    }
+
+    #[test]
+    fn issue_15761() {
+        fn repro() {
+            let (tx1, rx1) = sync_channel::<()>(3);
+            let (tx2, rx2) = sync_channel::<()>(3);
+
+            let _t = thread::spawn(move || {
+                rx1.recv().unwrap();
+                tx2.try_send(()).unwrap();
+            });
+
+            tx1.try_send(()).unwrap();
+            rx2.recv().unwrap();
+        }
+
+        for _ in 0..100 {
+            repro()
+        }
+    }
+}
+
+// Source: https://github.com/rust-lang/rust/blob/master/src/libstd/sync/mpsc/select.rs
+mod select_tests {
+    use super::*;
+
+    use std::thread;
+
+    #[test]
+    fn smoke() {
+        let (tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<i32>();
+        tx1.send(1).unwrap();
+        select! {
+            foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); },
+            _bar = rx2.recv() => { panic!() }
+        }
+        tx2.send(2).unwrap();
+        select! {
+            _foo = rx1.recv() => { panic!() },
+            bar = rx2.recv() => { assert_eq!(bar.unwrap(), 2) }
+        }
+        drop(tx1);
+        select! {
+            foo = rx1.recv() => { assert!(foo.is_err()); },
+            _bar = rx2.recv() => { panic!() }
+        }
+        drop(tx2);
+        select! {
+            bar = rx2.recv() => { assert!(bar.is_err()); }
+        }
+    }
+
+    #[test]
+    fn smoke2() {
+        let (_tx1, rx1) = channel::<i32>();
+        let (_tx2, rx2) = channel::<i32>();
+        let (_tx3, rx3) = channel::<i32>();
+        let (_tx4, rx4) = channel::<i32>();
+        let (tx5, rx5) = channel::<i32>();
+        tx5.send(4).unwrap();
+        select! {
+            _foo = rx1.recv() => { panic!("1") },
+            _foo = rx2.recv() => { panic!("2") },
+            _foo = rx3.recv() => { panic!("3") },
+            _foo = rx4.recv() => { panic!("4") },
+            foo = rx5.recv() => { assert_eq!(foo.unwrap(), 4); }
+        }
+    }
+
+    #[test]
+    fn closed() {
+        let (_tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<i32>();
+        drop(tx2);
+
+        select! {
+            _a1 = rx1.recv() => { panic!() },
+            a2 = rx2.recv() => { assert!(a2.is_err()); }
+        }
+    }
+
+    #[test]
+    fn unblocks() {
+        let (tx1, rx1) = channel::<i32>();
+        let (_tx2, rx2) = channel::<i32>();
+        let (tx3, rx3) = channel::<i32>();
+
+        let t = thread::spawn(move || {
+            for _ in 0..20 {
+                thread::yield_now();
+            }
+            tx1.send(1).unwrap();
+            rx3.recv().unwrap();
+            for _ in 0..20 {
+                thread::yield_now();
+            }
+        });
+
+        select! {
+            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+            _b = rx2.recv() => { panic!() }
+        }
+        tx3.send(1).unwrap();
+        select! {
+            a = rx1.recv() => { assert!(a.is_err()) },
+            _b = rx2.recv() => { panic!() }
+        }
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn both_ready() {
+        let (tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<i32>();
+        let (tx3, rx3) = channel::<()>();
+
+        let t = thread::spawn(move || {
+            for _ in 0..20 {
+                thread::yield_now();
+            }
+            tx1.send(1).unwrap();
+            tx2.send(2).unwrap();
+            rx3.recv().unwrap();
+        });
+
+        select! {
+            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+            a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
+        }
+        select! {
+            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
+            a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
+        }
+        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
+        assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));
+        tx3.send(()).unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stress() {
+        const AMT: i32 = 10000;
+        let (tx1, rx1) = channel::<i32>();
+        let (tx2, rx2) = channel::<i32>();
+        let (tx3, rx3) = channel::<()>();
+
+        let t = thread::spawn(move || {
+            for i in 0..AMT {
+                if i % 2 == 0 {
+                    tx1.send(i).unwrap();
+                } else {
+                    tx2.send(i).unwrap();
+                }
+                rx3.recv().unwrap();
+            }
+        });
+
+        for i in 0..AMT {
+            select! {
+                i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },
+                i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }
+            }
+            tx3.send(()).unwrap();
+        }
+        t.join().unwrap();
+    }
+
+    #[allow(unused_must_use)]
+    #[test]
+    fn cloning() {
+        let (tx1, rx1) = channel::<i32>();
+        let (_tx2, rx2) = channel::<i32>();
+        let (tx3, rx3) = channel::<()>();
+
+        let t = thread::spawn(move || {
+            rx3.recv().unwrap();
+            tx1.clone();
+            assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
+            tx1.send(2).unwrap();
+            rx3.recv().unwrap();
+        });
+
+        tx3.send(()).unwrap();
+        select! {
+            _i1 = rx1.recv() => {},
+            _i2 = rx2.recv() => panic!()
+        }
+        tx3.send(()).unwrap();
+        t.join().unwrap();
+    }
+
+    #[allow(unused_must_use)]
+    #[test]
+    fn cloning2() {
+        let (tx1, rx1) = channel::<i32>();
+        let (_tx2, rx2) = channel::<i32>();
+        let (tx3, rx3) = channel::<()>();
+
+        let t = thread::spawn(move || {
+            rx3.recv().unwrap();
+            tx1.clone();
+            assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
+            tx1.send(2).unwrap();
+            rx3.recv().unwrap();
+        });
+
+        tx3.send(()).unwrap();
+        select! {
+            _i1 = rx1.recv() => {},
+            _i2 = rx2.recv() => panic!()
+        }
+        tx3.send(()).unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn cloning3() {
+        let (tx1, rx1) = channel::<()>();
+        let (tx2, rx2) = channel::<()>();
+        let (tx3, rx3) = channel::<()>();
+        let t = thread::spawn(move || {
+            select! {
+                _ = rx1.recv() => panic!(),
+                _ = rx2.recv() => {}
+            }
+            tx3.send(()).unwrap();
+        });
+
+        for _ in 0..1000 {
+            thread::yield_now();
+        }
+        drop(tx1.clone());
+        tx2.send(()).unwrap();
+        rx3.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn preflight1() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        select! {
+            _n = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight2() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        tx.send(()).unwrap();
+        select! {
+            _n = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight3() {
+        let (tx, rx) = channel();
+        drop(tx.clone());
+        tx.send(()).unwrap();
+        select! {
+            _n = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight4() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight5() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        tx.send(()).unwrap();
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight6() {
+        let (tx, rx) = channel();
+        drop(tx.clone());
+        tx.send(()).unwrap();
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight7() {
+        let (tx, rx) = channel::<()>();
+        drop(tx);
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight8() {
+        let (tx, rx) = channel();
+        tx.send(()).unwrap();
+        drop(tx);
+        rx.recv().unwrap();
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn preflight9() {
+        let (tx, rx) = channel();
+        drop(tx.clone());
+        tx.send(()).unwrap();
+        drop(tx);
+        rx.recv().unwrap();
+        select! {
+            _ = rx.recv() => {}
+        }
+    }
+
+    #[test]
+    fn oneshot_data_waiting() {
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
+        let t = thread::spawn(move || {
+            select! {
+                _n = rx1.recv() => {}
+            }
+            tx2.send(()).unwrap();
+        });
+
+        for _ in 0..100 {
+            thread::yield_now()
+        }
+        tx1.send(()).unwrap();
+        rx2.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn stream_data_waiting() {
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
+        tx1.send(()).unwrap();
+        tx1.send(()).unwrap();
+        rx1.recv().unwrap();
+        rx1.recv().unwrap();
+        let t = thread::spawn(move || {
+            select! {
+                _n = rx1.recv() => {}
+            }
+            tx2.send(()).unwrap();
+        });
+
+        for _ in 0..100 {
+            thread::yield_now()
+        }
+        tx1.send(()).unwrap();
+        rx2.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn shared_data_waiting() {
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
+        drop(tx1.clone());
+        tx1.send(()).unwrap();
+        rx1.recv().unwrap();
+        let t = thread::spawn(move || {
+            select! {
+                _n = rx1.recv() => {}
+            }
+            tx2.send(()).unwrap();
+        });
+
+        for _ in 0..100 {
+            thread::yield_now()
+        }
+        tx1.send(()).unwrap();
+        rx2.recv().unwrap();
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn sync1() {
+        let (tx, rx) = sync_channel::<i32>(1);
+        tx.send(1).unwrap();
+        select! {
+            n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
+        }
+    }
+
+    #[test]
+    fn sync2() {
+        let (tx, rx) = sync_channel::<i32>(0);
+        let t = thread::spawn(move || {
+            for _ in 0..100 {
+                thread::yield_now()
+            }
+            tx.send(1).unwrap();
+        });
+        select! {
+            n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
+        }
+        t.join().unwrap();
+    }
+
+    #[test]
+    fn sync3() {
+        let (tx1, rx1) = sync_channel::<i32>(0);
+        let (tx2, rx2): (Sender<i32>, Receiver<i32>) = channel();
+        let t = thread::spawn(move || {
+            tx1.send(1).unwrap();
+        });
+        let t2 = thread::spawn(move || {
+            tx2.send(2).unwrap();
+        });
+        select! {
+            n = rx1.recv() => {
+                let n = n.unwrap();
+                assert_eq!(n, 1);
+                assert_eq!(rx2.recv().unwrap(), 2);
+            },
+            n = rx2.recv() => {
+                let n = n.unwrap();
+                assert_eq!(n, 2);
+                assert_eq!(rx1.recv().unwrap(), 1);
+            }
+        }
+        t.join().unwrap();
+        t2.join().unwrap();
+    }
+}
diff --git a/vendor/flume/tests/never.rs b/vendor/flume/tests/never.rs
new file mode 100644
index 0000000..676903f
--- /dev/null
+++ b/vendor/flume/tests/never.rs
@@ -0,0 +1,99 @@
+// //! Tests for the never channel flavor.
+
+// #[macro_use]
+// extern crate crossbeam_channel;
+// extern crate rand;
+
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{never, tick, unbounded};
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn smoke() {
+//     select! {
+//         recv(never::<i32>()) -> _ => panic!(),
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn optional() {
+//     let (s, r) = unbounded::<i32>();
+//     s.send(1).unwrap();
+//     s.send(2).unwrap();
+
+//     let mut r = Some(&r);
+//     select! {
+//         recv(r.unwrap_or(&never())) -> _ => {}
+//         default => panic!(),
+//     }
+
+//     r = None;
+//     select! {
+//         recv(r.unwrap_or(&never())) -> _ => panic!(),
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn tick_n() {
+//     let mut r = tick(ms(100));
+//     let mut step = 0;
+
+//     loop {
+//         select! {
+//             recv(r) -> _ => step += 1,
+//             default(ms(500)) => break,
+//         }
+
+//         if step == 10 {
+//             r = never();
+//         }
+//     }
+
+//     assert_eq!(step, 10);
+// }
+
+// #[test]
+// fn capacity() {
+//     let r = never::<i32>();
+//     assert_eq!(r.capacity(), Some(0));
+// }
+
+// #[test]
+// fn len_empty_full() {
+//     let r = never::<i32>();
+//     assert_eq!(r.len(), 0);
+//     assert_eq!(r.is_empty(), true);
+//     assert_eq!(r.is_full(), true);
+// }
+
+// #[test]
+// fn try_recv() {
+//     let r = never::<i32>();
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(100));
+//     assert!(r.try_recv().is_err());
+// }
+
+// #[test]
+// fn recv_timeout() {
+//     let start = Instant::now();
+//     let r = never::<i32>();
+
+//     assert!(r.recv_timeout(ms(100)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(100));
+//     assert!(now - start <= ms(150));
+
+//     assert!(r.recv_timeout(ms(100)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(200));
+//     assert!(now - start <= ms(250));
+// }
diff --git a/vendor/flume/tests/ready.rs b/vendor/flume/tests/ready.rs
new file mode 100644
index 0000000..2f42d9a
--- /dev/null
+++ b/vendor/flume/tests/ready.rs
@@ -0,0 +1,837 @@
+// //! Tests for channel readiness using the `Select` struct.
+
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, bounded, tick, unbounded};
+// use crossbeam_channel::{Receiver, Select, TryRecvError, TrySendError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn smoke1() {
+//     let (s1, r1) = unbounded::<usize>();
+//     let (s2, r2) = unbounded::<usize>();
+
+//     s1.send(1).unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     assert_eq!(sel.ready(), 0);
+//     assert_eq!(r1.try_recv(), Ok(1));
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     assert_eq!(sel.ready(), 1);
+//     assert_eq!(r2.try_recv(), Ok(2));
+// }
+
+// #[test]
+// fn smoke2() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (_s2, r2) = unbounded::<i32>();
+//     let (_s3, r3) = unbounded::<i32>();
+//     let (_s4, r4) = unbounded::<i32>();
+//     let (s5, r5) = unbounded::<i32>();
+
+//     s5.send(5).unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     sel.recv(&r3);
+//     sel.recv(&r4);
+//     sel.recv(&r5);
+//     assert_eq!(sel.ready(), 4);
+//     assert_eq!(r5.try_recv(), Ok(5));
+// }
+
+// #[test]
+// fn disconnected() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             drop(s1);
+//             thread::sleep(ms(500));
+//             s2.send(5).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         match sel.ready_timeout(ms(1000)) {
+//             Ok(0) => assert_eq!(r1.try_recv(), Err(TryRecvError::Disconnected)),
+//             _ => panic!(),
+//         }
+
+//         r2.recv().unwrap();
+//     })
+//     .unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     match sel.ready_timeout(ms(1000)) {
+//         Ok(0) => assert_eq!(r1.try_recv(), Err(TryRecvError::Disconnected)),
+//         _ => panic!(),
+//     }
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             drop(s2);
+//         });
+
+//         let mut sel = Select::new();
+//         sel.recv(&r2);
+//         match sel.ready_timeout(ms(1000)) {
+//             Ok(0) => assert_eq!(r2.try_recv(), Err(TryRecvError::Disconnected)),
+//             _ => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     assert!(sel.try_ready().is_err());
+
+//     drop(s1);
+
+//     let mut sel = Select::new();
+//     sel.recv(&r1);
+//     sel.recv(&r2);
+//     match sel.try_ready() {
+//         Ok(0) => assert!(r1.try_recv().is_err()),
+//         _ => panic!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r2);
+//     match sel.try_ready() {
+//         Ok(0) => assert_eq!(r2.try_recv(), Ok(2)),
+//         _ => panic!(),
+//     }
+
+//     let mut sel = Select::new();
+//     sel.recv(&r2);
+//     assert!(sel.try_ready().is_err());
+
+//     let mut sel = Select::new();
+//     assert!(sel.try_ready().is_err());
+// }
+
+// #[test]
+// fn timeout() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(1500));
+//             s2.send(2).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         assert!(sel.ready_timeout(ms(1000)).is_err());
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         match sel.ready_timeout(ms(1000)) {
+//             Ok(1) => assert_eq!(r2.try_recv(), Ok(2)),
+//             _ => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         let (s, r) = unbounded::<i32>();
+
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(500));
+//             drop(s);
+//         });
+
+//         let mut sel = Select::new();
+//         assert!(sel.ready_timeout(ms(1000)).is_err());
+
+//         let mut sel = Select::new();
+//         sel.recv(&r);
+//         match sel.try_ready() {
+//             Ok(0) => assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected)),
+//             _ => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default_when_disconnected() {
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r);
+//     match sel.try_ready() {
+//         Ok(0) => assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected)),
+//         _ => panic!(),
+//     }
+
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r);
+//     match sel.ready_timeout(ms(1000)) {
+//         Ok(0) => assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected)),
+//         _ => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     sel.send(&s);
+//     match sel.try_ready() {
+//         Ok(0) => assert_eq!(s.try_send(0), Err(TrySendError::Disconnected(0))),
+//         _ => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     sel.send(&s);
+//     match sel.ready_timeout(ms(1000)) {
+//         Ok(0) => assert_eq!(s.try_send(0), Err(TrySendError::Disconnected(0))),
+//         _ => panic!(),
+//     }
+// }
+
+// #[test]
+// fn default_only() {
+//     let start = Instant::now();
+
+//     let mut sel = Select::new();
+//     assert!(sel.try_ready().is_err());
+//     let now = Instant::now();
+//     assert!(now - start <= ms(50));
+
+//     let start = Instant::now();
+//     let mut sel = Select::new();
+//     assert!(sel.ready_timeout(ms(500)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(450));
+//     assert!(now - start <= ms(550));
+// }
+
+// #[test]
+// fn unblocks() {
+//     let (s1, r1) = bounded::<i32>(0);
+//     let (s2, r2) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s2.send(2).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         match sel.ready_timeout(ms(1000)) {
+//             Ok(1) => assert_eq!(r2.try_recv(), Ok(2)),
+//             _ => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             assert_eq!(r1.recv().unwrap(), 1);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.send(&s1);
+//         let oper2 = sel.send(&s2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => oper.send(&s1, 1).unwrap(),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn both_ready() {
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s1.send(1).unwrap();
+//             assert_eq!(r2.recv().unwrap(), 2);
+//         });
+
+//         for _ in 0..2 {
+//             let mut sel = Select::new();
+//             sel.recv(&r1);
+//             sel.send(&s2);
+//             match sel.ready() {
+//                 0 => assert_eq!(r1.try_recv(), Ok(1)),
+//                 1 => s2.try_send(2).unwrap(),
+//                 _ => panic!(),
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning1() {
+//     scope(|scope| {
+//         let (s1, r1) = unbounded::<i32>();
+//         let (_s2, r2) = unbounded::<i32>();
+//         let (s3, r3) = unbounded::<()>();
+
+//         scope.spawn(move |_| {
+//             r3.recv().unwrap();
+//             drop(s1.clone());
+//             assert!(r3.try_recv().is_err());
+//             s1.send(1).unwrap();
+//             r3.recv().unwrap();
+//         });
+
+//         s3.send(()).unwrap();
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         match sel.ready() {
+//             0 => drop(r1.try_recv()),
+//             1 => drop(r2.try_recv()),
+//             _ => panic!(),
+//         }
+
+//         s3.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning2() {
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+//     let (_s3, _r3) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             let mut sel = Select::new();
+//             sel.recv(&r1);
+//             sel.recv(&r2);
+//             match sel.ready() {
+//                 0 => panic!(),
+//                 1 => drop(r2.try_recv()),
+//                 _ => panic!(),
+//             }
+//         });
+
+//         thread::sleep(ms(500));
+//         drop(s1.clone());
+//         s2.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn preflight1() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r);
+//     match sel.ready() {
+//         0 => drop(r.try_recv()),
+//         _ => panic!(),
+//     }
+// }
+
+// #[test]
+// fn preflight2() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+
+//     let mut sel = Select::new();
+//     sel.recv(&r);
+//     match sel.ready() {
+//         0 => assert_eq!(r.try_recv(), Ok(())),
+//         _ => panic!(),
+//     }
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+// }
+
+// #[test]
+// fn preflight3() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+//     r.recv().unwrap();
+
+//     let mut sel = Select::new();
+//     sel.recv(&r);
+//     match sel.ready() {
+//         0 => assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected)),
+//         _ => panic!(),
+//     }
+// }
+
+// #[test]
+// fn duplicate_operations() {
+//     let (s, r) = unbounded::<i32>();
+//     let hit = vec![Cell::new(false); 4];
+
+//     while hit.iter().map(|h| h.get()).any(|hit| !hit) {
+//         let mut sel = Select::new();
+//         sel.recv(&r);
+//         sel.recv(&r);
+//         sel.send(&s);
+//         sel.send(&s);
+//         match sel.ready() {
+//             0 => {
+//                 assert!(r.try_recv().is_ok());
+//                 hit[0].set(true);
+//             }
+//             1 => {
+//                 assert!(r.try_recv().is_ok());
+//                 hit[1].set(true);
+//             }
+//             2 => {
+//                 assert!(s.try_send(0).is_ok());
+//                 hit[2].set(true);
+//             }
+//             3 => {
+//                 assert!(s.try_send(0).is_ok());
+//                 hit[3].set(true);
+//             }
+//             _ => panic!(),
+//         }
+//     }
+// }
+
+// #[test]
+// fn nesting() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     sel.send(&s);
+//     match sel.ready() {
+//         0 => {
+//             assert!(s.try_send(0).is_ok());
+
+//             let mut sel = Select::new();
+//             sel.recv(&r);
+//             match sel.ready() {
+//                 0 => {
+//                     assert_eq!(r.try_recv(), Ok(0));
+
+//                     let mut sel = Select::new();
+//                     sel.send(&s);
+//                     match sel.ready() {
+//                         0 => {
+//                             assert!(s.try_send(1).is_ok());
+
+//                             let mut sel = Select::new();
+//                             sel.recv(&r);
+//                             match sel.ready() {
+//                                 0 => {
+//                                     assert_eq!(r.try_recv(), Ok(1));
+//                                 }
+//                                 _ => panic!(),
+//                             }
+//                         }
+//                         _ => panic!(),
+//                     }
+//                 }
+//                 _ => panic!(),
+//             }
+//         }
+//         _ => panic!(),
+//     }
+// }
+
+// #[test]
+// fn stress_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded();
+//     let (s2, r2) = bounded(5);
+//     let (s3, r3) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 r3.recv().unwrap();
+
+//                 s2.send(i).unwrap();
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 sel.recv(&r1);
+//                 sel.recv(&r2);
+//                 match sel.ready() {
+//                     0 => assert_eq!(r1.try_recv(), Ok(i)),
+//                     1 => assert_eq!(r2.try_recv(), Ok(i)),
+//                     _ => panic!(),
+//                 }
+
+//                 s3.send(()).unwrap();
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 assert_eq!(r1.recv().unwrap(), i);
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 sel.send(&s1);
+//                 sel.send(&s2);
+//                 match sel.ready() {
+//                     0 => assert!(s1.try_send(i).is_ok()),
+//                     1 => assert!(s2.try_send(i).is_ok()),
+//                     _ => panic!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_mixed() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 sel.recv(&r1);
+//                 sel.send(&s2);
+//                 match sel.ready() {
+//                     0 => assert_eq!(r1.try_recv(), Ok(i)),
+//                     1 => assert!(s2.try_send(i).is_ok()),
+//                     _ => panic!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_timeout_two_threads() {
+//     const COUNT: usize = 20;
+
+//     let (s, r) = bounded(2);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 let done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     sel.send(&s);
+//                     match sel.ready_timeout(ms(100)) {
+//                         Err(_) => {}
+//                         Ok(0) => {
+//                             assert!(s.try_send(i).is_ok());
+//                             break;
+//                         }
+//                         Ok(_) => panic!(),
+//                     }
+//                 }
+//             }
+//         });
+
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 let mut done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     sel.recv(&r);
+//                     match sel.ready_timeout(ms(100)) {
+//                         Err(_) => {}
+//                         Ok(0) => {
+//                             assert_eq!(r.try_recv(), Ok(i));
+//                             done = true;
+//                         }
+//                         Ok(_) => panic!(),
+//                     }
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_recv_same_channel() {
+//     let (s, r) = bounded::<i32>(0);
+//     let mut sel = Select::new();
+//     sel.send(&s);
+//     sel.recv(&r);
+//     assert!(sel.ready_timeout(ms(100)).is_err());
+
+//     let (s, r) = unbounded::<i32>();
+//     let mut sel = Select::new();
+//     sel.send(&s);
+//     sel.recv(&r);
+//     match sel.ready_timeout(ms(100)) {
+//         Err(_) => panic!(),
+//         Ok(0) => assert!(s.try_send(0).is_ok()),
+//         Ok(_) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn channel_through_channel() {
+//     const COUNT: usize = 1000;
+
+//     type T = Box<dyn Any + Send>;
+
+//     for cap in 1..4 {
+//         let (s, r) = bounded::<T>(cap);
+
+//         scope(|scope| {
+//             scope.spawn(move |_| {
+//                 let mut s = s;
+
+//                 for _ in 0..COUNT {
+//                     let (new_s, new_r) = bounded(cap);
+//                     let new_r: T = Box::new(Some(new_r));
+
+//                     {
+//                         let mut sel = Select::new();
+//                         sel.send(&s);
+//                         match sel.ready() {
+//                             0 => assert!(s.try_send(new_r).is_ok()),
+//                             _ => panic!(),
+//                         }
+//                     }
+
+//                     s = new_s;
+//                 }
+//             });
+
+//             scope.spawn(move |_| {
+//                 let mut r = r;
+
+//                 for _ in 0..COUNT {
+//                     let new = {
+//                         let mut sel = Select::new();
+//                         sel.recv(&r);
+//                         match sel.ready() {
+//                             0 => r
+//                                 .try_recv()
+//                                 .unwrap()
+//                                 .downcast_mut::<Option<Receiver<T>>>()
+//                                 .unwrap()
+//                                 .take()
+//                                 .unwrap(),
+//                             _ => panic!(),
+//                         }
+//                     };
+//                     r = new;
+//                 }
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn fairness1() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let hits = vec![Cell::new(0usize); 4];
+//     for _ in 0..COUNT {
+//         let after = after(ms(0));
+//         let tick = tick(ms(0));
+
+//         let mut sel = Select::new();
+//         sel.recv(&r1);
+//         sel.recv(&r2);
+//         sel.recv(&after);
+//         sel.recv(&tick);
+//         match sel.ready() {
+//             0 => {
+//                 r1.try_recv().unwrap();
+//                 hits[0].set(hits[0].get() + 1);
+//             }
+//             1 => {
+//                 r2.try_recv().unwrap();
+//                 hits[1].set(hits[1].get() + 1);
+//             }
+//             2 => {
+//                 after.try_recv().unwrap();
+//                 hits[2].set(hits[2].get() + 1);
+//             }
+//             3 => {
+//                 tick.try_recv().unwrap();
+//                 hits[3].set(hits[3].get() + 1);
+//             }
+//             _ => panic!(),
+//         }
+//     }
+//     assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness2() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = bounded::<()>(1);
+//     let (s3, r3) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for _ in 0..COUNT {
+//                 let mut sel = Select::new();
+//                 let mut oper1 = None;
+//                 let mut oper2 = None;
+//                 if s1.is_empty() {
+//                     oper1 = Some(sel.send(&s1));
+//                 }
+//                 if s2.is_empty() {
+//                     oper2 = Some(sel.send(&s2));
+//                 }
+//                 let oper3 = sel.send(&s3);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     i if Some(i) == oper1 => assert!(oper.send(&s1, ()).is_ok()),
+//                     i if Some(i) == oper2 => assert!(oper.send(&s2, ()).is_ok()),
+//                     i if i == oper3 => assert!(oper.send(&s3, ()).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//         });
+
+//         let hits = vec![Cell::new(0usize); 3];
+//         for _ in 0..COUNT {
+//             let mut sel = Select::new();
+//             sel.recv(&r1);
+//             sel.recv(&r2);
+//             sel.recv(&r3);
+//             loop {
+//                 match sel.ready() {
+//                     0 => {
+//                         if r1.try_recv().is_ok() {
+//                             hits[0].set(hits[0].get() + 1);
+//                             break;
+//                         }
+//                     }
+//                     1 => {
+//                         if r2.try_recv().is_ok() {
+//                             hits[1].set(hits[1].get() + 1);
+//                             break;
+//                         }
+//                     }
+//                     2 => {
+//                         if r3.try_recv().is_ok() {
+//                             hits[2].set(hits[2].get() + 1);
+//                             break;
+//                         }
+//                     }
+//                     _ => unreachable!(),
+//                 }
+//             }
+//         }
+//         assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 10));
+//     })
+//     .unwrap();
+// }
diff --git a/vendor/flume/tests/same_channel.rs b/vendor/flume/tests/same_channel.rs
new file mode 100644
index 0000000..c6452ec
--- /dev/null
+++ b/vendor/flume/tests/same_channel.rs
@@ -0,0 +1,114 @@
+// extern crate crossbeam_channel;
+
+// use std::time::Duration;
+
+// use crossbeam_channel::{after, bounded, never, tick, unbounded};
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn after_same_channel() {
+//     let r = after(ms(50));
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     let r3 = after(ms(50));
+//     assert!(!r.same_channel(&r3));
+//     assert!(!r2.same_channel(&r3));
+
+//     let r4 = after(ms(100));
+//     assert!(!r.same_channel(&r4));
+//     assert!(!r2.same_channel(&r4));
+// }
+
+// #[test]
+// fn array_same_channel() {
+//     let (s, r) = bounded::<usize>(1);
+
+//     let s2 = s.clone();
+//     assert!(s.same_channel(&s2));
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     let (s3, r3) = bounded::<usize>(1);
+//     assert!(!s.same_channel(&s3));
+//     assert!(!s2.same_channel(&s3));
+//     assert!(!r.same_channel(&r3));
+//     assert!(!r2.same_channel(&r3));
+// }
+
+// #[test]
+// fn list_same_channel() {
+//     let (s, r) = unbounded::<usize>();
+
+//     let s2 = s.clone();
+//     assert!(s.same_channel(&s2));
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     let (s3, r3) = unbounded::<usize>();
+//     assert!(!s.same_channel(&s3));
+//     assert!(!s2.same_channel(&s3));
+//     assert!(!r.same_channel(&r3));
+//     assert!(!r2.same_channel(&r3));
+// }
+
+// #[test]
+// fn never_same_channel() {
+//     let r = never::<usize>();
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     // Never channel are always equal to one another.
+//     let r3 = never::<usize>();
+//     assert!(r.same_channel(&r3));
+//     assert!(r2.same_channel(&r3));
+// }
+
+// #[test]
+// fn tick_same_channel() {
+//     let r = tick(ms(50));
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     let r3 = tick(ms(50));
+//     assert!(!r.same_channel(&r3));
+//     assert!(!r2.same_channel(&r3));
+
+//     let r4 = tick(ms(100));
+//     assert!(!r.same_channel(&r4));
+//     assert!(!r2.same_channel(&r4));
+// }
+
+// #[test]
+// fn zero_same_channel() {
+//     let (s, r) = bounded::<usize>(0);
+
+//     let s2 = s.clone();
+//     assert!(s.same_channel(&s2));
+
+//     let r2 = r.clone();
+//     assert!(r.same_channel(&r2));
+
+//     let (s3, r3) = bounded::<usize>(0);
+//     assert!(!s.same_channel(&s3));
+//     assert!(!s2.same_channel(&s3));
+//     assert!(!r.same_channel(&r3));
+//     assert!(!r2.same_channel(&r3));
+// }
+
+// #[test]
+// fn different_flavors_same_channel() {
+//     let (s1, r1) = bounded::<usize>(0);
+//     let (s2, r2) = unbounded::<usize>();
+
+//     assert!(!s1.same_channel(&s2));
+//     assert!(!r1.same_channel(&r2));
+// }
diff --git a/vendor/flume/tests/select.rs b/vendor/flume/tests/select.rs
new file mode 100644
index 0000000..4fac9e9
--- /dev/null
+++ b/vendor/flume/tests/select.rs
@@ -0,0 +1,1304 @@
+// //! Tests for channel selection using the `Select` struct.
+
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, bounded, tick, unbounded, Receiver, Select, TryRecvError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn smoke1() {
+//     let (s1, r1) = unbounded::<usize>();
+//     let (s2, r2) = unbounded::<usize>();
+
+//     s1.send(1).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//         i if i == oper2 => panic!(),
+//         _ => unreachable!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => panic!(),
+//         i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn smoke2() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (_s2, r2) = unbounded::<i32>();
+//     let (_s3, r3) = unbounded::<i32>();
+//     let (_s4, r4) = unbounded::<i32>();
+//     let (s5, r5) = unbounded::<i32>();
+
+//     s5.send(5).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper3 = sel.recv(&r3);
+//     let oper4 = sel.recv(&r4);
+//     let oper5 = sel.recv(&r5);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => panic!(),
+//         i if i == oper2 => panic!(),
+//         i if i == oper3 => panic!(),
+//         i if i == oper4 => panic!(),
+//         i if i == oper5 => assert_eq!(oper.recv(&r5), Ok(5)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn disconnected() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             drop(s1);
+//             thread::sleep(ms(500));
+//             s2.send(5).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+
+//         r2.recv().unwrap();
+//     })
+//     .unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//             i if i == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             drop(s2);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => assert!(oper.recv(&r2).is_err()),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let _oper1 = sel.recv(&r1);
+//     let _oper2 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+
+//     drop(s1);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//             i if i == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert_eq!(oper.recv(&r2), Ok(2)),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let mut sel = Select::new();
+//     let _oper1 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+
+//     let mut sel = Select::new();
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn timeout() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(1500));
+//             s2.send(2).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => {}
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         let (s, r) = unbounded::<i32>();
+
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(500));
+//             drop(s);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => panic!(),
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//             }
+//             Ok(_) => unreachable!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default_when_disconnected() {
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.send(&s, 0).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.send(&s, 0).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+// }
+
+// #[test]
+// fn default_only() {
+//     let start = Instant::now();
+
+//     let mut sel = Select::new();
+//     let oper = sel.try_select();
+//     assert!(oper.is_err());
+//     let now = Instant::now();
+//     assert!(now - start <= ms(50));
+
+//     let start = Instant::now();
+//     let mut sel = Select::new();
+//     let oper = sel.select_timeout(ms(500));
+//     assert!(oper.is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(450));
+//     assert!(now - start <= ms(550));
+// }
+
+// #[test]
+// fn unblocks() {
+//     let (s1, r1) = bounded::<i32>(0);
+//     let (s2, r2) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s2.send(2).unwrap();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             assert_eq!(r1.recv().unwrap(), 1);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.send(&s1);
+//         let oper2 = sel.send(&s2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => oper.send(&s1, 1).unwrap(),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn both_ready() {
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s1.send(1).unwrap();
+//             assert_eq!(r2.recv().unwrap(), 2);
+//         });
+
+//         for _ in 0..2 {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.send(&s2);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//                 i if i == oper2 => oper.send(&s2, 2).unwrap(),
+//                 _ => unreachable!(),
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn loop_try() {
+//     const RUNS: usize = 20;
+
+//     for _ in 0..RUNS {
+//         let (s1, r1) = bounded::<i32>(0);
+//         let (s2, r2) = bounded::<i32>(0);
+//         let (s_end, r_end) = bounded::<()>(0);
+
+//         scope(|scope| {
+//             scope.spawn(|_| loop {
+//                 let mut done = false;
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.send(&s1);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.send(&s1, 1);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r_end);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.recv(&r_end);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+//             });
+
+//             scope.spawn(|_| loop {
+//                 if let Ok(x) = r2.try_recv() {
+//                     assert_eq!(x, 2);
+//                     break;
+//                 }
+
+//                 let mut done = false;
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r_end);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.recv(&r_end);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+//             });
+
+//             scope.spawn(|_| {
+//                 thread::sleep(ms(500));
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select_timeout(ms(1000));
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//                         i if i == oper2 => assert!(oper.send(&s2, 2).is_ok()),
+//                         _ => unreachable!(),
+//                     },
+//                 }
+
+//                 drop(s_end);
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn cloning1() {
+//     scope(|scope| {
+//         let (s1, r1) = unbounded::<i32>();
+//         let (_s2, r2) = unbounded::<i32>();
+//         let (s3, r3) = unbounded::<()>();
+
+//         scope.spawn(move |_| {
+//             r3.recv().unwrap();
+//             drop(s1.clone());
+//             assert!(r3.try_recv().is_err());
+//             s1.send(1).unwrap();
+//             r3.recv().unwrap();
+//         });
+
+//         s3.send(()).unwrap();
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper1 => drop(oper.recv(&r1)),
+//             i if i == oper2 => drop(oper.recv(&r2)),
+//             _ => unreachable!(),
+//         }
+
+//         s3.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning2() {
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+//     let (_s3, _r3) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.recv(&r2);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => drop(oper.recv(&r2)),
+//                 _ => unreachable!(),
+//             }
+//         });
+
+//         thread::sleep(ms(500));
+//         drop(s1.clone());
+//         s2.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn preflight1() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => drop(oper.recv(&r)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn preflight2() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert_eq!(oper.recv(&r), Ok(())),
+//         _ => unreachable!(),
+//     }
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+// }
+
+// #[test]
+// fn preflight3() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+//     r.recv().unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn duplicate_operations() {
+//     let (s, r) = unbounded::<i32>();
+//     let hit = vec![Cell::new(false); 4];
+
+//     while hit.iter().map(|h| h.get()).any(|hit| !hit) {
+//         let mut sel = Select::new();
+//         let oper0 = sel.recv(&r);
+//         let oper1 = sel.recv(&r);
+//         let oper2 = sel.send(&s);
+//         let oper3 = sel.send(&s);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper0 => {
+//                 assert!(oper.recv(&r).is_ok());
+//                 hit[0].set(true);
+//             }
+//             i if i == oper1 => {
+//                 assert!(oper.recv(&r).is_ok());
+//                 hit[1].set(true);
+//             }
+//             i if i == oper2 => {
+//                 assert!(oper.send(&s, 0).is_ok());
+//                 hit[2].set(true);
+//             }
+//             i if i == oper3 => {
+//                 assert!(oper.send(&s, 0).is_ok());
+//                 hit[3].set(true);
+//             }
+//             _ => unreachable!(),
+//         }
+//     }
+// }
+
+// #[test]
+// fn nesting() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => {
+//             assert!(oper.send(&s, 0).is_ok());
+
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => {
+//                     assert_eq!(oper.recv(&r), Ok(0));
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.send(&s);
+//                     let oper = sel.select();
+//                     match oper.index() {
+//                         i if i == oper1 => {
+//                             assert!(oper.send(&s, 1).is_ok());
+
+//                             let mut sel = Select::new();
+//                             let oper1 = sel.recv(&r);
+//                             let oper = sel.select();
+//                             match oper.index() {
+//                                 i if i == oper1 => {
+//                                     assert_eq!(oper.recv(&r), Ok(1));
+//                                 }
+//                                 _ => unreachable!(),
+//                             }
+//                         }
+//                         _ => unreachable!(),
+//                     }
+//                 }
+//                 _ => unreachable!(),
+//             }
+//         }
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn stress_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded();
+//     let (s2, r2) = bounded(5);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 r3.recv().unwrap();
+
+//                 s2.send(i).unwrap();
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.recv(&r2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert_eq!(oper.recv(&r2), Ok(i)),
+//                     _ => unreachable!(),
+//                 }
+
+//                 s3.send(()).unwrap();
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 assert_eq!(r1.recv().unwrap(), i);
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.send(&s1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert!(oper.send(&s1, i).is_ok()),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_mixed() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_timeout_two_threads() {
+//     const COUNT: usize = 20;
+
+//     let (s, r) = bounded(2);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 let done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.send(&s);
+//                     let oper = sel.select_timeout(ms(100));
+//                     match oper {
+//                         Err(_) => {}
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => {
+//                                 assert!(oper.send(&s, i).is_ok());
+//                                 break;
+//                             }
+//                             _ => unreachable!(),
+//                         },
+//                     }
+//                 }
+//             }
+//         });
+
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 let mut done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r);
+//                     let oper = sel.select_timeout(ms(100));
+//                     match oper {
+//                         Err(_) => {}
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => {
+//                                 assert_eq!(oper.recv(&r), Ok(i));
+//                                 done = true;
+//                             }
+//                             _ => unreachable!(),
+//                         },
+//                     }
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_recv_same_channel() {
+//     let (s, r) = bounded::<i32>(0);
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper2 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(100));
+//     match oper {
+//         Err(_) => {}
+//         Ok(oper) => match oper.index() {
+//             ix if ix == oper1 => panic!(),
+//             ix if ix == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, r) = unbounded::<i32>();
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper2 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(100));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             ix if ix == oper1 => assert!(oper.send(&s, 0).is_ok()),
+//             ix if ix == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+// }
+
+// #[test]
+// fn matching() {
+//     const THREADS: usize = 44;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper2 = sel.send(&s);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn matching_with_leftover() {
+//     const THREADS: usize = 55;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper2 = sel.send(&s);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//         s.send(!0).unwrap();
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn channel_through_channel() {
+//     const COUNT: usize = 1000;
+
+//     type T = Box<dyn Any + Send>;
+
+//     for cap in 0..3 {
+//         let (s, r) = bounded::<T>(cap);
+
+//         scope(|scope| {
+//             scope.spawn(move |_| {
+//                 let mut s = s;
+
+//                 for _ in 0..COUNT {
+//                     let (new_s, new_r) = bounded(cap);
+//                     let new_r: T = Box::new(Some(new_r));
+
+//                     {
+//                         let mut sel = Select::new();
+//                         let oper1 = sel.send(&s);
+//                         let oper = sel.select();
+//                         match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.send(&s, new_r).is_ok()),
+//                             _ => unreachable!(),
+//                         }
+//                     }
+
+//                     s = new_s;
+//                 }
+//             });
+
+//             scope.spawn(move |_| {
+//                 let mut r = r;
+
+//                 for _ in 0..COUNT {
+//                     let new = {
+//                         let mut sel = Select::new();
+//                         let oper1 = sel.recv(&r);
+//                         let oper = sel.select();
+//                         match oper.index() {
+//                             ix if ix == oper1 => oper
+//                                 .recv(&r)
+//                                 .unwrap()
+//                                 .downcast_mut::<Option<Receiver<T>>>()
+//                                 .unwrap()
+//                                 .take()
+//                                 .unwrap(),
+//                             _ => unreachable!(),
+//                         }
+//                     };
+//                     r = new;
+//                 }
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_try() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r1);
+//                     let oper2 = sel.recv(&r2);
+//                     let oper = sel.try_select();
+//                     match oper {
+//                         Err(_) => unreachable!(),
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.recv(&r1).is_ok()),
+//                             ix if ix == oper2 => assert!(oper.recv(&r2).is_ok()),
+//                             _ => unreachable!(),
+//                         },
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_timeout() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r1);
+//                     let oper2 = sel.recv(&r2);
+//                     let oper = sel.select_timeout(ms(0));
+//                     match oper {
+//                         Err(_) => unreachable!(),
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.recv(&r1).is_ok()),
+//                             ix if ix == oper2 => assert!(oper.recv(&r2).is_ok()),
+//                             _ => unreachable!(),
+//                         },
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn fairness1() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let hits = vec![Cell::new(0usize); 4];
+//     for _ in 0..COUNT {
+//         let after = after(ms(0));
+//         let tick = tick(ms(0));
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper3 = sel.recv(&after);
+//         let oper4 = sel.recv(&tick);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper1 => {
+//                 oper.recv(&r1).unwrap();
+//                 hits[0].set(hits[0].get() + 1);
+//             }
+//             i if i == oper2 => {
+//                 oper.recv(&r2).unwrap();
+//                 hits[1].set(hits[1].get() + 1);
+//             }
+//             i if i == oper3 => {
+//                 oper.recv(&after).unwrap();
+//                 hits[2].set(hits[2].get() + 1);
+//             }
+//             i if i == oper4 => {
+//                 oper.recv(&tick).unwrap();
+//                 hits[3].set(hits[3].get() + 1);
+//             }
+//             _ => unreachable!(),
+//         }
+//     }
+//     assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness2() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = bounded::<()>(1);
+//     let (s3, r3) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for _ in 0..COUNT {
+//                 let mut sel = Select::new();
+//                 let mut oper1 = None;
+//                 let mut oper2 = None;
+//                 if s1.is_empty() {
+//                     oper1 = Some(sel.send(&s1));
+//                 }
+//                 if s2.is_empty() {
+//                     oper2 = Some(sel.send(&s2));
+//                 }
+//                 let oper3 = sel.send(&s3);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     i if Some(i) == oper1 => assert!(oper.send(&s1, ()).is_ok()),
+//                     i if Some(i) == oper2 => assert!(oper.send(&s2, ()).is_ok()),
+//                     i if i == oper3 => assert!(oper.send(&s3, ()).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//         });
+
+//         let hits = vec![Cell::new(0usize); 3];
+//         for _ in 0..COUNT {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.recv(&r2);
+//             let oper3 = sel.recv(&r3);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => {
+//                     oper.recv(&r1).unwrap();
+//                     hits[0].set(hits[0].get() + 1);
+//                 }
+//                 i if i == oper2 => {
+//                     oper.recv(&r2).unwrap();
+//                     hits[1].set(hits[1].get() + 1);
+//                 }
+//                 i if i == oper3 => {
+//                     oper.recv(&r3).unwrap();
+//                     hits[2].set(hits[2].get() + 1);
+//                 }
+//                 _ => unreachable!(),
+//             }
+//         }
+//         assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 50));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn sync_and_clone() {
+//     const THREADS: usize = 20;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper2 = sel.send(&s);
+//     let sel = &sel;
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 let mut sel = sel.clone();
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn send_and_clone() {
+//     const THREADS: usize = 20;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper2 = sel.send(&s);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             let mut sel = sel.clone();
+//             scope.spawn(move |_| {
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn reuse() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.send(&s2);
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
diff --git a/vendor/flume/tests/select_macro.rs b/vendor/flume/tests/select_macro.rs
new file mode 100644
index 0000000..367d8dd
--- /dev/null
+++ b/vendor/flume/tests/select_macro.rs
@@ -0,0 +1,1440 @@
+// //! Tests for the `select!` macro.
+
+// #![deny(unsafe_code)]
+
+// #[macro_use]
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::ops::Deref;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, bounded, never, tick, unbounded};
+// use crossbeam_channel::{Receiver, RecvError, SendError, Sender, TryRecvError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn smoke1() {
+//     let (s1, r1) = unbounded::<usize>();
+//     let (s2, r2) = unbounded::<usize>();
+
+//     s1.send(1).unwrap();
+
+//     select! {
+//         recv(r1) -> v => assert_eq!(v, Ok(1)),
+//         recv(r2) -> _ => panic!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> v => assert_eq!(v, Ok(2)),
+//     }
+// }
+
+// #[test]
+// fn smoke2() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (_s2, r2) = unbounded::<i32>();
+//     let (_s3, r3) = unbounded::<i32>();
+//     let (_s4, r4) = unbounded::<i32>();
+//     let (s5, r5) = unbounded::<i32>();
+
+//     s5.send(5).unwrap();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> _ => panic!(),
+//         recv(r3) -> _ => panic!(),
+//         recv(r4) -> _ => panic!(),
+//         recv(r5) -> v => assert_eq!(v, Ok(5)),
+//     }
+// }
+
+// #[test]
+// fn disconnected() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             drop(s1);
+//             thread::sleep(ms(500));
+//             s2.send(5).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> v => assert!(v.is_err()),
+//             recv(r2) -> _ => panic!(),
+//             default(ms(1000)) => panic!(),
+//         }
+
+//         r2.recv().unwrap();
+//     })
+//     .unwrap();
+
+//     select! {
+//         recv(r1) -> v => assert!(v.is_err()),
+//         recv(r2) -> _ => panic!(),
+//         default(ms(1000)) => panic!(),
+//     }
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             drop(s2);
+//         });
+
+//         select! {
+//             recv(r2) -> v => assert!(v.is_err()),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> _ => panic!(),
+//         default => {}
+//     }
+
+//     drop(s1);
+
+//     select! {
+//         recv(r1) -> v => assert!(v.is_err()),
+//         recv(r2) -> _ => panic!(),
+//         default => panic!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     select! {
+//         recv(r2) -> v => assert_eq!(v, Ok(2)),
+//         default => panic!(),
+//     }
+
+//     select! {
+//         recv(r2) -> _ => panic!(),
+//         default => {},
+//     }
+
+//     select! {
+//         default => {},
+//     }
+// }
+
+// #[test]
+// fn timeout() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(1500));
+//             s2.send(2).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> _ => panic!(),
+//             default(ms(1000)) => {},
+//         }
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> v => assert_eq!(v, Ok(2)),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         let (s, r) = unbounded::<i32>();
+
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(500));
+//             drop(s);
+//         });
+
+//         select! {
+//             default(ms(1000)) => {
+//                 select! {
+//                     recv(r) -> v => assert!(v.is_err()),
+//                     default => panic!(),
+//                 }
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default_when_disconnected() {
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> res => assert!(res.is_err()),
+//         default => panic!(),
+//     }
+
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> res => assert!(res.is_err()),
+//         default(ms(1000)) => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     select! {
+//         send(s, 0) -> res => assert!(res.is_err()),
+//         default => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     select! {
+//         send(s, 0) -> res => assert!(res.is_err()),
+//         default(ms(1000)) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn default_only() {
+//     let start = Instant::now();
+//     select! {
+//         default => {}
+//     }
+//     let now = Instant::now();
+//     assert!(now - start <= ms(50));
+
+//     let start = Instant::now();
+//     select! {
+//         default(ms(500)) => {}
+//     }
+//     let now = Instant::now();
+//     assert!(now - start >= ms(450));
+//     assert!(now - start <= ms(550));
+// }
+
+// #[test]
+// fn unblocks() {
+//     let (s1, r1) = bounded::<i32>(0);
+//     let (s2, r2) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s2.send(2).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> v => assert_eq!(v, Ok(2)),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             assert_eq!(r1.recv().unwrap(), 1);
+//         });
+
+//         select! {
+//             send(s1, 1) -> _ => {},
+//             send(s2, 2) -> _ => panic!(),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn both_ready() {
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s1.send(1).unwrap();
+//             assert_eq!(r2.recv().unwrap(), 2);
+//         });
+
+//         for _ in 0..2 {
+//             select! {
+//                 recv(r1) -> v => assert_eq!(v, Ok(1)),
+//                 send(s2, 2) -> _ => {},
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn loop_try() {
+//     const RUNS: usize = 20;
+
+//     for _ in 0..RUNS {
+//         let (s1, r1) = bounded::<i32>(0);
+//         let (s2, r2) = bounded::<i32>(0);
+//         let (s_end, r_end) = bounded::<()>(0);
+
+//         scope(|scope| {
+//             scope.spawn(|_| loop {
+//                 select! {
+//                     send(s1, 1) -> _ => break,
+//                     default => {}
+//                 }
+
+//                 select! {
+//                     recv(r_end) -> _ => break,
+//                     default => {}
+//                 }
+//             });
+
+//             scope.spawn(|_| loop {
+//                 if let Ok(x) = r2.try_recv() {
+//                     assert_eq!(x, 2);
+//                     break;
+//                 }
+
+//                 select! {
+//                     recv(r_end) -> _ => break,
+//                     default => {}
+//                 }
+//             });
+
+//             scope.spawn(|_| {
+//                 thread::sleep(ms(500));
+
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(1)),
+//                     send(s2, 2) -> _ => {},
+//                     default(ms(500)) => panic!(),
+//                 }
+
+//                 drop(s_end);
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn cloning1() {
+//     scope(|scope| {
+//         let (s1, r1) = unbounded::<i32>();
+//         let (_s2, r2) = unbounded::<i32>();
+//         let (s3, r3) = unbounded::<()>();
+
+//         scope.spawn(move |_| {
+//             r3.recv().unwrap();
+//             drop(s1.clone());
+//             assert_eq!(r3.try_recv(), Err(TryRecvError::Empty));
+//             s1.send(1).unwrap();
+//             r3.recv().unwrap();
+//         });
+
+//         s3.send(()).unwrap();
+
+//         select! {
+//             recv(r1) -> _ => {},
+//             recv(r2) -> _ => {},
+//         }
+
+//         s3.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning2() {
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+//     let (_s3, _r3) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r1) -> _ => panic!(),
+//                 recv(r2) -> _ => {},
+//             }
+//         });
+
+//         thread::sleep(ms(500));
+//         drop(s1.clone());
+//         s2.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn preflight1() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     select! {
+//         recv(r) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn preflight2() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+
+//     select! {
+//         recv(r) -> v => assert!(v.is_ok()),
+//     }
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+// }
+
+// #[test]
+// fn preflight3() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+//     r.recv().unwrap();
+
+//     select! {
+//         recv(r) -> v => assert!(v.is_err())
+//     }
+// }
+
+// #[test]
+// fn duplicate_operations() {
+//     let (s, r) = unbounded::<i32>();
+//     let mut hit = [false; 4];
+
+//     while hit.iter().any(|hit| !hit) {
+//         select! {
+//             recv(r) -> _ => hit[0] = true,
+//             recv(r) -> _ => hit[1] = true,
+//             send(s, 0) -> _ => hit[2] = true,
+//             send(s, 0) -> _ => hit[3] = true,
+//         }
+//     }
+// }
+
+// #[test]
+// fn nesting() {
+//     let (s, r) = unbounded::<i32>();
+
+//     select! {
+//         send(s, 0) -> _ => {
+//             select! {
+//                 recv(r) -> v => {
+//                     assert_eq!(v, Ok(0));
+//                     select! {
+//                         send(s, 1) -> _ => {
+//                             select! {
+//                                 recv(r) -> v => {
+//                                     assert_eq!(v, Ok(1));
+//                                 }
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// #[test]
+// #[should_panic(expected = "send panicked")]
+// fn panic_sender() {
+//     fn get() -> Sender<i32> {
+//         panic!("send panicked")
+//     }
+
+//     #[allow(unreachable_code)]
+//     {
+//         select! {
+//             send(get(), panic!()) -> _ => {}
+//         }
+//     }
+// }
+
+// #[test]
+// #[should_panic(expected = "recv panicked")]
+// fn panic_receiver() {
+//     fn get() -> Receiver<i32> {
+//         panic!("recv panicked")
+//     }
+
+//     select! {
+//         recv(get()) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn stress_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded();
+//     let (s2, r2) = bounded(5);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 r3.recv().unwrap();
+
+//                 s2.send(i).unwrap();
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(i)),
+//                     recv(r2) -> v => assert_eq!(v, Ok(i)),
+//                 }
+
+//                 s3.send(()).unwrap();
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 assert_eq!(r1.recv().unwrap(), i);
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     send(s1, i) -> _ => {},
+//                     send(s2, i) -> _ => {},
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_mixed() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(i)),
+//                     send(s2, i) -> _ => {},
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_timeout_two_threads() {
+//     const COUNT: usize = 20;
+
+//     let (s, r) = bounded(2);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 loop {
+//                     select! {
+//                         send(s, i) -> _ => break,
+//                         default(ms(100)) => {}
+//                     }
+//                 }
+//             }
+//         });
+
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 loop {
+//                     select! {
+//                         recv(r) -> v => {
+//                             assert_eq!(v, Ok(i));
+//                             break;
+//                         }
+//                         default(ms(100)) => {}
+//                     }
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_recv_same_channel() {
+//     let (s, r) = bounded::<i32>(0);
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         recv(r) -> _ => panic!(),
+//         default(ms(500)) => {}
+//     }
+
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         send(s, 0) -> _ => {},
+//         recv(r) -> _ => panic!(),
+//         default(ms(500)) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn matching() {
+//     const THREADS: usize = 44;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 select! {
+//                     recv(r) -> v => assert_ne!(v.unwrap(), i),
+//                     send(s, i) -> _ => {},
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn matching_with_leftover() {
+//     const THREADS: usize = 55;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 select! {
+//                     recv(r) -> v => assert_ne!(v.unwrap(), i),
+//                     send(s, i) -> _ => {},
+//                 }
+//             });
+//         }
+//         s.send(!0).unwrap();
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn channel_through_channel() {
+//     const COUNT: usize = 1000;
+
+//     type T = Box<dyn Any + Send>;
+
+//     for cap in 0..3 {
+//         let (s, r) = bounded::<T>(cap);
+
+//         scope(|scope| {
+//             scope.spawn(move |_| {
+//                 let mut s = s;
+
+//                 for _ in 0..COUNT {
+//                     let (new_s, new_r) = bounded(cap);
+//                     let new_r: T = Box::new(Some(new_r));
+
+//                     select! {
+//                         send(s, new_r) -> _ => {}
+//                     }
+
+//                     s = new_s;
+//                 }
+//             });
+
+//             scope.spawn(move |_| {
+//                 let mut r = r;
+
+//                 for _ in 0..COUNT {
+//                     r = select! {
+//                         recv(r) -> msg => {
+//                             msg.unwrap()
+//                                 .downcast_mut::<Option<Receiver<T>>>()
+//                                 .unwrap()
+//                                 .take()
+//                                 .unwrap()
+//                         }
+//                     }
+//                 }
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_default() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+//                     select! {
+//                         recv(r1) -> _ => {}
+//                         recv(r2) -> _ => {}
+//                         default => unreachable!()
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_timeout() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+//                     select! {
+//                         recv(r1) -> _ => {}
+//                         recv(r2) -> _ => {}
+//                         default(ms(0)) => unreachable!()
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn fairness1() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 4];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r1) -> _ => hits[0] += 1,
+//             recv(r2) -> _ => hits[1] += 1,
+//             recv(after(ms(0))) -> _ => hits[2] += 1,
+//             recv(tick(ms(0))) -> _ => hits[3] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness2() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = bounded::<()>(1);
+//     let (s3, r3) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             let (hole, _r) = bounded(0);
+
+//             for _ in 0..COUNT {
+//                 let s1 = if s1.is_empty() { &s1 } else { &hole };
+//                 let s2 = if s2.is_empty() { &s2 } else { &hole };
+
+//                 select! {
+//                     send(s1, ()) -> res => assert!(res.is_ok()),
+//                     send(s2, ()) -> res => assert!(res.is_ok()),
+//                     send(s3, ()) -> res => assert!(res.is_ok()),
+//                 }
+//             }
+//         });
+
+//         let hits = vec![Cell::new(0usize); 3];
+//         for _ in 0..COUNT {
+//             select! {
+//                 recv(r1) -> _ => hits[0].set(hits[0].get() + 1),
+//                 recv(r2) -> _ => hits[1].set(hits[1].get() + 1),
+//                 recv(r3) -> _ => hits[2].set(hits[2].get() + 1),
+//             }
+//         }
+//         assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 50));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn fairness_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 2];
+//     while hits[0] + hits[1] < COUNT {
+//         select! {
+//             recv(r1) -> _ => hits[0] += 1,
+//             recv(r2) -> _ => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / 4));
+// }
+
+// #[test]
+// fn fairness_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, _r1) = bounded::<()>(COUNT);
+//     let (s2, _r2) = unbounded::<()>();
+
+//     let mut hits = [0usize; 2];
+//     for _ in 0..COUNT {
+//         select! {
+//             send(s1, ()) -> _ => hits[0] += 1,
+//             send(s2, ()) -> _ => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / 4));
+// }
+
+// #[test]
+// fn references() {
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         send(s, 0) -> _ => {}
+//         recv(r) -> _ => {}
+//     }
+//     select! {
+//         send(&&&&s, 0) -> _ => {}
+//         recv(&&&&r) -> _ => {}
+//     }
+//     select! {
+//         recv(Some(&r).unwrap_or(&never())) -> _ => {},
+//         default => {}
+//     }
+//     select! {
+//         recv(Some(r).unwrap_or(never())) -> _ => {},
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn case_blocks() {
+//     let (s, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> _ => 3.0,
+//         recv(r) -> _ => loop {
+//             unreachable!()
+//         },
+//         recv(r) -> _ => match 7 + 3 {
+//             _ => unreachable!()
+//         },
+//         default => 7.
+//     };
+
+//     select! {
+//         recv(r) -> msg => if msg.is_ok() {
+//             unreachable!()
+//         },
+//         default => ()
+//     }
+
+//     drop(s);
+// }
+
+// #[test]
+// fn move_handles() {
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         recv((move || r)()) -> _ => {}
+//         send((move || s)(), 0) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn infer_types() {
+//     let (s, r) = unbounded();
+//     select! {
+//         recv(r) -> _ => {}
+//         default => {}
+//     }
+//     s.send(()).unwrap();
+
+//     let (s, r) = unbounded();
+//     select! {
+//         send(s, ()) -> _ => {}
+//     }
+//     r.recv().unwrap();
+// }
+
+// #[test]
+// fn default_syntax() {
+//     let (s, r) = bounded::<i32>(0);
+
+//     select! {
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         default() => {}
+//     }
+//     select! {
+//         default => {}
+//     }
+//     select! {
+//         default() => {}
+//     }
+// }
+
+// #[test]
+// fn same_variable_name() {
+//     let (_, r) = unbounded::<i32>();
+//     select! {
+//         recv(r) -> r => assert!(r.is_err()),
+//     }
+// }
+
+// #[test]
+// fn handles_on_heap() {
+//     let (s, r) = unbounded::<i32>();
+//     let (s, r) = (Box::new(s), Box::new(r));
+
+//     select! {
+//         send(*s, 0) -> _ => {}
+//         recv(*r) -> _ => {}
+//         default => {}
+//     }
+
+//     drop(s);
+//     drop(r);
+// }
+
+// #[test]
+// fn once_blocks() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     select! {
+//         send(s, 0) -> _ => drop(once),
+//     }
+
+//     let once = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         send(s, 0) -> _ => drop(once1),
+//         default => drop(once2),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once1),
+//         default => drop(once2),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once1),
+//         send(s, 0) -> _ => drop(once2),
+//     }
+// }
+
+// #[test]
+// fn once_receiver() {
+//     let (_, r) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     let get = move || {
+//         drop(once);
+//         r
+//     };
+
+//     select! {
+//         recv(get()) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn once_sender() {
+//     let (s, _) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     let get = move || {
+//         drop(once);
+//         s
+//     };
+
+//     select! {
+//         send(get(), 5) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn parse_nesting() {
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> _ => {}
+//         recv(r) -> _ => {
+//             select! {
+//                 recv(r) -> _ => {}
+//                 recv(r) -> _ => {
+//                     select! {
+//                         recv(r) -> _ => {}
+//                         recv(r) -> _ => {
+//                             select! {
+//                                 default => {}
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// #[test]
+// fn evaluate() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         send(s, 0) -> _ => "bar".to_owned(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "bar");
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "foo");
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "baz");
+// }
+
+// #[test]
+// fn deref() {
+//     use crossbeam_channel as cc;
+
+//     struct Sender<T>(cc::Sender<T>);
+//     struct Receiver<T>(cc::Receiver<T>);
+
+//     impl<T> Deref for Receiver<T> {
+//         type Target = cc::Receiver<T>;
+
+//         fn deref(&self) -> &Self::Target {
+//             &self.0
+//         }
+//     }
+
+//     impl<T> Deref for Sender<T> {
+//         type Target = cc::Sender<T>;
+
+//         fn deref(&self) -> &Self::Target {
+//             &self.0
+//         }
+//     }
+
+//     let (s, r) = bounded::<i32>(0);
+//     let (s, r) = (Sender(s), Receiver(r));
+
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn result_types() {
+//     let (s, _) = bounded::<i32>(0);
+//     let (_, r) = bounded::<i32>(0);
+
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//     }
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//         default => {}
+//     }
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//         default(ms(0)) => {}
+//     }
+
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//     }
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         default => {}
+//     }
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         default(ms(0)) => {}
+//     }
+
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//     }
+// }
+
+// #[test]
+// fn try_recv() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> _ => panic!(),
+//                 default => {}
+//             }
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//                 default => panic!(),
+//             }
+//             thread::sleep(ms(500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//                 default => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(9)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//             }
+//             select! {
+//                 send(s, 9) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv_timeout() {
+//     let (s, r) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> _ => panic!(),
+//                 default(ms(1000)) => {}
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//                 default(ms(1000)) => panic!(),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//                 default(ms(1000)) => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn try_send() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> _ => panic!(),
+//                 default => {}
+//             }
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//                 default => panic!(),
+//             }
+//             thread::sleep(ms(500));
+//             select! {
+//                 send(s, 8) -> res => assert_eq!(res, Err(SendError(8))),
+//                 default => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 9) -> res => res.unwrap(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(9)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_timeout() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> _ => panic!(),
+//                 default(ms(1000)) => {}
+//             }
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//                 default(ms(1000)) => panic!(),
+//             }
+//             select! {
+//                 send(s, 9) -> res => assert_eq!(res, Err(SendError(9))),
+//                 default(ms(1000)) => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn disconnect_wakes_sender() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, ()) -> res => assert_eq!(res, Err(SendError(()))),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             drop(r);
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn disconnect_wakes_receiver() {
+//     let (s, r) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> res => assert_eq!(res, Err(RecvError)),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             drop(s);
+//         });
+//     })
+//     .unwrap();
+// }
diff --git a/vendor/flume/tests/stream.rs b/vendor/flume/tests/stream.rs
new file mode 100644
index 0000000..e3b32cd
--- /dev/null
+++ b/vendor/flume/tests/stream.rs
@@ -0,0 +1,255 @@
+#[cfg(feature = "async")]
+use {
+    flume::*,
+    futures::{stream::FuturesUnordered, StreamExt, TryFutureExt},
+    async_std::prelude::FutureExt,
+    std::time::Duration,
+};
+use futures::{stream, Stream};
+
+#[cfg(feature = "async")]
+#[test]
+fn stream_recv() {
+    let (tx, rx) = unbounded();
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        tx.send(42u32).unwrap();
+        println!("sent");
+    });
+
+    async_std::task::block_on(async {
+        println!("receiving...");
+        let x = rx.stream().next().await;
+        println!("received");
+        assert_eq!(x, Some(42));
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn stream_recv_disconnect() {
+    let (tx, rx) = bounded::<i32>(0);
+
+    let t = std::thread::spawn(move || {
+        tx.send(42);
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        drop(tx)
+    });
+
+    async_std::task::block_on(async {
+        let mut stream = rx.into_stream();
+        assert_eq!(stream.next().await, Some(42));
+        assert_eq!(stream.next().await, None);
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn stream_recv_drop_recv() {
+    let (tx, rx) = bounded::<i32>(10);
+
+    let rx2 = rx.clone();
+    let mut stream = rx.into_stream();
+
+    async_std::task::block_on(async {
+        let res = async_std::future::timeout(
+            std::time::Duration::from_millis(500),
+            stream.next()
+        ).await;
+
+        assert!(res.is_err());
+    });
+
+    let t = std::thread::spawn(move || {
+        async_std::task::block_on(async {
+            rx2.stream().next().await
+        })
+    });
+
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    tx.send(42).unwrap();
+
+    drop(stream);
+
+    assert_eq!(t.join().unwrap(), Some(42))
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn r#stream_drop_send_disconnect() {
+    let (tx, rx) = bounded::<i32>(1);
+
+    let t = std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        drop(tx);
+    });
+
+    async_std::task::block_on(async {
+        let mut stream = rx.into_stream();
+        assert_eq!(stream.next().await, None);
+    });
+
+    t.join().unwrap();
+}
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn stream_send_1_million_no_drop_or_reorder() {
+    #[derive(Debug)]
+    enum Message {
+        Increment {
+            old: u64,
+        },
+        ReturnCount,
+    }
+
+    let (tx, rx) = unbounded();
+
+    let t = async_std::task::spawn(async move {
+        let mut count = 0u64;
+        let mut stream = rx.into_stream();
+
+        while let Some(Message::Increment { old }) = stream.next().await {
+            assert_eq!(old, count);
+            count += 1;
+        }
+
+        count
+    });
+
+    for next in 0..1_000_000 {
+        tx.send(Message::Increment { old: next }).unwrap();
+    }
+
+    tx.send(Message::ReturnCount).unwrap();
+
+    let count = t.await;
+    assert_eq!(count, 1_000_000)
+}
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn parallel_streams_and_async_recv() {
+    let (tx, rx) = flume::unbounded();
+    let rx = &rx;
+    let send_fut = async move {
+        let n_sends: usize = 100000;
+        for _ in 0..n_sends {
+            tx.send_async(()).await.unwrap();
+        }
+    };
+
+    async_std::task::spawn(
+        send_fut
+            .timeout(Duration::from_secs(5))
+            .map_err(|_| panic!("Send timed out!"))
+    );
+
+    let mut futures_unordered = (0..250)
+        .map(|n| async move {
+            if n % 2 == 0 {
+                let mut stream = rx.stream();
+                while let Some(()) = stream.next().await {}
+            } else {
+                while let Ok(()) = rx.recv_async().await {}
+            }
+
+        })
+        .collect::<FuturesUnordered<_>>();
+
+    let recv_fut = async {
+        while futures_unordered.next().await.is_some() {}
+    };
+
+    recv_fut
+        .timeout(Duration::from_secs(5))
+        .map_err(|_| panic!("Receive timed out!"))
+        .await
+        .unwrap();
+}
+
+#[cfg(feature = "async")]
+#[test]
+fn stream_no_double_wake() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Arc;
+    use std::pin::Pin;
+    use std::task::Context;
+    use futures::task::{waker, ArcWake};
+    use futures::Stream;
+
+    let count = Arc::new(AtomicUsize::new(0));
+
+    // all this waker does is count how many times it is called
+    struct CounterWaker {
+        count: Arc<AtomicUsize>,
+    }
+
+    impl ArcWake for CounterWaker {
+        fn wake_by_ref(arc_self: &Arc<Self>) {
+            arc_self.count.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    // create waker and context
+    let w = CounterWaker {
+        count: count.clone(),
+    };
+    let w = waker(Arc::new(w));
+    let cx = &mut Context::from_waker(&w);
+
+    // create unbounded channel
+    let (tx, rx) = unbounded::<()>();
+    let mut stream = rx.stream();
+
+    // register waker with stream
+    let _ = Pin::new(&mut stream).poll_next(cx);
+
+    // send multiple items
+    tx.send(()).unwrap();
+    tx.send(()).unwrap();
+    tx.send(()).unwrap();
+
+    // verify that stream is only woken up once.
+    assert_eq!(count.load(Ordering::SeqCst), 1);
+}
+
+#[cfg(feature = "async")]
+#[async_std::test]
+async fn stream_forward_issue_55() { // https://github.com/zesterer/flume/issues/55
+    fn dummy_stream() -> impl Stream<Item = usize> {
+        stream::unfold(0, |count| async move {
+            if count < 1000 {
+                Some((count, count + 1))
+            } else {
+                None
+            }
+        })
+    }
+
+    let (send_task, recv_task) = {
+        use futures::SinkExt;
+        let (tx, rx) = flume::bounded(100);
+
+        let send_task = dummy_stream()
+            .map(|i| Ok(i))
+            .forward(tx.into_sink().sink_map_err(|e| {
+                panic!("send error:{:#?}", e)
+            }));
+
+        let recv_task = rx
+            .into_stream()
+            .for_each(|item| async move {});
+        (send_task, recv_task)
+    };
+
+    let jh = async_std::task::spawn(send_task);
+    async_std::task::block_on(recv_task);
+    jh.await.unwrap();
+}
diff --git a/vendor/flume/tests/thread_locals.rs b/vendor/flume/tests/thread_locals.rs
new file mode 100644
index 0000000..acde751
--- /dev/null
+++ b/vendor/flume/tests/thread_locals.rs
@@ -0,0 +1,53 @@
+// //! Tests that make sure accessing thread-locals while exiting the thread doesn't cause panics.
+
+// extern crate crossbeam_utils;
+
+// use std::thread;
+// use std::time::Duration;
+
+// use flume::unbounded;
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// #[cfg_attr(target_os = "macos", ignore = "TLS is destroyed too early on macOS")]
+// fn use_while_exiting() {
+//     struct Foo;
+
+//     impl Drop for Foo {
+//         fn drop(&mut self) {
+//             // A blocking operation after the thread-locals have been dropped. This will attempt to
+//             // use the thread-locals and must not panic.
+//             let (_s, r) = unbounded::<()>();
+//             select! {
+//                 recv(r) -> _ => {}
+//                 default(ms(100)) => {}
+//             }
+//         }
+//     }
+
+//     thread_local! {
+//         static FOO: Foo = Foo;
+//     }
+
+//     let (s, r) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             // First initialize `FOO`, then the thread-locals related to crossbeam-channel.
+//             FOO.with(|_| ());
+//             r.recv().unwrap();
+//             // At thread exit, thread-locals related to crossbeam-channel get dropped first and
+//             // `FOO` is dropped last.
+//         });
+
+//         scope.spawn(|_| {
+//             thread::sleep(ms(100));
+//             s.send(()).unwrap();
+//         });
+//     })
+//     .unwrap();
+// }
diff --git a/vendor/flume/tests/tick.rs b/vendor/flume/tests/tick.rs
new file mode 100644
index 0000000..b0fcd44
--- /dev/null
+++ b/vendor/flume/tests/tick.rs
@@ -0,0 +1,353 @@
+// //! Tests for the tick channel flavor.
+
+// #[macro_use]
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+// extern crate rand;
+
+// use std::sync::atomic::AtomicUsize;
+// use std::sync::atomic::Ordering;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, tick, Select, TryRecvError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn fire() {
+//     let start = Instant::now();
+//     let r = tick(ms(50));
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+//     thread::sleep(ms(100));
+
+//     let fired = r.try_recv().unwrap();
+//     assert!(start < fired);
+//     assert!(fired - start >= ms(50));
+
+//     let now = Instant::now();
+//     assert!(fired < now);
+//     assert!(now - fired >= ms(50));
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+
+//     select! {
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+
+//     select! {
+//         recv(r) -> _ => {}
+//         recv(tick(ms(200))) -> _ => panic!(),
+//     }
+// }
+
+// #[test]
+// fn intervals() {
+//     let start = Instant::now();
+//     let r = tick(ms(50));
+
+//     let t1 = r.recv().unwrap();
+//     assert!(start + ms(50) <= t1);
+//     assert!(start + ms(100) > t1);
+
+//     thread::sleep(ms(300));
+//     let t2 = r.try_recv().unwrap();
+//     assert!(start + ms(100) <= t2);
+//     assert!(start + ms(150) > t2);
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+//     let t3 = r.recv().unwrap();
+//     assert!(start + ms(400) <= t3);
+//     assert!(start + ms(450) > t3);
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn capacity() {
+//     const COUNT: usize = 10;
+
+//     for i in 0..COUNT {
+//         let r = tick(ms(i as u64));
+//         assert_eq!(r.capacity(), Some(1));
+//     }
+// }
+
+// #[test]
+// fn len_empty_full() {
+//     let r = tick(ms(50));
+
+//     assert_eq!(r.len(), 0);
+//     assert_eq!(r.is_empty(), true);
+//     assert_eq!(r.is_full(), false);
+
+//     thread::sleep(ms(100));
+
+//     assert_eq!(r.len(), 1);
+//     assert_eq!(r.is_empty(), false);
+//     assert_eq!(r.is_full(), true);
+
+//     r.try_recv().unwrap();
+
+//     assert_eq!(r.len(), 0);
+//     assert_eq!(r.is_empty(), true);
+//     assert_eq!(r.is_full(), false);
+// }
+
+// #[test]
+// fn try_recv() {
+//     let r = tick(ms(200));
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(100));
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(200));
+//     assert!(r.try_recv().is_ok());
+//     assert!(r.try_recv().is_err());
+
+//     thread::sleep(ms(200));
+//     assert!(r.try_recv().is_ok());
+//     assert!(r.try_recv().is_err());
+// }
+
+// #[test]
+// fn recv() {
+//     let start = Instant::now();
+//     let r = tick(ms(50));
+
+//     let fired = r.recv().unwrap();
+//     assert!(start < fired);
+//     assert!(fired - start >= ms(50));
+
+//     let now = Instant::now();
+//     assert!(fired < now);
+//     assert!(now - fired < fired - start);
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn recv_timeout() {
+//     let start = Instant::now();
+//     let r = tick(ms(200));
+
+//     assert!(r.recv_timeout(ms(100)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(100));
+//     assert!(now - start <= ms(150));
+
+//     let fired = r.recv_timeout(ms(200)).unwrap();
+//     assert!(fired - start >= ms(200));
+//     assert!(fired - start <= ms(250));
+
+//     assert!(r.recv_timeout(ms(100)).is_err());
+//     let now = Instant::now();
+//     assert!(now - start >= ms(300));
+//     assert!(now - start <= ms(350));
+
+//     let fired = r.recv_timeout(ms(200)).unwrap();
+//     assert!(fired - start >= ms(400));
+//     assert!(fired - start <= ms(450));
+// }
+
+// #[test]
+// fn recv_two() {
+//     let r1 = tick(ms(50));
+//     let r2 = tick(ms(50));
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for _ in 0..10 {
+//                 select! {
+//                     recv(r1) -> _ => {}
+//                     recv(r2) -> _ => {}
+//                 }
+//             }
+//         });
+//         scope.spawn(|_| {
+//             for _ in 0..10 {
+//                 select! {
+//                     recv(r1) -> _ => {}
+//                     recv(r2) -> _ => {}
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv_race() {
+//     select! {
+//         recv(tick(ms(50))) -> _ => {}
+//         recv(tick(ms(100))) -> _ => panic!(),
+//     }
+
+//     select! {
+//         recv(tick(ms(100))) -> _ => panic!(),
+//         recv(tick(ms(50))) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn stress_default() {
+//     const COUNT: usize = 10;
+
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(tick(ms(0))) -> _ => {}
+//             default => panic!(),
+//         }
+//     }
+
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(tick(ms(100))) -> _ => panic!(),
+//             default => {}
+//         }
+//     }
+// }
+
+// #[test]
+// fn select() {
+//     const THREADS: usize = 4;
+
+//     let hits = AtomicUsize::new(0);
+//     let r1 = tick(ms(200));
+//     let r2 = tick(ms(300));
+
+//     scope(|scope| {
+//         for _ in 0..THREADS {
+//             scope.spawn(|_| {
+//                 let timeout = after(ms(1100));
+//                 loop {
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r1);
+//                     let oper2 = sel.recv(&r2);
+//                     let oper3 = sel.recv(&timeout);
+//                     let oper = sel.select();
+//                     match oper.index() {
+//                         i if i == oper1 => {
+//                             oper.recv(&r1).unwrap();
+//                             hits.fetch_add(1, Ordering::SeqCst);
+//                         }
+//                         i if i == oper2 => {
+//                             oper.recv(&r2).unwrap();
+//                             hits.fetch_add(1, Ordering::SeqCst);
+//                         }
+//                         i if i == oper3 => {
+//                             oper.recv(&timeout).unwrap();
+//                             break;
+//                         }
+//                         _ => unreachable!(),
+//                     }
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(hits.load(Ordering::SeqCst), 8);
+// }
+
+// #[test]
+// fn ready() {
+//     const THREADS: usize = 4;
+
+//     let hits = AtomicUsize::new(0);
+//     let r1 = tick(ms(200));
+//     let r2 = tick(ms(300));
+
+//     scope(|scope| {
+//         for _ in 0..THREADS {
+//             scope.spawn(|_| {
+//                 let timeout = after(ms(1100));
+//                 'outer: loop {
+//                     let mut sel = Select::new();
+//                     sel.recv(&r1);
+//                     sel.recv(&r2);
+//                     sel.recv(&timeout);
+//                     loop {
+//                         match sel.ready() {
+//                             0 => {
+//                                 if r1.try_recv().is_ok() {
+//                                     hits.fetch_add(1, Ordering::SeqCst);
+//                                     break;
+//                                 }
+//                             }
+//                             1 => {
+//                                 if r2.try_recv().is_ok() {
+//                                     hits.fetch_add(1, Ordering::SeqCst);
+//                                     break;
+//                                 }
+//                             }
+//                             2 => {
+//                                 if timeout.try_recv().is_ok() {
+//                                     break 'outer;
+//                                 }
+//                             }
+//                             _ => unreachable!(),
+//                         }
+//                     }
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(hits.load(Ordering::SeqCst), 8);
+// }
+
+// #[test]
+// fn fairness() {
+//     const COUNT: usize = 30;
+
+//     for &dur in &[0, 1] {
+//         let mut hits = [0usize; 2];
+
+//         for _ in 0..COUNT {
+//             let r1 = tick(ms(dur));
+//             let r2 = tick(ms(dur));
+
+//             for _ in 0..COUNT {
+//                 select! {
+//                     recv(r1) -> _ => hits[0] += 1,
+//                     recv(r2) -> _ => hits[1] += 1,
+//                 }
+//             }
+//         }
+
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     }
+// }
+
+// #[test]
+// fn fairness_duplicates() {
+//     const COUNT: usize = 30;
+
+//     for &dur in &[0, 1] {
+//         let mut hits = [0usize; 5];
+
+//         for _ in 0..COUNT {
+//             let r = tick(ms(dur));
+
+//             for _ in 0..COUNT {
+//                 select! {
+//                     recv(r) -> _ => hits[0] += 1,
+//                     recv(r) -> _ => hits[1] += 1,
+//                     recv(r) -> _ => hits[2] += 1,
+//                     recv(r) -> _ => hits[3] += 1,
+//                     recv(r) -> _ => hits[4] += 1,
+//                 }
+//             }
+//         }
+
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     }
+// }
diff --git a/vendor/flume/tests/zero.rs b/vendor/flume/tests/zero.rs
new file mode 100644
index 0000000..be4239d
--- /dev/null
+++ b/vendor/flume/tests/zero.rs
@@ -0,0 +1,557 @@
+//! Tests for the zero channel flavor.
+
+extern crate crossbeam_utils;
+extern crate rand;
+
+use std::any::Any;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::thread;
+use std::time::Duration;
+
+use flume::{bounded, Receiver};
+use flume::{RecvError, RecvTimeoutError, TryRecvError};
+use flume::{SendError, SendTimeoutError, TrySendError};
+use crossbeam_utils::thread::scope;
+use rand::{thread_rng, Rng};
+
+fn ms(ms: u64) -> Duration {
+    Duration::from_millis(ms)
+}
+
+#[test]
+fn smoke() {
+    let (s, r) = bounded(0);
+    assert_eq!(s.try_send(7), Err(TrySendError::Full(7)));
+    assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+}
+
+#[test]
+fn capacity() {
+    let (s, r) = bounded::<()>(0);
+    assert_eq!(s.capacity(), Some(0));
+    assert_eq!(r.capacity(), Some(0));
+}
+
+#[test]
+fn len_empty_full() {
+    let (s, r) = bounded(0);
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(s.is_empty(), true);
+    assert_eq!(s.is_full(), true);
+    assert_eq!(r.len(), 0);
+    assert_eq!(r.is_empty(), true);
+    assert_eq!(r.is_full(), true);
+
+    scope(|scope| {
+        scope.spawn(|_| s.send(0).unwrap());
+        scope.spawn(|_| r.recv().unwrap());
+    })
+    .unwrap();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(s.is_empty(), true);
+    assert_eq!(s.is_full(), true);
+    assert_eq!(r.len(), 0);
+    assert_eq!(r.is_empty(), true);
+    assert_eq!(r.is_full(), true);
+}
+
+#[test]
+fn try_recv() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+            thread::sleep(ms(1500));
+            assert_eq!(r.try_recv(), Ok(7));
+            thread::sleep(ms(500));
+            assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv(), Ok(7));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(8));
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(9));
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+            s.send(8).unwrap();
+            s.send(9).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn recv_timeout() {
+    let (s, r) = bounded::<i32>(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(r.recv_timeout(ms(1000)), Err(RecvTimeoutError::Timeout));
+            assert_eq!(r.recv_timeout(ms(1000)), Ok(7));
+            assert_eq!(
+                r.recv_timeout(ms(1000)),
+                Err(RecvTimeoutError::Disconnected)
+            );
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            s.send(7).unwrap();
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn try_send() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(s.try_send(7), Err(TrySendError::Full(7)));
+            thread::sleep(ms(1500));
+            assert_eq!(s.try_send(8), Ok(()));
+            thread::sleep(ms(500));
+            assert_eq!(s.try_send(9), Err(TrySendError::Disconnected(9)));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            assert_eq!(r.recv(), Ok(8));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn send() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            s.send(7).unwrap();
+            thread::sleep(ms(1000));
+            s.send(8).unwrap();
+            thread::sleep(ms(1000));
+            s.send(9).unwrap();
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            assert_eq!(r.recv(), Ok(7));
+            assert_eq!(r.recv(), Ok(8));
+            assert_eq!(r.recv(), Ok(9));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn send_timeout() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(
+                s.send_timeout(7, ms(1000)),
+                Err(SendTimeoutError::Timeout(7))
+            );
+            assert_eq!(s.send_timeout(8, ms(1000)), Ok(()));
+            assert_eq!(
+                s.send_timeout(9, ms(1000)),
+                Err(SendTimeoutError::Disconnected(9))
+            );
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1500));
+            assert_eq!(r.recv(), Ok(8));
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn len() {
+    const COUNT: usize = 25_000;
+
+    let (s, r) = bounded(0);
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                assert_eq!(r.recv(), Ok(i));
+                assert_eq!(r.len(), 0);
+            }
+        });
+
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                s.send(i).unwrap();
+                assert_eq!(s.len(), 0);
+            }
+        });
+    })
+    .unwrap();
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(r.len(), 0);
+}
+
+#[test]
+fn disconnect_wakes_sender() {
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert_eq!(s.send(()), Err(SendError(())));
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            drop(r);
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn disconnect_wakes_receiver() {
+    let (s, r) = bounded::<()>(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            thread::sleep(ms(1000));
+            drop(s);
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn spsc() {
+    const COUNT: usize = 100_000;
+
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                assert_eq!(r.recv(), Ok(i));
+            }
+            assert!(r.recv().is_err());
+        });
+        scope.spawn(move |_| {
+            for i in 0..COUNT {
+                s.send(i).unwrap();
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn mpmc() {
+    const COUNT: usize = 25_000;
+    const THREADS: usize = 4;
+
+    let (s, r) = bounded::<usize>(0);
+    let v = (0..COUNT).map(|_| AtomicUsize::new(0)).collect::<Vec<_>>();
+
+    scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for _ in 0..COUNT {
+                    let n = r.recv().unwrap();
+                    v[n].fetch_add(1, Ordering::SeqCst);
+                }
+            });
+        }
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                for i in 0..COUNT {
+                    s.send(i).unwrap();
+                }
+            });
+        }
+    })
+    .unwrap();
+
+    for c in v {
+        assert_eq!(c.load(Ordering::SeqCst), THREADS);
+    }
+}
+
+#[test]
+fn stress_oneshot() {
+    const COUNT: usize = 10_000;
+
+    for _ in 0..COUNT {
+        let (s, r) = bounded(1);
+
+        scope(|scope| {
+            scope.spawn(|_| r.recv().unwrap());
+            scope.spawn(|_| s.send(0).unwrap());
+        })
+        .unwrap();
+    }
+}
+
+#[test]
+fn stress_iter() {
+    const COUNT: usize = 1000;
+
+    let (request_s, request_r) = bounded(0);
+    let (response_s, response_r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut count = 0;
+            loop {
+                for x in response_r.try_iter() {
+                    count += x;
+                    if count == COUNT {
+                        return;
+                    }
+                }
+                let _ = request_s.try_send(());
+            }
+        });
+
+        for _ in request_r.iter() {
+            if response_s.send(1).is_err() {
+                break;
+            }
+        }
+    })
+    .unwrap();
+}
+
+#[test]
+fn stress_timeout_two_threads() {
+    const COUNT: usize = 100;
+
+    let (s, r) = bounded(0);
+
+    scope(|scope| {
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                loop {
+                    if let Ok(()) = s.send_timeout(i, ms(10)) {
+                        break;
+                    }
+                }
+            }
+        });
+
+        scope.spawn(|_| {
+            for i in 0..COUNT {
+                if i % 2 == 0 {
+                    thread::sleep(ms(50));
+                }
+                loop {
+                    if let Ok(x) = r.recv_timeout(ms(10)) {
+                        assert_eq!(x, i);
+                        break;
+                    }
+                }
+            }
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn drops() {
+    static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+    #[derive(Debug, PartialEq)]
+    struct DropCounter;
+
+    impl Drop for DropCounter {
+        fn drop(&mut self) {
+            DROPS.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    let mut rng = thread_rng();
+
+    for _ in 0..100 {
+        let steps = rng.gen_range(0..3_000);
+
+        DROPS.store(0, Ordering::SeqCst);
+        let (s, r) = bounded::<DropCounter>(0);
+
+        scope(|scope| {
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    r.recv().unwrap();
+                }
+            });
+
+            scope.spawn(|_| {
+                for _ in 0..steps {
+                    s.send(DropCounter).unwrap();
+                }
+            });
+        })
+        .unwrap();
+
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps);
+        drop(s);
+        drop(r);
+        assert_eq!(DROPS.load(Ordering::SeqCst), steps);
+    }
+}
+
+// #[test]
+// fn fairness() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(0);
+//     let (s2, r2) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             let mut hits = [0usize; 2];
+//             for _ in 0..COUNT {
+//                 select! {
+//                     recv(r1) -> _ => hits[0] += 1,
+//                     recv(r2) -> _ => hits[1] += 1,
+//                 }
+//             }
+//             assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//         });
+
+//         let mut hits = [0usize; 2];
+//         for _ in 0..COUNT {
+//             select! {
+//                 send(s1, ()) -> _ => hits[0] += 1,
+//                 send(s2, ()) -> _ => hits[1] += 1,
+//             }
+//         }
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn fairness_duplicates() {
+//     const COUNT: usize = 10_000;
+
+//     let (s, r) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             let mut hits = [0usize; 5];
+//             for _ in 0..COUNT {
+//                 select! {
+//                     recv(r) -> _ => hits[0] += 1,
+//                     recv(r) -> _ => hits[1] += 1,
+//                     recv(r) -> _ => hits[2] += 1,
+//                     recv(r) -> _ => hits[3] += 1,
+//                     recv(r) -> _ => hits[4] += 1,
+//                 }
+//             }
+//             assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//         });
+
+//         let mut hits = [0usize; 5];
+//         for _ in 0..COUNT {
+//             select! {
+//                 send(s, ()) -> _ => hits[0] += 1,
+//                 send(s, ()) -> _ => hits[1] += 1,
+//                 send(s, ()) -> _ => hits[2] += 1,
+//                 send(s, ()) -> _ => hits[3] += 1,
+//                 send(s, ()) -> _ => hits[4] += 1,
+//             }
+//         }
+//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv_in_send() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(100));
+//             r.recv()
+//         });
+
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s.send(()).unwrap();
+//         });
+
+//         select! {
+//             send(s, r.recv().unwrap()) -> _ => {}
+//         }
+//     })
+//     .unwrap();
+// }
+
+#[test]
+fn channel_through_channel() {
+    const COUNT: usize = 1000;
+
+    type T = Box<dyn Any + Send>;
+
+    let (s, r) = bounded::<T>(0);
+
+    scope(|scope| {
+        scope.spawn(move |_| {
+            let mut s = s;
+
+            for _ in 0..COUNT {
+                let (new_s, new_r) = bounded(0);
+                let new_r: T = Box::new(Some(new_r));
+
+                s.send(new_r).unwrap();
+                s = new_s;
+            }
+        });
+
+        scope.spawn(move |_| {
+            let mut r = r;
+
+            for _ in 0..COUNT {
+                r = r
+                    .recv()
+                    .unwrap()
+                    .downcast_mut::<Option<Receiver<T>>>()
+                    .unwrap()
+                    .take()
+                    .unwrap()
+            }
+        });
+    })
+    .unwrap();
+}