initial commit

.gitignore

···
+target

Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
+dependencies = [
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "clap"
+version = "4.5.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c26d721170e0295f191a69bd9a1f93efcdb0aff38684b61ab5750468972e5f5"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75835f0c7bf681bfd05abe44e965760fea999a5286c6eb2d59883634fd02011a"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "indexmap"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "libredox"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+dependencies = [
+ "bitflags",
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pest"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "989e7521a040efde50c3ab6bbadafbe15ab6dc042686926be59ac35d74607df4"
+dependencies = [
+ "memchr",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "187da9a3030dbafabbbfb20cb323b976dc7b7ce91fcd84f2f74d6e31d378e2de"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49b401d98f5757ebe97a26085998d6c0eecec4995cad6ab7fc30ffdf4b052843"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f27a2cfee9f9039c4d86faa5af122a0ac3851441a34865b8a043b46be0065a"
+dependencies = [
+ "pest",
+ "sha2",
+]
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom",
+ "libredox",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.145"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_qs"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd34f36fe4c5ba9654417139a9b3a20d2e1de6012ee678ad14d240c22c78d8d6"
+dependencies = [
+ "percent-encoding",
+ "serde",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.110"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "uson"
+version = "0.1.0"
+dependencies = [
+ "base64",
+ "clap",
+ "dirs",
+ "hex",
+ "pest",
+ "pest_derive",
+ "pretty_assertions",
+ "serde",
+ "serde_json",
+ "serde_qs",
+ "serde_yaml",
+ "thiserror 2.0.17",
+ "toml",
+]
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"

Cargo.toml

···
+[package]
+name = "uson"
+version = "0.1.0"
+edition = "2021"
+authors = ["Your Name"]
+description = "A Rust parser for μson (microson) - a relaxed JSON variant"
+license = "MIT"
+readme = "README.md"
+
+[[bin]]
+name = "uson"
+path = "src/main.rs"
+
+[dependencies]
+pest = "2.7"
+pest_derive = "2.7"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "2.0"
+clap = { version = "4.5", features = ["derive"] }
+base64 = "0.22"
+hex = "0.4"
+serde_yaml = { version = "0.9", optional = true }
+serde_qs = { version = "0.13", optional = true }
+toml = "0.9"
+dirs = "5.0"
+
+[dev-dependencies]
+pretty_assertions = "1.4"
+
+[features]
+default = []
+yaml = ["dep:serde_yaml"]
+form = ["dep:serde_qs"]
+
+[[test]]
+name = "compliance"
+path = "tests/compliance.rs"

Makefile

···
+.PHONY: build install release clean test run help
+
+# Default target
+help:
+	@echo "uson Makefile"
+	@echo ""
+	@echo "Available targets:"
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-12s\033[0m %s\n", $$1, $$2}'
+
+build: ## Build in debug mode
+	cargo build
+
+release: ## Build optimized release binary
+	cargo build --release
+	@echo ""
+	@echo "Release binary: target/release/uson"
+
+install: ## Install to ~/.cargo/bin
+	cargo install --path .
+
+clean: ## Clean build artifacts
+	cargo clean
+
+test: ## Run tests
+	cargo test
+
+run: ## Run with example query
+	cargo run -- "did" -b "1" -j 1
+
+fmt: ## Format code
+	cargo fmt
+
+lint: ## Run clippy linter
+	cargo clippy -- -D warnings
+
+check: ## Check without building
+	cargo check

README.md

···
+# μson (uson)
+
+A compact human-readable data serialization format specially designed for shell.
+
+This format is certainly not intended to replace the classical JSON format, but brings different syntax, for use in environments with specific requirements.
+
+Main advantage should be in better writability (mostly in the command line), because it uses less expressive syntax. The purpose is not to create a format that is as small as possible in terms of byte size.
+
+This is a Rust implementation of μson. Grammar is written using [Pest](https://pest.rs/) parser. This is a port of the original [JavaScript implementation](https://github.com/burningtree/uson).
+
+* [μson Overview](#μson-overview)
+* [Rust Library](#rust-library)
+* [Command-line tool (CLI)](#command-line-tool-cli)
+
+## μson Overview
+
+* [Introduction](#introduction)
+  * [Principles](#principles)
+* [Example](#example)
+* [Basic usage](#basic-usage)
+  * [Standard types](#standard-types)
+  * [Arrays](#arrays)
+  * [Objects](#objects)
+  * [Nested objects](#nested-objects)
+  * [Type casting](#type-casting)
+  * [Custom types](#custom-types)
+  * [Comments](#comments)
+
+### Introduction
+
+#### Principles
+
+* Superset of JSON (every JSON is valid μson).
+* Whitespace is not significant.
+* String quoting `"` is optional.
+* In Array or Object, comma `,` can be replaced by whitespace ` `.
+* Assignment with colon `:` can be repeated to create nested objects (see [Nested objects](#nested-objects)).
+* You can use custom types, casting is done by `!` character (see [Type casting](#type-casting)).
+
+### Example
+
+```
+endpoint:id:wikipedia pages:[Malta Prague "New York"]
+```
+
+Result in JSON:
+```json
+[
+  {
+    "endpoint": {
+      "id": "wikipedia"
+    }
+  },
+  {
+    "pages": [
+      "Malta",
+      "Prague",
+      "New York"
+    ]
+  }
+]
+```
+
+### Basic usage
+
+```
+expr1 expr2 expr3 ..
+```
+
+Supported types:
+* false
+* null
+* true
+* array
+* object
+* number
+* string
+
+#### Standard types
+
+```
+number:12.05 text:Banana quotedText:"John Devilseed" empty:null good:true
+```
+
+Output:
+```json
+[
+  {
+    "number": 12.05
+  },
+  {
+    "text": "Banana"
+  },
+  {
+    "quotedText": "John Devilseed"
+  },
+  {
+    "empty": null
+  },
+  {
+    "good": true
+  }
+]
+```
+
+#### Arrays
+
+```
+simple:[1 2 3] texts:[Malta Budapest "New York"] objects:[{id:1}]
+```
+
+Output:
+```json
+[
+  {
+    "simple": [
+      1,
+      2,
+      3
+    ]
+  },
+  {
+    "texts": [
+      "Malta",
+      "Budapest",
+      "New York"
+    ]
+  },
+  {
+    "objects": [
+      {
+        "id": 1
+      }
+    ]
+  }
+]
+```
+
+#### Objects
+
+```
+obj:{name:John} {nested:[{id:42} value:"Nagano"]}
+```
+
+Output:
+```json
+[
+  {
+    "obj": {
+      "name": "John"
+    }
+  },
+  {
+    "nested": [
+      {
+        "id": 42
+      },
+      {
+        "value": "Nagano"
+      }
+    ]
+  }
+]
+```
+
+#### Nested objects
+
+You can use standard colon notation to expand objects:
+```
+<key>:(<value>|(<key>:(<value>| .. )))
+```
+
+For example:
+```
+cities:eu:hu:budapest:Budapest
+```
+
+becomes:
+```json
+[
+  {
+    "cities": {
+      "eu": {
+        "hu": {
+          "budapest": "Budapest"
+        }
+      }
+    }
+  }
+]
+```
+
+#### Type casting
+
+If you want to return a value in specific type, you can use this syntax:
+```
+<type>!<expr>
+```
+
+For example, this input:
+```
+str!42
+```
+
+produces this output:
+```json
+["42"]
+```
+
+You can use casting repeatedly:
+```
+str!int!12.42
+```
+
+output:
+```json
+["12"]
+```
+
+##### Built-in casting types
+
+**Scalars:**
+* `str` - string
+* `int` - integer
+* `float` - float
+* `null` - null
+* `bool` - boolean
+* `date` - date & time (ISO 8601 formatting)
+
+**Data formats:**
+* `base64` - decode base64 to bytes
+* `hex` - decode hex to bytes
+* `url` - parse URL
+* `regex` - parse regular expression
+* `toml` - parse TOML data
+
+#### Custom types
+
+Custom type support is planned for future versions.
+
+#### Comments
+
+Comments begin with `#` and terminate at end of line.
+
+```
+array:[1 2 3] # this is a comment
+```
+
+Output:
+```json
+[
+  {
+    "array": [
+      1,
+      2,
+      3
+    ]
+  }
+]
+```
+
+## Rust Library
+
+### Installation
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+uson = "0.1.0"
+```
+
+### Usage
+
+```rust
+use uson::{parse, Value};
+
+fn main() {
+    // Parse μson
+    let result = parse("name:John age:30 active:true").unwrap();
+    
+    // Convert to JSON
+    let json = uson::to_json("name:John age:30", true, true).unwrap();
+    println!("{}", json);
+}
+```
+
+### API
+
+* `uson::parse(input: &str) -> Result<Vec<Value>, ParseError>` - Parse μson string
+* `uson::to_json(input: &str, apply_types: bool, pretty: bool) -> Result<String, ParseError>` - Parse and convert to JSON
+* `uson::stringify(input: &str, apply_types: bool) -> Result<String, ParseError>` - Parse and stringify back to μson
+* `uson::apply_builtin_types(value: Value) -> Value` - Apply built-in type transformations
+
+## Command-line tool (CLI)
+
+### Installation
+
+```bash
+cargo install uson
+```
+
+### Usage
+
+```bash
+$ uson [options] [expression]
+```
+
+### Example
+
+```bash
+$ uson 'user:john age:42'
+```
+
+Returns:
+```json
+[{"user":"john"},{"age":42}]
+```
+
+### Options
+
+For pretty-printed output, use `--pretty` or `-p`:
+
+```bash
+$ uson --pretty 'name:John age:30'
+```
+
+To read from a file, use `--file` or `-f`:
+
+```bash
+$ uson --file input.uson
+```
+
+To apply built-in type transformations, use `--types` or `-t`:
+
+```bash
+$ uson --types 'date!"2024-01-01"'
+```
+
+### Output Formats
+
+- JSON (default): `--json` or `-j`
+- YAML: `--yaml` or `-y` (requires `yaml` feature)
+- Query string: `--form` or `-F` (requires `form` feature)
+
+Example:
+```bash
+$ uson --yaml --pretty 'endpoint:id:wikipedia'
+```
+
+Returns:
+```yaml
+- endpoint:
+    id: wikipedia
+```
+
+### Streams support (pipe)
+
+If you don't specify any input then input is taken from standard input (stdin):
+
+```bash
+$ echo "a b c:[a:42]" | uson --pretty
+```
+
+## Development
+
+```bash
+# Build
+cargo build
+
+# Run tests
+cargo test
+
+# Run compliance tests
+cargo test --test compliance
+
+# Build with all features
+cargo build --all-features
+```
+
+## Inspiration
+
+Inspired by the original JavaScript implementation by [@burningtree](https://github.com/burningtree).
+
+## License
+
+MIT

src/ast.rs

···
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Value {
+    Null,
+    Bool(bool),
+    Number(Number),
+    String(String),
+    Array(Vec<Value>),
+    Object(HashMap<String, Value>),
+    Typed {
+        type_name: String,
+        value: Box<Value>,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Number {
+    Integer(i64),
+    Float(f64),
+}
+
+impl Value {
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            Value::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    pub fn as_number(&self) -> Option<&Number> {
+        match self {
+            Value::Number(n) => Some(n),
+            _ => None,
+        }
+    }
+
+    pub fn as_string(&self) -> Option<&str> {
+        match self {
+            Value::String(s) => Some(s),
+            _ => None,
+        }
+    }
+
+    pub fn as_array(&self) -> Option<&Vec<Value>> {
+        match self {
+            Value::Array(a) => Some(a),
+            _ => None,
+        }
+    }
+
+    pub fn as_object(&self) -> Option<&HashMap<String, Value>> {
+        match self {
+            Value::Object(o) => Some(o),
+            _ => None,
+        }
+    }
+
+    /// Convert to minimal μson string format (no unnecessary quotes, compact)
+    pub fn to_uson_string(&self) -> String {
+        match self {
+            Value::Null => "null".to_string(),
+            Value::Bool(b) => b.to_string(),
+            Value::Number(Number::Integer(i)) => i.to_string(),
+            Value::Number(Number::Float(f)) => {
+                // Format float
+                let s = f.to_string();
+                // Avoid scientific notation for simple numbers if possible
+                if s.contains('e') && f.abs() < 1e10 && f.fract() == 0.0 {
+                    format!("{:.0}", f)
+                } else {
+                    s
+                }
+            }
+            Value::String(s) => {
+                // Use unquoted strings when possible
+                if needs_quoting(s) {
+                    format!("\"{}\"", escape_string(s))
+                } else {
+                    s.clone()
+                }
+            }
+            Value::Array(arr) => {
+                if arr.is_empty() {
+                    "[]".to_string()
+                } else {
+                    let items: Vec<String> = arr
+                        .iter()
+                        .map(|v| v.to_uson_string())
+                        .collect();
+                    format!("[{}]", items.join(" "))
+                }
+            }
+            Value::Object(obj) => {
+                if obj.is_empty() {
+                    "{}".to_string()
+                } else {
+                    let mut items: Vec<String> = obj
+                        .iter()
+                        .map(|(k, v)| {
+                            let key = if needs_quoting(k) {
+                                format!("\"{}\"", escape_string(k))
+                            } else {
+                                k.clone()
+                            };
+                            format!("{}:{}", key, v.to_uson_string())
+                        })
+                        .collect();
+                    items.sort(); // Sort for consistent output
+                    format!("{{{}}}", items.join(" "))
+                }
+            }
+            Value::Typed { type_name, value } => {
+                format!("{}!{}", type_name, value.to_uson_string())
+            }
+        }
+    }
+
+    /// Convert to pretty μson string format with indentation
+    pub fn to_uson_string_pretty(&self) -> String {
+        self.stringify_pretty(0)
+    }
+
+    fn stringify_pretty(&self, indent: usize) -> String {
+        let indent_str = "  ".repeat(indent);
+        let next_indent_str = "  ".repeat(indent + 1);
+
+        match self {
+            Value::Null => "null".to_string(),
+            Value::Bool(b) => b.to_string(),
+            Value::Number(Number::Integer(i)) => i.to_string(),
+            Value::Number(Number::Float(f)) => f.to_string(),
+            Value::String(s) => {
+                if needs_quoting(s) {
+                    format!("\"{}\"", escape_string(s))
+                } else {
+                    s.clone()
+                }
+            }
+            Value::Array(arr) => {
+                if arr.is_empty() {
+                    "[]".to_string()
+                } else if arr.len() <= 3 && arr.iter().all(|v| matches!(v, Value::Number(_) | Value::String(_) | Value::Bool(_) | Value::Null)) {
+                    // Keep simple arrays on one line
+                    let items: Vec<String> = arr.iter().map(|v| v.to_uson_string()).collect();
+                    format!("[{}]", items.join(" "))
+                } else {
+                    // Multi-line for complex arrays
+                    let items: Vec<String> = arr
+                        .iter()
+                        .map(|v| format!("{}{}", next_indent_str, v.stringify_pretty(indent + 1)))
+                        .collect();
+                    format!("[\n{}\n{}]", items.join("\n"), indent_str)
+                }
+            }
+            Value::Object(obj) => {
+                if obj.is_empty() {
+                    "{}".to_string()
+                } else {
+                    let mut items: Vec<(String, String)> = obj
+                        .iter()
+                        .map(|(k, v)| {
+                            let key = if needs_quoting(k) {
+                                format!("\"{}\"", escape_string(k))
+                            } else {
+                                k.clone()
+                            };
+                            (k.clone(), format!("{}{}: {}", next_indent_str, key, v.stringify_pretty(indent + 1)))
+                        })
+                        .collect();
+                    items.sort_by(|a, b| a.0.cmp(&b.0));
+                    let formatted: Vec<String> = items.into_iter().map(|(_, s)| s).collect();
+                    format!("{{\n{}\n{}}}", formatted.join("\n"), indent_str)
+                }
+            }
+            Value::Typed { type_name, value } => {
+                format!("{}!{}", type_name, value.stringify_pretty(indent))
+            }
+        }
+    }
+
+    /// Convert to JSON string
+    pub fn to_json_string(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string(self)
+    }
+
+    /// Convert to pretty JSON string
+    pub fn to_json_string_pretty(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(self)
+    }
+}
+
+fn needs_quoting(s: &str) -> bool {
+    if s.is_empty() {
+        return true;
+    }
+
+    // Check if it's a reserved keyword
+    if matches!(s, "true" | "false" | "null") {
+        return true;
+    }
+
+    // Check if it looks like a number
+    if s.parse::<f64>().is_ok() {
+        return true;
+    }
+
+    // Check if it contains special characters or starts with certain chars
+    for ch in s.chars() {
+        if matches!(ch, ' ' | '\t' | '\n' | '\r' | '"' | '\'' | '#' | ',' | ':' | '[' | ']' | '{' | '}' | '\\' | '!' | '/' | '=' | '<' | '>') {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn escape_string(s: &str) -> String {
+    let mut result = String::new();
+    for ch in s.chars() {
+        match ch {
+            '"' => result.push_str("\\\""),
+            '\\' => result.push_str("\\\\"),
+            '\n' => result.push_str("\\n"),
+            '\r' => result.push_str("\\r"),
+            '\t' => result.push_str("\\t"),
+            '\x08' => result.push_str("\\b"),
+            '\x0C' => result.push_str("\\f"),
+            _ => result.push(ch),
+        }
+    }
+    result
+}
+
+impl Number {
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Number::Integer(i) => Some(*i),
+            Number::Float(f) => {
+                if f.fract() == 0.0 && *f >= i64::MIN as f64 && *f <= i64::MAX as f64 {
+                    Some(*f as i64)
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    pub fn as_f64(&self) -> f64 {
+        match self {
+            Number::Integer(i) => *i as f64,
+            Number::Float(f) => *f,
+        }
+    }
+}

src/lib.rs

···
+pub mod ast;
+pub mod parser;
+
+pub use ast::{Number, Value};
+pub use parser::{parse, apply_builtin_types, ParseError, ParseResult};
+
+/// Parse and stringify in one go (for convenience)
+pub fn stringify(input: &str, apply_types: bool) -> ParseResult<String> {
+    let mut values = parse(input)?;
+    if apply_types {
+        values = values.into_iter().map(apply_builtin_types).collect();
+    }
+    
+    if values.len() == 1 {
+        Ok(values[0].to_uson_string())
+    } else {
+        let strings: Vec<String> = values.iter().map(|v| v.to_uson_string()).collect();
+        Ok(strings.join(" "))
+    }
+}
+
+/// Parse and convert to JSON string
+pub fn to_json(input: &str, apply_types: bool, pretty: bool) -> ParseResult<String> {
+    let mut values = parse(input)?;
+    if apply_types {
+        values = values.into_iter().map(apply_builtin_types).collect();
+    }
+    
+    let json_value = serde_json::to_value(&values)
+        .map_err(|e| ParseError::NumberError(e.to_string()))?;
+    
+    if pretty {
+        serde_json::to_string_pretty(&json_value)
+            .map_err(|e| ParseError::NumberError(e.to_string()))
+    } else {
+        serde_json::to_string(&json_value)
+            .map_err(|e| ParseError::NumberError(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_null() {
+        let result = parse("null").unwrap();
+        assert_eq!(result, vec![Value::Null]);
+    }
+
+    #[test]
+    fn test_bool() {
+        assert_eq!(parse("true").unwrap(), vec![Value::Bool(true)]);
+        assert_eq!(parse("false").unwrap(), vec![Value::Bool(false)]);
+    }
+
+    #[test]
+    fn test_numbers() {
+        assert_eq!(
+            parse("42").unwrap(),
+            vec![Value::Number(Number::Integer(42))]
+        );
+        assert_eq!(
+            parse("3.14").unwrap(),
+            vec![Value::Number(Number::Float(3.14))]
+        );
+        assert_eq!(
+            parse("-10").unwrap(),
+            vec![Value::Number(Number::Integer(-10))]
+        );
+    }
+
+    #[test]
+    fn test_strings() {
+        assert_eq!(
+            parse("\"hello\"").unwrap(),
+            vec![Value::String("hello".to_string())]
+        );
+        assert_eq!(
+            parse("'world'").unwrap(),
+            vec![Value::String("world".to_string())]
+        );
+        assert_eq!(
+            parse("unquoted").unwrap(),
+            vec![Value::String("unquoted".to_string())]
+        );
+    }
+
+    #[test]
+    fn test_array() {
+        let result = parse("[1, 2, 3]").unwrap();
+        assert_eq!(
+            result,
+            vec![Value::Array(vec![
+                Value::Number(Number::Integer(1)),
+                Value::Number(Number::Integer(2)),
+                Value::Number(Number::Integer(3))
+            ])]
+        );
+    }
+
+    #[test]
+    fn test_array_no_commas() {
+        let result = parse("[1 2 3]").unwrap();
+        assert_eq!(
+            result,
+            vec![Value::Array(vec![
+                Value::Number(Number::Integer(1)),
+                Value::Number(Number::Integer(2)),
+                Value::Number(Number::Integer(3))
+            ])]
+        );
+    }
+
+    #[test]
+    fn test_object() {
+        let result = parse(r#"{"key": "value"}"#).unwrap();
+        let mut expected = std::collections::HashMap::new();
+        expected.insert("key".to_string(), Value::String("value".to_string()));
+        assert_eq!(result, vec![Value::Object(expected)]);
+    }
+
+    #[test]
+    fn test_comment() {
+        let result = parse("# comment\n42").unwrap();
+        assert_eq!(result, vec![Value::Number(Number::Integer(42))]);
+    }
+
+    #[test]
+    fn test_typed() {
+        let result = parse("date!\"2024-01-01\"").unwrap();
+        assert_eq!(
+            result,
+            vec![Value::Typed {
+                type_name: "date".to_string(),
+                value: Box::new(Value::String("2024-01-01".to_string()))
+            }]
+        );
+    }
+
+    #[test]
+    fn test_assign() {
+        let result = parse(r#"name: "John""#).unwrap();
+        let mut expected = std::collections::HashMap::new();
+        expected.insert("name".to_string(), Value::String("John".to_string()));
+        assert_eq!(result, vec![Value::Object(expected)]);
+    }
+
+    #[test]
+    fn test_multiple_expressions() {
+        let result = parse("1 2 3").unwrap();
+        assert_eq!(
+            result,
+            vec![
+                Value::Number(Number::Integer(1)),
+                Value::Number(Number::Integer(2)),
+                Value::Number(Number::Integer(3))
+            ]
+        );
+    }
+
+    #[test]
+    fn test_stringify_simple() {
+        let value = Value::String("hello".to_string());
+        assert_eq!(value.to_uson_string(), "hello");
+    }
+
+    #[test]
+    fn test_stringify_number() {
+        let value = Value::Number(Number::Integer(42));
+        assert_eq!(value.to_uson_string(), "42");
+    }
+
+    #[test]
+    fn test_stringify_array() {
+        let value = Value::Array(vec![
+            Value::Number(Number::Integer(1)),
+            Value::Number(Number::Integer(2)),
+            Value::Number(Number::Integer(3)),
+        ]);
+        assert_eq!(value.to_uson_string(), "[1 2 3]");
+    }
+
+    #[test]
+    fn test_stringify_object() {
+        let mut obj = std::collections::HashMap::new();
+        obj.insert("name".to_string(), Value::String("John".to_string()));
+        obj.insert("age".to_string(), Value::Number(Number::Integer(30)));
+        let value = Value::Object(obj);
+        let result = value.to_uson_string();
+        // Note: HashMap doesn't guarantee order, but our stringify sorts keys
+        assert!(result.contains("age:30"));
+        assert!(result.contains("name:John"));
+    }
+
+    #[test]
+    fn test_stringify_needs_quotes() {
+        let value = Value::String("hello world".to_string());
+        assert_eq!(value.to_uson_string(), "\"hello world\"");
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        let input = "name:John age:30 active:true";
+        let parsed = parse(input).unwrap();
+        let stringified: Vec<String> = parsed.iter().map(|v| v.to_uson_string()).collect();
+        let result = stringified.join(" ");
+        
+        // Parse again
+        let reparsed = parse(&result).unwrap();
+        assert_eq!(parsed, reparsed);
+    }
+}

src/main.rs

···
+use clap::Parser;
+use std::collections::HashMap;
+use std::fs;
+use std::io::{self, Read};
+use std::path::PathBuf;
+use uson::{parse, apply_builtin_types, Value};
+use base64::Engine;
+
+#[derive(Parser)]
+#[command(name = "uson")]
+#[command(author, version)]
+#[command(about = "μson (uson) is a shorthand for JSON", long_about = None)]
+struct Cli {
+    /// μson expression to parse (can be multiple words without quotes)
+    #[arg(value_name = "EXPRESSION", num_args = 0..)]
+    expression: Vec<String>,
+
+    /// "object" mode - combines all expressions into one object
+    #[arg(short, long)]
+    object: bool,
+
+    /// "json" mode (default)
+    #[arg(short, long)]
+    json: bool,
+
+    /// Load data from file
+    #[arg(short, long, value_name = "FILE")]
+    input: Option<PathBuf>,
+
+    /// Write output to file
+    #[arg(long, value_name = "FILE")]
+    output: Option<PathBuf>,
+
+    /// Pretty print output
+    #[arg(short, long)]
+    pretty: bool,
+
+    /// Output format: json (default), uson, form, yaml
+    #[arg(short = 'F', long, value_name = "FORMAT", default_value = "json")]
+    format: String,
+
+    /// Return output in form query-string
+    #[arg(short, long)]
+    #[cfg(feature = "form")]
+    form: bool,
+
+    /// Return output in YAML
+    #[arg(short = 'y', long)]
+    #[cfg(feature = "yaml")]
+    yaml: bool,
+
+    /// Use custom usonrc file instead of ~/.usonrc.toml
+    #[arg(short, long, value_name = "FILE")]
+    usonrc: Option<PathBuf>,
+
+    /// Output in hex encoding
+    #[arg(long)]
+    hex: bool,
+
+    /// Output in base64 encoding
+    #[arg(long)]
+    base64: bool,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct UsonConfig {
+    #[serde(default)]
+    types: HashMap<String, String>,
+}
+
+fn main() {
+    let cli = Cli::parse();
+
+    if let Err(e) = run(cli) {
+        eprintln!("Error: {}", e);
+        std::process::exit(1);
+    }
+}
+
+fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
+    // Extract all values we need from cli before any moves
+    let expression = if !cli.expression.is_empty() {
+        Some(cli.expression.join(" "))
+    } else {
+        None
+    };
+    let input_file = cli.input;
+    let object_mode = cli.object;
+    let output_file = cli.output;
+    let hex_encode = cli.hex;
+    let base64_encode = cli.base64;
+    let pretty = cli.pretty;
+    let usonrc_path = cli.usonrc;
+    let format = cli.format.to_lowercase();
+    
+    #[cfg(feature = "yaml")]
+    let yaml_output = cli.yaml;
+    
+    #[cfg(feature = "form")]
+    let form_output = cli.form;
+    
+    // Load configuration
+    let config = load_config(usonrc_path)?;
+
+    // Get input
+    let input = get_input(expression, input_file)?;
+
+    // Parse
+    let mut values = parse(&input)?;
+
+    // Apply built-in type handlers first
+    values = values.into_iter().map(apply_builtin_types).collect();
+
+    // Apply custom type handlers from config
+    if !config.types.is_empty() {
+        values = apply_type_handlers(values, &config)?;
+    }
+
+    // Format output based on specified format
+    let output = match format.as_str() {
+        "uson" | "microson" => {
+            // Output in μson format
+            format_uson(&values, object_mode, pretty)?
+        }
+        "json" => {
+            // Convert to output format based on mode
+            let result = if object_mode {
+                merge_to_object(values)?
+            } else {
+                serde_json::to_value(&values)?
+            };
+
+            format_output(
+                &result,
+                pretty,
+                #[cfg(feature = "yaml")]
+                yaml_output,
+                #[cfg(feature = "form")]
+                form_output,
+            )?
+        }
+        _ => {
+            return Err(format!("Unknown format: {}", format).into());
+        }
+    };
+
+    // Encode if needed
+    let final_output = if hex_encode {
+        hex::encode(&output)
+    } else if base64_encode {
+        base64::engine::general_purpose::STANDARD.encode(&output)
+    } else {
+        output
+    };
+
+    // Write output
+    write_output(&final_output, output_file)?;
+
+    Ok(())
+}
+
+fn format_uson(values: &[Value], object_mode: bool, pretty: bool) -> Result<String, Box<dyn std::error::Error>> {
+    if object_mode {
+        // Merge all into one object first
+        let mut merged = HashMap::new();
+        for value in values {
+            match value {
+                Value::Object(obj) => {
+                    for (key, val) in obj {
+                        merged.insert(key.clone(), val.clone());
+                    }
+                }
+                _ => {
+                    return Err("Object mode requires all values to be objects".into());
+                }
+            }
+        }
+        let merged_value = Value::Object(merged);
+        Ok(if pretty {
+            merged_value.to_uson_string_pretty()
+        } else {
+            merged_value.to_uson_string()
+        })
+    } else {
+        // Output each value
+        if values.len() == 1 {
+            Ok(if pretty {
+                values[0].to_uson_string_pretty()
+            } else {
+                values[0].to_uson_string()
+            })
+        } else {
+            let strings: Vec<String> = values.iter().map(|v| {
+                if pretty {
+                    v.to_uson_string_pretty()
+                } else {
+                    v.to_uson_string()
+                }
+            }).collect();
+            Ok(strings.join(if pretty { "\n\n" } else { " " }))
+        }
+    }
+}
+
+fn load_config(custom_path: Option<PathBuf>) -> Result<UsonConfig, Box<dyn std::error::Error>> {
+    let config_path = if let Some(path) = custom_path {
+        path
+    } else {
+        let home = dirs::home_dir().ok_or("Could not find home directory")?;
+        home.join(".usonrc.toml")
+    };
+
+    if config_path.exists() {
+        let content = fs::read_to_string(config_path)?;
+        let config: UsonConfig = toml::from_str(&content)?;
+        Ok(config)
+    } else {
+        Ok(UsonConfig {
+            types: HashMap::new(),
+        })
+    }
+}
+
+fn get_input(
+    expression: Option<String>,
+    input_file: Option<PathBuf>,
+) -> Result<String, Box<dyn std::error::Error>> {
+    if let Some(expr) = expression {
+        Ok(expr)
+    } else if let Some(file) = input_file {
+        Ok(fs::read_to_string(file)?)
+    } else {
+        // Read from stdin
+        let mut buffer = String::new();
+        io::stdin().read_to_string(&mut buffer)?;
+        Ok(buffer)
+    }
+}
+
+fn apply_type_handlers(
+    values: Vec<Value>,
+    _config: &UsonConfig,
+) -> Result<Vec<Value>, Box<dyn std::error::Error>> {
+    // Note: Custom type handlers would require dynamic evaluation
+    // For now, we'll keep typed values as-is
+    // In a real implementation, you might want to use a scripting engine like rhai or lua
+    Ok(values)
+}
+
+fn merge_to_object(values: Vec<Value>) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
+    let mut result = serde_json::Map::new();
+
+    for value in values {
+        match value {
+            Value::Object(obj) => {
+                for (key, val) in obj {
+                    result.insert(key, serde_json::to_value(val)?);
+                }
+            }
+            _ => {
+                return Err("Object mode requires all values to be objects".into());
+            }
+        }
+    }
+
+    Ok(serde_json::Value::Object(result))
+}
+
+fn format_output(
+    value: &serde_json::Value,
+    pretty: bool,
+    #[cfg(feature = "yaml")]
+    yaml: bool,
+    #[cfg(feature = "form")]
+    form: bool,
+) -> Result<String, Box<dyn std::error::Error>> {
+    #[cfg(feature = "yaml")]
+    if yaml {
+        return Ok(serde_yaml::to_string(value)?);
+    }
+
+    #[cfg(feature = "form")]
+    if form {
+        return Ok(serde_qs::to_string(value)?);
+    }
+
+    // Default: JSON
+    if pretty {
+        Ok(serde_json::to_string_pretty(value)?)
+    } else {
+        Ok(serde_json::to_string(value)?)
+    }
+}
+
+fn write_output(
+    output: &str,
+    output_file: Option<PathBuf>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if let Some(file) = output_file {
+        fs::write(file, output)?;
+    } else {
+        println!("{}", output);
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_merge_to_object() {
+        let values = vec![
+            Value::Object({
+                let mut map = HashMap::new();
+                map.insert("user".to_string(), Value::String("john".to_string()));
+                map
+            }),
+            Value::Object({
+                let mut map = HashMap::new();
+                map.insert("age".to_string(), Value::Number(uson::Number::Integer(42)));
+                map
+            }),
+        ];
+
+        let result = merge_to_object(values).unwrap();
+        assert!(result.is_object());
+        let obj = result.as_object().unwrap();
+        assert_eq!(obj.get("user").unwrap().as_str().unwrap(), "john");
+        assert_eq!(obj.get("age").unwrap().as_i64().unwrap(), 42);
+    }
+}

src/parser.rs

···
+use crate::ast::{Number, Value};
+use pest::iterators::Pair;
+use pest::Parser;
+use pest_derive::Parser;
+use std::collections::HashMap;
+use thiserror::Error;
+
+#[derive(Parser)]
+#[grammar = "uson.pest"]
+pub struct UsonParser;
+
+#[derive(Error, Debug)]
+pub enum ParseError {
+    #[error("Parse error: {0}")]
+    PestError(#[from] pest::error::Error<Rule>),
+    
+    #[error("Invalid number format: {0}")]
+    NumberError(String),
+    
+    #[error("Invalid escape sequence: {0}")]
+    EscapeError(String),
+}
+
+pub type ParseResult<T> = Result<T, ParseError>;
+
+pub fn parse(input: &str) -> ParseResult<Vec<Value>> {
+    let mut pairs = UsonParser::parse(Rule::uson_text, input)?;
+    let uson_text = pairs.next().unwrap();
+    
+    let mut values = Vec::new();
+    for pair in uson_text.into_inner() {
+        if pair.as_rule() == Rule::EOI {
+            break;
+        }
+        if pair.as_rule() == Rule::expr {
+            let value_pair = pair.into_inner().next().unwrap();
+            values.push(parse_value(value_pair)?);
+        }
+    }
+    
+    Ok(values)
+}
+
+fn parse_value(pair: Pair<Rule>) -> ParseResult<Value> {
+    match pair.as_rule() {
+        Rule::null_val => Ok(Value::Null),
+        Rule::true_val => Ok(Value::Bool(true)),
+        Rule::false_val => Ok(Value::Bool(false)),
+        Rule::number => parse_number(pair),
+        Rule::string => parse_string(pair),
+        Rule::array => parse_array(pair),
+        Rule::object => parse_object(pair),
+        Rule::assign => parse_assign(pair),
+        Rule::typed => parse_typed(pair),
+        Rule::value => {
+            let inner = pair.into_inner().next().unwrap();
+            parse_value(inner)
+        }
+        _ => unreachable!("Unexpected rule: {:?}", pair.as_rule()),
+    }
+}
+
+fn parse_number(pair: Pair<Rule>) -> ParseResult<Value> {
+    let num_str = pair.as_str();
+    
+    if num_str.contains('.') || num_str.contains('e') || num_str.contains('E') {
+        let f = num_str.parse::<f64>()
+            .map_err(|e| ParseError::NumberError(e.to_string()))?;
+        Ok(Value::Number(Number::Float(f)))
+    } else {
+        let i = num_str.parse::<i64>()
+            .map_err(|e| ParseError::NumberError(e.to_string()))?;
+        Ok(Value::Number(Number::Integer(i)))
+    }
+}
+
+fn parse_string(pair: Pair<Rule>) -> ParseResult<Value> {
+    let inner = pair.into_inner().next().unwrap();
+    let s = match inner.as_rule() {
+        Rule::double_quoted_string => {
+            let s = inner.as_str();
+            unescape_string(&s[1..s.len()-1])?
+        }
+        Rule::single_quoted_string => {
+            let s = inner.as_str();
+            unescape_string(&s[1..s.len()-1])?
+        }
+        Rule::unquoted_string => {
+            let s = inner.as_str();
+            // Check if it's a number
+            if s.chars().all(|c| c.is_ascii_digit() || c == '.') {
+                if s.contains('.') {
+                    if let Ok(f) = s.parse::<f64>() {
+                        return Ok(Value::Number(Number::Float(f)));
+                    }
+                } else if let Ok(i) = s.parse::<i64>() {
+                    return Ok(Value::Number(Number::Integer(i)));
+                }
+            }
+            s.to_string()
+        }
+        _ => unreachable!(),
+    };
+    
+    Ok(Value::String(s))
+}
+
+fn unescape_string(s: &str) -> ParseResult<String> {
+    let mut result = String::new();
+    let mut chars = s.chars();
+    
+    while let Some(ch) = chars.next() {
+        if ch == '\\' {
+            match chars.next() {
+                Some('n') => result.push('\n'),
+                Some('r') => result.push('\r'),
+                Some('t') => result.push('\t'),
+                Some('b') => result.push('\u{0008}'),
+                Some('f') => result.push('\u{000C}'),
+                Some('\\') => result.push('\\'),
+                Some('/') => result.push('/'),
+                Some('#') => result.push('#'),
+                Some('"') => result.push('"'),
+                Some('\'') => result.push('\''),
+                Some('u') => {
+                    let hex: String = chars.by_ref().take(4).collect();
+                    let code = u32::from_str_radix(&hex, 16)
+                        .map_err(|_| ParseError::EscapeError(format!("Invalid unicode escape: \\u{}", hex)))?;
+                    let ch = char::from_u32(code)
+                        .ok_or_else(|| ParseError::EscapeError(format!("Invalid unicode codepoint: {}", code)))?;
+                    result.push(ch);
+                }
+                Some(c) => result.push(c),
+                None => return Err(ParseError::EscapeError("Incomplete escape sequence".to_string())),
+            }
+        } else {
+            result.push(ch);
+        }
+    }
+    
+    Ok(result)
+}
+
+fn parse_array(pair: Pair<Rule>) -> ParseResult<Value> {
+    let mut values = Vec::new();
+    
+    for inner in pair.into_inner() {
+        if inner.as_rule() == Rule::value {
+            values.push(parse_value(inner)?);
+        }
+    }
+    
+    Ok(Value::Array(values))
+}
+
+fn parse_object(pair: Pair<Rule>) -> ParseResult<Value> {
+    let mut map = HashMap::new();
+    
+    for inner in pair.into_inner() {
+        if inner.as_rule() == Rule::member {
+            let mut member_parts = inner.into_inner();
+            let key_pair = member_parts.next().unwrap();
+            let key = if let Value::String(s) = parse_string(key_pair)? {
+                s
+            } else {
+                unreachable!()
+            };
+            let value_pair = member_parts.next().unwrap();
+            let value = parse_value(value_pair)?;
+            map.insert(key, value);
+        }
+    }
+    
+    Ok(Value::Object(map))
+}
+
+fn parse_assign(pair: Pair<Rule>) -> ParseResult<Value> {
+    let mut inner = pair.into_inner();
+    let key_pair = inner.next().unwrap();
+    let key = if let Value::String(s) = parse_string(key_pair)? {
+        s
+    } else {
+        unreachable!()
+    };
+    let value_pair = inner.next().unwrap();
+    let value = parse_value(value_pair)?;
+    
+    let mut map = HashMap::new();
+    map.insert(key, value);
+    Ok(Value::Object(map))
+}
+
+fn parse_typed(pair: Pair<Rule>) -> ParseResult<Value> {
+    let mut inner = pair.into_inner();
+    let type_name = inner.next().unwrap().as_str().to_string();
+    let value_pair = inner.next().unwrap();
+    let value = parse_value(value_pair)?;
+    
+    Ok(Value::Typed {
+        type_name,
+        value: Box::new(value),
+    })
+}
+
+pub fn apply_builtin_types(value: Value) -> Value {
+    match value {
+        Value::Typed { type_name, value } => {
+            let inner = apply_builtin_types(*value);
+            match type_name.as_str() {
+                "str" => match &inner {
+                    Value::String(s) => Value::String(s.clone()),
+                    Value::Number(Number::Integer(i)) => Value::String(i.to_string()),
+                    Value::Number(Number::Float(f)) => Value::String(f.to_string()),
+                    Value::Bool(b) => Value::String(b.to_string()),
+                    Value::Null => Value::String("null".to_string()),
+                    Value::Array(arr) => {
+                        let strs: Vec<String> = arr.iter().map(|v| match v {
+                            Value::String(s) => s.clone(),
+                            Value::Number(Number::Integer(i)) => i.to_string(),
+                            Value::Number(Number::Float(f)) => f.to_string(),
+                            _ => "".to_string(),
+                        }).collect();
+                        Value::String(strs.join(","))
+                    }
+                    _ => inner,
+                },
+                "int" => match &inner {
+                    Value::String(s) => s.parse::<i64>()
+                        .map(|i| Value::Number(Number::Integer(i)))
+                        .unwrap_or(inner),
+                    Value::Number(_) => inner,
+                    _ => inner,
+                },
+                "float" => match &inner {
+                    Value::String(s) => s.parse::<f64>()
+                        .map(|f| Value::Number(Number::Float(f)))
+                        .unwrap_or(inner),
+                    Value::Number(Number::Integer(i)) => Value::Number(Number::Float(*i as f64)),
+                    Value::Number(_) => inner,
+                    _ => inner,
+                },
+                "bool" => match &inner {
+                    Value::String(s) => match s.as_str() {
+                        "true" => Value::Bool(true),
+                        "false" => Value::Bool(false),
+                        _ => inner,
+                    },
+                    Value::Bool(_) => inner,
+                    _ => inner,
+                },
+                "null" => Value::Null,
+                "arr" => match &inner {
+                    Value::String(s) => {
+                        let parts: Vec<Value> = s.split(',')
+                            .filter_map(|p| p.trim().parse::<i64>().ok())
+                            .map(|i| Value::Number(Number::Integer(i)))
+                            .collect();
+                        Value::Array(parts)
+                    }
+                    Value::Array(_) => inner,
+                    _ => inner,
+                },
+                "obj" => match &inner {
+                    Value::String(s) => {
+                        // Try to parse as JSON
+                        if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(s) {
+                            json_to_value(parsed)
+                        } else {
+                            inner
+                        }
+                    }
+                    _ => inner,
+                },
+                _ => inner, // Unknown type, return value as-is
+            }
+        }
+        Value::Array(arr) => Value::Array(arr.into_iter().map(apply_builtin_types).collect()),
+        Value::Object(obj) => Value::Object(
+            obj.into_iter()
+                .map(|(k, v)| (k, apply_builtin_types(v)))
+                .collect()
+        ),
+        other => other,
+    }
+}
+
+fn json_to_value(json: serde_json::Value) -> Value {
+    match json {
+        serde_json::Value::Null => Value::Null,
+        serde_json::Value::Bool(b) => Value::Bool(b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Value::Number(Number::Integer(i))
+            } else if let Some(f) = n.as_f64() {
+                Value::Number(Number::Float(f))
+            } else {
+                Value::Null
+            }
+        }
+        serde_json::Value::String(s) => Value::String(s),
+        serde_json::Value::Array(arr) => {
+            Value::Array(arr.into_iter().map(json_to_value).collect())
+        }
+        serde_json::Value::Object(obj) => {
+            Value::Object(obj.into_iter().map(|(k, v)| (k, json_to_value(v))).collect())
+        }
+    }
+}
+

src/uson.pest

···
+WHITESPACE = _{ " " | "\t" | "\n" | "\r" }
+COMMENT = _{ "#" ~ (!("\n" | "\r") ~ ANY)* }
+
+uson_text = { SOI ~ expr* ~ EOI }
+
+expr = { value }
+
+// Values
+value = {
+    typed
+    | false_val
+    | null_val
+    | true_val
+    | assign
+    | object
+    | array
+    | number
+    | string
+}
+
+false_val = { "false" }
+null_val = { "null" }
+true_val = { "true" }
+
+// Objects - support optional commas like arrays
+object = {
+    "{" ~ (member ~ (","? ~ member)* ~ ","?)? ~ "}"
+}
+
+member = { string ~ ":" ~ value }
+
+// Arrays
+array = {
+    "[" ~ (value ~ (","? ~ value)* ~ ","?)? ~ "]"
+}
+
+// Numbers - must not be followed by alphanumeric to avoid matching "1ab" as number
+number = @{
+    "-"? ~ int ~ ("." ~ ASCII_DIGIT+)? ~ (^"e" ~ ("+" | "-")? ~ ASCII_DIGIT+)? ~ !ASCII_ALPHANUMERIC
+}
+
+int = { "0" | (ASCII_NONZERO_DIGIT ~ ASCII_DIGIT*) }
+
+// Strings
+string = {
+    double_quoted_string
+    | single_quoted_string
+    | unquoted_string
+}
+
+double_quoted_string = @{
+    "\"" ~ (escape_sequence | (!("\"" | "\\") ~ ANY))* ~ "\""
+}
+
+single_quoted_string = @{
+    "'" ~ (escape_sequence | (!("'" | "\\") ~ ANY))* ~ "'"
+}
+
+unquoted_string = @{
+    simple_char+
+}
+
+simple_char = {
+    !("\"" | "#" | "," | ":" | "[" | "\\" | "]" | "{" | "}" | WHITESPACE) ~ ANY
+}
+
+escape_sequence = @{
+    "\\" ~ (
+        "\"" | "'" | "\\" | "/" | "#"
+        | "b" | "f" | "n" | "r" | "t"
+        | ("u" ~ ASCII_HEX_DIGIT{4})
+    )
+}
+
+// Assignments
+assign = { string ~ ":" ~ value }
+
+// Typed literals
+typed = { type_name ~ "!" ~ value }
+type_name = @{ (ASCII_ALPHA | ASCII_DIGIT | "_" | "-")+ }

tests/compliance.rs

···
+use uson::{parse, apply_builtin_types, Value, Number};
+use serde_json;
+
+fn parse_and_apply_types(input: &str) -> Vec<Value> {
+    let values = parse(input).expect("Parse should succeed");
+    values.into_iter().map(apply_builtin_types).collect()
+}
+
+fn to_array_mode(values: &[Value]) -> serde_json::Value {
+    serde_json::to_value(values).unwrap()
+}
+
+fn to_object_mode(values: &[Value]) -> serde_json::Value {
+    let mut result = serde_json::Map::new();
+    let mut non_object_index = 0;
+    
+    for value in values.iter() {
+        match value {
+            Value::Object(obj) => {
+                for (key, val) in obj {
+                    result.insert(key.clone(), serde_json::to_value(val).unwrap());
+                }
+            }
+            _ => {
+                result.insert(non_object_index.to_string(), serde_json::to_value(value).unwrap());
+                non_object_index += 1;
+            }
+        }
+    }
+    
+    serde_json::Value::Object(result)
+}
+
+// BASIC TESTS
+
+#[test]
+fn test_empty_input() {
+    let values = parse_and_apply_types("");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_empty_whitespace() {
+    let values = parse_and_apply_types("   ");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_empty_newlines() {
+    let values = parse_and_apply_types("\n          ");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_simple_values() {
+    let values = parse_and_apply_types("a b c");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["a", "b", "c"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "a", "1": "b", "2": "c"}));
+}
+
+#[test]
+fn test_nested_array_single() {
+    let values = parse_and_apply_types("[a]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([["a"]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a"]}));
+}
+
+#[test]
+fn test_nested_array_multiple() {
+    let values = parse_and_apply_types("[a b c]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([["a", "b", "c"]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a", "b", "c"]}));
+}
+
+#[test]
+fn test_nested_array_deep() {
+    let values = parse_and_apply_types("[a [[b]] c]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([["a", [["b"]], "c"]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a", [["b"]], "c"]}));
+}
+
+#[test]
+fn test_simple_objects() {
+    let values = parse_and_apply_types("a:1 b:2 c:3");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}, {"b": 2}, {"c": 3}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": 2, "c": 3}));
+}
+
+#[test]
+fn test_simple_objects_in_array() {
+    let values = parse_and_apply_types("[a:1 b:2 c:3]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([[{"a": 1}, {"b": 2}, {"c": 3}]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [{"a": 1}, {"b": 2}, {"c": 3}]}));
+}
+
+#[test]
+fn test_type_str() {
+    let values = parse_and_apply_types("str!42");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["42"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "42"}));
+}
+
+#[test]
+fn test_type_nested() {
+    let values = parse_and_apply_types("int!str!42");
+    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
+}
+
+#[test]
+fn test_type_triple_nested() {
+    let values = parse_and_apply_types("str!int!str!42");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["42"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "42"}));
+}
+
+#[test]
+fn test_type_in_object() {
+    let values = parse_and_apply_types("x:{test:str!42 multi:bool!str!true}");
+    assert_eq!(
+        to_array_mode(&values),
+        serde_json::json!([{"x": {"test": "42", "multi": true}}])
+    );
+    assert_eq!(
+        to_object_mode(&values),
+        serde_json::json!({"x": {"test": "42", "multi": true}})
+    );
+}
+
+#[test]
+fn test_type_str_array() {
+    let values = parse_and_apply_types("str![1 2 3]");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["1,2,3"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "1,2,3"}));
+}
+
+#[test]
+fn test_type_nonexistent() {
+    let values = parse_and_apply_types("nonexists!42");
+    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
+}
+
+#[test]
+fn test_type_custom_name() {
+    let values = parse_and_apply_types("A_b3-!42");
+    assert_eq!(to_array_mode(&values), serde_json::json!([42]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42}));
+}
+
+#[test]
+fn test_advanced_example() {
+    let values = parse_and_apply_types(
+        r#"number:12.05 text:Banana quotedText:"John Devilseed" empty:null good:true"#
+    );
+    assert_eq!(
+        to_array_mode(&values),
+        serde_json::json!([
+            {"number": 12.05},
+            {"text": "Banana"},
+            {"quotedText": "John Devilseed"},
+            {"empty": null},
+            {"good": true}
+        ])
+    );
+    assert_eq!(
+        to_object_mode(&values),
+        serde_json::json!({
+            "number": 12.05,
+            "text": "Banana",
+            "quotedText": "John Devilseed",
+            "empty": null,
+            "good": true
+        })
+    );
+}
+
+// TYPE TESTS
+
+#[test]
+fn test_number_integer() {
+    let values = parse_and_apply_types("1");
+    assert_eq!(to_array_mode(&values), serde_json::json!([1]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 1}));
+}
+
+#[test]
+fn test_number_float() {
+    let values = parse_and_apply_types("42.42");
+    assert_eq!(to_array_mode(&values), serde_json::json!([42.42]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42.42}));
+}
+
+#[test]
+fn test_number_negative() {
+    let values = parse_and_apply_types("-50.43");
+    assert_eq!(to_array_mode(&values), serde_json::json!([-50.43]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": -50.43}));
+}
+
+#[test]
+fn test_number_large() {
+    let values = parse_and_apply_types("1000000.0001");
+    assert_eq!(to_array_mode(&values), serde_json::json!([1000000.0001]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 1000000.0001}));
+}
+
+#[test]
+fn test_number_scientific() {
+    let values = parse_and_apply_types("10e5");
+    assert_eq!(to_array_mode(&values), serde_json::json!([10e5]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 10e5}));
+}
+
+#[test]
+fn test_float_type_cast() {
+    let values = parse_and_apply_types(r#"float!"42.42""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([42.42]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42.42}));
+}
+
+#[test]
+fn test_string_simple() {
+    let values = parse_and_apply_types("abc");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
+}
+
+#[test]
+fn test_string_starts_with_digit() {
+    let values = parse_and_apply_types("1ab");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["1ab"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "1ab"}));
+}
+
+#[test]
+fn test_string_multiple() {
+    let values = parse_and_apply_types("abc def");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc", "def"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc", "1": "def"}));
+}
+
+#[test]
+fn test_string_double_quoted() {
+    let values = parse_and_apply_types(r#""abc""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
+}
+
+#[test]
+fn test_string_double_quoted_with_space() {
+    let values = parse_and_apply_types(r#""abc def""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc def"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc def"}));
+}
+
+#[test]
+fn test_string_double_quoted_escaped() {
+    let values = parse_and_apply_types(r#""abc \"ok def""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([r#"abc "ok def"#]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": r#"abc "ok def"#}));
+}
+
+#[test]
+fn test_string_single_quoted() {
+    let values = parse_and_apply_types("'abc'");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc"}));
+}
+
+#[test]
+fn test_string_single_quoted_with_space() {
+    let values = parse_and_apply_types("'abc def'");
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc def"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc def"}));
+}
+
+#[test]
+fn test_string_single_quoted_escaped() {
+    let values = parse_and_apply_types(r#"'abc \'42 def'"#);
+    assert_eq!(to_array_mode(&values), serde_json::json!(["abc '42 def"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": "abc '42 def"}));
+}
+
+#[test]
+fn test_null_value() {
+    let values = parse_and_apply_types("null");
+    assert_eq!(to_array_mode(&values), serde_json::json!([null]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": null}));
+}
+
+#[test]
+fn test_null_typed() {
+    let values = parse_and_apply_types("x:null!xx");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": null}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"x": null}));
+}
+
+#[test]
+fn test_true_value() {
+    let values = parse_and_apply_types("true");
+    assert_eq!(to_array_mode(&values), serde_json::json!([true]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": true}));
+}
+
+#[test]
+fn test_bool_true_typed() {
+    let values = parse_and_apply_types(r#"bool!"true""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([true]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": true}));
+}
+
+#[test]
+fn test_false_value() {
+    let values = parse_and_apply_types("false");
+    assert_eq!(to_array_mode(&values), serde_json::json!([false]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": false}));
+}
+
+#[test]
+fn test_bool_false_typed() {
+    let values = parse_and_apply_types(r#"bool!"false""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([false]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": false}));
+}
+
+#[test]
+fn test_array_single() {
+    let values = parse_and_apply_types("[a]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([["a"]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": ["a"]}));
+}
+
+#[test]
+fn test_array_numbers_no_comma() {
+    let values = parse_and_apply_types("[1 2 3]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
+}
+
+#[test]
+fn test_array_numbers_with_commas() {
+    let values = parse_and_apply_types("[1, 2, 3]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
+}
+
+#[test]
+fn test_array_numbers_mixed_commas() {
+    let values = parse_and_apply_types("[1 2,3 ]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
+}
+
+#[test]
+fn test_array_typed() {
+    let values = parse_and_apply_types(r#"arr!"1,2,3""#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([[1, 2, 3]]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": [1, 2, 3]}));
+}
+
+#[test]
+fn test_object_single() {
+    let values = parse_and_apply_types("{a:1}");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_object_multiple_no_comma() {
+    let values = parse_and_apply_types("{a:1 b:two c:3}");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1, "b": "two", "c": 3}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": "two", "c": 3}));
+}
+
+#[test]
+fn test_object_multiple_with_commas() {
+    let values = parse_and_apply_types("{a:1,b:two,c:3}");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1, "b": "two", "c": 3}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": "two", "c": 3}));
+}
+
+#[test]
+fn test_object_typed() {
+    let values = parse_and_apply_types(r#"obj!'"a":1'"#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_object_nested() {
+    let values = parse_and_apply_types("x:{a:1 b:coffee}");
+    assert_eq!(
+        to_array_mode(&values),
+        serde_json::json!([{"x": {"a": 1, "b": "coffee"}}])
+    );
+    assert_eq!(
+        to_object_mode(&values),
+        serde_json::json!({"x": {"a": 1, "b": "coffee"}})
+    );
+}
+
+#[test]
+fn test_assign_simple() {
+    let values = parse_and_apply_types("a:1");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_assign_multiple() {
+    let values = parse_and_apply_types("a:1 b:2 c:3");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}, {"b": 2}, {"c": 3}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1, "b": 2, "c": 3}));
+}
+
+#[test]
+fn test_assign_single_quoted_key() {
+    let values = parse_and_apply_types("'a':1");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_assign_double_quoted_key() {
+    let values = parse_and_apply_types(r#""a":1"#);
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_assign_special_chars() {
+    let values = parse_and_apply_types("~@$%^&*()-:1");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"~@$%^&*()-": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"~@$%^&*()-": 1}));
+}
+
+#[test]
+fn test_comment_empty() {
+    let values = parse_and_apply_types("#");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_comment_escaped_hash() {
+    let values = parse_and_apply_types(r"a:\#");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": "#"}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": "#"}));
+}
+
+#[test]
+fn test_comment_in_quotes() {
+    let values = parse_and_apply_types(r"a:'\#1'");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": "#1"}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": "#1"}));
+}
+
+#[test]
+fn test_comment_after_value() {
+    let values = parse_and_apply_types("a:1 # a");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"a": 1}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"a": 1}));
+}
+
+#[test]
+fn test_comment_with_spaces() {
+    let values = parse_and_apply_types("  # a");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_comment_line_start() {
+    let values = parse_and_apply_types("#a");
+    assert_eq!(to_array_mode(&values), serde_json::json!([]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({}));
+}
+
+#[test]
+fn test_comment_in_array() {
+    let values = parse_and_apply_types("x: [a # b c]\n# good\n tone ]");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": ["a", "tone"]}]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"x": ["a", "tone"]}));
+}
+
+#[test]
+fn test_comment_complex() {
+    let values = parse_and_apply_types("{x: [#y ]\n] #n\n} 42 #^\n@");
+    assert_eq!(to_array_mode(&values), serde_json::json!([{"x": []}, 42, "@"]));
+    assert_eq!(to_object_mode(&values), serde_json::json!({"0": 42, "1": "@", "x": []}));
+}