Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 38869148;
     name = "Alex Eyre";
   };
-  algorith = {
-    email = "[e-mail]";
-    github = "DriesVanDaele";
-    githubId = 1141488;
-    name = "Dries Van Daele";
-  };
   alibabzo = {
     email = "[e-mail]";
     github = "alibabzo";
···
     github = "kquick";
     githubId = 787421;
     name = "Kevin Quick";
+  };
+  kradalby = {
+    name = "Kristoffer Dalby";
+    email = "[e-mail]";
+    github = "kradalby";
+    githubId = 98431;
   };
   kraem = {
     email = "[e-mail]";

nixos/doc/manual/from_md/release-notes/rl-2205.section.xml

···
           <link xlink:href="options.html#opt-services.rstudio-server.enable">services.rstudio-server</link>.
         </para>
       </listitem>
+      <listitem>
+        <para>
+          <link xlink:href="https://github.com/juanfont/headscale">headscale</link>,
+          an Open Source implementation of the
+          <link xlink:href="https://tailscale.io">Tailscale</link>
+          Control Server. Available as
+          <link xlink:href="options.html#opt-services.headscale.enable">services.headscale</link>
+        </para>
+      </listitem>
     </itemizedlist>
   </section>
   <section xml:id="sec-release-22.05-incompatibilities">

nixos/doc/manual/release-notes/rl-2205.section.md

···
 
 - [rstudio-server](https://www.rstudio.com/products/rstudio/#rstudio-server), a browser-based version of the RStudio IDE for the R programming language. Available as [services.rstudio-server](options.html#opt-services.rstudio-server.enable).
 
+- [headscale](https://github.com/juanfont/headscale), an Open Source implementation of the [Tailscale](https://tailscale.io) Control Server. Available as [services.headscale](options.html#opt-services.headscale.enable)
+
 <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->
 
 ## Backward Incompatibilities {#sec-release-22.05-incompatibilities}

nixos/lib/systemd-lib.nix

···
 
   mkPathSafeName = lib.replaceChars ["@" ":" "\\" "[" "]"] ["-" "-" "-" "" ""];
 
+  # a type for options that take a unit name
+  unitNameType = types.strMatching "[a-zA-Z0-9@%:_.\\-]+[.](service|socket|device|mount|automount|swap|target|path|timer|scope|slice)";
+
   makeUnit = name: unit:
     if unit.enable then
       pkgs.runCommand "unit-${mkPathSafeName name}"

nixos/lib/systemd-unit-options.nix

···
 
     requiredBy = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Units that require (i.e. depend on and need to go down with)
         this unit. The discussion under <literal>wantedBy</literal>
···
 
     wantedBy = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Units that want (i.e. depend on) this unit. The standard way
         to make a unit start by default at boot is to set this option
···
 
     aliases = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = "Aliases of that unit.";
     };
 
···
 
     requires = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Start the specified units when this unit is started, and stop
         this unit when the specified units are stopped or fail.
···
 
     wants = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Start the specified units when this unit is started.
       '';
···
 
     after = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         If the specified units are started at the same time as
         this unit, delay this unit until they have started.
···
 
     before = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         If the specified units are started at the same time as
         this unit, delay them until this unit has started.
···
 
     bindsTo = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Like ‘requires’, but in addition, if the specified units
         unexpectedly disappear, this unit will be stopped as well.
···
 
     partOf = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         If the specified units are stopped or restarted, then this
         unit is stopped or restarted as well.
···
 
     conflicts = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         If the specified units are started, then this unit is stopped
         and vice versa.
···
 
     requisite = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         Similar to requires. However if the units listed are not started,
         they will not be started and the transaction will fail.
···
 
     onFailure = mkOption {
       default = [];
-      type = types.listOf types.str;
+      type = types.listOf unitNameType;
       description = ''
         A list of one or more units that are activated when
         this unit enters the "failed" state.

nixos/modules/module-list.nix

···
   ./services/networking/gvpe.nix
   ./services/networking/hans.nix
   ./services/networking/haproxy.nix
+  ./services/networking/headscale.nix
   ./services/networking/hostapd.nix
   ./services/networking/htpdate.nix
   ./services/networking/hylafax/default.nix

nixos/modules/services/networking/headscale.nix

···
+{ config, lib, pkgs, ... }:
+with lib;
+let
+  cfg = config.services.headscale;
+
+  dataDir = "/var/lib/headscale";
+  runDir = "/run/headscale";
+
+  settingsFormat = pkgs.formats.yaml { };
+  configFile = settingsFormat.generate "headscale.yaml" cfg.settings;
+in
+{
+  options = {
+    services.headscale = {
+      enable = mkEnableOption "headscale, Open Source coordination server for Tailscale";
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.headscale;
+        defaultText = literalExpression "pkgs.headscale";
+        description = ''
+          Which headscale package to use for the running server.
+        '';
+      };
+
+      user = mkOption {
+        default = "headscale";
+        type = types.str;
+        description = ''
+          User account under which headscale runs.
+          <note><para>
+          If left as the default value this user will automatically be created
+          on system activation, otherwise you are responsible for
+          ensuring the user exists before the headscale service starts.
+          </para></note>
+        '';
+      };
+
+      group = mkOption {
+        default = "headscale";
+        type = types.str;
+        description = ''
+          Group under which headscale runs.
+          <note><para>
+          If left as the default value this group will automatically be created
+          on system activation, otherwise you are responsible for
+          ensuring the user exists before the headscale service starts.
+          </para></note>
+        '';
+      };
+
+      serverUrl = mkOption {
+        type = types.str;
+        default = "http://127.0.0.1:8080";
+        description = ''
+          The url clients will connect to.
+        '';
+        example = "https://myheadscale.example.com:443";
+      };
+
+      address = mkOption {
+        type = types.str;
+        default = "127.0.0.1";
+        description = ''
+          Listening address of headscale.
+        '';
+        example = "0.0.0.0";
+      };
+
+      port = mkOption {
+        type = types.port;
+        default = 8080;
+        description = ''
+          Listening port of headscale.
+        '';
+        example = 443;
+      };
+
+      privateKeyFile = mkOption {
+        type = types.path;
+        default = "${dataDir}/private.key";
+        description = ''
+          Path to private key file, generated automatically if it does not exist.
+        '';
+      };
+
+      derp = {
+        urls = mkOption {
+          type = types.listOf types.str;
+          default = [ "https://controlplane.tailscale.com/derpmap/default" ];
+          description = ''
+            List of urls containing DERP maps.
+            See <link xlink:href="https://tailscale.com/blog/how-tailscale-works/">How Tailscale works</link> for more information on DERP maps.
+          '';
+        };
+
+        paths = mkOption {
+          type = types.listOf types.path;
+          default = [ ];
+          description = ''
+            List of file paths containing DERP maps.
+            See <link xlink:href="https://tailscale.com/blog/how-tailscale-works/">How Tailscale works</link> for more information on DERP maps.
+          '';
+        };
+
+
+        autoUpdate = mkOption {
+          type = types.bool;
+          default = true;
+          description = ''
+            Whether to automatically update DERP maps on a set frequency.
+          '';
+          example = false;
+        };
+
+        updateFrequency = mkOption {
+          type = types.str;
+          default = "24h";
+          description = ''
+            Frequency to update DERP maps.
+          '';
+          example = "5m";
+        };
+
+      };
+
+      ephemeralNodeInactivityTimeout = mkOption {
+        type = types.str;
+        default = "30m";
+        description = ''
+          Time before an inactive ephemeral node is deleted.
+        '';
+        example = "5m";
+      };
+
+      database = {
+        type = mkOption {
+          type = types.enum [ "sqlite3" "postgres" ];
+          example = "postgres";
+          default = "sqlite3";
+          description = "Database engine to use.";
+        };
+
+        host = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          example = "127.0.0.1";
+          description = "Database host address.";
+        };
+
+        port = mkOption {
+          type = types.nullOr types.port;
+          default = null;
+          example = 3306;
+          description = "Database host port.";
+        };
+
+        name = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          example = "headscale";
+          description = "Database name.";
+        };
+
+        user = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          example = "headscale";
+          description = "Database user.";
+        };
+
+        passwordFile = mkOption {
+          type = types.nullOr types.path;
+          default = null;
+          example = "/run/keys/headscale-dbpassword";
+          description = ''
+            A file containing the password corresponding to
+            <option>database.user</option>.
+          '';
+        };
+
+        path = mkOption {
+          type = types.nullOr types.str;
+          default = "${dataDir}/db.sqlite";
+          description = "Path to the sqlite3 database file.";
+        };
+      };
+
+      logLevel = mkOption {
+        type = types.str;
+        default = "info";
+        description = ''
+          headscale log level.
+        '';
+        example = "debug";
+      };
+
+      dns = {
+        nameservers = mkOption {
+          type = types.listOf types.str;
+          default = [ "1.1.1.1" ];
+          description = ''
+            List of nameservers to pass to Tailscale clients.
+          '';
+        };
+
+        domains = mkOption {
+          type = types.listOf types.str;
+          default = [ ];
+          description = ''
+            Search domains to inject to Tailscale clients.
+          '';
+          example = [ "mydomain.internal" ];
+        };
+
+        magicDns = mkOption {
+          type = types.bool;
+          default = true;
+          description = ''
+            Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/).
+            Only works if there is at least a nameserver defined.
+          '';
+          example = false;
+        };
+
+        baseDomain = mkOption {
+          type = types.str;
+          default = "";
+          description = ''
+            Defines the base domain to create the hostnames for MagicDNS.
+            <option>baseDomain</option> must be a FQDNs, without the trailing dot.
+            The FQDN of the hosts will be
+            <literal>hostname.namespace.base_domain</literal> (e.g.
+            <literal>myhost.mynamespace.example.com</literal>).
+          '';
+        };
+      };
+
+      openIdConnect = {
+        issuer = mkOption {
+          type = types.str;
+          default = "";
+          description = ''
+            URL to OpenID issuer.
+          '';
+          example = "https://openid.example.com";
+        };
+
+        clientId = mkOption {
+          type = types.str;
+          default = "";
+          description = ''
+            OpenID Connect client ID.
+          '';
+        };
+
+        clientSecretFile = mkOption {
+          type = types.nullOr types.path;
+          default = null;
+          description = ''
+            Path to OpenID Connect client secret file.
+          '';
+        };
+
+        domainMap = mkOption {
+          type = types.attrsOf types.str;
+          default = { };
+          description = ''
+            Domain map is used to map incomming users (by their email) to
+            a namespace. The key can be a string, or regex.
+          '';
+          example = {
+            ".*" = "default-namespace";
+          };
+        };
+
+      };
+
+      tls = {
+        letsencrypt = {
+          hostname = mkOption {
+            type = types.nullOr types.str;
+            default = "";
+            description = ''
+              Domain name to request a TLS certificate for.
+            '';
+          };
+          challengeType = mkOption {
+            type = types.enum [ "TLS_ALPN-01" "HTTP-01" ];
+            default = "HTTP-01";
+            description = ''
+              Type of ACME challenge to use, currently supported types:
+              <literal>HTTP-01</literal> or <literal>TLS_ALPN-01</literal>.
+            '';
+          };
+          httpListen = mkOption {
+            type = types.nullOr types.str;
+            default = ":http";
+            description = ''
+              When HTTP-01 challenge is chosen, letsencrypt must set up a
+              verification endpoint, and it will be listening on:
+              <literal>:http = port 80</literal>.
+            '';
+          };
+        };
+
+        certFile = mkOption {
+          type = types.nullOr types.path;
+          default = null;
+          description = ''
+            Path to already created certificate.
+          '';
+        };
+        keyFile = mkOption {
+          type = types.nullOr types.path;
+          default = null;
+          description = ''
+            Path to key for already created certificate.
+          '';
+        };
+      };
+
+      aclPolicyFile = mkOption {
+        type = types.nullOr types.path;
+        default = null;
+        description = ''
+          Path to a file containg ACL policies.
+        '';
+      };
+
+      settings = mkOption {
+        type = settingsFormat.type;
+        default = { };
+        description = ''
+          Overrides to <filename>config.yaml</filename> as a Nix attribute set.
+          This option is ideal for overriding settings not exposed as Nix options.
+          Check the <link xlink:href="https://github.com/juanfont/headscale/blob/main/config-example.yaml">example config</link>
+          for possible options.
+        '';
+      };
+
+
+    };
+
+  };
+  config = mkIf cfg.enable {
+
+    services.headscale.settings = {
+      server_url = mkDefault cfg.serverUrl;
+      listen_addr = mkDefault "${cfg.address}:${toString cfg.port}";
+
+      private_key_path = mkDefault cfg.privateKeyFile;
+
+      derp = {
+        urls = mkDefault cfg.derp.urls;
+        paths = mkDefault cfg.derp.paths;
+        auto_update_enable = mkDefault cfg.derp.autoUpdate;
+        update_frequency = mkDefault cfg.derp.updateFrequency;
+      };
+
+      # Turn off update checks since the origin of our package
+      # is nixpkgs and not Github.
+      disable_check_updates = true;
+
+      ephemeral_node_inactivity_timeout = mkDefault cfg.ephemeralNodeInactivityTimeout;
+
+      db_type = mkDefault cfg.database.type;
+      db_path = mkDefault cfg.database.path;
+
+      log_level = mkDefault cfg.logLevel;
+
+      dns_config = {
+        nameservers = mkDefault cfg.dns.nameservers;
+        domains = mkDefault cfg.dns.domains;
+        magic_dns = mkDefault cfg.dns.magicDns;
+        base_domain = mkDefault cfg.dns.baseDomain;
+      };
+
+      unix_socket = "${runDir}/headscale.sock";
+
+      # OpenID Connect
+      oidc = {
+        issuer = mkDefault cfg.openIdConnect.issuer;
+        client_id = mkDefault cfg.openIdConnect.clientId;
+        domain_map = mkDefault cfg.openIdConnect.domainMap;
+      };
+
+      tls_letsencrypt_cache_dir = "${dataDir}/.cache";
+
+    } // optionalAttrs (cfg.database.host != null) {
+      db_host = mkDefault cfg.database.host;
+    } // optionalAttrs (cfg.database.port != null) {
+      db_port = mkDefault cfg.database.port;
+    } // optionalAttrs (cfg.database.name != null) {
+      db_name = mkDefault cfg.database.name;
+    } // optionalAttrs (cfg.database.user != null) {
+      db_user = mkDefault cfg.database.user;
+    } // optionalAttrs (cfg.tls.letsencrypt.hostname != null) {
+      tls_letsencrypt_hostname = mkDefault cfg.tls.letsencrypt.hostname;
+    } // optionalAttrs (cfg.tls.letsencrypt.challengeType != null) {
+      tls_letsencrypt_challenge_type = mkDefault cfg.tls.letsencrypt.challengeType;
+    } // optionalAttrs (cfg.tls.letsencrypt.httpListen != null) {
+      tls_letsencrypt_listen = mkDefault cfg.tls.letsencrypt.httpListen;
+    } // optionalAttrs (cfg.tls.certFile != null) {
+      tls_cert_path = mkDefault cfg.tls.certFile;
+    } // optionalAttrs (cfg.tls.keyFile != null) {
+      tls_key_path = mkDefault cfg.tls.keyFile;
+    } // optionalAttrs (cfg.aclPolicyFile != null) {
+      acl_policy_path = mkDefault cfg.aclPolicyFile;
+    };
+
+    # Setup the headscale configuration in a known path in /etc to
+    # allow both the Server and the Client use it to find the socket
+    # for communication.
+    environment.etc."headscale/config.yaml".source = configFile;
+
+    users.groups.headscale = mkIf (cfg.group == "headscale") { };
+
+    users.users.headscale = mkIf (cfg.user == "headscale") {
+      description = "headscale user";
+      home = dataDir;
+      group = cfg.group;
+      isSystemUser = true;
+    };
+
+    systemd.services.headscale = {
+      description = "headscale coordination server for Tailscale";
+      after = [ "network-online.target" ];
+      wantedBy = [ "multi-user.target" ];
+      restartTriggers = [ configFile ];
+
+      script = ''
+        ${optionalString (cfg.database.passwordFile != null) ''
+          export HEADSCALE_DB_PASS="$(head -n1 ${escapeShellArg cfg.database.passwordFile})"
+        ''}
+
+        export HEADSCALE_OIDC_CLIENT_SECRET="$(head -n1 ${escapeShellArg cfg.openIdConnect.clientSecretFile})"
+        exec ${cfg.package}/bin/headscale serve
+      '';
+
+      serviceConfig =
+        let
+          capabilityBoundingSet = [ "CAP_CHOWN" ] ++ optional (cfg.port < 1024) "CAP_NET_BIND_SERVICE";
+        in
+        {
+          Restart = "always";
+          Type = "simple";
+          User = cfg.user;
+          Group = cfg.group;
+
+          # Hardening options
+          RuntimeDirectory = "headscale";
+          # Allow headscale group access so users can be added and use the CLI.
+          RuntimeDirectoryMode = "0750";
+
+          StateDirectory = "headscale";
+          StateDirectoryMode = "0750";
+
+          ProtectSystem = "strict";
+          ProtectHome = true;
+          PrivateTmp = true;
+          PrivateDevices = true;
+          ProtectKernelTunables = true;
+          ProtectControlGroups = true;
+          RestrictSUIDSGID = true;
+          PrivateMounts = true;
+          ProtectKernelModules = true;
+          ProtectKernelLogs = true;
+          ProtectHostname = true;
+          ProtectClock = true;
+          ProtectProc = "invisible";
+          ProcSubset = "pid";
+          RestrictNamespaces = true;
+          RemoveIPC = true;
+          UMask = "0077";
+
+          CapabilityBoundingSet = capabilityBoundingSet;
+          AmbientCapabilities = capabilityBoundingSet;
+          NoNewPrivileges = true;
+          LockPersonality = true;
+          RestrictRealtime = true;
+          SystemCallFilter = [ "@system-service" "~@priviledged" "@chown" ];
+          SystemCallArchitectures = "native";
+          RestrictAddressFamilies = "AF_INET AF_INET6 AF_UNIX";
+        };
+    };
+  };
+
+  meta.maintainers = with maintainers; [ kradalby ];
+}

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

···
 let
   cfg = config.services.miniflux;
 
+  defaultAddress = "localhost:8080";
+
   dbUser = "miniflux";
   dbPassword = "miniflux";
   dbHost = "localhost";
···
 {
   options = {
     services.miniflux = {
-      enable = mkEnableOption "miniflux";
+      enable = mkEnableOption "miniflux and creates a local postgres database for it";
 
       config = mkOption {
         type = types.attrsOf types.str;
···
           Configuration for Miniflux, refer to
           <link xlink:href="https://miniflux.app/docs/configuration.html"/>
           for documentation on the supported values.
+
+          Correct configuration for the database is already provided.
+          By default, listens on ${defaultAddress}.
         '';
       };
 
···
   config = mkIf cfg.enable {
 
     services.miniflux.config =  {
-      LISTEN_ADDR = mkDefault "localhost:8080";
+      LISTEN_ADDR = mkDefault defaultAddress;
       DATABASE_URL = "postgresql://${dbUser}:${dbPassword}@${dbHost}/${dbName}?sslmode=disable";
       RUN_MIGRATIONS = "1";
       CREATE_ADMIN = "1";

pkgs/applications/blockchains/ergo/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ergo";
-  version = "4.0.16.2";
+  version = "4.0.20.1";
 
   src = fetchurl {
     url = "https://github.com/ergoplatform/ergo/releases/download/v${version}/ergo-${version}.jar";
-    sha256 = "sha256-nAaNT5Rt/oLBA2pSJSinoLKMYJ0VZmuC0zoMYbMSAJQ=";
+    sha256 = "sha256-uKt0TNKcqiXiT5MnsguU5fTdUyFgV7Km5KjrFS/7tws=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/applications/misc/edgetx/default.nix

···
+{ lib, mkDerivation, fetchFromGitHub
+, cmake, gcc-arm-embedded, python3Packages
+, qtbase, qtmultimedia, qttranslations, SDL, gtest
+, dfu-util
+}:
+
+mkDerivation rec {
+  pname = "edgetx";
+  version = "2.6.0";
+
+  src = fetchFromGitHub {
+    owner = "EdgeTX";
+    repo = pname;
+    rev = "v${version}";
+    fetchSubmodules = true;
+    sha256 = "sha256-TffHFgr3g7v4VnNSSlLITz4cYjHM6wE0aI85W1g4IFA=";
+  };
+
+  nativeBuildInputs = [ cmake gcc-arm-embedded python3Packages.pillow ];
+
+  buildInputs = [ qtbase qtmultimedia qttranslations SDL ];
+
+  postPatch = ''
+    sed -i companion/src/burnconfigdialog.cpp \
+      -e 's|/usr/.*bin/dfu-util|${dfu-util}/bin/dfu-util|'
+  '';
+
+  cmakeFlags = [
+    "-DGTEST_ROOT=${gtest.src}/googletest"
+    "-DQT_TRANSLATIONS_DIR=${qttranslations}/translations"
+    "-DDFU_UTIL_PATH=${dfu-util}/bin/dfu-util"
+  ];
+
+  meta = with lib; {
+    description = "EdgeTX Companion transmitter support software";
+    longDescription = ''
+      EdgeTX Companion is used for many different tasks like loading EdgeTX
+      firmware to the radio, backing up model settings, editing settings and
+      running radio simulators.
+    '';
+    homepage = "https://edgetx.org/";
+    license = licenses.gpl2Only;
+    platforms = [ "i686-linux" "x86_64-linux" "aarch64-linux" ];
+    maintainers = with maintainers; [ elitak lopsided98 wucke13 ];
+  };
+
+}

pkgs/applications/misc/etesync-dav/default.nix

···
-{ lib, stdenv, python3Packages, radicale3 }:
+{ lib
+, stdenv
+, python3
+, radicale3
+}:
 
-python3Packages.buildPythonApplication rec {
+let
+  python = python3.override {
+    packageOverrides = self: super: {
+      flask_wtf = super.flask_wtf.overridePythonAttrs (old: rec {
+        version = "0.15.1";
+        src = old.src.override {
+          inherit version;
+          sha256 = "ff177185f891302dc253437fe63081e7a46a4e99aca61dfe086fb23e54fff2dc";
+        };
+      });
+    };
+  };
+in python.pkgs.buildPythonApplication rec {
   pname = "etesync-dav";
-  version = "0.30.8";
+  version = "0.32.1";
 
-  src = python3Packages.fetchPypi {
+  src = python.pkgs.fetchPypi {
     inherit pname version;
-    sha256 = "sha256-HBLQsq3B6TMdcnUt8ukbk3+S0Ed44+gePkpuGZ2AyC4=";
+    sha256 = "a4e2ee83932755d29ac39c1e74005ec289880fd2d4d2164f09fe2464a294d720";
   };
 
-  propagatedBuildInputs = with python3Packages; [
+  propagatedBuildInputs = with python.pkgs; [
     etebase
     etesync
     flask
     flask_wtf
-    radicale3
+    (python.pkgs.toPythonModule (radicale3.override { python3 = python; }))
   ];
 
   doCheck = false;

pkgs/applications/misc/nwg-panel/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "nwg-panel";
-  version = "0.5.4";
+  version = "0.5.7";
 
   src = fetchFromGitHub {
     owner = "nwg-piotr";
     repo = "nwg-panel";
     rev = "v${version}";
-    sha256 = "0vl9vfgpa1byf9vxn03j58h9zcbjd1y83b0kgv97cxm2mhqz12dg";
+    sha256 = "1d3qh42cwayb5d9ymhfs2vrbg5x5x6x73hw77m3xb9y4vyhji85x";
   };
 
   # No tests

pkgs/applications/misc/pdfstudio/default.nix

···
 , callPackage
 }:
 
+let makeurl = { pname, year, version }: "https://download.qoppa.com/${pname}/v${year}/${
+    builtins.replaceStrings [ "pdfstudio" "viewer" "." ] [ "PDFStudio" "Viewer" "_" ] "${pname}_v${version}"
+  }_linux64.deb";
+in
 {
   pdfstudio = callPackage ./common.nix rec {
     pname = program;
···
       libgccjit #for libstdc++.so.6 and libgomp.so.1
     ];
     src = fetchurl {
-      url = "https://download.qoppa.com/${pname}/v${year}/PDFStudio_v${
-        builtins.replaceStrings [ "." ] [ "_" ] version
-        }_linux64.deb";
+      url = makeurl { inherit pname year version; };
       sha256 = "1188ll2qz58rr2slavqxisbz4q3fdzidpasb1p33926z0ym3rk45";
     };
   };
···
       PDF Studio Viewer is an easy to use, full-featured PDF editing software. This is the free edition. For the standard/pro edition, see the package pdfstudio.
     '';
     src = fetchurl {
-      url = "https://download.qoppa.com/${pname}/v${year}/PDFStudioViewer_v${
-          builtins.replaceStrings [ "." ] [ "_" ] version
-        }_linux64.deb";
+      url = makeurl { inherit pname year version; };
       sha256 = "128k3fm8m8zdykx4s30g5m2zl7cgmvs4qinf1w525zh84v56agz6";
     };
   };

pkgs/applications/networking/cluster/tilt/default.nix

···
   /* Do not use "dev" as a version. If you do, Tilt will consider itself
     running in development environment and try to serve assets from the
     source tree, which is not there once build completes.  */
-  version = "0.23.4";
+  version = "0.23.5";
 
   src = fetchFromGitHub {
     owner  = "tilt-dev";
     repo   = pname;
     rev    = "v${version}";
-    sha256 = "sha256-SWofXsbkuirPvqgU639W8IQklafLKbThoZUzOzfYwdQ=";
+    sha256 = "sha256-qVybS+gRuTezX89NMWYQVWtUH6wnjB11HImejrzVHAc=";
   };
   vendorSha256 = null;
 

pkgs/applications/networking/irc/quassel/0001-common-Disable-enum-type-stream-operators-for-Qt-5.1.patch

···
-From ac9387271b2420a71f7d172f44354fc35adac504 Mon Sep 17 00:00:00 2001
-From: Manuel Nickschas <[e-mail]>
-Date: Tue, 7 Jan 2020 18:34:54 +0100
-Subject: [PATCH] common: Disable enum type stream operators for Qt >= 5.14
-
-Starting from version 5.14, Qt provides stream operators for enum
-types, which collide with the ones we ship in types.h. Disable
-Quassel's stream operators when compiling against Qt 5.14 or later.
-
-(cherry-picked from 579e559a6322209df7cd51c34801fecff5fe734b)
----
- src/common/types.h | 2 ++
- 1 file changed, 2 insertions(+)
-
-diff --git a/src/common/types.h b/src/common/types.h
-index 467d9fb2..c4b9f364 100644
---- a/src/common/types.h
-+++ b/src/common/types.h
-@@ -140,6 +140,7 @@ Q_DECLARE_METATYPE(QHostAddress)
- typedef QList<MsgId> MsgIdList;
- typedef QList<BufferId> BufferIdList;
- 
-+#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
- /**
-  * Catch-all stream serialization operator for enum types.
-  *
-@@ -169,6 +170,7 @@ QDataStream &operator>>(QDataStream &in, T &value) {
-     value = static_cast<T>(v);
-     return in;
- }
-+#endif
- 
- // Exceptions
- 
--- 
-2.26.2
-

pkgs/applications/networking/irc/quassel/default.nix

···
 , static ? false # link statically
 
 , lib, stdenv, fetchFromGitHub, cmake, makeWrapper, dconf
-, mkDerivation, qtbase, qtscript
+, mkDerivation, qtbase, boost, zlib, qtscript
 , phonon, libdbusmenu, qca-qt5
 
 , withKDE ? true # enable KDE integration
···
 
 in (if !buildClient then stdenv.mkDerivation else mkDerivation) rec {
   pname = "quassel${tag}";
-  version = "0.13.1";
+  version = "0.14.0";
 
   src = fetchFromGitHub {
     owner = "quassel";
     repo = "quassel";
     rev = version;
-    sha256 = "0z8p7iv90yrrjbh31cyxhpr6hsynfmi23rlayn7p2f6ki5az7yc3";
+    sha256 = "sha256-eulhNcyCmy9ryietOhT2yVJeJH+MMZRbTUo2XuTy9qU=";
   };
 
-  patches = [
-    # fixes build with Qt 5.14
-    # source: https://github.com/quassel/quassel/pull/518/commits/8a46d983fc99204711cdff1e4c542e272fef45b9
-    ./0001-common-Disable-enum-type-stream-operators-for-Qt-5.1.patch
-  ];
-
   # Prevent ``undefined reference to `qt_version_tag''' in SSL check
   NIX_CFLAGS_COMPILE = "-DQT_NO_VERSION_TAGGING=1";
 
   nativeBuildInputs = [ cmake makeWrapper ];
-  buildInputs = [ qtbase ]
-    ++ lib.optionals buildCore [qtscript qca-qt5]
+  buildInputs = [ qtbase boost zlib ]
+    ++ lib.optionals buildCore [qtscript qca-qt5 ]
     ++ lib.optionals buildClient [libdbusmenu phonon]
     ++ lib.optionals (buildClient && withKDE) [
       extra-cmake-modules kconfigwidgets kcoreaddons

pkgs/applications/office/morgen/default.nix

···
+{ lib, stdenv, fetchurl, dpkg, autoPatchelfHook, makeWrapper, electron
+, nodePackages, alsa-lib, gtk3, libxshmfence, mesa, nss }:
+
+stdenv.mkDerivation rec {
+  pname = "morgen";
+  version = "2.4.3";
+
+  src = fetchurl {
+    url = "https://download.todesktop.com/210203cqcj00tw1/morgen-${version}.deb";
+    sha256 = "sha256-IWGeb0+IiFNYJ+jQAzGYfQ5FnrbR6HIpynS9jgd5/mY=";
+  };
+
+  nativeBuildInputs = [
+    dpkg
+    autoPatchelfHook
+    makeWrapper
+    nodePackages.asar
+  ];
+
+  buildInputs = [ alsa-lib gtk3 libxshmfence mesa nss ];
+
+  dontBuild = true;
+  dontConfigure = true;
+
+  unpackCmd = ''
+    dpkg-deb -x ${src} ./morgen-${pname}
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mv usr $out
+    mv opt $out
+
+    asar extract $out/opt/Morgen/resources/app.asar "$TMP/work"
+    # 1. Fixes path for todesktop-runtime-config.json
+    # 2. Fixes startup script
+    substituteInPlace $TMP/work/dist/main.js \
+      --replace "process.resourcesPath,\"todesktop-runtime-config.json" "\"$out/opt/Morgen/resources/todesktop-runtime-config.json" \
+      --replace "Exec=\"+process.execPath+\"" "Exec=$out/bin/morgen"
+    asar pack --unpack='{*.node,*.ftz,rect-overlay}' "$TMP/work" $out/opt/Morgen/resources/app.asar
+
+    substituteInPlace $out/share/applications/morgen.desktop \
+      --replace '/opt/Morgen' $out/bin
+
+    makeWrapper ${electron}/bin/electron $out/bin/morgen \
+      --add-flags $out/opt/Morgen/resources/app.asar
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "All-in-one Calendars, Tasks and Scheduler";
+    homepage = "https://morgen.so/download";
+    license = licenses.unfree;
+    maintainers = with maintainers; [ wolfangaukang ];
+    platforms = [ "x86_64-linux" ];
+  };
+}

pkgs/applications/office/skrooge/default.nix

···
 
 mkDerivation rec {
   pname = "skrooge";
-  version = "2.26.1";
+  version = "2.27.0";
 
   src = fetchurl {
     url = "https://download.kde.org/stable/skrooge/${pname}-${version}.tar.xz";
-    sha256 = "sha256-66hoA+FDTeMbNAInr9TlTSnwUywJQjTRz87MkdNYn5Q=";
+    sha256 = "sha256-xkl0UyJEDOeYOqqXf3woCDMb8ZyC2c5ChQdDFFERZxE=";
   };
 
   nativeBuildInputs = [

pkgs/applications/office/zanshin/default.nix

···
 
 mkDerivation rec {
   pname = "zanshin";
-  version = "21.12.0";
+  version = "21.12.1";
 
   src = fetchurl {
     url = "mirror://kde/stable/release-service/${version}/src/zanshin-${version}.tar.xz";
-    sha256 = "sha256-l8W47tS7q747fkSAH3HJdwPsqjMfCyxzl3xJEeAXeh0=";
+    sha256 = "sha256-hYbJwmnD9i/SL5ET2t9YgPxJHJUpAbMZ4a62WljhpHw=";
   };
 
   nativeBuildInputs = [

pkgs/applications/science/physics/shtns/default.nix

···
+{ lib, stdenv, fetchgit, fftw }:
+
+stdenv.mkDerivation rec {
+  pname = "shtns";
+  version = "3.5.1";
+
+  src = fetchgit {
+    url = "https://bitbucket.org/nschaeff/shtns";
+    rev = "v${version}";
+    sha256 = "1ajrplhv7a2dvb3cn3n638281w0bzdcydvvwbg64awbjg622mdpd";
+  };
+
+  buildInputs = [ fftw ];
+
+  meta = with lib; {
+    description = "High performance library for Spherical Harmonic Transform";
+    homepage = "https://nschaeff.bitbucket.io/shtns/";
+    license = licenses.cecill21;
+    maintainers = [ maintainers.bzizou ];
+    platforms = platforms.linux;
+  };
+}

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

···
     xcbutilwm
   ];
 
-  sourceRoot = let
+  prePatch = let
     subdir = if stdenv.isDarwin then "osx" else "linux";
-  in "source/${subdir}";
+  in "cd ${subdir}";
 
   makeFlags = [ "PREFIX=${placeholder "out"}" ];
 

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "3034b8f1052c41d5b3c571cb2bedb5f62bbede65",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/3034b8f1052c41d5b3c571cb2bedb5f62bbede65.tar.gz",
-  "sha256": "0kqga1mf7vr292jcaqw8qk4s1bjwc2z1wwjih5xwli3hkk584l20",
-  "msg": "Update from Hackage at 2022-01-24T10:21:35Z"
+  "commit": "b233c8c0ee187788a69d929293a953cf89ffc012",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/b233c8c0ee187788a69d929293a953cf89ffc012.tar.gz",
+  "sha256": "00mi9jxjbd9mk2pghj1ks9mjy9i0x50kcgi28iajq0kvxc97c9sp",
+  "msg": "Update from Hackage at 2022-01-27T16:52:24Z"
 }

pkgs/development/compilers/ghc/9.0.2.nix

···
   # build-time dependency too.
   buildTargetLlvmPackages, llvmPackages
 
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp
+, # If enabled, GHC will be built with the GPL-free but slightly slower native
+  # bignum backend instead of the faster but GPLed gmp backend.
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+, gmp
 
 , # If enabled, use -fPIC when compiling static libs.
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
···
   disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
 }:
 
-assert !enableIntegerSimple -> gmp != null;
+assert !enableNativeBignum -> gmp != null;
 
 # Cross cannot currently build the `haddock` program for silly reasons,
 # see note [HADDOCK_DOCS].
···
   ''
     HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}
     DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
+    BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}
   '' + lib.optionalString (targetPlatform != hostPlatform) ''
     Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
···
   # Splicer will pull out correct variations
   libDeps = platform: lib.optional enableTerminfo ncurses
     ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
+    ++ lib.optional (!enableNativeBignum) gmp
     ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
 
   # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
···
   # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
   variantSuffix = lib.concatStrings [
     (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
-    (lib.optionalString enableIntegerSimple "-integer-simple")
+    (lib.optionalString enableNativeBignum "-native-bignum")
   ];
 
 in
···
     "--with-system-libffi"
     "--with-ffi-includes=${targetPackages.libffi.dev}/include"
     "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
+  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
     "--with-gmp-includes=${targetPackages.gmp.dev}/include"
     "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
   ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

pkgs/development/compilers/ghc/9.2.1.nix

···
   # build-time dependency too.
   buildTargetLlvmPackages, llvmPackages
 
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp
+, # If enabled, GHC will be built with the GPL-free but slightly slower native
+  # bignum backend instead of the faster but GPLed gmp backend.
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+, gmp
 
 , # If enabled, use -fPIC when compiling static libs.
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
···
   disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
 }:
 
-assert !enableIntegerSimple -> gmp != null;
+assert !enableNativeBignum -> gmp != null;
 
 # Cross cannot currently build the `haddock` program for silly reasons,
 # see note [HADDOCK_DOCS].
···
   ''
     HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}
     DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
+    BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}
   '' + lib.optionalString (targetPlatform != hostPlatform) ''
     Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
···
   # Splicer will pull out correct variations
   libDeps = platform: lib.optional enableTerminfo ncurses
     ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
+    ++ lib.optional (!enableNativeBignum) gmp
     ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
 
   # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
···
   # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
   variantSuffix = lib.concatStrings [
     (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
-    (lib.optionalString enableIntegerSimple "-integer-simple")
+    (lib.optionalString enableNativeBignum "-native-bignum")
   ];
 
 in
···
     "--with-system-libffi"
     "--with-ffi-includes=${targetPackages.libffi.dev}/include"
     "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
+  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
     "--with-gmp-includes=${targetPackages.gmp.dev}/include"
     "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
   ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

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

···
   - arrow-list
   - arrowp
   - arrowp-qq
+  - arrow-utils
   - ArrowVHDL
   - artery
   - artifact
···
   - wavefront-obj
   - weak-bag
   - weather-api
+  - web3-polkadot
   - webapi
   - webapp
   - webauthn

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

···
  - clckwrks-theme-clckwrks
  - clckwrks-theme-geo-bootstrap
  - cless
+ - cleveland
  - click-clack
  - clifford
  - clippings
···
  - indentation-trifecta
  - indexation
  - indieweb-algorithms
+ - indigo
  - infernu
  - inline-java
  - inspector-wrecker
···
  - moo
  - moo-nad
  - morley
+ - morley-client
+ - morley-upgradeable
  - morloc
  - morpheus-graphql-client_0_18_0
  - morpheus-graphql_0_18_0
···
  - web-routes-regular
  - web-routing
  - web3
+ - web3-ethereum
  - webcrank-wai
  - webdriver-w3c
  - webserver

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

···
        license = lib.licenses.bsd3;
      }) {};
 
+  "amqp_0_22_1" = callPackage
+    ({ mkDerivation, base, binary, bytestring, clock, connection
+     , containers, data-binary-ieee754, hspec, hspec-expectations
+     , monad-control, network, network-uri, split, stm, text, vector
+     , xml
+     }:
+     mkDerivation {
+       pname = "amqp";
+       version = "0.22.1";
+       sha256 = "0z1w35ar0bswbjzgana52nh4ilxbidnfkvli29w2zr7cak9dgzg1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary bytestring clock connection containers
+         data-binary-ieee754 monad-control network network-uri split stm
+         text vector
+       ];
+       executableHaskellDepends = [ base containers xml ];
+       testHaskellDepends = [
+         base binary bytestring clock connection containers
+         data-binary-ieee754 hspec hspec-expectations network network-uri
+         split stm text vector
+       ];
+       description = "Client library for AMQP servers (currently only RabbitMQ)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "amqp-conduit" = callPackage
     ({ mkDerivation, amqp, base, bytestring, conduit, exceptions, hspec
      , HUnit, lifted-base, monad-control, mtl, resourcet, text
···
      }:
      mkDerivation {
        pname = "arrow-utils";
-       version = "0.1.0.0";
-       sha256 = "1l8njh623a00hvfd3cczvb4ngh7c39z6f0kfhr8hr6xhbkrgwqnc";
-       revision = "1";
-       editedCabalFile = "1jdl1jmr8hbjiybrjnfr8rraqdf95l4qia3nna3nh9pvh8c69jln";
+       version = "0.1.1";
+       sha256 = "112g74g844lnqfphkxqmp8ysnvi11iii9gcn70ml1ag6m5bdr7lc";
        libraryHaskellDepends = [ base vector-sized ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
        ];
        description = "functions for working with arrows";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "arrowapply-utils" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "authenticate_1_3_5_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , case-insensitive, conduit, containers, html-conduit, http-conduit
+     , http-types, network-uri, resourcet, text, transformers
+     , unordered-containers, xml-conduit
+     }:
+     mkDerivation {
+       pname = "authenticate";
+       version = "1.3.5.1";
+       sha256 = "1rhbvdgwdr68gp13p5piddfdqf3l9lmx4w7k249lc98y23780c3x";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder bytestring case-insensitive
+         conduit containers html-conduit http-conduit http-types network-uri
+         resourcet text transformers unordered-containers xml-conduit
+       ];
+       description = "Authentication methods for Haskell web applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "authenticate-kerberos" = callPackage
     ({ mkDerivation, base, process, text }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "avro_0_6_0_0" = callPackage
+  "avro_0_6_0_1" = callPackage
     ({ mkDerivation, aeson, array, base, base16-bytestring, bifunctors
      , binary, bytestring, containers, data-binary-ieee754, deepseq
      , directory, doctest, doctest-discover, extra, fail, gauge
···
      }:
      mkDerivation {
        pname = "avro";
-       version = "0.6.0.0";
-       sha256 = "056nd6cgl9lqv0ij8a2s0rca1f0qcxr2mfr0i8pkh84h9y84nzv9";
+       version = "0.6.0.1";
+       sha256 = "1kl7dp0vm2klvijszjhwj2x9m4bmw044s085fyq86cszqrsrrn6w";
        libraryHaskellDepends = [
          aeson array base base16-bytestring bifunctors binary bytestring
          containers data-binary-ieee754 deepseq fail HasBigDecimal hashable
···
        pname = "beam-core";
        version = "0.9.2.0";
        sha256 = "1b1xk4pi9j49fmh9lywgqcg61gbd6i7905gv5prnf0799iqz68g9";
+       revision = "1";
+       editedCabalFile = "1wfvfgram4sy9lw6l5xizhdmfaxq7gyv4ygph6r46c47abzv3ha0";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist free ghc-prim hashable
          microlens mtl network-uri scientific tagged text time vector
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "cleveland" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base-noprelude
+     , bimap, bytestring, constraints, containers, criterion, cryptonite
+     , data-default, directory, either, exceptions, file-embed, filepath
+     , first-class-families, fmt, gauge, hedgehog, hex-text, hspec
+     , hspec-expectations, HUnit, lens, lorentz, megaparsec, MonadRandom
+     , morley, morley-client, morley-prelude, mtl, named, o-clock
+     , optparse-applicative, safe-exceptions, servant-client
+     , servant-client-core, silently, singletons, spoon, statistics, syb
+     , tagged, tasty, tasty-ant-xml, tasty-discover, tasty-hedgehog
+     , tasty-hspec, tasty-hunit-compat, template-haskell, text, time
+     , type-spec, unordered-containers, vinyl, with-utf8
+     }:
+     mkDerivation {
+       pname = "cleveland";
+       version = "0.1.0";
+       sha256 = "0px16j08fakmxzsf6rgx9gs91g61ygxzkf7sngj06a76yzfj4hlw";
+       libraryHaskellDepends = [
+         aeson base-noprelude constraints containers criterion cryptonite
+         data-default directory either exceptions file-embed fmt hedgehog
+         hex-text hspec hspec-expectations HUnit lens lorentz MonadRandom
+         morley morley-client morley-prelude mtl named o-clock
+         optparse-applicative safe-exceptions servant-client-core singletons
+         statistics tagged tasty tasty-ant-xml tasty-hedgehog
+         tasty-hunit-compat template-haskell text time with-utf8
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty aeson-qq base-noprelude bimap bytestring
+         constraints containers data-default directory either filepath
+         first-class-families fmt hedgehog hex-text hspec hspec-expectations
+         HUnit lens lorentz megaparsec morley morley-client morley-prelude
+         mtl named o-clock servant-client silently singletons spoon syb
+         tasty tasty-hedgehog tasty-hspec tasty-hunit-compat text time
+         type-spec unordered-containers vinyl with-utf8
+       ];
+       testToolDepends = [ tasty-discover ];
+       benchmarkHaskellDepends = [
+         base-noprelude data-default gauge megaparsec morley morley-prelude
+         with-utf8
+       ];
+       description = "Testing framework for Morley";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "clevercss" = callPackage
     ({ mkDerivation, base, containers, mtl, parsec }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
-  "core-data_0_3_0_2" = callPackage
+  "core-data_0_3_1_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, core-text
      , hashable, prettyprinter, scientific, text, unordered-containers
      , vector
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.3.0.2";
-       sha256 = "0rfx7086ilv2rld2nnq96jkygvxxsnfs81mh4b4nmb4drdw02jl0";
+       version = "0.3.1.1";
+       sha256 = "0i11m2k1xb97f0plvp9g7l4zhp9d1njn9z7xfhcmghbvlkk82vx2";
        libraryHaskellDepends = [
          aeson base bytestring containers core-text hashable prettyprinter
          scientific text unordered-containers vector
···
        license = lib.licenses.mit;
      }) {};
 
-  "core-program_0_4_2_0" = callPackage
+  "core-program_0_4_4_0" = callPackage
     ({ mkDerivation, async, base, bytestring, chronologique, core-data
      , core-text, directory, exceptions, filepath, fsnotify, hashable
      , hourglass, mtl, prettyprinter, safe-exceptions, stm
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.4.2.0";
-       sha256 = "1xbfshfy6h7afpnlaafyq4mj3x0q4i83sxk6720k0dd0hhszb6b0";
+       version = "0.4.4.0";
+       sha256 = "1mp694llk3b04yqv8gr7i2rwcld99xmx1m55f5fhk1vgks816kih";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-text directory
          exceptions filepath fsnotify hashable hourglass mtl prettyprinter
···
   "core-telemetry" = callPackage
     ({ mkDerivation, async, base, bytestring, chronologique, core-data
      , core-program, core-text, exceptions, http-streams, io-streams
-     , locators, mtl, random, safe-exceptions, scientific, stm
-     , template-haskell, text, unix, uuid
+     , mtl, network-info, random, safe-exceptions, scientific, stm
+     , template-haskell, text, unix
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.1.8.1";
-       sha256 = "024npp0cm5f3v1h70iw03hv2lj0r2ylsp7w2pm1iv6zr8j63k1iy";
+       version = "0.1.9.1";
+       sha256 = "11b106gs96l20zb0lyr0qw49bnm8wxfc4wcncjaip6mdvgcc8cza";
        libraryHaskellDepends = [
          async base bytestring chronologique core-data core-program
-         core-text exceptions http-streams io-streams locators mtl random
-         safe-exceptions scientific stm template-haskell text unix uuid
+         core-text exceptions http-streams io-streams mtl network-info
+         random safe-exceptions scientific stm template-haskell text unix
        ];
        description = "Advanced telemetry";
        license = lib.licenses.mit;
···
      }) {};
 
   "deriving-trans" = callPackage
-    ({ mkDerivation, base, lifted-base, monad-control, mtl
-     , transformers, transformers-base
+    ({ mkDerivation, base, monad-control, mtl, transformers
+     , transformers-base
      }:
      mkDerivation {
        pname = "deriving-trans";
-       version = "0.1.0.0";
-       sha256 = "1yphl0wjp67b7hc3ys6snlvzk67by070p5vfmwcv7ic688vh1dw4";
+       version = "0.2.1.0";
+       sha256 = "114npy6rb24gsblncsgzdr1mfhnh8r2pblazvjz5l444h5im0ln2";
        libraryHaskellDepends = [
-         base lifted-base monad-control mtl transformers transformers-base
+         base monad-control mtl transformers transformers-base
        ];
-       description = "Derive transformer type classes with DerivingVia";
+       description = "Derive instances for monad transformer stacks";
        license = lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "diagrams-braille";
-       version = "0.1.0.2";
-       sha256 = "1jrhc8k0n9jabhg6rz22js9k3nj3v6r6klxskiksf6ajbqbzqg69";
+       version = "0.1.1";
+       sha256 = "1h9j1hrhpzl5rqhjnwp92sv0shc9i7yhnzpbs1dxfpyn8baws7mc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "diagrams-cairo";
-       version = "1.4.1.1";
-       sha256 = "0vyd2yr55n7x71194i18lnbcshdjpnqw4qyq7vj5zx377rsz711k";
-       revision = "3";
-       editedCabalFile = "16jm9g9rfc7d1dy2kwq3n9wfgcj8l6c0d54lym1r6b0arc7yjqlb";
+       version = "1.4.2";
+       sha256 = "094vavgsfn7hxn2h7phvmx82wdhw51vqqv29p8hsvmijf1gxa7c1";
        libraryHaskellDepends = [
          array base bytestring cairo colour containers data-default-class
          diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl
···
      }) {};
 
   "directory-contents" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, text
-     , transformers, witherable
+    ({ mkDerivation, base, containers, coquina, directory, filepath
+     , here, process, text, transformers, witherable
      }:
      mkDerivation {
        pname = "directory-contents";
-       version = "0.2.0.0";
-       sha256 = "15irmkg3ll6s3dqwl4hn7mmr5kygcl11slba3mzkdhlyg567is6x";
+       version = "0.2.0.1";
+       sha256 = "12c157lxqn910x7x3jwzv70fhb01bszxp0r00107igddrd6dqffv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base containers directory filepath text transformers witherable
        ];
        executableHaskellDepends = [ base filepath text ];
-       testHaskellDepends = [ base filepath ];
+       testHaskellDepends = [
+         base coquina directory filepath here process text
+       ];
        description = "Recursively build, navigate, and operate on a tree of directory contents";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "eflint";
-       version = "3.0.0.1";
-       sha256 = "1cij1g1mrw41dn4c63bzkahya3li9v7pkzisj0v129p6ckypv7cc";
-       revision = "1";
-       editedCabalFile = "10bi07ilvvmglbgsc1xf2fq4vsndrqh9d6c823d897s4didcv8rk";
+       version = "3.0.0.2";
+       sha256 = "14rhc9kmsb9krf5h8a8041pirp8mnlfc6kxidmdz2d4r4pd8yd8k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "fakedata_1_0_1" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
-     , directory, exceptions, fakedata-parser, filepath, gauge, hashable
-     , hspec, hspec-discover, QuickCheck, random, regex-tdfa
+  "fakedata_1_0_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , deepseq, directory, exceptions, fakedata-parser, filepath, gauge
+     , hashable, hspec, hspec-discover, QuickCheck, random, regex-tdfa
      , string-random, template-haskell, text, time, transformers
      , unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "fakedata";
-       version = "1.0.1";
-       sha256 = "08z3qhj93smpd2ksix3i7wcxqkz5533pkx9xf4xjq60qm99scmw6";
+       version = "1.0.2";
+       sha256 = "1xbp0wif3dfk4880f8lr8zj07jdqhbxalqm7bfpw6r0cv354w3l8";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         attoparsec base bytestring containers directory exceptions
+         aeson attoparsec base bytestring containers directory exceptions
          fakedata-parser filepath hashable random string-random
          template-haskell text time transformers unordered-containers vector
          yaml
        ];
        testHaskellDepends = [
-         attoparsec base bytestring containers directory exceptions
+         aeson attoparsec base bytestring containers directory exceptions
          fakedata-parser filepath hashable hspec QuickCheck random
          regex-tdfa string-random template-haskell text time transformers
          unordered-containers vector yaml
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
-         attoparsec base bytestring containers deepseq directory exceptions
-         fakedata-parser filepath gauge hashable random string-random
-         template-haskell text time transformers unordered-containers vector
-         yaml
+         aeson attoparsec base bytestring containers deepseq directory
+         exceptions fakedata-parser filepath gauge hashable random
+         string-random template-haskell text time transformers
+         unordered-containers vector yaml
        ];
        description = "Library for producing fake data";
        license = lib.licenses.bsd3;
···
        pname = "ghc-typelits-extra";
        version = "0.4.3";
        sha256 = "06g40q0n2d10c2zksx5rrjkvm5ywi3rh41hbiwy4zs28x9idsv18";
+       revision = "1";
+       editedCabalFile = "0m6z24zmi169zifz1jg4zri0izr5z37qx33c9mphy74vd6ds3zzz";
        libraryHaskellDepends = [
          base containers ghc ghc-prim ghc-tcplugins-extra
          ghc-typelits-knownnat ghc-typelits-natnormalise integer-gmp
···
      }:
      mkDerivation {
        pname = "graph-trace-dot";
-       version = "0.1.1.1";
-       sha256 = "11hwxccy7yaz3mwixp1gjlpdfi9525ydqlbmpgyasg9ndg7dvl8i";
-       revision = "1";
-       editedCabalFile = "0caa9xcxwrqzqwsl76kmwv3fq9klsnm7wamrwjs8lrliyxcriwl6";
+       version = "0.1.1.2";
+       sha256 = "0wq6addzcigp21f5caljszzwcr8rhws49s93yr156c35nlcw98jl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "has-transformers";
-       version = "0.1.0.3";
-       sha256 = "0mrz11hxm7nyxyirfz8f63w1mxf3snprrxvh2vvhmmi8p3wlay6n";
+       version = "0.1.0.4";
+       sha256 = "1wm8dwgcg1m2104lzgk3vdvng5mvh4xcn736nyarb9q6p99i0bq3";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [ base hspec operational ];
        testToolDepends = [ hspec-discover ];
···
     ({ mkDerivation, base, containers, imj-animation, imj-base
        version = "1.0.5";
     ({ mkDerivation, base, containers, imj-animation, imj-base
-       revision = "1";
-    ({ mkDerivation, base, containers, imj-animation, imj-base
+       revision = "2";
+       editedCabalFile = "1p6vixwflgz2y1fc94kqxiv8s5jvq63xhp56cqwpw2s7d7g5chx1";
        libraryHaskellDepends = [
     ({ mkDerivation, base, containers, imj-animation, imj-base
     ({ mkDerivation, base, containers, imj-animation, imj-base
···
        ];
     ({ mkDerivation, base, containers, imj-animation, imj-base
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
+  "hedgehog_1_1" = callPackage
+    ({ mkDerivation, ansi-terminal, async, barbies, base, bytestring
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+     }:
+     mkDerivation {
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+       version = "1.1";
+       sha256 = "1g05jw568lv02ikqhp2wyx52218b6rm7rxyh93cwrmbmgd2sxhsc";
+       revision = "1";
+       editedCabalFile = "19r528rsfzyfaz3xcwbi2zmf6sgzls2x61z24j3wfiicch30qk69";
+       libraryHaskellDepends = [
+         ansi-terminal async barbies base bytestring concurrent-output
+         containers deepseq directory erf exceptions lifted-async mmorph
+         monad-control mtl pretty-show primitive random resourcet stm
+         template-haskell text time transformers transformers-base
+         wl-pprint-annotated
+       ];
+       testHaskellDepends = [
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+       ];
+    ({ mkDerivation, base, containers, imj-animation, imj-base
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
···
     ({ mkDerivation, base, containers, imj-animation, imj-base
        version = "0.1.1";
     ({ mkDerivation, base, containers, imj-animation, imj-base
-       revision = "1";
-    ({ mkDerivation, base, containers, imj-animation, imj-base
+       revision = "2";
+       editedCabalFile = "1n7icqychb94j7s8msmih3h573vf17pn1sq79nkqric3wwf74rdp";
     ({ mkDerivation, base, containers, imj-animation, imj-base
     ({ mkDerivation, base, containers, imj-animation, imj-base
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http2_3_0_3" = 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.3";
+       sha256 = "1kv99i3pnnx31xndlkaczrpd2j5mvzbqlfz1kaw6cwlwkdnl5bhv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array async 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
+         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
···
        description = "Convenient imperative eDSL over Lorentz";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {cleveland = null;};
+     }) {};
 
   "inf-interval" = callPackage
     ({ mkDerivation, array, base, deepseq, QuickCheck, text, vector }:
···
        pname = "ipynb";
        version = "0.2";
        sha256 = "1iwia4sxg40m4d290gys72wabqmkqx24ywsaranwzk2wx5s3sx4s";
+       revision = "1";
+       editedCabalFile = "0fl9x5amq0g5dg57dcgc0g4ir0r1fdbx06aldsqdwzdc9zs97v6k";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring containers text
          unordered-containers
···
      }) {};
 
   "jacinda" = callPackage
-    ({ mkDerivation, alex, array, base, bytestring, containers, happy
-     , microlens, microlens-mtl, mtl, optparse-applicative
-     , prettyprinter, recursion, regex-rure, tasty, tasty-hunit, text
+    ({ mkDerivation, alex, array, base, bytestring, containers
+     , criterion, deepseq, directory, filepath, happy, microlens
+     , microlens-mtl, mtl, optparse-applicative, prettyprinter
+     , recursion, regex-rure, split, tasty, tasty-hunit, text
      , transformers, vector
      }:
      mkDerivation {
        pname = "jacinda";
-       version = "0.2.1.0";
-       sha256 = "0p7ng81dfilj277lq6sy6xb89jd8a0kr20wcndsqjg7pgp4rxpy2";
+       version = "0.3.0.0";
+       sha256 = "16m9gqswwqm66w1wynrivis51vhr6xh40gv12z6nf5w2dry8kljx";
        isLibrary = false;
        isExecutable = true;
+       enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         array base bytestring containers microlens microlens-mtl mtl
-         prettyprinter recursion regex-rure text transformers vector
+         array base bytestring containers directory filepath microlens
+         microlens-mtl mtl prettyprinter recursion regex-rure split text
+         transformers vector
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
          base bytestring optparse-applicative
        ];
        testHaskellDepends = [ base bytestring tasty tasty-hunit ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
        doHaddock = false;
        description = "Functional, expression-oriented data processing language";
        license = lib.licenses.agpl3Only;
···
      }:
      mkDerivation {
        pname = "koji-tool";
-       version = "0.6.1";
-       sha256 = "1l2w0dcy4fcv865z27661j7jmfy3blf8q321mv18dn44f3wr0xax";
+       version = "0.7";
+       sha256 = "1gyg76fajs7qc7mr86i0hiz5m4a0y2lqmqk67cb0glgbg53z47b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {egl = null; inherit (pkgs) glew;};
 
   "ktx-codec" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, directory
-     , filepath, shower, text, vector
+    ({ mkDerivation, base, binary, bytestring, containers, text, vector
      }:
      mkDerivation {
        pname = "ktx-codec";
-       version = "0.0.1.3";
-       sha256 = "0mm6lf8fm8zmi33s4zg8c3ar42aghdqmb3g7hv6qpcm1vc5krld4";
+       version = "0.0.1.4";
+       sha256 = "1n9vh7la5c359nczlla7jpf6qwbs6dx7n3fd9bnb4s2i6fpb5k0a";
        libraryHaskellDepends = [
          base binary bytestring containers text vector
-       ];
-       testHaskellDepends = [
-         base binary bytestring containers directory filepath shower text
-         vector
        ];
        description = "Khronos texture format";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "lorentz";
-       version = "0.13.1";
-       sha256 = "1cg2y15nz193s1mwm0c6x1z8nmdwv9n8qljl1a2irh3z3nb33sd2";
+       version = "0.13.2";
+       sha256 = "1kb611xj1rl8jbx3bibcqdklv8kls3xkis77vix2vdf6y6fhjhfr";
        libraryHaskellDepends = [
          aeson-pretty base-noprelude bimap bytestring constraints containers
          cryptonite data-default first-class-families fmt lens morley
···
      }:
      mkDerivation {
        pname = "mandrill";
-       version = "0.5.5.0";
-       sha256 = "1zq7kfs513zh7v5y4hafh5d6ly4jhmxsl3rfjavh2faw4i19fy3n";
+       version = "0.5.6.0";
+       sha256 = "1p58c83dqbpsl0a41s6xnnwbygk04gmsg51gfqprjkvzbgl2h7zq";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring containers
          email-validate http-client http-client-tls http-types microlens-th
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "memory-hexstring" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, memory, scale
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "memory-hexstring";
+       version = "1.0.0.0";
+       sha256 = "1sm7jj75mv8p7f33h619zm10xbzyjg1jds87cg36mrj8hfb32q48";
+       libraryHaskellDepends = [
+         aeson base bytestring memory scale template-haskell text
+       ];
+       description = "Hex-string type for Haskell Web3 library";
+       license = lib.licenses.asl20;
+     }) {};
+
   "memorypool" = callPackage
     ({ mkDerivation, base, containers, transformers, unsafe, vector }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "morley";
-       version = "1.16.1";
-       sha256 = "0kb4v5fwlxy80swqvjbrdc2qafiqrzw5zhihfjz4hc3vp5pcfizs";
+       version = "1.16.2";
+       sha256 = "1b236yp37pahx3njn0cwdbnkr7yj62ckhfsicgm2crb4l6sjkyas";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "morley-client" = callPackage
+    ({ mkDerivation, aeson, aeson-casing, base-noprelude, binary
+     , bytestring, co-log, co-log-core, colourista, constraints
+     , containers, data-default, exceptions, fmt, hex-text
+     , hspec-expectations, http-client, http-client-tls, http-types
+     , HUnit, lens, lorentz, megaparsec, memory, morley, morley-prelude
+     , mtl, named, optparse-applicative, process, random
+     , safe-exceptions, scientific, servant, servant-client
+     , servant-client-core, singletons, syb, tasty, tasty-ant-xml
+     , tasty-discover, tasty-hunit-compat, template-haskell, text
+     , th-reify-many, time, universum, unliftio, vector
+     }:
+     mkDerivation {
+       pname = "morley-client";
+       version = "0.1.0";
+       sha256 = "1xhmksv745dvf8axbihbdn9r9402na381czckab844whkdmnag0y";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-casing base-noprelude binary bytestring co-log
+         co-log-core colourista constraints containers data-default fmt
+         hex-text http-client http-client-tls http-types lens lorentz
+         megaparsec memory morley morley-prelude mtl named
+         optparse-applicative process random safe-exceptions scientific
+         servant servant-client servant-client-core singletons syb
+         template-haskell text th-reify-many time universum unliftio vector
+       ];
+       executableHaskellDepends = [
+         aeson base-noprelude data-default fmt morley morley-prelude
+         optparse-applicative safe-exceptions
+       ];
+       testHaskellDepends = [
+         aeson base-noprelude bytestring co-log co-log-core containers
+         exceptions fmt hex-text hspec-expectations http-types HUnit lens
+         lorentz memory morley morley-prelude safe-exceptions
+         servant-client-core singletons syb tasty tasty-ant-xml
+         tasty-hunit-compat template-haskell time
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Client to interact with the Tezos blockchain";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "morley-prelude" = callPackage
     ({ mkDerivation, base-noprelude, int-cast, lens, universum }:
      mkDerivation {
···
        description = "Upgradeability infrastructure based on Morley";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {cleveland = null; morley-client = null;};
+     }) {};
 
   "morloc" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
···
        testHaskellDepends = [ base hspec transformers ];
        description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "multistate_0_8_0_4" = callPackage
+    ({ mkDerivation, base, hspec, monad-control, mtl, tagged
+     , transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "multistate";
+       version = "0.8.0.4";
+       sha256 = "0y42c21ha0chqhrn40a4bikdbirsw7aqg4i866frpagz1ivr915q";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base monad-control mtl tagged transformers transformers-base
+       ];
+       testHaskellDepends = [ base hspec transformers ];
+       description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "multivariant" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "persistent-lens" = callPackage
+    ({ mkDerivation, base, lens, persistent }:
+     mkDerivation {
+       pname = "persistent-lens";
+       version = "1.0.0";
+       sha256 = "1pmk79m3p71sbcnzz27ji7305v4s8pbqghphl6nmkviswdy430xl";
+       libraryHaskellDepends = [ base lens persistent ];
+       description = "lens helpers for persistent";
+       license = lib.licenses.mit;
+     }) {};
+
   "persistent-map" = callPackage
     ({ mkDerivation, base, binary, containers, directory, EdisonAPI
      , EdisonCore, filepath, LRU, mtl, stm-io-hooks
···
        ];
        description = "Backend for the persistent library using MySQL database server";
        license = lib.licenses.mit;
+     }) {};
+
+  "persistent-mysql_2_13_0_3" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
+     , containers, fast-logger, hspec, http-api-data, HUnit
+     , monad-logger, mysql, mysql-simple, path-pieces, persistent
+     , persistent-qq, persistent-test, QuickCheck, quickcheck-instances
+     , resource-pool, resourcet, text, time, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "persistent-mysql";
+       version = "2.13.0.3";
+       sha256 = "0z4dpysridkssq3gmnh65mxa2acs1r7mhcbnsfgqk5gzqyzhfxr3";
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring conduit containers monad-logger
+         mysql mysql-simple persistent resource-pool resourcet text
+         transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers fast-logger hspec http-api-data
+         HUnit monad-logger mysql path-pieces persistent persistent-qq
+         persistent-test QuickCheck quickcheck-instances resourcet text time
+         transformers unliftio-core
+       ];
+       description = "Backend for the persistent library using MySQL database server";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-mysql-haskell" = callPackage
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
+     }) {};
+
+  "persistent-postgresql_2_13_3_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , conduit, containers, fast-logger, hspec, hspec-expectations
+     , hspec-expectations-lifted, http-api-data, HUnit, monad-logger
+     , mtl, path-pieces, persistent, persistent-qq, persistent-test
+     , postgresql-libpq, postgresql-simple, QuickCheck
+     , quickcheck-instances, resource-pool, resourcet
+     , string-conversions, text, time, transformers, unliftio
+     , unliftio-core, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "persistent-postgresql";
+       version = "2.13.3.0";
+       sha256 = "08br76dk1ilci5428z351n4ykvgazhbf9r8ny6kx95x5p7nifx0i";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder bytestring conduit containers
+         monad-logger mtl persistent postgresql-libpq postgresql-simple
+         resource-pool resourcet string-conversions text time transformers
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers fast-logger hspec
+         hspec-expectations hspec-expectations-lifted http-api-data HUnit
+         monad-logger path-pieces persistent persistent-qq persistent-test
+         QuickCheck quickcheck-instances resourcet text time transformers
+         unliftio unliftio-core unordered-containers vector
+       ];
+       description = "Backend for the persistent library using postgresql";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-postgresql-streaming" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ptera" = callPackage
+    ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
+     , enummapset-th, hspec, hspec-discover, membership, ptera-core
+     , QuickCheck, unordered-containers
+     }:
+     mkDerivation {
+       pname = "ptera";
+       version = "0.1.0.0";
+       sha256 = "1bcbv740rvhibmkvyp097nm1f07ira8i9anq4m3vd6gp96mbin48";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base containers enummapset-th membership ptera-core
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         base containers doctest enummapset-th hspec membership ptera-core
+         QuickCheck unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A parser generator";
+       license = "(Apache-2.0 OR MPL-2.0)";
+     }) {};
+
+  "ptera-core" = callPackage
+    ({ mkDerivation, array, base, Cabal, cabal-doctest, containers
+     , doctest, enummapset-th, hashable, hspec, hspec-discover
+     , membership, QuickCheck, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "ptera-core";
+       version = "0.1.0.0";
+       sha256 = "1bpgnd68c070i1azig6r0ck843hvxjcg17yhmy3nizm1bx4nppk1";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array base containers enummapset-th hashable membership
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         array base containers doctest enummapset-th hashable hspec
+         membership QuickCheck transformers unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A parser generator";
+       license = "(Apache-2.0 OR MPL-2.0)";
+     }) {};
+
+  "ptera-th" = callPackage
+    ({ mkDerivation, array, base, Cabal, cabal-doctest, containers
+     , doctest, enummapset-th, ghc-prim, hspec, hspec-discover
+     , membership, ptera, ptera-core, QuickCheck, template-haskell
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "ptera-th";
+       version = "0.1.0.0";
+       sha256 = "1sbgyq5gf9fyam0gazjr1gc49fv8s9rsd8rkb9pbpfi258yzj7pr";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array base containers enummapset-th ghc-prim membership ptera
+         ptera-core template-haskell unordered-containers
+       ];
+       testHaskellDepends = [
+         array base containers doctest enummapset-th ghc-prim hspec
+         membership ptera ptera-core QuickCheck template-haskell
+         unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A parser generator";
+       license = "(Apache-2.0 OR MPL-2.0)";
+     }) {};
+
   "pthread" = callPackage
     ({ mkDerivation, base, generic-deriving, hspec, hspec-discover }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "regex-rure";
-       version = "0.1.1.0";
-       sha256 = "1ap1cpm82dv9q9w8y6cf0rp9f5zvspnql9zr35fknaxaskr86zgj";
+       version = "0.1.2.0";
+       sha256 = "1my3rmj2766bd00qg25wijgvw7ffk8fq965y2b97s5v00fjds33r";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ rure ];
        libraryToolDepends = [ c2hs ];
···
      }:
      mkDerivation {
        pname = "reqcatcher";
-       version = "0.2.2.1";
-       sha256 = "0xc8ffz46m3hn7v9vjslh5z7yzqcbyijqfk8wl629539nishgsl9";
+       version = "0.2.2.2";
+       sha256 = "12p2mb215n7f0smczr5cfxkd89blchyyp5dsl6yzfij1ykf0yr9x";
        libraryHaskellDepends = [ base http-types network text wai warp ];
        testHaskellDepends = [
          base http-client http-types HUnit lens tasty tasty-hunit wai wreq
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "retry_0_9_0_0" = callPackage
+  "retry_0_9_1_0" = callPackage
     ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl
      , random, stm, tasty, tasty-hedgehog, tasty-hunit, time
      , transformers
      }:
      mkDerivation {
        pname = "retry";
-       version = "0.9.0.0";
-       sha256 = "0n304r6vyx238558z62kz7nii8y58h2z4iyx54gbkxmz9dsck4ff";
+       version = "0.9.1.0";
+       sha256 = "1scrkd6bd061h8s4d7sjs21m2ydz2mxiw95gs72rliikh2k3cj7v";
        libraryHaskellDepends = [
          base exceptions ghc-prim random transformers
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "scale" = callPackage
+    ({ mkDerivation, base, bitvec, bytestring, cereal, data-default
+     , generics-sop, hspec, hspec-contrib, hspec-discover
+     , hspec-expectations, memory, template-haskell, text, vector
+     }:
+     mkDerivation {
+       pname = "scale";
+       version = "1.0.0.0";
+       sha256 = "1c1khgy83402lqfqdvq5amf9pgn5a6m4m5zmqkkw6iw0wbjw7p3a";
+       libraryHaskellDepends = [
+         base bitvec bytestring cereal data-default generics-sop memory
+         template-haskell text vector
+       ];
+       testHaskellDepends = [
+         base bitvec bytestring cereal data-default generics-sop hspec
+         hspec-contrib hspec-discover hspec-expectations memory
+         template-haskell text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "SCALE v2.0 codec for Haskell Web3 library.";
+       license = lib.licenses.asl20;
+     }) {};
+
   "scaleimage" = callPackage
     ({ mkDerivation, base, filepath, gd }:
      mkDerivation {
···
        pname = "special-values";
        version = "0.1.0.0";
        sha256 = "1kkdw2c4d2hha99v9f89ahmifjxp7fxmxyfwq9a8xk6s0h9xs51w";
-       revision = "1";
-       editedCabalFile = "10pbx4px4kmg6nwb78bayi26dlzbzvji5zv9fa6f45rk19p2sdlc";
+       revision = "2";
+       editedCabalFile = "1vv5gydjd65jniifl3mnch8bzvpvdahi913gsa3kv5zijwhad699";
        libraryHaskellDepends = [
          base bytestring ieee754 scientific text
        ];
···
      }:
      mkDerivation {
        pname = "streamly-examples";
-       version = "0.1.0";
-       sha256 = "0ny22z33wwkg9bbziwcj77k6gb8lwj1v0y5z6mw8sw20k4ca93q3";
+       version = "0.1.1";
+       sha256 = "174283sarx0ccjzzxill9l06hi7g9jz76sxwlb4fyc03db5q027i";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) lmdb;};
 
-  "streamly-lmdb_0_3_0" = callPackage
+  "streamly-lmdb_0_4_0" = callPackage
     ({ mkDerivation, async, base, bytestring, directory, lmdb
      , QuickCheck, streamly, tasty, tasty-quickcheck, temporary
      }:
      mkDerivation {
        pname = "streamly-lmdb";
-       version = "0.3.0";
-       sha256 = "1da87rbmh9sgffjy5367pzy1d80f7zlxhszi9sq87jfws4i20pk7";
+       version = "0.4.0";
+       sha256 = "10749fl4dgm89z1d6sas1ngwxkkfl385465yxnrhxcc63wz53p5d";
        libraryHaskellDepends = [ async base bytestring streamly ];
        librarySystemDepends = [ lmdb ];
        testHaskellDepends = [
···
        pname = "tasty-hedgehog";
        version = "1.1.0.0";
        sha256 = "0cy49z8n124xh2ra2482vfy5if1n6d9lbdjma2zg1mxfj0k0zyfb";
-       revision = "1";
-       editedCabalFile = "0zn29qgsb5v4y7s4lrrhav9wqaz6pm97rcj1gl88qvvvi000jjbx";
+       revision = "2";
+       editedCabalFile = "08in0mli87szyx9lz2lcz3m1q0d3sxzzk5srzkkx4d10fgr6g6xv";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
        license = lib.licenses.mit;
      }) {};
 
+  "unliftio_0_2_20_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , directory, filepath, gauge, hspec, process, QuickCheck, stm, time
+     , transformers, unix, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio";
+       version = "0.2.20.1";
+       sha256 = "13fv7wfq7g1pilpk1vprbf2mbdj7qfm2y9v8glwr6dqyswv8z9dn";
+       libraryHaskellDepends = [
+         async base bytestring deepseq directory filepath process stm time
+         transformers unix unliftio-core
+       ];
+       testHaskellDepends = [
+         async base bytestring containers deepseq directory filepath hspec
+         process QuickCheck stm time transformers unix unliftio-core
+       ];
+       benchmarkHaskellDepends = [
+         async base bytestring deepseq directory filepath gauge process stm
+         time transformers unix unliftio-core
+       ];
+       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unliftio-core" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
      }) {};
 
   "web3" = callPackage
-    ({ mkDerivation, aeson, async, attoparsec, base, base58string
-     , basement, bitvec, bytestring, cereal, cryptonite, data-default
-     , errors, exceptions, generics-sop, hspec, hspec-contrib
-     , hspec-discover, hspec-expectations, http-client, http-client-tls
-     , http-media, http-types, machines, memory, microlens
-     , microlens-aeson, microlens-mtl, microlens-th, mtl, network
-     , OneTuple, parsec, random, relapse, servant, servant-client, split
-     , stm, tagged, tar, template-haskell, text, time, transformers
-     , unordered-containers, uuid-types, vector, vinyl, websockets
+    ({ mkDerivation, base, web3-ethereum, web3-polkadot, web3-provider
      }:
      mkDerivation {
        pname = "web3";
-       version = "0.9.1.0";
-       sha256 = "12nx9hgwx61yj44iym7na9jxf05jry3aa82j2s8l5rpw3qdv7dis";
+       version = "1.0.0.0";
+       sha256 = "0bnamwvdxl3i1p8bflnhaxxpn0bqcnf174gwplqjkxdc9pzfhiig";
+       libraryHaskellDepends = [
+         base web3-ethereum web3-polkadot web3-provider
+       ];
+       description = "Haskell Web3 library";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "web3-bignum" = callPackage
+    ({ mkDerivation, base, cereal, hspec, hspec-contrib, hspec-discover
+     , hspec-expectations, memory, memory-hexstring, scale, wide-word
+     }:
+     mkDerivation {
+       pname = "web3-bignum";
+       version = "1.0.0.0";
+       sha256 = "140qv8y6b63by81z0k5by8vqr7x0gc106a67r35qbhdfmbhv71n0";
        libraryHaskellDepends = [
-         aeson async attoparsec base base58string basement bitvec bytestring
-         cereal cryptonite data-default errors exceptions generics-sop hspec
-         http-client http-client-tls http-media http-types machines memory
-         microlens microlens-aeson microlens-mtl microlens-th mtl network
-         OneTuple parsec relapse servant servant-client tagged tar
-         template-haskell text transformers unordered-containers uuid-types
-         vector vinyl websockets
+         base cereal memory memory-hexstring scale wide-word
        ];
        testHaskellDepends = [
-         aeson async attoparsec base base58string basement bitvec bytestring
-         cereal cryptonite data-default errors exceptions generics-sop hspec
-         hspec-contrib hspec-discover hspec-expectations http-client
-         http-client-tls http-media http-types machines memory microlens
-         microlens-aeson microlens-mtl microlens-th mtl network OneTuple
-         parsec random relapse servant servant-client split stm tagged tar
-         template-haskell text time transformers unordered-containers
-         uuid-types vector vinyl websockets
+         base cereal hspec hspec-contrib hspec-discover hspec-expectations
+         memory memory-hexstring scale wide-word
        ];
        testToolDepends = [ hspec-discover ];
-       description = "Web3 API for Haskell";
-       license = lib.licenses.bsd3;
+       description = "Fixed size big integers for Haskell Web3 library";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "web3-crypto" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, cryptonite
+     , hspec, hspec-contrib, hspec-discover, hspec-expectations, memory
+     , memory-hexstring, text, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "web3-crypto";
+       version = "1.0.0.0";
+       sha256 = "16ygvnkxcalh7a0h7l1bj5gyir79gihcwzzqk31qibvd1r17mwd6";
+       libraryHaskellDepends = [
+         aeson base bytestring containers cryptonite memory memory-hexstring
+         text uuid-types vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers cryptonite hspec hspec-contrib
+         hspec-discover hspec-expectations memory memory-hexstring text
+         uuid-types vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Cryptograhical primitives for Haskell Web3 library";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "web3-ethereum" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default, exceptions
+     , generics-sop, hspec, hspec-contrib, hspec-discover
+     , hspec-expectations, jsonrpc-tinyclient, machines, memory
+     , memory-hexstring, microlens, microlens-aeson, mtl, OneTuple
+     , relapse, tagged, template-haskell, text, transformers, vinyl
+     , web3-crypto, web3-solidity
+     }:
+     mkDerivation {
+       pname = "web3-ethereum";
+       version = "1.0.0.0";
+       sha256 = "1vsvxhl6w6hjiv6b61sn8f2bnj6p55b4qyvblrfpk60k7pqq774c";
+       libraryHaskellDepends = [
+         aeson base bytestring data-default exceptions generics-sop
+         jsonrpc-tinyclient machines memory memory-hexstring microlens
+         microlens-aeson mtl OneTuple relapse tagged template-haskell text
+         transformers vinyl web3-crypto web3-solidity
+       ];
+       testHaskellDepends = [
+         aeson base bytestring data-default exceptions generics-sop hspec
+         hspec-contrib hspec-discover hspec-expectations jsonrpc-tinyclient
+         machines memory memory-hexstring microlens microlens-aeson mtl
+         OneTuple relapse tagged template-haskell text transformers vinyl
+         web3-crypto web3-solidity
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Ethereum support for Haskell Web3 library";
+       license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "web3-ipfs" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-client, http-media
+     , http-types, mtl, servant, servant-client, tar, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "web3-ipfs";
+       version = "1.0.0.0";
+       sha256 = "0m6rqk5vd53gl7mykwzzqblhgdqrjzjyqb5mqkagb1z0llwqxafg";
+       libraryHaskellDepends = [
+         aeson base bytestring http-client http-media http-types mtl servant
+         servant-client tar text unordered-containers
+       ];
+       description = "IPFS support for Haskell Web3 library";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "web3-polkadot" = callPackage
+    ({ mkDerivation, aeson, animalcase, base, base58-bytestring
+     , bytestring, containers, cryptonite, generics-sop, hspec
+     , hspec-contrib, hspec-discover, hspec-expectations
+     , hspec-expectations-json, jsonrpc-tinyclient, memory
+     , memory-hexstring, microlens, microlens-mtl, microlens-th, mtl
+     , parsec, scale, text, web3-bignum, web3-crypto
+     }:
+     mkDerivation {
+       pname = "web3-polkadot";
+       version = "1.0.0.0";
+       sha256 = "0sx9lj7px6m5ag4bk4imllh4bmy7kfgkfy1zb9hqjkdmjwn2i2w5";
+       libraryHaskellDepends = [
+         aeson animalcase base base58-bytestring bytestring containers
+         cryptonite generics-sop jsonrpc-tinyclient memory memory-hexstring
+         microlens microlens-mtl microlens-th mtl parsec scale text
+         web3-bignum web3-crypto
+       ];
+       testHaskellDepends = [
+         aeson animalcase base base58-bytestring bytestring containers
+         cryptonite generics-sop hspec hspec-contrib hspec-discover
+         hspec-expectations hspec-expectations-json jsonrpc-tinyclient
+         memory memory-hexstring microlens microlens-mtl microlens-th mtl
+         parsec scale text web3-bignum web3-crypto
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Polkadot support for Haskell Web3 library";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "web3-provider" = callPackage
+    ({ mkDerivation, async, base, data-default, exceptions, http-client
+     , jsonrpc-tinyclient, mtl, network, text, transformers, websockets
+     }:
+     mkDerivation {
+       pname = "web3-provider";
+       version = "1.0.0.0";
+       sha256 = "03c892xj7yxwbb4r1vpqzwgsf4fyk9389rqivpr6bwklnx9230ic";
+       libraryHaskellDepends = [
+         async base data-default exceptions http-client jsonrpc-tinyclient
+         mtl network text transformers websockets
+       ];
+       description = "Node connection provider for Haskell Web3 library";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "web3-solidity" = callPackage
+    ({ mkDerivation, aeson, base, basement, bytestring, cereal
+     , data-default, generics-sop, hspec, hspec-contrib, hspec-discover
+     , hspec-expectations, memory, memory-hexstring, microlens, OneTuple
+     , parsec, tagged, template-haskell, text, web3-crypto
+     }:
+     mkDerivation {
+       pname = "web3-solidity";
+       version = "1.0.0.0";
+       sha256 = "1n5jf9vdxps8sxcaa3k2a4m3qn5w3kphvvn7f4jy0dh0zkr7i5nm";
+       libraryHaskellDepends = [
+         aeson base basement bytestring cereal data-default generics-sop
+         memory memory-hexstring microlens OneTuple parsec tagged
+         template-haskell text web3-crypto
+       ];
+       testHaskellDepends = [
+         aeson base basement bytestring cereal data-default generics-sop
+         hspec hspec-contrib hspec-discover hspec-expectations memory
+         memory-hexstring microlens OneTuple parsec tagged template-haskell
+         text web3-crypto
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Solidity language for Haskell Web3 library";
+       license = lib.licenses.asl20;
      }) {};
 
   "webapi" = callPackage

pkgs/development/interpreters/rakudo/zef.nix

···
 
 stdenv.mkDerivation rec {
   pname = "zef";
-  version = "0.13.4";
+  version = "0.13.6";
 
   src = fetchFromGitHub {
     owner = "ugexe";
     repo = "zef";
     rev = "v${version}";
-    sha256 = "sha256-zTgXMICuLn612bmL5e6GP5aBQ4uOcSLfce0PCRYGob0=";
+    sha256 = "sha256-Bios3h2bcR6PntFt6JWF7l5u6gjKaljS8HsKfTf+0X8=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/libraries/science/astronomy/indilib/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "indilib";
-  version = "1.9.3";
+  version = "1.9.4";
 
   src = fetchFromGitHub {
     owner = "indilib";
     repo = "indi";
     rev = "v${version}";
-    sha256 = "sha256-Ik62kbOetA2vSMpnwrSiNRNJqOgmqlCB2+KNhpBo9TA=";
+    sha256 = "sha256-U3Q0WUEDRn0zfBIdHXFp5Zcaf+M6HrSFnpeu5aAkjks=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/soci/default.nix

···
 { cmake
 , fetchFromGitHub
+, fetchpatch
 , sqlite
 , postgresql
 , boost
···
     rev = "v${version}";
     sha256 = "sha256-NE0ApbX8HG2VAQ9cg9+kX3kJQ4PR1XvWL9BlT8NphmE=";
   };
+
+  patches = [
+    (fetchpatch {
+      name = "fix-backend-search-path.patch";
+      url = "https://github.com/SOCI/soci/commit/56c93afc467bdba8ffbe68739eea76059ea62f7a.patch";
+      sha256 = "sha256-nC/39pn3Cv5e65GgIfF3l64/AbCsfZHPUPIWETZFZAY=";
+    })
+  ];
 
   # Do not build static libraries
   cmakeFlags = [ "-DSOCI_STATIC=OFF" "-DCMAKE_CXX_STANDARD=11" ];

pkgs/development/php-packages/maxminddb/default.nix

···
     sha256 = "sha256-Dw1+pYJmZ3U2+rgSOEkx4a6HB8FebSr7YZodOjSipjI=";
   };
 
+  prePatch = ''
+    cd ext
+  '';
+
   buildInputs = [ libmaxminddb ];
-  sourceRoot = "source/ext";
 
   meta = with lib; {
     description = "C extension that is a drop-in replacement for MaxMind\\Db\\Reader";

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

···
 
 buildPythonPackage rec {
   pname = "treq";
-  version = "21.5.0";
+  version = "22.1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "02ea86383fc4b57539c45a965eaa1e9fd28302cdf382d21da8430050c97be9b8";
+    sha256 = "sha256-d1WBYEkZo9echFQBWYoP0HDKvG3oOEBHLY6fpxXy02w=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/types-urllib3/default.nix

···
 
 buildPythonPackage rec {
   pname = "types-urllib3";
-  version = "1.26.7";
+  version = "1.26.8";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-z9H7vkuppgXtFIKUAIqsinuLdHJlHRzDV9UHrlli49I=";
+    hash = "sha256-qg3iaJPxOFI9VVK7sCOCbAzH6ldJ2AwWk8V6q3tV9Gk=";
   };
 
   # Module doesn't have tests

pkgs/development/tools/konstraint/default.nix

···
 
 buildGoModule rec {
   pname = "konstraint";
-  version = "0.15.1";
+  version = "0.16.0";
 
   src = fetchFromGitHub {
     owner = "plexsystems";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-vt8/hYsThBoAxMglF8pjdVphmkbHXsuzaHFJhnGXdU4=";
+    sha256 = "sha256-j1rVkI5hXYtY0jtP+i/yRw1sS3iN3KyVI4gV9fNdj/E=";
   };
-  vendorSha256 = "sha256-3m+mN90Edb/yMgVmkokRQrDM2EdB7cb2opL0QZJ8L+U=";
+  vendorSha256 = "sha256-oYIUeHMEK55mCkf5cb5ECCU5y6tUZAM258sINrBl9kM=";
 
   # Exclude go within .github folder
   excludedPackages = ".github";

pkgs/development/tools/pipenv/default.nix

···
 
 in buildPythonApplication rec {
   pname = "pipenv";
-  version = "2021.11.23";
+  version = "2022.1.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1bde859e8bbd1d21d503fd995bc0170048d6da7686ab885f074592c99a16e8f3";
+    sha256 = "f84d7119239b22ab2ac2b8fbc7d619d83cf41135206d72a17c4f151cda529fd0";
   };
 
   LC_ALL = "en_US.UTF-8";

pkgs/misc/emulators/wxmupen64plus/default.nix

···
-{ lib, stdenv, fetchurl, python2, wxGTK29, mupen64plus, SDL, libX11, libGLU, libGL
-, wafHook }:
-
-stdenv.mkDerivation rec {
-  pname = "wxmupen64plus";
-  version = "0.3";
-
-  src = fetchurl {
-    url = "https://bitbucket.org/auria/wxmupen64plus/get/${version}.tar.bz2";
-    sha256 = "1mnxi4k011dd300k35li2p6x4wccwi6im21qz8dkznnz397ps67c";
-  };
-
-  nativeBuildInputs = [ wafHook ];
-  buildInputs = [ python2 wxGTK29 SDL libX11 libGLU libGL ];
-
-  preConfigure = ''
-    tar xf ${mupen64plus.src}
-    APIDIR=$(eval echo `pwd`/mupen64plus*/source/mupen64plus-core/src/api)
-    export CXXFLAGS="-I${libX11.dev}/include/X11 -DLIBDIR=\\\"${mupen64plus}/lib/\\\""
-    export LDFLAGS="-lwx_gtk2u_adv-2.9"
-
-    wafConfigureFlagsArray+=("--mupenapi=$APIDIR" "--wxconfig=`type -P wx-config`")
-  '';
-
-  NIX_CFLAGS_COMPILE = "-fpermissive";
-
-  meta = {
-    description = "GUI for the Mupen64Plus 2.0 emulator";
-    license = lib.licenses.gpl2Plus;
-    homepage = "https://bitbucket.org/auria/wxmupen64plus/wiki/Home";
-  };
-}

pkgs/misc/vim-plugins/generated.nix

···
 
   aerial-nvim = buildVimPluginFrom2Nix {
     pname = "aerial.nvim";
-    version = "2022-01-26";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "aerial.nvim";
-      rev = "95916d1b5f171eb44faf54bb414f48856ec96aa6";
-      sha256 = "14a4h0h6g8rkglhn3f77s3bil63y1vz1qnd03026r8bhzcdbqn3j";
+      rev = "98a33857ac1baf1b1fc656a3ca5b0318cf03c3d5";
+      sha256 = "1zzl1zs4qrcjw3fskszqj62s59jggm7hbkchxkf92fqsgck323mx";
     };
     meta.homepage = "https://github.com/stevearc/aerial.nvim/";
   };
···
 
   auto-session = buildVimPluginFrom2Nix {
     pname = "auto-session";
-    version = "2022-01-15";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "rmagatti";
       repo = "auto-session";
-      rev = "486e23f024a21c952758726497244e27aa3b9f0e";
-      sha256 = "1sxg9gr329zlccm8xh8zv3n26s72mikqh4aik5l1hdx663afqc0d";
+      rev = "5860ae9369c86332ec45b38ab8308b9a4afb272c";
+      sha256 = "0klwbjgxqddw5apqzrx9fsqk25xy6nbaplx4fw68x6z0c63dbvsa";
     };
     meta.homepage = "https://github.com/rmagatti/auto-session/";
   };
···
 
   bufexplorer = buildVimPluginFrom2Nix {
     pname = "bufexplorer";
-    version = "2022-01-06";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "jlanzarotta";
       repo = "bufexplorer";
-      rev = "4d46f80734a1f6854942f78fcbf2163b959b8ab0";
-      sha256 = "1hzbxpz3yz3z7fxj7imd4l3aznrxcx1fnhf39gg2xqzk8j1yspwx";
+      rev = "b3a24722bea9029b4c37eb0547b87152d514c66f";
+      sha256 = "14114786fkqjzpl3aqsk2lmfnlhxzdkkanv6ls6q0cwvpqdng6wc";
     };
     meta.homepage = "https://github.com/jlanzarotta/bufexplorer/";
   };
···
 
   chadtree = buildVimPluginFrom2Nix {
     pname = "chadtree";
-    version = "2022-01-27";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "chadtree";
-      rev = "723d926f75680badc6cb95ba69668324833be8a3";
-      sha256 = "19wxzny2xha79ajjqwya5c20nlpmn584g97i0j9y83fvcx1bljs6";
+      rev = "53778b6820ef3e1b38d923c75183253caa4ffd90";
+      sha256 = "1zd0x10d5frmaxgr58crldf98j48lnj5jgzd05myjni2bmaniqyn";
     };
     meta.homepage = "https://github.com/ms-jpq/chadtree/";
   };
···
 
   coc-nvim = buildVimPluginFrom2Nix {
     pname = "coc.nvim";
-    version = "2022-01-25";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "neoclide";
       repo = "coc.nvim";
-      rev = "873b5942be70bb00541b995d501ac7c96ae5b185";
-      sha256 = "181drp1dyrprfv7ljprmyh1mn1nqdqw4c2lb4kna5qh9bfg6051i";
+      rev = "679b32cee056b49fbf81b9fd543ce13b2c5e03e7";
+      sha256 = "15kk2ggspq9sdwaym1r46x0pkr2hvv58mxkwxpjdkcyhmhcnp3z5";
     };
     meta.homepage = "https://github.com/neoclide/coc.nvim/";
   };
···
 
   comment-nvim = buildVimPluginFrom2Nix {
     pname = "comment.nvim";
-    version = "2022-01-26";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "numtostr";
       repo = "comment.nvim";
-      rev = "7365bfe9fc6dc004cc97b8977aa8129999d81bf5";
-      sha256 = "160pd7d2n66p3nxjp80sm6qhxlcmsg6nlv79ssyi9sxh1z27qm0l";
+      rev = "22e71071d9473996563464fde19b108e5504f892";
+      sha256 = "0arjg84z2lly1j7r0fwj4kdl23f6w51ckjzqll463fmr4jx387ir";
     };
     meta.homepage = "https://github.com/numtostr/comment.nvim/";
   };
···
 
   coq_nvim = buildVimPluginFrom2Nix {
     pname = "coq_nvim";
-    version = "2022-01-27";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq_nvim";
-      rev = "120fcb4231fb8f9852a7c366c183b300ffcf5aef";
-      sha256 = "0b29qdgwglj84m4brpn3ic6pdky3xhjnw3mgb97slb7vqkpq450y";
+      rev = "c254d54bf073c1875817a227fcccd502b7774b08";
+      sha256 = "1rrfav3ffxyhl2fa9ygdn8y5y99nxbmcvxy4zskiaarjbv9n88jb";
     };
     meta.homepage = "https://github.com/ms-jpq/coq_nvim/";
   };
 
   Coqtail = buildVimPluginFrom2Nix {
     pname = "Coqtail";
-    version = "2022-01-25";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "whonore";
       repo = "Coqtail";
-      rev = "9d386079d0fb5598598a3bbbe62cfba96e764ce2";
-      sha256 = "0rg97cqp91cj6czhs6fjk5xw1ydxazvm3dqn01n7l2bngbx44b0j";
+      rev = "106f292c4f9e60044d86497096831c48039921de";
+      sha256 = "0kxj9l0pby79zpm050wmqv4hv4wsgm8npvsb5flpsba1ws850vq6";
     };
     meta.homepage = "https://github.com/whonore/Coqtail/";
   };
···
 
   defx-nvim = buildVimPluginFrom2Nix {
     pname = "defx.nvim";
-    version = "2022-01-03";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "Shougo";
       repo = "defx.nvim";
-      rev = "10fa80481a9489be1ad38ceff84e357a5a4c416b";
-      sha256 = "10nqgha8p25n79sgi5arw79pr59q6wldm6s8c876l6al3111971n";
+      rev = "c3417f30029c384c73aeccb1084f21c14b4bae45";
+      sha256 = "0dc0w8j4fhbh86vmibi9wx146r79sv2yvsqczp28hqinwss6j68b";
     };
     meta.homepage = "https://github.com/Shougo/defx.nvim/";
   };
···
 
   fidget-nvim = buildVimPluginFrom2Nix {
     pname = "fidget.nvim";
-    version = "2022-01-26";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "j-hui";
       repo = "fidget.nvim";
-      rev = "66c5ba6ea5f9da9e6a9ef0da07ab594768d5bd39";
-      sha256 = "0065rw25rw4r7bnh80z6bis543zynk961w28dqz7pp1x3i4h9lmg";
+      rev = "2e91adf6667f1cafa9d0be51594fa3366534923f";
+      sha256 = "0rp820akrmj83csgajdlabh4y5xh2aiv8kiz7lma32pb0rmcm2lf";
     };
     meta.homepage = "https://github.com/j-hui/fidget.nvim/";
   };
···
 
   fzf-vim = buildVimPluginFrom2Nix {
     pname = "fzf.vim";
-    version = "2022-01-24";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "junegunn";
       repo = "fzf.vim";
-      rev = "91332acb1c48e7080539c5b5cd131816341c738c";
-      sha256 = "0s8695m25v2j5hpp80g3hd28g7ja17yxih5cd71jqmqvl3zwmqrg";
+      rev = "70541d2ee0bfd8998ef0f252bb93b660cf94fe14";
+      sha256 = "0sd3qg58nc0b5ydk2j8ypx707i405n4axm7f7h8ndj33bx2rapl1";
     };
     meta.homepage = "https://github.com/junegunn/fzf.vim/";
   };
···
 
   git-blame-nvim = buildVimPluginFrom2Nix {
     pname = "git-blame.nvim";
-    version = "2022-01-26";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "f-person";
       repo = "git-blame.nvim";
-      rev = "d1412ddfadc845f6a98789d7583b2bd428bae14f";
-      sha256 = "0r4c2a0fv8y5r97yg37p2v7v1ab6hvwrq5knn2ya29b1am6zzhi3";
+      rev = "e605e848885b184aa6af451fce20f68126dc1180";
+      sha256 = "19nr21mzw9bfzb2snji6idckvbahybpbsqdjlfk0a1hymvp8q9vr";
     };
     meta.homepage = "https://github.com/f-person/git-blame.nvim/";
   };
···
 
   gitlinker-nvim = buildVimPluginFrom2Nix {
     pname = "gitlinker.nvim";
-    version = "2022-01-10";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "ruifm";
       repo = "gitlinker.nvim";
-      rev = "e83ebb3465fb224df394477a0d68a61094d3f7b9";
-      sha256 = "0442yi5j1fdzh2wmyn59z9mzyzsja0j0dkialj4gzlsglg6ndbai";
+      rev = "ff33d07bb64e104b387fff7d91650a35274f81ea";
+      sha256 = "1sxhcbww0f780lp0zda1iaiyp89c6cirs0ncihjxr106a47zpya4";
     };
     meta.homepage = "https://github.com/ruifm/gitlinker.nvim/";
   };
 
   gitsigns-nvim = buildVimPluginFrom2Nix {
     pname = "gitsigns.nvim";
-    version = "2022-01-26";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "lewis6991";
       repo = "gitsigns.nvim";
-      rev = "4a2d30f5fb77750c7a42be9bb58a9cc2c6c7f31d";
-      sha256 = "0w105nggv6k2b22hkhlh7j19fp6gra70i3skaq1gihhh0x0h5pav";
+      rev = "2fa3716bc4690da96d885becdf9988603f0756f0";
+      sha256 = "12mdyrzw1aqjdcsqq6jfgd0sldi0hvdz24d64jxymyfz8z3xksam";
     };
     meta.homepage = "https://github.com/lewis6991/gitsigns.nvim/";
   };
···
 
   gruvbox-nvim = buildVimPluginFrom2Nix {
     pname = "gruvbox.nvim";
-    version = "2022-01-10";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "ellisonleao";
       repo = "gruvbox.nvim";
-      rev = "ba2a3592174c19d6f3231d06723606f6ca33fc23";
-      sha256 = "0qcc0f4lky8if91faw6923sdpgvr67nsfgfb1mqmhriwvq02l46y";
+      rev = "d4d0c6e66c1f4d5bdc0cb216c882d88d223a4187";
+      sha256 = "0s12sxhpk59r8a12df0zbhbmj6djffqmh1pw2fhw392zrb1549m8";
     };
     meta.homepage = "https://github.com/ellisonleao/gruvbox.nvim/";
   };
···
 
   hoon-vim = buildVimPluginFrom2Nix {
     pname = "hoon.vim";
-    version = "2020-11-09";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "urbit";
       repo = "hoon.vim";
-      rev = "91b1922f8627bb0a55341bb088f2526d0f43a6ac";
-      sha256 = "0h87r7r74iljwvfc6mb1maa08cxwnk6k89gc6vnwqm1zx6qxw1js";
+      rev = "f287adb9ce5f99a2a8b806833ab1582ba162aab0";
+      sha256 = "0nlmcz79qcmrkfji5mdc66p1pxrz5i68m50013fr66zqcccnynjk";
     };
     meta.homepage = "https://github.com/urbit/hoon.vim/";
   };
···
 
   jedi-vim = buildVimPluginFrom2Nix {
     pname = "jedi-vim";
-    version = "2022-01-17";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "davidhalter";
       repo = "jedi-vim";
-      rev = "08ad42efed82dbb7547fdebe2acc194f50e07854";
-      sha256 = "16acd976d44whpkl5bypskpf15a6mjf72pijjbg6j0jjnd2mm9qw";
+      rev = "32d05f7742dfb0ef84bee99e059ac3b7cb9526eb";
+      sha256 = "19z9i07w3wgf939fiy6kh7mq5pvlay3w37sm0sv4bmrdi42p8b4z";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/davidhalter/jedi-vim/";
···
 
   lean-nvim = buildVimPluginFrom2Nix {
     pname = "lean.nvim";
-    version = "2022-01-24";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "Julian";
       repo = "lean.nvim";
-      rev = "4d613c6aea73be9b8882d5710b11f502ef8692db";
-      sha256 = "16lcr9bbiq33agd9p1cwrrxmzsj3xmva1lva8ay4zrm1v2v45jn5";
+      rev = "08edf8f60d9d6fea83e9ef434ff04c30e579a2e0";
+      sha256 = "1xl80n1nxi0yq2hszr47apikhgf9skxldf4c9a6v78cj9wqk4dvz";
     };
     meta.homepage = "https://github.com/Julian/lean.nvim/";
   };
···
 
   lightspeed-nvim = buildVimPluginFrom2Nix {
     pname = "lightspeed.nvim";
-    version = "2022-01-21";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "ggandor";
       repo = "lightspeed.nvim";
-      rev = "428051b2e5212cea914510eb9eb979ec06d5b2e1";
-      sha256 = "01s3v3jfmgyrmwkifnyfh0wlm1d5fdvfvya0564y76bj4sh2lpzw";
+      rev = "ca8691dfd5127a4b9dfc79214b71ae31b125cdbe";
+      sha256 = "0w2f0jf1ljdj97bxy7pyyfhrav55j612cr6d2kqinx6bqd0cy3p4";
     };
     meta.homepage = "https://github.com/ggandor/lightspeed.nvim/";
   };
···
 
   litee-nvim = buildVimPluginFrom2Nix {
     pname = "litee.nvim";
-    version = "2022-01-19";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "ldelossa";
       repo = "litee.nvim";
-      rev = "54b3bcfd70250b5a5dc1d51d0f3653a4e6892555";
-      sha256 = "0z4y7iis1fkm76ibkfln70fasywwrlrf25r3si6ns0s3wq9q849v";
+      rev = "d29557a4024358cf028b706d91e3a95bd8180784";
+      sha256 = "0d16jms75nm2phx4hyvqlr3fbjadllgznd5dsy53cjf0gnybd6h2";
     };
     meta.homepage = "https://github.com/ldelossa/litee.nvim/";
   };
···
 
   lsp_signature-nvim = buildVimPluginFrom2Nix {
     pname = "lsp_signature.nvim";
-    version = "2022-01-23";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "ray-x";
       repo = "lsp_signature.nvim";
-      rev = "64eb5cc8961e54b2888d363bb94d551203080b45";
-      sha256 = "0v3dza9mp351715i87x75zxkm0d5i7v77a5zq8c8mlhz1v31z0vx";
+      rev = "30c7cf023782f50cfa8f65d0508163d6ebfd2442";
+      sha256 = "1qnzy258giqxkhmbvfv8fph5k3f2r313mj0rqsans2v8bq6ay6g0";
     };
     meta.homepage = "https://github.com/ray-x/lsp_signature.nvim/";
   };
···
 
   lspsaga-nvim = buildVimPluginFrom2Nix {
     pname = "lspsaga.nvim";
-    version = "2021-04-25";
+    version = "2022-01-19";
     src = fetchFromGitHub {
-      owner = "glepnir";
+      owner = "tami5";
       repo = "lspsaga.nvim";
-      rev = "cb0e35d2e594ff7a9c408d2e382945d56336c040";
-      sha256 = "0ywhdgh6aqs0xlm8a4d9jhkik254ywagang12r5nyqxawjsmjnib";
+      rev = "9968d7378a4bb3c13445bb6fd7937f3e757bfa0d";
+      sha256 = "04p138pkix3h02710r1812r0c1lkzga6pj35k0c7yic0p040ba35";
     };
-    meta.homepage = "https://github.com/glepnir/lspsaga.nvim/";
+    meta.homepage = "https://github.com/tami5/lspsaga.nvim/";
   };
 
   lua-dev-nvim = buildVimPluginFrom2Nix {
···
 
   lualine-nvim = buildVimPluginFrom2Nix {
     pname = "lualine.nvim";
-    version = "2022-01-24";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "nvim-lualine";
       repo = "lualine.nvim";
-      rev = "9208bae98fd5d1ab6145868a8c48bfee53c1a499";
-      sha256 = "1dz4kg3l79d128jgqs6cs8ikvr108z46ijv36wq7pw3dam4ybnaw";
+      rev = "dc31077bc517ac15a828102a386108e320c226d3";
+      sha256 = "1f1inhvpfy7qk8azjg6psv53g92fx5br4mlyydgijqiap8g7h33g";
     };
     meta.homepage = "https://github.com/nvim-lualine/lualine.nvim/";
   };
 
   luasnip = buildVimPluginFrom2Nix {
     pname = "luasnip";
-    version = "2022-01-24";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "l3mon4d3";
       repo = "luasnip";
-      rev = "59576a5cf28556a393eedfe38467e998288fc905";
-      sha256 = "1bwmzvsm9d6ilq616697rwk3j29i0q3nzwdyapjyxdyhp9rivgsj";
+      rev = "35322c97b041542f95c85e87a8215892ea4137d5";
+      sha256 = "0b6yxjsahy4ap6p9jvz2jvqg6akd8hkhd42pfz3krnwg85m7waiw";
     };
     meta.homepage = "https://github.com/l3mon4d3/luasnip/";
   };
···
 
   lush-nvim = buildVimPluginFrom2Nix {
     pname = "lush.nvim";
-    version = "2021-11-06";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "rktjmp";
       repo = "lush.nvim";
-      rev = "57e9f310b7ddde27664c3e1a5ec3517df235124b";
-      sha256 = "0y38id1dj15snx79sazh0kvs2c3jb1h6kyzr90zhm0130m7x6nri";
+      rev = "776c9381cfd80ead5c9388d59f3bc5b486e3b97d";
+      sha256 = "1bda2q28aryp7pxcsnvmqzbcw0sl6sz2mnii4vd0v4iprfkf779y";
     };
     meta.homepage = "https://github.com/rktjmp/lush.nvim/";
   };
···
 
   mini-nvim = buildVimPluginFrom2Nix {
     pname = "mini.nvim";
-    version = "2022-01-23";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "echasnovski";
       repo = "mini.nvim";
-      rev = "a89d87667eec94915121d8f5caf199f63f9ff81d";
-      sha256 = "0l6k5djgvhkl7y86g7wmaxs0yq5nv0g6aa46kjjc81lvycj9qg3m";
+      rev = "87e480118aef3429dc8eaff8eadfa41ffeba5fbd";
+      sha256 = "1hzmj42bz5lyyi1imm1pj4vk0dxin27qky4wyn5jcqdw7iyfr95a";
     };
     meta.homepage = "https://github.com/echasnovski/mini.nvim/";
   };
 
   minimap-vim = buildVimPluginFrom2Nix {
     pname = "minimap.vim";
-    version = "2022-01-12";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "wfxr";
       repo = "minimap.vim";
-      rev = "e5707899509be893a530d44b9bed8cff4cda65e1";
-      sha256 = "0kx5xdakwv9g8fhhc40rz2c0as5pjx46ymdw09bc5h1nnhwkgp8x";
+      rev = "c8ea2a5550b95b007631bc83908c48a3368eb57c";
+      sha256 = "08amdbn4xcdl7d09w3iqgrlyfmqnxlwmnild9q5mpqh5z372y6i0";
     };
     meta.homepage = "https://github.com/wfxr/minimap.vim/";
   };
···
 
   neorg = buildVimPluginFrom2Nix {
     pname = "neorg";
-    version = "2022-01-26";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "nvim-neorg";
       repo = "neorg";
-      rev = "c5f9957b00aa54cc66bcccb686e586859d44b484";
-      sha256 = "1ml0zrrij6a1f42q35wv7ml36yngc9gszzq1nqqh7mdad5zszxk5";
+      rev = "1e4cd7d7d0bd641173a3ef38a5427257acecbb63";
+      sha256 = "06p86l8l7akl8j4c20pg7sw12g944nwwdh0k9hwg99dkcisrnjyp";
     };
     meta.homepage = "https://github.com/nvim-neorg/neorg/";
   };
···
 
   neovim-ayu = buildVimPluginFrom2Nix {
     pname = "neovim-ayu";
-    version = "2022-01-21";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "Shatur";
       repo = "neovim-ayu";
-      rev = "0bca6a4382e7cc5e26da8dce49e7f69abfb0e998";
-      sha256 = "0pfrmzcs4vkxg74hzrp8g4kwb33m1r503c0b1yq25z33scqwc6hp";
+      rev = "1fff44e04d137c143af8f555963c90533ef9ae89";
+      sha256 = "1zffm9zmai82v3fnclp2nds3yiab0893kssyg0a2xyqp70xrh2hr";
     };
     meta.homepage = "https://github.com/Shatur/neovim-ayu/";
   };
···
 
   nord-nvim = buildVimPluginFrom2Nix {
     pname = "nord.nvim";
-    version = "2022-01-25";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "shaunsingh";
       repo = "nord.nvim";
-      rev = "5fdd8f273145f493c05eeff3d46c7538aea9f126";
-      sha256 = "0fj7w8ckp8949ysxnkq9h136pkd9ddqj54rzdb2dnia59wl2i2s1";
+      rev = "498b99c87a5826bfe4409883831deab91ebe296f";
+      sha256 = "1bhbk87wrjyk8mvg9aqspag58sz9chhrxvkhblpy2qypgla0s9pk";
     };
     meta.homepage = "https://github.com/shaunsingh/nord.nvim/";
   };
 
   nordic-nvim = buildVimPluginFrom2Nix {
     pname = "nordic.nvim";
-    version = "2022-01-27";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "andersevenrud";
       repo = "nordic.nvim";
-      rev = "a7cf7e887454b86a45243bfc3e8dbd4aa73007ba";
-      sha256 = "0ri0m0l8kv78ddkf9rgh4dn2857swrnsp6lnx6svpipi38cwz3w1";
+      rev = "6d0ccdb4d7e54b7ff29a626378f3c258b237d7db";
+      sha256 = "1ijanw0jpwc18wfrh5mnb981a9zrwr4r67w3sq40lb68v8vzmgnp";
     };
     meta.homepage = "https://github.com/andersevenrud/nordic.nvim/";
   };
···
 
   nui-nvim = buildVimPluginFrom2Nix {
     pname = "nui.nvim";
-    version = "2022-01-23";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "MunifTanjim";
       repo = "nui.nvim";
-      rev = "0d603c19171fb2e127bc128e9229d48340a6beeb";
-      sha256 = "1d6j3syv86afj0cpfqy8jcwj8pxm53wa1xjl76f1j5h7y6ba1237";
+      rev = "6f803e88093573f73d4ee6c0dfe0575df3f97a9f";
+      sha256 = "05napd3gqhdpb2x07affs50bm8prb3rzz0w5a39iyr40y96bpjix";
     };
     meta.homepage = "https://github.com/MunifTanjim/nui.nvim/";
   };
···
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "null-ls.nvim";
-      rev = "59067dae4bf2367eb06326e419c23353722ecbec";
-      sha256 = "0337mwsvd1jjjyvfg6xnmmadjw199i35wc0aiycv22kfdn7y4ybw";
+      rev = "2ae4a5e2e2b35716c44c104ef1afa35ecb40c444";
+      sha256 = "1y1vn3cr1q3wkgjabjb14pb8gwc4xy2rvka2s0a2mfv6a4f5v4z7";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";
   };
···
 
   nvim-base16 = buildVimPluginFrom2Nix {
     pname = "nvim-base16";
-    version = "2022-01-16";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "nvim-base16";
-      rev = "3720bdf0d651bb579ab0f24f889246862fdf8b00";
-      sha256 = "0x9agiyh5zjsa462bw3xqx2vnmax8qpidwd7w72zjig0hmhy34hs";
+      rev = "60ba8c6cac20af497f5444084993cd42f83576b4";
+      sha256 = "0ag2vh3j4wlwkdjwb9017nwmqqa78181rr0csjvh22x8x91mv5mi";
     };
     meta.homepage = "https://github.com/RRethy/nvim-base16/";
   };
 
   nvim-bqf = buildVimPluginFrom2Nix {
     pname = "nvim-bqf";
-    version = "2022-01-20";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "kevinhwang91";
       repo = "nvim-bqf";
-      rev = "88ad98547aee3ac7c026c9e3654532e62cc7f1b3";
-      sha256 = "0mcwzp7g631cg40gn8zy5rblqdwwrdrzgp3byaws47cgsmldb3w1";
+      rev = "a289c8fcb9f56a9df638b396a7c037997ab59a9d";
+      sha256 = "1d8ri9xzbryz4zi5fsl9s31racp7qs2mgih10p25rwyv6ai8sn58";
     };
     meta.homepage = "https://github.com/kevinhwang91/nvim-bqf/";
   };
···
 
   nvim-cmp = buildVimPluginFrom2Nix {
     pname = "nvim-cmp";
-    version = "2022-01-25";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "hrsh7th";
       repo = "nvim-cmp";
-      rev = "d93104244c3834fbd8f3dd01da9729920e0b5fe7";
-      sha256 = "1gn4m5ppqbhk3y5ad98kkgc72ms5xdgx6jdz3176dkd8ah6lnpf0";
+      rev = "d6838996da8dc9fe4697632d2abf34086ebab427";
+      sha256 = "1wzskfwz2hjjvyix8lfjzqjml66lypg8fg2fhqgn4rbr85p9lr7m";
     };
     meta.homepage = "https://github.com/hrsh7th/nvim-cmp/";
   };
···
 
   nvim-hs-vim = buildVimPluginFrom2Nix {
     pname = "nvim-hs.vim";
-    version = "2020-08-29";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "neovimhaskell";
       repo = "nvim-hs.vim";
-      rev = "30baacd3c7a10625cb2d4dd64ae3bbfc4fe3f8c6";
-      sha256 = "1w6cr6j77nwxszm1d0y4phvjsz9q4aw214xkscw6izakfmk06h1x";
+      rev = "d4a6b7278ae6a1fdc64e300c3ebc1e24719af342";
+      sha256 = "0a4sc2ff67xdqy5wj1j384vrsbnvhcd15mmwv7yygd7rccc2wsxs";
     };
     meta.homepage = "https://github.com/neovimhaskell/nvim-hs.vim/";
   };
 
   nvim-jdtls = buildVimPluginFrom2Nix {
     pname = "nvim-jdtls";
-    version = "2022-01-13";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-jdtls";
-      rev = "2cceff656f2bfac38da784f2cd4b202a64a2faf3";
-      sha256 = "13sx0rwz53rf8yg4ndc4m9fgvxa2xs46y92yn8rbgrjgf4xv18xi";
+      rev = "e2a80d5f51c326d6623979d614dd7968ef752061";
+      sha256 = "1m8sc88g8sk41m4ml62zn7dn05q1ns8xr20c7bldqaz9rwqbhqny";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-jdtls/";
   };
···
 
   nvim-lspconfig = buildVimPluginFrom2Nix {
     pname = "nvim-lspconfig";
-    version = "2022-01-24";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "c51096481dc13193991571b7132740d762902355";
-      sha256 = "02gpqp2r6f6zz3mfbxhsg2hvs00yldkz5wn3snk8nyqllm13i3dm";
+      rev = "e7df7ecae0b0d2f997ea65e951ddbe98ca3e154b";
+      sha256 = "03nqjv7zy87k4k8q8a6zknywdsvbb3xm7sxfgc5zhi8z4ymk17nr";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
   };
 
   nvim-lsputils = buildVimPluginFrom2Nix {
     pname = "nvim-lsputils";
-    version = "2021-09-28";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "RishabhRD";
       repo = "nvim-lsputils";
-      rev = "aaaf8c12771e905e5abf68470d8bda3e80536a0d";
-      sha256 = "1iag2ynp2yba5xaw4z0hnp9q6hfcrvjmkhl4js9hqhhsrm42c2vh";
+      rev = "ae1a4a62449863ad82c70713d5b6108f3a07917c";
+      sha256 = "0xl3crhgkzmas8zdcycgk11am3wx0az4jh7fh5n4lsjip8895p4s";
     };
     meta.homepage = "https://github.com/RishabhRD/nvim-lsputils/";
   };
···
 
   nvim-notify = buildVimPluginFrom2Nix {
     pname = "nvim-notify";
-    version = "2021-12-30";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "rcarriga";
       repo = "nvim-notify";
-      rev = "15f52efacd169ea26b0f4070451d3ea53f98cd5a";
-      sha256 = "1ixdckbmz6c54mm3mhkvh59ahfg5wc3h0ybnrp64d0bzsi3jngjh";
+      rev = "477b00f89bf863905c601210188eecf9677fa081";
+      sha256 = "11hh1yjl2pm8hkx8pb45fvhaqncbsl57wypx95fbg07yh2mzca0g";
     };
     meta.homepage = "https://github.com/rcarriga/nvim-notify/";
   };
···
 
   nvim-spectre = buildVimPluginFrom2Nix {
     pname = "nvim-spectre";
-    version = "2022-01-06";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "nvim-pack";
       repo = "nvim-spectre";
-      rev = "4a4cf2c981b077055ef7725959d13007e366ba23";
-      sha256 = "1aa062r2p69kn2xr9d2mbbrs8qdlv0q86lah2q9h6jhzxfi5ccdp";
+      rev = "9842b5fe987fb2c5a4ec4d42f8dbcdd04a047d4d";
+      sha256 = "12ww1yqxsk6qm6cimgr0ljgc98n831dpm711q4xqg9c6wm0pyzg7";
     };
     meta.homepage = "https://github.com/nvim-pack/nvim-spectre/";
   };
···
 
   nvim-tree-lua = buildVimPluginFrom2Nix {
     pname = "nvim-tree.lua";
-    version = "2022-01-21";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "kyazdani42";
       repo = "nvim-tree.lua";
-      rev = "2dfed89af7724f9e71d2fdbe3cde791a93e9b9e0";
-      sha256 = "1842c6s3q8hd8cnnyniwjxkkl48zzdy7v2gx20fiacnf365vgzpc";
+      rev = "0bc8258529e620b3c9d38bf5e88158ea24c85350";
+      sha256 = "1js0xg1w372xzihhs10zsrbgrgg47nx2pi6lrv9n5x9iiqigj2s3";
     };
     meta.homepage = "https://github.com/kyazdani42/nvim-tree.lua/";
   };
 
   nvim-treesitter = buildVimPluginFrom2Nix {
     pname = "nvim-treesitter";
-    version = "2022-01-25";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter";
-      rev = "620cc936ad6b26c59bb2d888b3890bb8d06c50c7";
-      sha256 = "0f2lg3dwcfvgjal1b87sgf6kvqs16h3a90w4994hp0ps9imipsp8";
+      rev = "05c963602b66f087cb15f39035d8b31d8225bb55";
+      sha256 = "1g9abw015mfpaazms48b12q1ksiszf0hj1hyc146hjqyp2bybf3w";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter/";
   };
···
 
   nvim-ts-rainbow = buildVimPluginFrom2Nix {
     pname = "nvim-ts-rainbow";
-    version = "2022-01-24";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "p00f";
       repo = "nvim-ts-rainbow";
-      rev = "38eb126412723fa4c3bfd137c1a3a811faf67eb5";
-      sha256 = "13igbd268z0533bsrz0r8s69lbryh0h4w33cpywmacghxy672jjl";
+      rev = "ac5032edc1d3e9216d081d130a14d4fcaf6cd3b3";
+      sha256 = "1cqh19pwhfr0sqcajp1fwrk6sm1n6apy859890d9k52n9ir21zj2";
     };
     meta.homepage = "https://github.com/p00f/nvim-ts-rainbow/";
   };
···
 
   nvim_context_vt = buildVimPluginFrom2Nix {
     pname = "nvim_context_vt";
-    version = "2022-01-22";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "haringsrob";
       repo = "nvim_context_vt";
-      rev = "47afb03249e36cd740bda79907c0f279f4e28544";
-      sha256 = "18pbdp7ci5gb7i0als4rgcr151rbm8j3mc0pxc9h4x9cvxdl8x5f";
+      rev = "b3d7072ab3a6db02ad173204b4420c1bbc46c2df";
+      sha256 = "0rxm91qa41hs8w5sc7yibn2n7zhqxfkvnildx6bpig054r21pa91";
     };
     meta.homepage = "https://github.com/haringsrob/nvim_context_vt/";
   };
···
 
   octo-nvim = buildVimPluginFrom2Nix {
     pname = "octo.nvim";
-    version = "2022-01-23";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "pwntester";
       repo = "octo.nvim";
-      rev = "33224362e20e1b3e87eb7ef2d669de6c60e727db";
-      sha256 = "0z163sfxly71bypskxnph9rwqamgp3h01i24va9n41wbbfvr0pw3";
+      rev = "3f1c6b93df0d927999dc7a243b0dd684d09f9d3e";
+      sha256 = "1sf7vqy0p6ssp6n9v91icvp1pm0yd0qki19icgpiqjsxya0qivca";
     };
     meta.homepage = "https://github.com/pwntester/octo.nvim/";
   };
···
 
   orgmode = buildVimPluginFrom2Nix {
     pname = "orgmode";
-    version = "2022-01-19";
+    version = "2022-01-27";
     src = fetchFromGitHub {
       owner = "nvim-orgmode";
       repo = "orgmode";
-      rev = "27c4083e29702c8b4fa5e314926ae054eb4c0dc2";
-      sha256 = "0vl95ywln1njxi7593gf2jp8y12fi6mwz3xmc8v6vd012vj4lbnk";
+      rev = "f339a7f87e4736c0a3e0db563b8c3cb45fc00a61";
+      sha256 = "1raicj3h524csqivw9x3l6znx5y7dwfn3cmh2hzddfy0n7n1mph0";
     };
     meta.homepage = "https://github.com/nvim-orgmode/orgmode/";
   };
···
 
   plantuml-syntax = buildVimPluginFrom2Nix {
     pname = "plantuml-syntax";
-    version = "2021-12-25";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "aklt";
       repo = "plantuml-syntax";
-      rev = "dbe57599bc340d7726938b624438779fa0ec2929";
-      sha256 = "095j1an00187ampxklwd6hhy05xzz7ssjwkgdsv06ydx7a1kn8xk";
+      rev = "32428a7b7bc1f1f4efe54490c212a7bda5dd073c";
+      sha256 = "06jxfr484wa563hs5qj2g4i37a6mfdvdjdn7a72dmbqzismvzd48";
     };
     meta.homepage = "https://github.com/aklt/plantuml-syntax/";
   };
···
 
   plenary-nvim = buildVimPluginFrom2Nix {
     pname = "plenary.nvim";
-    version = "2022-01-05";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "nvim-lua";
       repo = "plenary.nvim";
-      rev = "563d9f6d083f0514548f2ac4ad1888326d0a1c66";
-      sha256 = "1i4sj56fral52xa2wqzx331a6xza4ksi0n6092g6q93kxx202xwq";
+      rev = "e86dc9b11241ff69ece50c15a5cdd49d20d4c27c";
+      sha256 = "1yfiqkvk71i68hha2xdikfmch9qkn0di9gl14x4b9snvcf6l9plh";
     };
     meta.homepage = "https://github.com/nvim-lua/plenary.nvim/";
   };
···
 
   python-mode = buildVimPluginFrom2Nix {
     pname = "python-mode";
-    version = "2022-01-19";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "python-mode";
       repo = "python-mode";
-      rev = "6d81349723fdb6a7ce03b27afa8ea88819f3c0d5";
-      sha256 = "1cpmjg8867qmir79pd1zay63ihp2jzd8f1igxq2954q354bk08br";
+      rev = "85d2cd1a196ac1def79d4599b5be69395ed5b603";
+      sha256 = "0jk8pssliyar4qs42x9m1jgri446cr4yc7iv8l9wc9xn6r3qnm29";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/python-mode/python-mode/";
···
 
   quick-scope = buildVimPluginFrom2Nix {
     pname = "quick-scope";
-    version = "2021-12-28";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "unblevable";
       repo = "quick-scope";
-      rev = "4371a23bbb3b687e49c42a2a4379d17fc5c6a9a3";
-      sha256 = "0f625gmrs8zk622b1a8hhdxwx3c7hnxxznr98aqbxik6924rmr8g";
+      rev = "5e2373e36d774e1cebd58b318346db32c52db21a";
+      sha256 = "1dqygvc1gr35niqqdqivz5vgqpca9yj68incq3z73rl9qya96pvx";
     };
     meta.homepage = "https://github.com/unblevable/quick-scope/";
   };
···
 
   registers-nvim = buildVimPluginFrom2Nix {
     pname = "registers.nvim";
-    version = "2022-01-03";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "tversteeg";
       repo = "registers.nvim";
-      rev = "3a8b22157ad5b68380ee1b751bd87edbd6d46471";
-      sha256 = "07adb9rrcy4vr0bhjn4h8r1si0xq31gdpwr4l9lypfr23b2pdm10";
+      rev = "941a36e99bccc48fa9569a03b02ec95fb9c5222c";
+      sha256 = "0w0n3210c3j2jpvx0jf718in5hkj7vczv9n1qnls2f46ljwl1f5a";
     };
     meta.homepage = "https://github.com/tversteeg/registers.nvim/";
   };
···
 
   SchemaStore-nvim = buildVimPluginFrom2Nix {
     pname = "SchemaStore.nvim";
-    version = "2022-01-26";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "b0o";
       repo = "SchemaStore.nvim";
-      rev = "6c831123b78a352216adb640d34bebe355b7df15";
-      sha256 = "016r63vkyb2dpc6nvnky7ypv351893pyr5d1b11wpv53s0hr5z4y";
+      rev = "fd5423e0c9c6c27812070be4a2ec4a75d9e7778c";
+      sha256 = "16v8y6f40qx0n7gic3czhchch76yfrf3wp5ff10ij99sdsby84yc";
     };
     meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";
   };
···
 
   surround-nvim = buildVimPluginFrom2Nix {
     pname = "surround.nvim";
-    version = "2022-01-23";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "blackCauldron7";
       repo = "surround.nvim";
-      rev = "b0105011437ab148261b5c4ed6b84c735c54cd61";
-      sha256 = "1bs0ba29pfxvvz8j5qpam6mxch4b40idlpq7l39rsanrxyxl81yf";
+      rev = "3d5ae1ecd8a29a513895d5bd34723623702a03b0";
+      sha256 = "0rvj4l5hrr63alcg9dkr618xh8bvh2w6cinaxwdp0zx6a0ml2iv5";
     };
     meta.homepage = "https://github.com/blackCauldron7/surround.nvim/";
   };
···
 
   swift-vim = buildVimPluginFrom2Nix {
     pname = "swift.vim";
-    version = "2021-09-10";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "keith";
       repo = "swift.vim";
-      rev = "3278cf3b0522e6f08eaf11275fedce619beffe9a";
-      sha256 = "0hhi49iwkgzxhdixj0jbc4mbgad1irb056ijf7l5022r4k4gs2n8";
+      rev = "478e11812f3ddb1778918bd243d8b27c9984ab26";
+      sha256 = "15kqlbp1spkbkrgaa9dwp7dbdppncq059cps1qljpqp49qmgay2l";
     };
     meta.homepage = "https://github.com/keith/swift.vim/";
   };
···
 
   telescope-nvim = buildVimPluginFrom2Nix {
     pname = "telescope.nvim";
-    version = "2022-01-18";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "nvim-telescope";
       repo = "telescope.nvim";
-      rev = "0011b1148d3975600f5a9f0be8058cdaac4e30d9";
-      sha256 = "129cha5pwr1blnkyvkl59ildap0zdvk2khajmvd79fkcncgffvfi";
+      rev = "f262e7d56d37625613c5de0df5a933cccacf13c5";
+      sha256 = "0gi31w0rpd14zmnnc883hji7vf8hi1njdprhm9lk3n6pslipgfmv";
     };
     meta.homepage = "https://github.com/nvim-telescope/telescope.nvim/";
   };
···
 
   thesaurus_query-vim = buildVimPluginFrom2Nix {
     pname = "thesaurus_query.vim";
-    version = "2021-07-08";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "ron89";
       repo = "thesaurus_query.vim";
-      rev = "65e67a2dc3290d1fbed59db2a3f58944a73e7251";
-      sha256 = "1hak0ncsq43j0vblcgy9y4ylx2lazhij71sm3471cgini42klmgp";
+      rev = "23d8aa3f7d1a785e31e760e1b6b3b4c18abf8332";
+      sha256 = "0mh87m2jimblmdkfw5hr07li3zh2zmvgp23izc79k1i41v4yffsi";
     };
     meta.homepage = "https://github.com/ron89/thesaurus_query.vim/";
   };
···
 
   vim-clap = buildVimPluginFrom2Nix {
     pname = "vim-clap";
-    version = "2022-01-26";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "liuchengxu";
       repo = "vim-clap";
-      rev = "5ce5ea352432acfe8e9a15ee86dfe623e28b96f6";
-      sha256 = "1yh0iqcq6v5gj9bm2ni58bh69cy4y6ihlmp8x49lsr2jv9x4hck9";
+      rev = "4525903a95f3c3831d521a67eae6d8dcb0a58b58";
+      sha256 = "0c8r385zbadyqxwbpjh6r0ghys23mawv23arkpr1d2srj4dwaij4";
     };
     meta.homepage = "https://github.com/liuchengxu/vim-clap/";
   };
···
 
   vim-gitgutter = buildVimPluginFrom2Nix {
     pname = "vim-gitgutter";
-    version = "2021-09-07";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "airblade";
       repo = "vim-gitgutter";
-      rev = "256702dd1432894b3607d3de6cd660863b331818";
-      sha256 = "0zpa7cs59a8sq0k3frlf9flpf30jcn239yrpmv40r7nqvxzglbpl";
+      rev = "a02369403b8331b295f66a494d5d2ecf0e656b2f";
+      sha256 = "0g1wdpap96n9by7gli9s5w1k2s2bm9s5vrgv4j4ak0rzlgyhl1i3";
     };
     meta.homepage = "https://github.com/airblade/vim-gitgutter/";
   };
···
 
   vim-go = buildVimPluginFrom2Nix {
     pname = "vim-go";
-    version = "2022-01-20";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "fatih";
       repo = "vim-go";
-      rev = "8dfedede1c6e27e4339411b1071fee6a40663f11";
-      sha256 = "0micmffcbw70bbxcx03isrf4b4s6plz3drfjbbls7dvalws0z5pa";
+      rev = "430bc227654abc3eb5e27a9052a857344ca08cdc";
+      sha256 = "0wh3g0lilzi4rjlszjf5gys11zpqvyv53hy5gyjd72k0kkbfbc2k";
     };
     meta.homepage = "https://github.com/fatih/vim-go/";
   };
···
 
   vim-manpager = buildVimPluginFrom2Nix {
     pname = "vim-manpager";
-    version = "2020-10-28";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "lambdalisue";
       repo = "vim-manpager";
-      rev = "c23c02dd79b0a5cabe140d1f10f9aa2591cf55ed";
-      sha256 = "0g61qbp4vl010isigp6j3jjb3vb2kxalcbb56xzfa6c9k5zap5j9";
+      rev = "194607a8d1bd122ad811ef601eb04a3df7786d59";
+      sha256 = "0qnm4k0frki3p9fpb6h4xnv1dxijk9aqcd7glq28c216gh395a5d";
     };
     meta.homepage = "https://github.com/lambdalisue/vim-manpager/";
   };
···
 
   vim-markdown = buildVimPluginFrom2Nix {
     pname = "vim-markdown";
-    version = "2022-01-24";
+    version = "2022-01-29";
     src = fetchFromGitHub {
       owner = "preservim";
       repo = "vim-markdown";
-      rev = "9156bba66350d4c0c32b4ac783550c3e132d6a88";
-      sha256 = "0ghlswpc0qdxidc38y9xy22293nf0hjxqwvln71gzmxjlxj3rdgk";
+      rev = "50d42082819cfa91745b6eff6e28ad5cbc8b27fa";
+      sha256 = "1582y2cyqywbgf4pg8m5m2s0nd6wwgnm1nxy5kmrfcn1119hn639";
     };
     meta.homepage = "https://github.com/preservim/vim-markdown/";
   };
···
 
   vim-mundo = buildVimPluginFrom2Nix {
     pname = "vim-mundo";
-    version = "2021-11-09";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "simnalamburt";
       repo = "vim-mundo";
-      rev = "e193f185bad3aa58446e771f8f2739abf11d3262";
-      sha256 = "1q2j88rcg0slvm2bfdri4fy42h5a2md9bbqsspb3kzx5yrhgawhp";
+      rev = "595ee332719f397c2441d85f79608113957cc78f";
+      sha256 = "0kwiw877izpjqfj4gp4km8ivj6iy2c2jxyiqgxrvjqna62kic0ap";
     };
     meta.homepage = "https://github.com/simnalamburt/vim-mundo/";
   };
···
 
   vim-sandwich = buildVimPluginFrom2Nix {
     pname = "vim-sandwich";
-    version = "2022-01-18";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "machakann";
       repo = "vim-sandwich";
-      rev = "6ab5f16a56f5b2361ba17a41d8644631d2b43647";
-      sha256 = "1z36b9vdl8zr1r08jm43p2qys598lbxplbjdqmywkx5y78dm4hhr";
+      rev = "48acdaded60c6b75fce06a0d61183ee99950c0ec";
+      sha256 = "0rijq9xwm3n84vpjzyvcpy6r58y6ma2pxj61h86122wda5ymwxwg";
     };
     meta.homepage = "https://github.com/machakann/vim-sandwich/";
   };
···
 
   vim-surround = buildVimPluginFrom2Nix {
     pname = "vim-surround";
-    version = "2021-10-12";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-surround";
-      rev = "aeb933272e72617f7c4d35e1f003be16836b948d";
-      sha256 = "1b0bd5m5lv1p4d299mrwjfs2gk0zqwyaqdaid9hs9yqlxnr8s5nf";
+      rev = "baf89ad26488f6a7665d51b986f5c7ad2d22b30b";
+      sha256 = "0kzp1g2zw2an0z7bb8h4xs8jf17z0mnn0zf6v1wkipvz6nvp7di8";
     };
     meta.homepage = "https://github.com/tpope/vim-surround/";
   };
···
 
   vim-tpipeline = buildVimPluginFrom2Nix {
     pname = "vim-tpipeline";
-    version = "2022-01-24";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "vimpostor";
       repo = "vim-tpipeline";
-      rev = "72b956f668237a4cd9b020b2c173d013699b38b5";
-      sha256 = "1f0kkxclpa9x3qc81yzagl1qili13ihbicb6d84pnpycy482k0sj";
+      rev = "400e17c7af65ab194f968a1edac4bcae08fb48f2";
+      sha256 = "0s22bkh77avklapn5lr7pm36zaxn656pf4dwxx6lc5xdj3p2qd7y";
     };
     meta.homepage = "https://github.com/vimpostor/vim-tpipeline/";
   };
···
 
   vim-ultest = buildVimPluginFrom2Nix {
     pname = "vim-ultest";
-    version = "2022-01-21";
+    version = "2022-01-30";
     src = fetchFromGitHub {
       owner = "rcarriga";
       repo = "vim-ultest";
-      rev = "00da9eacaf4396bdc11817f987c35e5d09486eb4";
-      sha256 = "1r5zdwm20110mzwawxik563l4bw5zxhrpdsn0cgq04icp5gbbxrc";
+      rev = "616bbca2e5d0a97edadb441df56bc21598e59a1a";
+      sha256 = "1a3ms0b6kvv70l7fd4wxc7lgnqj97c5ad9a1mk2bqcd3xh3yq6ki";
     };
     meta.homepage = "https://github.com/rcarriga/vim-ultest/";
   };
···
 
   vim-wakatime = buildVimPluginFrom2Nix {
     pname = "vim-wakatime";
-    version = "2022-01-27";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "wakatime";
       repo = "vim-wakatime";
-      rev = "6fd8b9401af0597cfe8f05550d0194d057fce9c7";
-      sha256 = "1j3d0fl449a539azm1ldralmijnc8qgn6c703k4qg2kzdkvpaa48";
+      rev = "b6754ace510ffa931bceb47df417a9ef3a87cb6b";
+      sha256 = "13dfaf6y0yfnbnxl43fc0jwqv45gigki4iyhb4698fhmcy105jv6";
     };
     meta.homepage = "https://github.com/wakatime/vim-wakatime/";
   };
···
 
   vimade = buildVimPluginFrom2Nix {
     pname = "vimade";
-    version = "2022-01-12";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "TaDaa";
       repo = "vimade";
-      rev = "fd3d3eb4bf6e5bdb643353f9d4bdae70faa16768";
-      sha256 = "046w99vqk0lmxiwnsw57yvz6xgs64wmqwfm3iymxygqz828c8n3s";
+      rev = "b0ce0820240e72a330bd388caa48baf434f1a0e3";
+      sha256 = "1yknp4fjdwkc5sfw8f6rkhffa1k7lz3pa9q62v9ifj27a0gykwsd";
     };
     meta.homepage = "https://github.com/TaDaa/vimade/";
   };
···
 
   vimtex = buildVimPluginFrom2Nix {
     pname = "vimtex";
-    version = "2022-01-25";
+    version = "2022-01-31";
     src = fetchFromGitHub {
       owner = "lervag";
       repo = "vimtex";
-      rev = "5659e6ac5ffc3ae43bd401d78b3a62653a28b750";
-      sha256 = "1nqq10isng6fdkxbn5bjy8c54i00h85m3m13sm0j94lzcia7qxqr";
+      rev = "54bcb0407f8ff24a1cface0e91759940b81ae04e";
+      sha256 = "1n2k6jq01znx5501fdwdzbxxlzhyng5zv9j5k2hiijqkv9rm1487";
     };
     meta.homepage = "https://github.com/lervag/vimtex/";
   };
···
 
   zig-vim = buildVimPluginFrom2Nix {
     pname = "zig.vim";
-    version = "2022-01-17";
+    version = "2022-01-28";
     src = fetchFromGitHub {
       owner = "ziglang";
       repo = "zig.vim";
-      rev = "29ceb12298015dfb59a6e06706c9005f76153238";
-      sha256 = "1i5h6lk0ikwhda4h368m4nn0shb6xciaqhxpag109l9xijgm3yap";
+      rev = "0762d89c24f5a1da6bf26ca83f3719c379008ff9";
+      sha256 = "00vfyi79m85d8pv0cnhyj82nqlnwiqs5pkzbr9yn8mvy6r0hscf3";
     };
     meta.homepage = "https://github.com/ziglang/zig.vim/";
   };

pkgs/misc/vim-plugins/overrides.nix

···
             libiconv
           ];
 
-          cargoSha256 = "sha256-4VXXQjGmGGQXgfzSOvFnQS+iQjidj0FjaNKZ3VzBqw0=";
+          cargoSha256 = "sha256-y4yQ8Zv9bpfOyQrBX/TAuVYHhDsXdj0rh8nHJonxgcU=";
         };
       in
       ''

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

···
 gleam-lang/gleam.vim
 glepnir/dashboard-nvim
 glepnir/galaxyline.nvim
-glepnir/lspsaga.nvim
 glepnir/oceanic-material
 glepnir/zephyr-nvim
 glts/vim-textobj-comment
···
 tamago324/lir.nvim
 tami5/compe-conjure
 tami5/lispdocs.nvim
+tami5/lspsaga.nvim
 tami5/sqlite.lua
 tbastos/vim-lua
 tbodt/deoplete-tabnine

pkgs/os-specific/linux/busybox/default.nix

···
     ./busybox-in-store.patch
   ] ++ lib.optional (stdenv.hostPlatform != stdenv.buildPlatform) ./clang-cross.patch;
 
+  separateDebugInfo = true;
+
   postPatch = "patchShebangs .";
 
   configurePhase = ''
···
   postConfigure = lib.optionalString (useMusl && stdenv.hostPlatform.libc != "musl") ''
     makeFlagsArray+=("CC=${stdenv.cc.targetPrefix}cc -isystem ${musl.dev}/include -B${musl}/lib -L${musl}/lib")
   '';
+
+  makeFlags = [ "SKIP_STRIP=y" ];
 
   postInstall = ''
     sed -e '

pkgs/os-specific/linux/numatop/default.nix

···
-{ lib, stdenv, fetchurl, pkg-config, numactl, ncurses, check }:
+{ lib, stdenv, fetchFromGitHub, fetchpatch, autoreconfHook, pkg-config, numactl, ncurses, check }:
 
 stdenv.mkDerivation rec {
   pname = "numatop";
-  version = "2.1";
-  src = fetchurl {
-    url = "https://github.com/intel/${pname}/releases/download/v${version}/${pname}-v${version}.tar.xz";
-    sha256 = "1s7psq1xyswj0lpx10zg5lnppav2xy9safkfx3rssrs9c2fp5d76";
+  version = "2.2";
+  src = fetchFromGitHub {
+    owner = "intel";
+    repo = "numatop";
+    rev = "v${version}";
+    sha256 = "sha256-GJvTwqgx34ZW10eIJj/xiKe3ZkAfs7GlJImz8jrnjfI=";
   };
 
-  nativeBuildInputs = [ pkg-config ];
+  nativeBuildInputs = [ autoreconfHook pkg-config ];
   buildInputs = [ numactl ncurses ];
   checkInputs = [ check ];
 
+  patches = [
+    (fetchpatch {
+      url = "https://github.com/intel/numatop/pull/54.patch";
+      sha256 = "sha256-TbMLv7TT9T8wE4uJ1a/AroyPPwrwL0eX5IBLsh9GTTM=";
+      name = "fix-string-operations.patch";
+    })
+    (fetchpatch {
+      url = "https://github.com/intel/numatop/pull/64.patch";
+      sha256 = "sha256-IevbSFJRTS5iQ5apHOVXzF67f3LJaW6j7DySFmVuyiM=";
+      name = "fix-format-strings-mvwprintw.patch";
+    })
+  ];
+
   doCheck  = true;
 
   meta = with lib; {
···
     license = licenses.bsd3;
     maintainers = with maintainers; [ dtzWill ];
     platforms = [
-      { kernel.name = "linux"; cpu.family = "x86"; }
-      { kernel.name = "linux"; cpu.family = "power"; }
+      "i686-linux" "x86_64-linux"
+      "powerpc64-linux" "powerpc64le-linux"
     ];
   };
 }

pkgs/os-specific/linux/openvswitch/default.nix

···
   _kernel = kernel;
   pythonEnv = python3.withPackages (ps: with ps; [ six ]);
 in stdenv.mkDerivation rec {
-  version = "2.15.1";
+  version = "2.16.2";
   pname = "openvswitch";
 
   src = fetchurl {
     url = "https://www.openvswitch.org/releases/${pname}-${version}.tar.gz";
-    sha256 = "0vgijwycf3wvzv9v811jrfr5rlwmihlxwpf16spl6k9n6zaswysw";
+    sha256 = "sha256-A6xMMpmzjlbAtNTCejKclYsAOgjztUigo8qLmU8tSTQ=";
   };
 
   kernel = optional (_kernel != null) _kernel.dev;

pkgs/servers/http/gitlab-pages/default.nix

···
 
 buildGoModule rec {
   pname = "gitlab-pages";
-  version = "1.48.0";
+  version = "1.49.0";
 
   src = fetchFromGitLab {
     owner = "gitlab-org";
     repo = "gitlab-pages";
     rev = "v${version}";
-    sha256 = "sha256-oSimHF4qiI2zcMSx51qxs88AcrrewHIbhaRW8s4Ut7Q=";
+    sha256 = "sha256-9orJEt0w0ORHKEOpp40Aubj/pfnNO/A3oHEgWIdk+vM=";
   };
 
-  vendorSha256 = "sha256-dzYO1yAQSVJmDJvjB5XPRBiYCk+ko1n928CTtUXbHBc=";
+  vendorSha256 = "sha256-/dmEsoeB3UDOBZ/9rbnywRtpXVKaJKGF6xPeWTA4PPE=";
   subPackages = [ "." ];
 
   meta = with lib; {

pkgs/servers/irc/atheme/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "atheme";
-  version = "7.2.11";
+  version = "7.2.12";
 
   src = fetchgit {
     url = "https://github.com/atheme/atheme.git";
     rev = "v${version}";
-    sha256 = "15fs48cgzxblh2g4abl5v647ndfx9hg8cih2x67v3y7s9wz68wk2";
+    sha256 = "sha256-KAC1ZPNo4TqfVryKOYYef8cRWRgFmyEdvl1bgvpGNiM=";
     leaveDotGit = true;
   };
 

pkgs/servers/klipper/default.nix

···
 }:
 stdenv.mkDerivation rec {
   pname = "klipper";
-  version = "unstable-2021-12-24";
+  version = "unstable-2022-01-09";
 
   src = fetchFromGitHub {
     owner = "KevinOConnor";
     repo = "klipper";
-    rev = "247cd753e283e70a9949e76d0ba669d99c0eb144";
-    sha256 = "sha256-65wxhE/XqNK6ly+fxZFLjtImvpJlgU54RStUve40CJA=";
+    rev = "6e6ad7b5201d3452aa605f4ae852c51239c2c7d8";
+    sha256 = "sha256-cflcGweEjB0xj2LhYJzyvqFSQen2vhYXlL7lz/HoGaM=";
   };
 
   sourceRoot = "source/klippy";

pkgs/servers/radicale/3.x.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "radicale";
-  version = "3.1.0";
+  version = "3.1.3";
 
   src = fetchFromGitHub {
     owner = "Kozea";
     repo = "Radicale";
     rev = "v${version}";
-    hash = "sha256-LtPv+3FQMGC2YP2+1cSPZVUIzrUhteJTl58+JdvGcQg=";
+    hash = "sha256-a1oapCktJPvNO+MTsB9COtxSFB/ZIZvJiuqX+s+lncY=";
   };
 
   postPatch = ''
···
     homepage = "https://radicale.org/v3.html";
     description = "CalDAV and CardDAV server";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ dotlambda ];
+    maintainers = with maintainers; [ dotlambda erictapen ];
   };
 }

pkgs/servers/serviio/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "serviio";
-  version = "2.1";
+  version = "2.2.1";
 
   src = fetchurl {
     url = "http://download.serviio.org/releases/${pname}-${version}-linux.tar.gz";
-    sha256 = "0mxpdyhjf4w83q8ssmvpxm95hw4x7lfkh48vvdablccfndh82x2i";
+    sha256 = "sha256-uRRWKMv4f2b1yIE9OnXDIZAmcoqw/8F0z1LOesQBsyQ=";
   };
 
   installPhase = ''

pkgs/tools/audio/abcmidi/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "abcMIDI";
-  version = "2022.01.13";
+  version = "2022.01.28";
 
   src = fetchzip {
     url = "https://ifdo.ca/~seymour/runabc/${pname}-${version}.zip";
-    hash = "sha256-jXXUdPAmU6JcnqWBnzc9tfjEyLSdYxZZJh4w4iSCD1w=";
+    hash = "sha256-+g5oKUfm6vRuRQfOx0QDueYMabgScL8Mfw5GJcXQztg=";
   };
 
   meta = with lib; {

pkgs/tools/misc/cloud-sql-proxy/default.nix

···
 
 buildGoModule rec {
   pname = "cloud-sql-proxy";
-  version = "1.27.1";
+  version = "1.28.0";
 
   src = fetchFromGitHub {
     owner = "GoogleCloudPlatform";
     repo = "cloudsql-proxy";
     rev = "v${version}";
-    sha256 = "sha256-xVPs7D639KY2ryDZpivineH4yZSNXi78FWk2SFKX1sk=";
+    sha256 = "sha256-XA74rZ477Mwf8u0KLkFngfwiJexS10vh++ST6VtkcVg=";
   };
 
   subPackages = [ "cmd/cloud_sql_proxy" ];
 
-  vendorSha256 = "sha256-913GJ/rPvDavQQMqDDTe4gBXziPPeQRPpUUG3DAz96g=";
+  vendorSha256 = "sha256-ZXWhADfzvHcEW3IZlPyau5nHEXBJRH8aTvb3zCKl/LE=";
 
   checkFlags = [ "-short" ];
 

pkgs/tools/networking/boundary/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "boundary";
-  version = "0.7.1";
+  version = "0.7.3";
 
   src =
     let
···
         x86_64-darwin = "darwin_amd64";
       };
       sha256 = selectSystem {
-        x86_64-linux = "sha256-5m5ckeX3gVY82q9aQWusnq3o/+UBPJSPDdISL86OfV8=";
-        aarch64-linux = "sha256-+dnQh89kg3JcDL8sucMceCMRFyUjoAIYuZtDM8AUMYw=";
-        x86_64-darwin = "sha256-ZoWW8y048+5Ru3s7lUxLTMxuITFBC9AgwqafyHPDc54=";
+        x86_64-linux = "sha256-9WEvGU4VfJ1781DlvdJhpdzY4djoSRWu6ZzfOpBvKJQ=";
+        aarch64-linux = "sha256-QLjewB1FeYHVehM1U81GzyewWns40IlVEFWgzWP+2Vw=";
+        x86_64-darwin = "sha256-YxPkZnU8EBvRWBMsB0jifS63tJ7LQibgtwTbqosC/fg=";
       };
     in
     fetchzip {

pkgs/tools/networking/flannel/default.nix

···
 
 buildGoModule rec {
   pname = "flannel";
-  version = "0.15.1";
+  version = "0.16.1";
   rev = "v${version}";
 
   vendorSha256 = null;
···
     inherit rev;
     owner = "flannel-io";
     repo = "flannel";
-    sha256 = "1p4rz4kdiif8i78zgxhw6dd0c1bq159f6l1idvig5apph7zi2bwm";
+    sha256 = "sha256-5NrULpbf3PStzoywLyrfM5qup43idzeHCMRSuNLXR3g=";
   };
 
   ldflags = [ "-X github.com/flannel-io/flannel/version.Version=${rev}" ];

pkgs/tools/networking/i2p/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "i2p";
-  version = "1.5.0";
+  version = "1.6.1";
 
   src = fetchurl {
     url = "https://download.i2p2.de/releases/${version}/i2psource_${version}.tar.bz2";
-    sha256 = "sha256-JuX02VsaB2aHD5ezDlfJqOmGkCecO/CRmOMO/6vsxFA=";
+    sha256 = "sha256-cZYGxMtRDeT+dPJLv6U5EacFMYIfwe55op49luqhZzM=";
   };
 
   buildInputs = [ jdk ant gettext which ];

pkgs/tools/security/spire/default.nix

···
 
 buildGoModule rec {
   pname = "spire";
-  version = "1.1.2";
+  version = "1.2.0";
 
   outputs = [ "out" "agent" "server" ];
 
···
     owner = "spiffe";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-MX2kbdLj72S2WBceUW/3ps34Bcsf/VArK8RN4r13wQY=";
+    sha256 = "01ph9jzh18bnidrsbnnxm3gxh0cgfllnjvf7a5haqz51lm6a9pny";
   };
 
-  vendorSha256 = "sha256-ZRcXMNKhNY3W5fV9q/V7xsnODoG6KWHrzpWte9hx/Ms=";
+  vendorSha256 = "17d845lwlbk19lsc937c22b1l0ikimhlagknm2i7mn8s8xrs57q8";
 
   subPackages = [ "cmd/spire-agent" "cmd/spire-server" ];
 

pkgs/top-level/aliases.nix

···
   winswitch = throw "winswitch has been removed from nixpkgs."; # added 2019-12-10
   wireshark-gtk = throw "wireshark-gtk is not supported anymore. Use wireshark-qt or wireshark-cli instead."; # added 2019-11-18
   wireguard = wireguard-tools; # added 2018-05-19
+  wxmupen64plus = throw "wxmupen64plus was removed because the upstream disappeared."; # 2022-01-31
   morituri = whipper; # added 2018-09-13
   xbmc-retroarch-advanced-launchers = kodi-retroarch-advanced-launchers; # added 2021-11-19
   xp-pen-g430 = pentablet-driver; # added 2020-05-03

pkgs/top-level/all-packages.nix

···
 
   mole = callPackage ../tools/networking/mole { };
 
+  morgen = callPackage ../applications/office/morgen {
+    electron = electron_15;
+  };
+
   mosh = callPackage ../tools/networking/mosh { };
 
   mpage = callPackage ../tools/text/mpage { };
···
 
   mozjpeg = callPackage ../applications/graphics/mozjpeg { };
 
+  edgetx = libsForQt5.callPackage ../applications/misc/edgetx { };
+
   easytag = callPackage ../applications/audio/easytag { };
 
   mp3gain = callPackage ../applications/audio/mp3gain { };
···
 
   sherpa = callPackage ../applications/science/physics/sherpa {};
 
+  shtns = callPackage ../applications/science/physics/shtns { };
+
   xfitter = callPackage ../applications/science/physics/xfitter {};
 
   xflr5 = libsForQt5.callPackage ../applications/science/physics/xflr5 { };
···
   wprecon = callPackage ../tools/security/wprecon { };
 
   wraith = callPackage ../applications/networking/irc/wraith { };
-
-  wxmupen64plus = callPackage ../misc/emulators/wxmupen64plus { };
 
   wxsqlite3 = callPackage ../development/libraries/wxsqlite3 {
     wxGTK = wxGTK30;

pkgs/top-level/haskell-packages.nix

···
     "ghcjs810"
     "integer-simple"
     "native-bignum"
+    "ghc902"
+    "ghc921"
     "ghcHEAD"
   ];
 
   nativeBignumIncludes = [
+    "ghc902"
+    "ghc921"
     "ghcHEAD"
   ];
 

pkgs/top-level/perl-packages.nix

···
 
   Appcpanminus = buildPerlPackage {
     pname = "App-cpanminus";
-    version = "1.7044";
+    version = "1.7045";
     src = fetchurl {
-      url = "mirror://cpan/authors/id/M/MI/MIYAGAWA/App-cpanminus-1.7044.tar.gz";
-      sha256 = "9b60767fe40752ef7a9d3f13f19060a63389a5c23acc3e9827e19b75500f81f3";
+      url = "mirror://cpan/authors/id/M/MI/MIYAGAWA/App-cpanminus-1.7045.tar.gz";
+      sha256 = "1779w07zxlgfk35s24ksr7k9azd5yl8sbb48y1aaph7y4gf4lkmc";
     };
+    # Use TLS endpoints for downloads and metadata by default
+    preConfigure = ''
+      substituteInPlace bin/cpanm \
+        --replace http://www.cpan.org https://www.cpan.org \
+        --replace http://backpan.perl.org https://backpan.perl.org \
+        --replace http://fastapi.metacpan.org https://fastapi.metacpan.org \
+        --replace http://cpanmetadb.plackperl.org https://cpanmetadb.plackperl.org
+    '';
+    propagatedBuildInputs = [ IOSocketSSL ];
     meta = {
       homepage = "https://github.com/miyagawa/cpanminus";
       description = "Get, unpack, build and install modules from CPAN";

pkgs/top-level/release-haskell.nix

···
           jobs.pkgsMusl.haskell.compiler.ghc921
           jobs.pkgsMusl.haskell.compiler.ghcHEAD
           jobs.pkgsMusl.haskell.compiler.integer-simple.ghc8107
-          jobs.pkgsMusl.haskell.compiler.integer-simple.ghc902
-          jobs.pkgsMusl.haskell.compiler.integer-simple.ghc921
+          jobs.pkgsMusl.haskell.compiler.native-bignum.ghc902
+          jobs.pkgsMusl.haskell.compiler.native-bignum.ghc921
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghcHEAD
         ];
       };