Merge master into staging-next

nixos/doc/manual/release-notes/rl-2105.xml

···
      <link linkend="opt-boot.extraSystemdUnitPaths">boot.extraSystemdUnitPaths</link> list.
     </para>
    </listitem>
+   <listitem>
+    <para>
+     PostgreSQL 9.5 is scheduled EOL during the 21.05 life cycle and has been removed.
+    </para>
+   </listitem>
   </itemizedlist>
  </section>
 </section>

nixos/modules/services/databases/postgresql.nix

···
       # systems!
       mkDefault (if versionAtLeast config.system.stateVersion "20.03" then pkgs.postgresql_11
             else if versionAtLeast config.system.stateVersion "17.09" then pkgs.postgresql_9_6
-            else if versionAtLeast config.system.stateVersion "16.03" then pkgs.postgresql_9_5
-            else throw "postgresql_9_4 was removed, please upgrade your postgresql version.");
+            else throw "postgresql_9_5 was removed, please upgrade your postgresql version.");
 
     services.postgresql.dataDir = mkDefault "/var/lib/postgresql/${cfg.package.psqlSchema}";
 

nixos/modules/services/web-servers/nginx/default.nix

···
                 Defines the address and other parameters of the upstream servers.
               '';
               default = {};
+              example = { "127.0.0.1:8000" = {}; };
             };
             extraConfig = mkOption {
               type = types.lines;
···
           Defines a group of servers to use as proxy target.
         '';
         default = {};
+        example = literalExample ''
+          "backend_server" = {
+            servers = { "127.0.0.1:8000" = {}; };
+            extraConfig = ''''
+              keepalive 16;
+            '''';
+          };
+        '';
       };
 
       virtualHosts = mkOption {

pkgs/applications/blockchains/openethereum/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "openethereum";
-  version = "3.2.3";
+  version = "3.2.4";
 
   src = fetchFromGitHub {
     owner = "openethereum";
     repo = "openethereum";
     rev = "v${version}";
-    sha256 = "1j7wfgpnvf9pcprd53sbd3pa7yz9588z81i1bx12wmj1fja3xa0j";
+    sha256 = "143w0b0ff1s73qzr844l25w90d2y2z0b3w2fr5kkbc1wsnpcq7jp";
   };
 
-  cargoSha256 = "0ha18caw8mxzrh984y2z148cmdijrjxf0rc8j4ccwvmrbdsaz1xn";
+  cargoSha256 = "1gm02pcfll362add8a0dcb0sk0mag8z0q23b87yb6fs870bqvhib";
 
   LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
   nativeBuildInputs = [

pkgs/applications/editors/kakoune/plugins/generated.nix

···
 
   auto-pairs-kak = buildKakounePluginFrom2Nix {
     pname = "auto-pairs-kak";
-    version = "2020-10-04";
+    version = "2021-03-28";
     src = fetchFromGitHub {
       owner = "alexherbo2";
       repo = "auto-pairs.kak";
-      rev = "fd735ec149ef0d9ca5f628a95b1e52858b5afbdc";
-      sha256 = "07795kv9njlnp6mckwv141ny2ns6wyf5r0dfjaxh9ngd105zgif1";
+      rev = "526779a26a5cf5f48e7c4f5c5fecca274968a737";
+      sha256 = "0gkhvwxyh8pdfydrj7zkfidk0drrbhvdi1fq3pkzllna3vz8q181";
     };
     meta.homepage = "https://github.com/alexherbo2/auto-pairs.kak/";
   };
···
 
   fzf-kak = buildKakounePluginFrom2Nix {
     pname = "fzf-kak";
-    version = "2021-03-15";
+    version = "2021-04-03";
     src = fetchFromGitHub {
       owner = "andreyorst";
       repo = "fzf.kak";
-      rev = "4e6c9a857511fccdbbc835a1c9acb205b6486a4c";
-      sha256 = "0syhhdlsm7vg6hcd2n2acag9g562z49rbb5smh5p2gnplhmp93i0";
+      rev = "1b3a3beebbe7134e671fde2ef2f4242b34ae2c60";
+      sha256 = "0rsd65zcizbq3isy8576gqw7mcml5ixw84padaz6ndwfif5fv701";
     };
     meta.homepage = "https://github.com/andreyorst/fzf.kak/";
   };
···
 
   kakoune-buffers = buildKakounePluginFrom2Nix {
     pname = "kakoune-buffers";
-    version = "2020-06-11";
+    version = "2021-04-02";
     src = fetchFromGitHub {
       owner = "Delapouite";
       repo = "kakoune-buffers";
-      rev = "67959fbad727ba8470fe8cd6361169560f4fb532";
-      sha256 = "09prhzz4yzf6ryw0npd1gpcfp77681vgawpp1ilfvbf25xgbbz33";
+      rev = "7832ea7a4528363482f5684f16cbcebcbec0adfd";
+      sha256 = "196d36jww6asf5zr03l1rwg49kkv16s2d4zyryb2m3zvy7prf2bb";
     };
     meta.homepage = "https://github.com/Delapouite/kakoune-buffers/";
   };
···
     meta.homepage = "https://github.com/mayjs/openscad.kak/";
   };
 
+  pandoc-kak = buildKakounePluginFrom2Nix {
+    pname = "pandoc-kak";
+    version = "2020-11-30";
+    src = fetchFromGitHub {
+      owner = "basbebe";
+      repo = "pandoc.kak";
+      rev = "63979f7e08b86d80436bbe2d9dba173a56057b97";
+      sha256 = "16pmmnpyxf8r7gpj8g1lwa960nscjmcl52n1a7s6xcqkp9856wxs";
+    };
+    meta.homepage = "https://github.com/basbebe/pandoc.kak/";
+  };
+
   powerline-kak = buildKakounePluginFrom2Nix {
     pname = "powerline-kak";
-    version = "2021-02-25";
+    version = "2021-04-06";
     src = fetchFromGitHub {
       owner = "andreyorst";
       repo = "powerline.kak";
-      rev = "64ad98b6c85e63345563671b043960464d51c4b0";
-      sha256 = "09w2sk19qi64hgsyg4gb407vyppnlgk272mqbinz2r3apy6szkl3";
+      rev = "6fa5ad383f2884f201d6e3ef07a4687c606df525";
+      sha256 = "1s7ggjby0bymq48njzhdvkkarmzl44803xv0dlnzrj7q9c3xv27a";
     };
     meta.homepage = "https://github.com/andreyorst/powerline.kak/";
   };
···
 
   tabs-kak = buildKakounePluginFrom2Nix {
     pname = "tabs-kak";
-    version = "2021-02-16";
+    version = "2021-04-14";
     src = fetchFromGitHub {
       owner = "enricozb";
       repo = "tabs.kak";
-      rev = "1aaa8cd89e404cbbd76d44ff8089de0951612fbf";
-      sha256 = "0dfz6j6yxl65jbh4xvpiy2abr2sdjyalynzhl28y7l1gzqv4ni3j";
+      rev = "048f83455ea7c671ab06e9b9578ac25e5de1d6fb";
+      sha256 = "0xswpsdf1bj54inl6vf2lzbjkxfc6g0fyv5kd6y9ahlh5irij8z0";
     };
     meta.homepage = "https://github.com/enricozb/tabs.kak/";
   };

pkgs/applications/editors/kakoune/plugins/kakoune-plugin-names

···
 alexherbo2/sleuth.kak
 andreyorst/fzf.kak
 andreyorst/powerline.kak
+basbebe/pandoc.kak
 danr/kakoune-easymotion
 Delapouite/kakoune-buffers
 Delapouite/kakoune-registers

pkgs/applications/misc/dasel/default.nix

···
 
 buildGoModule rec {
   pname = "dasel";
-  version = "1.14.0";
+  version = "1.14.1";
 
   src = fetchFromGitHub {
     owner = "TomWright";
     repo = pname;
     rev = "v${version}";
-    sha256 = "1g4a001k86myfln0xlzy8w9krwamvfchnvywpr1p3x6iw95z46w8";
+    sha256 = "0nxdyd0zg4w1zr8p9z2x88h36vbn7ryk7160zszdiwh5qmdlv47v";
   };
 
   vendorSha256 = "sha256-BdX4DO77mIf/+aBdkNVFUzClsIml1UMcgvikDbbdgcY=";

pkgs/applications/misc/haunt/default.nix

···
+{ lib
+, stdenv
+, fetchurl
+, guile
+, guile-commonmark
+, guile-reader
+, makeWrapper
+, pkg-config
+}:
+
+stdenv.mkDerivation rec {
+  pname = "haunt";
+  version = "0.2.4";
+
+  src = fetchurl {
+    url = "https://files.dthompson.us/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-zOkICg7KmJJhPWPtJRT3C9sYB1Oig1xLtgPNGe0n3xQ=";
+  };
+
+  nativeBuildInputs = [
+    makeWrapper
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+    guile-commonmark
+    guile-reader
+  ];
+
+  postInstall = ''
+    wrapProgram $out/bin/haunt \
+      --prefix GUILE_LOAD_PATH : "$out/share/guile/site:${guile-commonmark}/share/guile/site:${guile-reader}/share/guile/site" \
+      --prefix GUILE_LOAD_COMPILED_PATH : "$out/share/guile/site:${guile-commonmark}/share/guile/site:${guile-reader}/share/guile/site"
+  '';
+
+  meta = with lib; {
+    homepage = "https://dthompson.us/projects/haunt.html";
+    description = "Guile-based static site generator";
+    longDescription = ''
+      Haunt is a simple, functional, hackable static site generator that gives
+      authors the ability to treat websites as Scheme programs.
+
+      By giving authors the full expressive power of Scheme, they are able to
+      control every aspect of the site generation process. Haunt provides a
+      simple, functional build system that can be easily extended for this
+      purpose.
+
+      Haunt has no opinion about what markup language authors should use to
+      write posts, though it comes with support for the popular Markdown
+      format. Likewise, Haunt has no opinion about how authors structure their
+      sites. Though it comes with support for building simple blogs or Atom
+      feeds, authors should feel empowered to tweak, replace, or create builders
+      to do things that aren't provided out-of-the-box.
+    '';
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ AndersonTorres ];
+    platforms = guile.meta.platforms;
+  };
+}

pkgs/applications/misc/stretchly/default.nix

···
 , electron
 , common-updater-scripts
 , writeShellScript
-, jq
 , makeDesktopItem
 }:
 
 stdenv.mkDerivation rec {
 
   pname = "stretchly";
-  version = "1.5.0";
+  version = "1.6.0";
 
   src = fetchurl {
     url = "https://github.com/hovancik/stretchly/releases/download/v${version}/stretchly-${version}.tar.xz";
-    sha256 = "19czwmwqsn82zdzln9zqqyl9sb3dm95gp58dqn1459gyinkzpvda";
+    sha256 = "1q0ihp6cd65lnscbr7xj3yyb06qds77r4s6m1xbk5l9vs2rw923d";
   };
 
   icon = fetchurl {

pkgs/applications/misc/yubioath-desktop/0001-replace-git-with-normal-python-package.patch

···
-From 5eb4d6a384753896d495b09d8651c48672ef234d Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?J=C3=B6rg=20Thalheim?= <[e-mail]>
-Date: Wed, 25 Nov 2020 11:26:49 +0100
-Subject: [PATCH] replace git with normal python package
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Signed-off-by: Jörg Thalheim <[e-mail]>
----
- requirements.txt | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/requirements.txt b/requirements.txt
-index ef25aad..b4246a4 100644
---- a/requirements.txt
-+++ b/requirements.txt
-@@ -1,2 +1,2 @@
--git+https://github.com/Yubico/yubikey-manager.git
-+yubikey-manager
- ./py/qr
--- 
-2.29.2
-

pkgs/applications/misc/yubioath-desktop/default.nix

···
 
 mkDerivation rec {
   pname = "yubioath-desktop";
-  version = "5.0.4";
+  version = "5.0.5";
 
   src = fetchurl {
     url = "https://developers.yubico.com/yubioath-desktop/Releases/yubioath-desktop-${version}.tar.gz";
-    sha256 = "1aw88xvg6gjsfwmmlcrdcgyycn2cp7b8vxjzj14h7igcj02xh84h";
+    sha256 = "05xs6xh9pi50h0668arirj0gnz11adpixgsdkds072077gasdm0g";
   };
 
   doCheck = false;
···
   buildInputs = [ stdenv qtbase qtquickcontrols2 qtgraphicaleffects python3 ];
 
   nativeBuildInputs = [ qmake makeWrapper python3.pkgs.wrapPython ];
-
-  patches = [
-    ./0001-replace-git-with-normal-python-package.patch
-  ];
 
   postPatch = ''
     substituteInPlace deployment.pri \
···
       cp resources/icons/*.{icns,ico,png,svg} $out/share/yubioath/icons
       substituteInPlace $out/share/applications/com.yubico.yubioath.desktop \
         --replace 'Exec=yubioath-desktop' "Exec=$out/bin/yubioath-desktop" \
-        --replace 'Icon=yubioath' "Icon=$out/share/yubioath/icons/com.yubico.yubioath.png"
+        --replace 'Icon=com.yubico.yubioath' "Icon=$out/share/yubioath/icons/com.yubico.yubioath.png"
   '';
 
   meta = with lib; {

pkgs/applications/networking/instant-messengers/profanity/default.nix

···
   # Enable feature flags, so that build fail if libs are missing
   configureFlags = [ "--enable-c-plugins" "--enable-otr" ]
     ++ optionals notifySupport       [ "--enable-notifications" ]
-    ++ optionals traySupport         [ "--enable-icons" ]
+    ++ optionals traySupport         [ "--enable-icons-and-clipboard" ]
     ++ optionals pgpSupport          [ "--enable-pgp" ]
     ++ optionals pythonPluginSupport [ "--enable-python-plugins" ]
     ++ optionals omemoSupport        [ "--enable-omemo" ];

pkgs/applications/networking/mailreaders/mailspring/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mailspring";
-  version = "1.8.0";
+  version = "1.9.0";
 
   src = fetchurl {
     url = "https://github.com/Foundry376/Mailspring/releases/download/${version}/mailspring-${version}-amd64.deb";
-    sha256 = "BtzYcHN87qH7s3GiBrsDfmuy9v2xdhCeSShu8+T9T3E=";
+    sha256 = "ISwNFR8M377+J7WoG9MlblF8r5yRTgCxEGszZCjqW/k=";
   };
 
   nativeBuildInputs = [
···
     alsaLib
     db
     glib
-    # We don't know why with trackerSupport the executable fail to launch, See:
-    # https://github.com/NixOS/nixpkgs/issues/106732
-    (gtk3.override {trackerSupport = false; })
+    gtk3
     libkrb5
     libsecret
     nss
···
   ];
 
   unpackPhase = ''
+    runHook preUnpack
+
     dpkg -x $src .
+
+    runHook postUnpack
   '';
 
   installPhase = ''
+    runHook preInstall
+
     mkdir -p $out/{bin,lib}
     cp -ar ./usr/share $out
 
···
 
     ln -s $out/share/mailspring/mailspring $out/bin/mailspring
     ln -s ${openssl.out}/lib/libcrypto.so $out/lib/libcrypto.so.1.0.0
+
+    runHook postInstall
   '';
 
   postFixup = /* sh */ ''
-    substituteInPlace $out/share/applications/mailspring.desktop \
-      --replace /usr/bin $out/bin
+    substituteInPlace $out/share/applications/Mailspring.desktop \
+      --replace Exec=mailspring Exec=$out/bin/mailspring
   '';
 
   meta = with lib; {
···
       Mailspring is an open-source mail client forked from Nylas Mail and built with Electron.
       Mailspring's sync engine runs locally, but its source is not open.
     '';
-    license = licenses.unfree;
-    maintainers = with maintainers; [ toschmidt ];
+    license = licenses.gpl3Plus;
+    maintainers = with maintainers; [ toschmidt doronbehar ];
     homepage = "https://getmailspring.com";
     downloadPage = "https://github.com/Foundry376/Mailspring";
     platforms = platforms.x86_64;

pkgs/applications/science/logic/coq/default.nix

···
    "8.12.2".sha256     = "18gscfm039pqhq4msq01nraig5dm9ab98bjca94zldf8jvdv0x2n";
    "8.13.0".sha256     = "0sjbqmz6qcvnz0hv87xha80qbhvmmyd675wyc5z4rgr34j2l1ymd";
    "8.13.1".sha256     = "0xx2ns84mlip9bg2mkahy3pmc5zfcgrjxsviq9yijbzy1r95wf0n";
+   "8.13.2".sha256     = "1884vbmwmqwn9ngibax6dhnqh4cc02l0s2ajc6jb1xgr0i60whjk";
   };
   releaseRev = v: "V${v}";
   fetched = import ../../../../build-support/coq/meta-fetch/default.nix

pkgs/applications/window-managers/neocomp/default.nix

···
 , libXinerama
 , libXrandr
 , libXrender
+, libXres
 , pcre
 , pkg-config
 }:
-let
-  rev   = "v0.6-17-g271e784";
-in
+
 stdenv.mkDerivation rec {
-  pname = "neocomp-unstable";
-  version = "2019-03-12";
+  pname = "neocomp";
+  version = "unstable-2021-04-06";
 
   src = fetchFromGitHub {
-    inherit rev;
-    owner  = "DelusionalLogic";
-    repo   = "NeoComp";
-    sha256 = "1mp338vz1jm5pwf7pi5azx4hzykmvpkwzx1kw6a9anj272f32zpg";
+    owner = "DelusionalLogic";
+    repo = "NeoComp";
+    rev = "ccd340d7b2dcd3f828aff958a638cc23686aee6f";
+    sha256 = "sha256-tLLEwpAGNVTC+N41bM7pfskIli4Yvc95wH2/NT0OZ+8=";
   };
 
-  buildInputs = [
+  nativeBuildInputs = [
     asciidoc
     docbook_xml_dtd_45
     docbook_xsl
+    pkg-config
+  ];
+
+  buildInputs = [
     freetype
     judy
     libGL
···
     libXinerama
     libXrandr
     libXrender
+    libXres
     pcre
-    pkg-config
   ];
 
   makeFlags = [
     "PREFIX=${placeholder "out"}"
     "CFGDIR=${placeholder "out"}/etc/xdg/neocomp"
     "ASTDIR=${placeholder "out"}/share/neocomp/assets"
-    "COMPTON_VERSION=git-${rev}-${version}"
+    "COMPTON_VERSION=${version}"
   ];
 
   postPatch = ''
···
 
   meta = with lib; {
     homepage        = "https://github.com/DelusionalLogic/NeoComp";
-    license         = licenses.gpl3;
-    maintainers     = with maintainers; [ twey ];
+    license         = licenses.gpl3Only;
+    maintainers     = with maintainers; [ twey fortuneteller2k ];
     platforms       = platforms.linux;
     description     = "A fork of Compton, a compositor for X11";
     longDescription = ''

pkgs/development/compilers/dmd/default.nix

···
     maintainers = with maintainers; [ ThomasMader lionello ];
     platforms = [ "x86_64-linux" "i686-linux" "x86_64-darwin" ];
     # many tests are failing
-    broken = true;
   };
 }

pkgs/development/compilers/dotnet/default.nix

···
 /*
 How to combine packages for use in development:
 dotnetCombined = with dotnetCorePackages; combinePackages [ sdk_3_1 sdk_2_2 sdk_3_0 sdk aspnetcore_2_1 ];
+
+Hashes below are retrived from:
+https://dotnet.microsoft.com/download/dotnet
 */
 { callPackage }:
 let
···
   };
 
   sdk_5_0 = buildNetCoreSdk {
-    version = "5.0.200";
+    version = "5.0.202";
     sha512 = {
-      x86_64-linux = "0g7zcmkcdwc11h42m6hq8d0w55nnvnsmj3dc16829q55cp7l7kggmjljnd9slx7r7nrsyi7yy8brwh8n4kfi5998pdyb09fzhq5w60d";
-      aarch64-linux = "2zy6nxiw313g2sbmnkg76r64llbk2w2wcsa6frq535zbviw52zf163jvw2687rpiw4szdizf337l3b0qa0396abw5dhq2czqlxjyjv8";
-      x86_64-darwin = "2p0yxplafhi5ks38pq8nyi43kpv4l4npa718rvcvl57qs76j0dqlk1s4wdw7msx8g7xxy1aal47zy9rxvlypmgwx4dnp339cmbd6mf6";
+      x86_64-linux = "Ae1Z8jYYSYdAVnPSSUDVXOKdgw59u8GVVv3AOJMDnmBGcS3m+QHcmREEeg3uT9FTGbfpT4ox32uYH6Nb2T2YOA==";
+      aarch64-linux = "JuwSWgY35xrK0gOGR034mhAemulIkhtd4M00P0vA6EtOeyMY4Vl4cj6zudMh6Jt5DD8EJKQ8KbABX8byuePp2Q==";
+      x86_64-darwin = "jxnfTbQUb0dJ2/NX2pu8Pi/F/e4EaDm2Ta5U+6sSYj/s6nNp6NHxtEn7BzhQ9/EVLszl/oXi3lL0d/BPbzldEA==";
     };
   };
 }

pkgs/development/compilers/go/1.16.nix

···
 
   inherit (lib) optionals optionalString;
 
-  version = "1.16.2";
+  version = "1.16.3";
 
   go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };
 
···
 
   src = fetchurl {
     url = "https://dl.google.com/go/go${version}.src.tar.gz";
-    sha256 = "1sl33wkhp6pi9f15f6khp5a7l7xwmpc3sp1zmji8pjr3g8l19jip";
+    sha256 = "sha256-spjSnekjbKR6Aj44IxO8wtLu0x36cGtgoEEDzoOnGiU=";
   };
 
   # perl is used for testing go vet

pkgs/development/compilers/roslyn/deps.nix

···
   }
   {
     name = "microsoft.netcore.app.host.linux-x64";
-    version = "3.1.12";
+    version = "3.1.14";
     src = fetchurl {
-      url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-x64/3.1.12/microsoft.netcore.app.host.linux-x64.3.1.12.nupkg";
-      sha256 = "1kp1sb7n1sb012v4k1xfv97n0x7k5r2rn0za8y8nbxjb2a4i4a8n";
+      url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.app.host.linux-x64/3.1.14/microsoft.netcore.app.host.linux-x64.3.1.14.nupkg";
+      sha256 = "11rqnascx9asfyxgxzwgxgr9gxxndm552k4dn4p1s57ciz7vkg9h";
     };
   }
   {

pkgs/development/guile-modules/guile-cairo/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, guile, guile-lib, cairo, expat }:
+{ lib
+, stdenv
+, fetchurl
+, cairo
+, expat
+, guile
+, guile-lib
+, pkg-config
+}:
 
 stdenv.mkDerivation rec {
   pname = "guile-cairo";
   version = "1.11.2";
 
   src = fetchurl {
-    url = "mirror://savannah/guile-cairo/${pname}-${version}.tar.gz";
-    sha256 = "0yx0844p61ljd4d3d63qrawiygiw6ks02fwv2cqx7nav5kfd8ck2";
+    url = "mirror://savannah/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-YjLU3Cxb2dMxE5s7AfQ0PD4fucp4mDYaaZIGcwlBoHs=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [
+    cairo
+    expat
+    guile
+  ];
 
-  buildInputs = [ guile cairo expat ];
   enableParallelBuilding = true;
 
   doCheck = false; # Cannot find unit-test module from guile-lib
   checkInputs = [ guile-lib ];
 
   meta = with lib; {
+    homepage = "https://www.nongnu.org/guile-cairo/";
     description = "Cairo bindings for GNU Guile";
     longDescription = ''
       Guile-Cairo wraps the Cairo graphics library for Guile Scheme.
···
       maintained graphics library with all of the benefits of Scheme: memory
       management, exceptions, macros, and a dynamic programming environment.
     '';
-    homepage = "https://www.nongnu.org/guile-cairo/";
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.linux;

pkgs/development/guile-modules/guile-commonmark/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, guile
+, pkg-config
+}:
+
+stdenv.mkDerivation rec {
+  pname = "guile-commonmark";
+  version = "0.1.2";
+
+  src = fetchFromGitHub {
+    owner = "OrangeShark";
+    repo = pname;
+    rev = "v${version}";
+    hash = "sha256-qYDcIiObKOU8lmcfk327LMPx/2Px9ecI3QLrSWWLxMo=";
+  };
+
+  nativeBuildInputs = [
+    autoreconfHook
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+  ];
+
+  # https://github.com/OrangeShark/guile-commonmark/issues/20
+  doCheck = false;
+
+  makeFlags = [
+    "GUILE_AUTO_COMPILE=0"
+  ];
+
+  meta = with lib; {
+    homepage = "https://github.com/OrangeShark/guile-commonmark";
+    description = "Implementation of CommonMark for Guile";
+    license = licenses.lgpl3Plus;
+    maintainers = with maintainers; [ AndersonTorres ];
+    platforms = guile.meta.platforms;
+  };
+}

pkgs/development/guile-modules/guile-fibers/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, guile, texinfo }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, guile
+, pkg-config
+, texinfo
+}:
 
-let
+stdenv.mkDerivation rec {
+  pname = "guile-fibers";
   version = "1.0.0";
-  name = "guile-fibers-${version}";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchFromGitHub {
     owner = "wingo";
     repo = "fibers";
     rev = "v${version}";
-    sha256 = "1r47m1m112kxf23xny99f0qkqsk6626iyc5jp7vzndfiyp5yskwi";
+    hash = "sha256-kU/ty/XRNfv3ubIwH40wZmo8MXApeduHcH2KEGqoh+Q=";
   };
 
-  nativeBuildInputs = [ autoreconfHook pkg-config ];
-  buildInputs = [ guile texinfo ];
+  nativeBuildInputs = [
+    autoreconfHook
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+    texinfo
+  ];
 
   autoreconfPhase = "./autogen.sh";
 
   meta = with lib; {
-    description = "Concurrent ML-like concurrency for Guile";
     homepage = "https://github.com/wingo/fibers";
+    description = "Concurrent ML-like concurrency for Guile";
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.linux;

pkgs/development/guile-modules/guile-gnome/default.nix

···
-{ fetchurl, lib, stdenv, guile, guile-lib, gwrap
-, pkg-config, gconf, glib, gnome_vfs, gtk2
-, libglade, libgnome, libgnomecanvas, libgnomeui
-, pango, guile-cairo, texinfo
+{ lib
+, stdenv
+, fetchurl
+, gconf
+, glib
+, gnome_vfs
+, gtk2
+, guile
+, guile-cairo
+, guile-lib
+, gwrap
+, libglade
+, libgnome
+, libgnomecanvas
+, libgnomeui
+, pango
+, pkg-config
+, texinfo
 }:
 
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://gnu/guile-gnome/${pname}/${pname}-${version}.tar.gz";
-    sha256 = "adabd48ed5993d8528fd604e0aa0d96ad81a61d06da6cdd68323572ad6c216c3";
+    hash = "sha256-ravUjtWZPYUo/WBOCqDZatgaYdBtps3WgyNXKtbCFsM=";
   };
 
+  nativeBuildInputs = [
+    pkg-config
+    texinfo
+  ];
   buildInputs = [
-    texinfo guile gwrap pkg-config gconf glib gnome_vfs gtk2
-    libglade libgnome libgnomecanvas libgnomeui pango guile-cairo
+    gconf
+    glib
+    gnome_vfs
+    gtk2
+    guile
+    guile-cairo
+    gwrap
+    libglade
+    libgnome
+    libgnomecanvas
+    libgnomeui
+    pango
   ] ++ lib.optional doCheck guile-lib;
 
   # The test suite tries to open an X display, which fails.
   doCheck = false;
 
-  GUILE_AUTO_COMPILE = 0;
+  makeFlags = [
+    "GUILE_AUTO_COMPILE=0"
+  ];
 
   meta = with lib; {
+    homepage = "https://www.gnu.org/software/guile-gnome/";
     description = "GNOME bindings for GNU Guile";
     longDescription = ''
       GNU guile-gnome brings the power of Scheme to your graphical application.
···
       guile-gnome a comprehensive environment for developing modern
       applications.
     '';
-    homepage = "https://www.gnu.org/software/guile-gnome/";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.linux;

pkgs/development/guile-modules/guile-lib/default.nix

···
-{ lib, stdenv, fetchurl, guile, texinfo, pkg-config }:
+{ lib
+, stdenv
+, fetchurl
+, guile
+, pkg-config
+, texinfo
+}:
 
 assert stdenv ? cc && stdenv.cc.isGNU;
 
-let
-  name = "guile-lib-${version}";
+stdenv.mkDerivation rec {
+  pname = "guile-lib";
   version = "0.2.6.1";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "mirror://savannah/guile-lib/${name}.tar.gz";
-    sha256 = "0aizxdif5dpch9cvs8zz5g8ds5s4xhfnwza2il5ji7fv2h7ks7bd";
+    url = "mirror://savannah/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-bR09DxTbnSgLjUJ9bh3sRBfd0Cv/I71Zguy24mLrPyo=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ guile texinfo ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+    texinfo
+  ];
 
   doCheck = true;
 
···
   '';
 
   meta = with lib; {
+    homepage = "https://www.nongnu.org/guile-lib/";
     description = "A collection of useful Guile Scheme modules";
     longDescription = ''
       guile-lib is intended as an accumulation place for pure-scheme Guile
···
       modules into a coherent library.  Think "a down-scaled, limited-scope CPAN
       for Guile".
     '';
-    homepage = "https://www.nongnu.org/guile-lib/";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.gnu ++ platforms.linux;

pkgs/development/guile-modules/guile-ncurses/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, guile, ncurses, libffi }:
+{ lib
+, stdenv
+, fetchurl
+, pkg-config
+, guile
+, libffi
+, ncurses
+}:
 
-let
-  name = "guile-ncurses-${version}";
+stdenv.mkDerivation rec {
+  pname = "guile-ncurses";
   version = "1.7";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "mirror://gnu/guile-ncurses/${name}.tar.gz";
-    sha256 = "153vv75gb7l62sp3666rc97i63rnaqbx2rjar7d9b5w81fhwv4r5";
+    url = "mirror://gnu/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-JZPNoQuIl5XayUpm0RdWNg8TT2LZGDOuFoae9crZe5Q=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ guile ncurses libffi ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+    libffi
+    ncurses
+  ];
 
   preConfigure = ''
     configureFlags="$configureFlags --with-guilesitedir=$out/share/guile/site"
···
   doCheck = false;
 
   meta = with lib; {
+    homepage = "https://www.gnu.org/software/guile-ncurses/";
     description = "Scheme interface to the NCurses libraries";
     longDescription = ''
       GNU Guile-Ncurses is a library for the Guile Scheme interpreter that
···
       interface functionality is built on the ncurses libraries: curses, form,
       panel, and menu.
     '';
-    homepage = "https://www.gnu.org/software/guile-ncurses/";
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.gnu ++ platforms.linux;

pkgs/development/guile-modules/guile-opengl/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, guile }:
+{ lib
+, stdenv
+, fetchurl
+, guile
+, pkg-config
+}:
 
-let
-  name = "guile-opengl-${version}";
+stdenv.mkDerivation rec {
+  pname = "guile-opengl";
   version = "0.1.0";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "mirror://gnu/guile-opengl/${name}.tar.gz";
-    sha256 = "13qfx4xh8baryxqrv986l848ygd0piqwm6s2s90pxk9c0m9vklim";
+    url = "mirror://gnu/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-NdK5UwUszX5B0kKbynG8oD2PCKIGpZ1x91ktBDvpDo8=";
   };
 
-  nativeBuildInputs = [ pkg-config guile ];
+  nativeBuildInputs = [
+    pkg-config
+    guile
+  ];
 
   meta = with lib; {
+    homepage = "https://www.gnu.org/software/guile-opengl/";
     description = "Guile bindings for the OpenGL graphics API";
-    homepage = "https://www.gnu.org/software/guile-opengl/";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.unix;

pkgs/development/guile-modules/guile-reader/default.nix

···
-{ lib, stdenv, fetchurl, fetchpatch, pkg-config
-, gperf, guile, guile-lib, libffi }:
+{ lib
+, stdenv
+, fetchurl
+, fetchpatch
+, gperf
+, guile
+, guile-lib
+, libffi
+, pkg-config
+}:
 
 stdenv.mkDerivation rec {
-
   pname = "guile-reader";
   version = "0.6.3";
 
   src = fetchurl {
-    url = "http://download.savannah.nongnu.org/releases/guile-reader/${pname}-${version}.tar.gz";
-    sha256 = "sha256-OMK0ROrbuMDKt42QpE7D6/9CvUEMW4SpEBjO5+tk0rs=";
+    url = "http://download.savannah.nongnu.org/releases/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-OMK0ROrbuMDKt42QpE7D6/9CvUEMW4SpEBjO5+tk0rs=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ gperf guile guile-lib libffi ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [
+    gperf
+    guile
+    guile-lib
+    libffi
+  ];
 
   GUILE_SITE="${guile-lib}/share/guile/site";
 
   configureFlags = [ "--with-guilemoduledir=$(out)/share/guile/site" ];
 
   meta = with lib; {
+    homepage = "https://www.nongnu.org/guile-reader/";
     description = "A simple framework for building readers for GNU Guile";
     longDescription = ''
-       Guile-Reader is a simple framework for building readers for GNU
-       Guile.
+       Guile-Reader is a simple framework for building readers for GNU Guile.
 
-       The idea is to make it easy to build procedures that extend
-       Guile's read procedure. Readers supporting various syntax
-       variants can easily be written, possibly by re-using existing
-       "token readers" of a standard Scheme readers. For example, it
-       is used to implement Skribilo's R5RS-derived document syntax.
+       The idea is to make it easy to build procedures that extend Guile's read
+       procedure. Readers supporting various syntax variants can easily be
+       written, possibly by re-using existing "token readers" of a standard
+       Scheme readers. For example, it is used to implement Skribilo's
+       R5RS-derived document syntax.
     '';
-    homepage = "https://www.nongnu.org/guile-reader/";
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ AndersonTorres ];
     platforms = platforms.gnu;

pkgs/development/guile-modules/guile-sdl/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, guile, buildEnv
-, SDL, SDL_image, SDL_ttf, SDL_mixer
+{ lib
+, stdenv
+, fetchurl
+, SDL
+, SDL_image
+, SDL_mixer
+, SDL_ttf
+, buildEnv
+, guile
+, pkg-config
 }:
 
 stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "mirror://gnu/${pname}/${pname}-${version}.tar.xz";
-    sha256 = "0cjgs012a9922hn6xqwj66w6qmfs3nycnm56hyykx5n3g5p7ag01";
+    hash = "sha256-ATx1bnnDlj69h6ZUy7wd2lVsuDGS424sFCIlJQLQTzI=";
   };
 
-  nativeBuildInputs = [ pkg-config guile ];
-
-  buildInputs = [ SDL.dev SDL_image SDL_ttf SDL_mixer ];
-
-  GUILE_AUTO_COMPILE = 0;
+  nativeBuildInputs = [
+    guile
+    pkg-config
+  ];
+  buildInputs = [
+    SDL.dev
+    SDL_image
+    SDL_mixer
+    SDL_ttf
+  ];
 
   makeFlags = let
-    sdl = buildEnv {
+    sdl-env = buildEnv {
       name = "sdl-env";
       paths = buildInputs;
     };
-  in [ "SDLMINUSI=-I${sdl}/include/SDL" ];
+  in [
+    "GUILE_AUTO_COMPILE=0"
+    "SDLMINUSI=-I${sdl-env}/include/SDL"
+  ];
 
   meta = with lib; {
-    description = "Guile bindings for SDL";
     homepage = "https://www.gnu.org/software/guile-sdl/";
+    description = "Guile bindings for SDL";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.linux;

pkgs/development/guile-modules/guile-sdl2/default.nix

···
-{ lib, stdenv, fetchurl, guile, libtool, pkg-config
-, SDL2, SDL2_image, SDL2_ttf, SDL2_mixer
+{ lib
+, stdenv
+, fetchurl
+, SDL2
+, SDL2_image
+, SDL2_mixer
+, SDL2_ttf
+, guile
+, libtool
+, pkg-config
 }:
 
-let
-  name = "${pname}-${version}";
+stdenv.mkDerivation rec {
   pname = "guile-sdl2";
   version = "0.5.0";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "https://files.dthompson.us/${pname}/${name}.tar.gz";
-    sha256 = "118x0cg7fzbsyrfhy5f9ab7dqp9czgia0ycgzp6sn3nlsdrcnr4m";
+    url = "https://files.dthompson.us/${pname}/${pname}-${version}.tar.gz";
+    hash = "sha256-lWTLctPUDqvN/Y95oOL7LF3czlLJFQ9d9np9dx4DHYU=";
   };
 
-  nativeBuildInputs = [ libtool pkg-config ];
+  nativeBuildInputs = [
+    pkg-config
+    libtool
+  ];
   buildInputs = [
-    guile SDL2 SDL2_image SDL2_ttf SDL2_mixer
+    SDL2
+    SDL2_image
+    SDL2_mixer
+    SDL2_ttf
+    guile
   ];
 
   configureFlags = [
+    "--with-libsdl2-image-prefix=${SDL2_image}"
+    "--with-libsdl2-mixer-prefix=${SDL2_mixer}"
     "--with-libsdl2-prefix=${SDL2}"
-    "--with-libsdl2-image-prefix=${SDL2_image}"
     "--with-libsdl2-ttf-prefix=${SDL2_ttf}"
-    "--with-libsdl2-mixer-prefix=${SDL2_mixer}"
   ];
 
-  makeFlags = [ "GUILE_AUTO_COMPILE=0" ];
+  makeFlags = [
+    "GUILE_AUTO_COMPILE=0"
+  ];
 
   meta = with lib; {
-    description = "Bindings to SDL2 for GNU Guile";
     homepage = "https://dthompson.us/projects/guile-sdl2.html";
+    description = "Bindings to SDL2 for GNU Guile";
     license = licenses.lgpl3Plus;
     maintainers = with maintainers; [ seppeljordan vyp ];
     platforms = platforms.all;

pkgs/development/guile-modules/guile-xcb/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, guile, texinfo }:
+{ lib
+, stdenv
+, fetchurl
+, guile
+, pkg-config
+, texinfo
+}:
 
-let
-  name = "guile-xcb-${version}";
+stdenv.mkDerivation rec {
+  pname = "guile-xcb";
   version = "1.3";
-in stdenv.mkDerivation {
-  inherit name;
 
   src = fetchurl {
-    url = "http://www.markwitmer.com/dist/${name}.tar.gz";
-    sha256 = "04dvbqdrrs67490gn4gkq9zk8mqy3mkls2818ha4p0ckhh0pm149";
+    url = "http://www.markwitmer.com/dist/${pname}-${version}.tar.gz";
+    hash = "sha256-iYR6AYSTgUsURAEJTWcdHlc0f8LzEftAIsfonBteuxE=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ guile texinfo ];
+  nativeBuildInputs = [
+    pkg-config
+  ];
+  buildInputs = [
+    guile
+    texinfo
+  ];
 
-  preConfigure = ''
-    configureFlags="
-      --with-guile-site-dir=$out/share/guile/site
-      --with-guile-site-ccache-dir=$out/share/guile/site
-    ";
-  '';
+  configureFlags = [
+    "--with-guile-site-dir=$out/share/guile/site"
+    "--with-guile-site-ccache-dir=$out/share/guile/site"
+  ];
 
   meta = with lib; {
-    description = "XCB bindings for Guile";
     homepage = "http://www.markwitmer.com/guile-xcb/guile-xcb.html";
+    description = "XCB bindings for Guile";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ vyp ];
     platforms = platforms.linux;

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

···
   patch = doJailbreak super.patch;
 
   # Tests disabled and broken override needed because of missing lib chrome-test-utils: https://github.com/reflex-frp/reflex-dom/issues/392
-  reflex-dom-core = doDistribute (unmarkBroken (dontCheck (appendPatch (doJailbreak super.reflex-dom-core) (pkgs.fetchpatch {
-    url = https://github.com/reflex-frp/reflex-dom/commit/6aed7b7ebb70372778f1a29a724fcb4de815ba04.patch;
-    sha256 = "1g7lgwj7rpziilif2gian412iy05gqbzwx9w0m6ajq3clxs5zs7l";
-    stripLen = 2;
-    extraPrefix = "";
-    includes = ["reflex-dom-core.cabal" ];
-  }))));
+  reflex-dom-core = doDistribute (unmarkBroken (dontCheck (doJailbreak super.reflex-dom-core)));
 
   # Tests disabled and broken override needed because of missing lib chrome-test-utils: https://github.com/reflex-frp/reflex-dom/issues/392
   reflex-dom = appendPatch super.reflex-dom (pkgs.fetchpatch {
···
   # https://github.com/obsidiansystems/dependent-sum/issues/55
   dependent-sum = doJailbreak super.dependent-sum;
 
-  # Overspecified constraint on 'constraints'. Kinda funny, huh?
-  dependent-sum-aeson-orphans = appendPatch (doJailbreak super.dependent-sum-aeson-orphans) (pkgs.fetchpatch {
-    # 2020-11-18: https://github.com/obsidiansystems/dependent-sum-aeson-orphans/pull/9
-    # Bump version bounds for ghc 8.10
-    url = https://github.com/obsidiansystems/dependent-sum-aeson-orphans/commit/e1f5898116222a1bc557d41f3395066f83736093.patch;
-    sha256 = "01fj29xdblxpz4drasaygf9875fipylpj8w164lb0cszd1vmqwnb";
-  });
-
   # 2020-11-18: https://github.com/srid/rib/issues/169
   # aeson bound out of sync
   rib-core = doJailbreak super.rib-core;
···
   # base upper bound is incompatible with ghc 8.10
   neuron = doJailbreak super.neuron;
 
-  reflex = dontCheck (doJailbreak (appendPatches super.reflex [
-    # https://github.com/reflex-frp/reflex/pull/444
-    # Fixes for ghc 8.10
-    (pkgs.fetchpatch {
-      url = https://github.com/reflex-frp/reflex/commit/d230632427fc1b7031163567c97f20050610c122.patch;
-      sha256 = "0gafqqi6q16m5y4mrc2f7lhahmazvcbiadn2v84y9p3zvx2v26xy";
-    })
-    # https://github.com/reflex-frp/reflex/pull/444
-    # Bound bumps for ghc 8.10
-    (pkgs.fetchpatch {
-      url = https://patch-diff.githubusercontent.com/raw/reflex-frp/reflex/pull/448.patch;
-      sha256 = "0a8gcq9g8dyyafkvs54mi3fnisff20r0x0qzmhxcp9md61nkf7gq";
-    })
-  ]));
+  # 2020-04-16: https://github.com/reflex-frp/reflex/issues/449
+  reflex = dontCheck (doJailbreak super.reflex);
 
   # 2020-11-19: jailbreaking because of pretty-simple bound out of date
   # https://github.com/kowainik/stan/issues/408
···
   );
 
   # 2020-12-05: http-client is fixed on too old version
-  essence-of-live-coding-warp = super.essence-of-live-coding-warp.override {
-    http-client = self.http-client_0_7_6;
-  };
+  essence-of-live-coding-warp = doJailbreak (super.essence-of-live-coding-warp.override {
+    http-client = self.http-client_0_7_7;
+  });
 
   # 2020-12-06: Restrictive upper bounds w.r.t. pandoc-types (https://github.com/owickstrom/pandoc-include-code/issues/27)
   pandoc-include-code = doJailbreak super.pandoc-include-code;
···
   # 2021-04-09: too strict time bound
   # PR pending https://github.com/zohl/cereal-time/pull/2
   cereal-time = doJailbreak super.cereal-time;
+
+  # 2021-04-16: too strict bounds on QuickCheck and tasty
+  # https://github.com/hasufell/lzma-static/issues/1
+  lzma-static = doJailbreak super.lzma-static;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   - hls-retrie-plugin < 1.0.0.1
   - lsp < 1.2
   - lsp-types < 1.2
+  - hls-plugin-api < 1.1.0.0
+  - hls-explicit-imports-plugin < 1.0.0.1
   # 2021-04-02: Stackage Nighlty has haskell-gi* < 0.25,
   # so we need to restrict these to compatible versions
   # Remove these as soon as haskell-gi{,-base} are 0.25.*
···
   - gi-secret < 0.0.13
   - gi-vte < 2.91.28
 
-  # Stackage Nightly 2021-04-02
+  # Stackage Nightly 2021-04-06
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - bech32 ==1.1.0
   - bech32-th ==1.0.2
   - bench ==1.0.12
-  - benchpress ==0.2.2.15
+  - benchpress ==0.2.2.16
   - between ==0.11.0.0
   - bibtex ==0.1.0.6
   - bifunctors ==5.5.10
···
   - boolsimplifier ==0.1.8
   - boots ==0.2.0.1
   - bordacount ==0.1.0.0
-  - boring ==0.1.3
+  - boring ==0.2
   - both ==0.1.1.1
   - bound ==2.0.3
   - BoundedChan ==1.0.3.0
···
   - composite-hashable ==0.7.4.0
   - composite-tuple ==0.1.2.0
   - composite-xstep ==0.1.0.0
-  - composition ==1.0.2.1
+  - composition ==1.0.2.2
   - composition-extra ==2.0.0
   - concise ==0.1.0.1
   - concurrency ==1.11.0.1
···
   - data-ordlist ==0.4.7.0
   - data-ref ==0.0.2
   - data-reify ==0.6.3
-  - data-serializer ==0.3.4.1
+  - data-serializer ==0.3.5
   - data-textual ==0.3.0.3
   - dataurl ==0.1.0.0
   - DAV ==1.3.4
···
   - distributed-closure ==0.4.2.0
   - distribution-opensuse ==1.1.1
   - distributive ==0.6.2.1
-  - dl-fedora ==0.7.6
+  - dl-fedora ==0.7.7
   - dlist ==0.8.0.8
   - dlist-instances ==0.1.1.1
   - dlist-nonempty ==0.1.1
···
   - fix-whitespace ==0.0.5
   - flac ==0.2.0
   - flac-picture ==0.1.2
-  - flags-applicative ==0.1.0.2
+  - flags-applicative ==0.1.0.3
   - flat ==0.4.4
   - flat-mcmc ==1.5.2
   - flexible-defaults ==0.0.3
···
   - graphite ==0.10.0.1
   - graphql-client ==1.1.1
   - graphs ==0.7.1
-  - graphula ==2.0.0.3
+  - graphula ==2.0.0.4
   - graphviz ==2999.20.1.0
   - graph-wrapper ==0.2.6.0
   - gravatar ==0.8.0
···
   - hformat ==0.3.3.1
   - hfsevents ==0.1.6
   - hgrev ==0.2.6
-  - hidapi ==0.1.6
+  - hidapi ==0.1.7
   - hie-bios ==0.7.5
   - hi-file-parser ==0.1.1.0
   - higher-leveldb ==0.6.0.0
···
   - hp2pretty ==0.10
   - hpack ==0.34.4
   - hpack-dhall ==0.5.2
-  - hpc-codecov ==0.2.0.2
+  - hpc-codecov ==0.3.0.0
   - hpc-lcov ==1.0.1
   - hprotoc ==2.4.17
   - hruby ==0.3.8.1
···
   - hslua-module-path ==0.1.0.1
   - hslua-module-system ==0.2.2.1
   - hslua-module-text ==0.3.0.1
-  - HsOpenSSL ==0.11.6
+  - HsOpenSSL ==0.11.6.1
   - HsOpenSSL-x509-system ==0.1.0.4
   - hsp ==0.10.0
   - hspec ==2.7.9
···
   - liboath-hs ==0.0.1.2
   - libyaml ==0.1.2
   - LibZip ==1.0.1
-  - lifted-async ==0.10.1.3
+  - lifted-async ==0.10.2
   - lifted-base ==0.2.3.12
   - lift-generics ==0.2
   - line ==4.0.1
···
   - mono-traversable ==1.0.15.1
   - mono-traversable-instances ==0.1.1.0
   - mono-traversable-keys ==0.1.0
-  - more-containers ==0.2.2.0
+  - more-containers ==0.2.2.2
   - morpheus-graphql ==0.17.0
   - morpheus-graphql-app ==0.17.0
   - morpheus-graphql-client ==0.17.0
···
   - rhine-gloss ==0.7.0
   - rigel-viz ==0.2.0.0
   - rio ==0.1.20.0
-  - rio-orphans ==0.1.1.0
+  - rio-orphans ==0.1.2.0
   - rio-prettyprint ==0.1.1.0
   - roc-id ==0.1.0.0
   - rocksdb-haskell ==1.0.1
···
   - servant-swagger ==1.1.10
   - servant-swagger-ui ==0.3.4.3.37.2
   - servant-swagger-ui-core ==0.3.4
-  - serverless-haskell ==0.12.5
+  - serverless-haskell ==0.12.6
   - serversession ==1.0.2
   - serversession-frontend-wai ==1.0
   - ses-html ==0.4.0.0
···
   - soap-tls ==0.1.1.4
   - socket ==0.8.3.0
   - socks ==0.6.1
-  - some ==1.0.2
+  - some ==1.0.3
   - sop-core ==0.5.0.1
   - sort ==1.0.0.0
   - sorted-list ==0.2.1.0
···
   - string-conversions ==0.4.0.1
   - string-interpolate ==0.3.1.0
   - string-qq ==0.0.4
-  - string-random ==0.1.4.0
+  - string-random ==0.1.4.1
   - stringsearch ==0.3.6.6
   - string-transform ==1.1.1
   - stripe-concepts ==1.0.2.6
···
   - tardis ==0.4.3.0
   - tasty ==1.4.1
   - tasty-ant-xml ==1.1.8
-  - tasty-bench ==0.2.4
+  - tasty-bench ==0.2.5
   - tasty-dejafu ==2.0.0.7
   - tasty-discover ==4.2.2
   - tasty-expected-failure ==0.12.3
···
   - yesod-sitemap ==1.6.0
   - yesod-static ==1.6.1.0
   - yesod-test ==1.6.12
-  - yesod-websockets ==0.3.0.2
+  - yesod-websockets ==0.3.0.3
   - yes-precure5-command ==5.5.3
   - yi-rope ==0.11
   - yjsvg ==0.2.0.1
···
   - ghcjs-xhr
   - ghclive
   - ghcprofview
+  - ghcup
   - ght
   - gi-cairo-again
   - gi-graphene
···
   - kparams
   - kqueue
   - kraken
-  - krank
   - krapsh
   - Kriens
   - krpc
···
   - puzzle-draw
   - puzzle-draw-cmdline
   - pvd
-  - PyF
   - pyffi
   - pyfi
   - python-pickle
···
   - sorted
   - sorting
   - sorty
+  - souffle-dsl
   - souffle-haskell
   - sound-collage
   - sounddelay
···
   - wai-graceful
   - wai-handler-devel
   - wai-handler-fastcgi
+  - wai-handler-hal
   - wai-handler-scgi
   - wai-handler-snap
   - wai-handler-webkit

pkgs/development/haskell-modules/generic-builder.nix

···
 , license
 , enableParallelBuilding ? true
 , maintainers ? null
+, changelog ? null
 , doCoverage ? false
 , doHaddock ? !(ghc.isHaLVM or false)
 , passthru ? {}
···
          // optionalAttrs (args ? description)    { inherit description; }
          // optionalAttrs (args ? maintainers)    { inherit maintainers; }
          // optionalAttrs (args ? hydraPlatforms) { inherit hydraPlatforms; }
+         // optionalAttrs (args ? changelog)      { inherit changelog; }
          ;
 
 }

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

···
        broken = true;
      }) {};
 
+  "GPipe-Core" = callPackage
+    ({ mkDerivation, base, Boolean, containers, criterion
+     , exception-transformers, gl, hspec, hspec-discover, lens, linear
+     , text, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "GPipe-Core";
+       version = "0.2.3.1";
+       sha256 = "0yrqhm77bn8dwx335fpkjyxz5jm7i7g5hpxgk9xrrm6b3sm24w0j";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base Boolean containers exception-transformers gl lens linear text
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [ base hspec lens ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion lens ];
+       description = "Typesafe functional GPU graphics programming";
+       license = lib.licenses.mit;
+     }) {};
+
   "GPipe-Examples" = callPackage
     ({ mkDerivation, base, GLUT, GPipe, GPipe-TextureLoad, haskell98
      , Vec, Vec-Transform
···
        broken = true;
      }) {};
 
+  "GPipe-GLFW4" = callPackage
+    ({ mkDerivation, async, base, containers, criterion
+     , exception-transformers, GLFW-b, GPipe-Core, hspec, hspec-discover
+     , JuicyPixels, lens, stm, transformers
+     }:
+     mkDerivation {
+       pname = "GPipe-GLFW4";
+       version = "2.0.0";
+       sha256 = "1bzbnn7ip5n01kd7nydlmmp5xbzhnfpfhhcmlx1l9qjwzj4zf708";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         async base containers GLFW-b GPipe-Core stm
+       ];
+       executableHaskellDepends = [
+         base exception-transformers GPipe-Core lens transformers
+       ];
+       testHaskellDepends = [
+         base exception-transformers GPipe-Core hspec lens transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base criterion GPipe-Core JuicyPixels
+       ];
+       description = "GLFW OpenGL context creation for GPipe";
+       license = lib.licenses.mit;
+     }) {};
+
   "GPipe-TextureLoad" = callPackage
     ({ mkDerivation, base, bitmap, GPipe, stb-image }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "HPDF";
-       version = "1.5.2";
-       sha256 = "0mp3lbyyp6iykqrnviam46wb5aab24c1ncivxp5c2v5hg89a1jrm";
+       version = "1.5.3";
+       sha256 = "12h3gx9gikzz4fwf11zk1nwzbpwqzzyavjz8mr27scy3s94vw41r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
      mkDerivation {
        pname = "HsOpenSSL";
-       version = "0.11.6";
-       sha256 = "1gkx6kk03ziz9wk6iwxcdpf1ig8a9whwv3yjbzmqrwkp7fh1wdrw";
+       version = "0.11.6.1";
+       sha256 = "0jmnmrhvm7rbspv0vw482i8wpmkzhnnwxswqwx75455w0mvdg62l";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [ base bytestring network time ];
        librarySystemDepends = [ openssl ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "IPv6Addr_2_0_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, HUnit, iproute, network
+     , network-info, random, test-framework, test-framework-hunit, text
+     }:
+     mkDerivation {
+       pname = "IPv6Addr";
+       version = "2.0.2";
+       sha256 = "0r712250lv8brgy3ysdyj41snl0qbsx9h0p853w8n1aif0fsnxkw";
+       libraryHaskellDepends = [
+         aeson attoparsec base iproute network network-info random text
+       ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit text
+       ];
+       description = "Library to deal with IPv6 address text representations";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "IPv6DB" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, fast-logger
      , hedis, hspec, http-client, http-types, IPv6Addr, mtl
···
        ];
        description = "Quasiquotations for a python like interpolated string formater";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "QIO" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "Spintax_0_3_6" = callPackage
+    ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, text }:
+     mkDerivation {
+       pname = "Spintax";
+       version = "0.3.6";
+       sha256 = "000yprzvq72ia6wfk3hjarb8anx3wfm54rzpv8x7d2zf09pzxk6k";
+       libraryHaskellDepends = [
+         attoparsec base extra mtl mwc-random text
+       ];
+       description = "Random text generation based on spintax";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Spock" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring, containers
      , cryptonite, focus, hashable, hspec, hspec-wai, http-types, hvect
···
      }:
      mkDerivation {
        pname = "Z-MessagePack";
-       version = "0.3.0.1";
-       sha256 = "1xn3by0fkn8w9akldfk2rrfk8ns2r64zxqadrcsgga7nv88q49am";
+       version = "0.4.0.1";
+       sha256 = "1i1ycf1bhahbh7d9rvz4hl5jq16mld8sya2h2xrxlvg9yqab19hy";
        libraryHaskellDepends = [
          base containers deepseq hashable integer-gmp primitive QuickCheck
          scientific tagged time unordered-containers Z-Data Z-IO
···
      , configurator, containers, cryptohash, hostname, http-client
      , http-client-tls, http-media, http-types, jwt, mtl, network
      , network-api-support, network-uri, snap, snap-core, split, text
-     , time, time-units, transformers, zlib
+     , time, time-units, transformers
      }:
      mkDerivation {
        pname = "atlassian-connect-core";
-       version = "0.8.1.0";
-       sha256 = "17xvqf2j77y8lqvl2k5a924yvjym4aqii6glwfs3rjvw6a08k9zp";
+       version = "0.8.2.0";
+       sha256 = "06wrbz8r4yc6spjrawqrdsc1nf3bc5nr40ssnrmyv00xzkhvjq2j";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson atlassian-connect-descriptor base base64-bytestring
···
          http-types jwt mtl network network-api-support network-uri snap
          snap-core split text time time-units transformers
        ];
-       libraryPkgconfigDepends = [ zlib ];
        description = "Atlassian Connect snaplet for the Snap Framework and helper code";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) zlib;};
+     }) {};
 
   "atlassian-connect-descriptor" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, cases, HUnit
···
     ({ mkDerivation, base, bytestring, mtl, time }:
      mkDerivation {
        pname = "benchpress";
-       version = "0.2.2.15";
-       sha256 = "0bffchlwcyqgbnviqvm01lyj7zldvd3yj9yqnc8150lgxr29kvf9";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base mtl time ];
-       executableHaskellDepends = [ base bytestring time ];
-       description = "Micro-benchmarking with detailed statistics";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "benchpress_0_2_2_16" = callPackage
-    ({ mkDerivation, base, bytestring, mtl, time }:
-     mkDerivation {
-       pname = "benchpress";
        version = "0.2.2.16";
        sha256 = "0p8wxd7liz7ihqlqhk1l8z3hn7hc24qlf69ykxixp69jx479dkan";
        isLibrary = true;
···
        executableHaskellDepends = [ base bytestring time ];
        description = "Micro-benchmarking with detailed statistics";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bencode" = callPackage
···
      }:
      mkDerivation {
        pname = "birch-beer";
-       version = "0.3.1.1";
-       sha256 = "0v2202zrnli49z4vw4zc6cgxvfqrv51b6p0svp0fdd2f9add4rvm";
+       version = "0.4.1.0";
+       sha256 = "07l9y57if58047d54g52vhpk4372aj563brbds62c3fgb5wjpdc6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "boring" = callPackage
-    ({ mkDerivation, adjunctions, base, base-compat, bin, constraints
-     , dec, fin, generics-sop, ral, singleton-bool, streams, tagged
-     , transformers, transformers-compat, vec
-     }:
-     mkDerivation {
-       pname = "boring";
-       version = "0.1.3";
-       sha256 = "1fljlkzc5016xbq9jykh0wr1mbyfcikh818pp54djws5vm66hh6d";
-       revision = "2";
-       editedCabalFile = "031vricyy2m7hg2hk3bj64lsz55k9qh36s2yfh09pgsfykr883ag";
-       libraryHaskellDepends = [
-         adjunctions base base-compat bin constraints dec fin generics-sop
-         ral singleton-bool streams tagged transformers transformers-compat
-         vec
-       ];
-       description = "Boring and Absurd types";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "boring_0_2" = callPackage
     ({ mkDerivation, base, tagged, transformers }:
      mkDerivation {
        pname = "boring";
···
        libraryHaskellDepends = [ base tagged transformers ];
        description = "Boring and Absurd types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "boring-game" = callPackage
···
      }:
      mkDerivation {
        pname = "calamity";
-       version = "0.1.27.0";
-       sha256 = "1aslkqv8j5zq3pznlw4ga32gz8w29xd365rcjw3xbdj4cygpix40";
+       version = "0.1.28.3";
+       sha256 = "0w7jcq6jplr31ljdvj9cqimg1xxz9pjnsdqkncdsiywa10ngww10";
        libraryHaskellDepends = [
          aeson async base bytestring colour concurrent-extra connection
          containers data-default-class data-flags deepseq deque df1 di-core
···
        broken = true;
      }) {};
 
+  "catalyst" = callPackage
+    ({ mkDerivation, base, profunctors }:
+     mkDerivation {
+       pname = "catalyst";
+       version = "0.0.0.1";
+       sha256 = "04vp18pblx88djjdiidhg2i52rry08kx43zzvf7nfap46zv51a6a";
+       libraryHaskellDepends = [ base profunctors ];
+       description = "A Category typeclass hierarchy powerful enough to encode full programs";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "catamorphism" = callPackage
     ({ mkDerivation, base, hspec, QuickCheck, template-haskell }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "cayley-client_0_4_15" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+     , exceptions, hspec, http-client, http-conduit, lens, lens-aeson
+     , mtl, text, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "cayley-client";
+       version = "0.4.15";
+       sha256 = "18kr88g4dlzg1ny0v3ql5yc07s0xsgbgszc69hf583d9c196lzib";
+       libraryHaskellDepends = [
+         aeson attoparsec base binary bytestring exceptions http-client
+         http-conduit lens lens-aeson mtl text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ aeson base hspec unordered-containers ];
+       description = "A Haskell client for the Cayley graph database";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "cayley-dickson" = callPackage
     ({ mkDerivation, base, random }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "chassis";
-       version = "0.0.4.0";
-       sha256 = "1mvi7h6pp1j3x4yccqy962f8d3gbm4sj5fvnfwxygnxqqhmy1dvk";
-       revision = "1";
-       editedCabalFile = "15pncz2x3llb2sg2x4as4r0wbx528dvlp0gvc2rl9y9dxhv89d9h";
+       version = "0.0.5.0";
+       sha256 = "0f9iipl7l9jhi6754yysk9kkliiab60ds95k8r4gjcch3hh4zbcj";
        libraryHaskellDepends = [
          base bytestring comonad composite-base containers contravariant
          distributive either exceptions extra first-class-families path
···
      }:
      mkDerivation {
        pname = "cli-extras";
-       version = "0.1.0.1";
-       sha256 = "1fggrnhdbr2ialdd93d0m81b85izs1gvcs8bkmwm8wdxgw4v7hsi";
+       version = "0.1.0.2";
+       sha256 = "1qcvphbimcclvy7qkqrz9djg4650axwqjfyq6nlbvmpivh14m9vq";
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring containers exceptions
          io-streams lens logging-effect monad-logger monad-loops mtl process
···
      }:
      mkDerivation {
        pname = "cli-git";
-       version = "0.1.0.1";
-       sha256 = "0jchv1j7dgay6xzny9rinsybavs4ggk93450cka6sp7015z06ysr";
+       version = "0.1.0.2";
+       sha256 = "08gjhg2bc8i9i1clpxp5bzk4sp4izfbhjqmbmfmqqzv6ci0p5fxx";
        libraryHaskellDepends = [
          base cli-extras containers data-default exceptions lens
          logging-effect megaparsec mtl text
···
        pname = "codeworld-api";
        version = "0.7.0";
        sha256 = "1l1w4mrw4b2njz4kmfvd94mlwn776vryy1y9x9cb3r69fw5qy2f3";
-       revision = "1";
-       editedCabalFile = "18npi0idydgzc59a5xvlch8kpkkwn0xfi6f95i3cnzy1h1q52grr";
+       revision = "3";
+       editedCabalFile = "0whbjs6j4fy4jk3bc1djx1bkxpsdyms3r3rf5167x0dhxnahwcgi";
        libraryHaskellDepends = [
          aeson base base64-bytestring blank-canvas bytestring cereal
          cereal-text containers deepseq dependent-sum ghc-prim hashable
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "composite-aeson_0_7_5_0" = callPackage
+    ({ mkDerivation, aeson, aeson-better-errors, aeson-qq, base
+     , composite-base, containers, contravariant, generic-deriving
+     , hashable, hspec, lens, mmorph, mtl, profunctors, QuickCheck
+     , scientific, tagged, template-haskell, text, time
+     , unordered-containers, vector, vinyl
+     }:
+     mkDerivation {
+       pname = "composite-aeson";
+       version = "0.7.5.0";
+       sha256 = "0cxsjk3zwkhwb3bgq2ji1mvvapcwxzg333z7zfdv9ba3xgw3ngq0";
+       libraryHaskellDepends = [
+         aeson aeson-better-errors base composite-base containers
+         contravariant generic-deriving hashable lens mmorph mtl profunctors
+         scientific tagged template-haskell text time unordered-containers
+         vector vinyl
+       ];
+       testHaskellDepends = [
+         aeson aeson-better-errors aeson-qq base composite-base containers
+         contravariant generic-deriving hashable hspec lens mmorph mtl
+         profunctors QuickCheck scientific tagged template-haskell text time
+         unordered-containers vector vinyl
+       ];
+       description = "JSON for Vinyl records";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "composite-aeson-cofree-list" = callPackage
     ({ mkDerivation, aeson, base, composite-aeson
      , composite-aeson-writeonly, free, vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "composite-aeson-path_0_7_5_0" = callPackage
+    ({ mkDerivation, base, composite-aeson, path }:
+     mkDerivation {
+       pname = "composite-aeson-path";
+       version = "0.7.5.0";
+       sha256 = "0b013jpdansx6fmxq1sf33975vvnajhs870a92i1lwd2k2wsj600";
+       libraryHaskellDepends = [ base composite-aeson path ];
+       description = "Formatting data for the path library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "composite-aeson-refined" = callPackage
     ({ mkDerivation, aeson-better-errors, base, composite-aeson, mtl
      , refined
···
        ];
        description = "composite-aeson support for Refined from the refined package";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "composite-aeson-refined_0_7_5_0" = callPackage
+    ({ mkDerivation, aeson-better-errors, base, composite-aeson, mtl
+     , refined
+     }:
+     mkDerivation {
+       pname = "composite-aeson-refined";
+       version = "0.7.5.0";
+       sha256 = "05iakig5cqy4zkfl1kvjf9ck7gw5m7bdlcwwnv0kc5znyj66fbif";
+       libraryHaskellDepends = [
+         aeson-better-errors base composite-aeson mtl refined
+       ];
+       description = "composite-aeson support for Refined from the refined package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-aeson-throw" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "composite-base_0_7_5_0" = callPackage
+    ({ mkDerivation, base, deepseq, exceptions, hspec, lens
+     , monad-control, mtl, profunctors, QuickCheck, template-haskell
+     , text, transformers, transformers-base, unliftio-core, vinyl
+     }:
+     mkDerivation {
+       pname = "composite-base";
+       version = "0.7.5.0";
+       sha256 = "12qaxm20kn2cf6d19xargxfg8jrvb5ix0glm3ba0641plxlssqrq";
+       libraryHaskellDepends = [
+         base deepseq exceptions lens monad-control mtl profunctors
+         template-haskell text transformers transformers-base unliftio-core
+         vinyl
+       ];
+       testHaskellDepends = [
+         base deepseq exceptions hspec lens monad-control mtl profunctors
+         QuickCheck template-haskell text transformers transformers-base
+         unliftio-core vinyl
+       ];
+       description = "Shared utilities for composite-* packages";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "composite-binary" = callPackage
     ({ mkDerivation, base, binary, composite-base }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "composite-binary_0_7_5_0" = callPackage
+    ({ mkDerivation, base, binary, composite-base }:
+     mkDerivation {
+       pname = "composite-binary";
+       version = "0.7.5.0";
+       sha256 = "0pvmmb4m6ysgj468khmggvsgs5c0hjmcn46s0wam353abdw89i7m";
+       libraryHaskellDepends = [ base binary composite-base ];
+       description = "Orphan binary instances";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "composite-ekg" = callPackage
     ({ mkDerivation, base, composite-base, ekg-core, lens, text, vinyl
      }:
···
        ];
        description = "EKG Metrics for Vinyl records";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "composite-ekg_0_7_5_0" = callPackage
+    ({ mkDerivation, base, composite-base, ekg-core, lens, text, vinyl
+     }:
+     mkDerivation {
+       pname = "composite-ekg";
+       version = "0.7.5.0";
+       sha256 = "00a689laq9a2wyq33vvpw7l69wsw9g6d5jzmrsizwqld6a4wdicv";
+       libraryHaskellDepends = [
+         base composite-base ekg-core lens text vinyl
+       ];
+       description = "EKG Metrics for Vinyl records";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-hashable" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "composite-hashable_0_7_5_0" = callPackage
+    ({ mkDerivation, base, composite-base, hashable }:
+     mkDerivation {
+       pname = "composite-hashable";
+       version = "0.7.5.0";
+       sha256 = "1s4bnlr08fb1sszys1frkxrjrsi61jpcldh126mcwzlf6wlvqvjn";
+       libraryHaskellDepends = [ base composite-base hashable ];
+       description = "Orphan hashable instances";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "composite-opaleye" = callPackage
     ({ mkDerivation, base, bytestring, composite-base, hspec, lens
      , opaleye, postgresql-simple, product-profunctors, profunctors
···
      }:
      mkDerivation {
        pname = "composite-opaleye";
-       version = "0.7.4.0";
-       sha256 = "0nzyslqgh7m9ryqw4rajq2m4kfknqzdq0aqnygyz0sblmgixn4hm";
+       version = "0.7.5.0";
+       sha256 = "1qmlhn1lj2l5qpykxdg23axvxwn8l2pvzvwqn261rj21qj90k093";
        libraryHaskellDepends = [
          base bytestring composite-base lens opaleye postgresql-simple
          product-profunctors profunctors template-haskell text vinyl
···
      }:
      mkDerivation {
        pname = "composite-swagger";
-       version = "0.7.4.0";
-       sha256 = "0a7pcs06m0w0mq60y3hhgn4a36gx5daypc1nh1ndsm6x3q3d99q8";
+       version = "0.7.5.0";
+       sha256 = "1b6bcw7gq2smghp7mnkh9gymn3mh4b1xxkv97zhxjsb91wnmvyml";
        libraryHaskellDepends = [
          base composite-base insert-ordered-containers lens swagger2
          template-haskell text vinyl
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "composition";
-       version = "1.0.2.1";
-       sha256 = "0smdyzcnfwiab1wnazmk4szali1ckh7dqcdp9vn7qnnabq7k08vi";
-       description = "Combinators for unorthodox function composition";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "composition_1_0_2_2" = callPackage
-    ({ mkDerivation }:
-     mkDerivation {
-       pname = "composition";
        version = "1.0.2.2";
        sha256 = "0bnl8kmaqbjnznqgnjj2gr2qygln6y6493prk0anpd8zdylzf2xm";
        description = "Combinators for unorthodox function composition";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composition-extra" = callPackage
···
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) python3;};
+     }) {python3 = null;};
 
   "cql" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, Decimal
···
 
   "data-serializer" = callPackage
     ({ mkDerivation, base, binary, bytestring, cereal, data-endian
-     , parsers, semigroups, split, tasty, tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "data-serializer";
-       version = "0.3.4.1";
-       sha256 = "1md6zkv1yqxmyca6mljw8y5g3xaqz3g087qd49qpi94w0x1lqgnk";
-       libraryHaskellDepends = [
-         base binary bytestring cereal data-endian parsers semigroups split
-       ];
-       testHaskellDepends = [
-         base binary bytestring cereal tasty tasty-quickcheck
-       ];
-       description = "Common API for serialization libraries";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "data-serializer_0_3_5" = callPackage
-    ({ mkDerivation, base, binary, bytestring, cereal, data-endian
      , parsers, split, tasty, tasty-quickcheck
      }:
      mkDerivation {
···
        ];
        description = "Common API for serialization libraries";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "data-size" = callPackage
···
        broken = true;
      }) {};
 
+  "deepl" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cmdargs, foldl, lens
+     , lens-aeson, protolude, resourcet, streaming, streaming-bytestring
+     , wreq
+     }:
+     mkDerivation {
+       pname = "deepl";
+       version = "0.1.0.1";
+       sha256 = "042xkvfs3ny0gchk0a1l427hg6sd5dngw43sdwzp6c1k969s4cda";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring cmdargs foldl lens lens-aeson protolude
+         resourcet streaming streaming-bytestring wreq
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring cmdargs foldl lens lens-aeson protolude
+         resourcet streaming streaming-bytestring wreq
+       ];
+       description = "Call DeepL to translate you files";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "deeplearning-hs" = callPackage
     ({ mkDerivation, accelerate, base, mtl, QuickCheck, repa
      , repa-algorithms, test-framework, test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "dependent-monoidal-map";
-       version = "0.1.1.1";
-       sha256 = "0i3zgngcdli6hw09h985ca4n7l9cpsrxalbhg8lbq32hwh7dim89";
+       version = "0.1.1.2";
+       sha256 = "11qcrxji3lvq4blzh1qk9wkhhzjkvz3maxfv63zgby98dpmkxa2x";
        libraryHaskellDepends = [
          aeson base constraints constraints-extras dependent-map
          dependent-sum dependent-sum-aeson-orphans
···
      }:
      mkDerivation {
        pname = "dependent-sum-aeson-orphans";
-       version = "0.3.0.0";
-       sha256 = "1wpjrynv9zva3hw1wgmqd5pmhhpa491yh85p1dnbpkj7h0g1pl1a";
+       version = "0.3.1.0";
+       sha256 = "1psjd7va8k53vq9kh4pclsf27798mc1ggk1csjk39c8d97vm41qz";
        libraryHaskellDepends = [
          aeson base constraints constraints-extras dependent-map
          dependent-sum some
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "depq_0_4_2" = callPackage
+    ({ mkDerivation, base, containers, deepseq, hspec, psqueues
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "depq";
+       version = "0.4.2";
+       sha256 = "18q953cr93qwjdblr06w8z4ryijzlz7j48hff4xwrdc3yrqk351l";
+       libraryHaskellDepends = [
+         base containers deepseq psqueues QuickCheck
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       description = "Double-ended priority queues";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "deptrack-core" = callPackage
     ({ mkDerivation, base, containers, dlist, mtl, parsec }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "dl-fedora";
-       version = "0.7.6";
-       sha256 = "03npp2cq1259w590am87v0r4q48pfjq2zb2b04hymlr6hi3a8xw5";
+       version = "0.7.7";
+       sha256 = "0m4rf0h2hzsd00cgn14w1n8pyrqrikwnf9d232lzwx6qx3nf2nqp";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          optparse-applicative regex-posix simple-cmd simple-cmd-args text
          time unix xdg-userdirs
        ];
+       testHaskellDepends = [ base simple-cmd ];
        description = "Fedora image download tool";
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "duckling";
-       version = "0.1.6.1";
-       sha256 = "0lvvp13f5zcnf3cnl40avnfh3mgj304d5qfw08mbnwqz1bqp94xy";
+       version = "0.2.0.0";
+       sha256 = "0hr3dwfksi04is2wqykfx04da40sa85147fnfnmazw5czd20xwya";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          aeson base tasty tasty-hunit text time unordered-containers
        ];
        description = "A Haskell library for parsing text into structured data";
-       license = "unknown";
-       hydraPlatforms = lib.platforms.none;
+       license = lib.licenses.bsd3;
      }) {};
 
   "duet" = callPackage
···
        pname = "envy";
        version = "2.1.0.0";
        sha256 = "0s6jp2npnp0x5hndnhkjwc9bhdghzlpl0n38804afiwxai9bawy8";
+       revision = "1";
+       editedCabalFile = "1girkgynrr5md1fa892cpg2cyy21hs5g463p5rb0fkhsnvci52xm";
        libraryHaskellDepends = [
          base bytestring containers mtl text time transformers
        ];
···
      }) {};
 
   "epi-sim" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, cassava, hspec
-     , mwc-random, primitive, statistics, trifecta, vector
+    ({ mkDerivation, aeson, base, bytestring, hspec, mwc-random
+     , primitive, statistics, vector
      }:
      mkDerivation {
        pname = "epi-sim";
-       version = "0.2.2.0";
-       sha256 = "17pri7fynx5zi6hacglv2xww41837nrq0d355pv7rkvmqz5f8y3a";
+       version = "0.4.2";
+       sha256 = "0hwamynf66abhnipjdb292zpsf80hafpjjdv0yfq712qgjb9mgvp";
        libraryHaskellDepends = [
-         aeson base bytestring cassava hspec mwc-random primitive statistics
-         trifecta vector
+         aeson base bytestring hspec mwc-random primitive statistics vector
        ];
        testHaskellDepends = [
-         aeson base bytestring cassava hspec mwc-random primitive statistics
-         trifecta vector
+         aeson base bytestring hspec mwc-random primitive statistics vector
        ];
        description = "A library for simulating epidemics as birth-death processes";
        license = lib.licenses.mit;
···
        benchmarkHaskellDepends = [ base leancheck ];
        description = "Dynamically-typed expressions involving applications and variables";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "express_0_1_4" = callPackage
+    ({ mkDerivation, base, leancheck, template-haskell }:
+     mkDerivation {
+       pname = "express";
+       version = "0.1.4";
+       sha256 = "0rhrlynb950n2c79s3gz0vyd6b34crlhzlva0w91qbzn9dpfrays";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base leancheck ];
+       benchmarkHaskellDepends = [ base leancheck ];
+       description = "Dynamically-typed expressions involving applications and variables";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "expression-parser" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fixed-length_0_2_2_1" = callPackage
+    ({ mkDerivation, base, non-empty, storable-record, tfp, utility-ht
+     }:
+     mkDerivation {
+       pname = "fixed-length";
+       version = "0.2.2.1";
+       sha256 = "123iyy1id86h0j45jyc9jiz24hvjw7j3l57iv80b57gv4hd8a6q7";
+       libraryHaskellDepends = [
+         base non-empty storable-record tfp utility-ht
+       ];
+       description = "Lists with statically known length based on non-empty package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fixed-list" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "flags-applicative";
-       version = "0.1.0.2";
-       sha256 = "192yghdmylynn57l22ahb6dhrbl590dxmv2cdn755r22v7dbhsgf";
-       libraryHaskellDepends = [
-         base casing containers mtl network text
-       ];
-       testHaskellDepends = [ base containers hspec text ];
-       description = "Applicative flag parsing";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "flags-applicative_0_1_0_3" = callPackage
-    ({ mkDerivation, base, casing, containers, hspec, mtl, network
-     , text
-     }:
-     mkDerivation {
-       pname = "flags-applicative";
        version = "0.1.0.3";
        sha256 = "0sgla62999s9g5a2ckl70nbqi678pqq3zqad7jbm9p0kdm9yn5z3";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base containers hspec text ];
        description = "Applicative flag parsing";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "flamethrower" = callPackage
···
      }) {};
 
   "ftdi" = callPackage
-    ({ mkDerivation, base, base-unicode-symbols, bytestring, safe
-     , transformers, usb
+    ({ mkDerivation, async, base, base-unicode-symbols, bytestring
+     , generic-random, QuickCheck, random, tagged, test-framework
+     , test-framework-quickcheck2, transformers, usb, vector
      }:
      mkDerivation {
        pname = "ftdi";
-       version = "0.2.0.1";
-       sha256 = "1gnfbngn3jwva6nvrcrzmi2n2vy4k55yh41zvg0kyb61w7kgm4m8";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.3.0.0";
+       sha256 = "1yhcpd9jzhmvlmhidyv70s5mvakq6jn9lb3zh132lrqsrirbmpx8";
        libraryHaskellDepends = [
-         base base-unicode-symbols bytestring safe transformers usb
+         async base base-unicode-symbols bytestring transformers usb vector
+       ];
+       testHaskellDepends = [
+         base base-unicode-symbols bytestring generic-random QuickCheck
+         random tagged test-framework test-framework-quickcheck2
+         transformers usb vector
        ];
        description = "A thin layer over USB to communicate with FTDI chips";
        license = lib.licenses.bsd3;
···
        pname = "futhark";
        version = "0.19.4";
        sha256 = "1d4704pmknv39yw2bjxkp5n2wl9a14n3pn221m3src5z237lchq7";
+       revision = "1";
+       editedCabalFile = "1d8vwgdvj1dib7l4a3lhn03ri2mbnm57wnd3pki6m7y8sr3xk730";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "fuzzyfind" = callPackage
-    ({ mkDerivation, base, containers, criterion, deepseq, massiv, text
+    ({ mkDerivation, base, containers, criterion, deepseq, hspec
+     , massiv, QuickCheck, text
      }:
      mkDerivation {
        pname = "fuzzyfind";
-       version = "2.1.0";
-       sha256 = "0ah7kdbr2w0l06b28nprndx09fkdh5wk5sgl5gfb1f5iy090b8k1";
+       version = "3.0.0";
+       sha256 = "0vkjqgsa0qv8sz4bwwi49zf17fl23vckwvmr1agsd20rbhw4ivyr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers massiv text ];
        executableHaskellDepends = [ base criterion deepseq ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "Fuzzy text matching";
        license = lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "gamgee";
-       version = "1.2.1";
-       sha256 = "0kfaqxwnrpp9g6iz6s33b7lngw00l8n9bv9ssvw73dhh3r0rsj2b";
+       version = "1.2.2";
+       sha256 = "13mkdva9mchp48c5rc55c9h2l6iyc6phs46ncvy2053r1p8j31ki";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "gc";
-       version = "0.0.3";
-       sha256 = "0cql0csrwqddpw28qmpr47mcnszmdc2szwvbnardr86pmjhvgwph";
+       version = "0.1";
+       sha256 = "1k8gda9hs0xl19hyl81ysshs32sxp5w50h3kq7id6yqvkfvyii5p";
+       revision = "1";
+       editedCabalFile = "0b5ry13gcrg9lxhn4crv911z6ibfm9ha2y942s455hw1pxkw279i";
        libraryHaskellDepends = [ base ];
        description = "Poor Richard's Memory Manager";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.asl20;
      }) {};
 
-  "ghcide_1_1_0_0" = callPackage
-    ({ mkDerivation, aeson, array, async, base, base16-bytestring
-     , binary, bytestring, bytestring-encoding, case-insensitive
-     , containers, cryptohash-sha1, data-default, deepseq, dependent-map
-     , dependent-sum, Diff, directory, dlist, extra, filepath
-     , fingertree, fuzzy, ghc, ghc-boot, ghc-boot-th, ghc-check
-     , ghc-exactprint, ghc-paths, ghc-typelits-knownnat, gitrev, Glob
-     , haddock-library, hashable, heapsize, hie-bios, hie-compat, hiedb
-     , 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
-     , 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
+  "ghcide_1_2_0_2" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, async, base
+     , base16-bytestring, binary, bytestring, bytestring-encoding
+     , case-insensitive, containers, cryptohash-sha1, data-default
+     , deepseq, dependent-map, dependent-sum, Diff, directory, dlist
+     , extra, filepath, fingertree, fuzzy, ghc, ghc-boot, ghc-boot-th
+     , ghc-check, ghc-exactprint, ghc-paths, ghc-trace-events
+     , ghc-typelits-knownnat, gitrev, Glob, haddock-library, hashable
+     , heapsize, hie-bios, hie-compat, hiedb, 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, 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
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "1.1.0.0";
-       sha256 = "1i2xyp2n4g4cpz50wpwmzmknrzqzxnv3b551ibmhdy41v2fh6y5l";
+       version = "1.2.0.2";
+       sha256 = "0r3n23i4b51bb92q6pch9knj079a26jbz0q70qfpv66154d00wld";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          bytestring-encoding case-insensitive containers cryptohash-sha1
          data-default deepseq dependent-map dependent-sum Diff directory
          dlist extra filepath fingertree fuzzy ghc ghc-boot ghc-boot-th
-         ghc-check ghc-exactprint ghc-paths Glob haddock-library hashable
-         heapsize hie-bios hie-compat hiedb hls-plugin-api hslogger
-         implicit-hie-cradle lens lsp lsp-types mtl network-uri
-         opentelemetry parallel prettyprinter prettyprinter-ansi-terminal
-         regex-tdfa retrie rope-utf16-splay safe safe-exceptions shake
-         sorted-list sqlite-simple stm syb text time transformers unix
-         unliftio unliftio-core unordered-containers utf8-string vector
+         ghc-check ghc-exactprint ghc-paths ghc-trace-events Glob
+         haddock-library hashable heapsize hie-bios hie-compat hiedb
+         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 shake sorted-list
+         sqlite-simple stm syb text time transformers unix unliftio
+         unliftio-core unordered-containers utf8-string vector
        ];
        executableHaskellDepends = [
-         aeson base bytestring containers data-default directory extra
-         filepath ghc gitrev hashable heapsize hie-bios hiedb hls-plugin-api
-         lens lsp lsp-test lsp-types optparse-applicative process
-         safe-exceptions shake text unordered-containers
+         aeson aeson-pretty base bytestring containers data-default
+         directory extra filepath ghc gitrev hashable heapsize hie-bios
+         hiedb hls-plugin-api lens lsp lsp-test lsp-types
+         optparse-applicative process safe-exceptions shake text
+         unordered-containers
        ];
        testHaskellDepends = [
-         aeson base binary bytestring containers data-default directory
-         extra filepath ghc ghc-typelits-knownnat haddock-library
+         aeson async base binary bytestring containers data-default
+         directory extra filepath ghc ghc-typelits-knownnat haddock-library
          hls-plugin-api lens lsp lsp-test lsp-types network-uri
          optparse-applicative process QuickCheck quickcheck-instances
-         record-dot-preprocessor record-hasfield rope-utf16-splay safe
-         safe-exceptions shake tasty tasty-expected-failure tasty-hunit
+         record-dot-preprocessor record-hasfield regex-tdfa rope-utf16-splay
+         safe safe-exceptions shake tasty tasty-expected-failure tasty-hunit
          tasty-quickcheck tasty-rerun text
        ];
        testToolDepends = [ implicit-hie ];
···
        broken = true;
      }) {};
 
+  "ghcup" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ascii-string, async, base
+     , base16-bytestring, binary, bytestring, bz2, case-insensitive
+     , casing, concurrent-output, containers, cryptohash-sha256
+     , generic-arbitrary, generics-sop, haskus-utils-types
+     , haskus-utils-variant, hpath, hpath-directory, hpath-filepath
+     , hpath-io, hpath-posix, hspec, hspec-golden-aeson, libarchive
+     , lzma-static, megaparsec, monad-logger, mtl, optics, optics-vl
+     , optparse-applicative, os-release, parsec, pretty, pretty-terminal
+     , QuickCheck, quickcheck-arbitrary-adt, regex-posix, resourcet
+     , safe, safe-exceptions, split, streamly, streamly-bytestring
+     , streamly-posix, strict-base, string-interpolate, template-haskell
+     , text, time, transformers, unix, unix-bytestring
+     , unordered-containers, uri-bytestring, utf8-string, vector
+     , versions, vty, word8, yaml, zlib
+     }:
+     mkDerivation {
+       pname = "ghcup";
+       version = "0.1.14.1";
+       sha256 = "1lx6ahn4mvjzs3x4qm32sdn1n8w4v7jqj2jslvan008zk664d5l2";
+       revision = "1";
+       editedCabalFile = "0a9c2ha61mlz9ci652djy4vmmzi4s1g8rwl1a2miymrw5b36zsmq";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ascii-string async base base16-bytestring binary bytestring
+         bz2 case-insensitive casing concurrent-output containers
+         cryptohash-sha256 generics-sop haskus-utils-types
+         haskus-utils-variant hpath hpath-directory hpath-filepath hpath-io
+         hpath-posix libarchive lzma-static megaparsec monad-logger mtl
+         optics optics-vl os-release parsec pretty pretty-terminal
+         regex-posix resourcet safe safe-exceptions split streamly
+         streamly-bytestring streamly-posix strict-base string-interpolate
+         template-haskell text time transformers unix unix-bytestring
+         unordered-containers uri-bytestring utf8-string vector versions vty
+         word8 yaml zlib
+       ];
+       executableHaskellDepends = [
+         aeson aeson-pretty base bytestring containers haskus-utils-variant
+         hpath hpath-filepath hpath-io libarchive megaparsec monad-logger
+         mtl optics optparse-applicative pretty pretty-terminal regex-posix
+         resourcet safe safe-exceptions string-interpolate template-haskell
+         text transformers uri-bytestring utf8-string versions yaml
+       ];
+       testHaskellDepends = [
+         base bytestring containers generic-arbitrary hpath hspec
+         hspec-golden-aeson QuickCheck quickcheck-arbitrary-adt text
+         uri-bytestring versions
+       ];
+       description = "ghc toolchain installer";
+       license = lib.licenses.lgpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "ghczdecode" = callPackage
     ({ mkDerivation, base, zenc }:
      mkDerivation {
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gdk-pixbuf;};
 
-  "gi-gdkpixbuf_2_0_25" = callPackage
+  "gi-gdkpixbuf_2_0_26" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gdk-pixbuf
-     , gi-gio, gi-glib, gi-gobject, haskell-gi, haskell-gi-base
-     , haskell-gi-overloading, text, transformers
+     , gi-gio, gi-glib, gi-gmodule, gi-gobject, haskell-gi
+     , haskell-gi-base, haskell-gi-overloading, text, transformers
      }:
      mkDerivation {
        pname = "gi-gdkpixbuf";
-       version = "2.0.25";
-       sha256 = "18iz6rmqcf5q098hzv8p8hhk6ib8k99phmmnzp64j37c3x71c27b";
+       version = "2.0.26";
+       sha256 = "1g11pyrf1bzn0qrd9w52qhjq6qas4d3ycnprhwrglaffmaf0p9s8";
        setupHaskellDepends = [
-         base Cabal gi-gio gi-glib gi-gobject haskell-gi
+         base Cabal gi-gio gi-glib gi-gmodule gi-gobject haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-gio gi-glib gi-gobject haskell-gi
-         haskell-gi-base haskell-gi-overloading text transformers
+         base bytestring containers gi-gio gi-glib gi-gmodule gi-gobject
+         haskell-gi haskell-gi-base haskell-gi-overloading text transformers
        ];
        libraryPkgconfigDepends = [ gdk-pixbuf ];
        description = "GdkPixbuf bindings";
···
        license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glib;};
+
+  "gi-gmodule" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib
+     , gmodule, haskell-gi, haskell-gi-base, haskell-gi-overloading
+     , text, transformers
+     }:
+     mkDerivation {
+       pname = "gi-gmodule";
+       version = "2.0.1";
+       sha256 = "16x0gpbs92l250ly9k52z6y85i78ycfsg0zbksfpsym4w45zjpbp";
+       setupHaskellDepends = [ base Cabal gi-glib haskell-gi ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-glib haskell-gi haskell-gi-base
+         haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ gmodule ];
+       description = "GModule bindings";
+       license = lib.licenses.lgpl21Only;
+     }) {gmodule = null;};
 
   "gi-gobject" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib, glib
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "gl3w" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "gl3w";
+       version = "0.1.0";
+       sha256 = "14wm8wp4jxi4fq75bvr6sl4xmsxjfw30yq7011v28xqpm9015ns0";
+       libraryHaskellDepends = [ base ];
+       description = "Haskell bindings for the gl3w library";
+       license = lib.licenses.mit;
+     }) {};
+
   "glabrous" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , cereal, cereal-text, directory, either, hspec, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "glabrous_2_0_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
+     , cereal, cereal-text, directory, either, hspec, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "glabrous";
+       version = "2.0.3";
+       sha256 = "06bpazshc07rg1w06sl171k12mry708512hrdckqw7winwfrwwkh";
+       libraryHaskellDepends = [
+         aeson aeson-pretty attoparsec base bytestring cereal cereal-text
+         either text unordered-containers
+       ];
+       testHaskellDepends = [
+         base directory either hspec text unordered-containers
+       ];
+       description = "A template DSL library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "glade" = callPackage
     ({ mkDerivation, base, Cabal, glib, gtk, gtk2hs-buildtools
      , libglade
···
      }:
      mkDerivation {
        pname = "graphula";
-       version = "2.0.0.3";
-       sha256 = "1hmay1g8j1b8pq98blq1sizc61h7lj782sajlwrllgvxc826rjm2";
-       libraryHaskellDepends = [
-         base containers directory generics-eot HUnit mtl persistent
-         QuickCheck random semigroups temporary text transformers unliftio
-         unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers hspec http-api-data markdown-unlit
-         monad-logger path-pieces persistent persistent-sqlite
-         persistent-template QuickCheck resourcet text transformers
-         unliftio-core uuid
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "A declarative library for describing dependencies between data";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "graphula_2_0_0_4" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, directory
-     , generics-eot, hspec, http-api-data, HUnit, markdown-unlit
-     , monad-logger, mtl, path-pieces, persistent, persistent-sqlite
-     , persistent-template, QuickCheck, random, resourcet, semigroups
-     , temporary, text, transformers, unliftio, unliftio-core, uuid
-     }:
-     mkDerivation {
-       pname = "graphula";
        version = "2.0.0.4";
        sha256 = "1jqli2ws2n67cha6qd460h1y5iz688dwi5dn6h0a6jmc03yzgxni";
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hakyll-agda";
-       version = "0.1.12";
-       sha256 = "0fa2pw3zaqrxr2in3bb63w7wmch7345lmn84z25s80z0if9qv2x3";
+       version = "0.1.13";
+       sha256 = "1fylx5h0w774j0wwp3g1mhfyifiyrbclydipg9i8v98br9xcnspb";
        libraryHaskellDepends = [
          Agda base containers directory filepath hakyll mtl pandoc text
          transformers xhtml
···
   "hal" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , case-insensitive, conduit, conduit-extra, containers, envy
-     , exceptions, http-client, http-conduit, http-types, mtl, text
-     , time, unordered-containers
+     , exceptions, hspec, http-client, http-types, mtl, text, time
+     , unordered-containers
      }:
      mkDerivation {
        pname = "hal";
-       version = "0.4.6";
-       sha256 = "07xzkb9yavrh17d64gm3pc08jr8cb53lm5fdw6apcn7826ys76vh";
+       version = "0.4.7";
+       sha256 = "1bf2d4djbw8gpkcgrvjm52hsyw8hv20rsk0qdxfi8aml6mp152k5";
        revision = "1";
-       editedCabalFile = "01mx3i40i3xhn9i1bbdppp20df2l305zgzl9r4y02dfzcsy3xff5";
+       editedCabalFile = "19hic5cgxyk2nz8nnrz091hv79al49q7ah9pv9d7fwagjzi027ch";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive conduit
-         conduit-extra containers envy exceptions http-client http-conduit
-         http-types mtl text time unordered-containers
+         conduit-extra containers envy exceptions http-client http-types mtl
+         text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base containers hspec http-client http-types time
        ];
        description = "A runtime environment for Haskell applications running on AWS Lambda";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "haskell-awk" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, doctest
-     , easy-file, exceptions, filepath, haskell-src-exts, hint, hspec
-     , HUnit, mtl, network, process, stringsearch, temporary
-     , test-framework, test-framework-hunit, time, transformers
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
+     , cabal-doctest, containers, directory, doctest, easy-file
+     , exceptions, extra, filelock, filepath, ghc, haskell-src-exts
+     , hint, hspec, HUnit, list-t, mtl, process, stringsearch
+     , template-haskell, temporary, test-framework, test-framework-hunit
+     , time, transformers
      }:
      mkDerivation {
        pname = "haskell-awk";
-       version = "1.1.1";
-       sha256 = "0s6vzfsqh2wwsp98l8zpg6cvh7jwz5wha44idz3yavhmy6z08zgd";
-       revision = "2";
-       editedCabalFile = "1nq69vqp5dphhkq3h94c1gw2hpgyn2snnsig6kjwm4z60ww87viw";
+       version = "1.2";
+       sha256 = "14jfw5s3xw7amwasw37mxfinzwvxd6pr64iypmy65z7bkx3l01cj";
        isLibrary = true;
        isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         base bytestring containers stringsearch
+         base bytestring containers ghc list-t stringsearch
        ];
        executableHaskellDepends = [
-         base bytestring containers directory easy-file exceptions filepath
-         haskell-src-exts hint mtl network process stringsearch time
-         transformers
+         base bytestring containers directory exceptions extra filelock
+         filepath ghc haskell-src-exts hint list-t mtl process stringsearch
+         template-haskell time transformers
        ];
        testHaskellDepends = [
-         base bytestring containers directory doctest easy-file exceptions
-         filepath haskell-src-exts hint hspec HUnit mtl network process
-         stringsearch temporary test-framework test-framework-hunit time
-         transformers
+         aeson attoparsec base bytestring containers directory doctest
+         easy-file exceptions extra filelock filepath ghc haskell-src-exts
+         hint hspec HUnit list-t mtl process stringsearch template-haskell
+         temporary test-framework test-framework-hunit time transformers
        ];
        description = "Transform text from the command-line using Haskell expressions";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "haskell-ci";
-       version = "0.12";
-       sha256 = "17ccxpsi483fkiyp98m09nzqds9n78y53naii5x18nvdxv9fssam";
+       version = "0.12.1";
+       sha256 = "0bdb3x2kk5nqm6ly2ycdpx6xw7pspgg67x73cjscqj6pxcx1wjzf";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.52.4";
-       sha256 = "0qgiskx01rlwdmidv01k4mr9awb4sj6srhcrrsmiqd7fdnlaxb3s";
+       version = "0.52.8";
+       sha256 = "14qwdh0fwyqhb3pgykprgp1vs78y4ixn2dn55bsi9x53cjjvp1qp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, aeson, base, binary, bytes, bytestring, cereal
      , containers, data-default, deepseq, hashable, haskoin-core, hspec
      , hspec-discover, http-client, http-types, lens, mtl, network
-     , QuickCheck, scotty, string-conversions, text
+     , QuickCheck, scotty, string-conversions, text, time
      , unordered-containers, wreq
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.52.0";
-       sha256 = "0fgjmyps858dvx8i2mzn8kqmms869wamldrdlmy2y27wcmrzzj51";
+       version = "0.52.6";
+       sha256 = "0npiib582rnbk3w9f0m71y84xpk7akzkypfxrd9n1s4h3dh0qsfw";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
-         network scotty string-conversions text unordered-containers wreq
+         network scotty string-conversions text time unordered-containers
+         wreq
        ];
        testHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core hspec http-client http-types lens mtl
-         network QuickCheck scotty string-conversions text
+         network QuickCheck scotty string-conversions text time
          unordered-containers wreq
        ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "hidapi";
-       version = "0.1.6";
-       sha256 = "1dy5sbfh8rkzrjpn5ls5xbr32ja0h6bgigzya512advc4c21af2b";
-       libraryHaskellDepends = [
-         base bytestring deepseq deepseq-generics
-       ];
-       librarySystemDepends = [ systemd ];
-       description = "Haskell bindings to HIDAPI";
-       license = lib.licenses.mit;
-     }) {inherit (pkgs) systemd;};
-
-  "hidapi_0_1_7" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, deepseq-generics
-     , systemd
-     }:
-     mkDerivation {
-       pname = "hidapi";
        version = "0.1.7";
        sha256 = "0mgl2yrx7jgn9zzgbrxa7sa5wflzk1jj932jf0bf7f2vsvas71gf";
        libraryHaskellDepends = [
···
        librarySystemDepends = [ systemd ];
        description = "Haskell bindings to HIDAPI";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) systemd;};
 
   "hidden-char" = callPackage
···
        broken = true;
      }) {};
 
+  "hls-brittany-plugin" = callPackage
+    ({ mkDerivation, base, brittany, bytestring, filepath, ghc
+     , ghc-boot-th, ghcide, hls-plugin-api, hls-test-utils, lens
+     , lsp-types, text, transformers
+     }:
+     mkDerivation {
+       pname = "hls-brittany-plugin";
+       version = "1.0.0.1";
+       sha256 = "1lfhgvxs0bvs67raxalvj8pr4qln1yvi7i7wlp33gpk2x89bwaqy";
+       libraryHaskellDepends = [
+         base brittany filepath ghc ghc-boot-th ghcide hls-plugin-api lens
+         lsp-types text transformers
+       ];
+       testHaskellDepends = [ base bytestring hls-test-utils text ];
+       description = "Integration with the Brittany code formatter";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {hls-test-utils = null;};
+
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-explicit-imports-plugin_1_0_0_1" = callPackage
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+     }:
+     mkDerivation {
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       version = "1.0.0.1";
+       sha256 = "1ygs667pkc3zn66yqz6ssrxifhrc906sddmcgjnkprk7zappk2nc";
+       libraryHaskellDepends = [
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       ];
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-plugin-api_1_1_0_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, data-default
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+     , unordered-containers
+     }:
+     mkDerivation {
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       version = "1.1.0.0";
+       sha256 = "1i18a5gxa409882zpviy4paldaq43j4z1zmgr9mag2mn64vplrxy";
+       libraryHaskellDepends = [
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       ];
+       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
···
        license = lib.licenses.asl20;
      }) {};
 
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+  "hls-retrie-plugin_1_0_0_2" = callPackage
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
      }:
      mkDerivation {
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       version = "1.0.0.1";
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
+       version = "1.0.0.2";
+       sha256 = "0jw1q0dk5jl80wbyvi1a6vszj9x3s7d2bnsbnyycbh4zgl33agwb";
        libraryHaskellDepends = [
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
···
 
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-     }:
-     mkDerivation {
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       version = "0.2.0.2";
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       ];
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       license = lib.licenses.bsd3;
-     }) {};
-
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
-       sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
      }:
      mkDerivation {
···
        ];
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "1ryv2738ajagb0wdkac5lka1kzprrf85gqxabafmm3g5szllxjl1";
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec_2_7_10" = callPackage
+    ({ mkDerivation, base, hspec-core, hspec-discover
+     , hspec-expectations, QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec";
+       version = "2.7.10";
+       sha256 = "0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw";
+       libraryHaskellDepends = [
+         base hspec-core hspec-discover hspec-expectations QuickCheck
+       ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hspec
      , hspec-expectations, text
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec-core_2_7_10" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
+     , deepseq, directory, filepath, hspec-expectations, hspec-meta
+     , HUnit, process, QuickCheck, quickcheck-io, random, setenv
+     , silently, stm, temporary, tf-random, transformers
+     }:
+     mkDerivation {
+       pname = "hspec-core";
+       version = "2.7.10";
+       sha256 = "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1";
+       libraryHaskellDepends = [
+         ansi-terminal array base call-stack clock deepseq directory
+         filepath hspec-expectations HUnit QuickCheck quickcheck-io random
+         setenv stm tf-random transformers
+       ];
+       testHaskellDepends = [
+         ansi-terminal array base call-stack clock deepseq directory
+         filepath hspec-expectations hspec-meta HUnit process QuickCheck
+         quickcheck-io random setenv silently stm temporary tf-random
+         transformers
+       ];
+       testToolDepends = [ hspec-meta ];
+       testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-dirstream" = callPackage
     ({ mkDerivation, base, dirstream, filepath, hspec, hspec-core
      , pipes, pipes-safe, system-filepath, text
···
        testToolDepends = [ hspec-meta ];
        description = "Automatically discover and run Hspec tests";
        license = lib.licenses.mit;
+     }) {};
+
+  "hspec-discover_2_7_10" = callPackage
+    ({ mkDerivation, base, directory, filepath, hspec-meta, QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec-discover";
+       version = "2.7.10";
+       sha256 = "13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+         base directory filepath hspec-meta QuickCheck
+       ];
+       testToolDepends = [ hspec-meta ];
+       description = "Automatically discover and run Hspec tests";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hspec-expectations" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "http-client_0_7_6" = callPackage
+  "http-client_0_7_7" = callPackage
     ({ mkDerivation, array, async, base, base64-bytestring
      , blaze-builder, bytestring, case-insensitive, containers, cookie
      , deepseq, directory, exceptions, filepath, ghc-prim, hspec
-     , http-types, mime-types, monad-control, network, network-uri
-     , random, stm, streaming-commons, text, time, transformers, zlib
+     , http-types, iproute, mime-types, monad-control, network
+     , network-uri, random, stm, streaming-commons, text, time
+     , transformers, zlib
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.7.6";
-       sha256 = "1458mq5kh5fjlkhk9cgaz6sc6533l2nm4r2jz80diy8qc6bpiwrk";
+       version = "0.7.7";
+       sha256 = "0sbjfxfnj5b594klc7h7zmw27gssrbcsacld9lw9p0bpmgx73lvn";
        libraryHaskellDepends = [
          array base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie deepseq exceptions filepath
-         ghc-prim http-types mime-types network network-uri random stm
-         streaming-commons text time transformers
+         ghc-prim http-types iproute mime-types network network-uri random
+         stm streaming-commons text time transformers
        ];
        testHaskellDepends = [
          async base blaze-builder bytestring case-insensitive containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http2_3_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, async, base
+     , base16-bytestring, bytestring, case-insensitive, containers
+     , cryptonite, directory, filepath, gauge, Glob, heaps, hspec
+     , hspec-discover, http-types, mwc-random, network
+     , network-byte-order, network-run, psqueues, stm, text
+     , time-manager, typed-process, unix-time, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "http2";
+       version = "3.0.0";
+       sha256 = "17j4p2apyiiznkwdn9a8pdb43vcwbnpzyff2wqlzpbf9habb8idf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring case-insensitive containers http-types
+         network network-byte-order psqueues stm time-manager unix-time
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base base16-bytestring bytestring
+         cryptonite directory filepath Glob hspec http-types
+         network-byte-order network-run text typed-process
+         unordered-containers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         array base bytestring case-insensitive containers gauge heaps
+         mwc-random network-byte-order psqueues stm
+       ];
+       description = "HTTP/2 library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http2-client" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, deepseq
      , http2, lifted-async, lifted-base, mtl, network, stm, time, tls
···
     ({ mkDerivation, base, containers, QuickCheck, text }:
      mkDerivation {
        pname = "hzenhan";
-       version = "0.0.4";
-       sha256 = "1gbrzjjdihgzj63sp2h4762zybyhd5rxa8rpvsjra21qvvch12mx";
+       version = "0.0.5";
+       sha256 = "1zrxcbazask9dg9rqkdfkm8q055p1wl9834a3yslyxq0h39acc61";
        libraryHaskellDepends = [ base containers text ];
        testHaskellDepends = [ base containers QuickCheck text ];
        description = "Zenhan library for Haskell";
···
 
   "ircbot" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
-     , irc, mtl, network, parsec, random, SafeSemaphore, stm, time, unix
+     , irc, mtl, network, optparse-applicative, parsec, random
+     , SafeSemaphore, stm, time, unix
      }:
      mkDerivation {
        pname = "ircbot";
-       version = "0.6.6";
-       sha256 = "1nmqgimmmxry4pj1y5mfsp662hkivn0vr9n8rx1yn0aldlzrxdm8";
+       version = "0.6.6.1";
+       sha256 = "00dw9ay5x4hb8p2jvxwgcxqlny7cpm6lk5kqaw9yc9c6m6705fqc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring containers directory filepath irc mtl network
-         parsec random SafeSemaphore stm time unix
+         optparse-applicative parsec random SafeSemaphore stm time unix
        ];
-       executableHaskellDepends = [
-         base bytestring containers directory filepath irc mtl network
-         parsec random SafeSemaphore stm time unix
-       ];
+       executableHaskellDepends = [ base ];
        description = "A library for writing IRC bots";
        license = lib.licenses.bsd3;
      }) {};
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) python;};
+     }) {python = null;};
 
   "json-qq" = callPackage
     ({ mkDerivation, base, haskell-src-meta, parsec, template-haskell
···
        broken = true;
      }) {};
 
+  "koji" = callPackage
+    ({ mkDerivation, base, haxr, mtl }:
+     mkDerivation {
+       pname = "koji";
+       version = "0.0.1";
+       sha256 = "0yxx6xk5xld7jf7ph4x0r7k4bqcg02yl7597awbgbq82x97gyfb8";
+       libraryHaskellDepends = [ base haxr mtl ];
+       description = "Koji buildsystem XML-RPC API bindings";
+       license = lib.licenses.gpl2Only;
+     }) {};
+
   "kontra-config" = callPackage
     ({ mkDerivation, base, bytestring, data-default, exceptions, text
      , transformers-base, unjson, utf8-string, yaml
···
        ];
        description = "Krank checks your code source comments for important markers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "krapsh" = callPackage
···
      }:
      mkDerivation {
        pname = "lifted-async";
-       version = "0.10.1.3";
-       sha256 = "1hml672j8sqxhklxif3nwr8v59a596wwwbllq0zvvmlxcjdzlh7k";
-       libraryHaskellDepends = [
-         async base constraints lifted-base monad-control transformers-base
-       ];
-       testHaskellDepends = [
-         async base HUnit lifted-base monad-control mtl tasty
-         tasty-expected-failure tasty-hunit tasty-th
-       ];
-       benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
-       description = "Run lifted IO operations asynchronously and wait for their results";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lifted-async_0_10_2" = callPackage
-    ({ mkDerivation, async, base, constraints, deepseq, HUnit
-     , lifted-base, monad-control, mtl, tasty, tasty-bench
-     , tasty-expected-failure, tasty-hunit, tasty-th, transformers-base
-     }:
-     mkDerivation {
-       pname = "lifted-async";
        version = "0.10.2";
        sha256 = "0alhvrvxp4f4srllyq5br3waiba4c93cc4nxm7jd23440swr6a31";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
        description = "Run lifted IO operations asynchronously and wait for their results";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lifted-base" = callPackage
···
      }) {};
 
   "lzma" = callPackage
-    ({ mkDerivation, base, bytestring, HUnit, lzma, QuickCheck, tasty
-     , tasty-hunit, tasty-quickcheck
+    ({ mkDerivation, base, bytestring, HUnit, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck, xz
      }:
      mkDerivation {
        pname = "lzma";
···
        revision = "6";
        editedCabalFile = "1sh2g5wkh0m6646cxnii0k20f0crwdcnprfl9jfg7gxn5875bkip";
        libraryHaskellDepends = [ base bytestring ];
-       librarySystemDepends = [ lzma ];
+       librarySystemDepends = [ xz ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
        ];
        description = "LZMA/XZ compression and decompression";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs) lzma;};
+     }) {inherit (pkgs) xz;};
 
   "lzma-clib" = callPackage
     ({ mkDerivation }:
···
 
   "lzma-enumerator" = callPackage
     ({ mkDerivation, base, bindings-DSL, bytestring, enumerator, HUnit
-     , lzma, mtl, QuickCheck, test-framework, test-framework-hunit
-     , test-framework-quickcheck2
+     , mtl, QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, xz
      }:
      mkDerivation {
        pname = "lzma-enumerator";
···
        libraryHaskellDepends = [
          base bindings-DSL bytestring enumerator mtl
        ];
-       librarySystemDepends = [ lzma ];
+       librarySystemDepends = [ xz ];
        testHaskellDepends = [
          base bytestring enumerator HUnit QuickCheck test-framework
          test-framework-hunit test-framework-quickcheck2
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) lzma;};
+     }) {inherit (pkgs) xz;};
 
   "lzma-static" = callPackage
     ({ mkDerivation, base, bytestring, HUnit, QuickCheck, tasty
···
      }:
      mkDerivation {
        pname = "lzma-static";
-       version = "5.2.5";
-       sha256 = "13xgap430r2hpkwk56ra5ya8fparikpzy50mbyd0xdpvs02imwfp";
+       version = "5.2.5.2";
+       sha256 = "12na1ycwrd7p50g19kgnb6kdgswnkwgzynaf0lyrv30qicpd8a5z";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
···
        broken = true;
      }) {};
 
+  "mcaeson" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "mcaeson";
+       version = "0.0.0.1";
+       sha256 = "0gkwqkyp5apwkzlqwm4h1fy112fy2ywg5qq2ma4s5agz9574h73q";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "An Aeson parsing toolkit";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "mcl" = callPackage
     ({ mkDerivation, base, binary, bytestring, Cabal, criterion
      , deepseq, ghc-prim, gmpxx, groups, integer-gmp, mcl, openssl
···
     ({ mkDerivation, base, hspec, hspec-discover, rio, transformers }:
      mkDerivation {
        pname = "method";
-       version = "0.3.0.0";
-       sha256 = "1a5i9sd5zz5kjpjpar3r5ak61x8fz5rrbb1iak1r2dcwlyk6rq25";
+       version = "0.3.1.0";
+       sha256 = "0a96av07vbh3mvyczh2jiziqb098q81jx6q0c5kgn7pmlxijw1ba";
        libraryHaskellDepends = [ base rio transformers ];
        testHaskellDepends = [ base hspec rio transformers ];
        testToolDepends = [ hspec-discover ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "mod_0_1_2_2" = callPackage
+    ({ mkDerivation, base, deepseq, integer-gmp, primitive
+     , quickcheck-classes, quickcheck-classes-base, semirings, tasty
+     , tasty-bench, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "mod";
+       version = "0.1.2.2";
+       sha256 = "0m92yd323kjjwnphqlima2aj0hh7i1gnpblc8a29ks25gj0sv66v";
+       libraryHaskellDepends = [
+         base deepseq integer-gmp primitive semirings vector
+       ];
+       testHaskellDepends = [
+         base primitive quickcheck-classes quickcheck-classes-base semirings
+         tasty tasty-quickcheck vector
+       ];
+       benchmarkHaskellDepends = [ base tasty-bench ];
+       description = "Fast type-safe modular arithmetic";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "modbus-tcp" = callPackage
     ({ mkDerivation, base, bytestring, cereal, mtl, transformers }:
      mkDerivation {
···
      }) {};
 
   "more-containers" = callPackage
-    ({ mkDerivation, base, binary, containers, hspec }:
-     mkDerivation {
-       pname = "more-containers";
-       version = "0.2.2.0";
-       sha256 = "1i4klvfwgw608sy81mqqvd107b187gkib2rwsz6aqc4rh0vm0a87";
-       libraryHaskellDepends = [ base binary containers ];
-       testHaskellDepends = [ base binary containers hspec ];
-       description = "A few more collections";
-       license = lib.licenses.mit;
-     }) {};
-
-  "more-containers_0_2_2_2" = callPackage
     ({ mkDerivation, base, binary, containers, hspec }:
      mkDerivation {
        pname = "more-containers";
···
        testHaskellDepends = [ base binary containers hspec ];
        description = "A few more collections";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "more-extensible-effects" = callPackage
···
      }:
      mkDerivation {
        pname = "nix-thunk";
-       version = "0.2.0.2";
-       sha256 = "1jxdxb8ri0cd7ni9z80xlb86d81bb83c6ki5wj7jx7sn9inzz8z7";
+       version = "0.3.0.0";
+       sha256 = "11fn65swyj7b3l7xs6rws81nnccr2hcf81igqmna5bwck3g2gklw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "nonempty-zipper_1_0_0_2" = callPackage
+    ({ mkDerivation, base, comonad, deepseq, doctest, Glob, safe }:
+     mkDerivation {
+       pname = "nonempty-zipper";
+       version = "1.0.0.2";
+       sha256 = "10fj56ry851npkhrkw9gb1sckhx764l2s2c5x83cnylxlg7cfijj";
+       libraryHaskellDepends = [ base comonad deepseq safe ];
+       testHaskellDepends = [ base comonad deepseq doctest Glob safe ];
+       description = "A non-empty comonadic list zipper";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nonemptymap" = callPackage
     ({ mkDerivation, base, containers, semigroupoids }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-env-parser_0_1_0_7" = callPackage
+    ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text
+     }:
+     mkDerivation {
+       pname = "nri-env-parser";
+       version = "0.1.0.7";
+       sha256 = "1mm879mqpgl040p789wcjm5bhrqia5czn18c5dgni8bwa4y61ank";
+       libraryHaskellDepends = [
+         base modern-uri network-uri nri-prelude text
+       ];
+       description = "Read environment variables as settings to build 12-factor apps";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-observability" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
      , bytestring, directory, hostname, http-client, http-client-tls
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-observability_0_1_0_2" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
+     , bytestring, directory, hostname, http-client, http-client-tls
+     , nri-env-parser, nri-prelude, random, safe-exceptions, stm, text
+     , time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "nri-observability";
+       version = "0.1.0.2";
+       sha256 = "19nil7vyjbvbjlapvrxky8fkxdl3f2xhqdi3a5m5i5lyawm74b6z";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring directory
+         hostname http-client http-client-tls nri-env-parser nri-prelude
+         random safe-exceptions stm text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring directory
+         hostname http-client http-client-tls nri-env-parser nri-prelude
+         random safe-exceptions stm text time unordered-containers
+       ];
+       description = "Report log spans collected by nri-prelude";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-prelude" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
      , bytestring, containers, directory, exceptions, filepath, ghc
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-prelude_0_6_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
+     , bytestring, containers, directory, exceptions, filepath, ghc
+     , hedgehog, junit-xml, pretty-diff, pretty-show, safe-coloured-text
+     , safe-exceptions, terminal-size, text, time, vector
+     }:
+     mkDerivation {
+       pname = "nri-prelude";
+       version = "0.6.0.0";
+       sha256 = "02v83n08zxz8521skijgrn407a0mlkjc3fjn5q04gn932wf29g5s";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
+         pretty-show safe-coloured-text safe-exceptions terminal-size text
+         time vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
+         pretty-show safe-coloured-text safe-exceptions terminal-size text
+         time vector
+       ];
+       description = "A Prelude inspired by the Elm programming language";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nsis" = callPackage
     ({ mkDerivation, base, directory, process, transformers, uniplate
      }:
···
        pname = "patch";
        version = "0.0.3.2";
        sha256 = "1b819d1iramxb0sf0zm4ry8mrd74y35iffbb6qys3a2xq1d382xa";
+       revision = "2";
+       editedCabalFile = "09v23qakrdjscwvzjarkssikkp7xmq9jbpp5hh1y857l02r3fz5c";
        libraryHaskellDepends = [
          base constraints-extras containers dependent-map dependent-sum lens
          monoidal-containers semialign semigroupoids these transformers
···
        pname = "pixiv";
        version = "0.1.0";
        sha256 = "001pfzijh7ibcyinmw0l8yvw0kxsvmniw993qx9b6zlzf689cpp6";
+       revision = "1";
+       editedCabalFile = "03wfjj0a074n02mpa02gncfy35m53qdmij465dk8g6qjnjah8a01";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring cryptohash-md5 directory
          exceptions filepath http-client http-client-tls lens monad-control
···
 
   "polysemy-http" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring
-     , case-insensitive, co-log-core, co-log-polysemy, composition
-     , containers, data-default, either, hedgehog, http-client
-     , http-client-tls, http-types, lens, network, polysemy
-     , polysemy-log, polysemy-plugin, relude, servant, servant-client
-     , servant-server, string-interpolate, tasty, tasty-hedgehog
-     , template-haskell, text, time, warp
+     , case-insensitive, composition, containers, data-default, either
+     , hedgehog, http-client, http-client-tls, http-types, lens, network
+     , polysemy, polysemy-log, polysemy-plugin, relude, servant
+     , servant-client, servant-server, string-interpolate, tasty
+     , tasty-hedgehog, template-haskell, text, time, warp
      }:
      mkDerivation {
        pname = "polysemy-http";
-       version = "0.4.0.2";
-       sha256 = "0xxl33iydycw1n2q9wvbx3jlhzsw9yhbm4v0a8v2ic05nqlmaw4l";
+       version = "0.4.0.3";
+       sha256 = "0sp4s8spf0nzqs8cw9swnsxd2wxa0g4cnz236n7m6z73450ih3c7";
        libraryHaskellDepends = [
-         aeson ansi-terminal base bytestring case-insensitive co-log-core
-         co-log-polysemy composition containers data-default either
-         http-client http-client-tls http-types lens polysemy polysemy-log
-         polysemy-plugin relude string-interpolate template-haskell text
-         time
+         aeson ansi-terminal base bytestring case-insensitive composition
+         containers data-default either http-client http-client-tls
+         http-types lens polysemy polysemy-log polysemy-plugin relude
+         string-interpolate template-haskell text time
        ];
        testHaskellDepends = [
-         aeson ansi-terminal base bytestring case-insensitive co-log-core
-         co-log-polysemy composition containers data-default either hedgehog
-         http-client http-client-tls http-types lens network polysemy
-         polysemy-log polysemy-plugin relude servant servant-client
-         servant-server string-interpolate tasty tasty-hedgehog
-         template-haskell text time warp
+         aeson ansi-terminal base bytestring case-insensitive composition
+         containers data-default either hedgehog http-client http-client-tls
+         http-types lens network polysemy polysemy-log polysemy-plugin
+         relude servant servant-client servant-server string-interpolate
+         tasty tasty-hedgehog template-haskell text time warp
        ];
        description = "Polysemy effect for http-client";
        license = "BSD-2-Clause-Patent";
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) python;};
+     }) {python = null;};
 
   "pyfi" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, pureMD5
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) python;};
+     }) {python = null;};
 
   "python-pickle" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, cereal, cmdargs
···
        license = lib.licenses.mit;
      }) {};
 
+  "qr" = callPackage
+    ({ mkDerivation, array, base, cairo, gtk, optparse-applicative
+     , transformers, utf8-string
+     }:
+     mkDerivation {
+       pname = "qr";
+       version = "0.2.0.0";
+       sha256 = "0mn33p9j87w5fq4ddrwn5nb32gcxzxli55y3jv1aaypsgi6vf3w7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ array base utf8-string ];
+       executableHaskellDepends = [
+         array base cairo gtk optparse-applicative transformers
+       ];
+       description = "Pure Haskell QR encoder library and command line tool";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "qr-imager" = callPackage
     ({ mkDerivation, base, binary, bytestring, cryptonite, directory
      , haskell-qrencode, hspec, jose-jwt, JuicyPixels, microlens
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "quickcheck-classes_0_6_5_0" = callPackage
+    ({ mkDerivation, aeson, base, base-orphans, containers, primitive
+     , primitive-addr, QuickCheck, quickcheck-classes-base
+     , semigroupoids, semirings, tagged, tasty, tasty-quickcheck
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "quickcheck-classes";
+       version = "0.6.5.0";
+       sha256 = "19iw15mvb7gws3ljdxqwsbb4pmfc0sfflf8szgmrhiqr3k82mqv2";
+       libraryHaskellDepends = [
+         aeson base containers primitive primitive-addr QuickCheck
+         quickcheck-classes-base semigroupoids semirings transformers vector
+       ];
+       testHaskellDepends = [
+         aeson base base-orphans containers primitive QuickCheck
+         semigroupoids tagged tasty tasty-quickcheck transformers vector
+       ];
+       description = "QuickCheck common typeclasses";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "quickcheck-classes-base" = callPackage
     ({ mkDerivation, base, base-orphans, bifunctors, containers
      , contravariant, fail, QuickCheck, tagged, transformers
···
        ];
        description = "QuickCheck common typeclasses from `base`";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "quickcheck-classes-base_0_6_2_0" = callPackage
+    ({ mkDerivation, base, containers, QuickCheck, transformers }:
+     mkDerivation {
+       pname = "quickcheck-classes-base";
+       version = "0.6.2.0";
+       sha256 = "16c6gq4cqpkwnq1pzkhm6r7mrwk4an50ha5w77bmiia2qkhla6ch";
+       libraryHaskellDepends = [
+         base containers QuickCheck transformers
+       ];
+       description = "QuickCheck common typeclasses from `base`";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "quickcheck-combinators" = callPackage
···
      }:
      mkDerivation {
        pname = "reflex";
-       version = "0.8.0.0";
-       sha256 = "14pw033ljs6x5bi5657cm5lpwwj6gkfgskbv5lpdi2hp7svzayql";
+       version = "0.8.1.0";
+       sha256 = "0p27dj7fckkvw9li69whcfrv1cd59kkp6qbvfmndzx8fbh44ggbp";
        libraryHaskellDepends = [
          base bifunctors comonad constraints-extras containers data-default
          dependent-map dependent-sum exception-transformers haskell-src-exts
···
        pname = "reflex-dom";
        version = "0.6.1.0";
        sha256 = "190g56y16xvj508qdp3znlbbv4gb3ska38jbjpblvq8cz2d4nkdc";
+       revision = "1";
+       editedCabalFile = "0xi2bn6d4bgbfqngl2y9gva4nxii65v3hzrik74wzdsf17wyrmv9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "reflex-dom-core";
-       version = "0.6.1.0";
-       sha256 = "072bkjjmz6mjw42gchlbswhjhr9xs0vaybf6mvdycs618lb1zhf0";
+       version = "0.6.2.0";
+       sha256 = "067m8ifgkknafy0nxzmns89dqjzpsc983pm3gaq7dg618jp1dzy4";
        libraryHaskellDepends = [
          aeson base bifunctors bimap blaze-builder bytestring
          case-insensitive constraints containers contravariant data-default
···
      }:
      mkDerivation {
        pname = "retrie";
-       version = "0.1.1.1";
-       sha256 = "1l6pcvmf95i4r4b370j8dwqbvj3971xn6097lbw93agyrf704qpi";
+       version = "1.0.0.0";
+       sha256 = "1hrkx7gx7hwgljvx8zm1yhn7xvyif943hvxx5b27ali6grmndy9w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "rio-orphans" = callPackage
     ({ mkDerivation, base, exceptions, fast-logger, hspec
      , monad-control, monad-logger, resourcet, rio, transformers-base
-     }:
-     mkDerivation {
-       pname = "rio-orphans";
-       version = "0.1.1.0";
-       sha256 = "0klbshdsv3gq3l7g1d6gq2wxdqjlqxbnwk1lbg5dpbz7yrnjr3by";
-       libraryHaskellDepends = [
-         base exceptions fast-logger monad-control monad-logger resourcet
-         rio transformers-base
-       ];
-       testHaskellDepends = [
-         base exceptions fast-logger hspec monad-control monad-logger
-         resourcet rio transformers-base
-       ];
-       description = "Orphan instances for the RIO type in the rio package";
-       license = lib.licenses.mit;
-     }) {};
-
-  "rio-orphans_0_1_2_0" = callPackage
-    ({ mkDerivation, base, exceptions, fast-logger, hspec
-     , monad-control, monad-logger, resourcet, rio, transformers-base
      , unliftio-core
      }:
      mkDerivation {
···
        ];
        description = "Orphan instances for the RIO type in the rio package";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rio-prettyprint" = callPackage
···
        license = lib.licenses.publicDomain;
      }) {};
 
+  "safecopy_0_10_4_2" = callPackage
+    ({ mkDerivation, array, base, bytestring, cereal, containers
+     , generic-data, HUnit, lens, lens-action, old-time, QuickCheck
+     , quickcheck-instances, tasty, tasty-quickcheck, template-haskell
+     , text, time, transformers, vector
+     }:
+     mkDerivation {
+       pname = "safecopy";
+       version = "0.10.4.2";
+       sha256 = "0r2mf0p82gf8vnldx477b5ykrj1x7hyg13nqfn6gzb50japs6h3i";
+       libraryHaskellDepends = [
+         array base bytestring cereal containers generic-data old-time
+         template-haskell text time transformers vector
+       ];
+       testHaskellDepends = [
+         array base bytestring cereal containers HUnit lens lens-action
+         QuickCheck quickcheck-instances tasty tasty-quickcheck
+         template-haskell time vector
+       ];
+       description = "Binary serialization with version control";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "safecopy-migrate" = callPackage
     ({ mkDerivation, base, base-prelude, cereal, containers, extra
      , haskell-src-meta, microlens, safecopy, template-haskell
···
      }:
      mkDerivation {
        pname = "sak";
-       version = "0.1.3.0";
-       sha256 = "1khws0z9v91vz722k6y0b99ffy2vd04myvpww4p1i32396dhczln";
+       version = "0.1.3.1";
+       sha256 = "12vharmp5f0ffxy4j5kjwqnffc87y4wmzvgcfvp6prqyjfh87qfy";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        broken = true;
      }) {};
 
+  "sandwich" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, brick
+     , bytestring, colour, containers, directory, exceptions, filepath
+     , free, haskell-src-exts, lens, lifted-async, microlens
+     , microlens-th, monad-control, monad-logger, mtl
+     , optparse-applicative, pretty-show, process, safe, safe-exceptions
+     , stm, string-interpolate, template-haskell, text, time
+     , transformers, transformers-base, unix, unliftio-core, vector, vty
+     }:
+     mkDerivation {
+       pname = "sandwich";
+       version = "0.1.0.2";
+       sha256 = "1xcw3mdl85brj6pvynz58aclaf3ya0aq0y038cps9dsz58bqhbka";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lens
+         lifted-async microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       executableHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lens
+         lifted-async microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lens
+         lifted-async microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       description = "Yet another test framework for Haskell";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "sandwich-slack" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, lens
+     , lens-aeson, monad-logger, mtl, safe, safe-exceptions, sandwich
+     , stm, string-interpolate, text, time, vector, wreq
+     }:
+     mkDerivation {
+       pname = "sandwich-slack";
+       version = "0.1.0.1";
+       sha256 = "1c7csrdfq342733rgrfwx5rc6v14jhfb9wb44gn699pgzzj031kz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       description = "Sandwich integration with Slack";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "sandwich-webdriver" = callPackage
+    ({ mkDerivation, aeson, base, containers, convertible, data-default
+     , directory, exceptions, filepath, http-client, http-client-tls
+     , http-conduit, lifted-base, microlens, microlens-aeson
+     , monad-control, monad-logger, mtl, network, process, random, retry
+     , safe, safe-exceptions, sandwich, string-interpolate, temporary
+     , text, time, transformers, unix, unordered-containers, vector
+     , webdriver, X11
+     }:
+     mkDerivation {
+       pname = "sandwich-webdriver";
+       version = "0.1.0.1";
+       sha256 = "10s0zb3al4ii9gm3b6by8czvr8i3s424mlfk81v2hpdv5i7a0yqb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base containers convertible data-default directory exceptions
+         filepath http-client http-client-tls http-conduit lifted-base
+         microlens microlens-aeson monad-control monad-logger mtl network
+         process random retry safe safe-exceptions sandwich
+         string-interpolate temporary text time transformers unix
+         unordered-containers vector webdriver X11
+       ];
+       executableHaskellDepends = [
+         aeson base containers convertible data-default directory exceptions
+         filepath http-client http-client-tls http-conduit lifted-base
+         microlens microlens-aeson monad-control monad-logger mtl network
+         process random retry safe safe-exceptions sandwich
+         string-interpolate temporary text time transformers unix
+         unordered-containers vector webdriver X11
+       ];
+       testHaskellDepends = [
+         aeson base containers convertible data-default directory exceptions
+         filepath http-client http-client-tls http-conduit lifted-base
+         microlens microlens-aeson monad-control monad-logger mtl network
+         process random retry safe safe-exceptions sandwich
+         string-interpolate temporary text time transformers unix
+         unordered-containers vector webdriver X11
+       ];
+       description = "Sandwich integration with Selenium WebDriver";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "sarasvati" = callPackage
     ({ mkDerivation, base, deepseq, portaudio }:
      mkDerivation {
···
   "serverless-haskell" = callPackage
     ({ mkDerivation, aeson, aeson-casing, amazonka-core
      , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive
-     , hspec, hspec-discover, http-client, http-types, iproute, lens
-     , raw-strings-qq, safe-exceptions, text, time, transformers, unix
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "serverless-haskell";
-       version = "0.12.5";
-       sha256 = "1p15nzwjbwbjxnqgs6dzz7sb2cp5y3l69hr3n10zmwmgrq4x2nfa";
-       libraryHaskellDepends = [
-         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
-         bytestring case-insensitive http-client http-types iproute lens
-         safe-exceptions text time unix unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson aeson-casing amazonka-core amazonka-kinesis amazonka-s3 base
-         bytestring case-insensitive hspec hspec-discover http-client
-         http-types iproute lens raw-strings-qq safe-exceptions text time
-         transformers unix unordered-containers
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Deploying Haskell code onto AWS Lambda using Serverless";
-       license = lib.licenses.mit;
-     }) {};
-
-  "serverless-haskell_0_12_6" = callPackage
-    ({ mkDerivation, aeson, aeson-casing, amazonka-core
-     , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive
      , containers, hspec, hspec-discover, http-client, http-types
      , iproute, lens, raw-strings-qq, safe-exceptions, text, time
      , transformers, unix, unordered-containers
···
        testToolDepends = [ hspec-discover ];
        description = "Deploying Haskell code onto AWS Lambda using Serverless";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "serversession" = callPackage
···
     ({ mkDerivation, base, containers, lucid, skylighting-core, text }:
      mkDerivation {
        pname = "skylighting-lucid";
-       version = "1.0.0";
-       sha256 = "09wh0dh8glnb051hdbcf4q4v3nflikgc585acqin8kq7zny7ps72";
+       version = "1.0.1";
+       sha256 = "0igimymq8pcizl4wdmyjafjgdw8xi2059jzmcw64ij18rn6bip8d";
        libraryHaskellDepends = [
          base containers lucid skylighting-core text
        ];
···
 
   "snaplet-redis" = callPackage
     ({ mkDerivation, base, bytestring, cereal, clientsession
-     , configurator, hedis, lens, mtl, network, snap, snap-core, text
-     , time, transformers, unordered-containers
+     , configurator, hedis, lens, mtl, snap, snap-core, text, time
+     , unordered-containers
      }:
      mkDerivation {
        pname = "snaplet-redis";
-       version = "0.1.6";
-       sha256 = "09ba0jmbjk121c2cvnd83328w9h2d5rzwvmpxs2pi93x6jqpd9qw";
+       version = "0.1.6.1";
+       sha256 = "07wwh2gpbsg60p0a4qxf4knbchpq7bvh8bdckzw5f39k5xcaibsy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring cereal clientsession configurator hedis lens mtl
-         network snap snap-core text time transformers unordered-containers
+         snap snap-core text time unordered-containers
        ];
        description = "Redis support for Snap Framework";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, deepseq }:
      mkDerivation {
        pname = "some";
-       version = "1.0.2";
-       sha256 = "12mv5gzcvl4n5rz685r2nmmiykvnkvrvx7k4cvwscdjjgnqa9y6c";
-       libraryHaskellDepends = [ base deepseq ];
-       testHaskellDepends = [ base ];
-       description = "Existential type: Some";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "some_1_0_3" = callPackage
-    ({ mkDerivation, base, deepseq }:
-     mkDerivation {
-       pname = "some";
        version = "1.0.3";
        sha256 = "0w3syapwz9v916zf1i4f8vxymdfg7syc2cpxgnqr018pbswzxrk2";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [ base ];
        description = "Existential type: Some";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sonic-visualiser" = callPackage
···
        executableHaskellDepends = [ base bytestring ];
        description = "Sort lines per file size";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "souffle-dsl" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, hedgehog
+     , hspec, hspec-hedgehog, mtl, neat-interpolation, process
+     , souffle-haskell, template-haskell, temporary, text
+     , type-errors-pretty
+     }:
+     mkDerivation {
+       pname = "souffle-dsl";
+       version = "0.1.0";
+       sha256 = "1j3g4nwl0v5szphvyv0jp7qcmnpfmynr8dbkwwh4lwacldgnhbnr";
+       libraryHaskellDepends = [
+         base containers directory filepath mtl process souffle-haskell
+         template-haskell temporary text type-errors-pretty
+       ];
+       testHaskellDepends = [
+         base containers directory filepath hedgehog hspec hspec-hedgehog
+         mtl neat-interpolation process souffle-haskell template-haskell
+         temporary text type-errors-pretty
+       ];
+       description = "Haskell EDSL for Souffle";
+       license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
+  "spartacon" = callPackage
+    ({ mkDerivation, base, config-schema, config-value, containers
+     , either, mtl, relation, text, X11
+     }:
+     mkDerivation {
+       pname = "spartacon";
+       version = "0.1.0.0";
+       sha256 = "1mabp5gfwj7zv30rdnr1zwl4fv29128vg08izjcj8sym0hldzj81";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base config-schema config-value containers either mtl relation text
+         X11
+       ];
+       description = "A unix-style (read from stdin, write to stdout) global hotkey daemon";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "spata" = callPackage
     ({ mkDerivation, base, dlist, mps, mtl }:
      mkDerivation {
···
        benchmarkHaskellDepends = [ base express leancheck ];
        description = "discovery of properties about Haskell functions";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "speculate_0_4_4" = callPackage
+    ({ mkDerivation, base, cmdargs, containers, express, leancheck }:
+     mkDerivation {
+       pname = "speculate";
+       version = "0.4.4";
+       sha256 = "0vmxi8rapbld7b3llw2v6fz1v6vqyv90rpbnzjdfa29kdza4m5sf";
+       libraryHaskellDepends = [
+         base cmdargs containers express leancheck
+       ];
+       testHaskellDepends = [ base express leancheck ];
+       benchmarkHaskellDepends = [ base express leancheck ];
+       description = "discovery of properties about Haskell functions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "speculation" = callPackage
···
      }:
      mkDerivation {
        pname = "string-random";
-       version = "0.1.4.0";
-       sha256 = "09xv1jbhsz8hfxc6y54fj4pkhyxfbfh53i6kxy408zm3raa2nmii";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base containers random text transformers
-       ];
-       executableHaskellDepends = [ base optparse-applicative text ];
-       testHaskellDepends = [
-         base bytestring pcre-heavy QuickCheck tasty tasty-hunit
-         tasty-quickcheck text
-       ];
-       description = "A library for generating random string from a regular experession";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "string-random_0_1_4_1" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , optparse-applicative, pcre-heavy, QuickCheck, random, tasty
-     , tasty-hunit, tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "string-random";
        version = "0.1.4.1";
        sha256 = "1ggz48mzyzch3ga4682jd9y4g1j6px1anv7k8cczjlz9f4lh73nd";
        isLibrary = true;
···
        ];
        description = "A library for generating random string from a regular experession";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "string-similarity" = callPackage
···
      }:
      mkDerivation {
        pname = "syntactic";
-       version = "3.8.2";
-       sha256 = "04lv8v42bs4qjjcia39grfxmabiv41dipgg5b58xgiv4ay884nfm";
+       version = "3.8.3";
+       sha256 = "1ksznzw5g01xgbr2zs83m0lclbhvhs6lyaszhxykni10lxyxy7v8";
        libraryHaskellDepends = [
          base constraints containers data-hash deepseq mtl syb
          template-haskell tree-view
···
      }) {};
 
   "tasty-bench" = callPackage
-    ({ mkDerivation, base, containers, deepseq, tasty }:
-     mkDerivation {
-       pname = "tasty-bench";
-       version = "0.2.4";
-       sha256 = "11hkhlpwxzxxi6ny4jklaz70cd0ca905yxv9idacmwajbrliinna";
-       libraryHaskellDepends = [ base containers deepseq tasty ];
-       description = "Featherlight benchmark framework";
-       license = lib.licenses.mit;
-     }) {};
-
-  "tasty-bench_0_2_5" = callPackage
     ({ mkDerivation, base, containers, deepseq, tasty }:
      mkDerivation {
        pname = "tasty-bench";
        version = "0.2.5";
        sha256 = "146i1vkp9008hik7qyi8m9qq3ij5kji84qscsf598rzjmjga7igd";
+       revision = "1";
+       editedCabalFile = "0rcsdiwri52wng5dj30k3c5qrn8qfr14qs53cs1y99mbqfpzs02g";
        libraryHaskellDepends = [ base containers deepseq tasty ];
        description = "Featherlight benchmark framework";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-dejafu" = callPackage
···
      }:
      mkDerivation {
        pname = "tesla";
-       version = "0.3.1.0";
-       sha256 = "1fwrhmxqpliyq92v1j6jcqxi5iyh7s8rj17mybvgkwh5aprwsdp8";
+       version = "0.4.1.0";
+       sha256 = "0rnzgcwkgwnpjlf2r47a28zwkbnsb75wfmdiwnq4w99i2f519dnd";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring casing containers
          cryptonite exceptions generic-deriving lens lens-aeson memory
···
        license = lib.licenses.asl20;
      }) {};
 
+  "text-regex-replace_0_1_1_4" = callPackage
+    ({ mkDerivation, attoparsec, base, hspec, QuickCheck, smallcheck
+     , text, text-icu
+     }:
+     mkDerivation {
+       pname = "text-regex-replace";
+       version = "0.1.1.4";
+       sha256 = "19n7zwnrm4da8ifhwlqwrx969pni0njj5f69j30gp71fi9ihjgsb";
+       libraryHaskellDepends = [ attoparsec base text text-icu ];
+       testHaskellDepends = [
+         base hspec QuickCheck smallcheck text text-icu
+       ];
+       description = "Easy replacement when using text-icu regexes";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-region" = callPackage
     ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
      , groups, hspec, lens, text
···
        pname = "th-utilities";
        version = "0.2.4.2";
        sha256 = "09rbs878gjhyg8n789p2c67lzxr4h1pg0zar47a7j8sg6ff5wcx2";
+       revision = "1";
+       editedCabalFile = "177hbrwcyalm6gbqq96b5xz974bxzch9g2mvffvksi1205z6v7dr";
        libraryHaskellDepends = [
          base bytestring containers directory filepath primitive syb
          template-haskell text th-abstraction th-orphans
···
        license = lib.licenses.mit;
      }) {};
 
+  "th-utilities_0_2_4_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , hspec, primitive, syb, template-haskell, text, th-abstraction
+     , th-orphans, vector
+     }:
+     mkDerivation {
+       pname = "th-utilities";
+       version = "0.2.4.3";
+       sha256 = "1krvn3xp7zicp6wqcgmgbgl2a894n677vxi6vhcna16cx03smic9";
+       libraryHaskellDepends = [
+         base bytestring containers directory filepath primitive syb
+         template-haskell text th-abstraction th-orphans
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath hspec primitive syb
+         template-haskell text th-abstraction th-orphans vector
+       ];
+       description = "Collection of useful functions for use with Template Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "thank-you-stars" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , directory, filepath, hackage-db, hspec, req, split, text
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "tidal_1_7_3" = callPackage
+    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
+     , containers, criterion, deepseq, hosc, microspec, network, parsec
+     , primitive, random, text, transformers, weigh
+     }:
+     mkDerivation {
+       pname = "tidal";
+       version = "1.7.3";
+       sha256 = "0z0brlicisn7xpwag20vdrq6ympczxcyd886pm6am5phmifkmfif";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bifunctors bytestring clock colour containers deepseq hosc
+         network parsec primitive random text transformers
+       ];
+       testHaskellDepends = [
+         base containers deepseq hosc microspec parsec
+       ];
+       benchmarkHaskellDepends = [ base criterion weigh ];
+       description = "Pattern language for improvised music";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tidal-midi" = callPackage
     ({ mkDerivation, base, containers, PortMidi, tidal, time
      , transformers
···
        pname = "trackit";
        version = "0.7.2";
        sha256 = "1ha28wdc4dabr9qxkbpg9fasfnplicb2pyrn9zmija204nigbcdj";
+       revision = "1";
+       editedCabalFile = "0l9hi5f90nixayzahksgxrs4zij76767x64irql890ph6qzsq13c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "vector-binary-instances_0_2_5_2" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, tasty
+     , tasty-bench, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "vector-binary-instances";
+       version = "0.2.5.2";
+       sha256 = "0kgmlb4rf89b18d348cf2k06xfhdpamhmvq7iz5pab5014hknbmp";
+       libraryHaskellDepends = [ base binary vector ];
+       testHaskellDepends = [ base binary tasty tasty-quickcheck vector ];
+       benchmarkHaskellDepends = [
+         base binary bytestring deepseq tasty-bench vector
+       ];
+       description = "Instances of Data.Binary for vector";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "vector-buffer" = callPackage
     ({ mkDerivation, base, deepseq, vector }:
      mkDerivation {
···
        ];
        description = "Types and parsers for software version numbers";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "versions_5_0_0" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens
+     , parser-combinators, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "versions";
+       version = "5.0.0";
+       sha256 = "1rfxjivdsaqc6w7dfqdycy3a81rsajvpfyi5si9ssc0w3ljfsbzr";
+       libraryHaskellDepends = [
+         base deepseq hashable megaparsec parser-combinators text
+       ];
+       testHaskellDepends = [
+         base megaparsec microlens QuickCheck tasty tasty-hunit
+         tasty-quickcheck text
+       ];
+       description = "Types and parsers for software version numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vflow-types" = callPackage
···
        broken = true;
      }) {inherit (pkgs) fcgi;};
 
+  "wai-handler-hal" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring
+     , case-insensitive, hal, http-types, network, text
+     , unordered-containers, vault, wai
+     }:
+     mkDerivation {
+       pname = "wai-handler-hal";
+       version = "0.1.0.0";
+       sha256 = "0sjw01k5dyhdi33ld1pd4mf9plpij0spzxf2b228cjyc8x5zx7rj";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring case-insensitive hal http-types
+         network text unordered-containers vault wai
+       ];
+       description = "Wrap WAI applications to run on AWS Lambda";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "wai-handler-launch" = callPackage
     ({ mkDerivation, async, base, bytestring, http-types, process
      , streaming-commons, transformers, wai, warp
···
        broken = true;
      }) {};
 
+  "wai-session-redis" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, data-default, hedis
+     , hspec, http-types, vault, wai, wai-session, warp
+     }:
+     mkDerivation {
+       pname = "wai-session-redis";
+       version = "0.1.0.0";
+       sha256 = "12l2r85xq8ryv6y660c20yfxa19n3rvkilmkb74bj1ch7jmm8d6n";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring cereal data-default hedis vault wai wai-session
+       ];
+       executableHaskellDepends = [
+         base bytestring cereal data-default hedis http-types vault wai
+         wai-session warp
+       ];
+       testHaskellDepends = [
+         base bytestring cereal data-default hedis hspec vault wai
+         wai-session
+       ];
+       description = "Simple Redis backed wai-session backend";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "wai-session-tokyocabinet" = callPackage
     ({ mkDerivation, base, bytestring, cereal, errors
      , tokyocabinet-haskell, transformers, wai-session
···
        ];
        description = "A fast, light-weight web server for WAI applications";
        license = lib.licenses.mit;
+     }) {};
+
+  "warp_3_3_15" = callPackage
+    ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked
+     , bytestring, case-insensitive, containers, directory, gauge
+     , ghc-prim, hashable, hspec, http-client, http-date, http-types
+     , http2, HUnit, iproute, lifted-base, network, process, QuickCheck
+     , simple-sendfile, stm, streaming-commons, text, time, time-manager
+     , unix, unix-compat, vault, wai, word8, x509
+     }:
+     mkDerivation {
+       pname = "warp";
+       version = "3.3.15";
+       sha256 = "0nj4xxzjcy33hyfdagpc2ij6ga71r1fmc248rjgwsyfflial63bz";
+       libraryHaskellDepends = [
+         array async auto-update base bsb-http-chunked bytestring
+         case-insensitive containers ghc-prim hashable http-date http-types
+         http2 iproute network simple-sendfile stm streaming-commons text
+         time-manager unix unix-compat vault wai word8 x509
+       ];
+       testHaskellDepends = [
+         array async auto-update base bsb-http-chunked bytestring
+         case-insensitive containers directory ghc-prim hashable hspec
+         http-client http-date http-types http2 HUnit iproute lifted-base
+         network process QuickCheck simple-sendfile stm streaming-commons
+         text time time-manager unix unix-compat vault wai word8 x509
+       ];
+       benchmarkHaskellDepends = [
+         auto-update base bytestring containers gauge hashable http-date
+         http-types network time-manager unix unix-compat x509
+       ];
+       description = "A fast, light-weight web server for WAI applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "warp-dynamic" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "xml-conduit_1_9_1_1" = callPackage
+    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
+     , bytestring, Cabal, cabal-doctest, conduit, conduit-extra
+     , containers, data-default-class, deepseq, doctest, hspec, HUnit
+     , resourcet, text, transformers, xml-types
+     }:
+     mkDerivation {
+       pname = "xml-conduit";
+       version = "1.9.1.1";
+       sha256 = "1zzh7xnmbm68dab1vqsjkr6ghxqgnla5nik4amrwlmhbdih1gcdx";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         attoparsec base blaze-html blaze-markup bytestring conduit
+         conduit-extra containers data-default-class deepseq resourcet text
+         transformers xml-types
+       ];
+       testHaskellDepends = [
+         base blaze-markup bytestring conduit conduit-extra containers
+         doctest hspec HUnit resourcet text transformers xml-types
+       ];
+       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "xml-conduit-decode" = callPackage
     ({ mkDerivation, base, bifunctors, data-default, lens, semigroups
      , tasty, tasty-hunit, text, time, xml-conduit, xml-types
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod_1_6_1_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, conduit
+     , data-default-class, directory, fast-logger, file-embed
+     , monad-logger, shakespeare, streaming-commons, template-haskell
+     , text, unix, unordered-containers, wai, wai-extra, wai-logger
+     , warp, yaml, yesod-core, yesod-form, yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod";
+       version = "1.6.1.1";
+       sha256 = "1iiaixd1xrqjcvknl9g3yvr26nbpfa2amh2ayfxmnpjlxvdhfnyn";
+       libraryHaskellDepends = [
+         aeson base bytestring conduit data-default-class directory
+         fast-logger file-embed monad-logger shakespeare streaming-commons
+         template-haskell text unix unordered-containers wai wai-extra
+         wai-logger warp yaml yesod-core yesod-form yesod-persistent
+       ];
+       description = "Creation of type-safe, RESTful web applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yesod-alerts" = callPackage
     ({ mkDerivation, alerts, base, blaze-html, blaze-markup, safe, text
      , yesod-core
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod-auth_1_6_10_3" = callPackage
+    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
+     , base64-bytestring, binary, blaze-builder, blaze-html
+     , blaze-markup, bytestring, conduit, conduit-extra, containers
+     , cryptonite, data-default, email-validate, file-embed, http-client
+     , http-client-tls, http-conduit, http-types, memory, network-uri
+     , nonce, persistent, random, safe, shakespeare, template-haskell
+     , text, time, transformers, unliftio, unliftio-core
+     , unordered-containers, wai, yesod-core, yesod-form
+     , yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod-auth";
+       version = "1.6.10.3";
+       sha256 = "00a7gbp2czg6ixxx62k2nmrj5g1la6cjh697y8vg9xhxq7vpyshg";
+       libraryHaskellDepends = [
+         aeson authenticate base base16-bytestring base64-bytestring binary
+         blaze-builder blaze-html blaze-markup bytestring conduit
+         conduit-extra containers cryptonite data-default email-validate
+         file-embed http-client http-client-tls http-conduit http-types
+         memory network-uri nonce persistent random safe shakespeare
+         template-haskell text time transformers unliftio unliftio-core
+         unordered-containers wai yesod-core yesod-form yesod-persistent
+       ];
+       description = "Authentication for Yesod";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yesod-auth-account" = callPackage
     ({ mkDerivation, base, blaze-html, bytestring, hspec, monad-logger
      , mtl, nonce, persistent, persistent-sqlite, pwstore-fast
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod-auth-hashdb_1_7_1_6" = callPackage
+    ({ mkDerivation, aeson, base, basic-prelude, bytestring, containers
+     , hspec, http-conduit, http-types, monad-logger, network-uri
+     , persistent, persistent-sqlite, resourcet, text
+     , unordered-containers, wai-extra, yesod, yesod-auth, yesod-core
+     , yesod-form, yesod-persistent, yesod-test
+     }:
+     mkDerivation {
+       pname = "yesod-auth-hashdb";
+       version = "1.7.1.6";
+       sha256 = "062f2fv4ixr5bd5xcs208xfg2i18z25g3imf86qrziv0yxxg5qpc";
+       libraryHaskellDepends = [
+         aeson base bytestring persistent text yesod-auth yesod-core
+         yesod-form yesod-persistent
+       ];
+       testHaskellDepends = [
+         aeson base basic-prelude bytestring containers hspec http-conduit
+         http-types monad-logger network-uri persistent-sqlite resourcet
+         text unordered-containers wai-extra yesod yesod-auth yesod-core
+         yesod-test
+       ];
+       description = "Authentication plugin for Yesod";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yesod-auth-hmac-keccak" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cryptonite, mtl
      , persistent, random, shakespeare, text, yesod-auth, yesod-core
···
      }:
      mkDerivation {
        pname = "yesod-auth-oauth";
-       version = "1.6.0.2";
-       sha256 = "1rr21vclcvy4lrv6r3v6f6sslmwg49jr7jiad63snn81nz854da1";
+       version = "1.6.0.3";
+       sha256 = "0y57d5y0l0fzmk6zxrpf2xf8y00hp2i0lk3xh5sqlb77a57r109s";
        libraryHaskellDepends = [
          authenticate-oauth base bytestring text unliftio yesod-auth
          yesod-core yesod-form
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod-form_1_7_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
+     , blaze-markup, byteable, bytestring, containers, data-default
+     , email-validate, hspec, network-uri, persistent, resourcet
+     , shakespeare, text, time, transformers, wai, xss-sanitize
+     , yesod-core, yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod-form";
+       version = "1.7.0";
+       sha256 = "170gby381h5pg9njn908cyx2931yiv79x3rc5npg2rd74kif06vi";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder blaze-html blaze-markup
+         byteable bytestring containers data-default email-validate
+         network-uri persistent resourcet shakespeare text time transformers
+         wai xss-sanitize yesod-core yesod-persistent
+       ];
+       testHaskellDepends = [ base hspec text time ];
+       description = "Form handling support for Yesod Web Framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "yesod-form-bootstrap4" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, shakespeare, text
      , yesod-core, yesod-form
···
      }:
      mkDerivation {
        pname = "yesod-form-multi";
-       version = "1.7.0.1";
-       sha256 = "0dpcyq6l28zbm12rzjp18bhjaghf38jhjzj6qp40qyvb5f8yx9dp";
+       version = "1.7.0.2";
+       sha256 = "1kx27680mgplmqnfjygbcf6a2bv0i9rcxbys986aaa3x785dfj02";
        libraryHaskellDepends = [
          base containers network-uri shakespeare text transformers
          yesod-core yesod-form
···
        broken = true;
      }) {};
 
+  "yesod-markdown_0_12_6_9" = 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.9";
+       sha256 = "05s63nx27f823b47yy70p9kqxi1cvfk226zgb0qhs5a2q70nxj7z";
+       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;
+       broken = true;
+     }) {};
+
   "yesod-media-simple" = callPackage
     ({ mkDerivation, base, bytestring, diagrams-cairo, diagrams-core
      , diagrams-lib, directory, JuicyPixels, vector, yesod
···
        pname = "yesod-page-cursor";
        version = "2.0.0.5";
        sha256 = "0jz5dhmvfggbyjkcxs7v4pc4jpcd759jfv77avzwr64xx2glk1yw";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-link-header network-uri text
+         unliftio yesod-core
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec hspec-expectations-lifted
+         http-link-header http-types lens lens-aeson monad-logger mtl
+         persistent persistent-sqlite persistent-template scientific text
+         time unliftio unliftio-core wai-extra yesod yesod-core yesod-test
+       ];
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "yesod-page-cursor_2_0_0_6" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , hspec-expectations-lifted, http-link-header, http-types, lens
+     , lens-aeson, monad-logger, mtl, network-uri, persistent
+     , persistent-sqlite, persistent-template, scientific, text, time
+     , unliftio, unliftio-core, wai-extra, yesod, yesod-core, yesod-test
+     }:
+     mkDerivation {
+       pname = "yesod-page-cursor";
+       version = "2.0.0.6";
+       sha256 = "0if4pwpzpr48cz1vixk234fdl4lj3895ma9ak8x917sc3cgp2kv1";
        libraryHaskellDepends = [
          aeson base bytestring containers http-link-header network-uri text
          unliftio yesod-core
···
      }:
      mkDerivation {
        pname = "yesod-websockets";
-       version = "0.3.0.2";
-       sha256 = "1k206l84g25xml8yg4q7i62x5aydxq2hni2fk2cc36dlvl0rgih1";
-       libraryHaskellDepends = [
-         base conduit mtl transformers unliftio wai-websockets websockets
-         yesod-core
-       ];
-       description = "WebSockets support for Yesod";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-websockets_0_3_0_3" = callPackage
-    ({ mkDerivation, base, conduit, mtl, transformers, unliftio
-     , wai-websockets, websockets, yesod-core
-     }:
-     mkDerivation {
-       pname = "yesod-websockets";
        version = "0.3.0.3";
        sha256 = "0hm4qzn0kqwl7mfvhgc1h1xbpj80fnkfbh5r3k9c52n5dmcapy6n";
        libraryHaskellDepends = [
···
        ];
        description = "WebSockets support for Yesod";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-websockets-extra" = callPackage

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

···
 , buildPythonPackage
 , fetchFromGitHub
 , protobuf
-, pytestCheckHook
 }:
 
 buildPythonPackage rec {

pkgs/development/tools/electron/default.nix

···
     headers = "0yx8mkrm15ha977hzh7g2sc5fab9sdvlk1bk3yxignhxrqqbw885";
   };
 
-  electron_10 = mkElectron "10.4.2" {
-    x86_64-linux = "3d613b413f01c8af1600be42c82941761452407e1160125eca60feec0d7dd0c0";
-    x86_64-darwin = "87b18811d165f2fd64606ae13a567b737f54bd41c7e2204a047a3532f4fa2d9c";
-    i686-linux = "297083ca9b21554ea1f729ed17c0c8b13aaea24e77194f9c1b340489fcfc0fa6";
-    armv7l-linux = "3d93ec220824cce5d99b3a7511604b89c63935bd1130fc64ce08b8436e34c096";
-    aarch64-linux = "0060e37eada91bac51945ae325ab04309438609089d31ab3f8bbfda73cc26166";
-    headers = "13cpkblkvhvd3sww8n1gw4rhva84x2fkkg81yr3n2mb0virlfgpn";
+  electron_10 = mkElectron "10.4.3" {
+    x86_64-linux = "48793fc6c6d3bfb8df81cd29f6c52e68c8c6b901693c6ba4ed505799fa673e9f";
+    x86_64-darwin = "28cbacf51e0528e0d4ba30a2c56efd6a8e7f836104786733aae0c5fc99dc2615";
+    i686-linux = "b9b7fd9b91630350dafe97a31c918f941ab15b044f0b4e9b2a705482447fe78f";
+    armv7l-linux = "b1e1b4d0620eae647915c95d21656d21c00efe89f44198938d9fd9fba045e39c";
+    aarch64-linux = "aa9177becf787920cef4cde27a6ed08e2e23976678162a3cd6b77615b1582c05";
+    headers = "0phv08myxq226blrqzg3fza3mh3ivgfmcja98b7377pc3x7bv76g";
   };
 
-  electron_11 = mkElectron "11.4.1" {
-    x86_64-linux = "3efd3d3b5a9f71323320288aece65fcec89ea0331c3d6d3afc2495d3b0dc95d3";
-    x86_64-darwin = "6ff91613c51b2ebaf280eb86b826f47d62639081a0f38c2012c428a17619a163";
-    i686-linux = "513e1bc7a3e546dc0e712836886ac89c9f76bb7fb1e4b7a1f9d9cbc7347d8569";
-    armv7l-linux = "838fc96d90cfcc5e1e892287008f9d9d2dbe27f3d4cf2479e6275ecdd140fb65";
-    aarch64-linux = "a3de4208b5033a19ffa9dd8130d440909b181c0ef57cb51c8f9c8dbbb1267a26";
-    headers = "1bpsmmlxl4gk9yn5w7f8m6g8k1gmvwk0jwpqlk5islpkcy6x7107";
+  electron_11 = mkElectron "11.4.3" {
+    x86_64-linux = "222e7aa51d5516796d532f784c574f07315bad4bf29efb0ce687014f93ba5fa5";
+    x86_64-darwin = "6cccbaf8dca7eb3819b0ac3044686f6705c5d51c88ee1361d8573c2b83c8dc0a";
+    i686-linux = "1910729fd6088e9c914db9fdd6c42ce6747fcb048947dd83fa2cdf564c786353";
+    armv7l-linux = "e0e1375bdb79a6917467490683e49bb59da9260b73d7b710a5e4e4535c1c5e80";
+    aarch64-linux = "9fb287ed8bcc7782775bd615fe1c31db4a8b6d548209fd15ef5312ac72a04d07";
+    headers = "00gln9jlb621gvxx1z7s212wakjbdigdqv02vx1pjvkg62aazg8j";
   };
 
-  electron_12 = mkElectron "12.0.2" {
-    x86_64-linux = "fc3ff888d8cd4ada8368420c8951ed1b5ad78919bdcb688abe698d00e12a2e0a";
-    x86_64-darwin = "766ca8f8adc4535db3069665ea8983979ea79dd5ec376e1c298f858b420ec58f";
-    i686-linux = "78ab55db275b85210c6cc14ddf41607fbd5cefed93ef4d1b6b74630b0841b23c";
-    armv7l-linux = "8be8c6ea05da669d79179c5969ddee853710a1dd44f86e8f3bbe1167a2daf13c";
-    aarch64-linux = "9ef70ab9347be63555784cac99efbaff1ef2d02dcc79070d7bccd18c38de87ef";
-    headers = "07095b5rylilbmyd0syamm6fc4pngazldj5jgm7blgirdi8yzzd2";
+  electron_12 = mkElectron "12.0.4" {
+    x86_64-linux = "6419716f614f396954981e6432afe77277dff2b64ecb84e2bbd6d740362ea01c";
+    x86_64-darwin = "3072f1854eb5b91d5f24e03a313583bb85d696cda48381bdf3e40ee2c93dfe34";
+    i686-linux = "fa241874aacca8fe4b4f940fa9133fe65fdcf9ef0847322332f0c67ee7b42aa0";
+    armv7l-linux = "8d88d13bf117820bc3b46501d34004f18ebf402f2817836a2a7ba4fc60433653";
+    aarch64-linux = "c5cbcbb5b397407e45e682480b30da4fcf94154ac92d8f6eea4c79a50d56626a";
+    headers = "121falvhz0bfxc2h7wwvyfqdagr3aznida4f4phzqp0ja3rznxf3";
   };
 }

pkgs/development/tools/purescript/spago/default.nix

···
         maintainers = (oldAttrs.maintainers or []) ++ [
           lib.maintainers.cdepillabout
         ];
+        changelog =
+          "https://github.com/purescript/spago/releases/tag/${oldAttrs.version}";
       }));
 in
 

pkgs/games/osu-lazer/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "osu-lazer";
-  version = "2021.331.0";
+  version = "2021.410.0";
 
   src = fetchFromGitHub {
     owner = "ppy";
     repo = "osu";
     rev = version;
-    sha256 = "dCKBxVDBBhJ7LEawmMOU7PKh0yxmDgVw6PL2F0qA5RU=";
+    sha256 = "twKg9iZdY+zgwEQeHMOlRZKXxAHic7GnoqH0jOdW7fw=";
   };
 
   patches = [ ./bypass-tamper-detection.patch ];

pkgs/games/osu-lazer/deps.nix

···
   })
   (fetchNuGet {
     name = "JetBrains.Annotations";
-    version = "2020.3.0";
-    sha256 = "04xlfqnfg3069f014q8f0vx7y70m8nldbf9fia4b50bp3rry2lv2";
+    version = "2021.1.0";
+    sha256 = "07pnhxxlgx8spmwmakz37nmbvgyb6yjrbrhad5rrn6y767z5r1gb";
   })
   (fetchNuGet {
     name = "ManagedBass";
···
   })
   (fetchNuGet {
     name = "Microsoft.AspNetCore.App.Runtime.linux-x64";
-    version = "5.0.0";
-    sha256 = "14njzl0907wzcbsnxl62m4y6mv9pdirm68bj8qbbip0q5a6xgidw";
+    version = "5.0.5";
+    sha256 = "026m19pddhkx5idwpi6mp1yl9yfcfgm2qjp1jh54mdja1d7ng0vk";
   })
   (fetchNuGet {
     name = "Microsoft.AspNetCore.Connections.Abstractions";
···
   })
   (fetchNuGet {
     name = "Microsoft.Extensions.ObjectPool";
-    version = "5.0.4";
-    sha256 = "07kyqbm7f7k4bv3fa54b826b87z00385pqgjzd4s8l26j6p39rrm";
+    version = "5.0.5";
+    sha256 = "0hh0xm14hp479dsd0gb9igz0vbbn3sak27v39phpyilxvk7ky5z1";
   })
   (fetchNuGet {
     name = "Microsoft.Extensions.Options";
···
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.App.Runtime.linux-x64";
-    version = "5.0.0";
-    sha256 = "1k9yxklzdnjfkqysg54dz0mr75yg29fhlls9alh5qlfpsfpk32yq";
+    version = "5.0.5";
+    sha256 = "1h5yry6k9bpqqis2fb1901csb8kipm7anm174fjj41r317vzfjfa";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.Platforms";
···
   })
   (fetchNuGet {
     name = "ppy.osu.Framework";
-    version = "2021.330.0";
-    sha256 = "01v319nd9szq5z5qq6pa348y1mv93pnhw0vrgbrjwvcs797h7mjl";
+    version = "2021.410.0";
+    sha256 = "1vwdrspdpal44hyspv3rsax8mkszvbnc2xl1xswczx9mzj6qs4by";
   })
   (fetchNuGet {
     name = "ppy.osu.Framework.NativeLibs";
···
   })
   (fetchNuGet {
     name = "ppy.osu.Game.Resources";
-    version = "2021.211.1";
-    sha256 = "0rqv5blmyzvcpk0b1r6fzr1bla62kr2fwkr1f9ahir9zafvk2wmm";
+    version = "2021.410.0";
+    sha256 = "1a5qia4595n0b21dj63sl71ar56m9x1glqwky7a9bb0dqpvfivya";
   })
   (fetchNuGet {
     name = "ppy.osuTK.NS20";
···
   })
   (fetchNuGet {
     name = "ppy.SDL2-CS";
-    version = "1.0.82";
-    sha256 = "0hdfih1hjpqxgblwc947inyfhskkj85f061cagf8gdl69xsp2l1b";
+    version = "1.0.225-alpha";
+    sha256 = "1x8hvk9kikwi7wrvwxdxk3pkbs491iss2mvqgiw844zld5izihqc";
   })
   (fetchNuGet {
     name = "ppy.squirrel.windows";

pkgs/games/osu-lazer/update.sh

···
 
 pushd "$src"
 
-# Setup empty nuget package folder to force reinstall.
 mkdir ./nuget_tmp.packages
-cat >./nuget_tmp.config <<EOF
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <add key="nuget" value="https://api.nuget.org/v3/index.json" />
-  </packageSources>
-  <config>
-    <add key="globalPackagesFolder" value="$(realpath ./nuget_tmp.packages)" />
-  </config>
-</configuration>
-EOF
-
-dotnet restore osu.Desktop --configfile ./nuget_tmp.config --runtime linux-x64
+dotnet restore osu.Desktop --packages ./nuget_tmp.packages --runtime linux-x64
 
 echo "{ fetchNuGet }: [" >"$deps_file"
 while read pkg_spec; do

pkgs/misc/emulators/ryujinx/default.nix

···
   ];
 in stdenv.mkDerivation rec {
   pname = "ryujinx";
-  version = "1.0.6807"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
+  version = "1.0.6835"; # Versioning is based off of the official appveyor builds: https://ci.appveyor.com/project/gdkchan/ryujinx
 
   src = fetchFromGitHub {
     owner = "Ryujinx";
     repo = "Ryujinx";
-    rev = "0ee314fb3b9d476d0d207a3595bde24af9c4b69b";
-    sha256 = "1yyjy5qblsdg186hr81qpc07n0cqla67q3hjf2rrzq5pyb10bldy";
+    rev = "e520eecb5ba682d4b51bb782e3bc99fb1d6afe04";
+    sha256 = "1yy1xslnvvl0m7g0jszj2pjwdwf0pbv53crzfkhla3n68kvfy00f";
   };
 
   nativeBuildInputs = [ dotnet-sdk_5 dotnetPackages.Nuget cacert makeWrapper wrapGAppsHook gobject-introspection gdk-pixbuf ];

pkgs/misc/emulators/ryujinx/deps.nix

···
     sha256 = "1j8i5izk97ga30z1qpd765zqd2q5w71y8bhnkqq4bj59768fyxp5";
   })
   (fetchNuGet {
-    name = "GLWidget";
-    version = "1.0.2";
-    sha256 = "0nb46jiscnsywwdfy7zhx1bw4jfmca3s6l8dhbi99gc4bvp8ar7p";
+    name = "GtkSharp";
+    version = "3.22.25.128";
+    sha256 = "0z0wx0p3gc02r8d7y88k1rw307sb2vapbr1k1yc5qdc38fxz5jsy";
   })
   (fetchNuGet {
     name = "GtkSharp.Dependencies";
···
     sha256 = "1g1rhcn38ww97638rds6l5bysra43hkhv47fy71fvq89623zgyxn";
   })
   (fetchNuGet {
-    name = "GtkSharp";
-    version = "3.22.25.128";
-    sha256 = "0z0wx0p3gc02r8d7y88k1rw307sb2vapbr1k1yc5qdc38fxz5jsy";
-  })
-  (fetchNuGet {
     name = "LibHac";
     version = "0.12.0";
     sha256 = "08r9b9cdcbz6339sw8r5dfy2a8iw53df0j3xq9rygkg02xspimld";
   })
   (fetchNuGet {
     name = "Microsoft.AspNetCore.App.Runtime.linux-x64";
-    version = "5.0.0";
-    sha256 = "14njzl0907wzcbsnxl62m4y6mv9pdirm68bj8qbbip0q5a6xgidw";
+    version = "5.0.5";
+    sha256 = "026m19pddhkx5idwpi6mp1yl9yfcfgm2qjp1jh54mdja1d7ng0vk";
   })
   (fetchNuGet {
     name = "Microsoft.AspNetCore.App.Runtime.osx-x64";
-    version = "5.0.0";
-    sha256 = "1mmklq1fwq4km9y9jgk63wmwjlarx4npkpvjaiwdzv83vdv104ja";
+    version = "5.0.5";
+    sha256 = "09nsi9fa8kb3jpnim0hdap3jabskvpr4fmpvnj5wsh3gp91vqvgb";
   })
   (fetchNuGet {
     name = "Microsoft.AspNetCore.App.Runtime.win-x64";
-    version = "5.0.0";
-    sha256 = "0k7q89w3nky4m0j5jsk95c8gczlyp5jl9982gf1hli3gqpl2q4jr";
+    version = "5.0.5";
+    sha256 = "10g2vdsz685agqbd7h7dd9gvs584prpai0zv37r59wzlynj1assl";
   })
   (fetchNuGet {
     name = "Microsoft.CodeCoverage";
···
     sha256 = "0mp8ihqlb7fsa789frjzidrfjc1lrhk88qp3xm5qvr7vf4wy4z8x";
   })
   (fetchNuGet {
-    name = "Microsoft.NET.Test.Sdk";
-    version = "16.8.0";
-    sha256 = "1ln2mva7j2mpsj9rdhpk8vhm3pgd8wn563xqdcwd38avnhp74rm9";
-  })
-  (fetchNuGet {
     name = "Microsoft.NETCore.App.Host.osx-x64";
-    version = "5.0.0";
-    sha256 = "1nirb155gzn2ws1ayaqspjmjaizw87jq2684mzkn18jv4si0hbpf";
+    version = "5.0.5";
+    sha256 = "14d6wz593dwm2j3apd3ny10idk8bfxqgfrparhc1q7q4i66y21ws";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.App.Host.win-x64";
-    version = "5.0.0";
-    sha256 = "0nghghcapc28ixg21wb30ccjirc9wz83h0y3bn5zyfanxv2m2ypx";
+    version = "5.0.5";
+    sha256 = "1233y31z46yqzjgwpa6mmb1h63iqp6wbly6mbwkjqm2adx1wkp47";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.App.Runtime.linux-x64";
-    version = "5.0.0";
-    sha256 = "1k9yxklzdnjfkqysg54dz0mr75yg29fhlls9alh5qlfpsfpk32yq";
+    version = "5.0.5";
+    sha256 = "1h5yry6k9bpqqis2fb1901csb8kipm7anm174fjj41r317vzfjfa";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.App.Runtime.osx-x64";
-    version = "5.0.0";
-    sha256 = "0lvpf4zz617y94zz3zsmzrg6zcdd6z3z9gz2bd5kq1l8y1pmq77y";
+    version = "5.0.5";
+    sha256 = "1a1ijdk61l0h25sj9ypcf96vz1c08ca7q5809g82qpi9m34kw8b8";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.App.Runtime.win-x64";
-    version = "5.0.0";
-    sha256 = "1486654z369857h45v73jz8pwr8ibb97fiw5mfm7f01kdbyjdsdd";
+    version = "5.0.5";
+    sha256 = "1gc4msk61jgj9ill4icp0mn523g411iqpxphp0fykfvqdpqyqg46";
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.Platforms";
···
   })
   (fetchNuGet {
     name = "Microsoft.NETCore.Platforms";
-    version = "3.1.0";
-    sha256 = "1gc1x8f95wk8yhgznkwsg80adk1lc65v9n5rx4yaa4bc5dva0z3j";
-  })
-  (fetchNuGet {
-    name = "Microsoft.NETCore.Platforms";
     version = "5.0.0";
     sha256 = "0mwpwdflidzgzfx2dlpkvvnkgkr2ayaf0s80737h4wa35gaj11rc";
   })
···
     name = "Microsoft.NETCore.Targets";
     version = "1.1.0";
     sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh";
+  })
+  (fetchNuGet {
+    name = "Microsoft.NET.Test.Sdk";
+    version = "16.8.0";
+    sha256 = "1ln2mva7j2mpsj9rdhpk8vhm3pgd8wn563xqdcwd38avnhp74rm9";
   })
   (fetchNuGet {
     name = "Microsoft.TestPlatform.ObjectModel";
···
     name = "Microsoft.Win32.Registry";
     version = "4.5.0";
     sha256 = "1zapbz161ji8h82xiajgriq6zgzmb1f3ar517p2h63plhsq5gh2q";
-  })
-  (fetchNuGet {
-    name = "Microsoft.Win32.Registry";
-    version = "4.7.0";
-    sha256 = "0bx21jjbs7l5ydyw4p6cn07chryxpmchq2nl5pirzz4l3b0q4dgs";
   })
   (fetchNuGet {
     name = "Microsoft.Win32.Registry";
···
   })
   (fetchNuGet {
     name = "Microsoft.Win32.SystemEvents";
-    version = "4.5.0";
-    sha256 = "0fnkv3ky12227zqg4zshx4kw2mvysq2ppxjibfw02cc3iprv4njq";
-  })
-  (fetchNuGet {
-    name = "Microsoft.Win32.SystemEvents";
     version = "5.0.0";
     sha256 = "0sja4ba0mrvdamn0r9mhq38b9dxi08yb3c1hzh29n1z6ws1hlrcq";
   })
···
     sha256 = "0kxc6z3b8ccdrcyqz88jm5yh5ch9nbg303v67q8sp5hhs8rl8nk6";
   })
   (fetchNuGet {
-    name = "OpenTK.NetStandard";
-    version = "1.0.5.32";
-    sha256 = "12y8kg73llmq3zibcp6j3hhiw04g7mqlm1nslmb74gfkzx0b4m9f";
+    name = "OpenTK.Core";
+    version = "4.5.0";
+    sha256 = "06qxczikp0aah20d4skk3g588dgh2vn2xffn0ajyyv0475m61s9m";
+  })
+  (fetchNuGet {
+    name = "OpenTK.Graphics";
+    version = "4.5.0";
+    sha256 = "180g5c92fhhhpmwl6paihx4h1bil7akaihlz2qy124n28pf4s988";
+  })
+  (fetchNuGet {
+    name = "OpenTK.Mathematics";
+    version = "4.5.0";
+    sha256 = "1h9dxhq1llxdbgdzsi87ijqgj2ilr3rv0zkxhaa65xrc5x8j8fva";
+  })
+  (fetchNuGet {
+    name = "OpenTK.OpenAL";
+    version = "4.5.0";
+    sha256 = "0lqxpc3vnxglql42x2frvq5bpkl5cf3dpnf9nx6pr3q6qnhigkfb";
   })
   (fetchNuGet {
     name = "PangoSharp";
     version = "3.22.25.128";
     sha256 = "0dkl9j0yd65s5ds9xj5z6yb7yca7wlycqz25m8dng20d13sqr1zp";
+  })
+  (fetchNuGet {
+    name = "ppy.SDL2-CS";
+    version = "1.0.225-alpha";
+    sha256 = "1x8hvk9kikwi7wrvwxdxk3pkbs491iss2mvqgiw844zld5izihqc";
   })
   (fetchNuGet {
     name = "runtime.any.System.Collections";
···
     sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Globalization.Calendars";
+    name = "runtime.any.System.Globalization";
     version = "4.3.0";
-    sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201";
+    sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Globalization";
+    name = "runtime.any.System.Globalization.Calendars";
     version = "4.3.0";
-    sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x";
+    sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201";
   })
   (fetchNuGet {
     name = "runtime.any.System.IO";
···
     sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x";
   })
   (fetchNuGet {
+    name = "runtime.any.System.Reflection";
+    version = "4.3.0";
+    sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly";
+  })
+  (fetchNuGet {
     name = "runtime.any.System.Reflection.Extensions";
     version = "4.3.0";
     sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33";
···
     sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Reflection";
+    name = "runtime.any.System.Resources.ResourceManager";
     version = "4.3.0";
-    sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly";
+    sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Resources.ResourceManager";
+    name = "runtime.any.System.Runtime";
     version = "4.3.0";
-    sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl";
+    sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b";
   })
   (fetchNuGet {
     name = "runtime.any.System.Runtime.Handles";
···
     sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19";
   })
   (fetchNuGet {
-    name = "runtime.any.System.Runtime";
+    name = "runtime.any.System.Text.Encoding";
     version = "4.3.0";
-    sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b";
+    sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3";
   })
   (fetchNuGet {
     name = "runtime.any.System.Text.Encoding.Extensions";
     version = "4.3.0";
     sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8";
-  })
-  (fetchNuGet {
-    name = "runtime.any.System.Text.Encoding";
-    version = "4.3.0";
-    sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3";
   })
   (fetchNuGet {
     name = "runtime.any.System.Threading.Tasks";
···
     sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa";
   })
   (fetchNuGet {
+    name = "runtime.native.System";
+    version = "4.0.0";
+    sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf";
+  })
+  (fetchNuGet {
+    name = "runtime.native.System";
+    version = "4.3.0";
+    sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4";
+  })
+  (fetchNuGet {
     name = "runtime.native.System.IO.Compression";
     version = "4.1.0";
     sha256 = "0d720z4lzyfcabmmnvh0bnj76ll7djhji2hmfh3h44sdkjnlkknk";
···
     sha256 = "1hgv2bmbaskx77v8glh7waxws973jn4ah35zysnkxmf0196sfxg6";
   })
   (fetchNuGet {
-    name = "runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97";
-  })
-  (fetchNuGet {
     name = "runtime.native.System.Security.Cryptography";
     version = "4.0.0";
     sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9";
   })
   (fetchNuGet {
-    name = "runtime.native.System";
-    version = "4.0.0";
-    sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf";
-  })
-  (fetchNuGet {
-    name = "runtime.native.System";
+    name = "runtime.native.System.Security.Cryptography.OpenSsl";
     version = "4.3.0";
-    sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4";
+    sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97";
   })
   (fetchNuGet {
     name = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl";
···
     sha256 = "0r0aw8xxd32rwcawawcz6asiyggz02hnzg5hvz8gimq8hvwx1wql";
   })
   (fetchNuGet {
+    name = "SixLabors.ImageSharp";
+    version = "1.0.2";
+    sha256 = "0fhk9sn8k18slfb26wz8mal0j699f7djwhxgv97snz6b10wynfaj";
+  })
+  (fetchNuGet {
     name = "SixLabors.ImageSharp.Drawing";
     version = "1.0.0-beta11";
     sha256 = "0hl0rs3kr1zdnx3gdssxgli6fyvmwzcfp99f4db71s0i8j8b2bp5";
   })
   (fetchNuGet {
-    name = "SixLabors.ImageSharp";
-    version = "1.0.2";
-    sha256 = "0fhk9sn8k18slfb26wz8mal0j699f7djwhxgv97snz6b10wynfaj";
+    name = "SPB";
+    version = "0.0.2";
+    sha256 = "178z9mi7zlk0laj79nkjh75ych47jjajiaj33hnh7zfmz05d8h6r";
   })
   (fetchNuGet {
     name = "System.AppContext";
···
     sha256 = "14zs2wqkmdlxzj8ikx19n321lsbarx5vl2a8wrachymxn8zb5njh";
   })
   (fetchNuGet {
+    name = "System.Collections";
+    version = "4.0.11";
+    sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6";
+  })
+  (fetchNuGet {
+    name = "System.Collections";
+    version = "4.3.0";
+    sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9";
+  })
+  (fetchNuGet {
     name = "System.Collections.Concurrent";
     version = "4.0.12";
     sha256 = "07y08kvrzpak873pmyxs129g1ch8l27zmg51pcyj2jvq03n0r0fc";
···
     sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20";
   })
   (fetchNuGet {
-    name = "System.Collections";
-    version = "4.0.11";
-    sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6";
-  })
-  (fetchNuGet {
-    name = "System.Collections";
+    name = "System.ComponentModel";
     version = "4.3.0";
-    sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9";
+    sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb";
   })
   (fetchNuGet {
     name = "System.ComponentModel.EventBasedAsync";
···
     name = "System.ComponentModel.TypeConverter";
     version = "4.3.0";
     sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x";
-  })
-  (fetchNuGet {
-    name = "System.ComponentModel";
-    version = "4.3.0";
-    sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb";
   })
   (fetchNuGet {
     name = "System.Console";
···
     name = "System.Diagnostics.Tracing";
     version = "4.3.0";
     sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4";
-  })
-  (fetchNuGet {
-    name = "System.Drawing.Common";
-    version = "4.5.0";
-    sha256 = "0knqa0zsm91nfr34br8gx5kjqq4v81zdhqkacvs2hzc8nqk0ddhc";
   })
   (fetchNuGet {
     name = "System.Drawing.Common";
···
     sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9";
   })
   (fetchNuGet {
+    name = "System.Globalization";
+    version = "4.0.11";
+    sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d";
+  })
+  (fetchNuGet {
+    name = "System.Globalization";
+    version = "4.3.0";
+    sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki";
+  })
+  (fetchNuGet {
     name = "System.Globalization.Calendars";
     version = "4.0.1";
     sha256 = "0bv0alrm2ck2zk3rz25lfyk9h42f3ywq77mx1syl6vvyncnpg4qh";
···
     sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls";
   })
   (fetchNuGet {
-    name = "System.Globalization";
-    version = "4.0.11";
-    sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d";
+    name = "System.IO";
+    version = "4.1.0";
+    sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp";
   })
   (fetchNuGet {
-    name = "System.Globalization";
+    name = "System.IO";
     version = "4.3.0";
-    sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki";
-  })
-  (fetchNuGet {
-    name = "System.IO.Compression.ZipFile";
-    version = "4.0.1";
-    sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82";
+    sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f";
   })
   (fetchNuGet {
     name = "System.IO.Compression";
···
     sha256 = "0iym7s3jkl8n0vzm3jd6xqg9zjjjqni05x45dwxyjr2dy88hlgji";
   })
   (fetchNuGet {
-    name = "System.IO.FileSystem.Primitives";
+    name = "System.IO.Compression.ZipFile";
     version = "4.0.1";
-    sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612";
-  })
-  (fetchNuGet {
-    name = "System.IO.FileSystem.Primitives";
-    version = "4.3.0";
-    sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c";
+    sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82";
   })
   (fetchNuGet {
     name = "System.IO.FileSystem";
···
     sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw";
   })
   (fetchNuGet {
-    name = "System.IO";
-    version = "4.1.0";
-    sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp";
+    name = "System.IO.FileSystem.Primitives";
+    version = "4.0.1";
+    sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612";
   })
   (fetchNuGet {
-    name = "System.IO";
+    name = "System.IO.FileSystem.Primitives";
     version = "4.3.0";
-    sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f";
-  })
-  (fetchNuGet {
-    name = "System.Linq.Expressions";
-    version = "4.1.0";
-    sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg";
+    sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c";
   })
   (fetchNuGet {
     name = "System.Linq";
···
     name = "System.Linq";
     version = "4.3.0";
     sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7";
+  })
+  (fetchNuGet {
+    name = "System.Linq.Expressions";
+    version = "4.1.0";
+    sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg";
   })
   (fetchNuGet {
     name = "System.Management";
···
     sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx";
   })
   (fetchNuGet {
+    name = "System.Reflection";
+    version = "4.1.0";
+    sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9";
+  })
+  (fetchNuGet {
+    name = "System.Reflection";
+    version = "4.3.0";
+    sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m";
+  })
+  (fetchNuGet {
+    name = "System.Reflection.Emit";
+    version = "4.0.1";
+    sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp";
+  })
+  (fetchNuGet {
+    name = "System.Reflection.Emit";
+    version = "4.3.0";
+    sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74";
+  })
+  (fetchNuGet {
     name = "System.Reflection.Emit.ILGeneration";
     version = "4.0.1";
     sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0";
···
     name = "System.Reflection.Emit.Lightweight";
     version = "4.3.0";
     sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c";
-  })
-  (fetchNuGet {
-    name = "System.Reflection.Emit";
-    version = "4.0.1";
-    sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp";
-  })
-  (fetchNuGet {
-    name = "System.Reflection.Emit";
-    version = "4.3.0";
-    sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74";
   })
   (fetchNuGet {
     name = "System.Reflection.Extensions";
···
     sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1";
   })
   (fetchNuGet {
-    name = "System.Reflection";
-    version = "4.1.0";
-    sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9";
+    name = "System.Resources.ResourceManager";
+    version = "4.0.1";
+    sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi";
   })
   (fetchNuGet {
-    name = "System.Reflection";
+    name = "System.Resources.ResourceManager";
     version = "4.3.0";
-    sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m";
+    sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49";
   })
   (fetchNuGet {
-    name = "System.Resources.ResourceManager";
-    version = "4.0.1";
-    sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi";
+    name = "System.Runtime";
+    version = "4.1.0";
+    sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m";
   })
   (fetchNuGet {
-    name = "System.Resources.ResourceManager";
+    name = "System.Runtime";
     version = "4.3.0";
-    sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49";
+    sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7";
   })
   (fetchNuGet {
     name = "System.Runtime.CompilerServices.Unsafe";
···
     sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8";
   })
   (fetchNuGet {
-    name = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.0.0";
-    sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6";
-  })
-  (fetchNuGet {
-    name = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.3.0";
-    sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii";
-  })
-  (fetchNuGet {
     name = "System.Runtime.InteropServices";
     version = "4.1.0";
     sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1";
···
     sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j";
   })
   (fetchNuGet {
+    name = "System.Runtime.InteropServices.RuntimeInformation";
+    version = "4.0.0";
+    sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6";
+  })
+  (fetchNuGet {
+    name = "System.Runtime.InteropServices.RuntimeInformation";
+    version = "4.3.0";
+    sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii";
+  })
+  (fetchNuGet {
     name = "System.Runtime.Numerics";
     version = "4.0.1";
     sha256 = "1y308zfvy0l5nrn46mqqr4wb4z1xk758pkk8svbz8b5ij7jnv4nn";
···
     sha256 = "042rfjixknlr6r10vx2pgf56yming8lkjikamg3g4v29ikk78h7k";
   })
   (fetchNuGet {
-    name = "System.Runtime";
-    version = "4.1.0";
-    sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m";
-  })
-  (fetchNuGet {
-    name = "System.Runtime";
-    version = "4.3.0";
-    sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7";
-  })
-  (fetchNuGet {
     name = "System.Security.AccessControl";
     version = "4.5.0";
     sha256 = "1wvwanz33fzzbnd2jalar0p0z3x0ba53vzx1kazlskp7pwyhlnq0";
   })
   (fetchNuGet {
     name = "System.Security.AccessControl";
-    version = "4.7.0";
-    sha256 = "0n0k0w44flkd8j0xw7g3g3vhw7dijfm51f75xkm1qxnbh4y45mpz";
-  })
-  (fetchNuGet {
-    name = "System.Security.AccessControl";
     version = "5.0.0";
     sha256 = "17n3lrrl6vahkqmhlpn3w20afgz09n7i6rv0r3qypngwi7wqdr5r";
   })
···
     sha256 = "0clg1bv55mfv5dq00m19cp634zx6inm31kf8ppbq1jgyjf2185dh";
   })
   (fetchNuGet {
+    name = "System.Security.Principal";
+    version = "4.3.0";
+    sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf";
+  })
+  (fetchNuGet {
     name = "System.Security.Principal.Windows";
     version = "4.3.0";
     sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr";
···
   })
   (fetchNuGet {
     name = "System.Security.Principal.Windows";
-    version = "4.7.0";
-    sha256 = "1a56ls5a9sr3ya0nr086sdpa9qv0abv31dd6fp27maqa9zclqq5d";
+    version = "5.0.0";
+    sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8";
   })
   (fetchNuGet {
-    name = "System.Security.Principal.Windows";
-    version = "5.0.0";
-    sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8";
+    name = "System.Text.Encoding";
+    version = "4.0.11";
+    sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw";
   })
   (fetchNuGet {
-    name = "System.Security.Principal";
+    name = "System.Text.Encoding";
     version = "4.3.0";
-    sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf";
+    sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr";
   })
   (fetchNuGet {
     name = "System.Text.Encoding.Extensions";
···
     sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy";
   })
   (fetchNuGet {
-    name = "System.Text.Encoding";
-    version = "4.0.11";
-    sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw";
-  })
-  (fetchNuGet {
-    name = "System.Text.Encoding";
-    version = "4.3.0";
-    sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr";
-  })
-  (fetchNuGet {
     name = "System.Text.RegularExpressions";
     version = "4.1.0";
     sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7";
···
     sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l";
   })
   (fetchNuGet {
-    name = "System.Threading.Overlapped";
-    version = "4.3.0";
-    sha256 = "1nahikhqh9nk756dh8p011j36rlcp1bzz3vwi2b4m1l2s3vz8idm";
+    name = "System.Threading";
+    version = "4.0.11";
+    sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls";
   })
   (fetchNuGet {
-    name = "System.Threading.Tasks.Extensions";
-    version = "4.0.0";
-    sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr";
+    name = "System.Threading";
+    version = "4.3.0";
+    sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34";
   })
   (fetchNuGet {
-    name = "System.Threading.Tasks.Extensions";
+    name = "System.Threading.Overlapped";
     version = "4.3.0";
-    sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z";
+    sha256 = "1nahikhqh9nk756dh8p011j36rlcp1bzz3vwi2b4m1l2s3vz8idm";
   })
   (fetchNuGet {
     name = "System.Threading.Tasks";
···
     sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7";
   })
   (fetchNuGet {
+    name = "System.Threading.Tasks.Extensions";
+    version = "4.0.0";
+    sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr";
+  })
+  (fetchNuGet {
+    name = "System.Threading.Tasks.Extensions";
+    version = "4.3.0";
+    sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z";
+  })
+  (fetchNuGet {
     name = "System.Threading.Thread";
     version = "4.3.0";
     sha256 = "0y2xiwdfcph7znm2ysxanrhbqqss6a3shi1z3c779pj2s523mjx4";
···
     sha256 = "15n54f1f8nn3mjcjrlzdg6q3520571y012mx7v991x2fvp73lmg6";
   })
   (fetchNuGet {
-    name = "System.Threading";
-    version = "4.0.11";
-    sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls";
-  })
-  (fetchNuGet {
-    name = "System.Threading";
-    version = "4.3.0";
-    sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34";
-  })
-  (fetchNuGet {
     name = "System.Xml.ReaderWriter";
     version = "4.0.11";
     sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5";
···
     sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi";
   })
   (fetchNuGet {
-    name = "System.Xml.XPath.XmlDocument";
+    name = "System.Xml.XPath";
     version = "4.3.0";
-    sha256 = "1h9lh7qkp0lff33z847sdfjj8yaz98ylbnkbxlnsbflhj9xyfqrm";
+    sha256 = "1cv2m0p70774a0sd1zxc8fm8jk3i5zk2bla3riqvi8gsm0r4kpci";
   })
   (fetchNuGet {
-    name = "System.Xml.XPath";
+    name = "System.Xml.XPath.XmlDocument";
     version = "4.3.0";
-    sha256 = "1cv2m0p70774a0sd1zxc8fm8jk3i5zk2bla3riqvi8gsm0r4kpci";
+    sha256 = "1h9lh7qkp0lff33z847sdfjj8yaz98ylbnkbxlnsbflhj9xyfqrm";
   })
 ]

pkgs/servers/gemini/agate/default.nix

···
     sha256 = "sha256-+X1ibnYAUB34u8+oNBSkjLtsArxlrg0Nq5zJrXi7Rfk=";
   };
 
-  cargoSha256 = "sha256-ZVu7wQFe+FHWX2wevVYct1dQSE9rFET8bkmv85wNV8A=";
+  cargoSha256 = "sha256-EOxklOiazxhhIIv6c+N4uuItY/oFMAG0r/ATZ3Anlko=";
 
   buildInputs = lib.optionals stdenv.isDarwin [ Security ];
 

pkgs/servers/home-assistant/component-packages.nix

···
 # Do not edit!
 
 {
-  version = "2021.4.4";
+  version = "2021.4.5";
   components = {
     "abode" = ps: with ps; [ abodepy ];
     "accuweather" = ps: with ps; [ accuweather ];

pkgs/servers/home-assistant/default.nix

···
   extraBuildInputs = extraPackages py.pkgs;
 
   # Don't forget to run parse-requirements.py after updating
-  hassVersion = "2021.4.4";
+  hassVersion = "2021.4.5";
 
 in with py.pkgs; buildPythonApplication rec {
   pname = "homeassistant";
···
     owner = "home-assistant";
     repo = "core";
     rev = version;
-    sha256 = "1p36ymjhirl32ax3xxdg9ia089jw1klww5imq18r6ksajafr78ys";
+    sha256 = "106d1n9z8pfcnqm594vkhczrrrjap801w6fdr0psv5vhdxrqh4sj";
   };
 
   # leave this in, so users don't have to constantly update their downstream patch handling

pkgs/servers/sql/postgresql/default.nix

···
 
 in self: {
 
-  postgresql_9_5 = self.callPackage generic {
-    version = "9.5.25";
-    psqlSchema = "9.5";
-    sha256 = "00yny0sskxrqk4ji2phgv3iqxd1aiy6rh660k73s4s1pn9gcaa3n";
-    this = self.postgresql_9_5;
-    thisAttr = "postgresql_9_5";
-    inherit self;
-  };
-
   postgresql_9_6 = self.callPackage generic {
     version = "9.6.21";
     psqlSchema = "9.6";

pkgs/tools/graphics/agi/default.nix

···
+{ lib
+, stdenv
+, fetchzip
+, autoPatchelfHook
+, makeWrapper
+, makeDesktopItem
+, copyDesktopItems
+, wrapGAppsHook
+, gobject-introspection
+, gdk-pixbuf
+, jre
+, androidenv
+}:
+
+stdenv.mkDerivation rec {
+  pname = "agi";
+  version = "1.1.0-dev-20210413";
+
+  src = fetchzip {
+    url = "https://github.com/google/agi-dev-releases/releases/download/v${version}/agi-${version}-linux.zip";
+    sha256 = "13i6n95d0cjrhx68qsich6xzk5f9ga0y3m19k4z2d58s164rnh0v";
+  };
+
+  nativeBuildInputs = [
+    autoPatchelfHook
+    makeWrapper
+    wrapGAppsHook
+    gdk-pixbuf
+    gobject-introspection
+    copyDesktopItems
+  ];
+
+  buildInputs = [
+    stdenv.cc.cc.lib
+  ];
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out/{bin,lib}
+    cp ./{agi,gapis,gapir,gapit,device-info} $out/bin
+    cp lib/gapic.jar $out/lib
+    wrapProgram $out/bin/agi \
+      --add-flags "--vm ${jre}/bin/java" \
+      --add-flags "--jar $out/lib/gapic.jar" \
+      --add-flags "--adb ${androidenv.androidPkgs_9_0.platform-tools}/bin/adb"
+    for i in 16 32 48 64 96 128 256 512 1024; do
+      install -D ${src}/icon.png $out/share/icons/hicolor/''${i}x$i/apps/agi.png
+    done
+    runHook postInstall
+  '';
+
+  desktopItems = [(makeDesktopItem {
+    name = "agi";
+    desktopName = "Android GPU Inspector";
+    exec = "$out/bin/agi";
+    icon = "agi";
+    type = "Application";
+    categories = "Development;Debugger;Graphics;3DGraphics";
+    terminal = "false";
+  })];
+
+  meta = with lib; {
+    homepage = "https://github.com/google/agi/";
+    description = "Android GPU Inspector";
+    license = licenses.asl20;
+    platforms = [ "x86_64-linux" ];
+    maintainers = [ maintainers.ivar ];
+  };
+}

pkgs/tools/misc/tremor-rs/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "tremor";
-  version = "0.10.1";
+  version = "0.11.0";
 
   src = fetchFromGitHub {
     owner = "tremor-rs";
     repo = "tremor-runtime";
     rev = "v${version}";
-    sha256 = "1z1khxfdj2j0xf7dp0x2cd9kl6r4qicp7kc4p4sdky2yib66512y";
+    sha256 = "19g0ijkclrza6s0qcbwwh3lhlkisy00ffcl0c0d7dfqwrcisgz57";
   };
 
-  cargoSha256 = "sha256-rN/d6BL2d0D0ichQR6v0543Bh/Y2ktz8ExMH50M8B8c=";
+  cargoSha256 = "1xv205czb2z6qpqi6vslyrx2n21510qqa11i2hwya3jdcc9lkrsd";
 
   nativeBuildInputs = [ cmake pkg-config installShellFiles ];
 
   buildInputs = [ openssl ];
 
+  # TODO export TREMOR_PATH($out/lib) variable
   postInstall = ''
+    # Copy the standard library to $out/lib
+    cp -r ${src}/tremor-script/lib/ $out
+
     installShellCompletion --cmd tremor \
       --bash <($out/bin/tremor completions bash) \
       --fish <($out/bin/tremor completions fish) \
···
   # OPENSSL_NO_VENDOR - If set, always find OpenSSL in the system, even if the vendored feature is enabled.
   OPENSSL_NO_VENDOR = 1;
 
-  cargoBuildFlags = [ "--all" ];
+  cargoBuildFlags = [ "-p tremor-cli" ];
 
   meta = with lib; {
     description = "Early stage event processing system for unstructured data with rich support for structural pattern matching, filtering and transformation";

pkgs/tools/networking/ntp/default.nix

···
       url = "https://www.eecis.udel.edu/~mills/ntp/html/copyright.html";
     };
     maintainers = with maintainers; [ eelco thoughtpolice ];
-    platforms = platforms.linux;
+    platforms = platforms.unix;
   };
 }

pkgs/tools/security/yubikey-agent/default.nix

···
 
 buildGoModule rec {
   pname = "yubikey-agent";
-  version = "0.1.3";
+  version = "unstable-2021-02-18";
 
   src = fetchFromGitHub {
     owner = "FiloSottile";
     repo = pname;
-    rev = "v${version}";
-    sha256 = "07gix5wrakn4z846zhvl66lzwx58djrfnn6m8v7vc69l9jr3kihr";
+    rev = "8cadc13d107757f8084d9d2b93ea64ff0c1748e8";
+    sha256 = "1lklgq9qkqil5s0g56wbhs0vpr9c1bd4ir7bkrjwqj75ygxim8ml";
   };
 
   buildInputs =
···
     substituteInPlace main.go --replace 'notify-send' ${libnotify}/bin/notify-send
   '';
 
-  vendorSha256 = "128mlsagj3im6h0p0ndhzk29ya47g19im9dldx3nmddf2jlccj2h";
+  vendorSha256 = "1zx1w2is61471v4dlmr4wf714zqsc8sppik671p7s4fis5vccsca";
 
   doCheck = false;
 
···
   # See https://github.com/FiloSottile/yubikey-agent/pull/43
   + lib.optionalString stdenv.isLinux ''
     mkdir -p $out/lib/systemd/user
-    substitute ${./yubikey-agent.service} $out/lib/systemd/user/yubikey-agent.service \
+    substitute contrib/systemd/user/yubikey-agent.service $out/lib/systemd/user/yubikey-agent.service \
       --replace 'ExecStart=yubikey-agent' "ExecStart=$out/bin/yubikey-agent"
   '';
 

pkgs/tools/security/yubikey-agent/yubikey-agent.service

···
-[Unit]
-Description=Seamless ssh-agent for YubiKeys
-Documentation=https://filippo.io/yubikey-agent
-
-[Service]
-ExecStart=yubikey-agent -l %t/yubikey-agent/yubikey-agent.sock
-ExecReload=/bin/kill -HUP $MAINPID
-ProtectSystem=strict
-ProtectKernelLogs=yes
-ProtectKernelModules=yes
-ProtectKernelTunables=yes
-ProtectControlGroups=yes
-ProtectClock=yes
-ProtectHostname=yes
-PrivateTmp=yes
-PrivateDevices=yes
-PrivateUsers=yes
-IPAddressDeny=any
-RestrictAddressFamilies=AF_UNIX
-RestrictNamespaces=yes
-RestrictRealtime=yes
-RestrictSUIDSGID=yes
-LockPersonality=yes
-CapabilityBoundingSet=
-SystemCallFilter=@system-service
-SystemCallFilter=~@privileged @resources
-SystemCallErrorNumber=EPERM
-SystemCallArchitectures=native
-NoNewPrivileges=yes
-KeyringMode=private
-UMask=0177
-RuntimeDirectory=yubikey-agent
-
-[Install]
-WantedBy=default.target

pkgs/top-level/aliases.nix

···
   pmtools = acpica-tools; # added 2018-11-01
   polarssl = mbedtls; # added 2018-04-25
   poppler_qt5 = libsForQt5.poppler;  # added 2015-12-19
-  postgresql95 = postgresql_9_5;
   postgresql96 = postgresql_9_6;
   postgresql100 = throw "postgresql100 was deprecated on 2018-10-21: use postgresql_10 instead";
   # postgresql plugins

pkgs/top-level/all-packages.nix

···
 
   agda-pkg = callPackage ../development/tools/agda-pkg { };
 
+  agi = callPackage ../tools/graphics/agi { };
+
   agrep = callPackage ../tools/text/agrep { };
 
   aha = callPackage ../tools/text/aha { };
···
 
   groovy = callPackage ../development/interpreters/groovy { };
 
-  guile_1_8 = callPackage ../development/interpreters/guile/1.8.nix { };
-
-  # Needed for autogen
-  guile_2_0 = callPackage ../development/interpreters/guile/2.0.nix { };
-
-  guile_2_2 = callPackage ../development/interpreters/guile { };
-
-  guile = guile_2_2;
-
   inherit (callPackages ../applications/networking/cluster/hadoop {
     jre = jre8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
   })
···
 
   gImageReader = callPackage ../applications/misc/gImageReader { };
 
+  guile_1_8 = callPackage ../development/interpreters/guile/1.8.nix { };
+
+  # Needed for autogen
+  guile_2_0 = callPackage ../development/interpreters/guile/2.0.nix { };
+
+  guile_2_2 = callPackage ../development/interpreters/guile { };
+
+  guile = guile_2_2;
+
   guile-cairo = callPackage ../development/guile-modules/guile-cairo { };
 
+  guile-commonmark = callPackage ../development/guile-modules/guile-commonmark { };
+
   guile-fibers = callPackage ../development/guile-modules/guile-fibers { };
 
   guile-gnome = callPackage ../development/guile-modules/guile-gnome {
···
   timescaledb-tune = callPackage ../development/tools/database/timescaledb-tune { };
 
   inherit (import ../servers/sql/postgresql pkgs)
-    postgresql_9_5
     postgresql_9_6
     postgresql_10
     postgresql_11
···
     wxGTK = wxGTK30;
   };
 
+  haunt = callPackage ../applications/misc/haunt { };
+
   hugo = callPackage ../applications/misc/hugo { };
 
   go-org = callPackage ../applications/misc/go-org { };
···
   };
 
   kodi-wayland = callPackage ../applications/video/kodi {
+    jre_headless = jdk11_headless;
     waylandSupport = true;
   };
 
   kodi-gbm = callPackage ../applications/video/kodi {
+    jre_headless = jdk11_headless;
     gbmSupport = true;
   };