(define-module (sigils packages crates-io)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix utils)
  #:use-module (guix gexp)
  #:use-module ((guix licenses)
                #:prefix license:)
  #:use-module (guix build-system cargo)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages crates-io)
  #:use-module (gnu packages crates-windows)
  #:use-module (gnu packages crates-web)
  #:use-module (gnu packages crates-apple)
  #:use-module (gnu packages crates-graphics)
  #:use-module (gnu packages crates-tls)
  #:use-module (gnu packages crates-crypto)
  #:use-module (gnu packages crates-gtk)
  #:use-module (gnu packages pkg-config))


;;; INTENTRACE

(define-public rust-uzers-0.12
  (package
    (name "rust-uzers")
    (version "0.12.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "uzers" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1pcpi9v90nr3q2y3i4pkac9c20r1nzaimvcm7vajmn770ksizy2d"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-libc" ,rust-libc-0.2)
                       ("rust-log" ,rust-log-0.4))))
    (home-page "https://github.com/rustadopt/uzers-rs")
    (synopsis
     "Continuation of users, a library for accessing Unix users and groups")
    (description
     "This package provides Continuation of users, a library for accessing Unix users and groups.")
    (license license:expat)))

(define-public rust-tabled-derive-0.8
  (package
    (name "rust-tabled-derive")
    (version "0.8.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "tabled_derive" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0sbh8x67frl69j8ns0z3jyp67ywkfivncjp2ak0qd5vhvjzvh3xz"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-heck" ,rust-heck-0.4)
                       ("rust-proc-macro-error" ,rust-proc-macro-error-1)
                       ("rust-proc-macro2" ,rust-proc-macro2-1)
                       ("rust-quote" ,rust-quote-1)
                       ("rust-syn" ,rust-syn-1))))
    (home-page "https://github.com/zhiburt/tabled")
    (synopsis "Derive macros which is used by tabled crate")
    (description
     "This package provides Derive macros which is used by tabled crate.")
    (license license:expat)))

(define-public rust-papergrid-0.12
  (package
    (name "rust-papergrid")
    (version "0.12.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "papergrid" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "09b7x34znfnm7lyzk8vajbazpw9xzsh8a4716c6vdsbx5barlhf7"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-ansi-str" ,rust-ansi-str-0.8)
                       ("rust-ansitok" ,rust-ansitok-0.2)
                       ("rust-bytecount" ,rust-bytecount-0.6)
                       ("rust-fnv" ,rust-fnv-1)
                       ("rust-unicode-width" ,rust-unicode-width-0.1))))
    (home-page "https://github.com/zhiburt/tabled")
    (synopsis "Papergrid is a core library to print a table")
    (description
     "This package provides Papergrid is a core library to print a table.")
    (license license:expat)))

(define-public rust-tabled-0.16
  (package
    (name "rust-tabled")
    (version "0.16.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "tabled" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "06ybawqbcf1qk4laxff9cwxa26viwfda4bh14bvyv6qbwqz31jbp"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-ansi-str" ,rust-ansi-str-0.8)
                       ("rust-ansitok" ,rust-ansitok-0.2)
                       ("rust-papergrid" ,rust-papergrid-0.12)
                       ("rust-tabled-derive" ,rust-tabled-derive-0.8))))
    (home-page "https://github.com/zhiburt/tabled")
    (synopsis
     "An easy to use library for pretty print tables of Rust `struct`s and `enum`s")
    (description
     "This package provides An easy to use library for pretty print tables of Rust `struct`s and `enum`s.")
    (license license:expat)))

(define-public rust-syscalls-0.6
  (package
    (name "rust-syscalls")
    (version "0.6.18")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "syscalls" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1gkwzlb2432jrixwfkkpxv0a017qgqbpsvby7jjpcffpqxfy7l23"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-serde" ,rust-serde-1)
                       ("rust-serde-repr" ,rust-serde-repr-0.1))))
    (home-page "https://github.com/jasonwhite/syscalls")
    (synopsis "list of Linux system calls.")
    (description "This package provides a list of Linux system calls.")
    (license license:bsd-2)))

(define-public rust-linux-raw-sys-0.4
  (package
    (name "rust-linux-raw-sys")
    (version "0.4.14")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "linux-raw-sys" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "12gsjgbhhjwywpqcrizv80vrp7p7grsz5laqq773i33wphjsxcvq"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-compiler-builtins" ,rust-compiler-builtins-0.1)
                       ("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1))))
    (home-page "https://github.com/sunfishcode/linux-raw-sys")
    (synopsis "Generated bindings for Linux's userspace API")
    (description
     "This package provides Generated bindings for Linux's userspace API.")
    (license (list license:asl2.0 license:asl2.0
                   license:expat))))

(define-public rust-rustix-0.38
  (package
    (name "rust-rustix")
    (version "0.38.39")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rustix" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1vplx9gqyalc963z2czmaz9gzzcxm6k4w5g2mxlxb7mywaz1cl9p"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-bitflags" ,rust-bitflags-2)
                       ("rust-compiler-builtins" ,rust-compiler-builtins-0.1)
                       ("rust-errno" ,rust-errno-0.3)
                       ("rust-itoa" ,rust-itoa-1)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-linux-raw-sys" ,rust-linux-raw-sys-0.4)
                       ("rust-once-cell" ,rust-once-cell-1)
                       ("rust-rustc-std-workspace-alloc" ,rust-rustc-std-workspace-alloc-1)
                       ("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1)
                       ("rust-windows-sys" ,rust-windows-sys-0.52))))
    (home-page "https://github.com/bytecodealliance/rustix")
    (synopsis "Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls")
    (description
     "This package provides Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls.")
    (license (list license:asl2.0
                   license:expat))))

(define-public rust-pete-0.12
  (package
    (name "rust-pete")
    (version "0.12.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "pete" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1gbc13vp3zqsyzchxg5njcrgyky67n5fhgv4z17jkps0mp0w228g"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-libc" ,rust-libc-0.2)
                       ("rust-memoffset" ,rust-memoffset-0.8)
                       ("rust-nix" ,rust-nix-0.26)
                       ("rust-thiserror" ,rust-thiserror-1))))
    (home-page "https://github.com/ranweiler/pete")
    (synopsis "friendly wrapper around ptrace(2)")
    (description "This package provides a friendly wrapper around ptrace(2).")
    (license license:isc)))

(define-public rust-libc-0.2
  (package
    (name "rust-libc")
    (version "0.2.162")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1633a00yyx45kzx9r54fndvr8njsjqyr7zl12mzgsmgyczg8glhq"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1))))
    (home-page "https://github.com/rust-lang/libc")
    (synopsis "Raw FFI bindings to platform libraries like libc.")
    (description
     "This package provides Raw FFI bindings to platform libraries like libc.")
    (license (list license:expat license:asl2.0))))

(define-public rust-cfg-aliases-0.2
  (package
    (name "rust-cfg-aliases")
    (version "0.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "cfg_aliases" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "092pxdc1dbgjb6qvh83gk56rkic2n2ybm4yvy76cgynmzi3zwfk1"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t))
    (home-page "https://github.com/katharostech/cfg_aliases")
    (synopsis
     "tiny utility to help save you a lot of effort with long winded `#[cfg()]` checks.")
    (description
     "This package provides a tiny utility to help save you a lot of effort with long
winded `#[cfg()]` checks.")
    (license license:expat)))

(define-public rust-nix-0.29
  (package
    (name "rust-nix")
    (version "0.29.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "nix" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0ikvn7s9r2lrfdm3mx1h7nbfjvcc6s9vxdzw7j5xfkd2qdnp9qki"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-bitflags" ,rust-bitflags-2)
                       ("rust-cfg-if" ,rust-cfg-if-1)
                       ("rust-cfg-aliases" ,rust-cfg-aliases-0.2)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-memoffset" ,rust-memoffset-0.9)
                       ("rust-pin-utils" ,rust-pin-utils-0.1))))
    (home-page "https://github.com/nix-rust/nix")
    (synopsis "Rust friendly bindings to *nix APIs")
    (description "This package provides Rust friendly bindings to *nix APIs.")
    (license license:expat)))

(define-public rust-lazy-static-1
  (package
    (name "rust-lazy-static")
    (version "1.5.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lazy_static" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1zk6dqqni0193xg6iijh7i3i44sryglwgvx20spdvwk3r6sbrlmv"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-spin" ,rust-spin-0.9))))
    (home-page "https://github.com/rust-lang-nursery/lazy-static.rs")
    (synopsis "macro for declaring lazily evaluated statics in Rust.")
    (description
     "This package provides a macro for declaring lazily evaluated statics in Rust.")
    (license (list license:expat license:asl2.0))))

(define-public rust-exec-0.3
  (package
    (name "rust-exec")
    (version "0.3.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "exec" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0596cw844vw1aw5saawg13av25mywhfqx195q2zp325sihr70sw8"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-errno" ,rust-errno-0.2)
                       ("rust-libc" ,rust-libc-0.2))))
    (home-page "https://github.com/faradayio/exec-rs")
    (synopsis
     "Use the POSIX exec function to replace the running program with another")
    (description
     "This package provides Use the POSIX exec function to replace the running program with another.")
    (license (list license:expat license:asl2.0))))

(define-public rust-errno-0.3
  (package
    (name "rust-errno")
    (version "0.3.9")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "errno" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1fi0m0493maq1jygcf1bya9cymz2pc1mqxj26bdv7yjd37v5qk2k"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-libc" ,rust-libc-0.2)
                       ("rust-windows-sys" ,rust-windows-sys-0.52))))
    (home-page "https://github.com/lambda-fairy/rust-errno")
    (synopsis "Cross-platform interface to the `errno` variable")
    (description
     "This package provides Cross-platform interface to the `errno` variable.")
    (license (list license:expat license:asl2.0))))

(define-public rust-uapi-proc-0.0.5
  (package
    (name "rust-uapi-proc")
    (version "0.0.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "uapi-proc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0nlpc278yxbkxx2r7sa3hg364w6g6lf9yzwginpb59yfh3wldpjl"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-lazy-static" ,rust-lazy-static-1)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-proc-macro2" ,rust-proc-macro2-1)
                       ("rust-quote" ,rust-quote-1)
                       ("rust-regex" ,rust-regex-1)
                       ("rust-syn" ,rust-syn-1))))
    (home-page "https://github.com/mahkoh/uapi")
    (synopsis "Internal macros for the uapi crate. DO NOT USE!")
    (description
     "This package provides Internal macros for the uapi crate.  DO NOT USE!")
    (license (list license:expat license:asl2.0))))

(define-public rust-uapi-0.2
  (package
    (name "rust-uapi")
    (version "0.2.13")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "uapi" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1rk1cl9y624phvgjl59zqnd8vqyfxi9fgd18zrdlh5hv1n277w1v"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-cc" ,rust-cc-1)
                       ("rust-cfg-if" ,rust-cfg-if-1)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-uapi-proc" ,rust-uapi-proc-0.0.5))))
    (home-page "https://github.com/mahkoh/uapi")
    (synopsis "Wrappers for OS APIs on UNIX-like platform")
    (description
     "This package provides Wrappers for OS APIs on UNIX-like platform.")
    (license (list license:expat license:asl2.0))))

(define-public rust-clone3-0.2
  (package
    (name "rust-clone3")
    (version "0.2.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "clone3" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "03znv6afh9lb7r5j9kh8kfk40f4mydw3hrh9ra8h501hx9hy1r2y"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-bitflags" ,rust-bitflags-1)
                       ("rust-uapi" ,rust-uapi-0.2))))
    (home-page "https://github.com/e00E/clone3")
    (synopsis "Rust bindings to the clone3 linux system call")
    (description
     "This package provides Rust bindings to the clone3 linux system call.")
    (license license:expat)))

(define-public rust-intentrace-0.2
  (package
    (name "rust-intentrace")
    (version "0.2.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "intentrace" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "183zg89wfmyz9y7qx0i6n74iv9ikjj01hh6bzd0rwn387z2pfm6q"))))
    (build-system cargo-build-system)
    (arguments
     `(#:cargo-inputs (("rust-clone3" ,rust-clone3-0.2)
                       ("rust-colored" ,rust-colored-2)
                       ("rust-errno" ,rust-errno-0.3)
                       ("rust-exec" ,rust-exec-0.3)
                       ("rust-lazy-static" ,rust-lazy-static-1)
                       ("rust-nix" ,rust-nix-0.29)
                       ("rust-num-cpus" ,rust-num-cpus-1)
                       ("rust-page-size" ,rust-page-size-0.6)
                       ("rust-pete" ,rust-pete-0.12)
                       ("rust-phf" ,rust-phf-0.11)
                       ("rust-procfs" ,rust-procfs-0.16)
                       ("rust-rustix" ,rust-rustix-0.38)
                       ("rust-syscalls" ,rust-syscalls-0.6)
                       ("rust-tabled" ,rust-tabled-0.16)
                       ("rust-uzers" ,rust-uzers-0.12))))
    (home-page "https://github.com/sectordistrict/intentrace")
    (synopsis
     "intentrace is strace with intent, it goes all the way for you instead of half the way")
    (description
     "This package provides intentrace is strace with intent, it goes all the way for you instead of half
the way.")
    (license license:expat)))

;; WASM-PACK

(define-public rust-which-4
  (package
    (name "rust-which")
    (version "4.4.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "which" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1ixzmx3svsv5hbdvd8vdhd3qwvf6ns8jdpif1wmwsy10k90j9fl7"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-either" ,rust-either-1)
                       ("rust-home" ,rust-home-0.5)
                       ("rust-once-cell" ,rust-once-cell-1)
                       ("rust-regex" ,rust-regex-1)
                       ("rust-rustix" ,rust-rustix-0.38))))
    (home-page "https://github.com/harryfei/which-rs.git")
    (synopsis
     "Rust equivalent of Unix command \"which\". Locate installed executable in cross platforms.")
    (description
     "This package provides a Rust equivalent of Unix command \"which\".  Locate
installed executable in cross platforms.")
    (license license:expat)))

(define-public rust-human-panic-1
  (package
    (name "rust-human-panic")
    (version "1.2.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "human-panic" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0w7kbj2y3rrnax2bj4s3aashsm5lrg55wh58a44v7fr0k741dw64"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-anstream" ,rust-anstream-0.6)
                       ("rust-anstyle" ,rust-anstyle-1)
                       ("rust-backtrace" ,rust-backtrace-0.3)
                       ("rust-os-info" ,rust-os-info-3)
                       ("rust-serde" ,rust-serde-1)
                       ("rust-serde-derive" ,rust-serde-derive-1)
                       ("rust-toml" ,rust-toml-0.8)
                       ("rust-uuid" ,rust-uuid-1))))
    (home-page "https://github.com/rust-cli/human-panic")
    (synopsis "Panic messages for humans")
    (description "This package provides Panic messages for humans.")
    (license (list license:expat license:asl2.0))))

(define-public rust-zstd-safe-7
  (package
    (name "rust-zstd-safe")
    (version "7.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zstd-safe" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0nch85m5cr493y26yvndm6a8j6sd9mxpr2awrim3dslcnr6sp8sl"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-zstd-sys" ,rust-zstd-sys-2))))
    (home-page "https://github.com/gyscos/zstd-rs")
    (synopsis "Safe low-level bindings for the zstd compression library")
    (description
     "This package provides Safe low-level bindings for the zstd compression library.")
    (license (list license:expat license:asl2.0))))

(define-public rust-zstd-0.13
  (package
    (name "rust-zstd")
    (version "0.13.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zstd" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1ygkr6wspm9clbp7ykyl0rv69cfsf9q4lic9wcqiwn34lrwbgwpw"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-zstd-safe" ,rust-zstd-safe-7))))
    (home-page "https://github.com/gyscos/zstd-rs")
    (synopsis "Binding for the zstd compression library")
    (description
     "This package provides Binding for the zstd compression library.")
    (license license:expat)))

(define-public rust-lockfree-object-pool-0.1
  (package
    (name "rust-lockfree-object-pool")
    (version "0.1.6")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lockfree-object-pool" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0bjm2g1g1avab86r02jb65iyd7hdi35khn1y81z4nba0511fyx4k"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t))
    (home-page "https://github.com/EVaillant/lockfree-object-pool")
    (synopsis
     "thread-safe object pool collection with automatic return and attach/detach semantics.")
    (description
     "This package provides a thread-safe object pool collection with automatic return
and attach/detach semantics.")
    (license license:boost1.0)))

(define-public rust-bumpalo-3
  (package
    (name "rust-bumpalo")
    (version "3.16.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "bumpalo" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0b015qb4knwanbdlp1x48pkb4pm57b8gidbhhhxr900q2wb6fabr"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-allocator-api2" ,rust-allocator-api2-0.2)
                       ("rust-serde" ,rust-serde-1))))
    (home-page "https://github.com/fitzgen/bumpalo")
    (synopsis "fast bump allocation arena for Rust.")
    (description
     "This package provides a fast bump allocation arena for Rust.")
    (license (list license:expat license:asl2.0))))

(define-public rust-zopfli-0.8
  (package
    (name "rust-zopfli")
    (version "0.8.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zopfli" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0ip9azz9ldk19m0m1hdppz3n5zcz0cywbg1vx59g4p5c3cwry0g5"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-bumpalo" ,rust-bumpalo-3)
                       ("rust-crc32fast" ,rust-crc32fast-1)
                       ("rust-lockfree-object-pool" ,rust-lockfree-object-pool-0.1)
                       ("rust-log" ,rust-log-0.4)
                       ("rust-once-cell" ,rust-once-cell-1)
                       ("rust-simd-adler32" ,rust-simd-adler32-0.3))))
    (home-page "https://github.com/zopfli-rs/zopfli")
    (synopsis "Rust implementation of the Zopfli compression algorithm.")
    (description
     "This package provides a Rust implementation of the Zopfli compression algorithm.")
    (license license:asl2.0)))

(define-public rust-zeroize-1
  (package
    (name "rust-zeroize")
    (version "1.8.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zeroize" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1pjdrmjwmszpxfd7r860jx54cyk94qk59x13sc307cvr5256glyf"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-serde" ,rust-serde-1)
                       ("rust-zeroize-derive" ,rust-zeroize-derive-1))))
    (home-page "https://github.com/RustCrypto/utils/tree/master/zeroize")
    (synopsis "Securely clear secrets from memory with a simple trait built on
stable Rust primitives which guarantee memory is zeroed using an
operation will not be 'optimized away' by the compiler.
Uses a portable pure Rust implementation that works everywhere,
even WASM!")
    (description
     "This package provides Securely clear secrets from memory with a simple trait built on stable Rust
primitives which guarantee memory is zeroed using an operation will not be
optimized away by the compiler.  Uses a portable pure Rust implementation that
works everywhere, even WASM!")
    (license (list license:asl2.0 license:expat))))

(define-public rust-time-macros-0.2
  (package
    (name "rust-time-macros")
    (version "0.2.18")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "time-macros" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1kqwxvfh2jkpg38fy673d6danh1bhcmmbsmffww3mphgail2l99z"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-num-conv" ,rust-num-conv-0.1)
                       ("rust-time-core" ,rust-time-core-0.1))))
    (home-page "https://github.com/time-rs/time")
    (synopsis
     "Procedural macros for the time crate.
    This crate is an implementation detail and should not be relied upon directly.")
    (description
     "This package provides Procedural macros for the time crate.  This crate is an implementation detail
and should not be relied upon directly.")
    (license (list license:expat license:asl2.0))))

(define-public rust-time-0.3
  (package
    (name "rust-time")
    (version "0.3.36")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "time" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "11g8hdpahgrf1wwl2rpsg5nxq3aj7ri6xr672v4qcij6cgjqizax"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-deranged" ,rust-deranged-0.3)
                       ("rust-itoa" ,rust-itoa-1)
                       ("rust-js-sys" ,rust-js-sys-0.3)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-num-conv" ,rust-num-conv-0.1)
                       ("rust-num-threads" ,rust-num-threads-0.1)
                       ("rust-powerfmt" ,rust-powerfmt-0.2)
                       ("rust-quickcheck" ,rust-quickcheck-1)
                       ("rust-rand" ,rust-rand-0.8)
                       ("rust-serde" ,rust-serde-1)
                       ("rust-time-core" ,rust-time-core-0.1)
                       ("rust-time-macros" ,rust-time-macros-0.2))))
    (home-page "https://time-rs.github.io")
    (synopsis
     "Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std]")
    (description
     "This package provides Date and time library.  Fully interoperable with the standard library.  Mostly
compatible with #![no_std].")
    (license (list license:expat license:asl2.0))))

(define-public rust-proc-macro2-1
  (package
    (name "rust-proc-macro2")
    (version "1.0.91")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "proc-macro2" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1csb3sy18vffw39nra971071n8r8rprj17fmw2kga46gpq230zih"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-unicode-ident" ,rust-unicode-ident-1))))
    (home-page "https://github.com/dtolnay/proc-macro2")
    (synopsis
     "substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case.")
    (description
     "This package provides a substitute implementation of the compiler's `proc_macro`
API to decouple token-based libraries from the procedural macro use case.")
    (license (list license:expat license:asl2.0))))

(define-public rust-syn-2
  (package
    (name "rust-syn")
    (version "2.0.89")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "syn" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0kicx48gndpxkkqnpv89f1slrzzbyldhr8nyhk6pmj61y6169m24"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-proc-macro2" ,rust-proc-macro2-1)
                       ("rust-quote" ,rust-quote-1)
                       ("rust-unicode-ident" ,rust-unicode-ident-1))))
    (home-page "https://github.com/dtolnay/syn")
    (synopsis "Parser for Rust source code")
    (description "This package provides Parser for Rust source code.")
    (license (list license:expat license:asl2.0))))

(define-public rust-thiserror-impl-2
  (package
    (name "rust-thiserror-impl")
    (version "2.0.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "thiserror-impl" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0s1m4jyjpvsqpdpbci1rswgafmy7fsjjh1a3cnpirp3sc0ymaxzh"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-proc-macro2" ,rust-proc-macro2-1)
                       ("rust-quote" ,rust-quote-1)
                       ("rust-syn" ,rust-syn-2))))
    (home-page "https://github.com/dtolnay/thiserror")
    (synopsis "Implementation detail of the `thiserror` crate")
    (description
     "This package provides Implementation detail of the `thiserror` crate.")
    (license (list license:expat license:asl2.0))))

(define-public rust-thiserror-2
  (package
    (name "rust-thiserror")
    (version "2.0.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "thiserror" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1ak7wvbkc6s37jgv7ksaqax0ggbkcyizm125v8mczcsifrfch1n0"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-thiserror-impl" ,rust-thiserror-impl-2))))
    (home-page "https://github.com/dtolnay/thiserror")
    (synopsis "derive(Error)")
    (description "This package provides derive(Error).")
    (license (list license:expat license:asl2.0))))

(define-public rust-memchr-2
  (package
    (name "rust-memchr")
    (version "2.7.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "memchr" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "18z32bhxrax0fnjikv475z7ii718hq457qwmaryixfxsl2qrmjkq"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-compiler-builtins" ,rust-compiler-builtins-0.1)
                       ("rust-log" ,rust-log-0.4)
                       ("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1))))
    (home-page "https://github.com/BurntSushi/memchr")
    (synopsis
     "Provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for
1, 2 or 3 byte search and single substring search.")
    (description
     "This package provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32)
routines for 1, 2 or 3 byte search and single substring search.")
    (license (list license:unlicense license:expat))))

(define-public rust-lzma-rs-0.3
  (package
    (name "rust-lzma-rs")
    (version "0.3.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lzma-rs" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0phif4pnjrn28zcxgz3a7z86hhx5gdajmkrndfw4vrkahd682zi9"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-byteorder" ,rust-byteorder-1)
                       ("rust-crc" ,rust-crc-3)
                       ("rust-env-logger" ,rust-env-logger-0.9)
                       ("rust-log" ,rust-log-0.4))))
    (home-page "https://github.com/gendx/lzma-rs")
    (synopsis "codec for LZMA, LZMA2 and XZ written in pure Rust")
    (description
     "This package provides a codec for LZMA, LZMA2 and XZ written in pure Rust.")
    (license license:expat)))

(define-public rust-adler2-2
  (package
    (name "rust-adler2")
    (version "2.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "adler2" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "09r6drylvgy8vv8k20lnbvwq8gp09h7smfn6h1rxsy15pgh629si"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-compiler-builtins" ,rust-compiler-builtins-0.1)
                       ("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1))))
    (home-page "https://github.com/oyvindln/adler2")
    (synopsis "simple clean-room implementation of the Adler-32 checksum")
    (description
     "This package provides a simple clean-room implementation of the Adler-32
checksum.")
    (license (list license:bsd-0 license:expat license:asl2.0))))

(define-public rust-miniz-oxide-0.8
  (package
    (name "rust-miniz-oxide")
    (version "0.8.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "miniz_oxide" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1wadxkg6a6z4lr7kskapj5d8pxlx7cp1ifw4daqnkzqjxych5n72"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-adler2" ,rust-adler2-2)
                       ("rust-compiler-builtins" ,rust-compiler-builtins-0.1)
                       ("rust-rustc-std-workspace-alloc" ,rust-rustc-std-workspace-alloc-1)
                       ("rust-rustc-std-workspace-core" ,rust-rustc-std-workspace-core-1)
                       ("rust-simd-adler32" ,rust-simd-adler32-0.3))))
    (home-page "https://github.com/Frommi/miniz_oxide/tree/master/miniz_oxide")
    (synopsis
     "DEFLATE compression and decompression library rewritten in Rust based on miniz")
    (description
     "This package provides DEFLATE compression and decompression library rewritten in Rust based on miniz.")
    (license (list license:expat license:zlib license:asl2.0))))

(define-public rust-jobserver-0.1
  (package
    (name "rust-jobserver")
    (version "0.1.32")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "jobserver" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1l2k50qmj84x9mn39ivjz76alqmx72jhm12rw33zx9xnpv5xpla8"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-libc" ,rust-libc-0.2))))
    (home-page "https://github.com/rust-lang/jobserver-rs")
    (synopsis "An implementation of the GNU Make jobserver for Rust.")
    (description
     "This package provides An implementation of the GNU Make jobserver for Rust.")
    (license (list license:expat license:asl2.0))))

(define-public rust-cc-1
  (package
    (name "rust-cc")
    (version "1.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "cc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0izavwg0w3ahhp8jhajy97adv53r6ggv11g6czyz6pjx43rfk7gx"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-jobserver" ,rust-jobserver-0.1)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-shlex" ,rust-shlex-1))))
    (home-page "https://github.com/rust-lang/cc-rs")
    (synopsis
     "build-time dependency for Cargo build scripts to assist in invoking the native
C compiler to compile native C code into a static archive to be linked into Rust
code.")
    (description
     "This package provides a build-time dependency for Cargo build scripts to assist
in invoking the native C compiler to compile native C code into a static archive
to be linked into Rust code.")
    (license (list license:expat license:asl2.0))))

(define-public rust-libz-sys-1
  (package
    (name "rust-libz-sys")
    (version "1.1.20")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libz-sys" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0wp4i6zl385ilmcqafv61jwsk1mpk6yb8gpws9nwza00x19n9lfj"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-cc" ,rust-cc-1)
                       ("rust-cmake" ,rust-cmake-0.1)
                       ("rust-libc" ,rust-libc-0.2)
                       ("rust-pkg-config" ,rust-pkg-config-0.3)
                       ("rust-vcpkg" ,rust-vcpkg-0.2))))
    (home-page "https://github.com/rust-lang/libz-sys")
    (synopsis
     "Low-level bindings to the system libz library (also known as zlib)")
    (description
     "This package provides Low-level bindings to the system libz library (also known as zlib).")
    (license (list license:expat license:asl2.0))))

(define-public rust-zlib-rs-0.4
  (package
    (name "rust-zlib-rs")
    (version "0.4.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zlib-rs" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1rbyn2bd0mi7b60bx7qgxslz90dxfxaxrpk1q5625jb6cpfak91c"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-arbitrary" ,rust-arbitrary-1)
                       ("rust-quickcheck" ,rust-quickcheck-1))))
    (home-page "https://github.com/trifectatechfoundation/zlib-rs")
    (synopsis "memory-safe zlib implementation written in rust")
    (description
     "This package provides a memory-safe zlib implementation written in rust.")
    (license license:zlib)))

(define-public rust-libz-rs-sys-0.4
  (package
    (name "rust-libz-rs-sys")
    (version "0.4.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libz-rs-sys" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0c7z9wbfzxipanms1lc1miqw15a7r4d1ff0afgssj8lcd2n73k1r"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-zlib-rs" ,rust-zlib-rs-0.4))))
    (home-page "https://github.com/trifectatechfoundation/zlib-rs")
    (synopsis "memory-safe zlib implementation written in rust")
    (description
     "This package provides a memory-safe zlib implementation written in rust.")
    (license license:zlib)))

(define-public rust-libz-ng-sys-1
  (package
    (name "rust-libz-ng-sys")
    (version "1.1.20")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libz-ng-sys" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1m8mm1dxa7myvp6fwy7jdkyxza74isqci31frdx9g1a6lfap43wg"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-cmake" ,rust-cmake-0.1)
                       ("rust-libc" ,rust-libc-0.2))))
    (home-page "https://github.com/rust-lang/libz-sys")
    (synopsis
     "Low-level bindings to zlib-ng (libz-ng), a high-performance zlib library")
    (description
     "This package provides Low-level bindings to zlib-ng (libz-ng), a high-performance zlib library.")
    (license (list license:expat license:asl2.0))))

(define-public rust-flate2-1
  (package
    (name "rust-flate2")
    (version "1.0.35")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "flate2" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0z6h0wa095wncpfngx75wyhyjnqwld7wax401gsvnzjhzgdbydn9"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-cloudflare-zlib-sys" ,rust-cloudflare-zlib-sys-0.3)
                       ("rust-crc32fast" ,rust-crc32fast-1)
                       ("rust-libz-ng-sys" ,rust-libz-ng-sys-1)
                       ("rust-libz-rs-sys" ,rust-libz-rs-sys-0.4)
                       ("rust-libz-sys" ,rust-libz-sys-1)
                       ("rust-miniz-oxide" ,rust-miniz-oxide-0.8))))
    (home-page "https://github.com/rust-lang/flate2-rs")
    (synopsis
     "DEFLATE compression and decompression exposed as Read/BufRead/Write streams.
Supports miniz_oxide and multiple zlib implementations. Supports zlib, gzip,
and raw deflate streams.")
    (description
     "This package provides DEFLATE compression and decompression exposed as Read/@code{BufRead/Write}
streams.  Supports miniz_oxide and multiple zlib implementations.  Supports
zlib, gzip, and raw deflate streams.")
    (license (list license:expat license:asl2.0))))

(define-public rust-displaydoc-0.2
  (package
    (name "rust-displaydoc")
    (version "0.2.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "displaydoc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1q0alair462j21iiqwrr21iabkfnb13d6x5w95lkdg21q2xrqdlp"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-proc-macro2" ,rust-proc-macro2-1)
                       ("rust-quote" ,rust-quote-1)
                       ("rust-syn" ,rust-syn-2))))
    (home-page "https://github.com/yaahc/displaydoc")
    (synopsis
     "derive macro for implementing the display Trait via a doc comment and string interpolation")
    (description
     "This package provides a derive macro for implementing the display Trait via a
doc comment and string interpolation.")
    (license (list license:expat license:asl2.0))))

(define-public rust-deflate64-0.1
  (package
    (name "rust-deflate64")
    (version "0.1.9")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "deflate64" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "06scix17pa7wzzfsnhkycpcc6s04shs49cdaxx2k1sl0226jnsfs"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t))
    (home-page "https://github.com/anatawa12/deflate64-rs#readme")
    (synopsis "Deflate64 implementation based on .NET's implementation")
    (description
     "This package provides Deflate64 implementation based on .NET's implementation.")
    (license license:expat)))

(define-public rust-crossbeam-utils-0.8
  (package
    (name "rust-crossbeam-utils")
    (version "0.8.20")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "crossbeam-utils" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "100fksq5mm1n7zj242cclkw6yf7a4a8ix3lvpfkhxvdhbda9kv12"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-loom" ,rust-loom-0.7))))
    (home-page
     "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
    (synopsis "Utilities for concurrent programming")
    (description "This package provides Utilities for concurrent programming.")
    (license (list license:expat license:asl2.0))))

(define-public rust-crc32fast-1
  (package
    (name "rust-crc32fast")
    (version "1.4.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "crc32fast" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1czp7vif73b8xslr3c9yxysmh9ws2r8824qda7j47ffs9pcnjxx9"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-cfg-if" ,rust-cfg-if-1))))
    (home-page "https://github.com/srijs/rust-crc32fast")
    (synopsis "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation")
    (description
     "This package provides Fast, SIMD-accelerated CRC32 (IEEE) checksum computation.")
    (license (list license:expat license:asl2.0))))

(define-public rust-constant-time-eq-0.3
  (package
    (name "rust-constant-time-eq")
    (version "0.3.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "constant_time_eq" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "19nwwczii762pwlsm7bpizgjg8hkg1kqi32b2g4rglijklsbhx3w"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t))
    (home-page "https://github.com/cesarb/constant_time_eq")
    (synopsis "Compares two equal-sized byte strings in constant time")
    (description
     "This package provides Compares two equal-sized byte strings in constant time.")
    (license (list license:cc0 license:expat-0 license:asl2.0))))

(define-public rust-chrono-0.4
  (package
    (name "rust-chrono")
    (version "0.4.38")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "chrono" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "009l8vc5p8750vn02z30mblg4pv2qhkbfizhfwmzc6vpy5nr67x2"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-android-tzdata" ,rust-android-tzdata-0.1)
                       ("rust-arbitrary" ,rust-arbitrary-1)
                       ("rust-iana-time-zone" ,rust-iana-time-zone-0.1)
                       ("rust-js-sys" ,rust-js-sys-0.3)
                       ("rust-num-traits" ,rust-num-traits-0.2)
                       ("rust-pure-rust-locales" ,rust-pure-rust-locales-0.8)
                       ("rust-rkyv" ,rust-rkyv-0.7)
                       ("rust-serde" ,rust-serde-1)
                       ("rust-wasm-bindgen" ,rust-wasm-bindgen-0.2)
                       ("rust-windows-targets" ,rust-windows-targets-0.52))))
    (home-page "https://github.com/chronotope/chrono")
    (synopsis "Date and time library for Rust")
    (description "This package provides Date and time library for Rust.")
    (license (list license:expat license:asl2.0))))

(define-public rust-zip-2
  (package
    (name "rust-zip")
    (version "2.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "zip" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0lm3ax0pq6xgrllwf95fwwv3cs11xf0vpcvi77qprsl6zj9j5mcr"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-aes" ,rust-aes-0.8)
                       ("rust-arbitrary" ,rust-arbitrary-1)
                       ("rust-bzip2" ,rust-bzip2-0.4)
                       ("rust-chrono" ,rust-chrono-0.4)
                       ("rust-constant-time-eq" ,rust-constant-time-eq-0.3)
                       ("rust-crc32fast" ,rust-crc32fast-1)
                       ("rust-crossbeam-utils" ,rust-crossbeam-utils-0.8)
                       ("rust-deflate64" ,rust-deflate64-0.1)
                       ("rust-displaydoc" ,rust-displaydoc-0.2)
                       ("rust-flate2" ,rust-flate2-1)
                       ("rust-hmac" ,rust-hmac-0.12)
                       ("rust-indexmap" ,rust-indexmap-2)
                       ("rust-lzma-rs" ,rust-lzma-rs-0.3)
                       ("rust-memchr" ,rust-memchr-2)
                       ("rust-pbkdf2" ,rust-pbkdf2-0.12)
                       ("rust-rand" ,rust-rand-0.8)
                       ("rust-sha1" ,rust-sha1-0.10)
                       ("rust-thiserror" ,rust-thiserror-2)
                       ("rust-time" ,rust-time-0.3)
                       ("rust-zeroize" ,rust-zeroize-1)
                       ("rust-zopfli" ,rust-zopfli-0.8)
                       ("rust-zstd" ,rust-zstd-0.13))))
    (home-page "https://github.com/zip-rs/zip2.git")
    (synopsis "Library to support the reading and writing of zip files.")
    (description
     "This package provides Library to support the reading and writing of zip files.")
    (license license:expat)))

(define-public rust-is-executable-0.1
  (package
    (name "rust-is-executable")
    (version "0.1.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "is_executable" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0xy516afjh79a0d53j9v4w5mgi2s0r6f6qynnyz8g0dwi8xmab9h"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-winapi" ,rust-winapi-0.3))))
    (home-page "https://github.com/fitzgen/is_executable")
    (synopsis "Is there an executable file at the given path?")
    (description
     "This package provides Is there an executable file at the given path?")
    (license (list license:asl2.0 license:expat))))

(define-public rust-fs4-0.6
  (package
    (name "rust-fs4")
    (version "0.6.6")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "fs4" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0ixxx352j33n4fdf1wif2dq2fd98vb6zkqxa1gxbfhrgw7clxsrf"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-async-std" ,rust-async-std-1)
                       ("rust-async-trait" ,rust-async-trait-0.1)
                       ("rust-rustix" ,rust-rustix-0.38)
                       ("rust-smol" ,rust-smol-1)
                       ("rust-tokio" ,rust-tokio-1)
                       ("rust-windows-sys" ,rust-windows-sys-0.48))))
    (home-page "https://github.com/al8n/fs4-rs")
    (synopsis
     "No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix")
    (description
     "This package provides No libc, pure Rust cross-platform file locks.  Original fs2, now supports async
and replace libc by rustix.")
    (license (list license:expat license:asl2.0))))

(define-public rust-binary-install-0.4
  (package
    (name "rust-binary-install")
    (version "0.4.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "binary-install" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "0qq7xjv6gzp893ghlm2wqm79hxrh8hrg48vih9wpyrfp9qdf8ljj"))))
    (build-system cargo-build-system)
    (arguments
     `(#:skip-build? #t
       #:cargo-inputs (("rust-anyhow" ,rust-anyhow-1)
                       ("rust-dirs-next" ,rust-dirs-next-2)
                       ("rust-flate2" ,rust-flate2-1)
                       ("rust-fs4" ,rust-fs4-0.6)
                       ("rust-hex" ,rust-hex-0.4)
                       ("rust-is-executable" ,rust-is-executable-0.1)
                       ("rust-siphasher" ,rust-siphasher-0.3)
                       ("rust-tar" ,rust-tar-0.4)
                       ("rust-ureq" ,rust-ureq-2)
                       ("rust-zip" ,rust-zip-2))))
    (home-page "https://github.com/rustwasm/binary-install")
    (synopsis "Install a binary from a path to a global cache")
    (description
     "This package provides Install a binary from a path to a global cache.")
    (license (list license:expat license:asl2.0))))

(define-public rust-wasm-pack-0.13
  (package
    (name "rust-wasm-pack")
    (version "0.13.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "wasm-pack" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32 "1c0q0cmlj9qrg1fxwm773lkida7gi544x6h4wzjk7zxvqdwqik5w"))))
    (build-system cargo-build-system)
    (arguments
     `(#:tests? #f ;; tests need internet
       #:cargo-inputs (("rust-anyhow" ,rust-anyhow-1)
                       ("rust-binary-install" ,rust-binary-install-0.4)
                       ("rust-cargo-metadata" ,rust-cargo-metadata-0.15)
                       ("rust-chrono" ,rust-chrono-0.4)
                       ("rust-clap" ,rust-clap-4)
                       ("rust-console" ,rust-console-0.15)
                       ("rust-dialoguer" ,rust-dialoguer-0.10)
                       ("rust-env-logger" ,rust-env-logger-0.10)
                       ("rust-glob" ,rust-glob-0.3)
                       ("rust-human-panic" ,rust-human-panic-1)
                       ("rust-log" ,rust-log-0.4)
                       ("rust-parking-lot" ,rust-parking-lot-0.12)
                       ("rust-path-clean" ,rust-path-clean-1)
                       ("rust-semver" ,rust-semver-1)
                       ("rust-serde" ,rust-serde-1)
                       ("rust-serde-derive" ,rust-serde-derive-1)
                       ("rust-serde-ignored" ,rust-serde-ignored-0.1)
                       ("rust-serde-json" ,rust-serde-json-1)
                       ("rust-siphasher" ,rust-siphasher-0.3)
                       ("rust-strsim" ,rust-strsim-0.10)
                       ("rust-toml" ,rust-toml-0.7)
                       ("rust-ureq" ,rust-ureq-2)
                       ("rust-walkdir" ,rust-walkdir-2)
                       ("rust-which" ,rust-which-4))
       #:cargo-development-inputs (("rust-assert-cmd" ,rust-assert-cmd-2)
                                   ("rust-lazy-static" ,rust-lazy-static-1)
                                   ("rust-predicates" ,rust-predicates-3)
                                   ("rust-serial-test" ,rust-serial-test-2)
                                   ("rust-tempfile" ,rust-tempfile-3))))
    (native-inputs (list pkg-config))
    (inputs `((,zstd "lib")))
    (home-page "https://github.com/rustwasm/wasm-pack.git")
    (synopsis "your favorite rust -> wasm workflow tool!")
    (description
     "This package provides your favorite rust -> wasm workflow tool!")
    (license (list license:expat license:asl2.0))))