Merge staging-next into staging

nixos/modules/services/misc/gitea.nix

···
           description = "Root path for log files.";
         };
         level = mkOption {
-          default = "Trace";
+          default = "Info";
           type = types.enum [ "Trace" "Debug" "Info" "Warn" "Error" "Critical" ];
           description = "General log level.";
         };

nixos/modules/services/web-apps/nextcloud.nix

···
   cfg = config.services.nextcloud;
   fpm = config.services.phpfpm.pools.nextcloud;
 
-  phpPackage = pkgs.php74.buildEnv {
+  phpPackage = cfg.phpPackage.buildEnv {
     extensions = { enabled, all }:
       (with all;
         enabled
···
       type = types.package;
       description = "Which package to use for the Nextcloud instance.";
       relatedPackages = [ "nextcloud20" "nextcloud21" "nextcloud22" ];
+    };
+    phpPackage = mkOption {
+      type = types.package;
+      relatedPackages = [ "php74" "php80" ];
+      defaultText = "pkgs.php";
+      description = ''
+        PHP package to use for Nextcloud.
+      '';
     };
 
     maxUploadSize = mkOption {
···
           else if versionOlder stateVersion "21.11" then nextcloud21
           else nextcloud22
         );
+
+      services.nextcloud.phpPackage =
+        if versionOlder cfg.package.version "21" then pkgs.php74
+        else pkgs.php80;
     }
 
     { systemd.timers.nextcloud-cron = {

nixos/modules/services/x11/display-managers/gdm.nix

···
 
   cfg = config.services.xserver.displayManager;
   gdm = pkgs.gnome.gdm;
+  settingsFormat = pkgs.formats.ini { };
+  configFile = settingsFormat.generate "custom.conf" cfg.gdm.settings;
 
   xSessionWrapper = if (cfg.setupCommands == "") then null else
     pkgs.writeScript "gdm-x-session-wrapper" ''
···
           (Does not affect automatic suspend while logged in, or at lock screen.)
         '';
         type = types.bool;
+      };
+
+      settings = mkOption {
+        type = settingsFormat.type;
+        default = { };
+        example = {
+          debug.enable = true;
+        };
+        description = ''
+          Options passed to the gdm daemon.
+          See <link xlink:href="https://help.gnome.org/admin/gdm/stable/configuration.html.en#daemonconfig">here</link> for supported options.
+        '';
       };
 
     };
···
     # Use AutomaticLogin if delay is zero, because it's immediate.
     # Otherwise with TimedLogin with zero seconds the prompt is still
     # presented and there's a little delay.
-    environment.etc."gdm/custom.conf".text = ''
-      [daemon]
-      WaylandEnable=${boolToString cfg.gdm.wayland}
-      ${optionalString cfg.autoLogin.enable (
-        if cfg.gdm.autoLogin.delay > 0 then ''
-          TimedLoginEnable=true
-          TimedLogin=${cfg.autoLogin.user}
-          TimedLoginDelay=${toString cfg.gdm.autoLogin.delay}
-        '' else ''
-          AutomaticLoginEnable=true
-          AutomaticLogin=${cfg.autoLogin.user}
-        '')
-      }
+    services.xserver.displayManager.gdm.settings = {
+      daemon = mkMerge [
+        { WaylandEnable = cfg.gdm.wayland; }
+        # nested if else didn't work
+        (mkIf (cfg.autoLogin.enable && cfg.gdm.autoLogin.delay != 0 ) {
+          TimedLoginEnable = true;
+          TimedLogin = cfg.autoLogin.user;
+          TimedLoginDelay = cfg.gdm.autoLogin.delay;
+        })
+        (mkIf (cfg.autoLogin.enable && cfg.gdm.autoLogin.delay == 0 ) {
+          AutomaticLoginEnable = true;
+          AutomaticLogin = cfg.autoLogin.user;
+        })
+      ];
+      debug = mkIf cfg.gdm.debug {
+        Enable = true;
+      };
+    };
 
-      [security]
-
-      [xdmcp]
-
-      [greeter]
-
-      [chooser]
-
-      [debug]
-      ${optionalString cfg.gdm.debug "Enable=true"}
-    '';
+    environment.etc."gdm/custom.conf".source = configFile;
 
     environment.etc."gdm/Xsession".source = config.services.xserver.displayManager.sessionData.wrapper;
 

nixos/tests/nextcloud/basic.nix

···
-import ../make-test-python.nix ({ pkgs, ...}: let
+args@{ pkgs, nextcloudVersion ? 22, ... }:
+
+(import ../make-test-python.nix ({ pkgs, ...}: let
   adminpass = "notproduction";
   adminuser = "root";
 in {
···
           inherit adminpass;
           dbtableprefix = "nixos_";
         };
+        package = pkgs.${"nextcloud" + (toString nextcloudVersion)};
         autoUpdateApps = {
           enable = true;
           startAt = "20:00";
···
     )
     assert "hi" in client.succeed("cat /mnt/dav/test-shared-file")
   '';
-})
+})) args

nixos/tests/nextcloud/default.nix

···
   config ? {},
   pkgs ? import ../../.. { inherit system config; }
 }:
-{
-  basic = import ./basic.nix { inherit system pkgs; };
-  with-postgresql-and-redis = import ./with-postgresql-and-redis.nix { inherit system pkgs; };
-  with-mysql-and-memcached = import ./with-mysql-and-memcached.nix { inherit system pkgs; };
-}
+
+with pkgs.lib;
+
+foldl
+  (matrix: ver: matrix // {
+    "basic${toString ver}" = import ./basic.nix { inherit system pkgs; nextcloudVersion = ver; };
+    "with-postgresql-and-redis${toString ver}" = import ./with-postgresql-and-redis.nix {
+      inherit system pkgs;
+      nextcloudVersion = ver;
+    };
+    "with-mysql-and-memcached${toString ver}" = import ./with-mysql-and-memcached.nix {
+      inherit system pkgs;
+      nextcloudVersion = ver;
+    };
+  })
+  {}
+  [ 20 21 22 ]

nixos/tests/nextcloud/with-mysql-and-memcached.nix

···
-import ../make-test-python.nix ({ pkgs, ...}: let
+args@{ pkgs, nextcloudVersion ? 22, ... }:
+
+(import ../make-test-python.nix ({ pkgs, ...}: let
   adminpass = "hunter2";
   adminuser = "root";
 in {
···
         enable = true;
         hostName = "nextcloud";
         https = true;
+        package = pkgs.${"nextcloud" + (toString nextcloudVersion)};
         caching = {
           apcu = true;
           redis = false;
···
         "${withRcloneEnv} ${diffSharedFile}"
     )
   '';
-})
+})) args

nixos/tests/nextcloud/with-postgresql-and-redis.nix

···
-import ../make-test-python.nix ({ pkgs, ...}: let
+args@{ pkgs, nextcloudVersion ? 22, ... }:
+
+(import ../make-test-python.nix ({ pkgs, ...}: let
   adminpass = "hunter2";
   adminuser = "custom-admin-username";
 in {
···
       services.nextcloud = {
         enable = true;
         hostName = "nextcloud";
+        package = pkgs.${"nextcloud" + (toString nextcloudVersion)};
         caching = {
           apcu = false;
           redis = true;
···
         "${withRcloneEnv} ${diffSharedFile}"
     )
   '';
-})
+})) args

pkgs/applications/audio/helm/default.nix

···
   buildInputs = [
     xorg.libX11 xorg.libXcomposite xorg.libXcursor xorg.libXext
     xorg.libXinerama xorg.libXrender xorg.libXrandr
-    freetype alsa-lib curl libjack2 pkg-config libGLU libGL lv2
+    freetype alsa-lib curl libjack2 libGLU libGL lv2
   ];
+  nativeBuildInputs = [ pkg-config ];
 
   CXXFLAGS = "-DHAVE_LROUND";
+  enableParallelBuilding = true;
+  makeFlags = [ "DESTDIR=$(out)" ];
 
   patches = [
     # gcc9 compatibility https://github.com/mtytel/helm/pull/233
···
 
   prePatch = ''
     sed -i 's|usr/||g' Makefile
-  '';
-
-  buildPhase = ''
-    make lv2
-    make standalone
-  '';
-
-  installPhase = ''
-   make DESTDIR="$out" install
+    sed -i "s|/usr/share/|$out/share/|" src/common/load_save.cpp
   '';
 
   meta = with lib; {
···
         Simple arpeggiator
         Effects: Formant filter, stutter, delay
     '';
-    license = lib.licenses.gpl3;
+    license = lib.licenses.gpl3Plus;
     maintainers = [ maintainers.magnetophon ];
     platforms = platforms.linux;
   };

pkgs/applications/audio/pamixer/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, boost, libpulseaudio }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, boost, libpulseaudio, installShellFiles }:
 
 stdenv.mkDerivation rec {
   pname = "pamixer";
-  version = "1.4";
+  version = "unstable-2021-03-29";
 
   src = fetchFromGitHub {
     owner = "cdemoulins";
     repo = "pamixer";
-    rev = version;
-    sha256 = "1i14550n8paijwwnhksv5izgfqm3s5q2773bdfp6vyqybkll55f7";
+    rev = "4ea2594cb8c605dccd00a381ba19680eba368e94";
+    sha256 = "sha256-kV4wIxm1WZvqqyfmgQ2cSbRJwJR154OW0MMDg2ntf6g=";
   };
 
   buildInputs = [ boost libpulseaudio ];
+
+  nativeBuildInputs = [ installShellFiles ];
 
   installPhase = ''
+    runHook preInstall
+
     install -Dm755 pamixer -t $out/bin
+
+    runHook postInstall
+  '';
+
+  postInstall = ''
+    installManPage pamixer.1
   '';
 
   meta = with lib; {
···
         - Mute or unmute a device
     '';
     homepage = "https://github.com/cdemoulins/pamixer";
+    maintainers = with maintainers; [ thiagokokada ];
     license = licenses.gpl3;
     platforms = platforms.linux;
+    mainProgram = "pamixer";
   };
 }

pkgs/applications/graphics/ImageMagick/7.0.nix

···
     ++ (if arch != null then [ "--with-gcc-arch=${arch}" ] else [ "--without-gcc-arch" ])
     ++ lib.optional (librsvg != null) "--with-rsvg"
     ++ lib.optional (liblqr1 != null) "--with-lqr"
-    ++ lib.optional (libjxl != null) "--with-jxl"
+    # libjxl is broken on aarch64 (see meta.broken in libjxl) for now,
+    # let's disable it for now to unbreak the imagemagick build.
+    ++ lib.optional (libjxl != null && !stdenv.isAarch64) "--with-jxl"
     ++ lib.optionals (ghostscript != null)
       [ "--with-gs-font-dir=${ghostscript}/share/ghostscript/fonts"
         "--with-gslib"
···
 
   buildInputs =
     [ zlib fontconfig freetype ghostscript
-      libjxl liblqr1 libpng libtiff libxml2 libheif djvulibre
+      liblqr1 libpng libtiff libxml2 libheif djvulibre
     ]
+    # libjxl is broken on aarch64 (see meta.broken in libjxl) for now,
+    # let's disable it for now to unbreak the imagemagick build.
+    ++ lib.optionals (!stdenv.isAarch64)
+      [ libjxl ]
     ++ lib.optionals (!stdenv.hostPlatform.isMinGW)
       [ openexr librsvg openjpeg ]
     ++ lib.optionals stdenv.isDarwin [

pkgs/applications/misc/visidata/default.nix

···
 }:
 buildPythonApplication rec {
   pname = "visidata";
-  version = "2.6";
+  version = "2.6.1";
 
   src = fetchFromGitHub {
     owner = "saulpw";
     repo = "visidata";
     rev = "v${version}";
-    sha256 = "sha256-fsk+Cn7CzrOAif5+LUMrs8llSnEfoSLAdg1qOFMJOh8=";
+    sha256 = "1dmiy87x0yc0d594v3d3km13dl851mx7ym1vgh3bg91llg8ykg33";
   };
 
   propagatedBuildInputs = [

pkgs/applications/networking/browsers/brave/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "brave";
-  version = "1.30.86";
+  version = "1.30.87";
 
   src = fetchurl {
     url = "https://github.com/brave/brave-browser/releases/download/v${version}/brave-browser_${version}_amd64.deb";
-    sha256 = "0pg29i01dm5gqfd3aagsc83dbx0n3051wfxi0r1c9l93dwm5bmq9";
+    sha256 = "0mx1vnrip1y87g6zj9sdcf5siihwn0b6v1q106d9kz89znpzd64s";
   };
 
   dontConfigure = true;

pkgs/applications/office/hledger-check-fancyassertions/default.nix

···
+{lib, stdenvNoCC, haskellPackages, fetchurl, writers}:
+
+stdenvNoCC.mkDerivation rec {
+  pname = "hledger-check-fancyassertions";
+  version = "1.23";
+
+  src = fetchurl {
+    url = "https://raw.githubusercontent.com/simonmichael/hledger/hledger-lib-${version}/bin/hledger-check-fancyassertions.hs";
+    sha256 = "08p2din1j7l4c29ipn68k8vvs3ys004iy8a3zf318lzby4h04h0n";
+  };
+
+  dontUnpack = true;
+  dontBuild = true;
+
+  executable = writers.writeHaskell
+    "hledger-check-fancyassertions"
+    {
+      libraries = with haskellPackages; [
+        base base-compat base-compat-batteries filepath hledger-lib_1_23
+        megaparsec microlens optparse-applicative string-qq text time
+        transformers
+      ];
+      inherit (haskellPackages) ghc;
+    }
+    src;
+
+  installPhase = ''
+    runHook preInstall
+    install -D $executable $out/bin/${pname}
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Complex account balance assertions for hledger journals";
+    homepage = "https://hledger.org/";
+    changelog = "https://github.com/simonmichael/hledger/blob/master/CHANGES.md";
+    license = licenses.gpl3;
+    maintainers = [ maintainers.DamienCassou ];
+    platforms = lib.platforms.all; # GHC can cross-compile
+  };
+}

pkgs/applications/terminal-emulators/rxvt-unicode/default.nix

···
 
 
   configureFlags = [
-    "--with-terminfo=$terminfo/share/terminfo"
+    "--with-terminfo=${placeholder "terminfo"}/share/terminfo"
     "--enable-256-color"
     (enableFeature perlSupport "perl")
     (enableFeature unicode3Support "unicode3")

pkgs/applications/virtualization/docker-slim/default.nix

···
 
 buildGoPackage rec {
   pname = "docker-slim";
-  version = "1.36.4";
+  version = "1.37.0";
 
   goPackagePath = "github.com/docker-slim/docker-slim";
 
···
     owner = "docker-slim";
     repo = "docker-slim";
     rev = version;
-    sha256 = "0hgiigai5jpczjll4s4r4jzbq272s3p8f0r6mj4r3mjjs89hkqz1";
+    sha256 = "1gxbgn61qv4zhzxwdd917hywwicr3jand34ghjzha35r44lmyzgz";
   };
 
   subPackages = [ "cmd/docker-slim" "cmd/docker-slim-sensor" ];

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "e0bd041989865809059f6039125dfb93cb075f72",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e0bd041989865809059f6039125dfb93cb075f72.tar.gz",
-  "sha256": "1fpm2kawxlias5xxmiara6224akgii0mnwnlyklc8szflv9cbs17",
-  "msg": "Update from Hackage at 2021-09-19T21:23:33Z"
+  "commit": "85edb79d7ee62685f6ccc57b932ff3920affcb77",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/85edb79d7ee62685f6ccc57b932ff3920affcb77.tar.gz",
+  "sha256": "13yxypamp0pwx8mcslg4mgq5599cldhmfss881m22zqjkbqvi8sj",
+  "msg": "Update from Hackage at 2021-09-29T20:58:23Z"
 }

pkgs/development/haskell-modules/configuration-common.nix

···
       stripLen = 1;
     });
 
+  # hledger-lib 1.23 depends on doctest >= 0.18
+  hledger-lib_1_23 = super.hledger-lib_1_23.override {
+    doctest = self.doctest_0_18_1;
+  };
+
   # Copy hledger man pages from data directory into the proper place. This code
   # should be moved into the cabal2nix generator.
   hledger = overrideCabal super.hledger (drv: {
···
     doJailbreak super.hw-eliasfano;
   hw-xml = assert pkgs.lib.versionOlder self.generic-lens.version "2.2.0.0";
     doJailbreak super.hw-xml;
+
+  # doctests fail due to deprecation warnings in 0.2
+  candid = assert pkgs.lib.versionOlder super.candid.version "0.3";
+    overrideCabal super.candid (drv: {
+      version = "0.3";
+      sha256 = "0zq29zddkkwvlyz9qmxl942ml53m6jawl4m5rkb2510glbkcvr5x";
+      libraryHaskellDepends = drv.libraryHaskellDepends ++ [
+        self.file-embed
+      ];
+    });
+
+  # Needs network >= 3.1.2
+  quic = super.quic.overrideScope (self: super: {
+    network = self.network_3_1_2_2;
+  });
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

pkgs/development/haskell-modules/configuration-darwin.nix

···
   hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin;
   hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;
   hls-floskell-plugin = dontCheck super.hls-floskell-plugin;
+  hls-call-hierarchy-plugin = dontCheck super.hls-call-hierarchy-plugin;
 
   # We are lacking pure pgrep at the moment for tests to work
   tmp-postgres = dontCheck super.tmp-postgres;

pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix

···
   # 2021-09-18: Need path >= 0.9.0 for ghc 9 compat
   path = self.path_0_9_0;
   # 2021-09-18: Need ormolu >= 0.3.0.0 for ghc 9 compat
-  ormolu = self.ormolu_0_3_0_0;
+  ormolu = doDistribute self.ormolu_0_3_0_1;
   # 2021-09-18: https://github.com/haskell/haskell-language-server/issues/2206
   # Restrictive upper bound on ormolu
   hls-ormolu-plugin = doJailbreak super.hls-ormolu-plugin;

pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix

···
 
   # Jailbreaks & Version Updates
   async = doJailbreak super.async;
-  ChasingBottoms = markBrokenVersion "1.3.1.9" super.ChasingBottoms;
+  base64-bytestring = doJailbreak super.base64-bytestring;
+  ChasingBottoms = doJailbreak super.ChasingBottoms;
   data-fix = doJailbreak super.data-fix;
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
···
   HTTP = overrideCabal (doJailbreak super.HTTP) (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; });
   integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; });
   lukko = doJailbreak super.lukko;
+  network = super.network_3_1_2_2;
   parallel = doJailbreak super.parallel;
-  primitive = doJailbreak (dontCheck super.primitive);
+  primitive = doJailbreak super.primitive;
   regex-posix = doJailbreak super.regex-posix;
   resolv = doJailbreak super.resolv;
   singleton-bool = doJailbreak super.singleton-bool;
···
   });
 
   # 1.3.0 (on stackage) defines instances for the Option-type, which has been removed from base in GHC 9.2.x
-  # Tests fail because random hasn't been updated for GHC 9.2.x
-  hashable = dontCheck super.hashable_1_3_3_0;
+  hashable = super.hashable_1_3_3_0;
 
-  # Tests fail because random hasn't been updated for GHC 9.2.x
-  unordered-containers = dontCheck super.unordered-containers;
-
-  # The test suite seems pretty broken.
-  base64-bytestring = dontCheck super.base64-bytestring;
+  # 1.2.1 introduced support for GHC 9.2.1, stackage has 1.2.0
+  # The test suite indirectly depends on random, which leads to infinite recursion
+  random = dontCheck super.random_1_2_1;
 
   # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet
   lens = super.lens_5_0_1;

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···
   - semialign-extras
   - semibounded-lattices
   - Semigroup
+  - semigroupoids-do
   - semigroupoids-syntax
   - semigroups-actions
   - sendgrid-haskell
···
   - streaming-utils
   - streaming-with
   - streamly-examples
+  - streamly-lz4
   - streamly-process
   - stream-monad
   - streamproc
···
   - Titim
   - tkhs
   - tkyprof
+  - tmp-proc-example
   - todo
   - tofromxml
   - to-haskell
···
   - xml-prettify
   - xml-query
   - xml-tydom-core
+  - xml-verify
   - XMMS
   - xmonad-bluetilebranch
   - xmonad-contrib-gpl

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···
     - witch
   ncfavier:
     - lambdabot
+  nomeata:
+    - candid
+    - leb128-cereal
+    - tasty-expected-failure
   pacien:
     - ldgallery-compiler
   peti:

pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml

···
-# Stackage LTS 18.10
+# Stackage LTS 18.12
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - ascii-progress ==0.3.3.0
   - ascii-superset ==1.0.1.4
   - ascii-th ==1.0.0.4
-  - asif ==6.0.4
   - asn1-encoding ==0.9.6
   - asn1-parse ==0.9.5
   - asn1-types ==0.3.4
···
   - attoparsec-path ==0.0.0.1
   - audacity ==0.0.2
   - aur ==7.0.6
-  - aura ==3.2.5
+  - aura ==3.2.6
   - authenticate ==1.3.5
   - authenticate-oauth ==1.6.0.1
   - autoexporter ==1.1.20
···
   - bv ==0.5
   - bv-little ==1.1.1
   - byteable ==0.1.1
-  - byte-count-reader ==0.10.1.5
+  - byte-count-reader ==0.10.1.6
   - bytedump ==1.0
   - byte-order ==0.1.2.0
   - byteorder ==1.0.4
···
   - c2hs ==0.28.8
   - cabal2spec ==2.6.2
   - cabal-appimage ==0.3.0.2
-  - cabal-clean ==0.1.20210815
+  - cabal-clean ==0.1.20210924
   - cabal-debian ==5.1
   - cabal-doctest ==1.0.8
   - cabal-file ==0.1.1
···
   - cipher-des ==0.0.6
   - cipher-rc4 ==0.1.4
   - circle-packing ==0.1.0.6
-  - circular ==0.4.0.0
+  - circular ==0.4.0.1
   - citeproc ==0.4.0.1
   - clash-ghc ==1.4.3
   - clash-lib ==1.4.3
···
   - concurrent-supply ==0.1.8
   - cond ==0.4.1.1
   - conduino ==0.2.2.0
-  - conduit ==1.3.4.1
+  - conduit ==1.3.4.2
   - conduit-algorithms ==0.0.11.0
   - conduit-combinators ==1.3.0
   - conduit-concurrent-map ==0.1.1
···
   - di-monad ==1.3.1
   - directory-tree ==0.12.1
   - direct-sqlite ==2.3.26
-  - dirichlet ==0.1.0.4
+  - dirichlet ==0.1.0.5
   - discount ==0.1.1
   - disk-free-space ==0.1.0.1
   - distributed-closure ==0.4.2.0
···
   - fmlist ==0.9.4
   - fmt ==0.6.3.0
   - fn ==0.3.0.2
-  - focus ==1.0.2
+  - focus ==1.0.3
   - focuslist ==0.1.0.2
   - foldable1 ==0.1.0.0
   - fold-debounce ==0.2.0.9
···
   - fusion-plugin ==0.2.3
   - fusion-plugin-types ==0.1.0
   - fuzzcheck ==0.1.1
-  - fuzzy ==0.1.0.0
+  - fuzzy ==0.1.0.1
   - fuzzy-dates ==0.1.1.2
   - fuzzyset ==0.2.1
   - fuzzy-time ==0.1.0.0
···
   - ginger ==0.10.1.0
   - gingersnap ==0.3.1.0
   - gi-pango ==1.0.24
-  - githash ==0.1.6.1
+  - githash ==0.1.6.2
   - github-release ==1.3.7
   - github-rest ==1.0.3
   - github-types ==0.2.1
···
   - haskell-src-meta ==0.8.7
   - haskey-btree ==0.3.0.1
   - hasktags ==0.72.0
-  - hasql ==1.4.5.1
+  - hasql ==1.4.5.2
   - hasql-notifications ==0.2.0.0
   - hasql-optparse-applicative ==0.3.0.6
   - hasql-pool ==0.5.2
···
   - hw-conduit ==0.2.1.0
   - hw-conduit-merges ==0.2.1.0
   - hw-diagnostics ==0.0.1.0
-  - hw-dsv ==0.4.1.0
   - hweblib ==0.6.3
-  - hw-eliasfano ==0.1.2.0
   - hw-excess ==0.2.3.0
   - hw-fingertree ==0.1.2.0
   - hw-fingertree-strict ==0.1.2.0
   - hw-hedgehog ==0.1.1.0
   - hw-hspec-hedgehog ==0.1.1.0
   - hw-int ==0.0.2.0
-  - hw-ip ==2.4.2.0
   - hw-json-simd ==0.1.1.0
-  - hw-json-simple-cursor ==0.1.1.0
-  - hw-json-standard-cursor ==0.2.3.1
   - hw-kafka-client ==4.0.3
   - hw-packed-vector ==0.2.1.0
   - hw-parser ==0.1.1.0
···
   - hw-streams ==0.0.1.0
   - hw-string-parse ==0.0.0.4
   - hw-succinct ==0.1.0.1
-  - hw-xml ==0.5.1.0
   - hxt ==9.3.1.22
   - hxt-charproperties ==9.5.0.0
   - hxt-css ==0.1.0.3
···
   - LibZip ==1.0.1
   - lifted-async ==0.10.2.1
   - lifted-base ==0.2.3.12
-  - lift-generics ==0.2
+  - lift-generics ==0.2.1
   - lift-type ==0.1.0.1
   - line ==4.0.1
   - linear ==1.21.6
···
   - list-predicate ==0.1.0.1
   - listsafe ==0.1.0.1
   - list-singleton ==1.0.0.5
-  - list-t ==1.0.4
+  - list-t ==1.0.5
   - list-transformer ==1.0.7
   - ListTree ==0.2.3
   - literatex ==0.1.0.2
···
   - lz4-frame-conduit ==0.1.0.1
   - lzma ==0.0.0.3
   - lzma-clib ==5.2.2
-  - lzma-conduit ==1.2.1
+  - lzma-conduit ==1.2.2
   - machines ==0.7.2
   - machines-binary ==7.0.0.0
   - magic ==1.1
···
   - mock-time ==0.1.0
   - mod ==0.1.2.2
   - model ==0.5
-  - modern-uri ==0.3.4.1
+  - modern-uri ==0.3.4.2
   - modular ==0.1.0.8
   - monad-chronicle ==1.0.0.1
   - monad-control ==1.0.3.1
···
   - mongoDB ==2.7.1.1
   - monoid-subclasses ==1.1.1
   - monoid-transformer ==0.0.4
-  - mono-traversable ==1.0.15.1
+  - mono-traversable ==1.0.15.3
   - mono-traversable-instances ==0.1.1.0
   - mono-traversable-keys ==0.1.0
   - more-containers ==0.2.2.2
···
   - pathtype ==0.8.1.1
   - pathwalk ==0.3.1.2
   - pattern-arrows ==0.0.2
-  - pava ==0.1.1.1
+  - pava ==0.1.1.2
   - pcg-random ==0.1.3.7
   - pcre2 ==1.1.5
   - pcre-heavy ==1.0.0.2
···
   - pretty-class ==1.0.1.1
   - pretty-diff ==0.4.0.3
   - pretty-hex ==1.1
-  - prettyprinter ==1.7.0
-  - prettyprinter-ansi-terminal ==1.1.2
+  - prettyprinter ==1.7.1
+  - prettyprinter-ansi-terminal ==1.1.3
   - prettyprinter-compat-annotated-wl-pprint ==1.1
-  - prettyprinter-compat-ansi-wl-pprint ==1.0.1
-  - prettyprinter-compat-wl-pprint ==1.0.0.1
-  - prettyprinter-convert-ansi-wl-pprint ==1.1.1
+  - prettyprinter-compat-ansi-wl-pprint ==1.0.2
+  - prettyprinter-compat-wl-pprint ==1.0.1
+  - prettyprinter-convert-ansi-wl-pprint ==1.1.2
   - pretty-relative-time ==0.2.0.0
   - pretty-show ==1.10
   - pretty-simple ==4.0.0.0
···
   - Ranged-sets ==0.4.0
   - range-set-list ==0.1.3.1
   - rank1dynamic ==0.4.1
-  - rank2classes ==1.4.2
+  - rank2classes ==1.4.3
   - Rasterific ==0.7.5.4
   - rasterific-svg ==0.3.3.2
   - ratel ==1.0.15
···
   - regex-compat ==0.95.2.1
   - regex-compat-tdfa ==0.95.1.4
   - regex-pcre ==0.95.0.0
-  - regex-pcre-builtin ==0.95.2.3.8.43
+  - regex-pcre-builtin ==0.95.2.3.8.44
   - regex-posix ==0.96.0.1
   - regex-posix-clib ==2.7
   - regex-tdfa ==1.3.1.1
···
   - set-cover ==0.1.1
   - setenv ==0.1.1.3
   - setlocale ==1.0.0.10
-  - sexp-grammar ==2.3.1
+  - sexp-grammar ==2.3.2
   - SHA ==1.6.4.4
   - shake ==0.19.6
   - shake-language-c ==0.12.0
···
   - skylighting-core ==0.10.5.2
   - slack-api ==0.12
   - slack-progressbar ==0.1.0.1
-  - slick ==1.1.1.0
+  - slick ==1.1.2.2
   - slist ==0.2.0.0
   - slynx ==0.5.1.1
   - smallcheck ==1.2.1
···
   - tasty-program ==1.0.5
   - tasty-quickcheck ==0.10.1.2
   - tasty-rerun ==1.1.18
-  - tasty-silver ==3.2.2
+  - tasty-silver ==3.2.3
   - tasty-smallcheck ==0.8.2
   - tasty-test-reporter ==0.1.1.4
   - tasty-th ==0.1.7
···
   - texmath ==0.12.3.1
   - text-ansi ==0.1.1
   - text-binary ==0.2.1.1
-  - text-builder ==0.6.6.2
+  - text-builder ==0.6.6.3
   - text-conversions ==0.3.1
   - text-format ==0.3.2
   - text-icu ==0.7.1.0
···
   - vault ==0.3.1.5
   - vcs-ignore ==0.0.1.0
   - vec ==0.4
-  - vector ==0.12.3.0
+  - vector ==0.12.3.1
   - vector-algorithms ==0.8.0.4
   - vector-binary-instances ==0.2.5.2
   - vector-buffer ==0.4.1
···
   - xmonad-extras ==0.15.3
   - xss-sanitize ==0.3.6
   - xxhash-ffi ==0.2.0.0
-  - yaml ==0.11.5.0
+  - yaml ==0.11.6.0
   - yamlparse-applicative ==0.2.0.0
   - yesod ==1.6.1.2
   - yesod-auth ==1.6.10.4

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···
  - atuin
  - audiovisual
  - aura
- - aura_3_2_6
  - authoring
  - autonix-deps-kf5
  - avers

pkgs/development/haskell-modules/configuration-nix.nix

···
   # Runtime dependencies and CLI completion
   nvfetcher = generateOptparseApplicativeCompletion "nvfetcher" (overrideCabal
     super.nvfetcher (drv: {
+      # test needs network
+      doCheck = false;
       buildTools = drv.buildTools or [ ] ++ [ pkgs.buildPackages.makeWrapper ];
       postInstall = drv.postInstall or "" + ''
         wrapProgram "$out/bin/nvfetcher" --prefix 'PATH' ':' "${

pkgs/development/haskell-modules/hackage-packages.nix

···
      }:
      mkDerivation {
        pname = "Frames-streamly";
-       version = "0.1.1.1";
-       sha256 = "05al2v7wivvpwxq0gxypbm30ch4ssxmxw1wl4k9az3dqfvr0xgal";
+       version = "0.1.2.0";
+       sha256 = "1jsdbbpiclj5f8m6rnlpf43la5s2jirdllsdl41kmi6mwid7adj0";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base exceptions Frames primitive relude streamly strict text vinyl
···
      }) {};
 
   "HMock" = callPackage
-    ({ mkDerivation, array, base, constraints, containers, data-default
+    ({ mkDerivation, base, constraints, containers, data-default
      , deepseq, directory, doctest-exitcode-stdio, doctest-lib
-     , exceptions, extra, hspec, monad-control, mono-traversable, mtl
-     , QuickCheck, regex-tdfa, stm, syb, template-haskell
-     , transformers-base, unliftio
+     , exceptions, explainable-predicates, extra, hspec, monad-control
+     , mtl, QuickCheck, stm, syb, template-haskell, transformers-base
+     , unliftio
      }:
      mkDerivation {
        pname = "HMock";
-       version = "0.4.0.0";
-       sha256 = "1xkb4qyccpp5iws0jysgmcypbcab8yig6hnc756890z1dz5d1vy5";
+       version = "0.5.0.0";
+       sha256 = "0ib5cqwqqpyc58vg5h57410pq8ycr0y3ayck1pc6vq958m879v0r";
        libraryHaskellDepends = [
-         array base constraints containers data-default exceptions extra
-         monad-control mono-traversable mtl regex-tdfa stm syb
+         base constraints containers data-default exceptions
+         explainable-predicates extra monad-control mtl stm syb
          template-haskell transformers-base unliftio
        ];
        testHaskellDepends = [
          base containers data-default deepseq directory
-         doctest-exitcode-stdio doctest-lib exceptions extra hspec mtl
-         QuickCheck syb template-haskell unliftio
+         doctest-exitcode-stdio doctest-lib exceptions
+         explainable-predicates extra hspec mtl QuickCheck syb
+         template-haskell unliftio
        ];
        description = "A flexible mock framework for testing effectful code";
        license = lib.licenses.bsd3;
···
        executableHaskellDepends = [ base directory polyparse pretty ];
        description = "Utilities for manipulating XML documents";
        license = "LGPL";
+     }) {};
+
+  "HaXml_1_25_6" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , polyparse, pretty, random
+     }:
+     mkDerivation {
+       pname = "HaXml";
+       version = "1.25.6";
+       sha256 = "13idysjh6bqkcgzg0rbgd1cm6knapzbkf44rsnyvrfd0r8kja8gr";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers filepath polyparse pretty random
+       ];
+       executableHaskellDepends = [ base directory polyparse pretty ];
+       description = "Utilities for manipulating XML documents";
+       license = "LGPL";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Hach" = callPackage
···
        license = lib.licenses.publicDomain;
      }) {inherit (pkgs) openssl;};
 
+  "HsOpenSSL_0_11_7_2" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
+     mkDerivation {
+       pname = "HsOpenSSL";
+       version = "0.11.7.2";
+       sha256 = "0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring network time ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [ base bytestring ];
+       description = "Partial OpenSSL binding for Haskell";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) openssl;};
+
   "HsOpenSSL-x509-system" = callPackage
     ({ mkDerivation, base, bytestring, HsOpenSSL, unix }:
      mkDerivation {
···
 
   "Jikka" = callPackage
     ({ mkDerivation, alex, ansi-terminal, array, base, containers
-     , deepseq, directory, doctest, happy, hlint, hspec, hspec-discover
-     , mtl, ormolu, template-haskell, text, transformers, vector
+     , deepseq, directory, doctest, happy, hspec, hspec-discover, mtl
+     , template-haskell, text, transformers, vector
      }:
      mkDerivation {
        pname = "Jikka";
-       version = "5.5.0.0";
-       sha256 = "0z1000arwm0m6kl4nhwwq0iy1xwk1aml5q1lxrdsrhqq840q3x65";
+       version = "5.6.0.0";
+       sha256 = "18if2ghs642yvwqnblkhwd8ah32gdnpg53v5hjmqz4k4gr589bsg";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          template-haskell text transformers vector
        ];
        testHaskellDepends = [
-         ansi-terminal array base containers deepseq directory doctest hlint
-         hspec mtl ormolu template-haskell text transformers vector
+         ansi-terminal array base containers deepseq directory doctest hspec
+         mtl template-haskell text transformers vector
        ];
        testToolDepends = [ hspec-discover ];
        description = "A transpiler from Python to C++ for competitive programming";
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "ValveValueKeyvalue" = callPackage
+    ({ mkDerivation, base, parsec }:
+     mkDerivation {
+       pname = "ValveValueKeyvalue";
+       version = "1.0.1.0";
+       sha256 = "05m75nhsz1a2zb59lkdmkv7wznljhr76k7qm2pia37dj8h5zywcy";
+       libraryHaskellDepends = [ base parsec ];
+       description = "A Valve Value-keyvalue parser for Haskell made with Parsec";
+       license = lib.licenses.mit;
      }) {};
 
   "Vec" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii_1_1_1_0" = callPackage
+    ({ mkDerivation, ascii-case, ascii-char, ascii-group
+     , ascii-predicates, ascii-superset, ascii-th, base, bytestring
+     , text
+     }:
+     mkDerivation {
+       pname = "ascii";
+       version = "1.1.1.0";
+       sha256 = "11a2hwjz439damkjcx3ybbwjnvhdrhwxw78203vgydym4v1k2hrn";
+       libraryHaskellDepends = [
+         ascii-case ascii-char ascii-group ascii-predicates ascii-superset
+         ascii-th base bytestring text
+       ];
+       testHaskellDepends = [ base text ];
+       description = "The ASCII character set and encoding";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-art-to-unicode" = callPackage
     ({ mkDerivation, base, comonad, doctest, strict }:
      mkDerivation {
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-case_1_0_0_6" = callPackage
+    ({ mkDerivation, ascii-char, base, hashable }:
+     mkDerivation {
+       pname = "ascii-case";
+       version = "1.0.0.6";
+       sha256 = "1hsgid4c5w0b2bfgpsgbw21vxxflyg0imlcjqaaixnjzxzal2d6x";
+       libraryHaskellDepends = [ ascii-char base hashable ];
+       testHaskellDepends = [ ascii-char base ];
+       description = "ASCII letter case";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-char" = callPackage
     ({ mkDerivation, base, hashable }:
      mkDerivation {
···
        libraryHaskellDepends = [ base hashable ];
        description = "A Char type representing an ASCII character";
        license = lib.licenses.asl20;
+     }) {};
+
+  "ascii-char_1_0_0_10" = callPackage
+    ({ mkDerivation, base, hashable }:
+     mkDerivation {
+       pname = "ascii-char";
+       version = "1.0.0.10";
+       sha256 = "027pskgzrvyfgl1rw2rp17by5m8ak4v17hl590fflr2qc2wqcm5s";
+       libraryHaskellDepends = [ base hashable ];
+       testHaskellDepends = [ base ];
+       description = "A Char type representing an ASCII character";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-cows" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-group_1_0_0_6" = callPackage
+    ({ mkDerivation, ascii-char, base, hashable }:
+     mkDerivation {
+       pname = "ascii-group";
+       version = "1.0.0.6";
+       sha256 = "00qgs30jwxcrqjldzpd306yzhhjmrg9hfb4y4077shm7nqf75scv";
+       libraryHaskellDepends = [ ascii-char base hashable ];
+       testHaskellDepends = [ ascii-char base ];
+       description = "ASCII character groups";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-holidays" = callPackage
     ({ mkDerivation, base, random, random-shuffle, terminfo, time }:
      mkDerivation {
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-predicates_1_0_0_6" = callPackage
+    ({ mkDerivation, ascii-char, base }:
+     mkDerivation {
+       pname = "ascii-predicates";
+       version = "1.0.0.6";
+       sha256 = "19f8s5jb6yswa1a0wl4npvljs2pkyrpznxnim6563pn4gh60b945";
+       libraryHaskellDepends = [ ascii-char base ];
+       testHaskellDepends = [ ascii-char base ];
+       description = "Various categorizations of ASCII characters";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-progress" = callPackage
     ({ mkDerivation, async, base, concurrent-output, data-default
      , hspec, QuickCheck, time
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-superset_1_0_1_6" = callPackage
+    ({ mkDerivation, ascii-char, base, bytestring, hashable, text }:
+     mkDerivation {
+       pname = "ascii-superset";
+       version = "1.0.1.6";
+       sha256 = "06byxk5czii1i1hrm5m41g7ihccyykp9594406f260zhzrxrxll3";
+       libraryHaskellDepends = [
+         ascii-char base bytestring hashable text
+       ];
+       testHaskellDepends = [ ascii-char base text ];
+       description = "Representing ASCII with refined supersets";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-table" = callPackage
     ({ mkDerivation, aeson, base, containers, dlist, hashable, text
      , unordered-containers, vector, wl-pprint-extras
···
        ];
        description = "Template Haskell support for ASCII";
        license = lib.licenses.asl20;
+     }) {};
+
+  "ascii-th_1_0_0_6" = callPackage
+    ({ mkDerivation, ascii-char, ascii-superset, base, bytestring
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "ascii-th";
+       version = "1.0.0.6";
+       sha256 = "06yhb1mb67i4cxnh0zjrklykxm8p76q0m7dyslv7w1cngs8mzdm5";
+       libraryHaskellDepends = [
+         ascii-char ascii-superset base template-haskell
+       ];
+       testHaskellDepends = [
+         ascii-char ascii-superset base bytestring text
+       ];
+       description = "Template Haskell support for ASCII";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-vector-avc" = callPackage
···
      }:
      mkDerivation {
        pname = "aura";
-       version = "3.2.5";
-       sha256 = "1zrsjcvmhh3y0pahnz2fr944j2xz8sv4dcd9xz08vci4x1lm87hr";
-       revision = "1";
-       editedCabalFile = "0rmihjl4ysw36fpj4g5zkdhzvq8c0n0vxv4zlcmn35q37k85qpb6";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson algebraic-graphs aur base bytestring containers filepath
-         hashable http-client http-types language-bash megaparsec
-         network-uri prettyprinter prettyprinter-ansi-terminal rio scheduler
-         stm text time transformers typed-process versions
-       ];
-       executableHaskellDepends = [
-         aeson aur base bytestring containers http-client http-client-tls
-         megaparsec optparse-applicative prettyprinter
-         prettyprinter-ansi-terminal rio scheduler text transformers
-         typed-process versions
-       ];
-       testHaskellDepends = [
-         base bytestring containers megaparsec rio tasty tasty-hunit text
-         versions
-       ];
-       description = "A secure package manager for Arch Linux and the AUR";
-       license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "aura_3_2_6" = callPackage
-    ({ mkDerivation, aeson, algebraic-graphs, aur, base, bytestring
-     , containers, filepath, hashable, http-client, http-client-tls
-     , http-types, language-bash, megaparsec, network-uri
-     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
-     , rio, scheduler, stm, tasty, tasty-hunit, text, time, transformers
-     , typed-process, versions
-     }:
-     mkDerivation {
-       pname = "aura";
        version = "3.2.6";
        sha256 = "07sry2nf41f101ldcfcf2x5pp0w7qvlvl6m4j5bbkvxp3rmsjbx2";
        isLibrary = true;
···
        pname = "blaze-colonnade";
        version = "1.2.2.1";
        sha256 = "1wh0q72qv2s6a42i13lqb94i0b5bgmqwqw7d5xy89dc76j0ncd2d";
-       revision = "1";
-       editedCabalFile = "0b8imj6i3map53b3j9i7rz9wc65s10qd4hndpq6nik2xd6shdip3";
+       revision = "2";
+       editedCabalFile = "08baclp16z9qrvmd8qcf0nn98g735xr7la9kxs36w03b6vq02xmj";
        libraryHaskellDepends = [
          base blaze-html blaze-markup colonnade profunctors text
        ];
···
      }:
      mkDerivation {
        pname = "byte-count-reader";
-       version = "0.10.1.5";
-       sha256 = "0iq40gnfw8z1rkri1rpaqx5av1ay45h6518cg0a0m4ypdzf03r0s";
-       libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
-       testHaskellDepends = [
-         base extra hspec parsec parsec-numbers text
-       ];
-       description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";
-       license = lib.licenses.gpl3Only;
-     }) {};
-
-  "byte-count-reader_0_10_1_6" = callPackage
-    ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text
-     }:
-     mkDerivation {
-       pname = "byte-count-reader";
        version = "0.10.1.6";
        sha256 = "182pc1fx74zfcrvp1g3ghqw3rhc9pcjkxy92n66pg0zm8yk8xqly";
        libraryHaskellDepends = [ base extra parsec parsec-numbers text ];
···
        ];
        description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";
        license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "byte-order" = callPackage
···
      }:
      mkDerivation {
        pname = "cabal-clean";
-       version = "0.1.20210815";
-       sha256 = "0bx11grnw1x594n6si3lnswb87n2gsnn7fn7lr1ggn3rd0dm2ccg";
+       version = "0.1.20210924";
+       sha256 = "11r46rfncgp8gmvvsfp64krdnp0q4rykrhv5z2gwrxyv5sjkfpyz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "calamity";
-       version = "0.1.30.4";
-       sha256 = "038df356by37c1wj5i0a31hihxad44bbks1fb6xbx2abzp3343ji";
+       pname = "iproute";
+       sha256 = "1yk0b54m243vz4kiqw70w2hc1p6zz4z0z852slgwp3455q02qy18";
        libraryHaskellDepends = [
          aeson async base bytestring calamity-commands colour
          concurrent-extra connection containers data-default-class
···
      }:
      mkDerivation {
        pname = "camfort";
-       version = "1.1.0";
-       sha256 = "0y6ds8lhhs0r4ns35y6zrph3bjkq9kdx4zp7kb8knsn0cpd3haz1";
+       version = "1.1.1";
+       sha256 = "173k5mf2w4ba553j8qh5biljw3xhrk0qipix72cx8xd0vadkh62f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Candid integration";
        license = lib.licenses.asl20;
+       maintainers = with lib.maintainers; [ nomeata ];
      }) {};
 
   "canon" = callPackage
···
      }:
      mkDerivation {
        pname = "circular";
-       version = "0.4.0.0";
-       sha256 = "1542z19mf0ck3x8n62slw88rbmqy8dgwjlsz145a0i8lb8f79kn1";
-       libraryHaskellDepends = [ aeson base primitive vector ];
-       testHaskellDepends = [
-         aeson base hspec primitive QuickCheck quickcheck-instances vector
-       ];
-       benchmarkHaskellDepends = [ base criterion vector ];
-       description = "Circular fixed-sized mutable vectors";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ dschrempf ];
-     }) {};
-
-  "circular_0_4_0_1" = callPackage
-    ({ mkDerivation, aeson, base, criterion, hspec, primitive
-     , QuickCheck, quickcheck-instances, vector
-     }:
-     mkDerivation {
-       pname = "circular";
        version = "0.4.0.1";
        sha256 = "03j06zf2fshcf59df088i47s4nx89arggv9h96izbpi0rz4m0fmk";
        libraryHaskellDepends = [ aeson base primitive vector ];
···
        benchmarkHaskellDepends = [ base criterion vector ];
        description = "Circular fixed-sized mutable vectors";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
···
 
   "clash-shake" = callPackage
     ({ mkDerivation, aeson, base, bytestring, clash-ghc, clash-lib
-     , clash-prelude, directory, ghc-typelits-extra
-     , ghc-typelits-knownnat, ghc-typelits-natnormalise, shake, split
-     , stache, text, unordered-containers
+     , clash-prelude, directory, shake, split, stache, text
+     , unordered-containers
      }:
      mkDerivation {
        pname = "clash-shake";
-       version = "0.1.0";
-       sha256 = "0zjlbi8p0wxaxgfxhljbp9vzhki3ll8g1qqv3gghqkh7cym73kgq";
+       version = "0.1.1";
+       sha256 = "09c13rfsbb7r5fa214143a4nafkbz2slcb999hpj5wvl2882k1ry";
        libraryHaskellDepends = [
          aeson base bytestring clash-ghc clash-lib clash-prelude directory
-         ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
          shake split stache text unordered-containers
        ];
        description = "Shake rules for building Clash programs";
···
      }:
      mkDerivation {
        pname = "code-conjure";
-       version = "0.4.4";
-       sha256 = "155jkrdklwh65aqvg138yhysjpxcj9d6l77h54z2q338iak9fbvs";
+       version = "0.5.0";
+       sha256 = "0vby6br1hg4v2yvp835p1wf32jmp431zqxkgglnd4f1by09vbx7m";
        libraryHaskellDepends = [
          base express leancheck speculate template-haskell
        ];
        testHaskellDepends = [ base express leancheck speculate ];
-       description = "conjure Haskell functions out of partial definitions";
+       description = "synthesize Haskell functions out of partial definitions";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        pname = "colonnade";
        version = "1.2.0.2";
        sha256 = "1asjx71gp26a15v7g3p8bfddb5nnzky6672c35xx35hq73mhykr4";
-       revision = "1";
-       editedCabalFile = "1aq72ri6labv8vsf6s3h8mkry4kiig9659lgdmrqr8ngyp7jwp69";
+       revision = "2";
+       editedCabalFile = "0ps86y9vlai49qx3rxzmxy6dzxwhnz6sr7ndyzrp4w7qwhgkmd70";
        libraryHaskellDepends = [
          base bytestring contravariant profunctors semigroups text vector
        ];
···
      }:
      mkDerivation {
        pname = "conduit";
-       version = "1.3.4.1";
-       sha256 = "1w96q9nqxvl1s9js1rrzy9x711jpkj8mm6s5nz67jmrdby6knx45";
+       version = "1.3.4.2";
+       sha256 = "15r1rw5sp09zxjlfvjwpjva1pnn4my4gc28kxpd51kf74wpq7f9c";
        libraryHaskellDepends = [
          base bytestring directory exceptions filepath mono-traversable mtl
          primitive resourcet text transformers unix unliftio-core vector
···
        pname = "dhall";
        version = "1.40.1";
        sha256 = "0m2fw9ak9l6fz8ylpbi0cdihf2j66jlnd5j3vf56r7wlqgbkxhi1";
+       revision = "2";
+       editedCabalFile = "0vywq222wyy8rs4114d0pq70yji7xh440i0ilqbmfywjfj2gm1pj";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-csv";
        version = "1.0.0";
        sha256 = "1dg310mq4c00ykkm1vsvrcicls25zbx7iypcg0nqa8ggchac5jmh";
+       revision = "1";
+       editedCabalFile = "06mya0h8kw8609chxrbkq24gi7yk3fviz2q6balyv5gp3wivzzvg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-docs";
        version = "1.0.7";
        sha256 = "1h7bzpp3xa5m8zknhi24q0wh1n6w6z26ka780mdsbmchhhj59njm";
+       revision = "2";
+       editedCabalFile = "19mn12l8qljrf41n0xs58hqi89xaaab4wp6dldvi7pym276zg7pn";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-lsp-server";
        version = "1.0.16";
        sha256 = "04s4kvbjp4ai17l64syram0br3qc4fpz669ps24r8fkcbbaczckq";
+       revision = "1";
+       editedCabalFile = "1xhi855rcfm38p5wb8zk51m10m4afpxaglmhrinm4h2awawfvzpz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-nixpkgs";
        version = "1.0.6";
        sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";
+       revision = "1";
+       editedCabalFile = "0xy1g9ab355mdkcq30z091rr33sfw98jqjldmawrcq0yxb2gb2s6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "dhall-openapi";
        version = "1.0.2";
        sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";
+       revision = "1";
+       editedCabalFile = "1mbl9ximmblz1cdm07sk8lwsxdxknhlipx91amd155xpqs72i8jg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dirichlet";
-       version = "0.1.0.4";
-       sha256 = "1qhkqcdzdryzds5zb9y55ckd35wij39yk2k58s7fdacnash9l3fg";
-       libraryHaskellDepends = [
-         base log-domain math-functions mwc-random primitive vector
-       ];
-       testHaskellDepends = [ base hspec log-domain mwc-random vector ];
-       description = "Multivariate Dirichlet distribution";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ dschrempf ];
-     }) {};
-
-  "dirichlet_0_1_0_5" = callPackage
-    ({ mkDerivation, base, hspec, log-domain, math-functions
-     , mwc-random, primitive, vector
-     }:
-     mkDerivation {
-       pname = "dirichlet";
        version = "0.1.0.5";
        sha256 = "1ibp7cvbi86m2m0kb1pzxmnb68awhbkayms7gffx3nqli6yb1fi9";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hspec log-domain mwc-random vector ];
        description = "Multivariate Dirichlet distribution";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
···
 
   "docopt" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers
-     , HUnit, parsec, split, template-haskell, text, th-lift
+     , HUnit, parsec, split, template-haskell, text
      }:
      mkDerivation {
        pname = "docopt";
-       version = "0.7.0.6";
-       sha256 = "0gkj3bh74kbwk62zdr18lbd1544yi22w067xl8w35y8bdflkq7in";
+       version = "0.7.0.7";
+       sha256 = "0q3f9j7yqyb97z08h2k6p6bax87g6ab96ng4cpj1xf5k91726ic1";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base containers parsec template-haskell th-lift
+         base containers parsec template-haskell
        ];
        testHaskellDepends = [
          aeson ansi-terminal base bytestring containers HUnit parsec split
-         template-haskell text th-lift
+         template-haskell text
        ];
        description = "A command-line interface parser that will make you smile";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "exiftool";
-       version = "0.1.1.0";
-       sha256 = "1z0zk9axilxp3l13n0h83csia4lvahmqkwhlfp9mswbdy8v8fqm0";
+       version = "0.2.0.0";
+       sha256 = "138d25fxqz3vg62mfgmva52flyzjxd8dxr0kc7ayfil1zk3bp4jg";
        libraryHaskellDepends = [
          aeson base base64 bytestring hashable process scientific
          string-conversions temporary text unordered-containers vector
···
 
   "explainable-predicates" = callPackage
     ({ mkDerivation, array, base, doctest-exitcode-stdio, doctest-lib
-     , hspec, mono-traversable, regex-tdfa, syb, template-haskell
+     , hspec, HUnit, mono-traversable, QuickCheck, regex-tdfa, syb
+     , template-haskell
      }:
      mkDerivation {
        pname = "explainable-predicates";
-       version = "0.1.0.0";
-       sha256 = "18rw0vb61pvysywqhdl4rwpc38h37g2fgj11abd9gxm44cy04plg";
+       version = "0.1.2.0";
+       sha256 = "02gcbg3fas0kk13hm8g79dj62nxs1gdxsf58kx35vm58c5i8jay2";
        libraryHaskellDepends = [
-         array base mono-traversable regex-tdfa syb template-haskell
+         array base HUnit mono-traversable QuickCheck regex-tdfa syb
+         template-haskell
        ];
        testHaskellDepends = [
          base doctest-exitcode-stdio doctest-lib hspec
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "express_1_0_6" = callPackage
+  "express_1_0_8" = callPackage
     ({ mkDerivation, base, leancheck, template-haskell }:
      mkDerivation {
        pname = "express";
-       version = "1.0.6";
-       sha256 = "0zkjd3xv2vskj2slyvvxhakcqxygklbcigsrgrlrvg6d3sgx1wy9";
+       version = "1.0.8";
+       sha256 = "1hkcrzbqn54sx907zh28sg659f46yip6dvgjaywdjpk8hbvqfzs2";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base leancheck ];
        benchmarkHaskellDepends = [ base leancheck ];
···
      }:
      mkDerivation {
        pname = "focus";
-       version = "1.0.2";
-       sha256 = "09d85g6knv3wcn8ib5mpbpjn9xw1pbl3a6qlfy1lrzypv9lrv0ld";
+       version = "1.0.3";
+       sha256 = "03h6gq0k5z9a7nar29qijfnd4gwxd8h16dfsig74bsdzazj50c1m";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          QuickCheck quickcheck-instances rerebase tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "ftdi";
-       version = "0.3.0.1";
-       sha256 = "0xa1dld03ai3mxqywia3f9pvyz67slw7dai8m97iqg1xysd8ykzr";
+       version = "0.3.0.2";
+       sha256 = "0ybx59gs54nk5swh8c2yzcn7mxsm02qp7rwaj51y38p4yzajcw9x";
        libraryHaskellDepends = [
          async base base-unicode-symbols bytestring transformers usb vector
        ];
···
      , directory, directory-tree, dlist, file-embed, filepath, free
      , futhark-data, futhark-server, githash, half, happy, haskeline
      , language-c-quote, mainland-pretty, megaparsec, mtl
-     , neat-interpolation, parallel, parser-combinators, pcg-random
-     , process, process-extras, QuickCheck, regex-tdfa, srcloc, tasty
+     , neat-interpolation, parallel, parser-combinators, process
+     , process-extras, QuickCheck, random, regex-tdfa, srcloc, tasty
      , tasty-hunit, tasty-quickcheck, template-haskell, temporary
      , terminal-size, text, time, transformers, unordered-containers
      , vector, vector-binary-instances, versions, zip-archive, zlib
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.20.2";
-       sha256 = "0nn0ndnzabkgcpdwhim51ji6mm95ky48f8vybch4dvvwsm3ld10b";
+       version = "0.20.3";
+       sha256 = "1qz8grvf8zyn549zch6d3dkhzq8dmgqigf3q62141l1q7qa3b75q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          cryptohash-md5 directory directory-tree dlist file-embed filepath
          free futhark-data futhark-server githash half haskeline
          language-c-quote mainland-pretty megaparsec mtl neat-interpolation
-         parallel pcg-random process process-extras regex-tdfa srcloc
+         parallel process process-extras random regex-tdfa srcloc
          template-haskell temporary terminal-size text time transformers
          unordered-containers vector vector-binary-instances versions
          zip-archive zlib
···
     ({ mkDerivation, base, HUnit, monoid-subclasses }:
      mkDerivation {
        pname = "fuzzy";
-       version = "0.1.0.0";
-       sha256 = "1jz9arrg33x64ygipk0115b7jfchxh20cy14177iwg0na8mpl2l2";
+       version = "0.1.0.1";
+       sha256 = "16pl4ba9f3wlx69pg8va1c2qg4zb9c0w50d7f6d84x9b5ysaza5w";
        libraryHaskellDepends = [ base monoid-subclasses ];
        testHaskellDepends = [ base HUnit ];
        description = "Filters a list based on a fuzzy string search";
···
      }:
      mkDerivation {
        pname = "ghc-vis";
-       version = "0.9.2";
-       sha256 = "1i7sx0ffbgfskhj27wnh9f8qldf4fqxmshlmqvajsrg9n5v5i772";
+       version = "0.9.3";
+       sha256 = "08144lfp3amgi5i6qfbpi0gqv39q34q4v9ykzl00pbc1l1zxnspg";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal filepath ];
        libraryHaskellDepends = [
···
      , ghc-trace-events, ghc-typelits-knownnat, gitrev, Glob
      , haddock-library, hashable, heapsize, hie-bios, hie-compat, hiedb
      , hls-graph, hls-plugin-api, hp2pretty, hslogger, implicit-hie
-     , implicit-hie-cradle, lens, lsp, lsp-test, lsp-types, mtl
-     , network-uri, opentelemetry, optparse-applicative, parallel
-     , prettyprinter, prettyprinter-ansi-terminal, process, QuickCheck
+     , implicit-hie-cradle, lens, lsp, lsp-test, lsp-types
+     , monoid-subclasses, mtl, network-uri, opentelemetry
+     , optparse-applicative, parallel, prettyprinter
+     , prettyprinter-ansi-terminal, process, QuickCheck
      , quickcheck-instances, record-dot-preprocessor, record-hasfield
      , regex-tdfa, retrie, rope-utf16-splay, safe, safe-exceptions
      , shake, shake-bench, sorted-list, sqlite-simple, stm, syb, tasty
      , tasty-expected-failure, tasty-hunit, tasty-quickcheck
      , tasty-rerun, text, time, transformers, unix, unliftio
-     , unliftio-core, unordered-containers, utf8-string, vector, yaml
+     , unliftio-core, unordered-containers, utf8-string, vector
+     , vector-algorithms, yaml
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "1.4.2.0";
-       sha256 = "1hkh6j95rmsk2g9m2x7qr4w9ckhr7w1rg6di6h5dwqi9pryfbfny";
+       version = "1.4.2.2";
+       sha256 = "0vs4np7ylvc6cvrfxvp6dvwir9wk2yhhm5if75ij658hgl1bg66k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          ghc-api-compat ghc-boot ghc-boot-th ghc-check ghc-exactprint
          ghc-paths ghc-trace-events Glob haddock-library hashable heapsize
          hie-bios hie-compat hiedb hls-graph hls-plugin-api hslogger
-         implicit-hie-cradle lens lsp lsp-types mtl network-uri
-         opentelemetry optparse-applicative parallel prettyprinter
-         prettyprinter-ansi-terminal regex-tdfa retrie rope-utf16-splay safe
-         safe-exceptions sorted-list sqlite-simple stm syb text time
-         transformers unix unliftio unliftio-core unordered-containers
-         utf8-string vector
+         implicit-hie-cradle lens lsp lsp-types monoid-subclasses mtl
+         network-uri opentelemetry optparse-applicative parallel
+         prettyprinter prettyprinter-ansi-terminal regex-tdfa retrie
+         rope-utf16-splay safe safe-exceptions sorted-list sqlite-simple stm
+         syb text time transformers unix unliftio unliftio-core
+         unordered-containers utf8-string vector vector-algorithms
        ];
        executableHaskellDepends = [
          aeson base bytestring containers data-default directory extra
···
      }:
      mkDerivation {
        pname = "githash";
-       version = "0.1.6.1";
-       sha256 = "0g922g2l3xv795gvhri5ccrh751dnyckjs7mzv1d8pg2lffpj0bi";
-       libraryHaskellDepends = [
-         base bytestring directory filepath process template-haskell
-         th-compat
-       ];
-       testHaskellDepends = [
-         base bytestring directory filepath hspec process template-haskell
-         temporary th-compat unliftio
-       ];
-       description = "Compile git revision info into Haskell projects";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "githash_0_1_6_2" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath, hspec
-     , process, template-haskell, temporary, th-compat, unliftio
-     }:
-     mkDerivation {
-       pname = "githash";
        version = "0.1.6.2";
        sha256 = "1vkwc7j71vdrxy01vlm6xfp16kam7m9bnj9y3h217fzhq5mjywhz";
        libraryHaskellDepends = [
···
        ];
        description = "Compile git revision info into Haskell projects";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "github" = callPackage
···
   "graphql" = callPackage
     ({ mkDerivation, aeson, base, conduit, containers, exceptions
      , hspec, hspec-expectations, hspec-megaparsec, megaparsec
-     , parser-combinators, QuickCheck, raw-strings-qq, scientific, text
-     , transformers, unordered-containers, vector
+     , parser-combinators, QuickCheck, scientific, template-haskell
+     , text, transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "graphql";
-       version = "1.0.0.0";
-       sha256 = "09r2a444l18pzy0952hkpl98vkmldi8j94hr6qf16xg5y9nic3nd";
+       version = "1.0.1.0";
+       sha256 = "1kfrfmmapq5sjh0gs9g3hgr4s3780ihvzqw94h7mzngq2ikviqgh";
        libraryHaskellDepends = [
          aeson base conduit containers exceptions hspec-expectations
-         megaparsec parser-combinators scientific text transformers
-         unordered-containers vector
+         megaparsec parser-combinators scientific template-haskell text
+         transformers unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base conduit exceptions hspec hspec-megaparsec megaparsec
-         QuickCheck raw-strings-qq scientific text unordered-containers
+         QuickCheck scientific text unordered-containers
        ];
        description = "Haskell GraphQL implementation";
        license = "MPL-2.0 AND BSD-3-Clause";
···
     ({ mkDerivation, base, bytestring, hakyll, typed-process }:
      mkDerivation {
        pname = "hakyll-process";
-       version = "0.0.2.0";
-       sha256 = "03s51ql10g6vjsrzwxa2jwff4wckp7vf3sg9r6hdsbh30l4720il";
+       version = "0.0.3.0";
+       sha256 = "1ci7sw9r73h06kdrhqqbs0sar91z56scns3xljq2rpzhcpf3ppms";
        libraryHaskellDepends = [ base bytestring hakyll typed-process ];
        description = "Hakyll compiler for arbitrary external processes";
        license = lib.licenses.bsd3;
···
        pname = "haskell-lsp";
        version = "0.24.0.0";
        sha256 = "0gw289wy91h0qv4filw3glw3rrjvmr5j591wrdiwc1bl3w56bpig";
+       revision = "1";
+       editedCabalFile = "0px7k5768rnxfqi9cf2g2f99kh2kwmyy2vkzszcp2kgxhb7qzcha";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "haskell-lsp-types";
        version = "0.24.0.0";
        sha256 = "1p7k2g2xs95ylsnnz2np0w8c7p5dzmlss41g0kzblaz5n3352kbn";
+       revision = "1";
+       editedCabalFile = "1wy26rv0zih8zgc4as5prf305qw2llcc1srx3rcnzfwlggkslsnr";
        libraryHaskellDepends = [
          aeson base binary bytestring data-default deepseq filepath hashable
          lens network-uri scientific text unordered-containers
···
      }:
      mkDerivation {
        pname = "hasql";
-       version = "1.4.5.1";
-       sha256 = "0y23qk29bq419rjdzpvlr6hkml8fzk3sgl7dzvkvjpdycrzphlzl";
-       libraryHaskellDepends = [
-         attoparsec base bytestring bytestring-strict-builder contravariant
-         dlist hashable hashtables mtl postgresql-binary postgresql-libpq
-         profunctors text text-builder transformers vector
-       ];
-       testHaskellDepends = [
-         contravariant-extras QuickCheck quickcheck-instances rerebase tasty
-         tasty-hunit tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [ gauge rerebase ];
-       description = "An efficient PostgreSQL driver with a flexible mapping API";
-       license = lib.licenses.mit;
-     }) {};
-
-  "hasql_1_4_5_2" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring
-     , bytestring-strict-builder, contravariant, contravariant-extras
-     , dlist, gauge, hashable, hashtables, mtl, postgresql-binary
-     , postgresql-libpq, profunctors, QuickCheck, quickcheck-instances
-     , rerebase, tasty, tasty-hunit, tasty-quickcheck, text
-     , text-builder, transformers, vector
-     }:
-     mkDerivation {
-       pname = "hasql";
        version = "1.4.5.2";
        sha256 = "0kliby1gigmy1z856wnnlrn70hacqj2350yypdxkm7sfh717n4rj";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ gauge rerebase ];
        description = "An efficient PostgreSQL driver with a flexible mapping API";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hasql-backend" = callPackage
···
        pname = "haxr";
        version = "3000.11.4.1";
        sha256 = "12f3acc253x88pk20b60z1qzyhbngvg7zzb9j6azbii0hx8yxxhy";
+       revision = "1";
+       editedCabalFile = "0k6nymfmsvblsi3gh8xwiq744w7ifigd3i91w3gz220n9a32j1ia";
        libraryHaskellDepends = [
          array base base-compat base64-bytestring blaze-builder bytestring
          HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-       pname = "iproute";
+  "hledger_1_23" = callPackage
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
+     , hledger-lib, lucid, math-functions, megaparsec, microlens, mtl
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+       version = "1.23";
+       sha256 = "0s7dbizgx6x6p5phn61ljnhjwm7alp3vgbakbd51m30asnzxm98b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
+         megaparsec microlens mtl process regex-tdfa safe shakespeare split
        pname = "iproute";
        pname = "iproute";
        ];
        executableHaskellDepends = [
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
+         haskeline hledger-lib math-functions megaparsec microlens mtl
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
···
        testHaskellDepends = [
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
+         haskeline hledger-lib math-functions megaparsec microlens mtl
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
···
        license = lib.licenses.bsd3;
      }) {};
 
-       pname = "iproute";
+  "hledger-iadd_1_3_16" = callPackage
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
···
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       revision = "1";
-       pname = "iproute";
+       version = "1.3.16";
+       sha256 = "09b8519s8f3ckh1ghcj8zn0s4dnagbpaf0hyinvmy5vjnjvnyf1f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-       pname = "iproute";
+  "hledger-interest_1_6_3" = callPackage
        pname = "iproute";
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+       version = "1.6.3";
+       sha256 = "1r8iydl66k2j7xv1b465alf3h8mqwjfz13ffwsd50h0kscxjmxhg";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-       pname = "iproute";
+  "hledger-lib_1_23" = callPackage
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-     , unordered-containers, utf8-string
+     , hashtables, megaparsec, microlens, microlens-th, mtl
+     , parser-combinators, pretty-simple, regex-tdfa, safe, tabular
+     , tasty, tasty-hunit, template-haskell, text, time, timeit
+     , transformers, uglymemo, unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+       version = "1.23";
+       sha256 = "182pa9f4paqbyrqqnn8vhgwys0sk9lrkvf972d9hbvr339iysm1c";
        libraryHaskellDepends = [
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
+         filepath Glob hashtables megaparsec microlens microlens-th mtl
+       pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
          unordered-containers utf8-string
        ];
        testHaskellDepends = [
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-         unordered-containers utf8-string
+         file-embed filepath Glob hashtables megaparsec microlens
+         microlens-th mtl parser-combinators pretty-simple regex-tdfa safe
+         tabular tasty tasty-hunit template-haskell text time timeit
+         transformers uglymemo unordered-containers utf8-string
        ];
        pname = "iproute";
        license = lib.licenses.gpl3Only;
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-       pname = "iproute";
+  "hledger-ui_1_23" = callPackage
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
···
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+       version = "1.23";
+       sha256 = "04wsp0jlrv5lmlaw38644q66mg8ga6l2ij32pqa585713zcx2frs";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
-       pname = "iproute";
-    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+  "hledger-web_1_23" = callPackage
+    ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
+     , bytestring, case-insensitive, clientsession, cmdargs, conduit
+     , conduit-extra, containers, data-default, Decimal, directory
+     , extra, filepath, hjsmin, hledger, hledger-lib, hspec, http-client
+     , http-conduit, http-types, megaparsec, mtl, network, shakespeare
        pname = "iproute";
        pname = "iproute";
        pname = "iproute";
···
      }:
      mkDerivation {
        pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+       version = "1.23";
+       sha256 = "0sphhmh43d2lifvx8xbvgdmfs0f8cd5zpnpzhv8dp6mzd72g44wi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
-       pname = "iproute";
+         aeson base base64 blaze-html blaze-markup bytestring
+         case-insensitive clientsession cmdargs conduit conduit-extra
+         containers data-default Decimal directory extra filepath hjsmin
+         hledger hledger-lib hspec http-client http-conduit http-types
+         megaparsec mtl network shakespeare template-haskell text time
+         transformers unix-compat unordered-containers utf8-string wai
+         wai-cors wai-extra wai-handler-launch warp yaml yesod yesod-core
+         yesod-form yesod-static yesod-test
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.9.1.2";
-       sha256 = "1dvyvsj5f5fpqs6jgqxhrf1dfq2nwb75rf797zkyy3m4a278d58q";
+       version = "1.9.2.0";
+       sha256 = "0agdii93xl6hn5a9szl2qazpjn2j6vwkcr2pg7jp5mdsswwkvd3l";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          aeson async base bytestring containers exceptions lifted-base
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.11.0.0";
-       sha256 = "0574ma8b149rhpdk9mdg5sawhl3db4d0qxs5az31g83i93hf4mwq";
-       revision = "2";
-       editedCabalFile = "1n98wpppwd0gwchwfis525qac3808j1vnvb3vxziq1d9x088gqf6";
+       version = "1.12.0.0";
+       sha256 = "0pxidphf0qzfy5zv1q7qhp49bgglf3pqd6r91qq0iawnvgzcyi7z";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra fields-json hpqtypes lifted-base log-base monad-control mtl
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "hspec-tmp-proc" = callPackage
+    ({ mkDerivation, base, hspec, tmp-proc }:
+     mkDerivation {
+       pname = "hspec-tmp-proc";
+       version = "0.5.0.0";
+       sha256 = "00w5rly9a4pkr3qmj3924md4nlkn55jwl8a4dnnmpzbinhz4mav1";
+       libraryHaskellDepends = [ base hspec tmp-proc ];
+       description = "Simplify use of tmp-proc from hspec tests";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "hspec-wai" = callPackage
     ({ mkDerivation, base, base-compat, bytestring, case-insensitive
      , hspec, hspec-core, hspec-expectations, http-types, QuickCheck
···
        description = "A Haskell98 parsing tags program similar to ctags";
        license = lib.licenses.bsd3;
      }) {};
+
+  "htalkat" = callPackage
+    ({ mkDerivation, array, asn1-encoding, asn1-types, base, bytestring
+     , containers, cryptonite, data-default-class, data-hash, directory
+     , exceptions, filelock, filepath, hourglass, hscurses, memory, mtl
+     , ncurses, network, network-simple, pem, process, rset, safe
+     , temporary, text, time, tls, transformers, unix, x509
+     , x509-validation
+     }:
+     mkDerivation {
+       pname = "htalkat";
+       version = "0.1.1";
+       sha256 = "0hczxal05wy42shmrjqw4mhqscr58b6jfv8vm2ll05smvwnrwxji";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         array asn1-encoding asn1-types base bytestring containers
+         cryptonite data-default-class data-hash directory exceptions
+         filelock filepath hourglass hscurses memory mtl network
+         network-simple pem process rset safe temporary text time tls
+         transformers unix x509 x509-validation
+       ];
+       executablePkgconfigDepends = [ ncurses ];
+       description = "Talk across TLS";
+       license = lib.licenses.gpl3Only;
+       pname = "iproute";
 
   "htar" = callPackage
     ({ mkDerivation, base, bytestring, bzlib, directory, filepath
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http3" = callPackage
+    ({ mkDerivation, array, attoparsec, base, base16-bytestring
+     , bytestring, case-insensitive, conduit, conduit-extra, containers
+     , cryptonite, doctest, hspec, hspec-discover, http-types, http2
+     , iproute, network, network-byte-order, quic, QuickCheck, sockaddr
+     , stm, time-manager, tls, unliftio
+     }:
+     mkDerivation {
+       pname = "http3";
+       version = "0.0.0";
+       sha256 = "12mkxhqhaxcmg2b8finpm5zlkzc614k004jzbacl6jrla3wvzmhw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring case-insensitive containers http-types http2
+         network network-byte-order quic sockaddr stm time-manager unliftio
+       ];
+       testHaskellDepends = [
+         attoparsec base base16-bytestring bytestring conduit conduit-extra
+         cryptonite doctest hspec http-types http2 iproute network quic
+         QuickCheck stm tls unliftio
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "HTTP/3 library";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "httpd-shed" = callPackage
     ({ mkDerivation, base, network, network-bsd, network-uri }:
      mkDerivation {
···
        pname = "invertible-grammar";
        version = "0.1.3";
        sha256 = "160hw7p5mpajwmv8fps2gicqj3x3yr9w239pfnv9i5gsf4irnn9n";
-       revision = "1";
-       editedCabalFile = "021pq45sz1x819yksgyl8p4h7c659gb99798j791a3r8583cz2za";
+       revision = "2";
+       editedCabalFile = "1fmw3v2g22n812ppba4yibgq1wlpfwkypsxa768calxafynb3i33";
        libraryHaskellDepends = [
          base bifunctors containers mtl prettyprinter profunctors semigroups
          tagged template-haskell text transformers
···
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.3.1";
-       sha256 = "0jf5wragwcqhal860s1i26dk32dmnhsyl4n85mr8sc8v626bkj76";
+       version = "1.3.2";
+       sha256 = "11gy8szp41l1y6mnvj6knb5lhlax859gri9j31w5lzhidj0045df";
        libraryHaskellDepends = [
          aeson base bytestring envy flow Glob http-media lens monad-logger
          network-ip regex-compat rio servant servant-client
···
        license = lib.licenses.asl20;
      }) {};
 
-  "jose_0_8_4_1" = callPackage
+  "jose_0_8_5" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , bytestring, concise, containers, cryptonite, hspec, lens, memory
      , monad-time, mtl, network-uri, pem, QuickCheck
···
      }:
      mkDerivation {
        pname = "jose";
-       version = "0.8.4.1";
-       sha256 = "0zwac71gqxf2wz840gfwnpv0ax7c4wpiwkcxqwcfil7fn4bqjlpw";
+       version = "0.8.5";
+       sha256 = "0d3dgm12bjdmb806599amrxqkq1rz9bs5rkp8smllvrqyxc1qn9h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "kempe";
-       version = "0.2.0.5";
-       sha256 = "185kz7ssbh0zmac1n015chhdch41driqvm6f0l71flf70kh6183a";
+       version = "0.2.0.6";
+       sha256 = "1qv867aks1vgcri7gsgim3852g7mnznarnsr97x1j3lx4qfkppnv";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , email-validate, hscim, http-client, http-client-tls, http-types
      , ldap-client, network, relude, servant, servant-client
-     , servant-client-core, string-conversions, text, tinylog, yaml
+     , servant-client-core, string-conversions, text, tinylog
+     , unordered-containers, yaml
      }:
      mkDerivation {
        pname = "ldap-scim-bridge";
-       version = "0.2";
-       sha256 = "16z878iq7b2spa6mhppm1bjj2hi73f9rm6pl9yw6yz7zbqphi9sd";
+       version = "0.4";
+       sha256 = "1xjnph3ndqwzyng0227jp6dw5rfyiqy9nraya05nnic69526hj7h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring containers email-validate hscim
          http-client http-client-tls http-types ldap-client network relude
          servant servant-client servant-client-core string-conversions text
-         tinylog yaml
+         tinylog unordered-containers yaml
        ];
        executableHaskellDepends = [
          aeson aeson-pretty base bytestring containers email-validate hscim
          http-client http-client-tls http-types ldap-client network relude
          servant servant-client servant-client-core string-conversions text
-         tinylog yaml
+         tinylog unordered-containers yaml
        ];
        description = "See README for synopsis";
        license = lib.licenses.agpl3Plus;
···
        ];
        description = "LEB128 and SLEB128 encoding";
        license = lib.licenses.mit;
+       maintainers = with lib.maintainers; [ nomeata ];
      }) {};
 
   "leetify" = callPackage
···
      }:
      mkDerivation {
        pname = "libarchive";
-       version = "3.0.2.2";
-       sha256 = "1i3zrby1pmlm7dwv1xra9xmlv4a30cgmbwz5zygdyw1mwy4y9wnh";
+       version = "3.0.3.0";
+       sha256 = "0zf2x317xkp7mnamm8aqp0wmc5xka6p6pljyadz0xbmy7ih55ylh";
+       revision = "1";
+       editedCabalFile = "0n0s9qfa6b0r2rwz834dlqqm68xz2hvlygzjw084dy85d6xmvl75";
        setupHaskellDepends = [ base Cabal chs-cabal ];
        libraryHaskellDepends = [
          base bytestring composition-prelude deepseq dlist filepath mtl
···
        libraryPkgconfigDepends = [ libarchive ];
        libraryToolDepends = [ c2hs cpphs ];
        testHaskellDepends = [
-         base bytestring composition-prelude dir-traverse directory filepath
-         hspec hspec-core mtl pathological-bytestrings temporary
+         base bytestring composition-prelude deepseq dir-traverse directory
+         filepath hspec hspec-core mtl pathological-bytestrings temporary
        ];
        testToolDepends = [ cpphs ];
        benchmarkHaskellDepends = [
···
      }) {};
 
   "lift-generics" = callPackage
-    ({ mkDerivation, base, base-compat, generic-deriving, ghc-prim
-     , hspec, hspec-discover, mtl, template-haskell, th-compat
-     }:
-     mkDerivation {
-       pname = "lift-generics";
-       version = "0.2";
-       sha256 = "1m5pnf0vgbhkjzgkzfzzvd5jq1ilxpkh9mwjl06rs2kl1af66nna";
-       revision = "1";
-       editedCabalFile = "0jxqzzspwyv92ji8331r2lqh6igxyh9p70ci90068f3qy9zrgrr4";
-       libraryHaskellDepends = [
-         base generic-deriving ghc-prim template-haskell th-compat
-       ];
-       testHaskellDepends = [
-         base base-compat generic-deriving hspec mtl template-haskell
-         th-compat
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "GHC.Generics-based Language.Haskell.TH.Syntax.lift implementation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lift-generics_0_2_1" = callPackage
     ({ mkDerivation, base, base-compat, containers, generic-deriving
      , ghc-prim, hspec, hspec-discover, mtl, template-haskell, th-compat
      , th-lift-instances
···
        testToolDepends = [ hspec-discover ];
        description = "GHC.Generics-based Language.Haskell.TH.Syntax.lift implementation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lift-read-show" = callPackage
···
        pname = "linear";
        version = "1.21.6";
        sha256 = "0ax6prmc7b53w0lz5ddc40wrjj9bm7wldpp57283gx9hdf8qrb35";
+       revision = "1";
+       editedCabalFile = "13pv3k0yayib0l6wq09bz54r44lxjhvvpc49sgnlc8p9959cs8q9";
        libraryHaskellDepends = [
          adjunctions base base-orphans binary bytes cereal containers
          deepseq distributive ghc-prim hashable indexed-traversable lens
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "linear_1_21_7" = callPackage
+    ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
+     , bytestring, cereal, containers, deepseq, distributive, ghc-prim
+     , hashable, HUnit, indexed-traversable, lens, random, reflection
+     , semigroupoids, semigroups, simple-reflect, tagged
+     , template-haskell, test-framework, test-framework-hunit
+     , transformers, transformers-compat, unordered-containers, vector
+     , void
+     }:
+     mkDerivation {
+       pname = "linear";
+       version = "1.21.7";
+       sha256 = "0k5vpd5rmxwnrax3zl305h941kxqz0kg6qpscdxf0brmxamjlx4i";
+       libraryHaskellDepends = [
+         adjunctions base base-orphans binary bytes cereal containers
+         deepseq distributive ghc-prim hashable indexed-traversable lens
+         random reflection semigroupoids semigroups tagged template-haskell
+         transformers transformers-compat unordered-containers vector void
+       ];
+       testHaskellDepends = [
+         base binary bytestring deepseq HUnit reflection simple-reflect
+         test-framework test-framework-hunit vector
+       ];
+       description = "Linear Algebra";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "linear-accelerate" = callPackage
     ({ mkDerivation, accelerate, base, Cabal, cabal-doctest
      , distributive, doctest, lens, linear
···
      }) {};
 
   "list-t" = callPackage
-    ({ mkDerivation, base, base-prelude, foldl, HTF, mmorph
-     , monad-control, mtl, mtl-prelude, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "list-t";
-       version = "1.0.4";
-       sha256 = "0xsmq4rhp91k4az1d0hnpiy2b3d3nqqdywjrrryrjiway55q8qrq";
-       libraryHaskellDepends = [
-         base foldl mmorph monad-control mtl transformers transformers-base
-       ];
-       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
-       description = "ListT done right";
-       license = lib.licenses.mit;
-     }) {};
-
-  "list-t_1_0_5" = callPackage
     ({ mkDerivation, base, base-prelude, foldl, HTF, logict, mmorph
      , monad-control, mtl, mtl-prelude, semigroups, transformers
      , transformers-base
···
        testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
        description = "ListT done right";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "list-t-attoparsec" = callPackage
···
      }:
      mkDerivation {
        pname = "lzma-conduit";
-       version = "1.2.1";
-       sha256 = "0hm72da7xk9l3zxjh274yg444vf405djxqbkf3q3p2qhicmxlmg9";
-       libraryHaskellDepends = [
-         base bytestring conduit lzma resourcet transformers
-       ];
-       testHaskellDepends = [
-         base base-compat bytestring conduit HUnit QuickCheck resourcet
-         test-framework test-framework-hunit test-framework-quickcheck2
-       ];
-       description = "Conduit interface for lzma/xz compression";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lzma-conduit_1_2_2" = callPackage
-    ({ mkDerivation, base, base-compat, bytestring, conduit, HUnit
-     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, transformers
-     }:
-     mkDerivation {
-       pname = "lzma-conduit";
        version = "1.2.2";
        sha256 = "1z6q16hzp2r5a4gdbg9akky5l9bfarzzhzswrgvh0v28ax400whb";
        libraryHaskellDepends = [
···
        ];
        description = "Conduit interface for lzma/xz compression";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lzma-enumerator" = callPackage
···
      }:
      mkDerivation {
        pname = "map-reduce-folds";
-       version = "0.1.0.7";
-       sha256 = "0khwcxw5cxx3y9rryak7qb65q055lg6b7gsbj20rvskq300asbk0";
+       version = "0.1.1.1";
+       sha256 = "1x00hnvj9fwzja451hx9395c7jxwyz995mx63m0ljxvnxq2lgilk";
        libraryHaskellDepends = [
          base containers discrimination foldl hashable hashtables parallel
          profunctors split streaming streamly text unordered-containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "markdown_0_1_17_5" = callPackage
+    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
+     , bytestring, call-stack, conduit, conduit-extra, containers
+     , data-default, directory, filepath, hspec, text, transformers
+     , xml-conduit, xml-types, xss-sanitize
+     }:
+     mkDerivation {
+       pname = "markdown";
+       version = "0.1.17.5";
+       sha256 = "0aglxvgpp6f8gvlvkdx0d5vik552wjiv0xys8b1jlh7zdbwwghcq";
+       libraryHaskellDepends = [
+         attoparsec base blaze-html blaze-markup conduit conduit-extra
+         containers data-default text transformers xml-conduit xml-types
+         xss-sanitize
+       ];
+       testHaskellDepends = [
+         base blaze-html bytestring call-stack conduit conduit-extra
+         containers directory filepath hspec text transformers xss-sanitize
+       ];
+       description = "Convert Markdown to HTML, with XSS protection";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "markdown-kate" = callPackage
     ({ mkDerivation, attoparsec, attoparsec-conduit, base, blaze-html
      , conduit, containers, data-default, highlighting-kate, hspec
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec_9_1_0" = callPackage
+  "megaparsec_9_2_0" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , criterion, deepseq, mtl, parser-combinators, scientific, text
      , transformers, weigh
      }:
      mkDerivation {
        pname = "megaparsec";
-       version = "9.1.0";
-       sha256 = "0rbs0nwr3ffhn10gl9sxqd2q8n6pn96ggf0dyz23myfskzar1fn1";
-       revision = "1";
-       editedCabalFile = "0aw0kvx744730h232rw23yh8ds07irc2ywv5i5iacgqyrh48mvzj";
+       version = "9.2.0";
+       sha256 = "1whjn3n14h2q3ja1v7zllzmj28ai7lqwfbif22c08rl00wpwmwhd";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq mtl
          parser-combinators scientific text transformers
        ];
        benchmarkHaskellDepends = [
-         base containers criterion deepseq text weigh
+         base bytestring containers criterion deepseq text weigh
        ];
        description = "Monadic parser combinators";
        license = lib.licenses.bsd2;
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec-tests_9_1_0" = callPackage
+  "megaparsec-tests_9_2_0" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , hspec, hspec-discover, hspec-expectations, hspec-megaparsec
      , megaparsec, mtl, parser-combinators, QuickCheck, scientific, text
···
      }:
      mkDerivation {
        pname = "megaparsec-tests";
-       version = "9.1.0";
-       sha256 = "0hz76bszcxk4p548nvalkh1vyrkwkp3scv2bhdmpb1d853whdskp";
+       version = "9.2.0";
+       sha256 = "09vcdywyy3h79fwq7l6aig3b52ygwv55d61maxdw06d1jw04fxr3";
        libraryHaskellDepends = [
          base bytestring containers hspec hspec-expectations
          hspec-megaparsec megaparsec mtl QuickCheck text transformers
···
        pname = "mmark-ext";
        version = "0.2.1.3";
        sha256 = "1hc95gvw4dyjlf2y4nli68zavjd0aj9br55n7417r7g70si1m82s";
-       revision = "1";
-       editedCabalFile = "0wkmi06n57ppm5n4x0l4mc6any21q70pb1v01ssv386hrc67bxwv";
+       revision = "2";
+       editedCabalFile = "1jnx5g34k7l5vxds8f7amsjn9cqpvwy1g6hvfq8kjrdnxv6rzyfs";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base foldl ghc-syntax-highlighter lucid microlens mmark modern-uri
···
      }:
      mkDerivation {
        pname = "modern-uri";
-       version = "0.3.4.1";
-       sha256 = "09yzn5lim3wv0120lfdwlc8ynx15z3p6p0js2r6ij3rzx26nchqd";
+       version = "0.3.4.2";
+       sha256 = "018hiiqx6n272mwbmhd5j9wlzyz0x7ppa9jsrv4zx1nb6n7shkh5";
        libraryHaskellDepends = [
          base bytestring containers contravariant deepseq exceptions
          megaparsec mtl profunctors QuickCheck reflection tagged
···
 
   "mono-traversable" = callPackage
     ({ mkDerivation, base, bytestring, containers, foldl, gauge
-     , hashable, hspec, HUnit, mwc-random, QuickCheck, semigroups, split
-     , text, transformers, unordered-containers, vector
-     , vector-algorithms
-     }:
-     mkDerivation {
-       pname = "mono-traversable";
-       version = "1.0.15.1";
-       sha256 = "1psxhfjmpv3y54wy8f8dwa43finlj7aw2mry67pg521gxmwmppy2";
-       revision = "1";
-       editedCabalFile = "1bzzfyn8q4v9d7nnaxa2vx81xxii4n9596cb2gph9sml1wk3i9ly";
-       libraryHaskellDepends = [
-         base bytestring containers hashable split text transformers
-         unordered-containers vector vector-algorithms
-       ];
-       testHaskellDepends = [
-         base bytestring containers foldl hspec HUnit QuickCheck semigroups
-         text transformers unordered-containers vector
-       ];
-       benchmarkHaskellDepends = [ base gauge mwc-random vector ];
-       description = "Type classes for mapping, folding, and traversing monomorphic containers";
-       license = lib.licenses.mit;
-     }) {};
-
-  "mono-traversable_1_0_15_2" = callPackage
-    ({ mkDerivation, base, bytestring, containers, foldl, gauge
      , hashable, hspec, HUnit, mwc-random, QuickCheck, split, text
      , transformers, unordered-containers, vector, vector-algorithms
      }:
      mkDerivation {
        pname = "mono-traversable";
-       version = "1.0.15.2";
-       sha256 = "1drh7nxfzlfmjr11hk2ijjsf3zsim18blaghhxmx6nxgy8i95876";
+       version = "1.0.15.3";
+       sha256 = "1dvlp7r7r1lc3fxkwaz68f1nffg83240q8a989x24x1x67rj1clq";
        libraryHaskellDepends = [
          base bytestring containers hashable split text transformers
          unordered-containers vector vector-algorithms
···
        benchmarkHaskellDepends = [ base gauge mwc-random vector ];
        description = "Type classes for mapping, folding, and traversing monomorphic containers";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mono-traversable-instances" = callPackage
···
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , bytestring-to-vector, c2hs, containers, data-default, directory
      , exceptions, extra, formatting, glew, hspec, http-client, HUnit
-     , JuicyPixels, lens, mtl, nanovg, OpenGL, process, random, safe
-     , scientific, sdl2, silently, stm, text, text-show, time
-     , transformers, unordered-containers, vector, websockets, wreq
-     , wuss
+     , JuicyPixels, lens, mtl, nanovg, OpenGL, OpenGLRaw, process
+     , random, safe, scientific, sdl2, silently, stm, text, text-show
+     , time, transformers, unordered-containers, vector, websockets
+     , wreq, wuss
      }:
      mkDerivation {
        pname = "monomer";
-       version = "1.0.0.3";
-       sha256 = "1jzjpzf3y5rawis57f8a08sxpqhmjgkndvjks5n06406k4c9qafd";
+       version = "1.1.0.0";
+       sha256 = "1a2cszh84sgyml9yxw2yln7g1ll249aq37lqd6aqjjb7mzb9fjxm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        executableHaskellDepends = [
          aeson async attoparsec base bytestring bytestring-to-vector
          containers data-default exceptions extra formatting http-client
-         JuicyPixels lens mtl nanovg OpenGL process random safe scientific
-         sdl2 stm text text-show time transformers unordered-containers
-         vector websockets wreq wuss
+         JuicyPixels lens mtl nanovg OpenGL OpenGLRaw process random safe
+         scientific sdl2 stm text text-show time transformers
+         unordered-containers vector websockets wreq wuss
        ];
        testHaskellDepends = [
          async attoparsec base bytestring bytestring-to-vector containers
···
          test-framework-hunit test-framework-quickcheck2
        ];
        description = "Pure Haskell implementation of the MurmurHash3 x86_32 algorithm";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "murmur3_1_0_5" = callPackage
+    ({ mkDerivation, base, base16, bytestring, cereal, HUnit
+     , QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "murmur3";
+       version = "1.0.5";
+       sha256 = "0ldmhprzldcxdbv5cd7nm7dfaavns4iv4z6mi1prnx1yn41lp6d0";
+       libraryHaskellDepends = [ base bytestring cereal ];
+       testHaskellDepends = [
+         base base16 bytestring cereal HUnit QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2
+       ];
+       description = "Pure Haskell implementation of the MurmurHash3 x86 algorithm";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nonempty-containers_0_3_4_4" = callPackage
+    ({ mkDerivation, aeson, base, comonad, containers, deepseq
+     , hedgehog, hedgehog-fn, invariant, nonempty-vector, semigroupoids
+     , tasty, tasty-hedgehog, text, these, vector
+     }:
+     mkDerivation {
+       pname = "nonempty-containers";
+       version = "0.3.4.4";
+       sha256 = "12p40gzhmggbvh466s50d6xqaz9y7d32px3yv911wdwkcs3xxkch";
+       libraryHaskellDepends = [
+         aeson base comonad containers deepseq invariant nonempty-vector
+         semigroupoids these vector
+       ];
+       testHaskellDepends = [
+         base comonad containers hedgehog hedgehog-fn invariant
+         nonempty-vector semigroupoids tasty tasty-hedgehog text these
+         vector
+       ];
+       description = "Non-empty variants of containers data types, with full API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nonempty-lift" = callPackage
     ({ mkDerivation, base, comonad, hedgehog, hedgehog-classes
      , semigroupoids
···
      }) {};
 
   "nvfetcher" = callPackage
-    ({ mkDerivation, aeson, base, binary, binary-instances, bytestring
-     , containers, data-default, extra, free, microlens, microlens-th
-     , neat-interpolation, optparse-simple, parsec, shake, text, tomland
-     , transformers, unordered-containers, validation-selective
+    ({ mkDerivation, aeson, async, base, binary, binary-instances
+     , bytestring, containers, data-default, extra, free, hspec
+     , hspec-discover, microlens, microlens-th, neat-interpolation
+     , optparse-simple, parsec, shake, stm, text, tomland, transformers
+     , unliftio, unordered-containers, validation-selective
      }:
      mkDerivation {
        pname = "nvfetcher";
-       version = "0.3.0.0";
-       sha256 = "1b6kb7qlnrg74ymhj74ikqs80hmg013vv4rc7sdkb0pfs3l6f6mh";
+       version = "0.4.0.0";
+       sha256 = "1mj2vmll0zpzx1f0j445h800lxvma30f9ainbnm54x3d4n6yvw7n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          optparse-simple parsec shake text tomland transformers
          unordered-containers validation-selective
        ];
+       testHaskellDepends = [
+         aeson async base binary binary-instances bytestring containers
+         data-default extra free hspec microlens microlens-th
+         neat-interpolation optparse-simple parsec shake stm text tomland
+         transformers unliftio unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
        description = "Generate nix sources expr for the latest version of packages";
        license = lib.licenses.mit;
        maintainers = with lib.maintainers; [ berberman ];
···
        license = lib.licenses.asl20;
      }) {};
 
-  "nvim-hs_2_1_0_5" = callPackage
+  "nvim-hs_2_1_0_7" = callPackage
     ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
      , containers, data-default, deepseq, foreign-store, hslogger, hspec
      , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
      , optparse-applicative, path, path-io, prettyprinter
      , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm
-     , streaming-commons, template-haskell, text, time
-     , time-locale-compat, transformers, transformers-base
-     , typed-process, unliftio, unliftio-core, utf8-string, vector, void
+     , streaming-commons, template-haskell
+     , template-haskell-compat-v0208, text, time, time-locale-compat
+     , transformers, transformers-base, typed-process, unliftio
+     , unliftio-core, utf8-string, vector, void
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.1.0.5";
-       sha256 = "11ld5bgrica3ma54f7x37hcbcl0ms3x6gi0326by3jsnskxplz0z";
+       version = "2.1.0.7";
+       sha256 = "0vbqlrjwfg5pl4f9xymdlx0k01jziqrmqf8m0vm7iiy0vnjzx19j";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
          mtl network optparse-applicative path path-io prettyprinter
          prettyprinter-ansi-terminal resourcet stm streaming-commons
-         template-haskell text time time-locale-compat transformers
-         transformers-base typed-process unliftio unliftio-core utf8-string
-         vector void
+         template-haskell template-haskell-compat-v0208 text time
+         time-locale-compat transformers transformers-base typed-process
+         unliftio unliftio-core utf8-string vector void
        ];
        testHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default foreign-store hslogger hspec hspec-discover HUnit
          megaparsec messagepack mtl network optparse-applicative path
          path-io prettyprinter prettyprinter-ansi-terminal QuickCheck
-         resourcet stm streaming-commons template-haskell text time
-         time-locale-compat transformers transformers-base typed-process
-         unliftio unliftio-core utf8-string vector
+         resourcet stm streaming-commons template-haskell
+         template-haskell-compat-v0208 text time time-locale-compat
+         transformers transformers-base typed-process unliftio unliftio-core
+         utf8-string vector
        ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell plugin backend for neovim";
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ormolu_0_3_0_0" = callPackage
+  "ormolu_0_3_0_1" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, Cabal, containers
      , Diff, directory, dlist, exceptions, filepath, ghc-lib-parser
      , gitrev, hspec, hspec-discover, mtl, optparse-applicative, path
-     , path-io, syb, text
+     , path-io, syb, temporary, text
      }:
      mkDerivation {
        pname = "ormolu";
-       version = "0.3.0.0";
-       sha256 = "073d8wkpciqadcv1vnim00c13n30ybqdraaxgyr96dcqvq71zvjv";
+       version = "0.3.0.1";
+       sha256 = "1cp543ff0gng6v5l251fklrk73yqfgbymx824ldc7inwybmd6z03";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base filepath ghc-lib-parser gitrev optparse-applicative text
        ];
        testHaskellDepends = [
-         base containers filepath hspec path path-io text
+         base containers directory filepath hspec path path-io temporary
+         text
        ];
        testToolDepends = [ hspec-discover ];
        description = "A formatter for Haskell source code";
···
      }:
      mkDerivation {
        pname = "pandoc-filter-indent";
-       version = "0.3.1.0";
-       sha256 = "1ys7v9ygy07c4jxraqmbb1fqswhh0fydcgd5zcfjln2sjb637947";
+       version = "0.3.2.0";
+       sha256 = "0nhv38vpkjsy6fbidrfwh8n2pzs4ipb8l4dq9is0rjb36fahjmvg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, criterion, hspec, mwc-random, vector }:
      mkDerivation {
        pname = "pava";
-       version = "0.1.1.1";
-       sha256 = "11jlhc1cqsn0r82rbwnf323s0w1ir3vf4ija0r39j58y19blc8zv";
-       libraryHaskellDepends = [ base vector ];
-       testHaskellDepends = [ base hspec vector ];
-       pname = "iproute";
-       description = "Greatest convex majorants and least concave minorants";
-       license = lib.licenses.gpl3Plus;
-       maintainers = with lib.maintainers; [ dschrempf ];
-     }) {};
-
-  "pava_0_1_1_2" = callPackage
-    ({ mkDerivation, base, criterion, hspec, mwc-random, vector }:
-     mkDerivation {
-       pname = "pava";
        version = "0.1.1.2";
        sha256 = "0qvyia9iy8f9s16v2khgzm74z9r7mks98xz1g1qhrdkw950mjlga";
        libraryHaskellDepends = [ base vector ];
···
        pname = "iproute";
        description = "Greatest convex majorants and least concave minorants";
        license = lib.licenses.gpl3Plus;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ dschrempf ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "persistent-migration";
-       version = "0.2.1";
-       sha256 = "0jxhd9bkzcak48nz02g1s8rmbc9fkylf13p4vxkn3x26g2qlig7i";
+       version = "0.3.0";
+       sha256 = "1jm3qizi1l0wdsmmb87lk7i35lp8ip935vbwzwnd7ybb6s8js1pn";
        libraryHaskellDepends = [
          base containers fgl mtl persistent text time unordered-containers
        ];
···
        pname = "pointfree-fancy";
        version = "1.1.1.15";
        sha256 = "1jbxgn4raa5zzy5riflvx1sch6ar78fi84yf0ag86yxda3lh70qd";
-       revision = "1";
-       editedCabalFile = "1hk3558yviij4d4x93h253x7rpqmnjj7imgydgllgi7xa0jzwknc";
+       revision = "2";
+       editedCabalFile = "1m23ll2r9aizgp21jssyxxqa20lg93carpn7gwdfzafakwjzdg26";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "polysemy-RandomFu";
-       version = "0.4.2.1";
-       sha256 = "16r167cx87y9l36psa3ffrcfjyhm4ngzbbsmm9c5dh3gvq53vw58";
+       version = "0.4.3.0";
+       sha256 = "054v54kwkrg13nx9kznkclnmjnynh9j48bk2fjylwd9xqrj1r63a";
        libraryHaskellDepends = [
          base polysemy polysemy-plugin polysemy-zoo random-fu random-source
        ];
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.3.0.0";
-       sha256 = "0lg68nwasak6yvzy1wgjlydmvbj5cwyadmgi14vw4df6wnh17wwq";
+       version = "0.4.0.1";
+       sha256 = "1wf24837p5bk6p6p2d3bqwyrj93ls7kndvzr9qa8w8g46fv1ryp4";
        libraryHaskellDepends = [
          async base containers polysemy polysemy-time relude stm stm-chans
          string-interpolate template-haskell text time unagi-chan unix
        ];
        testHaskellDepends = [
-         base polysemy polysemy-test polysemy-time stm tasty unagi-chan unix
+         base polysemy polysemy-test polysemy-time stm tasty time unagi-chan
+         unix
        ];
        description = "Polysemy Effects for Concurrency";
        license = "BSD-2-Clause-Patent";
···
      }:
      mkDerivation {
        pname = "prettyprinter";
-       version = "1.7.0";
-       sha256 = "19z04sn0kqxgwcyfn5igjmbxw13xsb3mdhdidkb3kzswib78f6sr";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base text ];
-       testHaskellDepends = [
-         base bytestring doctest pgp-wordlist QuickCheck
-         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
-       ];
-       benchmarkHaskellDepends = [
-         ansi-wl-pprint base base-compat containers deepseq gauge mtl
-         QuickCheck random text transformers
-       ];
-       description = "A modern, easy to use, well-documented, extensible pretty-printer";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter_1_7_1" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, base-compat, bytestring
-     , containers, deepseq, doctest, gauge, mtl, pgp-wordlist
-     , QuickCheck, quickcheck-instances, random, tasty, tasty-hunit
-     , tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "prettyprinter";
        version = "1.7.1";
        sha256 = "0i8b3wjjpdvp5b857j065jwyrpgcnzgk75imrj7i3yhl668acvjy";
        isLibrary = true;
···
        ];
        description = "A modern, easy to use, well-documented, extensible pretty-printer";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-ansi-terminal" = callPackage
···
      }:
      mkDerivation {
        pname = "prettyprinter-ansi-terminal";
-       version = "1.1.2";
-       sha256 = "168p5b7fzqs0g8ld26d3k78afgdx4r21dv0hw8ka2c08p4w76sz2";
-       libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
-       testHaskellDepends = [ base doctest ];
-       benchmarkHaskellDepends = [
-         base base-compat containers deepseq gauge prettyprinter QuickCheck
-         text
-       ];
-       description = "ANSI terminal backend for the »prettyprinter« package";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-ansi-terminal_1_1_3" = callPackage
-    ({ mkDerivation, ansi-terminal, base, base-compat, containers
-     , deepseq, doctest, gauge, prettyprinter, QuickCheck, text
-     }:
-     mkDerivation {
-       pname = "prettyprinter-ansi-terminal";
        version = "1.1.3";
        sha256 = "1cqxbcmy9ykk4pssq5hp6h51g2h547zfz549awh0c1fni8q3jdw1";
        libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
···
        ];
        description = "ANSI terminal backend for the »prettyprinter« package";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-compat-annotated-wl-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "prettyprinter-compat-ansi-wl-pprint";
-       version = "1.0.1";
-       sha256 = "0gzpjddnxl4z8pvb0lyal13jbr94dk900k8g4qwcq9fs26vnnb81";
-       revision = "1";
-       editedCabalFile = "0rzvap56ygygzs95091ipmcdc7n76sczc2dk88g4nr7zskb2nf1k";
-       libraryHaskellDepends = [
-         base prettyprinter prettyprinter-ansi-terminal text
-       ];
-       description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-compat-ansi-wl-pprint_1_0_2" = callPackage
-    ({ mkDerivation, base, prettyprinter, prettyprinter-ansi-terminal
-     , text
-     }:
-     mkDerivation {
-       pname = "prettyprinter-compat-ansi-wl-pprint";
        version = "1.0.2";
        sha256 = "0mcy0621lx0zmc2csdq348r21f932f2w51y62jzyz4cby58p5ch5";
        libraryHaskellDepends = [
···
        ];
        description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-compat-wl-pprint" = callPackage
     ({ mkDerivation, base, prettyprinter, text }:
      mkDerivation {
        pname = "prettyprinter-compat-wl-pprint";
-       version = "1.0.0.1";
-       sha256 = "17jj8m9s3cp1s1szpy67g7wni9ssid78jqksh3aym7p6ci81y8km";
-       revision = "3";
-       editedCabalFile = "0cb1i1hmr6wl8lacy3w822h273lapqhp537snxgbmhf9xvfckbpr";
-       libraryHaskellDepends = [ base prettyprinter text ];
-       description = "Prettyprinter compatibility module for previous users of the wl-pprint package";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-compat-wl-pprint_1_0_1" = callPackage
-    ({ mkDerivation, base, prettyprinter, text }:
-     mkDerivation {
-       pname = "prettyprinter-compat-wl-pprint";
        version = "1.0.1";
        sha256 = "0ffrbh79da9ihn3lbk9vq9329sdhddf6ccnag1k148z3ividxc63";
        libraryHaskellDepends = [ base prettyprinter text ];
        description = "Drop-in compatibility package to migrate from »wl-pprint« to »prettyprinter«";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-convert-ansi-wl-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "prettyprinter-convert-ansi-wl-pprint";
-       version = "1.1.1";
-       sha256 = "0bgf2np1ymy6zsd1qacndgyipcf0bamw1wkkikaq57npbb7psc41";
-       libraryHaskellDepends = [
-         ansi-terminal ansi-wl-pprint base prettyprinter
-         prettyprinter-ansi-terminal text
-       ];
-       testHaskellDepends = [ base doctest ];
-       description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "prettyprinter-convert-ansi-wl-pprint_1_1_2" = callPackage
-    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, doctest
-     , prettyprinter, prettyprinter-ansi-terminal, text
-     }:
-     mkDerivation {
-       pname = "prettyprinter-convert-ansi-wl-pprint";
        version = "1.1.2";
        sha256 = "0kfrwnaldx0cyr3mwx3ys14bl58nfjpxkzrfi6152gvfh8ly44c6";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base doctest ];
        description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-graphviz" = callPackage
···
      }:
      mkDerivation {
        pname = "push-notify-apn";
-       version = "0.3.0.0";
-       sha256 = "1bvdndyvrggvjc6y2dkhx570g8l9y58cr88kinbv4sg65kxnxsy0";
+       version = "0.3.0.2";
+       sha256 = "1iirjbqzgxh6skdpkk2w600kk6y0z6a11jcnzyayi81akfqm4jmn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, network-uri, template-haskell }:
      mkDerivation {
        pname = "qq-literals";
-       version = "0.1.0.1";
-       sha256 = "00a0lhjpv7vn90ah5s7qzpzq21x1r7wv24mkffiinj75bc8acnas";
-       revision = "1";
-       editedCabalFile = "0x81c0injndvlx5adrgk85yrf8p07mr1glcdd1x444mm3035zjvy";
+       version = "0.1.1.0";
+       sha256 = "1xiix8nd83vil303w5fikhwk213bd9b7dwsklw7cq5qlkh1pkvbq";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base network-uri template-haskell ];
        description = "Compile-time checked literal values via QuasiQuoters";
···
        description = "A library of queuelike data structures, both functional and stateful";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "quic" = callPackage
+    ({ mkDerivation, array, async, base, base16-bytestring, bytestring
+     , containers, crypto-token, cryptonite, data-default-class, doctest
+     , fast-logger, filepath, hspec, hspec-discover, iproute, memory
+     , network, network-byte-order, psqueues, QuickCheck, random, stm
+     , tls, unix-time, unliftio, unliftio-core, x509
+     }:
+     mkDerivation {
+       pname = "quic";
+       version = "0.0.0";
+       sha256 = "0hiyw9qpx7h42ay9jna8xr7vr16jlr62v0nfnq4y29gki38221a4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base base16-bytestring bytestring containers crypto-token
+         cryptonite data-default-class fast-logger filepath iproute memory
+         network network-byte-order psqueues random stm tls unix-time
+         unliftio unliftio-core x509
+       ];
+       testHaskellDepends = [
+         async base base16-bytestring bytestring containers cryptonite
+         doctest hspec network QuickCheck tls unix-time unliftio
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "QUIC";
+       license = lib.licenses.bsd3;
      }) {};
 
   "quick-generator" = callPackage
···
      }:
      mkDerivation {
        pname = "rank2classes";
-       version = "1.4.2";
-       sha256 = "0b32mgqzwj9hzz29fhvzidw40iygkbra5ng7z7l9kpp15pbak0pp";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base distributive template-haskell transformers
-       ];
-       testHaskellDepends = [
-         base distributive doctest tasty tasty-hunit
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "standard type constructor class hierarchy, only with methods of rank 2 types";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "rank2classes_1_4_3" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-doctest, distributive, doctest
-     , markdown-unlit, tasty, tasty-hunit, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "rank2classes";
        version = "1.4.3";
        sha256 = "03sla9gsg23ma8xxm3mndc9wrh715lsgksxc34rxkmjbp9vxlccj";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ markdown-unlit ];
        description = "standard type constructor class hierarchy, only with methods of rank 2 types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rapid" = callPackage
···
      }:
      mkDerivation {
        pname = "regex-pcre-builtin";
-       version = "0.95.2.3.8.43";
-       sha256 = "02c6vzxcy1zkqwy6w4dsc97xvvdwlh8xr7imrlx2qs2521rvswr7";
-       libraryHaskellDepends = [
-         array base bytestring containers regex-base text
-       ];
-       description = "PCRE Backend for \"Text.Regex\" (regex-base)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "regex-pcre-builtin_0_95_2_3_8_44" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, regex-base
-     , text
-     }:
-     mkDerivation {
-       pname = "regex-pcre-builtin";
        version = "0.95.2.3.8.44";
        sha256 = "0pn55ssrwr05c9sa9jvp0knvzjksz04wn3pmzf5dz4xgbyjadkna";
        libraryHaskellDepends = [
···
        ];
        description = "PCRE Backend for \"Text.Regex\" (regex-base)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-pcre-text" = callPackage
···
        pname = "repa";
        version = "3.4.1.4";
        sha256 = "17m3wl4hvf04fxwm4fflhnv41yl9bm263hnbpxc8x6xqwifplq23";
-       revision = "8";
-       editedCabalFile = "0bhkiav26m61lzjkxjldals136viixyg88xf1bbihsp9kzkbv6as";
+       revision = "9";
+       editedCabalFile = "0n287hg4lmn139dwji5xbry369a4ci0qh1birxkzzrsvyv0aq0nz";
        libraryHaskellDepends = [
          base bytestring ghc-prim QuickCheck template-haskell vector
        ];
···
        pname = "rle";
        version = "0.1.0.1";
        sha256 = "05rbhm0lxrq7vdbq9s0q21m0f0hlzmknljmampcmdjnwbl4nvf3d";
+       revision = "1";
+       editedCabalFile = "0077n1z80x3psgcgvbs7cxln63m2ghb4iiqih0r5aq96j4v9x3f0";
        libraryHaskellDepends = [
          base cereal deepseq portray portray-diff wrapped
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "row-types-aeson" = callPackage
+    ({ mkDerivation, aeson, base, row-types, text }:
+     mkDerivation {
+       pname = "row-types-aeson";
+       version = "1.0.0.0";
+       sha256 = "0har2qcca9asd50jmcqab4v8jx83v5h5bgqk82awnrg7d99c24sf";
+       libraryHaskellDepends = [ aeson base row-types text ];
+       description = "aeson instances for Open Records and Variants";
+       license = lib.licenses.mit;
+     }) {};
+
+  "row-types-barbies" = callPackage
+    ({ mkDerivation, barbies, base, row-types, text }:
+     mkDerivation {
+       pname = "row-types-barbies";
+       version = "1.0.0.0";
+       sha256 = "1c2slxggr3jl3dvakyysq3d4svd61nhzj74xnzs0q7v6y5dlsl2b";
+       libraryHaskellDepends = [ barbies base row-types text ];
+       description = "barbies instances for Open Records and Variants";
+       license = lib.licenses.mit;
+     }) {};
+
   "rowdy" = callPackage
     ({ mkDerivation, base, containers, dlist, hspec, mtl }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "semigroupoids-do" = callPackage
+    ({ mkDerivation, base, semigroupoids }:
+     mkDerivation {
+       pname = "semigroupoids-do";
+       version = "1.0";
+       sha256 = "1f3b1adwmdjgq1qjazd0cdz6lr711s3v29qci13vyjsdxixlzjkf";
+       libraryHaskellDepends = [ base semigroupoids ];
+       description = "Support for QualifiedDo with semigroupoids classes";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "semigroupoids-syntax" = callPackage
     ({ mkDerivation, base, comonad, containers, contravariant
      , directory, distributive, doctest, filepath, QuickCheck
···
 
   "seonbi" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal, cases
-     , cassava, containers, data-default, directory, doctest
+     , cassava, containers, data-default, Diff, directory, doctest
      , doctest-discover, file-embed, filepath, hlint, hspec
      , hspec-discover, html-charset, http-client, http-types
      , interpolatedstring-perl6, optparse-applicative, QuickCheck
···
      }:
      mkDerivation {
        pname = "seonbi";
-       version = "0.2.0";
-       sha256 = "1bj428ds0lw6vg0927mn9ss63zrrzfi9jn7fy1hpr583vywc8pba";
+       version = "0.2.3";
+       sha256 = "1wr32bpn6hg6gjd9ppzim0212b04dwcbllk64h8395nnklcv1j44";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          optparse-applicative text wai warp
        ];
        testHaskellDepends = [
-         aeson base bytestring containers directory doctest doctest-discover
-         filepath hlint hspec hspec-discover interpolatedstring-perl6
-         QuickCheck random text unicode-show
+         aeson base bytestring containers Diff directory doctest
+         doctest-discover filepath hlint hspec hspec-discover
+         interpolatedstring-perl6 QuickCheck random text unicode-show
        ];
        testToolDepends = [ hspec-discover ];
        description = "SmartyPants for Korean language";
···
     ({ mkDerivation, base, bytestring, HUnit, unix }:
      mkDerivation {
        pname = "serialport";
-       version = "0.5.2";
-       sha256 = "1wxi4arxbcvaacrm6phfnd3dvmy5h2bfcwlqis7x1bgyqpzxcq4b";
+       version = "0.5.3";
+       sha256 = "0f0q26n27s6b9mfqc9xb9j8p4qrfjfddwiz1wslxk4rh176qw96i";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [ base bytestring HUnit ];
        description = "Cross platform serial port library";
···
 
   "servant-docs-simple" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hspec
-     , hspec-core, ordered-containers, prettyprinter, raw-strings-qq
-     , servant, text, unordered-containers
+     , hspec-core, prettyprinter, raw-strings-qq, servant, text
      }:
      mkDerivation {
        pname = "servant-docs-simple";
-       version = "0.3.0.0";
-       sha256 = "0nzlgb3ccycqm3v599hh7k7fk7f8wqj0r2c2ldy9fj1c55h9n8hb";
+       version = "0.4.0.0";
+       sha256 = "0hsx2c3f1afcsrl4z63mmwhr08xlf9kl93ga127b14vz8fh1xb3m";
        libraryHaskellDepends = [
-         aeson aeson-pretty base bytestring ordered-containers prettyprinter
-         servant text unordered-containers
+         aeson aeson-pretty base bytestring prettyprinter servant text
        ];
        testHaskellDepends = [
-         aeson aeson-pretty base bytestring hspec hspec-core
-         ordered-containers prettyprinter raw-strings-qq servant text
-         unordered-containers
+         aeson base hspec hspec-core raw-strings-qq servant
        ];
        description = "Generate endpoints overview for Servant API";
        license = lib.licenses.mit;
···
 
   "servant-serf" = callPackage
     ({ mkDerivation, attoparsec, base, hpack, mtl, optparse-applicative
-     , parser-combinators, regex-base, regex-tdfa, text
+     , regex-base, regex-tdfa, text
      }:
      mkDerivation {
        pname = "servant-serf";
-       version = "0.1.1";
-       sha256 = "0n4970bx48hwxixqgq1jayprcaq82mm2462iclyzkbfxl6v01zrd";
+       version = "0.2.0";
+       sha256 = "1dda569calcwy0xa0avxzx55r4iydwz49wnc015rjj81kp1ij02y";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
-         attoparsec base hpack mtl optparse-applicative parser-combinators
-         regex-base regex-tdfa text
+         attoparsec base hpack mtl optparse-applicative regex-base
+         regex-tdfa text
        ];
        doHaddock = false;
        description = "Generates a servant API module";
···
      }:
      mkDerivation {
        pname = "sexp-grammar";
-       version = "2.3.1";
-       sha256 = "05vj998wzj1wja4848kd04c89jb8pmvdyl40aw6qvc9fq0qzw6m4";
+       version = "2.3.2";
+       sha256 = "1rsa953pykrrfsf7lcnk4ds7vydb9p7s8irvaxvi1v4m2q2zg7a5";
        libraryHaskellDepends = [
          array base bytestring containers data-fix deepseq
          invertible-grammar prettyprinter recursion-schemes scientific
···
        ];
        description = "Invertible grammar combinators for S-expressions";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "sexp-grammar_2_3_3" = callPackage
+    ({ mkDerivation, alex, array, base, bytestring, containers
+     , criterion, data-fix, deepseq, happy, invertible-grammar
+     , prettyprinter, QuickCheck, recursion-schemes, scientific
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, text
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "sexp-grammar";
+       version = "2.3.3";
+       sha256 = "0mil91bqzx5lrd7pl1in35ir7zwa6h8lmm9wvqifk7y241hg99gg";
+       libraryHaskellDepends = [
+         array base bytestring containers data-fix deepseq
+         invertible-grammar prettyprinter recursion-schemes scientific
+         semigroups text utf8-string
+       ];
+       libraryToolDepends = [ alex happy ];
+       testHaskellDepends = [
+         base containers invertible-grammar prettyprinter QuickCheck
+         scientific semigroups tasty tasty-hunit tasty-quickcheck text
+         utf8-string
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq text
+       ];
+       description = "Invertible grammar combinators for S-expressions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sexp-show" = callPackage
···
      }:
      mkDerivation {
        pname = "slick";
-       version = "1.1.1.0";
-       sha256 = "19zqg85j3685hsbax5sv96zfqxih7rmcjd65z88vynmiv718147d";
-       libraryHaskellDepends = [
-         aeson base bytestring directory extra mustache pandoc shake text
-         unordered-containers
-       ];
-       description = "A quick & easy static site builder built with shake and pandoc";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "slick_1_1_2_2" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, directory, extra
-     , mustache, pandoc, shake, text, unordered-containers
-     }:
-     mkDerivation {
-       pname = "slick";
        version = "1.1.2.2";
        sha256 = "0q6q496cvrsc4gnksihib0dr80cjg0n9vy69h2ani2ax0g75fzqd";
        libraryHaskellDepends = [
···
        ];
        description = "A quick & easy static site builder built with shake and pandoc";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "slidemews" = callPackage
···
     ({ mkDerivation, base, constraints }:
      mkDerivation {
        pname = "some-dict-of";
-       version = "0.1.0.1";
-       sha256 = "15gs459x08a8dg18vjizy0rmhh0vnmy33dvx9a38jni0bpmmnc6f";
+       version = "0.1.0.2";
+       sha256 = "0yimraj4r8h1vqsy4pvmfdl9asf2flc1mcfj1jgyh4am4pz0d8p7";
        libraryHaskellDepends = [ base constraints ];
        testHaskellDepends = [ base constraints ];
        description = "Carry evidence of constraints around";
···
        pname = "split";
        version = "0.2.3.4";
        sha256 = "0ahzdjcxw5wywr3w4msspia99k6fkckddam1m5506h4z9h8fa7r7";
-       revision = "1";
-       editedCabalFile = "06pmlvyrz4rr7rsrghpyrdypprphm9522rvnz4l3i8333n4pb304";
+       revision = "2";
+       editedCabalFile = "0jwaw5plby8bmjmhshrr5813avqmq4zih2lqpi8cprvfh0z9rpx6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Combinator library for splitting lists";
···
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) lmdb;};
 
+  "streamly-lz4" = callPackage
+    ({ mkDerivation, base, directory, exceptions, fusion-plugin-types
+     , gauge, hspec, QuickCheck, streamly, temporary
+     }:
+     mkDerivation {
+       pname = "streamly-lz4";
+       version = "0.1.0";
+       sha256 = "0jp6px6m85rji0wpq0xfp2cv63jidvqmb1x1z33q95xfh6v73yng";
+       libraryHaskellDepends = [
+         base exceptions fusion-plugin-types streamly
+       ];
+       testHaskellDepends = [ base hspec QuickCheck streamly temporary ];
+       benchmarkHaskellDepends = [ base directory gauge streamly ];
+       description = "Streamly combinators for LZ4 compression";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "streamly-posix" = callPackage
     ({ mkDerivation, base, bytestring, filepath, hpath-posix, hspec
      , hspec-discover, safe-exceptions, streamly, streamly-bytestring
···
        ];
        description = "Mark tasty tests as failure expected";
        license = lib.licenses.mit;
+       maintainers = with lib.maintainers; [ nomeata ];
      }) {};
 
   "tasty-fail-fast" = callPackage
···
   "tasty-silver" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
      , deepseq, directory, filepath, mtl, optparse-applicative, process
-     , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
-     , temporary, text, transformers
+     , process-extras, regex-tdfa, silently, stm, tagged, tasty
+     , tasty-hunit, temporary, text, transformers
      }:
      mkDerivation {
        pname = "tasty-silver";
-       version = "3.2.2";
-       sha256 = "0zsl6nna8ir215qyxhyh2czx4i16hzw1n1m8jw8ym02j6sp6iz13";
-       revision = "1";
-       editedCabalFile = "0mgdk77xz38zc46qbxvss6vnp4yk328zbpw1l0c1n0f5gyf6sbav";
+       version = "3.2.3";
+       sha256 = "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring containers deepseq directory
          filepath mtl optparse-applicative process process-extras regex-tdfa
          stm tagged tasty temporary text
        ];
        testHaskellDepends = [
-         base directory filepath process tasty tasty-hunit temporary
-         transformers
+         base directory filepath process silently tasty tasty-hunit
+         temporary transformers
        ];
        description = "A fancy test runner, including support for golden tests";
        license = lib.licenses.mit;
      }) {};
 
-  "tasty-silver_3_2_3" = callPackage
+  "tasty-silver_3_3" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
      , deepseq, directory, filepath, mtl, optparse-applicative, process
      , process-extras, regex-tdfa, silently, stm, tagged, tasty
···
      }:
      mkDerivation {
        pname = "tasty-silver";
-       version = "3.2.3";
-       sha256 = "0nvh2k8iqqkanmp7lpwd3asimyarzisly8wavbdahcxryn0j4xb7";
+       version = "3.3";
+       sha256 = "1glhq2kkgnv5bf2664k7ph9kz9wcak758jb1jszl03wpv5c8idil";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring containers deepseq directory
          filepath mtl optparse-applicative process process-extras regex-tdfa
-         stm tagged tasty temporary text
+         silently stm tagged tasty temporary text
        ];
        testHaskellDepends = [
          base directory filepath process silently tasty tasty-hunit
···
     ({ mkDerivation, base, time }:
      mkDerivation {
        pname = "tempi";
-       version = "1.0.2.0";
-       sha256 = "08hjgs32cx3vcm6sga4xc7ijcj3lbjlg133vkri06xfi0v3hjgnp";
+       version = "1.0.2.1";
+       sha256 = "0l01iday5dkqz6mmnbjp5z69mm0p9b1c2xlks54cv7n069m0mpk4";
        libraryHaskellDepends = [ base time ];
        description = "For representing musical tempi";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "text-builder";
-       version = "0.6.6.2";
-       sha256 = "1cj6k27w9zm0g5wjfwyiwjljnqs9lz0zhw52nd0p7f1mhb9r80dw";
-       libraryHaskellDepends = [
-         base bytestring deferred-folds text transformers
-       ];
-       testHaskellDepends = [
-         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
-         tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [ criterion rerebase ];
-       description = "An efficient strict text builder";
-       license = lib.licenses.mit;
-     }) {};
-
-  "text-builder_0_6_6_3" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deferred-folds
-     , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
-     , tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "text-builder";
        version = "0.6.6.3";
        sha256 = "0j2f9zbkk2lbvfb0f3c1i6376zbrr4p782ivbhgi8nv65rsp2ijy";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ criterion rerebase ];
        description = "An efficient strict text builder";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-containers" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tmp-proc" = callPackage
+    ({ mkDerivation, async, base, bytestring, connection, data-default
+     , doctest, hspec, http-client, http-client-tls, http-types, mtl
+     , network, process, req, text, unliftio, wai, warp, warp-tls
+     }:
+     mkDerivation {
+       pname = "tmp-proc";
+       version = "0.5.0.0";
+       sha256 = "0vqmi5dpq7b8yn1djlpg662nwwjqzhqblz85f83qvlhiyikqkhdp";
+       libraryHaskellDepends = [
+         async base bytestring mtl network process text unliftio wai warp
+         warp-tls
+       ];
+       testHaskellDepends = [
+         base bytestring connection data-default doctest hspec http-client
+         http-client-tls http-types req text wai warp warp-tls
+       ];
+       description = "Run 'tmp' processes in integration tests";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "tmp-proc-example" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, exceptions, hedis, hspec
+     , hspec-tmp-proc, http-client, http-client-tls, monad-logger, mtl
+     , persistent, persistent-postgresql, persistent-template
+     , postgresql-simple, servant, servant-client, servant-server, tasty
+     , tasty-hunit, text, time, tmp-proc, tmp-proc-postgres
+     , tmp-proc-redis, transformers, wai, warp
+     }:
+     mkDerivation {
+       pname = "tmp-proc-example";
+       version = "0.5.0.0";
+       sha256 = "00cpx35z3s8pk8jn53kkxmkcwmrslyaw0xnr7hgbmh1f1nadbc05";
+       libraryHaskellDepends = [
+         aeson base bytestring exceptions hedis hspec hspec-tmp-proc
+         http-client http-client-tls monad-logger mtl persistent
+         persistent-postgresql persistent-template postgresql-simple servant
+         servant-client servant-server tasty tasty-hunit text time tmp-proc
+         tmp-proc-postgres tmp-proc-redis transformers wai warp
+       ];
+       testHaskellDepends = [ base hspec ];
+       description = "Shows how to test a simple service using tmp-proc";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "tmp-proc-postgres" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-tmp-proc
+     , postgresql-simple, text, tmp-proc
+     }:
+     mkDerivation {
+       pname = "tmp-proc-postgres";
+       version = "0.5.0.0";
+       sha256 = "15jfmh7g6nslnvwdn24hrsgd0rs5ikvc1fid33i2a2am89myf8x0";
+       libraryHaskellDepends = [
+         base bytestring postgresql-simple text tmp-proc
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-tmp-proc postgresql-simple text
+         tmp-proc
+       ];
+       description = "Shows how to run a PostgreSQL database as a tmp proc";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "tmp-proc-rabbitmq" = callPackage
+    ({ mkDerivation, amqp, base, bytestring, hspec, hspec-tmp-proc
+     , text, tmp-proc
+     }:
+     mkDerivation {
+       pname = "tmp-proc-rabbitmq";
+       version = "0.5.0.0";
+       sha256 = "0nl05a1zycrs955lnv1skq00bpkj776z9mbllax8zswskkd5ggn8";
+       libraryHaskellDepends = [ amqp base bytestring text tmp-proc ];
+       testHaskellDepends = [
+         amqp base bytestring hspec hspec-tmp-proc text tmp-proc
+       ];
+       description = "Shows how to run RabbitMQ as a tmp proc";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "tmp-proc-redis" = callPackage
+    ({ mkDerivation, base, bytestring, hedis, hspec, hspec-tmp-proc
+     , text, tmp-proc
+     }:
+     mkDerivation {
+       pname = "tmp-proc-redis";
+       version = "0.5.0.1";
+       sha256 = "15ggm9624nijnm9xwnw8pla347f7qwfxibmnk39xixxdh2g034qn";
+       libraryHaskellDepends = [ base bytestring hedis text tmp-proc ];
+       testHaskellDepends = [
+         base bytestring hedis hspec hspec-tmp-proc text tmp-proc
+       ];
+       description = "Shows how to run redis as a tmp proc";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "tmp-proc-zipkin" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-tmp-proc
+     , http-client, text, tmp-proc, tracing
+     }:
+     mkDerivation {
+       pname = "tmp-proc-zipkin";
+       version = "0.5.0.0";
+       sha256 = "0lcxggzh550xlk65dsl94mk0y72szk63wxn23mg5xwbj4xzn6j9s";
+       libraryHaskellDepends = [
+         base bytestring http-client text tmp-proc tracing
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-tmp-proc text tmp-proc
+       ];
+       description = "Shows how to run redis as a tmp proc";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "tmpl" = callPackage
     ({ mkDerivation, base, bytestring, directory, template, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "vector";
-       version = "0.12.3.0";
-       sha256 = "00xp86yad3yv4ja4q07gkmmcf7iwpcnzkkaf91zkx9nxb981iy0m";
-       revision = "2";
-       editedCabalFile = "18nlva9z2s37ikcl4msadynl7glipsx9cfpcdi8pzy8k5gvdm5hm";
+       version = "0.12.3.1";
+       sha256 = "0dczbcisxhhix859dng5zhxkn3xvlnllsq60apqzvmyl5g056jpv";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
          base base-orphans HUnit primitive QuickCheck random tasty
···
      }:
      mkDerivation {
        pname = "wai-app-file-cgi";
-       version = "3.1.9";
-       sha256 = "1knf3dmal9immsxj4cvqf2i4ijlrn17fick6slxb1mrms7f50wkq";
+       version = "3.1.10";
+       sha256 = "1wspg5pjl24vvsdp2qxzx93a9ffj6pnv2kvm26ia5gh1kx570zfl";
        libraryHaskellDepends = [
          array attoparsec attoparsec-conduit base bytestring
          case-insensitive conduit conduit-extra containers
···
      }:
      mkDerivation {
        pname = "wai-middleware-delegate";
-       version = "0.1.1.0";
-       sha256 = "15q4qy2i1ssb3fz2x9xack5rs8a2a6dka18zqjzpng06izl2009j";
+       version = "0.1.2.2";
+       sha256 = "0g2zbvzi3d3pd3b4a2lrhp3vxk93agcg236yif0wghw3d0rqv1mr";
        libraryHaskellDepends = [
          async base blaze-builder bytestring case-insensitive conduit
          conduit-extra data-default http-client http-conduit http-types
···
        broken = true;
      }) {};
 
+  "warp-quic" = callPackage
+    ({ mkDerivation, base, bytestring, http3, quic, tls, wai, warp }:
+     mkDerivation {
+       pname = "warp-quic";
+       version = "0.0.0";
+       sha256 = "01w9rssp8a5yhc5w2y3mn3ihbnpvannl4q2rmjvphnqr5lj556sp";
+       libraryHaskellDepends = [
+         base bytestring http3 quic tls wai warp
+       ];
+       description = "Warp based on QUIC";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "warp-static" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, containers, directory
      , mime-types, text, wai-app-static, wai-extra, warp
···
        license = lib.licenses.mit;
      }) {};
 
+  "warp-tls_3_3_2" = callPackage
+    ({ mkDerivation, base, bytestring, cryptonite, data-default-class
+     , network, streaming-commons, tls, tls-session-manager, unliftio
+     , wai, warp
+     }:
+     mkDerivation {
+       pname = "warp-tls";
+       version = "3.3.2";
+       sha256 = "0b9viw26ymzq4q8snfddz3w59sqcf5ankxnw6f99iacxjhk6zs6m";
+       libraryHaskellDepends = [
+         base bytestring cryptonite data-default-class network
+         streaming-commons tls tls-session-manager unliftio wai warp
+       ];
+       description = "HTTP over TLS support for Warp via the TLS package";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "warp-tls-uid" = callPackage
     ({ mkDerivation, base, bytestring, data-default, network
      , streaming-commons, tls, unix, wai, warp, warp-tls, x509
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "word-wrap_0_5" = callPackage
+    ({ mkDerivation, base, criterion, hspec, text }:
+     mkDerivation {
+       pname = "word-wrap";
+       version = "0.5";
+       sha256 = "0i57233g4p9p8c0jf9mp3pvknwgv1lsrxm4mxjay38rw0372jpzq";
+       libraryHaskellDepends = [ base text ];
+       testHaskellDepends = [ base hspec ];
+       benchmarkHaskellDepends = [ base criterion text ];
+       description = "A library for word-wrapping";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "word16" = callPackage
     ({ mkDerivation, base, bytestring, criterion, hspec, hspec-discover
      , template-haskell, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "xeno_0_4_3" = callPackage
+    ({ mkDerivation, array, base, bytestring, bytestring-mmap, bzlib
+     , criterion, deepseq, filepath, ghc-prim, hexml, hexpat, hspec, mtl
+     , mutable-containers, time, vector, weigh, xml
+     }:
+     mkDerivation {
+       pname = "xeno";
+       version = "0.4.3";
+       sha256 = "0g7vwp41dz2zvw5s9w7cask543p556wlc4rk3vpx5cawr6v4d2ha";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array base bytestring deepseq mtl mutable-containers vector
+       ];
+       testHaskellDepends = [ base bytestring hexml hspec ];
+       benchmarkHaskellDepends = [
+         base bytestring bytestring-mmap bzlib criterion deepseq filepath
+         ghc-prim hexml hexpat time weigh xml
+       ];
+       description = "A fast event-based XML parser in pure Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "xenstore" = callPackage
     ({ mkDerivation, base, bytestring, cereal, mtl, network }:
      mkDerivation {
···
        description = "Basic types for representing XML";
        license = lib.licenses.mit;
      }) {};
+
+  "xml-verify" = callPackage
+    ({ mkDerivation, base, bytestring, cryptostore, hxt, mtl, pem, x509
+     , xmlsec1
+     }:
+     mkDerivation {
+       pname = "xml-verify";
+       version = "0.1.0.1";
+       sha256 = "01a8qivl4bv656zqygy6rysznic5nw2m5r3q14zgvc855879imw7";
+       libraryHaskellDepends = [
+         base bytestring cryptostore hxt mtl pem x509
+       ];
+       librarySystemDepends = [ xmlsec1 ];
+       description = "Verifying XML signatures";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {xmlsec1 = null;};
 
   "xml2html" = callPackage
     ({ mkDerivation, base, xml-conduit }:
···
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.11.5.0";
-       sha256 = "1bfdsqckzql50j6ni4fa1470cvkmfiy4skb98cdwnj4rss5p93mj";
-       configureFlags = [ "-fsystem-libyaml" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring conduit containers directory
-         filepath libyaml mtl resourcet scientific template-haskell text
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base-compat bytestring conduit containers
-         directory filepath hspec HUnit libyaml mockery mtl raw-strings-qq
-         resourcet scientific template-haskell temporary text transformers
-         unordered-containers vector
-       ];
-       description = "Support for parsing and rendering YAML documents";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "yaml_0_11_6_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
-     , conduit, containers, directory, filepath, hspec, HUnit, libyaml
-     , mockery, mtl, raw-strings-qq, resourcet, scientific
-     , template-haskell, temporary, text, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "yaml";
        version = "0.11.6.0";
        sha256 = "0hxg9mfi1dn9a7kp3imzfvnk7jj4sdjdxi6xyqz9ra7lqg14np3r";
        configureFlags = [ "-fsystem-libyaml" ];
···
        ];
        description = "Support for parsing and rendering YAML documents";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yaml-combinators" = callPackage
···
        testHaskellDepends = [ base blaze-html hspec text ];
        description = "Tools for using markdown in a yesod application";
        license = lib.licenses.gpl2Only;
+     }) {};
+
+  "yesod-markdown_0_12_6_12" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
+     , directory, hspec, pandoc, persistent, shakespeare, text
+     , xss-sanitize, yesod-core, yesod-form
+     }:
+     mkDerivation {
+       pname = "yesod-markdown";
+       version = "0.12.6.12";
+       sha256 = "0ha06wbzdy040wdimqzpw71hvy5z0pg0b4q524lln05gb26wdlsn";
+       libraryHaskellDepends = [
+         base blaze-html blaze-markup bytestring directory pandoc persistent
+         shakespeare text xss-sanitize yesod-core yesod-form
+       ];
+       testHaskellDepends = [ base blaze-html hspec text ];
+       description = "Tools for using markdown in a yesod application";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-media-simple" = callPackage
···
        ];
        description = "Haskell bindings to the Zstandard compression algorithm";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "zstd_0_1_3_0" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deepseq, ghc-prim
+     , QuickCheck, test-framework, test-framework-quickcheck2, zlib
+     }:
+     mkDerivation {
+       pname = "zstd";
+       version = "0.1.3.0";
+       sha256 = "0vghl48cxcqy72sqk2gpi7rvy5ya36j13vndaxi6kck6bqivbhm0";
+       libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
+       testHaskellDepends = [
+         base bytestring QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion ghc-prim zlib
+       ];
+       description = "Haskell bindings to the Zstandard compression algorithm";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "zsyntax" = callPackage

pkgs/development/python-modules/aioesphomeapi/default.nix

···
 
 buildPythonPackage rec {
   pname = "aioesphomeapi";
-  version = "9.1.1";
+  version = "9.1.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "esphome";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1bkk6mj1h1zhhp4s1ps6g950vzgfbxdj9pw762fz238p48ccw90b";
+    sha256 = "sha256-rgRXJ0kbIHg8QpYdBXJ5KA2kU6lV14yuVfj5OjQvmU8=";
   };
 
   propagatedBuildInputs = [

pkgs/development/tools/analysis/tfsec/default.nix

···
 
 buildGoPackage rec {
   pname = "tfsec";
-  version = "0.58.11";
+  version = "0.58.12";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-IapWH7bkjrFmdkGHUHROECmfF3su4HtJJ8Ii5a4GSRg=";
+    sha256 = "sha256-+djNbTr4TBo3KJ2skQysfrhVp9Q+HuaeB1UCzASB1+w=";
   };
 
   goPackagePath = "github.com/aquasecurity/tfsec";

pkgs/development/tools/htmltest/default.nix

···
 
 buildGoModule rec {
   pname = "htmltest";
-  version = "0.14.0";
+  version = "0.15.0";
 
   src = fetchFromGitHub {
     owner = "wjdp";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0z2j54ywim1nl10vidcnbwhywyzanj4qd93ai533808wrm3ghwb6";
+    sha256 = "sha256-lj+bR27huswHemF8M+G69PblqnQQUWsg4jtLfz89yVY=";
   };
 
   vendorSha256 = "0zx3ii9crick647kslzwg4d39li6jds938f9j9dp287rhrlzjfbm";
+
+  ldflags = [
+    "-w"
+    "-s"
+    "-X main.version=${version}"
+  ];
 
   # tests require network access
   doCheck = false;

pkgs/development/tools/packer/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub, installShellFiles, fetchpatch }:
+{ lib, buildGoModule, fetchFromGitHub, installShellFiles }:
 
 buildGoModule rec {
   pname = "packer";
-  version = "1.7.5";
+  version = "1.7.6";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "packer";
     rev = "v${version}";
-    sha256 = "15kw4zy0p7hr6jm0202s0fk5ja3ff0pdir37qdifngm1x7id1vxc";
+    sha256 = "sha256-nZeOtV6sbgzUhDOlWJ5eLzOh0gsaukXFrPg3y8x9ce4=";
   };
 
-  vendorSha256 = "1785yv48sn504zcig9szjw9s4dxb55dg9idh10i2gzfgbda2c3nf";
-
-  patches = [
-    # https://github.com/hashicorp/packer/pull/11282
-    (fetchpatch {
-      url = "https://github.com/hashicorp/packer/commit/dbf13803217e18c6cb567ffefc9476c4e0149e02.patch";
-      sha256 = "1n038x6qnr75c5ci2jp8jcwp6yvlchcf2nydksb2s75ffvidjrsa";
-    })
-  ];
+  vendorSha256 = "sha256-zg4mVFvP/SciCLDF9FopqzeiE5dfpxfZJ6BYjcj2BZ0=";
 
   subPackages = [ "." ];
 

pkgs/misc/vim-plugins/generated.nix

···
 
   aniseed = buildVimPluginFrom2Nix {
     pname = "aniseed";
-    version = "2021-09-29";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "Olical";
       repo = "aniseed";
-      rev = "6e1bee1c2bef907eb5361fd8d4e8014b9c122c47";
-      sha256 = "1x96zv6p5x8n2yy4m9ndggilvg6x6sqy3805mn7k2hc8zma91v3i";
+      rev = "f764c5cf633a89ea71a41055413e3a36acb43541";
+      sha256 = "1za93194wdhw29fz6z4lj8xh8cq38gq9sdavc2syyc50amfqpxh3";
     };
     meta.homepage = "https://github.com/Olical/aniseed/";
   };
···
       sha256 = "1xrc3zs9jz7dvdfhfx9ikg7abxgvjns0iqr9yzn3jzqm4a37zc62";
     };
     meta.homepage = "https://github.com/f3fora/cmp-spell/";
+  };
+
+  cmp-tabnine = buildVimPluginFrom2Nix {
+    pname = "cmp-tabnine";
+    version = "2021-09-30";
+    src = fetchFromGitHub {
+      owner = "tzachar";
+      repo = "cmp-tabnine";
+      rev = "71fd46be319f96dc35ecda2fb2641a643c1ca3ba";
+      sha256 = "08kqzhzx90r06hjbbr5y79bh4xgg4nj73lsam0wcvq6xyjh7qbnn";
+    };
+    meta.homepage = "https://github.com/tzachar/cmp-tabnine/";
   };
 
   cmp-treesitter = buildVimPluginFrom2Nix {
···
 
   conjure = buildVimPluginFrom2Nix {
     pname = "conjure";
-    version = "2021-09-29";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "Olical";
       repo = "conjure";
-      rev = "22f62e95b19cb5758e4738843165ee7796598f1f";
-      sha256 = "1dlz9gm6pb9f26d820idb7b9qk65ajzjldx1vmfyzp8abbp2mdfy";
+      rev = "2c1105f1e21544db614caed82b2873b563b31620";
+      sha256 = "1ndh772dml8d4y347smlg7bap2h6mnd3q77canzgashj1ramk4rh";
     };
     meta.homepage = "https://github.com/Olical/conjure/";
   };
···
     src = fetchFromGitHub {
       owner = "saecki";
       repo = "crates.nvim";
-      rev = "7f4cfb543541abea7de564434063415d2b0d3ba5";
-      sha256 = "0g0xnzsavvqd49vikcfkjw93avw655kc7h9mqz6yjfkqj65zy3lq";
+      rev = "3a77d7af5fe50e1a8e56dcd79e78ae2e221e4cde";
+      sha256 = "13yg5d4vndm81kaas62ga0nlx0srfpcg8cwfj70g7410kqfph9m3";
     };
     meta.homepage = "https://github.com/saecki/crates.nvim/";
   };
···
 
   fzf-lsp-nvim = buildVimPluginFrom2Nix {
     pname = "fzf-lsp.nvim";
-    version = "2021-09-27";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "gfanto";
       repo = "fzf-lsp.nvim";
-      rev = "6ccdcc3527848af12093a6e4c47dc8cbbe59b8dd";
-      sha256 = "0a5d17ik3jvxd0nv3djp4x2drxbg121pl4v1gn2bgwl2mf0rgdn5";
+      rev = "880de9e83a3390a1c15fb20ad24fa48006d8cefd";
+      sha256 = "1xrhqb8dsfhf2v0kb0k8fdmizaxsyf1dlryrynyn8v4s644h7zyl";
     };
     meta.homepage = "https://github.com/gfanto/fzf-lsp.nvim/";
   };
···
 
   luasnip = buildVimPluginFrom2Nix {
     pname = "luasnip";
-    version = "2021-09-30";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "l3mon4d3";
       repo = "luasnip";
-      rev = "40d9886a4294ecd28fed72324de7b6afb43b67af";
-      sha256 = "1wvw18k2afpnica53l18ixrkdqbb5d5g84sk9nz1nbnk6skhfbah";
+      rev = "0349dccdfe9bb27af5280dc252cd38ca61f2fbbf";
+      sha256 = "0sqy2bk10dpfn1fh3cfk2j8szc5na2cci6gslp0bl8gwj8xiwvgn";
     };
     meta.homepage = "https://github.com/l3mon4d3/luasnip/";
   };
···
 
   null-ls-nvim = buildVimPluginFrom2Nix {
     pname = "null-ls.nvim";
-    version = "2021-09-29";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "null-ls.nvim";
-      rev = "9d179a26ff974dbd0d3729c2603bc958cf929876";
-      sha256 = "08jwaj8n2n8d6c0xcgn4kgypyclcd3jr84wlk2p7jmr8m5q36xi6";
+      rev = "27d30e43b8ecd0623463ff8e71f7c1bb989b7e21";
+      sha256 = "1ikyi99mgysf1b780cldrqm0pym2023wxi1a6s55v7pm649xnrwy";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";
   };
···
     src = fetchFromGitHub {
       owner = "windwp";
       repo = "nvim-autopairs";
-      rev = "ff985c71417bceb168c5415813e40e656e3ea9ed";
-      sha256 = "1khff4grbldrc086w9mgnig5k2hrwmh61pn0wsn4kb1fjd09snf3";
+      rev = "e93e047051e4dbf034930fea19ec8e90c1cb6260";
+      sha256 = "19784jb3r52c8ccbgvr2d4jva1r3czadhrf5ij9j57wdf5mp12xx";
     };
     meta.homepage = "https://github.com/windwp/nvim-autopairs/";
   };
···
 
   nvim-notify = buildVimPluginFrom2Nix {
     pname = "nvim-notify";
-    version = "2021-09-09";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "rcarriga";
       repo = "nvim-notify";
-      rev = "2f5559d38967587d4982bd70002b6e8091a7dfb3";
-      sha256 = "0a51z3a2n9k80s60palm1gdry3n5zfv8vs8swvqla9zjvj3d960h";
+      rev = "dfaf5b90a8a827cb541b201218aeb0062cd8f312";
+      sha256 = "0scfh3y54cwczn9iwjbwczqxj9bnc025mkxw2l0bqzfp9a157d0a";
     };
     meta.homepage = "https://github.com/rcarriga/nvim-notify/";
   };
···
 
   nvim-tree-lua = buildVimPluginFrom2Nix {
     pname = "nvim-tree.lua";
-    version = "2021-09-30";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "kyazdani42";
       repo = "nvim-tree.lua";
-      rev = "1b04082872aaa4b58f0259a2b049402a88be67b6";
-      sha256 = "026llwfds8lm2asyriwdqvk279ka1zjz2ig4aiyv56dw6lxh0ycp";
+      rev = "7c88a0f8ee6250a8408c28e0b03a4925b396c916";
+      sha256 = "1cqz25d619yhrvk3l4asr6vsyynip092difimmp6c1i5nb6hv6sx";
     };
     meta.homepage = "https://github.com/kyazdani42/nvim-tree.lua/";
   };
···
     src = fetchFromGitHub {
       owner = "kristijanhusak";
       repo = "orgmode.nvim";
-      rev = "f6c8746f9b637d7e8a8255638989bff5fc46c302";
-      sha256 = "0pdp642cmf1rpv6glsp38ak8ksfxw7q2xwa9ia8vlbdqky92rw3i";
+      rev = "a94f7b8169ed9cbb8ca0d1ef9701fdcd2f4c4bbc";
+      sha256 = "0yf4nc7yywh22a44892cppilq58hd4dvlwn0v9jdl7p1b1fng9kc";
     };
     meta.homepage = "https://github.com/kristijanhusak/orgmode.nvim/";
   };
···
 
   vim-matchup = buildVimPluginFrom2Nix {
     pname = "vim-matchup";
-    version = "2021-09-29";
+    version = "2021-10-01";
     src = fetchFromGitHub {
       owner = "andymass";
       repo = "vim-matchup";
-      rev = "74cbb6b941efc91b236f655ed2f7ac4b6ab55c77";
-      sha256 = "089w05rlb0pgviz0gx6qwjiqainic3jbfd4myk4q93j6icy7ppgb";
+      rev = "870df0bb741eed49d093268593bce385bd82a41a";
+      sha256 = "185jbg2i49vknfy64s811dppwgw1d4lq8q97q0rrnvh7w6q88wl8";
     };
     meta.homepage = "https://github.com/andymass/vim-matchup/";
   };

pkgs/misc/vim-plugins/overrides.nix

···
     '';
   });
 
+  cmp-tabnine = super.cmp-tabnine.overrideAttrs (old: {
+    buildInputs = [ tabnine ];
+
+    postFixup = ''
+      mkdir -p $target/binaries/${tabnine.version}
+      ln -s ${tabnine}/bin/ $target/binaries/${tabnine.version}/${tabnine.passthru.platform}
+    '';
+  });
+
   command-t = super.command-t.overrideAttrs (old: {
     buildInputs = [ ruby rake ];
     buildPhase = ''

pkgs/misc/vim-plugins/vim-plugin-names

···
 tyru/caw.vim
 tyru/open-browser-github.vim
 tyru/open-browser.vim
+tzachar/cmp-tabnine@main
 tzachar/compe-tabnine@main
 uarun/vim-protobuf
 udalov/kotlin-vim

pkgs/os-specific/linux/kernel/hardened/patches.json

···
     },
     "5.10": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.10.69-hardened1.patch",
-        "sha256": "11frhnprvxnqxm8yn1kay2jv2i473i9glnvsjnqz6kj8f0q2gl4v",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.10.69-hardened1/linux-hardened-5.10.69-hardened1.patch"
+        "name": "linux-hardened-5.10.70-hardened1.patch",
+        "sha256": "12r6x7v7n3f7c7pn86ivykg6gqmqlzwrsncdkvj5qf7raw38ad5r",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.10.70-hardened1/linux-hardened-5.10.70-hardened1.patch"
     },
     "5.14": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.14.8-hardened1.patch",
-        "sha256": "1kg02ixyd2dbk97iz28g26k1nnxi96s0bcyr90wc7diylhf7kz4a",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.14.8-hardened1/linux-hardened-5.14.8-hardened1.patch"
+        "name": "linux-hardened-5.14.9-hardened1.patch",
+        "sha256": "190588p6xw65y1f106zgnv5s043yi633vg0zdbz85qjz27g49db8",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.14.9-hardened1/linux-hardened-5.14.9-hardened1.patch"
     },
     "5.4": {
         "extra": "-hardened1",
-        "name": "linux-hardened-5.4.149-hardened1.patch",
-        "sha256": "1v21dz66ngsdsdcld23rgmidz955x74al5nsxnvwasc5gh18ahh9",
-        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.4.149-hardened1/linux-hardened-5.4.149-hardened1.patch"
+        "name": "linux-hardened-5.4.150-hardened1.patch",
+        "sha256": "0vaxp5lfs7d5py0530sdhz8yzbzjxlwaam63mflwfd4mm8gf3ggc",
+        "url": "https://github.com/anthraxx/linux-hardened/releases/download/5.4.150-hardened1/linux-hardened-5.4.150-hardened1.patch"
     }
 }

pkgs/os-specific/linux/kernel/linux-5.10.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.10.69";
+  version = "5.10.70";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "1jhcl8qh4w4m2jnbp0glr6xbpn7phv17q6w3d247djnc7g2rwbr3";
+    sha256 = "0cmj5l425c6kkaplcp1y692j123lhyqq2jgfi642jzqxf4rnqwvm";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-5.14.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.14.8";
+  version = "5.14.9";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "12cvvrxky92z1g9kj7pgb83yg9pnv2fvi7jf0pyagvqjqladl3na";
+    sha256 = "1rl77k40xp9j0y8q5bgmhfmwiwbrdxjcsaw8dris456mjbdhg3xs";
   };
 } // (args.argsOverride or { }))

pkgs/os-specific/linux/kernel/linux-5.4.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.4.149";
+  version = "5.4.150";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "1s1zka0iay0drgkdnmzf587jbrg1gx13xv26k5r1qc7dik8xc6p7";
+    sha256 = "18iaqsbqlvk0j71d4q4h99ah300s0i7jwspr2x6g01shn2xsj97l";
   };
 } // (args.argsOverride or {}))

pkgs/os-specific/linux/kernel/linux-xanmod.nix

···
 { lib, stdenv, buildLinux, fetchFromGitHub, ... } @ args:
 
 let
-  version = "5.14.8";
+  version = "5.14.9";
   release = "1";
   suffix = "xanmod${release}-cacule";
 in
···
     owner = "xanmod";
     repo = "linux";
     rev = modDirVersion;
-    sha256 = "sha256-ikASMx5Lbp2BUfjMppnT8Y0UZdKMWqTze78XYoUTeiU=";
+    sha256 = "sha256-CMCZjuK9ofRup05l7HNg87jHTg4jOGrkmtvoxuNGwXE=";
   };
 
   structuredExtraConfig = with lib.kernel; {

pkgs/servers/sql/postgresql/ext/age.nix

···
 
 stdenv.mkDerivation rec {
   pname = "age";
-  version = "0.2.0";
+  version = "0.6.0";
 
   src = fetchFromGitHub {
-    owner = "bitnine-oss";
-    repo = "AgensGraph-Extension";
+    owner = "apache";
+    repo = "incubator-age";
     rev = "v${version}";
-    sha256 = "0way59lj30727jlz2qz6rnw4fsxcd5028xcwgrwk7jxcaqi5fa17";
+    sha256 = "1cl6p9qz2yhgm603ljlyjdn0msk3hzga1frjqsmqmpp3nw4dbkka";
   };
 
   buildInputs = [ postgresql ];
···
 
   meta = with lib; {
     description = "A graph database extension for PostgreSQL";
-    homepage = "https://github.com/bitnine-oss/AgensGraph-Extension";
-    changelog = "https://github.com/bitnine-oss/AgensGraph-Extension/releases/tag/v${version}";
+    homepage = "https://age.apache.org/";
+    changelog = "https://github.com/apache/incubator-age/releases/tag/v${version}";
     maintainers = with maintainers; [ ];
     platforms = postgresql.meta.platforms;
     license = licenses.asl20;

pkgs/servers/sql/postgresql/ext/pg_bigm.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pg_bigm";
-  version = "1.2";
+  version = "1.2-20200228";
 
   src = fetchurl {
-    url = "mirror://osdn/pgbigm/66565/${pname}-${version}-20161011.tar.gz";
-    sha256 = "1jp30za4bhwlas0yrhyjs9m03b1sj63km61xnvcbnh0sizyvhwis";
+    url = "mirror://osdn/pgbigm/72448/${pname}-${version}.tar.gz";
+    sha256 = "1hxn90prldwriqmqlf33ypgbxw5v54gkzx1305yzghryzfg7rhbl";
   };
 
   buildInputs = [ postgresql ];

pkgs/servers/sql/postgresql/ext/pgrouting.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pgrouting";
-  version = "3.1.3";
+  version = "3.2.1";
 
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ postgresql boost ];
···
     owner  = "pgRouting";
     repo   = pname;
     rev    = "v${version}";
-    sha256 = "sha256-ahDQ+nSTeIsdjID/ZwiGZCVBzOf0/oQs3SYsFYEEoxY=";
+    sha256 = "1zn3yyp4zz14yn2mmqwn7c4m65zfb2nj9zg4qj97ppsahs5xc6vw";
   };
 
   installPhase = ''

pkgs/servers/sql/postgresql/ext/plr.nix

···
 
 stdenv.mkDerivation rec {
   pname = "plr";
-  version = "8.4.1";
+  version = "8.4.4";
 
   src = fetchFromGitHub {
     owner = "postgres-plr";
     repo = "plr";
     rev = "REL${builtins.replaceStrings ["."] ["_"] version}";
-    sha256 = "1wy4blg8jl30kzhrkvbncl4gmy6k71zipnq89ykwi1vmx89v3ab7";
+    sha256 = "15dygf8klx2a4kzpmc1qnch629gcaa43ba1p3cqk9r1db4ima24k";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
   '';
   installPhase = ''
     install -D plr.so -t $out/lib/
-    install -D {plr--unpackaged--8.4.1.sql,plr--8.4.1.sql,plr.control} -t $out/share/postgresql/extension
+    install -D {plr--*.sql,plr.control} -t $out/share/postgresql/extension
   '';
 
   meta = with lib; {
     description = "PL/R - R Procedural Language for PostgreSQL";
     homepage = "https://github.com/postgres-plr/plr";
     maintainers = with maintainers; [ qoelet ];
-    platforms = [ "x86_64-linux" ];
+    platforms = postgresql.meta.platforms;
     license = licenses.gpl2Only;
   };
 }

pkgs/tools/misc/kalker/default.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "kalker";
-  version = "1.0.0";
+  version = "1.0.1-2";
 
   src = fetchFromGitHub {
     owner = "PaddiM8";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-1iZvp30/V0bw9NBxiKNiDgOMYJkDsGhTGdBsAPggdEg=";
+    sha256 = "sha256-fXTsCHqm+wO/ygyg0y+44G9pgaaEEH9fgePCDH86/vU=";
   };
 
-  cargoSha256 = "sha256-fBWnMlOLgwrOBPS2GIfOUDHQHcMMaU5r9JZVMbA+W58=";
+  cargoSha256 = "sha256-Ul21otEYCJuX5GnfV9OTpk/+3y32biASYZQpOecr8aU=";
 
-  # https://gitlab.com/tspiteri/gmp-mpfr-sys/-/issues/20
-  nativeBuildInputs = [ gcc ];
   buildInputs = [ gmp mpfr libmpc ];
 
   outputs = [ "out" "lib" ];

pkgs/tools/networking/wget2/default.nix

···
 , autoreconfHook
 , flex
 , gnulib
-, lzip
 , pkg-config
-, python3
 , texinfo
   # libraries
 , brotli
···
 , libhsts
 , libidn2
 , libpsl
-, xz
+, lzip
 , nghttp2
-, sslSupport ? true
 , openssl
 , pcre2
+, sslSupport ? true
+, xz
 , zlib
 , zstd
 }:
 
 stdenv.mkDerivation rec {
   pname = "wget2";
-  version = "1.99.2";
+  version = "2.0.0";
+
+  outputs = [ "out" "lib" "dev" ];
 
   src = fetchFromGitLab {
     owner = "gnuwget";
     repo = pname;
-    rev = version;
-    sha256 = "1gws8y3z8xzi46c48n7jb162mr3ar4c34s7yy8kjcs14yzq951qz";
+    rev = "v${version}";
+    sha256 = "07zs2x2k62836l0arzc333j96yjpwal1v4mr8j99x6qxgmmssrbj";
   };
 
   patches = [
     (fetchpatch {
-      name = "fix-autotools-2.70.patch";
-      url = "https://gitlab.com/gnuwget/wget2/-/commit/580af869093cfda6bc8a9d5901850354a16b3666.patch";
-      sha256 = "1x6wq4wxvvy6174d52qrhxkcgmv366f8smxyki49zb6rs4gqhskd";
+      name = "fix-bashism-in-configure-ac.patch";
+      url = "https://gitlab.com/gnuwget/wget2/-/commit/da9788f5d62b89ba796393d9bc496b1d8d7a7b30.patch";
+      sha256 = "0bn3vkgyknks7jzs5722s2c4qlx7k5lwfiyz204bi42v1m28s1a5";
     })
     (fetchpatch {
-      name = "update-potfiles-for-gnulib-2020-11-28.patch";
-      url = "https://gitlab.com/gnuwget/wget2/-/commit/368deb9fcca0c281f9c76333607cc878c3945ad0.patch";
-      sha256 = "1qsz8hbzbgg14wikxsbjjlq0cp3jw4pajbaz9wdn6ny617hdvi8y";
+      name = "fix-double-quotes-in-configure-ac.patch";
+      url = "https://gitlab.com/gnuwget/wget2/-/commit/574c8ae08dfd8949da039879d85899123d31ab1d.patch";
+      sha256 = "14rfmij5w3bvj0fnkkkrxg0lfw3vgwiyvbkal3nqhgb0mlhlmd47";
     })
   ];
 
   # wget2_noinstall contains forbidden reference to /build/
   postPatch = ''
     substituteInPlace src/Makefile.am \
-      --replace 'bin_PROGRAMS = wget2 wget2_noinstall' 'bin_PROGRAMS = wget2'
+      --replace "bin_PROGRAMS = wget2 wget2_noinstall" "bin_PROGRAMS = wget2"
   '';
 
-  nativeBuildInputs = [ autoreconfHook flex lzip pkg-config python3 texinfo ];
+  strictDeps = true;
+
+  nativeBuildInputs = [
+    autoreconfHook
+    flex
+    lzip
+    pkg-config
+    texinfo
+  ];
 
-  buildInputs = [ brotli bzip2 gpgme libhsts libidn2 libpsl xz nghttp2 pcre2 zlib zstd ]
-    ++ lib.optional sslSupport openssl;
+  buildInputs = [
+    brotli
+    bzip2
+    gpgme
+    libhsts
+    libidn2
+    libpsl
+    nghttp2
+    pcre2
+    xz
+    zlib
+    zstd
+  ] ++ lib.optional sslSupport openssl;
 
   # TODO: include translation files
   autoreconfPhase = ''
···
     cp -r ${gnulib} gnulib
     chmod -R u+w gnulib/{build-aux,lib}
 
-    # fix bashisms can be removed when https://gitlab.com/gnuwget/wget2/-/commit/c9499dcf2f58983d03e659e2a1a7f21225141edf is in the release
-    sed 's|==|=|g' -i configure.ac
-
     ./bootstrap --no-git --gnulib-srcdir=gnulib --skip-po
   '';
 
   configureFlags = [
-    "--disable-static"
+    (lib.enableFeature false "shared")
     # TODO: https://gitlab.com/gnuwget/wget2/-/issues/537
     (lib.withFeatureAs sslSupport "ssl" "openssl")
   ];
-
-  outputs = [ "out" "lib" "dev" ];
 
   meta = with lib; {
     description = "successor of GNU Wget, a file and recursive website downloader.";

pkgs/tools/security/vault/default.nix

···
 
 buildGoModule rec {
   pname = "vault";
-  version = "1.8.2";
+  version = "1.8.3";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "vault";
     rev = "v${version}";
-    sha256 = "sha256-SFzThZX9oYBM7OGjlvWq1by1mUOA4qc89TMEvCZU9I0=";
+    sha256 = "sha256-7jJMF8pNCKkiOAY9sZEK0lOqP2/yBVqS3FaKOOz74XI=";
   };
 
-  vendorSha256 = "sha256-Fhj1qWv4NN5oHxS5xZt2BnLBPTTcxKq47Q1kd+60xY4=";
+  vendorSha256 = "sha256-j+07Q5dpt8I0sf5B3AVw4343EMWyJDqrzFrdDrBp0DY=";
 
   subPackages = [ "." ];
 

pkgs/tools/security/vault/vault-bin.nix

···
 { lib, stdenv, fetchurl, unzip, makeWrapper, gawk, glibc }:
 
 let
-  version = "1.8.2";
+  version = "1.8.3";
 
   sources = let
     base = "https://releases.hashicorp.com/vault/${version}";
   in {
     x86_64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_amd64.zip";
-      sha256 = "sha256-10ck1swivx4cfFGQCbAXaAms9vHCDuVhB94Mq1TNhGM=";
+      sha256 = "sha256-x1ZHemRyblfMgmG2zx3AnZmhn2Q952v3nzi3HEvlmE8=";
     };
     i686-linux = fetchurl {
       url = "${base}/vault_${version}_linux_386.zip";
-      sha256 = "0v8l056xs88mjpcfpi9k8chv0zk7lf80gkj580z3d37h2yr2b1gg";
+      sha256 = "1141zjf56fz76ka7bim9qkdk46pa3kk39swxza17g3qxpj21w0jp";
     };
     x86_64-darwin = fetchurl {
       url = "${base}/vault_${version}_darwin_amd64.zip";
-      sha256 = "1xabbndnx85zbhbwid30q0jii41hmwwlqrxz4a0rllqshvmq4fg3";
+      sha256 = "06bkka2k09alhps5h2dk0dgczgnnd6g4npjp9j103lvzi935zjsy";
     };
     aarch64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_arm64.zip";
-      sha256 = "00p2540bdhw46licab401vbwdyvp1hkngssx6nh99igj14sl60qa";
+      sha256 = "1z9pv46pgqnn34mc624x9z41kvr4hrjjdp6y9zv033h0cpxbd0y7";
     };
   };
 

pkgs/top-level/all-packages.nix

···
   hivelytracker = callPackage ../applications/audio/hivelytracker { };
 
   hledger = haskell.lib.justStaticExecutables haskellPackages.hledger;
+  hledger-check-fancyassertions = callPackage ../applications/office/hledger-check-fancyassertions { };
   hledger-iadd = haskell.lib.justStaticExecutables haskellPackages.hledger-iadd;
   hledger-interest = haskell.lib.justStaticExecutables haskellPackages.hledger-interest;
   hledger-ui = haskell.lib.justStaticExecutables haskellPackages.hledger-ui;

pkgs/top-level/release-haskell.nix

···
         hinit
         hedgewars
         hledger
+        hledger-check-fancyassertions
         hledger-iadd
         hledger-interest
         hledger-ui