Merging upstream version 1.71.1+dfsg1.

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

15 files changed, 3631 insertions, 0 deletions

diff --git a/vendor/kstring/.cargo-checksum.json b/vendor/kstring/.cargo-checksum.json
new file mode 100644
index 000000000..322069c76
--- /dev/null
+++ b/vendor/kstring/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"bb3f1dfc847c9f47c89a5c465a9e91ed68c42695bf80ae147c6c1ea4d3de9928","Cargo.toml":"d6aa48214500ad0cf5de9c904609af1dd6ea2fe2068b405237f9f2576df3c600","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6a5dfb0adf37850239f4b2388a79355c77b625d6c5542dea7743ac5033efaba2","README.md":"dcf7c8593f78a8e5d6cdb520c4c4499b229bdfc93bedcdfb22434b0e0b311d4a","benches/access.rs":"356362c7d1d6517e2e495be2c9edee5130db5aa8dee02dfab053b1374e91326a","benches/clone.rs":"ce6430a1da50da96d7f94b7d9912cf28f28ba4a1baa976f62d6b211c5729184e","examples/bench.rs":"01056ee7b3bca2f9525636080ccdc5d8b513934e5c001eb0b8beb6214c2bac88","src/backend.rs":"6f3ec727cae210c04c720b1ed77de3d4b21713a920aa3ee620861eeadd91ae31","src/lib.rs":"9932b5d3ed4440e2d167b1fff1f835ef0eb51ad0a47a64bde38c0bf5aee60c6d","src/stack.rs":"029dce8e4385f91b2e375cd50a81812b44a93db656890cfe30b81f59ff9af425","src/string.rs":"bca947a52972f59ec7211d9a573110a8b24942c6c1144ea4abd6d272bc07adf0","src/string_cow.rs":"80db9235eee78bc81ee50df1f1fed1863791cb41aa0bae00af3a36b586f5513a","src/string_ref.rs":"79d050ce3bc7145b40aa3f555ea89a830cd84f3ef002a3081f874d5425430937"},"package":"ec3066350882a1cd6d950d055997f379ac37fd39f81cd4d8ed186032eb3c5747"}
\ No newline at end of file
diff --git a/vendor/kstring/Cargo.lock b/vendor/kstring/Cargo.lock
new file mode 100644
index 000000000..206479e6d
--- /dev/null
+++ b/vendor/kstring/Cargo.lock
@@ -0,0 +1,814 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bit-set"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bstr"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+dependencies = [
+ "lazy_static",
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "cast"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
+dependencies = [
+ "rustc_version",
+]
+
+[[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 = "criterion"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1604dafd25fba2fe2d5895a9da139f8dc9b319a5fe5354ca137cbbce4e178d10"
+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.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d00996de9f2f7559f7f4dc286073197f83e92256a59ed395f9aac01fe717da57"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aaa7bd5fb665c6864b5f963dd9097905c54125909c7aa94c9e18507cdbe6c53"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "lazy_static",
+ "memoffset",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38"
+dependencies = [
+ "cfg-if",
+ "lazy_static",
+]
+
+[[package]]
+name = "csv"
+version = "1.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
+dependencies = [
+ "bstr",
+ "csv-core",
+ "itoa 0.4.8",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "document-features"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b01c09fd63b5136fba41aa625c7b3254f0aa0a435ff6ec4b2c9a28d496c83c88"
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "fastrand"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "getrandom"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[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 = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
+[[package]]
+name = "js-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kstring"
+version = "2.0.0"
+dependencies = [
+ "criterion",
+ "document-features",
+ "proptest",
+ "serde",
+ "static_assertions",
+]
+
+[[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.121"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f"
+
+[[package]]
+name = "log"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6389c490849ff5bc16be905ae24bc913a9c8892e19b2341dbc175e14c341c2b8"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "plotters"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d88417318da0eaf0fdcdb51a0ee6c3bed624333bff8f946733049380be67ac1c"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521fa9638fa597e1dc53e9412a4f9cefb01187ee1f7413076f9e6749e2885ba9"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "proptest"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0d9cc07f18492d879586c92b485def06bc850da3118075cd45d50e9c95b0e5"
+dependencies = [
+ "bit-set",
+ "bitflags",
+ "byteorder",
+ "lazy_static",
+ "num-traits",
+ "quick-error 2.0.1",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quote"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "632d02bff7f874a36f33ea8bb416cd484b90cc66c1194b1a1110d067a7013f58"
+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.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+dependencies = [
+ "autocfg",
+ "crossbeam-deque",
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "lazy_static",
+ "num_cpus",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae183fc1b06c149f0c1793e1eb447c8b04bfe46d48e9e48bfb8d2d7ed64ecf0"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
+dependencies = [
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error 1.2.3",
+ "tempfile",
+ "wait-timeout",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+
+[[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.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "semver"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65bd28f48be7196d222d95b9243287f48d27aca604e08497513019ff0502cc4"
+
+[[package]]
+name = "serde"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+
+[[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.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+dependencies = [
+ "itoa 1.0.1",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "syn"
+version = "1.0.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704df27628939572cd88d33f171cd6f896f4eaca85252c6e0a72d8d8287ee86f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "libc",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[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 = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+dependencies = [
+ "same-file",
+ "winapi",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"
+
+[[package]]
+name = "web-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
+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"
diff --git a/vendor/kstring/Cargo.toml b/vendor/kstring/Cargo.toml
new file mode 100644
index 000000000..87e11ed79
--- /dev/null
+++ b/vendor/kstring/Cargo.toml
@@ -0,0 +1,88 @@
+# 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 = "kstring"
+version = "2.0.0"
+authors = ["Ed Page <eopage@gmail.com>"]
+include = ["build.rs", "src/**/*", "Cargo.toml", "LICENSE*", "README.md", "benches/**/*", "examples/**/*"]
+description = "Key String: optimized for map keys"
+documentation = "https://docs.rs/kstring"
+readme = "README.md"
+keywords = ["serde", "serialization", "string"]
+categories = ["data-structures", "text-processing"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/cobalt-org/kstring"
+[package.metadata.docs.rs]
+all-features = true
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+min = 1
+replace = "{{version}}"
+search = "Unreleased"
+
+[[package.metadata.release.pre-release-replacements]]
+exactly = 1
+file = "CHANGELOG.md"
+replace = "...{{tag_name}}"
+search = "\\.\\.\\.HEAD"
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+min = 1
+replace = "{{date}}"
+search = "ReleaseDate"
+
+[[package.metadata.release.pre-release-replacements]]
+exactly = 1
+file = "CHANGELOG.md"
+replace = "<!-- next-header -->\n## [Unreleased] - ReleaseDate\n"
+search = "<!-- next-header -->"
+
+[[package.metadata.release.pre-release-replacements]]
+exactly = 1
+file = "CHANGELOG.md"
+replace = "<!-- next-url -->\n[Unreleased]: https://github.com/cobalt-org/kstring/compare/{{tag_name}}...HEAD"
+search = "<!-- next-url -->"
+[profile.release]
+debug = 1
+
+[[bench]]
+name = "clone"
+harness = false
+
+[[bench]]
+name = "access"
+harness = false
+[dependencies.document-features]
+version = "0.2"
+optional = true
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+
+[dependencies.static_assertions]
+version = "1.1.0"
+[dev-dependencies.criterion]
+version = "0.3"
+
+[dev-dependencies.proptest]
+version = "1.0.0"
+
+[features]
+arc = []
+default = ["std", "unsafe"]
+max_inline = []
+std = []
+unsafe = []
+unstable_bench_subset = []
diff --git a/vendor/kstring/LICENSE-APACHE b/vendor/kstring/LICENSE-APACHE
new file mode 100644
index 000000000..16fe87b06
--- /dev/null
+++ b/vendor/kstring/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.
diff --git a/vendor/kstring/LICENSE-MIT b/vendor/kstring/LICENSE-MIT
new file mode 100644
index 000000000..f1be6b7af
--- /dev/null
+++ b/vendor/kstring/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2016 Ning Sun and tojson_macros contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/kstring/README.md b/vendor/kstring/README.md
new file mode 100644
index 000000000..91828d01d
--- /dev/null
+++ b/vendor/kstring/README.md
@@ -0,0 +1,58 @@
+KString
+===========
+
+> Key String: Optimized for map keys.
+
+[![Crates Status](https://img.shields.io/crates/v/kstring.svg)](https://crates.io/crates/kstring)
+
+## Background
+
+Considerations:
+- Large maps
+- Most keys live and drop without being used in any other way
+- Most keys are relatively small (single to double digit bytes)
+- Keys are immutable
+- Allow zero-cost abstractions between structs and maps (e.g. no allocating
+  when dealing with struct field names)
+
+Ramifications:
+- Inline small strings rather than going to the heap.
+- Preserve `&'static str` across strings (`KString`),
+  references (`KStringRef`), and lifetime abstractions (`KStringCow`) to avoid
+  allocating for struct field names.
+- Use `Box<str>` rather than `String` to use less memory.
+
+Features
+- `max_inline`: Instead of aligning the inline-string for performance (15 bytes + length on 64-bit), use the full width (22 bytes on 64-bit)
+- `arc`: Instead of using `Box<str>`, use `Arc<str>`.  Note: allocations are fast enough that this can actually slow things down for small enough strings.
+
+Alternatives
+- [`smol_str`](https://crates.io/crates/smol_str)
+  - Size of String
+  - Always uses `Arc` instead of `Box`
+  - Always inlines 22 bytes
+  - Whitespace-only optimizations
+- [`smartstring`](https://crates.io/crates/smartstring)
+  - Size of String
+  - Allows mutability at the cost of relying on implementation details of `String`
+  - Always inlines 23 bytes
+- [`compact_str`](https://crates.io/crates/compact_str)
+  - Size of String
+  - Always uses `Arc` instead of `Box`
+  - Inlines 22-23 bytes, depending on implementation
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0, (http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license (http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual licensed as above, without any additional terms or
+conditions.
diff --git a/vendor/kstring/benches/access.rs b/vendor/kstring/benches/access.rs
new file mode 100644
index 000000000..a9b92d3d6
--- /dev/null
+++ b/vendor/kstring/benches/access.rs
@@ -0,0 +1,134 @@
+#![allow(
+    clippy::clone_on_copy,
+    clippy::useless_conversion,
+    clippy::clone_double_ref
+)]
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+type StringCow<'s> = std::borrow::Cow<'s, str>;
+
+#[cfg(not(feature = "unstable_bench_subset"))]
+pub static FIXTURES: &[&str] = &[
+    "",
+    "0",
+    "01",
+    "012",
+    "0123",
+    "01234",
+    "012345",
+    "0123456",
+    "01234567",
+    "012345678",
+    "0123456789",
+    "01234567890123456789",
+    "0123456789012345678901234567890123456789",
+    "01234567890123456789012345678901234567890123456789012345678901234567890123456789",
+];
+
+#[cfg(feature = "unstable_bench_subset")]
+pub static FIXTURES: &[&str] = &[
+    "0123456789",
+    "01234567890123456789012345678901234567890123456789012345678901234567890123456789",
+];
+
+// Note: this is meant to measure the overhead for accessing the underlying str.  We shouldn't try
+// to optimize *just* the case being measured here.
+fn bench_access(c: &mut Criterion) {
+    let mut group = c.benchmark_group("access");
+    for fixture in FIXTURES {
+        let len = fixture.len();
+        group.throughput(Throughput::Bytes(len as u64));
+        group.bench_with_input(
+            BenchmarkId::new("StringCow::Borrowed", len),
+            &len,
+            |b, _| {
+                let uut = StringCow::Borrowed(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("StringCow::Owned", len), &len, |b, _| {
+            let uut = StringCow::Owned(String::from(*fixture));
+            let uut = criterion::black_box(uut);
+            b.iter(|| uut.is_empty())
+        });
+        group.bench_with_input(
+            BenchmarkId::new("KString::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KString::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("KString::from_ref", len), &len, |b, _| {
+            let uut = kstring::KString::from_ref(*fixture);
+            let uut = criterion::black_box(uut);
+            b.iter(|| uut.is_empty())
+        });
+        group.bench_with_input(
+            BenchmarkId::new("KString::from_string", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KString::from_string(String::from(*fixture));
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringCow::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_ref", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringCow::from_ref(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_string", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringCow::from_string(String::from(*fixture));
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringRef::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringRef::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringRef::from_ref", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringRef::from_ref(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.is_empty())
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_access);
+criterion_main!(benches);
diff --git a/vendor/kstring/benches/clone.rs b/vendor/kstring/benches/clone.rs
new file mode 100644
index 000000000..b0740bad9
--- /dev/null
+++ b/vendor/kstring/benches/clone.rs
@@ -0,0 +1,139 @@
+#![allow(
+    clippy::clone_on_copy,
+    clippy::useless_conversion,
+    clippy::clone_double_ref
+)]
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+
+type StringCow<'s> = std::borrow::Cow<'s, str>;
+
+#[cfg(not(feature = "unstable_bench_subset"))]
+pub static FIXTURES: &[&str] = &[
+    // Empty handling
+    "",
+    // Barely used
+    "1",
+    // kstring's max small-string size
+    "123456789012345",
+    // Boundary conditions for most small-string optimizations
+    "1234567890123456789012",
+    "12345678901234567890123",
+    "123456789012345678901234",
+    "1234567890123456789012345",
+    // Small heap
+    "1234567890123456789012345678901234567890123456789012345678901234",
+    // Large heap
+    "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+];
+
+#[cfg(feature = "unstable_bench_subset")]
+pub static FIXTURES: &[&str] = &[
+    "0123456789",
+    "01234567890123456789012345678901234567890123456789012345678901234567890123456789",
+];
+
+fn bench_clone(c: &mut Criterion) {
+    let mut group = c.benchmark_group("clone");
+    for fixture in FIXTURES {
+        let len = fixture.len();
+        group.throughput(Throughput::Bytes(len as u64));
+        group.bench_with_input(
+            BenchmarkId::new("StringCow::Borrowed", len),
+            &len,
+            |b, _| {
+                let uut = StringCow::Borrowed(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("StringCow::Owned", len), &len, |b, _| {
+            let fixture = String::from(*fixture);
+            let uut = StringCow::Owned(fixture);
+            let uut = criterion::black_box(uut);
+            b.iter(|| uut.clone())
+        });
+        group.bench_with_input(
+            BenchmarkId::new("KString::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KString::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("KString::from_ref", len), &len, |b, _| {
+            let fixture = String::from(*fixture);
+            let uut = kstring::KString::from_ref(&fixture);
+            let uut = criterion::black_box(uut);
+            b.iter(|| uut.clone())
+        });
+        group.bench_with_input(
+            BenchmarkId::new("KString::from_string", len),
+            &len,
+            |b, _| {
+                let fixture = String::from(*fixture);
+                let uut = kstring::KString::from_string(fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringCow::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_ref", len),
+            &len,
+            |b, _| {
+                let fixture = String::from(*fixture);
+                let uut = kstring::KStringCow::from_ref(&fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringCow::from_string", len),
+            &len,
+            |b, _| {
+                let fixture = String::from(*fixture);
+                let uut = kstring::KStringCow::from_string(fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringRef::from_static", len),
+            &len,
+            |b, _| {
+                let uut = kstring::KStringRef::from_static(*fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+        #[cfg(not(feature = "unstable_bench_subset"))]
+        group.bench_with_input(
+            BenchmarkId::new("KStringRef::from_ref", len),
+            &len,
+            |b, _| {
+                let fixture = String::from(*fixture);
+                let uut = kstring::KStringRef::from_ref(&fixture);
+                let uut = criterion::black_box(uut);
+                b.iter(|| uut.clone())
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_clone);
+criterion_main!(benches);
diff --git a/vendor/kstring/examples/bench.rs b/vendor/kstring/examples/bench.rs
new file mode 100644
index 000000000..8d467da52
--- /dev/null
+++ b/vendor/kstring/examples/bench.rs
@@ -0,0 +1,18 @@
+fn main() {
+    let mut args = std::env::args();
+    let _ = args.next();
+    let method = args.next().unwrap_or_else(|| String::from("from_ref"));
+    let sample = args.next().unwrap_or_else(|| String::from("0123456789"));
+    let count = args
+        .next()
+        .unwrap_or_else(|| String::from("10000000"))
+        .parse::<usize>()
+        .unwrap();
+    #[allow(clippy::redundant_closure)] // Needed for consistent type
+    let method = match method.as_str() {
+        "from_ref" => |s| kstring::KString::from_ref(s),
+        "from_string" => |s| kstring::KString::from_string(String::from(s)),
+        _ => panic!("{:?} unsupported, try `from_ref`, `from_string`", method),
+    };
+    (0..count).map(|_| method(&sample)).last();
+}
diff --git a/vendor/kstring/src/backend.rs b/vendor/kstring/src/backend.rs
new file mode 100644
index 000000000..3827082f1
--- /dev/null
+++ b/vendor/kstring/src/backend.rs
@@ -0,0 +1,97 @@
+#[cfg(feature = "arc")]
+pub(crate) type DefaultStr = crate::backend::ArcStr;
+#[cfg(not(feature = "arc"))]
+pub(crate) type DefaultStr = crate::backend::BoxedStr;
+
+/// Fast allocations, O(n) clones
+pub type BoxedStr = Box<str>;
+static_assertions::assert_eq_size!(DefaultStr, BoxedStr);
+
+/// Cross-thread, O(1) clones
+pub type ArcStr = std::sync::Arc<str>;
+static_assertions::assert_eq_size!(DefaultStr, ArcStr);
+
+/// O(1) clones
+pub type RcStr = std::rc::Rc<str>;
+static_assertions::assert_eq_size!(DefaultStr, RcStr);
+
+/// Abstract over different type of heap-allocated strings
+pub trait HeapStr: std::fmt::Debug + Clone + private::Sealed {
+    fn from_str(other: &str) -> Self;
+    fn from_string(other: String) -> Self;
+    fn from_boxed_str(other: BoxedStr) -> Self;
+    fn as_str(&self) -> &str;
+}
+
+impl HeapStr for BoxedStr {
+    #[inline]
+    fn from_str(other: &str) -> Self {
+        other.into()
+    }
+
+    #[inline]
+    fn from_string(other: String) -> Self {
+        other.into_boxed_str()
+    }
+
+    #[inline]
+    fn from_boxed_str(other: BoxedStr) -> Self {
+        other
+    }
+
+    #[inline]
+    fn as_str(&self) -> &str {
+        self
+    }
+}
+
+impl HeapStr for ArcStr {
+    #[inline]
+    fn from_str(other: &str) -> Self {
+        other.into()
+    }
+
+    #[inline]
+    fn from_string(other: String) -> Self {
+        other.into_boxed_str().into()
+    }
+
+    #[inline]
+    fn from_boxed_str(other: BoxedStr) -> Self {
+        other.into()
+    }
+
+    #[inline]
+    fn as_str(&self) -> &str {
+        self
+    }
+}
+
+impl HeapStr for RcStr {
+    #[inline]
+    fn from_str(other: &str) -> Self {
+        other.into()
+    }
+
+    #[inline]
+    fn from_string(other: String) -> Self {
+        other.into_boxed_str().into()
+    }
+
+    #[inline]
+    fn from_boxed_str(other: BoxedStr) -> Self {
+        other.into()
+    }
+
+    #[inline]
+    fn as_str(&self) -> &str {
+        self
+    }
+}
+
+pub(crate) mod private {
+    pub trait Sealed {}
+    impl Sealed for super::BoxedStr {}
+    impl Sealed for super::ArcStr {}
+    impl Sealed for super::RcStr {}
+}
diff --git a/vendor/kstring/src/lib.rs b/vendor/kstring/src/lib.rs
new file mode 100644
index 000000000..dc1ffd608
--- /dev/null
+++ b/vendor/kstring/src/lib.rs
@@ -0,0 +1,78 @@
+//! Key String: Optimized for map keys.
+//!
+//! # Examples
+//!
+//! String creation
+//! ```rust
+//! // Explicit
+//! let literal = kstring::KString::from_static("literal");
+//! // Implicit
+//! let literal = kstring::KString::from("literal");
+//!
+//! // Explicit
+//! let inline = kstring::KString::try_inline("stack").unwrap();
+//! let inline = kstring::KString::from_ref("stack");
+//!
+//! let formatted: kstring::KStringCow = format!("Hello {} and {}", literal, inline).into();
+//! ```
+//!
+//! # Background
+//!
+//! Considerations:
+//! - Large maps
+//! - Most keys live and drop without being used in any other way
+//! - Most keys are relatively small (single to double digit bytes)
+//! - Keys are immutable
+//! - Allow zero-cost abstractions between structs and maps (e.g. no allocating
+//!   when dealing with struct field names)
+//!
+//! Ramifications:
+//! - Inline small strings rather than going to the heap.
+//! - Preserve `&'static str` across strings ([`KString`]),
+//!   references ([`KStringRef`]), and lifetime abstractions ([`KStringCow`]) to avoid
+//!   allocating for struct field names.
+//! - Use `Box<str>` rather than `String` to use less memory.
+//!
+//! # Feature Flags
+//!
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+#![cfg_attr(feature = "safe", forbid(unsafe_code))]
+
+#[cfg(not(feature = "std"))]
+compile_error!("`std` feature is required; reserved for future `no_std` support");
+
+mod stack;
+mod string;
+mod string_cow;
+mod string_ref;
+
+pub mod backend;
+
+pub use stack::StackString;
+pub use string::*;
+pub use string_cow::*;
+pub use string_ref::*;
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_size() {
+        println!(
+            "String: {}",
+            std::mem::size_of::<crate::string::StdString>()
+        );
+        println!(
+            "Box<str>: {}",
+            std::mem::size_of::<crate::backend::DefaultStr>()
+        );
+        println!(
+            "Box<Box<str>>: {}",
+            std::mem::size_of::<Box<crate::backend::DefaultStr>>()
+        );
+        println!("str: {}", std::mem::size_of::<&'static str>());
+        println!(
+            "Cow: {}",
+            std::mem::size_of::<std::borrow::Cow<'static, str>>()
+        );
+    }
+}
diff --git a/vendor/kstring/src/stack.rs b/vendor/kstring/src/stack.rs
new file mode 100644
index 000000000..93e2f0722
--- /dev/null
+++ b/vendor/kstring/src/stack.rs
@@ -0,0 +1,457 @@
+use std::fmt;
+
+pub(crate) type Len = u8;
+
+/// Fixed-size stack-allocated string
+#[derive(Copy, Clone)]
+pub struct StackString<const CAPACITY: usize> {
+    len: Len,
+    buffer: StrBuffer<CAPACITY>,
+}
+
+impl<const CAPACITY: usize> StackString<CAPACITY> {
+    pub const CAPACITY: usize = CAPACITY;
+    pub const EMPTY: Self = Self::empty();
+
+    const fn empty() -> Self {
+        Self {
+            len: 0,
+            buffer: StrBuffer::empty(),
+        }
+    }
+
+    /// Create a `StackString` from a `&str`, if it'll fit within `Self::CAPACITY`
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = kstring::StackString::<3>::try_new("foo");
+    /// assert_eq!(s.as_deref(), Some("foo"));
+    /// let s = kstring::StackString::<3>::try_new("foobar");
+    /// assert_eq!(s, None);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn try_new(s: &str) -> Option<Self> {
+        let len = s.as_bytes().len();
+        if len <= Self::CAPACITY {
+            #[cfg(feature = "unsafe")]
+            let stack = {
+                unsafe {
+                    // SAFETY: We've confirmed `len` is within size
+                    Self::new_unchecked(s)
+                }
+            };
+            #[cfg(not(feature = "unsafe"))]
+            let stack = { Self::new(s) };
+            Some(stack)
+        } else {
+            None
+        }
+    }
+
+    /// Create a `StackString` from a `&str`
+    ///
+    /// # Panic
+    ///
+    /// Calling this function with a string larger than `Self::CAPACITY` will panic
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = kstring::StackString::<3>::new("foo");
+    /// assert_eq!(s, "foo");
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn new(s: &str) -> Self {
+        let len = s.as_bytes().len() as u8;
+        debug_assert!(Self::CAPACITY <= Len::MAX.into());
+        let buffer = StrBuffer::new(s);
+        Self { len, buffer }
+    }
+
+    /// Create a `StackString` from a `&str`
+    ///
+    /// # Safety
+    ///
+    /// Calling this function with a string larger than `Self::CAPACITY` is undefined behavior.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = unsafe {
+    ///     // SAFETY: Literal is short-enough
+    ///     kstring::StackString::<3>::new_unchecked("foo")
+    /// };
+    /// assert_eq!(s, "foo");
+    /// ```
+    #[inline]
+    #[must_use]
+    #[cfg(feature = "unsafe")]
+    pub unsafe fn new_unchecked(s: &str) -> Self {
+        let len = s.as_bytes().len() as u8;
+        debug_assert!(Self::CAPACITY <= Len::MAX.into());
+        let buffer = StrBuffer::new_unchecked(s);
+        Self { len, buffer }
+    }
+
+    /// Extracts a string slice containing the entire `StackString`.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let s = kstring::StackString::<3>::try_new("foo").unwrap();
+    ///
+    /// assert_eq!("foo", s.as_str());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        let len = self.len as usize;
+        #[cfg(feature = "unsafe")]
+        unsafe {
+            // SAFETY: Constructors guarantee that `buffer[..len]` is a `str`,
+            // and we don't mutate the data afterwards.
+            self.buffer.as_str_unchecked(len)
+        }
+        #[cfg(not(feature = "unsafe"))]
+        self.buffer.as_str(len)
+    }
+
+    /// Converts a `StackString` into a mutable string slice.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let mut s = kstring::StackString::<6>::try_new("foobar").unwrap();
+    /// let s_mut_str = s.as_mut_str();
+    ///
+    /// s_mut_str.make_ascii_uppercase();
+    ///
+    /// assert_eq!("FOOBAR", s_mut_str);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn as_mut_str(&mut self) -> &mut str {
+        let len = self.len as usize;
+        #[cfg(feature = "unsafe")]
+        unsafe {
+            // SAFETY: Constructors guarantee that `buffer[..len]` is a `str`,
+            // and we don't mutate the data afterwards.
+            self.buffer.as_mut_str_unchecked(len)
+        }
+        #[cfg(not(feature = "unsafe"))]
+        self.buffer.as_mut_str(len)
+    }
+
+    /// Returns the length of this `StasckString`, in bytes, not [`char`]s or
+    /// graphemes. In other words, it might not be what a human considers the
+    /// length of the string.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let a = kstring::StackString::<3>::try_new("foo").unwrap();
+    /// assert_eq!(a.len(), 3);
+    ///
+    /// let fancy_f = kstring::StackString::<4>::try_new("ƒoo").unwrap();
+    /// assert_eq!(fancy_f.len(), 4);
+    /// assert_eq!(fancy_f.chars().count(), 3);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.len as usize
+    }
+
+    /// Returns `true` if this `StackString` has a length of zero, and `false` otherwise.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let mut v = kstring::StackString::<20>::EMPTY;
+    /// assert!(v.is_empty());
+    ///
+    /// let a = kstring::StackString::<3>::try_new("foo").unwrap();
+    /// assert!(!a.is_empty());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Truncates this `StackString`, removing all contents.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let mut s = kstring::StackString::<3>::try_new("foo").unwrap();
+    ///
+    /// s.clear();
+    ///
+    /// assert!(s.is_empty());
+    /// assert_eq!(0, s.len());
+    /// ```
+    #[inline]
+    pub fn clear(&mut self) {
+        self.len = 0;
+    }
+
+    /// Shortens this `StackString` to the specified length.
+    ///
+    /// If `new_len` is greater than the string's current length, this has no
+    /// effect.
+    ///
+    /// Note that this method has no effect on the allocated capacity
+    /// of the string
+    ///
+    /// # Panics
+    ///
+    /// Panics if `new_len` does not lie on a [`char`] boundary.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// let mut s = kstring::StackString::<5>::try_new("hello").unwrap();
+    ///
+    /// s.truncate(2);
+    ///
+    /// assert_eq!(s, "he");
+    /// ```
+    #[inline]
+    pub fn truncate(&mut self, new_len: usize) {
+        if new_len <= self.len() {
+            assert!(self.is_char_boundary(new_len));
+            self.len = new_len as u8;
+        }
+    }
+}
+
+impl<const CAPACITY: usize> Default for StackString<CAPACITY> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl<const CAPACITY: usize> std::ops::Deref for StackString<CAPACITY> {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<const CAPACITY: usize> Eq for StackString<CAPACITY> {}
+
+impl<const C1: usize, const C2: usize> PartialEq<StackString<C1>> for StackString<C2> {
+    #[inline]
+    fn eq(&self, other: &StackString<C1>) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<const CAPACITY: usize> PartialEq<str> for StackString<CAPACITY> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        PartialEq::eq(self.as_str(), other)
+    }
+}
+
+impl<'s, const CAPACITY: usize> PartialEq<&'s str> for StackString<CAPACITY> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        PartialEq::eq(self.as_str(), *other)
+    }
+}
+
+impl<const CAPACITY: usize> PartialEq<String> for StackString<CAPACITY> {
+    #[inline]
+    fn eq(&self, other: &String) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<const CAPACITY: usize> Ord for StackString<CAPACITY> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl<const C1: usize, const C2: usize> PartialOrd<StackString<C1>> for StackString<C2> {
+    #[inline]
+    fn partial_cmp(&self, other: &StackString<C1>) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<const CAPACITY: usize> PartialOrd<str> for StackString<CAPACITY> {
+    #[inline]
+    fn partial_cmp(&self, other: &str) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other)
+    }
+}
+
+impl<'s, const CAPACITY: usize> PartialOrd<&'s str> for StackString<CAPACITY> {
+    #[inline]
+    fn partial_cmp(&self, other: &&str) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other)
+    }
+}
+
+impl<const CAPACITY: usize> PartialOrd<String> for StackString<CAPACITY> {
+    #[inline]
+    fn partial_cmp(&self, other: &String) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<const CAPACITY: usize> std::hash::Hash for StackString<CAPACITY> {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}
+
+impl<const CAPACITY: usize> fmt::Debug for StackString<CAPACITY> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self.as_str(), f)
+    }
+}
+
+impl<const CAPACITY: usize> fmt::Display for StackString<CAPACITY> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+impl<const CAPACITY: usize> AsRef<str> for StackString<CAPACITY> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<const CAPACITY: usize> AsRef<[u8]> for StackString<CAPACITY> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl<const CAPACITY: usize> AsRef<std::ffi::OsStr> for StackString<CAPACITY> {
+    #[inline]
+    fn as_ref(&self) -> &std::ffi::OsStr {
+        (&**self).as_ref()
+    }
+}
+
+impl<const CAPACITY: usize> AsRef<std::path::Path> for StackString<CAPACITY> {
+    #[inline]
+    fn as_ref(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl<const CAPACITY: usize> std::borrow::Borrow<str> for StackString<CAPACITY> {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub(crate) struct StrBuffer<const CAPACITY: usize>([u8; CAPACITY]);
+
+impl<const CAPACITY: usize> StrBuffer<CAPACITY> {
+    pub(crate) const fn empty() -> Self {
+        let array = [0; CAPACITY];
+        StrBuffer(array)
+    }
+
+    #[inline]
+    pub(crate) fn new(s: &str) -> Self {
+        let len = s.as_bytes().len();
+        debug_assert!(len <= CAPACITY);
+        let mut buffer = Self::default();
+        if let Some(buffer) = buffer.0.get_mut(..len) {
+            buffer.copy_from_slice(s.as_bytes());
+        } else {
+            panic!("`{}` is larger than capacity {}", s, CAPACITY);
+        }
+        buffer
+    }
+
+    #[inline]
+    #[cfg(not(feature = "unsafe"))]
+    pub(crate) fn as_str(&self, len: usize) -> &str {
+        let slice = self.0.get(..len).unwrap();
+        std::str::from_utf8(slice).unwrap()
+    }
+
+    #[inline]
+    #[cfg(not(feature = "unsafe"))]
+    pub(crate) fn as_mut_str(&mut self, len: usize) -> &mut str {
+        let slice = self.0.get_mut(..len).unwrap();
+        std::str::from_utf8_mut(slice).unwrap()
+    }
+}
+
+impl<const CAPACITY: usize> StrBuffer<CAPACITY> {
+    #[inline]
+    #[cfg(feature = "unsafe")]
+    pub(crate) unsafe fn new_unchecked(s: &str) -> Self {
+        let len = s.as_bytes().len();
+        debug_assert!(len <= CAPACITY);
+        let mut buffer = Self::default();
+        buffer
+            .0
+            .get_unchecked_mut(..len)
+            .copy_from_slice(s.as_bytes());
+        buffer
+    }
+
+    #[inline]
+    #[cfg(feature = "unsafe")]
+    pub(crate) unsafe fn as_str_unchecked(&self, len: usize) -> &str {
+        let slice = self.0.get_unchecked(..len);
+        std::str::from_utf8_unchecked(slice)
+    }
+
+    #[inline]
+    #[cfg(feature = "unsafe")]
+    pub(crate) unsafe fn as_mut_str_unchecked(&mut self, len: usize) -> &mut str {
+        let slice = self.0.get_unchecked_mut(..len);
+        std::str::from_utf8_unchecked_mut(slice)
+    }
+}
+
+impl<const CAPACITY: usize> Default for StrBuffer<CAPACITY> {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
diff --git a/vendor/kstring/src/string.rs b/vendor/kstring/src/string.rs
new file mode 100644
index 000000000..ed39d188a
--- /dev/null
+++ b/vendor/kstring/src/string.rs
@@ -0,0 +1,865 @@
+use std::{borrow::Cow, fmt};
+
+use crate::stack::StackString;
+use crate::KStringCowBase;
+use crate::KStringRef;
+
+pub(crate) type StdString = std::string::String;
+
+/// A UTF-8 encoded, immutable string.
+pub type KString = KStringBase<crate::backend::DefaultStr>;
+
+/// A UTF-8 encoded, immutable string.
+#[derive(Clone)]
+#[repr(transparent)]
+pub struct KStringBase<B> {
+    inner: KStringInner<B>,
+}
+
+impl<B> KStringBase<B> {
+    pub const EMPTY: Self = KStringBase::from_static("");
+
+    /// Create a new empty `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn new() -> Self {
+        Self::EMPTY
+    }
+
+    /// Create a reference to a `'static` data.
+    #[inline]
+    #[must_use]
+    pub const fn from_static(other: &'static str) -> Self {
+        Self {
+            inner: KStringInner::from_static(other),
+        }
+    }
+
+    /// Create an inline string, if possible
+    #[inline]
+    #[must_use]
+    pub fn try_inline(other: &str) -> Option<Self> {
+        KStringInner::try_inline(other).map(|inner| Self { inner })
+    }
+}
+
+impl<B: crate::backend::HeapStr> KStringBase<B> {
+    /// Create an owned `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn from_boxed(other: crate::backend::BoxedStr) -> Self {
+        Self {
+            inner: KStringInner::from_boxed(other),
+        }
+    }
+
+    /// Create an owned `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn from_string(other: StdString) -> Self {
+        Self {
+            inner: KStringInner::from_string(other),
+        }
+    }
+
+    /// Create an owned `KStringBase` optimally from a reference.
+    #[inline]
+    #[must_use]
+    pub fn from_ref(other: &str) -> Self {
+        Self {
+            inner: KStringInner::from_ref(other),
+        }
+    }
+
+    /// Get a reference to the `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn as_ref(&self) -> KStringRef<'_> {
+        self.inner.as_ref()
+    }
+
+    /// Extracts a string slice containing the entire `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        self.inner.as_str()
+    }
+
+    /// Convert to a mutable string type, cloning the data if necessary.
+    #[inline]
+    #[must_use]
+    pub fn into_string(self) -> StdString {
+        String::from(self.into_boxed_str())
+    }
+
+    /// Convert to a mutable string type, cloning the data if necessary.
+    #[inline]
+    #[must_use]
+    pub fn into_boxed_str(self) -> crate::backend::BoxedStr {
+        self.inner.into_boxed_str()
+    }
+
+    /// Convert to a Cow str
+    #[inline]
+    #[must_use]
+    pub fn into_cow_str(self) -> Cow<'static, str> {
+        self.inner.into_cow_str()
+    }
+}
+
+impl<B: crate::backend::HeapStr> std::ops::Deref for KStringBase<B> {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<B: crate::backend::HeapStr> Eq for KStringBase<B> {}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<KStringBase<B>> for KStringBase<B> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<str> for KStringBase<B> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        PartialEq::eq(self.as_str(), other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<&'s str> for KStringBase<B> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        PartialEq::eq(self.as_str(), *other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<String> for KStringBase<B> {
+    #[inline]
+    fn eq(&self, other: &StdString) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<B: crate::backend::HeapStr> Ord for KStringBase<B> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl<B: crate::backend::HeapStr> PartialOrd for KStringBase<B> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<B: crate::backend::HeapStr> std::hash::Hash for KStringBase<B> {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}
+
+impl<B: crate::backend::HeapStr> fmt::Debug for KStringBase<B> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
+
+impl<B: crate::backend::HeapStr> fmt::Display for KStringBase<B> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+impl<B: crate::backend::HeapStr> AsRef<str> for KStringBase<B> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<B: crate::backend::HeapStr> AsRef<[u8]> for KStringBase<B> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl<B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringBase<B> {
+    #[inline]
+    fn as_ref(&self) -> &std::ffi::OsStr {
+        (&**self).as_ref()
+    }
+}
+
+impl<B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringBase<B> {
+    #[inline]
+    fn as_ref(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl<B: crate::backend::HeapStr> std::borrow::Borrow<str> for KStringBase<B> {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<B: crate::backend::HeapStr> Default for KStringBase<B> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<KStringRef<'s>> for KStringBase<B> {
+    #[inline]
+    fn from(other: KStringRef<'s>) -> Self {
+        other.to_owned()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringRef<'s>> for KStringBase<B> {
+    #[inline]
+    fn from(other: &'s KStringRef<'s>) -> Self {
+        other.to_owned()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<KStringCowBase<'s, B>> for KStringBase<B> {
+    #[inline]
+    fn from(other: KStringCowBase<'s, B>) -> Self {
+        other.into_owned()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringCowBase<'s, B>> for KStringBase<B> {
+    #[inline]
+    fn from(other: &'s KStringCowBase<'s, B>) -> Self {
+        other.clone().into_owned()
+    }
+}
+
+impl<B: crate::backend::HeapStr> From<StdString> for KStringBase<B> {
+    #[inline]
+    fn from(other: StdString) -> Self {
+        Self::from_string(other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s StdString> for KStringBase<B> {
+    #[inline]
+    fn from(other: &'s StdString) -> Self {
+        Self::from_ref(other)
+    }
+}
+
+impl<B: crate::backend::HeapStr> From<crate::backend::BoxedStr> for KStringBase<B> {
+    #[inline]
+    fn from(other: crate::backend::BoxedStr) -> Self {
+        Self::from_boxed(other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s crate::backend::BoxedStr> for KStringBase<B> {
+    #[inline]
+    fn from(other: &'s crate::backend::BoxedStr) -> Self {
+        Self::from_ref(other)
+    }
+}
+
+impl<B: crate::backend::HeapStr> From<&'static str> for KStringBase<B> {
+    #[inline]
+    fn from(other: &'static str) -> Self {
+        Self::from_static(other)
+    }
+}
+
+impl<B: crate::backend::HeapStr> std::str::FromStr for KStringBase<B> {
+    type Err = std::convert::Infallible;
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self::from_ref(s))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<B: crate::backend::HeapStr> serde::Serialize for KStringBase<B> {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, B: crate::backend::HeapStr> serde::Deserialize<'de> for KStringBase<B> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_string(StringVisitor(std::marker::PhantomData))
+    }
+}
+
+#[cfg(feature = "serde")]
+struct StringVisitor<B>(std::marker::PhantomData<B>);
+
+#[cfg(feature = "serde")]
+impl<'de, B: crate::backend::HeapStr> serde::de::Visitor<'de> for StringVisitor<B> {
+    type Value = KStringBase<B>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(Self::Value::from_ref(v))
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(Self::Value::from_string(v))
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match std::str::from_utf8(v) {
+            Ok(s) => Ok(Self::Value::from_ref(s)),
+            Err(_) => Err(serde::de::Error::invalid_value(
+                serde::de::Unexpected::Bytes(v),
+                &self,
+            )),
+        }
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        match String::from_utf8(v) {
+            Ok(s) => Ok(Self::Value::from_string(s)),
+            Err(e) => Err(serde::de::Error::invalid_value(
+                serde::de::Unexpected::Bytes(&e.into_bytes()),
+                &self,
+            )),
+        }
+    }
+}
+
+use inner::KStringInner;
+
+#[cfg(not(feature = "unsafe"))]
+mod inner {
+    use super::*;
+
+    pub(super) enum KStringInner<B> {
+        Singleton(&'static str),
+        Inline(StackString<CAPACITY>),
+        Owned(B),
+    }
+
+    impl<B> KStringInner<B> {
+        /// Create a reference to a `'static` data.
+        #[inline]
+        pub const fn from_static(other: &'static str) -> Self {
+            Self::Singleton(other)
+        }
+
+        #[inline]
+        pub fn try_inline(other: &str) -> Option<Self> {
+            StackString::try_new(other).map(Self::Inline)
+        }
+    }
+
+    impl<B: crate::backend::HeapStr> KStringInner<B> {
+        #[inline]
+        pub(super) fn from_boxed(other: crate::backend::BoxedStr) -> Self {
+            #[allow(clippy::useless_conversion)]
+            Self::Owned(B::from_boxed_str(other))
+        }
+
+        #[inline]
+        pub(super) fn from_string(other: StdString) -> Self {
+            if (0..=CAPACITY).contains(&other.len()) {
+                let inline = { StackString::new(other.as_str()) };
+                Self::Inline(inline)
+            } else {
+                Self::from_boxed(other.into_boxed_str())
+            }
+        }
+
+        #[inline]
+        pub(super) fn from_ref(other: &str) -> Self {
+            if (0..=CAPACITY).contains(&other.len()) {
+                let inline = { StackString::new(other) };
+                Self::Inline(inline)
+            } else {
+                Self::Owned(B::from_str(other))
+            }
+        }
+
+        #[inline]
+        pub(super) fn as_ref(&self) -> KStringRef<'_> {
+            match self {
+                Self::Singleton(s) => KStringRef::from_static(s),
+                Self::Inline(s) => KStringRef::from_ref(s.as_str()),
+                Self::Owned(s) => KStringRef::from_ref(s.as_str()),
+            }
+        }
+
+        #[inline]
+        pub(super) fn as_str(&self) -> &str {
+            match self {
+                Self::Singleton(s) => s,
+                Self::Inline(s) => s.as_str(),
+                Self::Owned(s) => s.as_str(),
+            }
+        }
+
+        #[inline]
+        pub(super) fn into_boxed_str(self) -> crate::backend::BoxedStr {
+            match self {
+                Self::Singleton(s) => crate::backend::BoxedStr::from(s),
+                Self::Inline(s) => crate::backend::BoxedStr::from(s.as_str()),
+                Self::Owned(s) => crate::backend::BoxedStr::from(s.as_str()),
+            }
+        }
+
+        /// Convert to a Cow str
+        #[inline]
+        pub(super) fn into_cow_str(self) -> Cow<'static, str> {
+            match self {
+                Self::Singleton(s) => Cow::Borrowed(s),
+                Self::Inline(s) => Cow::Owned(s.as_str().into()),
+                Self::Owned(s) => Cow::Owned(s.as_str().into()),
+            }
+        }
+    }
+
+    // Explicit to avoid inlining which cuts clone times in half.
+    //
+    // An automatically derived `clone()` has 10ns overhead while the explicit `Deref`/`as_str` has
+    // none of that.  Being explicit and removing the `#[inline]` attribute dropped the overhead to
+    // 5ns.
+    //
+    // My only guess is that the `clone()` calls we delegate to are just that much bigger than
+    // `as_str()` that, when combined with a jump table, is blowing the icache, slowing things down.
+    impl<B: Clone> Clone for KStringInner<B> {
+        fn clone(&self) -> Self {
+            match self {
+                Self::Singleton(s) => Self::Singleton(s),
+                Self::Inline(s) => Self::Inline(*s),
+                Self::Owned(s) => Self::Owned(s.clone()),
+            }
+        }
+    }
+
+    #[allow(unused)]
+    const LEN_SIZE: usize = std::mem::size_of::<crate::stack::Len>();
+
+    #[allow(unused)]
+    const TAG_SIZE: usize = std::mem::size_of::<u8>();
+
+    #[allow(unused)]
+    const MAX_CAPACITY: usize =
+        std::mem::size_of::<crate::string::StdString>() - TAG_SIZE - LEN_SIZE;
+
+    // Performance seems to slow down when trying to occupy all of the padding left by `String`'s
+    // discriminant.  The question is whether faster len=1-16 "allocations" outweighs going to the heap
+    // for len=17-22.
+    #[allow(unused)]
+    const ALIGNED_CAPACITY: usize = std::mem::size_of::<crate::backend::DefaultStr>() - LEN_SIZE;
+
+    #[cfg(feature = "max_inline")]
+    const CAPACITY: usize = MAX_CAPACITY;
+    #[cfg(not(feature = "max_inline"))]
+    const CAPACITY: usize = ALIGNED_CAPACITY;
+}
+
+#[cfg(feature = "unsafe")]
+mod inner {
+    use super::*;
+
+    pub(super) union KStringInner<B> {
+        tag: TagVariant,
+        singleton: SingletonVariant,
+        owned: std::mem::ManuallyDrop<OwnedVariant<B>>,
+        inline: InlineVariant,
+    }
+
+    impl<B> KStringInner<B> {
+        /// Create a reference to a `'static` data.
+        #[inline]
+        pub const fn from_static(other: &'static str) -> Self {
+            Self {
+                singleton: SingletonVariant::new(other),
+            }
+        }
+
+        #[inline]
+        pub fn try_inline(other: &str) -> Option<Self> {
+            StackString::try_new(other).map(|inline| Self {
+                inline: InlineVariant::new(inline),
+            })
+        }
+
+        #[inline]
+        const fn tag(&self) -> Tag {
+            unsafe {
+                // SAFETY: `tag` is in the same spot in each variant
+                self.tag.tag
+            }
+        }
+    }
+
+    impl<B: crate::backend::HeapStr> KStringInner<B> {
+        #[inline]
+        pub(super) fn from_boxed(other: crate::backend::BoxedStr) -> Self {
+            #[allow(clippy::useless_conversion)]
+            let payload = B::from_boxed_str(other);
+            Self {
+                owned: std::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
+            }
+        }
+
+        #[inline]
+        pub(super) fn from_string(other: StdString) -> Self {
+            if (0..=CAPACITY).contains(&other.len()) {
+                let payload = unsafe {
+                    // SAFETY: range check ensured this is always safe
+                    StackString::new_unchecked(other.as_str())
+                };
+                Self {
+                    inline: InlineVariant::new(payload),
+                }
+            } else {
+                Self::from_boxed(other.into_boxed_str())
+            }
+        }
+
+        #[inline]
+        pub(super) fn from_ref(other: &str) -> Self {
+            if (0..=CAPACITY).contains(&other.len()) {
+                let payload = unsafe {
+                    // SAFETY: range check ensured this is always safe
+                    StackString::new_unchecked(other)
+                };
+                Self {
+                    inline: InlineVariant::new(payload),
+                }
+            } else {
+                #[allow(clippy::useless_conversion)]
+                let payload = B::from_str(other);
+                Self {
+                    owned: std::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
+                }
+            }
+        }
+
+        #[inline]
+        pub(super) fn as_ref(&self) -> KStringRef<'_> {
+            let tag = self.tag();
+            unsafe {
+                // SAFETY: `tag` ensures access to correct variant
+                if tag.is_singleton() {
+                    KStringRef::from_static(self.singleton.payload)
+                } else if tag.is_owned() {
+                    KStringRef::from_ref(self.owned.payload.as_str())
+                } else {
+                    debug_assert!(tag.is_inline());
+                    KStringRef::from_ref(self.inline.payload.as_str())
+                }
+            }
+        }
+
+        #[inline]
+        pub(super) fn as_str(&self) -> &str {
+            let tag = self.tag();
+            unsafe {
+                // SAFETY: `tag` ensures access to correct variant
+                if tag.is_singleton() {
+                    self.singleton.payload
+                } else if tag.is_owned() {
+                    self.owned.payload.as_str()
+                } else {
+                    debug_assert!(tag.is_inline());
+                    self.inline.payload.as_str()
+                }
+            }
+        }
+
+        #[inline]
+        pub(super) fn into_boxed_str(self) -> crate::backend::BoxedStr {
+            let tag = self.tag();
+            unsafe {
+                // SAFETY: `tag` ensures access to correct variant
+                if tag.is_singleton() {
+                    crate::backend::BoxedStr::from(self.singleton.payload)
+                } else if tag.is_owned() {
+                    crate::backend::BoxedStr::from(self.owned.payload.as_str())
+                } else {
+                    debug_assert!(tag.is_inline());
+                    crate::backend::BoxedStr::from(self.inline.payload.as_ref())
+                }
+            }
+        }
+
+        /// Convert to a Cow str
+        #[inline]
+        pub(super) fn into_cow_str(self) -> Cow<'static, str> {
+            let tag = self.tag();
+            unsafe {
+                // SAFETY: `tag` ensures access to correct variant
+                if tag.is_singleton() {
+                    Cow::Borrowed(self.singleton.payload)
+                } else if tag.is_owned() {
+                    Cow::Owned(self.owned.payload.as_str().into())
+                } else {
+                    debug_assert!(tag.is_inline());
+                    Cow::Owned(self.inline.payload.as_str().into())
+                }
+            }
+        }
+    }
+
+    // Explicit to avoid inlining which cuts clone times in half.
+    //
+    // An automatically derived `clone()` has 10ns overhead while the explicit `Deref`/`as_str` has
+    // none of that.  Being explicit and removing the `#[inline]` attribute dropped the overhead to
+    // 5ns.
+    //
+    // My only guess is that the `clone()` calls we delegate to are just that much bigger than
+    // `as_str()` that, when combined with a jump table, is blowing the icache, slowing things down.
+    impl<B: Clone> Clone for KStringInner<B> {
+        fn clone(&self) -> Self {
+            let tag = self.tag();
+            if tag.is_owned() {
+                unsafe {
+                    // SAFETY: `tag` ensures access to correct variant
+                    Self {
+                        owned: std::mem::ManuallyDrop::new(OwnedVariant::new(
+                            self.owned.payload.clone(),
+                        )),
+                    }
+                }
+            } else {
+                unsafe {
+                    // SAFETY: `tag` ensures access to correct variant
+                    // SAFETY: non-owned types are copyable
+                    std::mem::transmute_copy(self)
+                }
+            }
+        }
+    }
+
+    impl<B> Drop for KStringInner<B> {
+        fn drop(&mut self) {
+            let tag = self.tag();
+            if tag.is_owned() {
+                unsafe {
+                    // SAFETY: `tag` ensures we are using the right variant
+                    std::mem::ManuallyDrop::drop(&mut self.owned)
+                }
+            }
+        }
+    }
+
+    #[allow(unused)]
+    const LEN_SIZE: usize = std::mem::size_of::<crate::stack::Len>();
+
+    #[allow(unused)]
+    const TAG_SIZE: usize = std::mem::size_of::<Tag>();
+
+    #[allow(unused)]
+    const PAYLOAD_SIZE: usize = std::mem::size_of::<crate::backend::DefaultStr>();
+    type Payload = Padding<PAYLOAD_SIZE>;
+
+    #[allow(unused)]
+    const TARGET_SIZE: usize = std::mem::size_of::<Target>();
+    type Target = crate::string::StdString;
+
+    #[allow(unused)]
+    const MAX_CAPACITY: usize = TARGET_SIZE - LEN_SIZE - TAG_SIZE;
+
+    // Performance seems to slow down when trying to occupy all of the padding left by `String`'s
+    // discriminant.  The question is whether faster len=1-16 "allocations" outweighs going to the heap
+    // for len=17-22.
+    #[allow(unused)]
+    const ALIGNED_CAPACITY: usize = PAYLOAD_SIZE - LEN_SIZE;
+
+    #[cfg(feature = "max_inline")]
+    const CAPACITY: usize = MAX_CAPACITY;
+    #[cfg(not(feature = "max_inline"))]
+    const CAPACITY: usize = ALIGNED_CAPACITY;
+
+    const PAYLOAD_PAD_SIZE: usize = TARGET_SIZE - PAYLOAD_SIZE - TAG_SIZE;
+    const INLINE_PAD_SIZE: usize = TARGET_SIZE - CAPACITY - LEN_SIZE - TAG_SIZE;
+
+    #[derive(Copy, Clone)]
+    #[repr(C)]
+    struct TagVariant {
+        payload: Payload,
+        pad: Padding<PAYLOAD_PAD_SIZE>,
+        tag: Tag,
+    }
+    static_assertions::assert_eq_size!(Target, TagVariant);
+
+    #[derive(Copy, Clone)]
+    #[repr(C)]
+    struct SingletonVariant {
+        payload: &'static str,
+        pad: Padding<PAYLOAD_PAD_SIZE>,
+        tag: Tag,
+    }
+    static_assertions::assert_eq_size!(Payload, &'static str);
+    static_assertions::assert_eq_size!(Target, SingletonVariant);
+
+    impl SingletonVariant {
+        #[inline]
+        const fn new(payload: &'static str) -> Self {
+            Self {
+                payload,
+                pad: Padding::new(),
+                tag: Tag::SINGLETON,
+            }
+        }
+    }
+
+    impl std::fmt::Debug for SingletonVariant {
+        #[inline]
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.payload.fmt(f)
+        }
+    }
+
+    #[derive(Clone)]
+    #[repr(C)]
+    struct OwnedVariant<B> {
+        payload: B,
+        pad: Padding<PAYLOAD_PAD_SIZE>,
+        tag: Tag,
+    }
+    static_assertions::assert_eq_size!(Payload, crate::backend::DefaultStr);
+    static_assertions::assert_eq_size!(Target, OwnedVariant<crate::backend::DefaultStr>);
+
+    impl<B> OwnedVariant<B> {
+        #[inline]
+        const fn new(payload: B) -> Self {
+            Self {
+                payload,
+                pad: Padding::new(),
+                tag: Tag::OWNED,
+            }
+        }
+    }
+
+    impl<B: crate::backend::HeapStr> std::fmt::Debug for OwnedVariant<B> {
+        #[inline]
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.payload.fmt(f)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    #[repr(C)]
+    struct InlineVariant {
+        payload: StackString<CAPACITY>,
+        pad: Padding<INLINE_PAD_SIZE>,
+        tag: Tag,
+    }
+    static_assertions::assert_eq_size!(Target, InlineVariant);
+
+    impl InlineVariant {
+        #[inline]
+        const fn new(payload: StackString<CAPACITY>) -> Self {
+            Self {
+                payload,
+                pad: Padding::new(),
+                tag: Tag::INLINE,
+            }
+        }
+    }
+
+    impl std::fmt::Debug for InlineVariant {
+        #[inline]
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.payload.fmt(f)
+        }
+    }
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    #[repr(transparent)]
+    struct Tag(u8);
+
+    impl Tag {
+        const SINGLETON: Tag = Tag(0);
+        const OWNED: Tag = Tag(u8::MAX);
+        const INLINE: Tag = Tag(1);
+
+        #[inline]
+        const fn is_singleton(self) -> bool {
+            self.0 == Self::SINGLETON.0
+        }
+
+        #[inline]
+        const fn is_owned(self) -> bool {
+            self.0 == Self::OWNED.0
+        }
+
+        #[inline]
+        const fn is_inline(self) -> bool {
+            !self.is_singleton() && !self.is_owned()
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Padding<const L: usize>([std::mem::MaybeUninit<u8>; L]);
+
+    impl<const L: usize> Padding<L> {
+        const fn new() -> Self {
+            let padding = unsafe {
+                // SAFETY: Padding, never actually used
+                std::mem::MaybeUninit::uninit().assume_init()
+            };
+            Self(padding)
+        }
+    }
+
+    impl<const L: usize> Default for Padding<L> {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_size() {
+        println!("KString: {}", std::mem::size_of::<KString>());
+    }
+}
diff --git a/vendor/kstring/src/string_cow.rs b/vendor/kstring/src/string_cow.rs
new file mode 100644
index 000000000..6a1b4b89a
--- /dev/null
+++ b/vendor/kstring/src/string_cow.rs
@@ -0,0 +1,383 @@
+use std::{borrow::Cow, fmt};
+
+use crate::KStringBase;
+use crate::KStringRef;
+use crate::KStringRefInner;
+
+type StdString = std::string::String;
+type BoxedStr = Box<str>;
+
+/// A reference to a UTF-8 encoded, immutable string.
+pub type KStringCow<'s> = KStringCowBase<'s, crate::backend::DefaultStr>;
+
+/// A reference to a UTF-8 encoded, immutable string.
+#[derive(Clone)]
+#[repr(transparent)]
+pub struct KStringCowBase<'s, B = crate::backend::DefaultStr> {
+    pub(crate) inner: KStringCowInner<'s, B>,
+}
+
+#[derive(Clone)]
+pub(crate) enum KStringCowInner<'s, B> {
+    Borrowed(&'s str),
+    Owned(KStringBase<B>),
+}
+
+impl<'s, B> KStringCowBase<'s, B> {
+    /// Create a new empty `KStringCowBase`.
+    #[inline]
+    #[must_use]
+    pub const fn new() -> Self {
+        Self::from_static("")
+    }
+
+    /// Create a reference to a `'static` data.
+    #[inline]
+    #[must_use]
+    pub const fn from_static(other: &'static str) -> Self {
+        Self {
+            inner: KStringCowInner::Owned(KStringBase::from_static(other)),
+        }
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> KStringCowBase<'s, B> {
+    /// Create an owned `KStringCowBase`.
+    #[inline]
+    #[must_use]
+    pub fn from_boxed(other: BoxedStr) -> Self {
+        Self {
+            inner: KStringCowInner::Owned(KStringBase::from_boxed(other)),
+        }
+    }
+
+    /// Create an owned `KStringCowBase`.
+    #[inline]
+    #[must_use]
+    pub fn from_string(other: StdString) -> Self {
+        Self {
+            inner: KStringCowInner::Owned(KStringBase::from_string(other)),
+        }
+    }
+
+    /// Create a reference to a borrowed data.
+    #[inline]
+    #[must_use]
+    pub fn from_ref(other: &'s str) -> Self {
+        Self {
+            inner: KStringCowInner::Borrowed(other),
+        }
+    }
+
+    /// Get a reference to the `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub fn as_ref(&self) -> KStringRef<'_> {
+        self.inner.as_ref()
+    }
+
+    /// Clone the data into an owned-type.
+    #[inline]
+    #[must_use]
+    pub fn into_owned(self) -> KStringBase<B> {
+        self.inner.into_owned()
+    }
+
+    /// Extracts a string slice containing the entire `KStringCowBase`.
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        self.inner.as_str()
+    }
+
+    /// Convert to a mutable string type, cloning the data if necessary.
+    #[inline]
+    #[must_use]
+    pub fn into_string(self) -> StdString {
+        String::from(self.into_boxed_str())
+    }
+
+    /// Convert to a mutable string type, cloning the data if necessary.
+    #[inline]
+    #[must_use]
+    pub fn into_boxed_str(self) -> BoxedStr {
+        self.inner.into_boxed_str()
+    }
+
+    /// Convert to a Cow str
+    #[inline]
+    #[must_use]
+    pub fn into_cow_str(self) -> Cow<'s, str> {
+        self.inner.into_cow_str()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> KStringCowInner<'s, B> {
+    #[inline]
+    fn as_ref(&self) -> KStringRef<'_> {
+        match self {
+            Self::Borrowed(s) => KStringRef::from_ref(s),
+            Self::Owned(s) => s.as_ref(),
+        }
+    }
+
+    #[inline]
+    fn into_owned(self) -> KStringBase<B> {
+        match self {
+            Self::Borrowed(s) => KStringBase::from_ref(s),
+            Self::Owned(s) => s,
+        }
+    }
+
+    #[inline]
+    fn as_str(&self) -> &str {
+        match self {
+            Self::Borrowed(s) => s,
+            Self::Owned(s) => s.as_str(),
+        }
+    }
+
+    #[inline]
+    fn into_boxed_str(self) -> BoxedStr {
+        match self {
+            Self::Borrowed(s) => BoxedStr::from(s),
+            Self::Owned(s) => s.into_boxed_str(),
+        }
+    }
+
+    /// Convert to a Cow str
+    #[inline]
+    fn into_cow_str(self) -> Cow<'s, str> {
+        match self {
+            Self::Borrowed(s) => Cow::Borrowed(s),
+            Self::Owned(s) => s.into_cow_str(),
+        }
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> std::ops::Deref for KStringCowBase<'s, B> {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> Eq for KStringCowBase<'s, B> {}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<KStringCowBase<'s, B>> for KStringCowBase<'s, B> {
+    #[inline]
+    fn eq(&self, other: &KStringCowBase<'s, B>) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<str> for KStringCowBase<'s, B> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        PartialEq::eq(self.as_str(), other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<&'s str> for KStringCowBase<'s, B> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        PartialEq::eq(self.as_str(), *other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialEq<String> for KStringCowBase<'s, B> {
+    #[inline]
+    fn eq(&self, other: &StdString) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> Ord for KStringCowBase<'s, B> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> PartialOrd for KStringCowBase<'s, B> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> std::hash::Hash for KStringCowBase<'s, B> {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> fmt::Debug for KStringCowBase<'s, B> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> fmt::Display for KStringCowBase<'s, B> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> AsRef<str> for KStringCowBase<'s, B> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> AsRef<[u8]> for KStringCowBase<'s, B> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringCowBase<'s, B> {
+    #[inline]
+    fn as_ref(&self) -> &std::ffi::OsStr {
+        (&**self).as_ref()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringCowBase<'s, B> {
+    #[inline]
+    fn as_ref(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> std::borrow::Borrow<str> for KStringCowBase<'s, B> {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s, B> Default for KStringCowBase<'s, B> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<KStringBase<B>> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: KStringBase<B>) -> Self {
+        let inner = KStringCowInner::Owned(other);
+        Self { inner }
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringBase<B>> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: &'s KStringBase<B>) -> Self {
+        let other = other.as_ref();
+        other.into()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<KStringRef<'s>> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: KStringRef<'s>) -> Self {
+        match other.inner {
+            KStringRefInner::Borrowed(s) => Self::from_ref(s),
+            KStringRefInner::Singleton(s) => Self::from_static(s),
+        }
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringRef<'s>> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: &'s KStringRef<'s>) -> Self {
+        match other.inner {
+            KStringRefInner::Borrowed(s) => Self::from_ref(s),
+            KStringRefInner::Singleton(s) => Self::from_static(s),
+        }
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<StdString> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: StdString) -> Self {
+        Self::from_string(other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s StdString> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: &'s StdString) -> Self {
+        Self::from_ref(other.as_str())
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<BoxedStr> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: BoxedStr) -> Self {
+        // Since the memory is already allocated, don't bother moving it into a FixedString
+        Self::from_boxed(other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s BoxedStr> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: &'s BoxedStr) -> Self {
+        Self::from_ref(other)
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s str> for KStringCowBase<'s, B> {
+    #[inline]
+    fn from(other: &'s str) -> Self {
+        Self::from_ref(other)
+    }
+}
+
+impl<B: crate::backend::HeapStr> std::str::FromStr for KStringCowBase<'_, B> {
+    type Err = std::convert::Infallible;
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self::from_string(s.into()))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'s, B: crate::backend::HeapStr> serde::Serialize for KStringCowBase<'s, B> {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, 's, B: crate::backend::HeapStr> serde::Deserialize<'de> for KStringCowBase<'s, B> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        KStringBase::deserialize(deserializer).map(|s| s.into())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_size() {
+        println!("KStringCow: {}", std::mem::size_of::<KStringCow<'static>>());
+    }
+}
diff --git a/vendor/kstring/src/string_ref.rs b/vendor/kstring/src/string_ref.rs
new file mode 100644
index 000000000..a79b9d46c
--- /dev/null
+++ b/vendor/kstring/src/string_ref.rs
@@ -0,0 +1,277 @@
+use std::fmt;
+
+use crate::KStringBase;
+use crate::KStringCowBase;
+
+type StdString = std::string::String;
+type BoxedStr = Box<str>;
+
+/// A reference to a UTF-8 encoded, immutable string.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct KStringRef<'s> {
+    pub(crate) inner: KStringRefInner<'s>,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum KStringRefInner<'s> {
+    Borrowed(&'s str),
+    Singleton(&'static str),
+}
+
+impl<'s> KStringRef<'s> {
+    /// Create a new empty `KStringBase`.
+    #[inline]
+    #[must_use]
+    pub const fn new() -> Self {
+        Self::from_static("")
+    }
+
+    /// Create a reference to a `'static` data.
+    #[inline]
+    #[must_use]
+    pub const fn from_static(other: &'static str) -> Self {
+        Self {
+            inner: KStringRefInner::Singleton(other),
+        }
+    }
+
+    /// Create a reference to a borrowed data.
+    #[inline]
+    #[must_use]
+    pub fn from_ref(other: &'s str) -> Self {
+        Self {
+            inner: KStringRefInner::Borrowed(other),
+        }
+    }
+
+    /// Clone the data into an owned-type.
+    #[inline]
+    #[must_use]
+    #[allow(clippy::wrong_self_convention)]
+    pub fn to_owned<B: crate::backend::HeapStr>(&self) -> KStringBase<B> {
+        self.inner.to_owned()
+    }
+
+    /// Extracts a string slice containing the entire `KStringRef`.
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        self.inner.as_str()
+    }
+
+    /// Convert to a mutable string type, cloning the data if necessary.
+    #[inline]
+    #[must_use]
+    pub fn into_mut(self) -> StdString {
+        self.inner.into_mut()
+    }
+}
+
+impl<'s> KStringRefInner<'s> {
+    #[inline]
+    #[allow(clippy::wrong_self_convention)]
+    fn to_owned<B: crate::backend::HeapStr>(&self) -> KStringBase<B> {
+        match self {
+            Self::Borrowed(s) => KStringBase::from_ref(s),
+            Self::Singleton(s) => KStringBase::from_static(s),
+        }
+    }
+
+    #[inline]
+    fn as_str(&self) -> &str {
+        match self {
+            Self::Borrowed(s) => s,
+            Self::Singleton(s) => s,
+        }
+    }
+
+    #[inline]
+    fn into_mut(self) -> StdString {
+        self.as_str().to_owned()
+    }
+}
+
+impl<'s> std::ops::Deref for KStringRef<'s> {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s> Eq for KStringRef<'s> {}
+
+impl<'s> PartialEq<KStringRef<'s>> for KStringRef<'s> {
+    #[inline]
+    fn eq(&self, other: &KStringRef<'s>) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<'s> PartialEq<str> for KStringRef<'s> {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        PartialEq::eq(self.as_str(), other)
+    }
+}
+
+impl<'s> PartialEq<&'s str> for KStringRef<'s> {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        PartialEq::eq(self.as_str(), *other)
+    }
+}
+
+impl<'s> PartialEq<String> for KStringRef<'s> {
+    #[inline]
+    fn eq(&self, other: &StdString) -> bool {
+        PartialEq::eq(self.as_str(), other.as_str())
+    }
+}
+
+impl<'s> Ord for KStringRef<'s> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl<'s> PartialOrd for KStringRef<'s> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<'s> std::hash::Hash for KStringRef<'s> {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}
+
+impl<'s> fmt::Debug for KStringRef<'s> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.inner, f)
+    }
+}
+
+impl<'s> fmt::Display for KStringRef<'s> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+impl<'s> AsRef<str> for KStringRef<'s> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s> AsRef<[u8]> for KStringRef<'s> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl<'s> AsRef<std::ffi::OsStr> for KStringRef<'s> {
+    #[inline]
+    fn as_ref(&self) -> &std::ffi::OsStr {
+        (&**self).as_ref()
+    }
+}
+
+impl<'s> AsRef<std::path::Path> for KStringRef<'s> {
+    #[inline]
+    fn as_ref(&self) -> &std::path::Path {
+        std::path::Path::new(self)
+    }
+}
+
+impl<'s> std::borrow::Borrow<str> for KStringRef<'s> {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'s> Default for KStringRef<'s> {
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringBase<B>> for KStringRef<'s> {
+    #[inline]
+    fn from(other: &'s KStringBase<B>) -> Self {
+        other.as_ref()
+    }
+}
+
+impl<'s, B: crate::backend::HeapStr> From<&'s KStringCowBase<'s, B>> for KStringRef<'s> {
+    #[inline]
+    fn from(other: &'s KStringCowBase<'s, B>) -> Self {
+        other.as_ref()
+    }
+}
+
+impl<'s> From<&'s StdString> for KStringRef<'s> {
+    #[inline]
+    fn from(other: &'s StdString) -> Self {
+        KStringRef::from_ref(other.as_str())
+    }
+}
+
+impl<'s> From<&'s BoxedStr> for KStringRef<'s> {
+    #[inline]
+    fn from(other: &'s BoxedStr) -> Self {
+        Self::from_ref(other)
+    }
+}
+
+impl<'s> From<&'s str> for KStringRef<'s> {
+    #[inline]
+    fn from(other: &'s str) -> Self {
+        KStringRef::from_ref(other)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'s> serde::Serialize for KStringRef<'s> {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de: 's, 's> serde::Deserialize<'de> for KStringRef<'s> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s: &'s str = serde::Deserialize::deserialize(deserializer)?;
+        let s = KStringRef::from_ref(s);
+        Ok(s)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_size() {
+        println!("KStringRef: {}", std::mem::size_of::<KStringRef<'static>>());
+    }
+}