Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 4331004;
     name = "Naoya Hatta";
   };
+  dalpd = {
+    email = "[e-mail]";
+    github = "dalpd";
+    githubId = 16895361;
+    name = "Deniz Alp Durmaz";
+  };
   DamienCassou = {
     email = "[e-mail]";
     github = "DamienCassou";

maintainers/scripts/update-luarocks-packages

···
 GENERATED_NIXFILE="pkgs/development/lua-modules/generated-packages.nix"
 LUAROCKS_CONFIG="$NIXPKGS_PATH/maintainers/scripts/luarocks-config.lua"
 
-HEADER = """
-/* {GENERATED_NIXFILE} is an auto-generated file -- DO NOT EDIT!
+HEADER = """/* {GENERATED_NIXFILE} is an auto-generated file -- DO NOT EDIT!
 Regenerate it with:
 nixpkgs$ ./maintainers/scripts/update-luarocks-packages
 
···
             header2 = textwrap.dedent(
             # header2 = inspect.cleandoc(
             """
-                { self, stdenv, lib, fetchurl, fetchgit, ... } @ args:
-                self: super:
-                with self;
+                { self, stdenv, lib, fetchurl, fetchgit, callPackage, ... } @ args:
+                final: prev:
                 {
             """)
             f.write(header2)
···
 
     log.debug("running %s", ' '.join(cmd))
     output = subprocess.check_output(cmd, text=True)
+    output = "callPackage(" + output.strip() + ") {};\n\n"
     return (plug, output)
 
 def main():

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

···
           encapsulation.
         </para>
       </listitem>
+      <listitem>
+        <para>
+          Changing systemd <literal>.socket</literal> units now restarts
+          them and stops the service that is activated by them.
+          Additionally, services with
+          <literal>stopOnChange = false</literal> don’t break anymore
+          when they are socket-activated.
+        </para>
+      </listitem>
     </itemizedlist>
   </section>
 </section>

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

···
 - The `networking` module has a new `networking.fooOverUDP` option to configure Foo-over-UDP encapsulations.
 
 - `networking.sits` now supports Foo-over-UDP encapsulation.
+
+- Changing systemd `.socket` units now restarts them and stops the service that is activated by them. Additionally, services with `stopOnChange = false` don't break anymore when they are socket-activated.

nixos/modules/services/torrent/transmission.nix

···
       install -d -m '${cfg.downloadDirPermissions}' -o '${cfg.user}' -g '${cfg.group}' '${cfg.settings.download-dir}'
       '' + optionalString cfg.settings.incomplete-dir-enabled ''
       install -d -m '${cfg.downloadDirPermissions}' -o '${cfg.user}' -g '${cfg.group}' '${cfg.settings.incomplete-dir}'
+      '' + optionalString cfg.settings.watch-dir-enabled ''
+      install -d -m '${cfg.downloadDirPermissions}' -o '${cfg.user}' -g '${cfg.group}' '${cfg.settings.watch-dir}'
       '';
 
     assertions = [

nixos/modules/system/activation/switch-to-configuration.pl

···
 
 my $out = "@out@";
 
-# FIXME: maybe we should use /proc/1/exe to get the current systemd.
 my $curSystemd = abs_path("/run/current-system/sw/bin");
 
 # To be robust against interruption, record what units need to be started etc.
···
 my $restartListFile = "/run/nixos/restart-list";
 my $reloadListFile = "/run/nixos/reload-list";
 
-# Parse restart/reload requests by the activation script
+# Parse restart/reload requests by the activation script.
+# Activation scripts may write newline-separated units to this
+# file and switch-to-configuration will handle them. While
+# `stopIfChanged = true` is ignored, switch-to-configuration will
+# handle `restartIfChanged = false` and `reloadIfChanged = true`.
+# This also works for socket-activated units.
 my $restartByActivationFile = "/run/nixos/activation-restart-list";
-my $reloadByActivationFile = "/run/nixos/activation-reload-list";
 my $dryRestartByActivationFile = "/run/nixos/dry-activation-restart-list";
-my $dryReloadByActivationFile = "/run/nixos/dry-activation-reload-list";
 
-make_path("/run/nixos", { mode => 0755 });
+make_path("/run/nixos", { mode => oct(755) });
 
 my $action = shift @ARGV;
 
···
     return abs_path($s) . (-f "${s}.d/overrides.conf" ? " " . abs_path "${s}.d/overrides.conf" : "");
 }
 
+sub handleModifiedUnit {
+    my ($unit, $baseName, $newUnitFile, $activePrev, $unitsToStop, $unitsToStart, $unitsToReload, $unitsToRestart, $unitsToSkip) = @_;
+
+    if ($unit eq "sysinit.target" || $unit eq "basic.target" || $unit eq "multi-user.target" || $unit eq "graphical.target" || $unit =~ /\.slice$/ || $unit =~ /\.path$/) {
+        # Do nothing.  These cannot be restarted directly.
+        # Slices and Paths don't have to be restarted since
+        # properties (resource limits and inotify watches)
+        # seem to get applied on daemon-reload.
+    } elsif ($unit =~ /\.mount$/) {
+        # Reload the changed mount unit to force a remount.
+        $unitsToReload->{$unit} = 1;
+        recordUnit($reloadListFile, $unit);
+    } else {
+        my $unitInfo = parseUnit($newUnitFile);
+        if (boolIsTrue($unitInfo->{'X-ReloadIfChanged'} // "no")) {
+            $unitsToReload->{$unit} = 1;
+            recordUnit($reloadListFile, $unit);
+        }
+        elsif (!boolIsTrue($unitInfo->{'X-RestartIfChanged'} // "yes") || boolIsTrue($unitInfo->{'RefuseManualStop'} // "no") || boolIsTrue($unitInfo->{'X-OnlyManualStart'} // "no")) {
+            $unitsToSkip->{$unit} = 1;
+        } else {
+            # If this unit is socket-activated, then stop it instead
+            # of restarting it to make sure the new version of it is
+            # socket-activated.
+            my $socketActivated = 0;
+            if ($unit =~ /\.service$/) {
+                my @sockets = split / /, ($unitInfo->{Sockets} // "");
+                if (scalar @sockets == 0) {
+                    @sockets = ("$baseName.socket");
+                }
+                foreach my $socket (@sockets) {
+                    if (-e "$out/etc/systemd/system/$socket") {
+                        $socketActivated = 1;
+                        $unitsToStop->{$unit} = 1;
+                        # If the socket was not running previously,
+                        # start it now.
+                        if (not defined $activePrev->{$socket}) {
+                            $unitsToStart->{$socket} = 1;
+                        }
+                    }
+                }
+            }
+
+            # Don't do the rest of this for socket-activated units
+            # because we handled these above where we stop the unit.
+            # Since only services can be socket-activated, the
+            # following condition always evaluates to `true` for
+            # non-service units.
+            if ($socketActivated) {
+                return;
+            }
+
+            # If we are restarting a socket, also stop the corresponding
+            # service. This is required because restarting a socket
+            # when the service is already activated fails.
+            if ($unit =~ /\.socket$/) {
+                my $service = $unitInfo->{Service} // "";
+                if ($service eq "") {
+                    $service = "$baseName.service";
+                }
+                if (defined $activePrev->{$service}) {
+                    $unitsToStop->{$service} = 1;
+                }
+                $unitsToRestart->{$unit} = 1;
+                recordUnit($restartListFile, $unit);
+            } else {
+                # Always restart non-services instead of stopping and starting them
+                # because it doesn't make sense to stop them with a config from
+                # the old evaluation.
+                if (!boolIsTrue($unitInfo->{'X-StopIfChanged'} // "yes") || $unit !~ /\.service$/) {
+                    # This unit should be restarted instead of
+                    # stopped and started.
+                    $unitsToRestart->{$unit} = 1;
+                    recordUnit($restartListFile, $unit);
+                } else {
+                    # We write to a file to ensure that the
+                    # service gets restarted if we're interrupted.
+                    $unitsToStart->{$unit} = 1;
+                    recordUnit($startListFile, $unit);
+                    $unitsToStop->{$unit} = 1;
+                }
+            }
+        }
+    }
+}
+
 # Figure out what units need to be stopped, started, restarted or reloaded.
 my (%unitsToStop, %unitsToSkip, %unitsToStart, %unitsToRestart, %unitsToReload);
 
···
         }
 
         elsif (fingerprintUnit($prevUnitFile) ne fingerprintUnit($newUnitFile)) {
-            if ($unit eq "sysinit.target" || $unit eq "basic.target" || $unit eq "multi-user.target" || $unit eq "graphical.target") {
-                # Do nothing.  These cannot be restarted directly.
-            } elsif ($unit =~ /\.mount$/) {
-                # Reload the changed mount unit to force a remount.
-                $unitsToReload{$unit} = 1;
-                recordUnit($reloadListFile, $unit);
-            } elsif ($unit =~ /\.socket$/ || $unit =~ /\.path$/ || $unit =~ /\.slice$/) {
-                # FIXME: do something?
-            } else {
-                my $unitInfo = parseUnit($newUnitFile);
-                if (boolIsTrue($unitInfo->{'X-ReloadIfChanged'} // "no")) {
-                    $unitsToReload{$unit} = 1;
-                    recordUnit($reloadListFile, $unit);
-                }
-                elsif (!boolIsTrue($unitInfo->{'X-RestartIfChanged'} // "yes") || boolIsTrue($unitInfo->{'RefuseManualStop'} // "no") || boolIsTrue($unitInfo->{'X-OnlyManualStart'} // "no")) {
-                    $unitsToSkip{$unit} = 1;
-                } else {
-                    if (!boolIsTrue($unitInfo->{'X-StopIfChanged'} // "yes")) {
-                        # This unit should be restarted instead of
-                        # stopped and started.
-                        $unitsToRestart{$unit} = 1;
-                        recordUnit($restartListFile, $unit);
-                    } else {
-                        # If this unit is socket-activated, then stop the
-                        # socket unit(s) as well, and restart the
-                        # socket(s) instead of the service.
-                        my $socketActivated = 0;
-                        if ($unit =~ /\.service$/) {
-                            my @sockets = split / /, ($unitInfo->{Sockets} // "");
-                            if (scalar @sockets == 0) {
-                                @sockets = ("$baseName.socket");
-                            }
-                            foreach my $socket (@sockets) {
-                                if (defined $activePrev->{$socket}) {
-                                    $unitsToStop{$socket} = 1;
-                                    # Only restart sockets that actually
-                                    # exist in new configuration:
-                                    if (-e "$out/etc/systemd/system/$socket") {
-                                        $unitsToStart{$socket} = 1;
-                                        recordUnit($startListFile, $socket);
-                                        $socketActivated = 1;
-                                    }
-                                }
-                            }
-                        }
-
-                        # If the unit is not socket-activated, record
-                        # that this unit needs to be started below.
-                        # We write this to a file to ensure that the
-                        # service gets restarted if we're interrupted.
-                        if (!$socketActivated) {
-                            $unitsToStart{$unit} = 1;
-                            recordUnit($startListFile, $unit);
-                        }
-
-                        $unitsToStop{$unit} = 1;
-                    }
-                }
-            }
+            handleModifiedUnit($unit, $baseName, $newUnitFile, $activePrev, \%unitsToStop, \%unitsToStart, \%unitsToReload, \%unitsToRestart, %unitsToSkip);
         }
     }
 }
···
 }
 
 my @unitsToStopFiltered = filterUnits(\%unitsToStop);
-my @unitsToStartFiltered = filterUnits(\%unitsToStart);
-
 
 # Show dry-run actions.
 if ($action eq "dry-activate") {
···
     print STDERR "would activate the configuration...\n";
     system("$out/dry-activate", "$out");
 
-    $unitsToRestart{$_} = 1 foreach
-        split('\n', read_file($dryRestartByActivationFile, err_mode => 'quiet') // "");
+    # Handle the activation script requesting the restart or reload of a unit.
+    my %unitsToAlsoStop;
+    my %unitsToAlsoSkip;
+    foreach (split('\n', read_file($dryRestartByActivationFile, err_mode => 'quiet') // "")) {
+        my $unit = $_;
+        my $baseUnit = $unit;
+        my $newUnitFile = "$out/etc/systemd/system/$baseUnit";
 
-    $unitsToReload{$_} = 1 foreach
-        split('\n', read_file($dryReloadByActivationFile, err_mode => 'quiet') // "");
+        # Detect template instances.
+        if (!-e $newUnitFile && $unit =~ /^(.*)@[^\.]*\.(.*)$/) {
+          $baseUnit = "$1\@.$2";
+          $newUnitFile = "$out/etc/systemd/system/$baseUnit";
+        }
+
+        my $baseName = $baseUnit;
+        $baseName =~ s/\.[a-z]*$//;
+
+        handleModifiedUnit($unit, $baseName, $newUnitFile, $activePrev, \%unitsToAlsoStop, \%unitsToStart, \%unitsToReload, \%unitsToRestart, %unitsToAlsoSkip);
+    }
+    unlink($dryRestartByActivationFile);
+
+    my @unitsToAlsoStopFiltered = filterUnits(\%unitsToAlsoStop);
+    if (scalar(keys %unitsToAlsoStop) > 0) {
+        print STDERR "would stop the following units as well: ", join(", ", @unitsToAlsoStopFiltered), "\n"
+            if scalar @unitsToAlsoStopFiltered;
+    }
+
+    print STDERR "would NOT restart the following changed units as well: ", join(", ", sort(keys %unitsToAlsoSkip)), "\n"
+        if scalar(keys %unitsToAlsoSkip) > 0;
 
     print STDERR "would restart systemd\n" if $restartSystemd;
+    print STDERR "would reload the following units: ", join(", ", sort(keys %unitsToReload)), "\n"
+        if scalar(keys %unitsToReload) > 0;
     print STDERR "would restart the following units: ", join(", ", sort(keys %unitsToRestart)), "\n"
         if scalar(keys %unitsToRestart) > 0;
+    my @unitsToStartFiltered = filterUnits(\%unitsToStart);
     print STDERR "would start the following units: ", join(", ", @unitsToStartFiltered), "\n"
         if scalar @unitsToStartFiltered;
-    print STDERR "would reload the following units: ", join(", ", sort(keys %unitsToReload)), "\n"
-        if scalar(keys %unitsToReload) > 0;
-    unlink($dryRestartByActivationFile);
-    unlink($dryReloadByActivationFile);
     exit 0;
 }
 
···
     print STDERR "stopping the following units: ", join(", ", @unitsToStopFiltered), "\n"
         if scalar @unitsToStopFiltered;
     # Use current version of systemctl binary before daemon is reexeced.
-    system("$curSystemd/systemctl", "stop", "--", sort(keys %unitsToStop)); # FIXME: ignore errors?
+    system("$curSystemd/systemctl", "stop", "--", sort(keys %unitsToStop));
 }
 
 print STDERR "NOT restarting the following changed units: ", join(", ", sort(keys %unitsToSkip)), "\n"
···
 
 # Handle the activation script requesting the restart or reload of a unit.
 # We can only restart and reload (not stop/start) because the units to be
-# stopped are already stopped before the activation script is run.
-$unitsToRestart{$_} = 1 foreach
-    split('\n', read_file($restartByActivationFile, err_mode => 'quiet') // "");
+# stopped are already stopped before the activation script is run. We do however
+# make an exception for services that are socket-activated and that have to be stopped
+# instead of being restarted.
+my %unitsToAlsoStop;
+my %unitsToAlsoSkip;
+foreach (split('\n', read_file($restartByActivationFile, err_mode => 'quiet') // "")) {
+    my $unit = $_;
+    my $baseUnit = $unit;
+    my $newUnitFile = "$out/etc/systemd/system/$baseUnit";
+
+    # Detect template instances.
+    if (!-e $newUnitFile && $unit =~ /^(.*)@[^\.]*\.(.*)$/) {
+      $baseUnit = "$1\@.$2";
+      $newUnitFile = "$out/etc/systemd/system/$baseUnit";
+    }
+
+    my $baseName = $baseUnit;
+    $baseName =~ s/\.[a-z]*$//;
+
+    handleModifiedUnit($unit, $baseName, $newUnitFile, $activePrev, \%unitsToAlsoStop, \%unitsToStart, \%unitsToReload, \%unitsToRestart, %unitsToAlsoSkip);
+}
+unlink($restartByActivationFile);
+
+my @unitsToAlsoStopFiltered = filterUnits(\%unitsToAlsoStop);
+if (scalar(keys %unitsToAlsoStop) > 0) {
+    print STDERR "stopping the following units as well: ", join(", ", @unitsToAlsoStopFiltered), "\n"
+        if scalar @unitsToAlsoStopFiltered;
+    system("$curSystemd/systemctl", "stop", "--", sort(keys %unitsToAlsoStop));
+}
 
-$unitsToReload{$_} = 1 foreach
-    split('\n', read_file($reloadByActivationFile, err_mode => 'quiet') // "");
+print STDERR "NOT restarting the following changed units as well: ", join(", ", sort(keys %unitsToAlsoSkip)), "\n"
+    if scalar(keys %unitsToAlsoSkip) > 0;
 
 # Restart systemd if necessary. Note that this is done using the
 # current version of systemd, just in case the new one has trouble
···
     print STDERR "reloading the following units: ", join(", ", sort(keys %unitsToReload)), "\n";
     system("@systemd@/bin/systemctl", "reload", "--", sort(keys %unitsToReload)) == 0 or $res = 4;
     unlink($reloadListFile);
-    unlink($reloadByActivationFile);
 }
 
 # Restart changed services (those that have to be restarted rather
 # than stopped and started).
 if (scalar(keys %unitsToRestart) > 0) {
     print STDERR "restarting the following units: ", join(", ", sort(keys %unitsToRestart)), "\n";
-    system("@systemd@/bin/systemctl", "restart", "--", sort(keys %unitsToRestart)) == 0 or $res = 4;
+
+    # We split the units to be restarted into sockets and non-sockets.
+    # This is because restarting sockets may fail which is not bad by
+    # itself but which will prevent changes on the sockets. We usually
+    # restart the socket and stop the service before that. Restarting
+    # the socket will fail however when the service was re-activated
+    # in the meantime. There is no proper way to prevent that from happening.
+    my @unitsWithErrorHandling = grep { $_ !~ /\.socket$/ } sort(keys %unitsToRestart);
+    my @unitsWithoutErrorHandling = grep { $_ =~ /\.socket$/ } sort(keys %unitsToRestart);
+
+    if (scalar(@unitsWithErrorHandling) > 0) {
+        system("@systemd@/bin/systemctl", "restart", "--", @unitsWithErrorHandling) == 0 or $res = 4;
+    }
+    if (scalar(@unitsWithoutErrorHandling) > 0) {
+        # Don't print warnings from systemctl
+        no warnings 'once';
+        open(OLDERR, ">&", \*STDERR);
+        close(STDERR);
+
+        my $ret = system("@systemd@/bin/systemctl", "restart", "--", @unitsWithoutErrorHandling);
+
+        # Print stderr again
+        open(STDERR, ">&OLDERR");
+
+        if ($ret ne 0) {
+            print STDERR "warning: some sockets failed to restart. Please check your journal (journalctl -eb) and act accordingly.\n";
+        }
+    }
     unlink($restartListFile);
     unlink($restartByActivationFile);
 }
···
 # that are symlinks to other units.  We shouldn't start both at the
 # same time because we'll get a "Failed to add path to set" error from
 # systemd.
+my @unitsToStartFiltered = filterUnits(\%unitsToStart);
 print STDERR "starting the following units: ", join(", ", @unitsToStartFiltered), "\n"
     if scalar @unitsToStartFiltered;
 system("@systemd@/bin/systemctl", "start", "--", sort(keys %unitsToStart)) == 0 or $res = 4;
···
 
 
 # Print failed and new units.
-my (@failed, @new, @restarting);
+my (@failed, @new);
 my $activeNew = getActiveUnits;
 while (my ($unit, $state) = each %{$activeNew}) {
     if ($state->{state} eq "failed") {
···
             push @failed, $unit;
         }
     }
-    elsif ($state->{state} ne "failed" && !defined $activePrev->{$unit}) {
+    # Ignore scopes since they are not managed by this script but rather
+    # created and managed by third-party services via the systemd dbus API.
+    elsif ($state->{state} ne "failed" && !defined $activePrev->{$unit} && $unit !~ /\.scope$/) {
         push @new, $unit;
     }
 }

nixos/modules/system/activation/top-level.nix

···
       export localeArchive="${config.i18n.glibcLocales}/lib/locale/locale-archive"
       substituteAll ${./switch-to-configuration.pl} $out/bin/switch-to-configuration
       chmod +x $out/bin/switch-to-configuration
+      ${optionalString (pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform) ''
+        if ! output=$($perl/bin/perl -c $out/bin/switch-to-configuration 2>&1); then
+          echo "switch-to-configuration syntax is not valid:"
+          echo "$output"
+          exit 1
+        fi
+      ''}
 
       echo -n "${toString config.system.extraDependencies}" > $out/extra-dependencies
 

nixos/tests/switch-test.nix

···
   };
 
   nodes = {
-    machine = { ... }: {
+    machine = { config, pkgs, lib, ... }: {
+      environment.systemPackages = [ pkgs.socat ]; # for the socket activation stuff
       users.mutableUsers = false;
+
+      specialisation = {
+        # A system with a simple socket-activated unit
+        simple-socket.configuration = {
+          systemd.services.socket-activated.serviceConfig = {
+            ExecStart = pkgs.writeScript "socket-test.py" /* python */ ''
+              #!${pkgs.python3}/bin/python3
+
+              from socketserver import TCPServer, StreamRequestHandler
+              import socket
+
+              class Handler(StreamRequestHandler):
+                  def handle(self):
+                      self.wfile.write("hello".encode("utf-8"))
+
+              class Server(TCPServer):
+                  def __init__(self, server_address, handler_cls):
+                      # Invoke base but omit bind/listen steps (performed by systemd activation!)
+                      TCPServer.__init__(
+                          self, server_address, handler_cls, bind_and_activate=False)
+                      # Override socket
+                      self.socket = socket.fromfd(3, self.address_family, self.socket_type)
+
+              if __name__ == "__main__":
+                  server = Server(("localhost", 1234), Handler)
+                  server.serve_forever()
+            '';
+          };
+          systemd.sockets.socket-activated = {
+            wantedBy = [ "sockets.target" ];
+            listenStreams = [ "/run/test.sock" ];
+            socketConfig.SocketMode = lib.mkDefault "0777";
+          };
+        };
+
+        # The same system but the socket is modified
+        modified-socket.configuration = {
+          imports = [ config.specialisation.simple-socket.configuration ];
+          systemd.sockets.socket-activated.socketConfig.SocketMode = "0666";
+        };
+
+        # The same system but the service is modified
+        modified-service.configuration = {
+          imports = [ config.specialisation.simple-socket.configuration ];
+          systemd.services.socket-activated.serviceConfig.X-Test = "test";
+        };
+
+        # The same system but both service and socket are modified
+        modified-service-and-socket.configuration = {
+          imports = [ config.specialisation.simple-socket.configuration ];
+          systemd.services.socket-activated.serviceConfig.X-Test = "some_value";
+          systemd.sockets.socket-activated.socketConfig.SocketMode = "0444";
+        };
+
+        # A system with a socket-activated service and some simple services
+        service-and-socket.configuration = {
+          imports = [ config.specialisation.simple-socket.configuration ];
+          systemd.services.simple-service = {
+            wantedBy = [ "multi-user.target" ];
+            serviceConfig = {
+              Type = "oneshot";
+              RemainAfterExit = true;
+              ExecStart = "${pkgs.coreutils}/bin/true";
+            };
+          };
+
+          systemd.services.simple-restart-service = {
+            stopIfChanged = false;
+            wantedBy = [ "multi-user.target" ];
+            serviceConfig = {
+              Type = "oneshot";
+              RemainAfterExit = true;
+              ExecStart = "${pkgs.coreutils}/bin/true";
+            };
+          };
+
+          systemd.services.simple-reload-service = {
+            reloadIfChanged = true;
+            wantedBy = [ "multi-user.target" ];
+            serviceConfig = {
+              Type = "oneshot";
+              RemainAfterExit = true;
+              ExecStart = "${pkgs.coreutils}/bin/true";
+              ExecReload = "${pkgs.coreutils}/bin/true";
+            };
+          };
+
+          systemd.services.no-restart-service = {
+            restartIfChanged = false;
+            wantedBy = [ "multi-user.target" ];
+            serviceConfig = {
+              Type = "oneshot";
+              RemainAfterExit = true;
+              ExecStart = "${pkgs.coreutils}/bin/true";
+            };
+          };
+        };
+
+        # The same system but with an activation script that restarts all services
+        restart-and-reload-by-activation-script.configuration = {
+          imports = [ config.specialisation.service-and-socket.configuration ];
+          system.activationScripts.restart-and-reload-test = {
+            supportsDryActivation = true;
+            deps = [];
+            text = ''
+              if [ "$NIXOS_ACTION" = dry-activate ]; then
+                f=/run/nixos/dry-activation-restart-list
+              else
+                f=/run/nixos/activation-restart-list
+              fi
+              cat <<EOF >> "$f"
+              simple-service.service
+              simple-restart-service.service
+              simple-reload-service.service
+              no-restart-service.service
+              socket-activated.service
+              EOF
+            '';
+          };
+        };
+
+        # A system with a timer
+        with-timer.configuration = {
+          systemd.timers.test-timer = {
+            wantedBy = [ "timers.target" ];
+            timerConfig.OnCalendar = "@1395716396"; # chosen by fair dice roll
+          };
+          systemd.services.test-timer = {
+            serviceConfig = {
+              Type = "oneshot";
+              ExecStart = "${pkgs.coreutils}/bin/true";
+            };
+          };
+        };
+
+        # The same system but with another time
+        with-timer-modified.configuration = {
+          imports = [ config.specialisation.with-timer.configuration ];
+          systemd.timers.test-timer.timerConfig.OnCalendar = lib.mkForce "Fri 2012-11-23 16:00:00";
+        };
+
+        # A system with a systemd mount
+        with-mount.configuration = {
+          systemd.mounts = [
+            {
+              description = "Testmount";
+              what = "tmpfs";
+              type = "tmpfs";
+              where = "/testmount";
+              options = "size=1M";
+              wantedBy = [ "local-fs.target" ];
+            }
+          ];
+        };
+
+        # The same system but with another time
+        with-mount-modified.configuration = {
+          systemd.mounts = [
+            {
+              description = "Testmount";
+              what = "tmpfs";
+              type = "tmpfs";
+              where = "/testmount";
+              options = "size=10M";
+              wantedBy = [ "local-fs.target" ];
+            }
+          ];
+        };
+
+        # A system with a path unit
+        with-path.configuration = {
+          systemd.paths.test-watch = {
+            wantedBy = [ "paths.target" ];
+            pathConfig.PathExists = "/testpath";
+          };
+          systemd.services.test-watch = {
+            serviceConfig = {
+              Type = "oneshot";
+              ExecStart = "${pkgs.coreutils}/bin/touch /testpath-modified";
+            };
+          };
+        };
+
+        # The same system but watching another file
+        with-path-modified.configuration = {
+          imports = [ config.specialisation.with-path.configuration ];
+          systemd.paths.test-watch.pathConfig.PathExists = lib.mkForce "/testpath2";
+        };
+
+        # A system with a slice
+        with-slice.configuration = {
+          systemd.slices.testslice.sliceConfig.MemoryMax = "1"; # don't allow memory allocation
+          systemd.services.testservice = {
+            serviceConfig = {
+              Type = "oneshot";
+              RemainAfterExit = true;
+              ExecStart = "${pkgs.coreutils}/bin/true";
+              Slice = "testslice.slice";
+            };
+          };
+        };
+
+        # The same system but the slice allows to allocate memory
+        with-slice-non-crashing.configuration = {
+          imports = [ config.specialisation.with-slice.configuration ];
+          systemd.slices.testslice.sliceConfig.MemoryMax = lib.mkForce null;
+        };
+      };
     };
     other = { ... }: {
       users.mutableUsers = true;
     };
   };
 
-  testScript = {nodes, ...}: let
+  testScript = { nodes, ... }: let
     originalSystem = nodes.machine.config.system.build.toplevel;
     otherSystem = nodes.other.config.system.build.toplevel;
 
···
       set -o pipefail
       exec env -i "$@" | tee /dev/stderr
     '';
-  in ''
+  in /* python */ ''
+    def switch_to_specialisation(name, action="test"):
+        out = machine.succeed(f"${originalSystem}/specialisation/{name}/bin/switch-to-configuration {action} 2>&1")
+        assert_lacks(out, "switch-to-configuration line")  # Perl warnings
+        return out
+
+    def assert_contains(haystack, needle):
+        if needle not in haystack:
+            print("The haystack that will cause the following exception is:")
+            print("---")
+            print(haystack)
+            print("---")
+            raise Exception(f"Expected string '{needle}' was not found")
+
+    def assert_lacks(haystack, needle):
+        if needle in haystack:
+            print("The haystack that will cause the following exception is:")
+            print("---")
+            print(haystack, end="")
+            print("---")
+            raise Exception(f"Unexpected string '{needle}' was found")
+
+
     machine.succeed(
         "${stderrRunner} ${originalSystem}/bin/switch-to-configuration test"
     )
     machine.succeed(
         "${stderrRunner} ${otherSystem}/bin/switch-to-configuration test"
     )
+
+    with subtest("systemd sockets"):
+        machine.succeed("${originalSystem}/bin/switch-to-configuration test")
+
+        # Simple socket is created
+        out = switch_to_specialisation("simple-socket")
+        assert_lacks(out, "stopping the following units:")
+        # not checking for reload because dbus gets reloaded
+        assert_lacks(out, "restarting the following units:")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_contains(out, "the following new units were started: socket-activated.socket\n")
+        assert_lacks(out, "as well:")
+        machine.succeed("[ $(stat -c%a /run/test.sock) = 777 ]")
+
+        # Changing the socket restarts it
+        out = switch_to_specialisation("modified-socket")
+        assert_lacks(out, "stopping the following units:")
+        #assert_lacks(out, "reloading the following units:")
+        assert_contains(out, "restarting the following units: socket-activated.socket\n")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+        machine.succeed("[ $(stat -c%a /run/test.sock) = 666 ]")  # change was applied
+
+        # The unit is properly activated when the socket is accessed
+        if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
+            raise Exception("Socket was not properly activated")
+
+        # Changing the socket restarts it and ignores the active service
+        out = switch_to_specialisation("simple-socket")
+        assert_contains(out, "stopping the following units: socket-activated.service\n")
+        assert_lacks(out, "reloading the following units:")
+        assert_contains(out, "restarting the following units: socket-activated.socket\n")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+        machine.succeed("[ $(stat -c%a /run/test.sock) = 777 ]")  # change was applied
+
+        # Changing the service does nothing when the service is not active
+        out = switch_to_specialisation("modified-service")
+        assert_lacks(out, "stopping the following units:")
+        assert_lacks(out, "reloading the following units:")
+        assert_lacks(out, "restarting the following units:")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+
+        # Activating the service and modifying it stops it but leaves the socket untouched
+        machine.succeed("socat - UNIX-CONNECT:/run/test.sock")
+        out = switch_to_specialisation("simple-socket")
+        assert_contains(out, "stopping the following units: socket-activated.service\n")
+        assert_lacks(out, "reloading the following units:")
+        assert_lacks(out, "restarting the following units:")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+
+        # Activating the service and both the service and the socket stops the service and restarts the socket
+        machine.succeed("socat - UNIX-CONNECT:/run/test.sock")
+        out = switch_to_specialisation("modified-service-and-socket")
+        assert_contains(out, "stopping the following units: socket-activated.service\n")
+        assert_lacks(out, "reloading the following units:")
+        assert_contains(out, "restarting the following units: socket-activated.socket\n")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+
+    with subtest("restart and reload by activation file"):
+        out = switch_to_specialisation("service-and-socket")
+        # Switch to a system where the example services get restarted
+        # by the activation script
+        out = switch_to_specialisation("restart-and-reload-by-activation-script")
+        assert_lacks(out, "stopping the following units:")
+        assert_contains(out, "stopping the following units as well: simple-service.service, socket-activated.service\n")
+        assert_contains(out, "reloading the following units: simple-reload-service.service\n")
+        assert_contains(out, "restarting the following units: simple-restart-service.service\n")
+        assert_contains(out, "\nstarting the following units: simple-service.service")
+
+        # The same, but in dry mode
+        switch_to_specialisation("service-and-socket")
+        out = switch_to_specialisation("restart-and-reload-by-activation-script", action="dry-activate")
+        assert_lacks(out, "would stop the following units:")
+        assert_contains(out, "would stop the following units as well: simple-service.service, socket-activated.service\n")
+        assert_contains(out, "would reload the following units: simple-reload-service.service\n")
+        assert_contains(out, "would restart the following units: simple-restart-service.service\n")
+        assert_contains(out, "\nwould start the following units: simple-service.service")
+
+    with subtest("mounts"):
+        switch_to_specialisation("with-mount")
+        out = machine.succeed("mount | grep 'on /testmount'")
+        assert_contains(out, "size=1024k")
+
+        out = switch_to_specialisation("with-mount-modified")
+        assert_lacks(out, "stopping the following units:")
+        assert_contains(out, "reloading the following units: testmount.mount\n")
+        assert_lacks(out, "restarting the following units:")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+        # It changed
+        out = machine.succeed("mount | grep 'on /testmount'")
+        assert_contains(out, "size=10240k")
+
+    with subtest("timers"):
+        switch_to_specialisation("with-timer")
+        out = machine.succeed("systemctl show test-timer.timer")
+        assert_contains(out, "OnCalendar=2014-03-25 02:59:56 UTC")
+
+        out = switch_to_specialisation("with-timer-modified")
+        assert_lacks(out, "stopping the following units:")
+        assert_lacks(out, "reloading the following units:")
+        assert_contains(out, "restarting the following units: test-timer.timer\n")
+        assert_lacks(out, "\nstarting the following units:")
+        assert_lacks(out, "the following new units were started:")
+        assert_lacks(out, "as well:")
+        # It changed
+        out = machine.succeed("systemctl show test-timer.timer")
+        assert_contains(out, "OnCalendar=Fri 2012-11-23 16:00:00")
+
+    with subtest("paths"):
+        switch_to_specialisation("with-path")
+        machine.fail("test -f /testpath-modified")
+
+        # touch the file, unit should be triggered
+        machine.succeed("touch /testpath")
+        machine.wait_until_succeeds("test -f /testpath-modified")
+
+        machine.succeed("rm /testpath /testpath-modified")
+        switch_to_specialisation("with-path-modified")
+
+        machine.succeed("touch /testpath")
+        machine.fail("test -f /testpath-modified")
+        machine.succeed("touch /testpath2")
+        machine.wait_until_succeeds("test -f /testpath-modified")
+
+    # This test ensures that changes to slice configuration get applied.
+    # We test this by having a slice that allows no memory allocation at
+    # all and starting a service within it. If the service crashes, the slice
+    # is applied and if we modify the slice to allow memory allocation, the
+    # service should successfully start.
+    with subtest("slices"):
+        machine.succeed("echo 0 > /proc/sys/vm/panic_on_oom")  # allow OOMing
+        out = switch_to_specialisation("with-slice")
+        machine.fail("systemctl start testservice.service")
+        out = switch_to_specialisation("with-slice-non-crashing")
+        machine.succeed("systemctl start testservice.service")
+        machine.succeed("echo 1 > /proc/sys/vm/panic_on_oom")  # disallow OOMing
+
   '';
 })

pkgs/applications/audio/ptcollab/default.nix

···
 
 mkDerivation rec {
   pname = "ptcollab";
-  version = "0.4.3";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "yuxshao";
     repo = "ptcollab";
     rev = "v${version}";
-    sha256 = "sha256-bFFWPl7yaTwCKz7/f9Vk6mg0roUnig0dFERS4IE4R7g=";
+    sha256 = "sha256-sN3O8m+ib6Chb/RXTFbNWW6PnrolCHpmC/avRX93AH4=";
   };
 
   nativeBuildInputs = [ qmake pkg-config ];

pkgs/applications/misc/logseq/default.nix

···
-{ lib, stdenv, fetchurl, appimageTools, makeWrapper, electron }:
+{ lib, stdenv, fetchurl, appimageTools, makeWrapper, electron_13 }:
 
 stdenv.mkDerivation rec {
   pname = "logseq";
-  version = "0.3.5";
+  version = "0.4.2";
 
   src = fetchurl {
     url = "https://github.com/logseq/logseq/releases/download/${version}/logseq-linux-x64-${version}.AppImage";
-    sha256 = "ruJALAI0YQNwG8An5VzoJX06Qu/pXZ9zsrPZ7EH+5Pk=";
+    sha256 = "BEDScQtGfkp74Gx3RKK8ItNQ9JD8AJkl1zdS/gZqyXk=";
     name = "${pname}-${version}.AppImage";
   };
 
···
   '';
 
   postFixup = ''
-    makeWrapper ${electron}/bin/electron $out/bin/${pname} \
+    makeWrapper ${electron_13}/bin/electron $out/bin/${pname} \
       --add-flags $out/share/${pname}/resources/app
   '';
 

pkgs/applications/office/qownnotes/default.nix

···
 
 mkDerivation rec {
   pname = "qownnotes";
-  version = "21.9.2";
+  version = "21.10.9";
 
   src = fetchurl {
     url = "https://download.tuxfamily.org/${pname}/src/${pname}-${version}.tar.xz";
     # Fetch the checksum of current version with curl:
     # curl https://download.tuxfamily.org/qownnotes/src/qownnotes-<version>.tar.xz.sha256
-    sha256 = "sha256-R+aXPnQ2Ns2D8PBTvaeh8ht3juZZhZJIb52A8CVRtFI=";
+    sha256 = "2c86d66ae427bdcd16d706b982cedaa669a27340f7819fc97a8e2b24c709e74f";
   };
 
   nativeBuildInputs = [ qmake qttools ];

pkgs/applications/version-management/git-and-tools/fast-export/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fast-export";
-  version = "200213";
+  version = "210917";
 
   src = fetchFromGitHub {
     owner = "frej";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0hzyh66rlawxip4n2pvz7pbs0cq82clqv1d6c7hf60v1drjxw287";
+    sha256 = "0xg8r9rbqv7mriraqxdks2mgj7j4c9gap3kc05y1kxi3nniywyd3";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/applications/version-management/pijul/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "pijul";
-  version = "1.0.0-alpha.53";
+  version = "1.0.0-alpha.54";
 
   src = fetchCrate {
     inherit version pname;
-    sha256 = "1y5wnqscyfhd806qs6gfmssm7hvfdi7mxc9p1125jnmzca4wcsm2";
+    sha256 = "0b9494kwchfds8hk566k3fkwdvcskpgw0ajlrdry9lmmvx3vj7dc";
   };
 
-  cargoSha256 = "0m9zjagq59rxf5pysklal030f4n0dqgmjsgwcnljajxc2r26665h";
+  cargoSha256 = "0rgd6mfxbxgzpj2nj2y315kgvxiayr9xbma4j014bc61ms7cnys7";
 
   cargoBuildFlags = lib.optional gitImportSupport "--features=git";
 

pkgs/applications/video/ffmpeg-normalize/default.nix

···
 
 buildPythonApplication rec {
   pname = "ffmpeg-normalize";
-  version = "1.22.3";
+  version = "1.22.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "317a9636587182280debc85d483f6d21987ceb6cd96ab36a2399836780eca822";
+    sha256 = "a20978538ae9a51bdbe5ef5aa0f87ede0f8efd2817ab240980de56eac36982e3";
   };
 
   propagatedBuildInputs = [ ffmpeg ffmpeg-progress-yield ];

pkgs/data/fonts/bront/default.nix

···
+{ stdenvNoCC, lib, fetchFromGitHub }:
+
+stdenvNoCC.mkDerivation {
+  pname = "bront_fonts";
+  version = "unstable-2015-06-28";
+
+  src = fetchFromGitHub {
+    owner = "chrismwendt";
+    repo = "bront";
+    rev = "aef23d9a11416655a8351230edb3c2377061c077";
+    sha256 = "1sx2gv19pgdyccb38sx3qnwszksmva7pqa1c8m35s6cipgjhhgb4";
+  };
+
+  installPhase = ''
+    install -m444 -Dt $out/share/fonts/truetype *Bront.ttf
+  '';
+
+  meta = with lib; {
+    description = "Bront Fonts";
+    longDescription = "Ubuntu Mono Bront and DejaVu Sans Mono Bront fonts.";
+    homepage = "https://github.com/chrismwendt/bront";
+    license = licenses.free;
+    platforms = platforms.all;
+    maintainers = [ maintainers.grburst ];
+  };
+}

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "67f421ee170f4f161832c146be8ef87499ff0d37",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/67f421ee170f4f161832c146be8ef87499ff0d37.tar.gz",
-  "sha256": "0rzwh0iff4xn499vvzv960gmrd85z6amjbbsyhb5qcldcap5jpjs",
-  "msg": "Update from Hackage at 2021-10-11T20:00:11Z"
+  "commit": "73463ac080cd55650580d58fe80e5b2dcdfe5a7e",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/73463ac080cd55650580d58fe80e5b2dcdfe5a7e.tar.gz",
+  "sha256": "1vwlpkrpfj6wdzlv4lwargyakyci81gri70z2jhkpvv3l6adc0gk",
+  "msg": "Update from Hackage at 2021-10-15T10:42:20Z"
 }

pkgs/desktops/enlightenment/terminology/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "terminology";
-  version = "1.9.0";
+  version = "1.10.0";
 
   src = fetchurl {
     url = "http://download.enlightenment.org/rel/apps/${pname}/${pname}-${version}.tar.xz";
-    sha256 = "0v74858yvrrfy0l2pq7yn6izvqhpkb9gw2jpd3a3khjwv8kw6frz";
+    sha256 = "0imk7cjkcjss3zf4hjwmy54pbizm6l6pq553jcx7bpsnhs56bbsz";
   };
 
   nativeBuildInputs = [
···
     patchShebangs data/colorschemes/*.py
   '';
 
-  meta = {
+  meta = with lib; {
     description = "Powerful terminal emulator based on EFL";
     homepage = "https://www.enlightenment.org/about-terminology";
-    license = lib.licenses.bsd2;
-    platforms = lib.platforms.linux;
-    maintainers = with lib.maintainers; [ matejc tstrobel ftrvxmtrx romildo ];
+    license = licenses.bsd2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ matejc tstrobel ftrvxmtrx romildo ];
   };
 }

pkgs/development/compilers/graalvm/001_mx.py.patch

···
-diff --git a/mx.py b/mx.py
-index a0b9315..b7d67a0 100755
---- a/mx.py
-+++ b/mx.py
-@@ -238,21 +238,7 @@ def _check_file_with_sha1(path, sha1, sha1path, mustExist=True, newFile=False, l
-             f.write(value or sha1OfFile(path))
- 
-     if exists(path):
--        if sha1Check and sha1:
--            if not _sha1CachedValid() or (newFile and sha1 != _sha1Cached()):
--                logv('Create/update SHA1 cache file ' + sha1path)
--                _writeSha1Cached()
--
--            if sha1 != _sha1Cached():
--                computedSha1 = sha1OfFile(path)
--                if sha1 == computedSha1:
--                    warn('Fixing corrupt SHA1 cache file ' + sha1path)
--                    _writeSha1Cached(computedSha1)
--                    return True
--                if logErrors:
--                    size = os.path.getsize(path)
--                    log_error('SHA1 of {} [size: {}] ({}) does not match expected value ({})'.format(TimeStampFile(path), size, computedSha1, sha1))
--                return False
-+        return True
-     elif mustExist:
-         if logErrors:
-             log_error("'{}' does not exist".format(path))
-@@ -1057,46 +1043,8 @@ class SuiteImport:
-         version = import_dict.get("version")
-         suite_dir = None
-         version_from = import_dict.get("versionFrom")
--        if version_from and version:
--            abort("In import for '{}': 'version' and 'versionFrom' can not be both set".format(name), context=context)
--        if version is None and version_from is None:
--            if not (in_subdir and (importer.vc_dir != importer.dir or isinstance(importer, BinarySuite))):
--                abort("In import for '{}': No version given and not a 'subdir' suite of the same repository".format(name), context=context)
--            if importer.isSourceSuite():
--                suite_dir = join(importer.vc_dir, name)
--            version = importer.version()
--        if urls is None:
--            if not in_subdir:
--                if import_dict.get("subdir") is None and importer.vc_dir != importer.dir:
--                    warn("In import for '{}': No urls given but 'subdir' is not set, assuming 'subdir=True'".format(name), context)
--                    in_subdir = True
--                else:
--                    abort("In import for '{}': No urls given and not a 'subdir' suite".format(name), context=context)
--            return SuiteImport(name, version, None, None, dynamicImport=dynamicImport, in_subdir=in_subdir, version_from=version_from, suite_dir=suite_dir)
--        # urls a list of alternatives defined as dicts
--        if not isinstance(urls, list):
--            abort('suite import urls must be a list', context=context)
--        urlinfos = []
--        mainKind = None
--        for urlinfo in urls:
--            if isinstance(urlinfo, dict) and urlinfo.get('url') and urlinfo.get('kind'):
--                kind = urlinfo.get('kind')
--                if not VC.is_valid_kind(kind):
--                    abort('suite import kind ' + kind + ' illegal', context=context)
--            else:
--                abort('suite import url must be a dict with {"url", kind", attributes', context=context)
--            vc = vc_system(kind)
--            if kind != 'binary':
--                assert not mainKind or mainKind == kind, "Only expecting one non-binary kind"
--                mainKind = kind
--            url = mx_urlrewrites.rewriteurl(urlinfo.get('url'))
--            urlinfos.append(SuiteImportURLInfo(url, kind, vc))
--        vc_kind = None
--        if mainKind:
--            vc_kind = mainKind
--        elif urlinfos:
--            vc_kind = 'binary'
--        return SuiteImport(name, version, urlinfos, vc_kind, dynamicImport=dynamicImport, in_subdir=in_subdir, version_from=version_from, suite_dir=suite_dir)
-+        suite_dir = join(get_env('MX_GIT_CACHE_DIR'), name)
-+        return SuiteImport(name, version, [], None, True, in_subdir=in_subdir, version_from=version_from, suite_dir=suite_dir)
- 
-     @staticmethod
-     def get_source_urls(source, kind=None):
-@@ -1467,8 +1415,6 @@ class Suite(object):
-     :type dists: list[Distribution]
-     """
-     def __init__(self, mxDir, primary, internal, importing_suite, load, vc, vc_dir, dynamicallyImported=False):
--        if primary is True and vc_dir is None:
--            abort("The primary suite must be in a vcs repository")
-         self.imported_by = [] if primary else [importing_suite]
-         self.mxDir = mxDir
-         self.dir = dirname(mxDir)
-@@ -1496,7 +1442,7 @@ class Suite(object):
-         self._outputRoot = None
-         self._preloaded_suite_dict = None
-         self.vc = vc
--        self.vc_dir = vc_dir
-+        self.vc_dir = get_env('MX_GIT_CACHE_DIR')
-         self._preload_suite_dict()
-         self._init_imports()
-         if load:
-@@ -2405,7 +2351,9 @@ class Repository(SuiteConstituent):
- class SourceSuite(Suite):
-     """A source suite"""
-     def __init__(self, mxDir, primary=False, load=True, internal=False, importing_suite=None, dynamicallyImported=False):
--        vc, vc_dir = VC.get_vc_root(dirname(mxDir), abortOnError=False)
-+        vc, vc_dir_test = VC.get_vc_root(dirname(mxDir), abortOnError=False)
-+        vc_dir = get_env('MX_GIT_CACHE_DIR')
-+        warn("LOOKING FOR: " + mxDir)
-         Suite.__init__(self, mxDir, primary, internal, importing_suite, load, vc, vc_dir, dynamicallyImported=dynamicallyImported)
-         logvv("SourceSuite.__init__({}), got vc={}, vc_dir={}".format(mxDir, self.vc, self.vc_dir))
-         self.projects = []
-@@ -2454,17 +2402,7 @@ class SourceSuite(Suite):
-         """
-         Gets the release tag from VC or create a time based once if VC is unavailable
-         """
--        if snapshotSuffix not in self._releaseVersion:
--            _version = self._get_early_suite_dict_property('version')
--            if _version and self.getMxCompatibility().addVersionSuffixToExplicitVersion():
--                if not self.is_release():
--                    _version = _version + '-' + snapshotSuffix
--            if not _version:
--                _version = self.vc.release_version_from_tags(self.vc_dir, self.name, snapshotSuffix=snapshotSuffix)
--            if not _version:
--                _version = 'unknown-{0}-{1}'.format(platform.node(), time.strftime('%Y-%m-%d_%H-%M-%S_%Z'))
--            self._releaseVersion[snapshotSuffix] = _version
--        return self._releaseVersion[snapshotSuffix]
-+        return get_env('version')
- 
-     def scm_metadata(self, abortOnError=False):
-         scm = self.scm
-@@ -2993,12 +2931,35 @@ def _find_suite_import(importing_suite, suite_import, fatalIfMissing=True, load=
-         Attempts to locate an existing suite in the local context
-         Returns the path to the mx.name dir if found else None
-         """
--        if mode == 'binary':
--            # binary suites are always stored relative to the importing suite in mx-private directory
--            return importing_suite._find_binary_suite_dir(suite_import.name)
-+        warn("FAKE CLONE: " + str(suite_import))
-+        if (suite_import.name == "truffle"):
-+            return join(get_env('TMP'), "source", "truffle", "mx.truffle")
-+        if (suite_import.name == "graal-nodejs"):
-+            return join(get_env('MX_GIT_CACHE_DIR'), "graaljs", "graal-nodejs", "mx.graal-nodejs")
-+        if (suite_import.name == "truffleruby"):
-+            return join(get_env('MX_GIT_CACHE_DIR'), "truffleruby", "mx.truffleruby")
-+        if (suite_import.name == "graalpython"):
-+            return join(get_env('MX_GIT_CACHE_DIR'), "graalpython", "mx.graalpython")
-+        if (suite_import.name == "vm"):
-+            return join(get_env('TMP'), "source", "vm", "mx.vm")
-+        if (suite_import.name == "fastr"):
-+            return join(get_env('MX_GIT_CACHE_DIR'), "fastr", "mx.fastr")
-+        if (suite_import.name == "sdk"):
-+            return join(get_env('TMP'), "source", "sdk", "mx.sdk")
-+        if (suite_import.name == "graal-js"):
-+            return join(get_env('MX_GIT_CACHE_DIR'), "graaljs", "graal-js", "mx.graal-js")
-+        if (suite_import.name == "regex"):
-+            return join(get_env('TMP'), "source", "regex", "mx.regex")
-+        if (suite_import.name == "substratevm"):
-+            return join(get_env('TMP'), "source", "substratevm", "mx.substratevm")
-+        if (suite_import.name == "tools"):
-+            return join(get_env('TMP'), "source", "tools", "mx.tools")
-+        if (suite_import.name == "sulong"):
-+            return join(get_env('TMP'), "source", "sulong", "mx.sulong")
-+        if (suite_import.name == "compiler"):
-+            return join(get_env('TMP'), "source", "compiler", "mx.compiler")
-         else:
--            # use the SuiteModel to locate a local source copy of the suite
--            return _suitemodel.find_suite_dir(suite_import)
-+            return join(get_env('MX_GIT_CACHE_DIR'), suite_import.name)
- 
-     def _get_import_dir(url, mode):
-         """Return directory where the suite will be cloned to"""
-@@ -3816,7 +3777,7 @@ def getmtime(name):
-     """
-     Wrapper for builtin open function that handles long path names on Windows.
-     """
--    return os.path.getmtime(_safe_path(name))
-+    return 315532800
- 
- 
- def stat(name):
-@@ -4062,57 +4023,8 @@ def _attempt_download(url, path, jarEntryName=None):
-     return False
- 
- def download(path, urls, verbose=False, abortOnError=True, verifyOnly=False):
--    """
--    Attempts to downloads content for each URL in a list, stopping after the first successful download.
--    If the content cannot be retrieved from any URL, the program is aborted, unless abortOnError=False.
--    The downloaded content is written to the file indicated by `path`.
--    """
--    if not verifyOnly:
--        ensure_dirname_exists(path)
--        assert not path.endswith(os.sep)
--
--    # https://docs.oracle.com/javase/7/docs/api/java/net/JarURLConnection.html
--    jarURLPattern = re.compile('jar:(.*)!/(.*)')
--    verify_errors = {}
--    for url in urls:
--        if not verifyOnly or verbose:
--            log('Downloading ' + url + ' to ' + path)
--        m = jarURLPattern.match(url)
--        jarEntryName = None
--        if m:
--            url = m.group(1)
--            jarEntryName = m.group(2)
--
--        if not _opts.trust_http and (url.lower().startswith('http://') or url.lower().startswith('ftp://')):
--            warn('Downloading from non-https URL {}. Use --trust-http mx option to suppress this warning.'.format(url))
--
--        if verifyOnly:
--            try:
--                conn = _urlopen(url, timeout=10)
--                conn.close()
--            except (IOError, socket.timeout) as e:
--                _suggest_tlsv1_error(e)
--                verify_errors[url] = e
--        else:
--            for i in range(4):
--                if i != 0:
--                    time.sleep(1)
--                    warn('Retry {} to download from {}'.format(i, url))
--                if _attempt_download(url, path, jarEntryName):
--                    return True # Download was successful
--
--    if verifyOnly and len(verify_errors) < len(urls): # verify-mode at least one success -> success
--        return True
--    else: # Either verification error or no download was successful
--        msg = 'Could not download to ' + path + ' from any of the following URLs: ' + ', '.join(urls)
--        if verifyOnly: # verify-mode -> print error details
--            for url, e in verify_errors.items():
--                msg += '\n  ' + url + ': ' + str(e)
--        if abortOnError:
--            abort(msg)
--        else:
--            warn(msg)
--            return False
-+    print("FAKE download(path={} urls={} verbose={} abortOnError={} verifyOnly={})".format(path, urls, verbose, abortOnError, verifyOnly))
-+    return True
- 
- def update_file(path, content, showDiff=False):
-     """
-@@ -7887,30 +7799,6 @@ class PackedResourceLibrary(ResourceLibrary):
- 
-     def get_path(self, resolve):
-         extract_path = _make_absolute(self.extract_path, self.suite.dir)
--        download_path = super(PackedResourceLibrary, self).get_path(resolve)
--        if resolve and self._check_extract_needed(extract_path, download_path):
--            extract_path_tmp = tempfile.mkdtemp(suffix=basename(extract_path), dir=dirname(extract_path))
--            try:
--                # extract archive
--                Extractor.create(download_path).extract(extract_path_tmp)
--                # ensure modification time is up to date
--                os.utime(extract_path_tmp, None)
--                logv("Moving temporary directory {} to {}".format(extract_path_tmp, extract_path))
--                try:
--                    # attempt atomic overwrite
--                    os.rename(extract_path_tmp, extract_path)
--                except OSError:
--                    # clean destination & re-try for cases where atomic overwrite doesn't work
--                    rmtree(extract_path, ignore_errors=True)
--                    os.rename(extract_path_tmp, extract_path)
--            except OSError as ose:
--                # Rename failed. Race with other process?
--                if self._check_extract_needed(extract_path, download_path):
--                    # ok something really went wrong
--                    abort("Extracting {} failed!".format(download_path), context=ose)
--            finally:
--                rmtree(extract_path_tmp, ignore_errors=True)
--
-         return extract_path
- 
-     def _check_download_needed(self):
-@@ -8430,7 +8318,7 @@ class VC(_with_metaclass(ABCMeta, object)):
-         :param str branch: a branch name
-         :param bool abortOnError: if True abort on error
-         """
--        abort(self.kind + " update_to_branch is not implemented")
-+        self.run(['hg', vcdir] + cmd)
- 
-     def is_release_from_tags(self, vcdir, prefix):
-         """
-@@ -8831,7 +8719,7 @@ class HgConfig(VC):
-                 return None
- 
-     def parent_info(self, vcdir, abortOnError=True):
--        out = self.hg_command(vcdir, ["log", "-r", ".", "--template", "{author}|||{date|hgdate}"], abortOnError=abortOnError)
-+        out = _check_output_str(["hg", '-R', vcdir, "log", "-r", ".", "--template", "{author}|||{date|hgdate}"])
-         author, date = out.split("|||")
-         ts, _ = date.split(" ")
-         return self._sanitize_parent_info({
-@@ -14069,6 +13957,7 @@ class Archiver(SafeFileCreation):
- 
-     def _add_zip(self, filename, archive_name, provenance):
-         self._add_provenance(archive_name, provenance)
-+        os.utime(filename, (315532800, 315532800))
-         self.zf.write(filename, archive_name)
- 
-     def _add_str_zip(self, data, archive_name, provenance):

pkgs/development/compilers/graalvm/002_setjmp.c.patch

···
-diff --git a/sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/src/setjmp.c b/sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/src/setjmp.c
-index 16b869354d8..3691739d13b 100644
---- a/sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/src/setjmp.c
-+++ b/sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/src/setjmp.c
-@@ -41,11 +41,3 @@ int sigsetjmp(sigjmp_buf env, int savesigs) {
-   WARN_UNSUPPORTED(sigsetjmp);
-   return 0;
- }
--
--void longjmp(jmp_buf env, int val) {
--  ERR_UNSUPPORTED(longjmp);
--}
--
--void siglongjmp(sigjmp_buf env, int val) {
--  ERR_UNSUPPORTED(siglongjmp);
--}

pkgs/development/compilers/graalvm/003_mx_truffle.py.patch

···
-diff --git a/truffle/mx.truffle/mx_truffle.py b/truffle/mx.truffle/mx_truffle.py
-index 8889c5ad810..add211a45c5 100644
---- a/truffle/mx.truffle/mx_truffle.py
-+++ b/truffle/mx.truffle/mx_truffle.py
-@@ -695,6 +695,7 @@ class LibffiBuildTask(mx.AbstractNativeBuildTask):
-                      os.path.relpath(self.subject.delegate.dir, self.subject.suite.vc_dir)]
-         for patch in self.subject.patches:
-             mx.run(git_apply + [patch], cwd=self.subject.suite.vc_dir)
-+        mx.run(['cp', os.path.join(os.getenv('TMP'), 'truffle.make'), os.path.join(self.subject.delegate.dir, 'Makefile')])
- 
-         self.delegate.logBuild()
-         self.delegate.build()

pkgs/development/compilers/graalvm/004_mx_jvmci.py.patch

···
-diff --git a/mx.jvmci/mx_jvmci.py b/mx.jvmci/mx_jvmci.py
-index 491fc19ab9..b4ddc03abb 100644
---- a/mx.jvmci/mx_jvmci.py
-+++ b/mx.jvmci/mx_jvmci.py
-@@ -192,6 +192,7 @@ class HotSpotVMJDKDeployedDist(JDKDeployedDist):
-                 if m.name in _hs_deploy_map:
-                     targetDir = join(jdkDir, _hs_deploy_map[m.name])
-                     mx.logv('Deploying {} from {} to {}'.format(m.name, dist.name, targetDir))
-+                    subprocess.call(["chmod", "-R", "+rw", targetDir])
-                     tar.extract(m, targetDir)
- 
- """

pkgs/development/compilers/graalvm/005_tool_jt.rb.patch

···
-diff --git a/tool/jt.rb b/tool/jt.rb
-index 870d88edcb..0a6e4c367b 100755
---- a/tool/jt.rb
-+++ b/tool/jt.rb
-@@ -152,13 +152,16 @@ module Utilities
-   end
- 
-   def find_mx
--    if which('mx')
--      'mx'
-+    if ENV.key?("MX_GIT_CACHE_DIR")
-+      "mx-internal"
-     else
--      mx_repo = find_or_clone_repo("https://github.com/graalvm/mx.git")
--      "#{mx_repo}/mx"
-+      if which('mx')
-+        'mx'
-+      else
-+        mx_repo = find_or_clone_repo("https://github.com/graalvm/mx.git")
-+        "#{mx_repo}/mx"
-+      end
-     end
--  end
- 
-   def find_launcher(use_native)
-     if use_native
-@@ -444,8 +447,8 @@ module Commands
-           --no-sforceimports                         do not run sforceimports before building
-           parser                                     build the parser
-           options                                    build the options
--          graalvm                                    build a minimal JVM-only GraalVM containing only TruffleRuby, 
--                                                     available by default in mxbuild/truffleruby-jvm, 
-+          graalvm                                    build a minimal JVM-only GraalVM containing only TruffleRuby,
-+                                                     available by default in mxbuild/truffleruby-jvm,
-                                                      the Ruby is symlinked into rbenv or chruby if available
-               --graal      include the GraalVM Compiler in the build
-               --native     build native ruby image as well, available in mxbuild/truffleruby-native
-@@ -491,7 +494,7 @@ module Commands
-       jt test compiler                               run compiler tests
-       jt test integration [TESTS]                    run integration tests
-       jt test bundle [--jdebug]                      tests using bundler
--      jt test gems [TESTS]                           tests using gems 
-+      jt test gems [TESTS]                           tests using gems
-       jt test ecosystem [TESTS]                      tests using the wider ecosystem such as bundler, Rails, etc
-       jt test cexts [--no-openssl] [--no-gems] [test_names...]
-                                                      run C extension tests (set GEM_HOME)

pkgs/development/compilers/graalvm/006_mx_copylib.py.patch

···
-diff --git a/mx.fastr/mx_copylib.py b/mx.fastr/mx_copylib.py
-index 4f57e1954..db45220d9 100644
---- a/mx.fastr/mx_copylib.py
-+++ b/mx.fastr/mx_copylib.py
-@@ -54,6 +54,9 @@ def _copylib(lib, libpath, plain_libpath_base, target):
-     else:
-         try:
-             if platform.system() == 'Linux':
-+                # https://github.com/oracle/fastr/issues/110
-+                if libpath.endswith("libgcc_s.so"):
-+                    libpath = libpath + ".1"
-                 output = subprocess.check_output(['objdump', '-p', libpath])
-             elif platform.system() == 'SunOS':
-                 output = subprocess.check_output(['elfdump', '-d', libpath])

pkgs/development/compilers/graalvm/007_unimplemented.c.patch

···
-diff --git a/com.oracle.truffle.r.native/fficall/src/common/unimplemented.c b/com.oracle.truffle.r.native/fficall/src/common/unimplemented.c
-index dcf081316..c2cb4879b 100644
---- a/com.oracle.truffle.r.native/fficall/src/common/unimplemented.c
-+++ b/com.oracle.truffle.r.native/fficall/src/common/unimplemented.c
-@@ -20,8 +20,10 @@
- 
- #include <Rinternals.h>
- #include <stdlib.h>
-+#include <rlocale.h>
- 
- #include <R_ext/eventloop.h>
-+#include <R_ext/GraphicsEngine.h>
- #include <Defn.h>
- 
- Rboolean known_to_be_latin1 = FALSE;
-@@ -166,3 +168,69 @@ int Scollate(SEXP a, SEXP b) {
- void z_prec_r(Rcomplex *r, Rcomplex *x, double digits) {
-     unimplemented("z_prec_r");
- }
-+
-+int Rf_AdobeSymbol2ucs2(int n) {
-+  unimplemented("Rf_AdobeSymbol2ucs2");
-+  return 0;
-+}
-+
-+size_t Mbrtowc(wchar_t *wc, const char *s, size_t n, mbstate_t *ps) {
-+  unimplemented("Mbrtowc");
-+  return 0;
-+}
-+
-+double R_GE_VStrHeight(const char *s, cetype_t enc, const pGEcontext gc, pGEDevDesc dd) {
-+  unimplemented("R_GE_VStrHeight");
-+  return 0;
-+}
-+
-+void R_GE_VText(double x, double y, const char * const s, cetype_t enc,
-+		double x_justify, double y_justify, double rotation,
-+		const pGEcontext gc, pGEDevDesc dd) {
-+  unimplemented("R_GE_VText");
-+}
-+
-+double R_GE_VStrWidth(const char *s, cetype_t enc, const pGEcontext gc, pGEDevDesc dd) {
-+  unimplemented("R_GE_VStrWidth");
-+}
-+
-+void setulb(int n, int m, double *x, double *l, double *u, int *nbd,
-+	    double *f, double *g, double factr, double *pgtol,
-+	    double *wa, int * iwa, char *task, int iprint, int *isave) {
-+  unimplemented("setulb");
-+}
-+
-+void genptry(int n, double *p, double *ptry, double scale, void *ex) {
-+  unimplemented("genptry");
-+}
-+
-+double EXP(double x) {
-+  unimplemented("EXP");
-+  return 0;
-+}
-+
-+double LOG(double x) {
-+  unimplemented("LOG");
-+  return 0;
-+}
-+
-+Rwchar_t Rf_utf8toucs32(wchar_t high, const char *s) {
-+  unimplemented("Rf_utf8toucs32");
-+  return 0;
-+}
-+
-+size_t mbtoucs(unsigned int *wc, const char *s, size_t n) {
-+  unimplemented("mbtoucs");
-+  return (size_t) 0;
-+}
-+
-+
-+int DispatchOrEval(SEXP call, SEXP op, const char *generic, SEXP args,
-+		   SEXP rho, SEXP *ans, int dropmissing, int argsevald) {
-+  unimplemented("DispatchOrEval");
-+  return 0;
-+}
-+
-+void ENSURE_NAMEDMAX (SEXP x) {
-+  unimplemented("ENSURE_NAMEDMAX");
-+}

pkgs/development/compilers/graalvm/008_remove_jfr.patch

···
-diff --git a/mx.jvmci/suite.py b/mx.jvmci/suite.py
-index 9690c0a38f..fa1d36b7e1 100644
---- a/mx.jvmci/suite.py
-+++ b/mx.jvmci/suite.py
-@@ -241,18 +241,7 @@ suite = {
-       "workingSets" : "JVMCI,HotSpot,SPARC",
-     },
- 
--    "jdk.vm.ci.hotspot.jfr" : {
--      "subDir" : "jvmci",
--      "sourceDirs" : ["src"],
--      "dependencies" : [
--        "jdk.vm.ci.hotspot",
--        "JFR",
--      ],
--      "checkstyle" : "jdk.vm.ci.hotspot",
--      "javaCompliance" : "1.8",
--      "profile" : "",
--      "workingSets" : "JVMCI,HotSpot",
--    },
-+
- 
-     "hotspot" : {
-       "native" : True,
-@@ -354,7 +343,7 @@ suite = {
-         "jdk.vm.ci.hotspot.aarch64",
-         "jdk.vm.ci.hotspot.amd64",
-         "jdk.vm.ci.hotspot.sparc",
--        "jdk.vm.ci.hotspot.jfr",
-+
-       ],
-       "distDependencies" : [
-         "JVMCI_SERVICES",

pkgs/development/compilers/graalvm/009_remove_signedness_verifier.patch

···
-diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/query/SizeAndSignednessVerifier.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/query/SizeAndSignednessVerifier.java
-index 23a76357fd2..f13694b6ed7 100644
---- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/query/SizeAndSignednessVerifier.java
-+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/query/SizeAndSignednessVerifier.java
-@@ -249,15 +249,6 @@ public final class SizeAndSignednessVerifier extends NativeInfoTreeVisitor {
-     }
- 
-     private void checkSignedness(boolean isUnsigned, ResolvedJavaType type, ResolvedJavaMethod method) {
--        if (isSigned(type)) {
--            if (isUnsigned) {
--                addError("Type " + type.toJavaName(false) + " is signed, but accessed C value is unsigned", method);
--            }
--        } else if (nativeLibs.isWordBase(type)) {
--            /* every Word type other than Signed is assumed to be unsigned. */
--            if (!isUnsigned) {
--                addError("Type " + type.toJavaName(false) + " is unsigned, but accessed C value is signed", method);
--            }
--        }
-+
-     }
- }

pkgs/development/compilers/graalvm/010_mx_substratevm.py

···
-diff --git a/substratevm/mx.substratevm/mx_substratevm.py b/substratevm/mx.substratevm/mx_substratevm.py
-index b89163ef983..0fd0138b336 100644
---- a/substratevm/mx.substratevm/mx_substratevm.py
-+++ b/substratevm/mx.substratevm/mx_substratevm.py
-@@ -189,7 +189,7 @@ if str(svm_java_compliance().value) not in GRAAL_COMPILER_FLAGS_MAP:
-     mx.abort("Substrate VM does not support this Java version: " + str(svm_java_compliance()))
- GRAAL_COMPILER_FLAGS = GRAAL_COMPILER_FLAGS_BASE + GRAAL_COMPILER_FLAGS_MAP[str(svm_java_compliance().value)]
- 
--IMAGE_ASSERTION_FLAGS = ['-H:+VerifyGraalGraphs', '-H:+VerifyPhases']
-+IMAGE_ASSERTION_FLAGS = ['-H:+VerifyGraalGraphs', '-H:+VerifyPhases', '-H:+ReportExceptionStackTraces']
- suite = mx.suite('substratevm')
- svmSuites = [suite]
- clibraryDists = ['SVM_HOSTED_NATIVE']

pkgs/development/compilers/graalvm/default.nix

···
-{ stdenv, lib, fetchFromGitHub, fetchurl, fetchzip, fetchgit, mercurial_4, python27, setJavaClassPath,
-  which, zlib, makeWrapper, openjdk, unzip, git, clang, llvm, icu, ruby, glibc, bash, gcc, libobjc,
-  xcodebuild, gfortran, readline, bzip2, xz, pcre, curl, ed, libresolv, libiconv, writeScriptBin,
-  openssl, perl, CoreFoundation, Foundation, JavaNativeFoundation, JavaRuntimeSupport, JavaVM, Cocoa
-}:
-
-let
-  version = "19.2.1";
-  mercurial = mercurial_4;
-  truffleMake = ./truffle.make;
-  makeMxGitCache = list: out: ''
-     mkdir ${out}
-    ${lib.concatMapStrings ({ url, name, rev, sha256 }: ''
-      mkdir -p ${out}/${name}
-      cp -rf ${fetchgit { inherit url rev sha256; }}/* ${out}/${name}
-    ''
-    ) list}
-
-    # # GRAAL-NODEJS # #
-    chmod -R +rw ${out}
-    sed -i "s|#include \"../../../../mxbuild/trufflenode/coremodules/node_snapshots.h\"| \
-           #include \"$NIX_BUILD_TOP/mxbuild/graal-nodejs/trufflenode/coremodules/node_snapshots.h\"|g" \
-      ${out}/graaljs/graal-nodejs/deps/v8/src/graal/callbacks.cc
-
-    # patch the shebang in python script runner
-    chmod -R +rw ${out}/graaljs/graal-nodejs/mx.graal-nodejs/python2
-    patchShebangs ${out}/graaljs/graal-nodejs/mx.graal-nodejs/python2/python
-
-    # # TUFFLE-RUBY # #
-    (cd ${out}/truffleruby && git apply ${./005_tool_jt.rb.patch})
-    patchShebangs ${out}/truffleruby/tool/query-versions-json.rb
-
-    substituteInPlace ${out}/truffleruby/src/main/c/Makefile \
-      --replace '(MX_HOME)/mx' '(MX_HOME)/mx-internal'
-
-    substituteInPlace ${out}/truffleruby/src/processor/java/org/truffleruby/processor/BuildInformationProcessor.java \
-      --replace 'trufflerubyHome = findHome();' \
-                'trufflerubyHome = new File(System.getenv("MX_GIT_CACHE_DIR"), "truffleruby");' \
-      --replace tool/query-versions-json.rb 'ruby tool/query-versions-json.rb' \
-      --replace 'revision = runCommand("git rev-parse --short=8 HEAD");' \
-                'revision = "${version}";' \
-      --replace 'compileDate = runCommand("git log -1 --date=short --pretty=format:%cd");' \
-                'compileDate = "1970-01-01";'
-
-    substituteInPlace ${out}/truffleruby/mx.truffleruby/mx_truffleruby.py \
-      --replace "mx_binary = join(mx._mx_home, 'mx')" "mx_binary = join(mx._mx_home, 'mx-internal')"
-
-    # # FASTR # #
-    (cd ${out}/fastr && git apply ${ ./006_mx_copylib.py.patch })
-    (cd ${out}/fastr && git apply ${ ./007_unimplemented.c.patch })
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.parser.processor/src/com/oracle/truffle/r/parser/processor/GenerateRParserProcessor.java \
-      --replace 'File suiteRoot = srcGenDir.getCanonicalFile().getParentFile().getParentFile().getParentFile();' \
-                'File suiteRoot = new File(System.getenv("MX_GIT_CACHE_DIR"), "fastr");'
-
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native/gnur/Makefile.libs \
-      --replace 'mx -p' 'mx-internal -p'
-
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native/include/Makefile \
-      --replace 'mx -p' 'mx-internal -p'
-
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native/fficall/Makefile \
-      --replace 'mx -p' 'mx-internal -p'
-
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native.recommended/Makefile \
-      --replace 'mx -p' 'mx-internal -p'
-
-    # Make sure that the logs aren't hidden when compiling gnur
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native/gnur/Makefile.gnur \
-      --replace '> gnur_configure.log 2>&1' "" \
-      --replace '> gnur_make.log 2>&1' ""
-
-    substituteInPlace ${out}/fastr/com.oracle.truffle.r.native/run/Linux/Renviron \
-      --replace /bin/ "" \
-      --replace /usr/bin/ ""
-
-    sed -i "s|exec \$mx|exec mx-internal|g" ${out}/fastr/com.oracle.truffle.r.native/run/*.sh
-    chmod +x ${out}/fastr/com.oracle.truffle.r.native/run/*.sh
-    patchShebangs ${out}/fastr/com.oracle.truffle.r.native/run/*.sh
-
-    cd ${out}
-    hg init
-    hg add
-    hg commit -m 'dummy commit'
-    hg tag      ${lib.escapeShellArg "vm${version}"}
-    hg checkout ${lib.escapeShellArg "vm${version}"}
-  '';
-
-  # pre-download some cache entries ('mx' will not be able to download under nixbld)
-  makeMxCache = list:
-    stdenv.mkDerivation {
-      name = "mx-cache";
-      nativeBuildInputs = [ unzip ];
-      buildCommand = with lib; ''
-        mkdir $out
-        ${lib.concatMapStrings
-          ({url, name, sha1, isNinja ? false}: ''
-            install -D ${fetchurl { inherit url sha1; }} $out/${name}
-            echo -n ${sha1} > $out/${name}.sha1
-            ${if isNinja then ''
-                export BASENAME=${removeSuffix ".zip" name}
-                mkdir "$out/$BASENAME.extracted" &&
-                unzip "$out/${name}" -d "$out/$BASENAME.extracted"
-
-                # Ninja is called later in the build process
-               ${lib.optionalString stdenv.isLinux ''
-                 if [ -f $out/$BASENAME.extracted/ninja ]; then
-                   patchelf --set-interpreter \
-                     "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-                     --set-rpath "${stdenv.cc.cc.lib}/lib64" \
-                     $out/$BASENAME.extracted/ninja
-                 fi''}
-                ''
-              else ""}
-         '') list}
-      '';
-    };
-
-  jvmci8-mxcache = [
-    rec { sha1 = "53addc878614171ff0fcbc8f78aed12175c22cdb"; name = "JACOCOCORE_0.8.4_${sha1}/jacococore-0.8.4.jar";                                   url = "mirror://maven/org/jacoco/org.jacoco.core/0.8.4/org.jacoco.core-0.8.4.jar"; }
-    rec { sha1 = "9bd1fa334d941005bc9ab3ac92478a590f5b7d73"; name = "JACOCOCORE_0.8.4_${sha1}/jacococore-0.8.4.sources.jar";                           url = "mirror://maven/org/jacoco/org.jacoco.core/0.8.4/org.jacoco.core-0.8.4-sources.jar"; }
-    rec { sha1 = "e5ca9511493b7e3bc2cabdb8ded92e855f3aac32"; name = "JACOCOREPORT_0.8.4_${sha1}/jacocoreport-0.8.4.jar";                               url = "mirror://maven/org/jacoco/org.jacoco.report/0.8.4/org.jacoco.report-0.8.4.jar"; }
-    rec { sha1 = "eb61e479b35b467954f28a565c094c563b790e19"; name = "JACOCOREPORT_0.8.4_${sha1}/jacocoreport-0.8.4.sources.jar";                       url = "mirror://maven/org/jacoco/org.jacoco.report/0.8.4/org.jacoco.report-0.8.4-sources.jar"; }
-    rec { sha1 = "869021a6d90cfb008b12e83fccbe42eca29e5355"; name = "JACOCOAGENT_0.8.4_${sha1}/jacocoagent-0.8.4.jar";                                 url = "mirror://maven/org/jacoco/org.jacoco.agent/0.8.4/org.jacoco.agent-0.8.4-runtime.jar"; }
-    rec { sha1 = "306816fb57cf94f108a43c95731b08934dcae15c"; name = "JOPTSIMPLE_4_6_${sha1}/joptsimple-4-6.jar";                                       url = "mirror://maven/net/sf/jopt-simple/jopt-simple/4.6/jopt-simple-4.6.jar"; }
-    rec { sha1 = "9cd14a61d7aa7d554f251ef285a6f2c65caf7b65"; name = "JOPTSIMPLE_4_6_${sha1}/joptsimple-4-6.sources.jar";                               url = "mirror://maven/net/sf/jopt-simple/jopt-simple/4.6/jopt-simple-4.6-sources.jar"; }
-    rec { sha1 = "fa29aa438674ff19d5e1386d2c3527a0267f291e"; name = "ASM_7.1_${sha1}/asm-7.1.jar";                                                     url = "mirror://maven/org/ow2/asm/asm/7.1/asm-7.1.jar"; }
-    rec { sha1 = "9d170062d595240da35301362b079e5579c86f49"; name = "ASM_7.1_${sha1}/asm-7.1.sources.jar";                                             url = "mirror://maven/org/ow2/asm/asm/7.1/asm-7.1-sources.jar"; }
-    rec { sha1 = "a3662cf1c1d592893ffe08727f78db35392fa302"; name = "ASM_TREE_7.1_${sha1}/asm-tree-7.1.jar";                                           url = "mirror://maven/org/ow2/asm/asm-tree/7.1/asm-tree-7.1.jar"; }
-    rec { sha1 = "157238292b551de8680505fa2d19590d136e25b9"; name = "ASM_TREE_7.1_${sha1}/asm-tree-7.1.sources.jar";                                   url = "mirror://maven/org/ow2/asm/asm-tree/7.1/asm-tree-7.1-sources.jar"; }
-    rec { sha1 = "379e0250f7a4a42c66c5e94e14d4c4491b3c2ed3"; name = "ASM_ANALYSIS_7.1_${sha1}/asm-analysis-7.1.jar";                                   url = "mirror://maven/org/ow2/asm/asm-analysis/7.1/asm-analysis-7.1.jar"; }
-    rec { sha1 = "36789198124eb075f1a5efa18a0a7812fb16f47f"; name = "ASM_ANALYSIS_7.1_${sha1}/asm-analysis-7.1.sources.jar";                           url = "mirror://maven/org/ow2/asm/asm-analysis/7.1/asm-analysis-7.1-sources.jar"; }
-    rec { sha1 = "431dc677cf5c56660c1c9004870de1ed1ea7ce6c"; name = "ASM_COMMONS_7.1_${sha1}/asm-commons-7.1.jar";                                     url = "mirror://maven/org/ow2/asm/asm-commons/7.1/asm-commons-7.1.jar"; }
-    rec { sha1 = "a62ff3ae6e37affda7c6fb7d63b89194c6d006ee"; name = "ASM_COMMONS_7.1_${sha1}/asm-commons-7.1.sources.jar";                             url = "mirror://maven/org/ow2/asm/asm-commons/7.1/asm-commons-7.1-sources.jar"; }
-    rec { sha1 = "ec2544ab27e110d2d431bdad7d538ed509b21e62"; name = "COMMONS_MATH3_3_2_${sha1}/commons-math3-3-2.jar";                                 url = "mirror://maven/org/apache/commons/commons-math3/3.2/commons-math3-3.2.jar"; }
-    rec { sha1 = "cd098e055bf192a60c81d81893893e6e31a6482f"; name = "COMMONS_MATH3_3_2_${sha1}/commons-math3-3-2.sources.jar";                         url = "mirror://maven/org/apache/commons/commons-math3/3.2/commons-math3-3.2-sources.jar"; }
-    rec { sha1 = "442447101f63074c61063858033fbfde8a076873"; name = "JMH_1_21_${sha1}/jmh-1-21.jar";                                                   url = "mirror://maven/org/openjdk/jmh/jmh-core/1.21/jmh-core-1.21.jar"; }
-    rec { sha1 = "a6fe84788bf8cf762b0e561bf48774c2ea74e370"; name = "JMH_1_21_${sha1}/jmh-1-21.sources.jar";                                           url = "mirror://maven/org/openjdk/jmh/jmh-core/1.21/jmh-core-1.21-sources.jar"; }
-    rec { sha1 = "7aac374614a8a76cad16b91f1a4419d31a7dcda3"; name = "JMH_GENERATOR_ANNPROCESS_1_21_${sha1}/jmh-generator-annprocess-1-21.jar";         url = "mirror://maven/org/openjdk/jmh/jmh-generator-annprocess/1.21/jmh-generator-annprocess-1.21.jar"; }
-    rec { sha1 = "fb48e2a97df95f8b9dced54a1a37749d2a64d2ae"; name = "JMH_GENERATOR_ANNPROCESS_1_21_${sha1}/jmh-generator-annprocess-1-21.sources.jar"; url = "mirror://maven/org/openjdk/jmh/jmh-generator-annprocess/1.21/jmh-generator-annprocess-1.21-sources.jar"; }
-    rec { sha1 = "2973d150c0dc1fefe998f834810d68f278ea58ec"; name = "JUNIT_${sha1}/junit.jar";                                                         url = "mirror://maven/junit/junit/4.12/junit-4.12.jar"; }
-    rec { sha1 = "a6c32b40bf3d76eca54e3c601e5d1470c86fcdfa"; name = "JUNIT_${sha1}/junit.sources.jar";                                                 url = "mirror://maven/junit/junit/4.12/junit-4.12-sources.jar"; }
-    rec { sha1 = "42a25dc3219429f0e5d060061f71acb49bf010a0"; name = "HAMCREST_${sha1}/hamcrest.jar";                                                   url = "mirror://maven/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"; }
-    rec { sha1 = "1dc37250fbc78e23a65a67fbbaf71d2e9cbc3c0b"; name = "HAMCREST_${sha1}/hamcrest.sources.jar";                                           url = "mirror://maven/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3-sources.jar"; }
-    rec { sha1 = "0d031013db9a80d6c88330c42c983fbfa7053193"; name = "hsdis_${sha1}/hsdis.so";                                                          url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/hsdis/intel/hsdis-amd64-linux-${sha1}.so"; }
-] ++ lib.optionals stdenv.isLinux [
-  rec { sha1 = "0d031013db9a80d6c88330c42c983fbfa7053193"; name = "hsdis_${sha1}/hsdis.so";                                                          url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/hsdis/intel/hsdis-amd64-linux-${sha1}.so"; }
-                                                                          ]
-++ lib.optionals stdenv.isDarwin [
-  rec { sha1 = "67f6d23cbebd8998450a88b5bef362171f66f11a"; name = "hsdis_${sha1}/hsdis.dylib";                                                       url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/hsdis/intel/hsdis-amd64-darwin-${sha1}.dylib"; }
-                                                                          ];
-
-  graal-mxcache = jvmci8-mxcache ++ [
-    # rec { sha1 = "5001adab652fc4eb35e30cdefbb0765442f8b7db"; name = "LLVM_ORG_LIBCXX_SRC_${sha1}/llvm-org-libcxx-src.tar.gz";                          url = "https://lafo.ssw.uni-linz.ac.at/pub/llvm-org/compiler-rt-llvmorg-8.0.0-4-gd563e33a79-bgae3b177eaa-linux-amd64.tar.gz"; }
-    rec { sha1 = "5001adab652fc4eb35e30cdefbb0765442f8b7db"; name = "LLVM_ORG_COMPILER_RT_LINUX_${sha1}/llvm-org-compiler-rt-linux.tar.gz";            url = "https://lafo.ssw.uni-linz.ac.at/pub/llvm-org/compiler-rt-llvmorg-8.0.0-4-gd563e33a79-bgae3b177eaa-linux-amd64.tar.gz"; }
-    rec { sha1 = "a990b2dba1c706f5c43c56fedfe70bad9a695852"; name = "LLVM_WRAPPER_${sha1}/llvm-wrapper.jar";                                           url = "mirror://maven/org/bytedeco/javacpp-presets/llvm/6.0.1-1.4.2/llvm-6.0.1-1.4.2.jar"; }
-    rec { sha1 = "decbd95d46092fa9afaf2523b5b23d07ad7ad6bc"; name = "LLVM_WRAPPER_${sha1}/llvm-wrapper.sources.jar";                                   url = "mirror://maven/org/bytedeco/javacpp-presets/llvm/6.0.1-1.4.2/llvm-6.0.1-1.4.2-sources.jar"; }
-    rec { sha1 = "cfa6a0259d98bff5aa8d41ba11b4d1dad648fbaa"; name = "JAVACPP_${sha1}/javacpp.jar";                                                     url = "mirror://maven/org/bytedeco/javacpp/1.4.2/javacpp-1.4.2.jar"; }
-    rec { sha1 = "fdb2d2c17f6b91cdd5421554396da8905f0dfed2"; name = "JAVACPP_${sha1}/javacpp.sources.jar";                                             url = "mirror://maven/org/bytedeco/javacpp/1.4.2/javacpp-1.4.2-sources.jar"; }
-    rec { sha1 = "702ca2d0ae93841c5ab75e4d119b29780ec0b7d9"; name = "NINJA_SYNTAX_${sha1}/ninja-syntax.tar.gz";                                        url = "https://pypi.org/packages/source/n/ninja_syntax/ninja_syntax-1.7.2.tar.gz"; }
-    rec { sha1 = "f2cfb09cee12469ff64f0d698b13de19903bb4f7"; name = "NanoHTTPD-WebSocket_${sha1}/nanohttpd-websocket.jar";                             url = "mirror://maven/org/nanohttpd/nanohttpd-websocket/2.3.1/nanohttpd-websocket-2.3.1.jar"; }
-    rec { sha1 = "a8d54d1ca554a77f377eff6bf9e16ca8383c8f6c"; name = "NanoHTTPD_${sha1}/nanohttpd.jar";                                                 url = "mirror://maven/org/nanohttpd/nanohttpd/2.3.1/nanohttpd-2.3.1.jar"; }
-    rec { sha1 = "946f8aa9daa917dd81a8b818111bec7e288f821a"; name = "ANTLR4_${sha1}/antlr4.jar";                                                       url = "mirror://maven/org/antlr/antlr4-runtime/4.7.1/antlr4-runtime-4.7.1.jar"; }
-    rec { sha1 = "c3aeac59c022bdc497c8c48ed86fa50450e4896a"; name = "JLINE_${sha1}/jline.jar";                                                         url = "mirror://maven/jline/jline/2.14.6/jline-2.14.6.jar"; }
-    rec { sha1 = "d0bdc21c5e6404726b102998e44c66a738897905"; name = "JAVA_ALLOCATION_INSTRUMENTER_${sha1}/java-allocation-instrumenter.jar";           url = "mirror://maven/com/google/code/java-allocation-instrumenter/java-allocation-instrumenter/3.1.0/java-allocation-instrumenter-3.1.0.jar"; }
-    rec { sha1 = "0da08b8cce7bbf903602a25a3a163ae252435795"; name = "ASM5_${sha1}/asm5.jar";                                                           url = "mirror://maven/org/ow2/asm/asm/5.0.4/asm-5.0.4.jar"; }
-    rec { sha1 = "396ce0c07ba2b481f25a70195c7c94922f0d1b0b"; name = "ASM_TREE5_${sha1}/asm-tree5.jar";                                                 url = "mirror://maven/org/ow2/asm/asm-tree/5.0.4/asm-tree-5.0.4.jar"; }
-    rec { sha1 = "280c265b789e041c02e5c97815793dfc283fb1e6"; name = "LIBFFI_SOURCES_${sha1}/libffi-sources.tar.gz";                                    url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/libffi-3.2.1.tar.gz"; }
-    rec { sha1 = "8819cea8bfe22c9c63f55465e296b3855ea41786"; name = "TruffleJSON_${sha1}/trufflejson.jar";                                             url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/trufflejson-20180130.jar"; }
-    rec { sha1 = "9712a8124c40298015f04a74f61b3d81a51513af"; name = "CHECKSTYLE_8.8_${sha1}/checkstyle-8.8.jar";                                       url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/checkstyle-8.8-all.jar"; }
-    rec { sha1 = "8dc5a90bed5f51d7538d05b8c31c31b7dfddbd66"; name = "VISUALVM_COMMON_${sha1}/visualvm-common.tar.gz";                                  url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/visualvm/visualvm-19_0_0-20.tar.gz"; }
-    rec { sha1 = "e6e60889b7211a80b21052a249bd7e0f88f79fee"; name = "Java-WebSocket_${sha1}/java-websocket.jar";                                       url = "mirror://maven/org/java-websocket/Java-WebSocket/1.3.9/Java-WebSocket-1.3.9.jar"; }
-    rec { sha1 = "7a4d00d5ec5febd252a6182e8b6e87a0a9821f81"; name = "ICU4J_${sha1}/icu4j.jar";                                                         url = "mirror://maven/com/ibm/icu/icu4j/62.1/icu4j-62.1.jar"; }
-    # This duplication of asm with underscore and minus is totally weird
-    rec { sha1 = "c01b6798f81b0fc2c5faa70cbe468c275d4b50c7"; name = "ASM-6.2.1_${sha1}/asm-6.2.1.jar";                                                 url = "mirror://maven/org/ow2/asm/asm/6.2.1/asm-6.2.1.jar"; }
-    rec { sha1 = "cee28077ac7a63d3de0b205ec314d83944ff6267"; name = "ASM-6.2.1_${sha1}/asm-6.2.1.sources.jar";                                         url = "mirror://maven/org/ow2/asm/asm/6.2.1/asm-6.2.1-sources.jar"; }
-    rec { sha1 = "332b022092ecec53cdb6272dc436884b2d940615"; name = "ASM_TREE-6.2.1_${sha1}/asm-tree-6.2.1.jar";                                       url = "mirror://maven/org/ow2/asm/asm-tree/6.2.1/asm-tree-6.2.1.jar"; }
-    rec { sha1 = "072bd64989090e4ed58e4657e3d4481d96f643af"; name = "ASM_TREE-6.2.1_${sha1}/asm-tree-6.2.1.sources.jar";                               url = "mirror://maven/org/ow2/asm/asm-tree/6.2.1/asm-tree-6.2.1-sources.jar"; }
-    rec { sha1 = "e8b876c5ccf226cae2f44ed2c436ad3407d0ec1d"; name = "ASM_ANALYSIS-6.2.1_${sha1}/asm-analysis-6.2.1.jar";                               url = "mirror://maven/org/ow2/asm/asm-analysis/6.2.1/asm-analysis-6.2.1.jar"; }
-    rec { sha1 = "b0b249bd185677648692e7c57b488b6d7c2a6653"; name = "ASM_ANALYSIS-6.2.1_${sha1}/asm-analysis-6.2.1.sources.jar";                       url = "mirror://maven/org/ow2/asm/asm-analysis/6.2.1/asm-analysis-6.2.1-sources.jar"; }
-    rec { sha1 = "eaf31376d741a3e2017248a4c759209fe25c77d3"; name = "ASM_COMMONS-6.2.1_${sha1}/asm-commons-6.2.1.jar";                                 url = "mirror://maven/org/ow2/asm/asm-commons/6.2.1/asm-commons-6.2.1.jar"; }
-    rec { sha1 = "667fa0f9d370e7848b0e3d173942855a91fd1daf"; name = "ASM_COMMONS-6.2.1_${sha1}/asm-commons-6.2.1.sources.jar";                         url = "mirror://maven/org/ow2/asm/asm-commons/6.2.1/asm-commons-6.2.1-sources.jar"; }
-    # From here on the deps are new
-    rec { sha1 = "400d664d7c92a659d988c00cb65150d1b30cf339"; name = "ASM_UTIL-6.2.1_${sha1}/asm-util-6.2.1.jar";                                       url = "mirror://maven/org/ow2/asm/asm-util/6.2.1/asm-util-6.2.1.jar"; }
-    rec { sha1 = "c9f7246bf93bb0dc7fe9e7c9eca531a8fb98d252"; name = "ASM_UTIL-6.2.1_${sha1}/asm-util-6.2.1.sources.jar";                               url = "mirror://maven/org/ow2/asm/asm-util/6.2.1/asm-util-6.2.1-sources.jar"; }
-    rec { sha1 = "4b52bd03014f6d080ef0528865c1ee50621e35c6"; name = "NETBEANS_PROFILER_${sha1}/netbeans-profiler.jar";                                 url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/truffle/js/org-netbeans-lib-profiler-8.2-201609300101.jar"; }
-    rec { sha1 = "b5840706cc8ce639fcafeab1bc61da2d8aa37afd"; name = "NASHORN_INTERNAL_TESTS_${sha1}/nashorn-internal-tests.jar";                       url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/truffle/js/nashorn-internal-tests-700f5e3f5ff2.jar"; }
-    rec { sha1 = "9577018f9ce3636a2e1cb0a0c7fe915e5098ded5"; name = "JACKSON_ANNOTATIONS_${sha1}/jackson-annotations.jar";                             url = "mirror://maven/com/fasterxml/jackson/core/jackson-annotations/2.8.6/jackson-annotations-2.8.6.jar"; }
-    rec { sha1 = "2ef7b1cc34de149600f5e75bc2d5bf40de894e60"; name = "JACKSON_CORE_${sha1}/jackson-core.jar";                                           url = "mirror://maven/com/fasterxml/jackson/core/jackson-core/2.8.6/jackson-core-2.8.6.jar"; }
-    rec { sha1 = "c43de61f74ecc61322ef8f402837ba65b0aa2bf4"; name = "JACKSON_DATABIND_${sha1}/jackson-databind.jar";                                   url = "mirror://maven/com/fasterxml/jackson/core/jackson-databind/2.8.6/jackson-databind-2.8.6.jar"; }
-    rec { sha1 = "2838952e91baa37ac73ed817451268a193ba440a"; name = "JCODINGS_${sha1}/jcodings.jar";                                                   url = "mirror://maven/org/jruby/jcodings/jcodings/1.0.40/jcodings-1.0.40.jar"; }
-    rec { sha1 = "0ed89e096c83d540acac00d6ee3ea935b4c905ff"; name = "JCODINGS_${sha1}/jcodings.sources.jar";                                           url = "mirror://maven/org/jruby/jcodings/jcodings/1.0.40/jcodings-1.0.40-sources.jar"; }
-    rec { sha1 = "5dbb09787a9b8780737b71fbf942235ef59051b9"; name = "JONI_${sha1}/joni.jar";                                                           url = "mirror://maven/org/jruby/joni/joni/2.1.25/joni-2.1.25.jar"; }
-    rec { sha1 = "505a09064f6e2209616f38724f6d97d8d889aa92"; name = "JONI_${sha1}/joni.sources.jar";                                                   url = "mirror://maven/org/jruby/joni/joni/2.1.25/joni-2.1.25-sources.jar"; }
-    rec { sha1 = "c4f7d054303948eb6a4066194253886c8af07128"; name = "XZ-1.8_${sha1}/xz-1.8.jar";                                                       url = "mirror://maven/org/tukaani/xz/1.8/xz-1.8.jar"; }
-    rec { sha1 = "9314d3d372b05546a33791fbc8dd579c92ebd16b"; name = "GNUR_${sha1}/gnur.tar.gz";                                                        url = "http://cran.rstudio.com/src/base/R-3/R-3.5.1.tar.gz"; }
-    rec { sha1 = "90aa8308da72ae610207d8f6ca27736921be692a"; name = "ANTLR4_COMPLETE_${sha1}/antlr4-complete.jar";                                     url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/antlr-4.7.1-complete.jar"; }] ++
-  lib.optionals stdenv.isLinux [
-    rec { sha1 = "df4c1f784294d02a82d78664064248283bfcc297"; name = "LLVM_ORG_${sha1}/llvm-org.tar.gz";                                                url = "https://lafo.ssw.uni-linz.ac.at/pub/llvm-org/llvm-llvmorg-8.0.0-4-gd563e33a79-bgae3b177eaa-linux-amd64.tar.gz"; }
-    rec { sha1 = "344483aefa15147c121a8fb6fb35a2406768cc5c"; name = "LLVM_PLATFORM_SPECIFIC_${sha1}/llvm-platform-specific.jar";                       url = "mirror://maven/org/bytedeco/javacpp-presets/llvm/6.0.1-1.4.2/llvm-6.0.1-1.4.2-linux-x86_64.jar"; }
-    rec { sha1 = "fd1a723d62cbbc591041d303e8b151d89f131643"; name = "VISUALVM_PLATFORM_SPECIFIC_${sha1}/visualvm-platform-specific.tar.gz";            url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/visualvm/visualvm-19_0_0-20-linux-amd64.tar.gz"; }
-    rec { sha1 = "987234c4ce45505c21302e097c24efef4873325c"; name = "NINJA_${sha1}/ninja.zip";                                                         url = "https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip";
-          isNinja = true; }] ++
-  lib.optionals stdenv.isDarwin [
-    rec { sha1 = "0fa1af180755fa4cc018ee9be33f2d7d827593c4"; name = "LLVM_ORG_${sha1}/llvm-org.tar.gz";                                                url = "https://lafo.ssw.uni-linz.ac.at/pub/llvm-org/llvm-llvmorg-8.0.0-4-gd563e33a79-bgae3b177eaa-darwin-amd64.tar.gz"; }
-    rec { sha1 = "57bc74574104a9e0a2dc4d7a71ffcc5731909e57"; name = "LLVM_PLATFORM_SPECIFIC_${sha1}/llvm-platform-specific.jar";                       url = "mirror://maven/org/bytedeco/javacpp-presets/llvm/6.0.1-1.4.2/llvm-6.0.1-1.4.2-macosx-x86_64.jar"; }
-    rec { sha1 = "ae23bb365930f720acc88c62640bae6852a37d67"; name = "VISUALVM_PLATFORM_SPECIFIC_${sha1}/visualvm-platform-specific.tar.gz";            url = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/visualvm/visualvm-19_0_0-20-macosx-x86_64.tar.gz"; }
-    rec { sha1 = "8142c497f7dfbdb052a1e31960fdfe2c6f9a5ca2"; name = "NINJA_${sha1}/ninja.zip";                                                         url = "https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-mac.zip";
-          isNinja = true; }];
-
-  graal-mxcachegit = [
-    { sha256 = "01w39ms39gl3cw7c2fgcacr2yjg94im9x2x7p5g94l6xlcgqvcnr"; name = "graaljs";     url = "https://github.com/graalvm/graaljs.git";     rev = "vm-${version}"; }
-    { sha256 = "1dps9n5b9c80pbg1fmlwpffy6ina0f0h27di24kafc8isxrdggia"; name = "truffleruby"; url = "https://github.com/oracle/truffleruby.git";  rev = "vm-${version}"; }
-    { sha256 = "0jdpdqm3ld1wsasmi8ka26qf19cibjac8lrqm040h5vh0iqzxizy"; name = "fastr";       url = "https://github.com/oracle/fastr.git";        rev = "vm-${version}"; }
-    { sha256 = "1gv8vafwrafjzvgv4gwk4kcsb3bnvsx07qa5inc0bdyxy5shl381"; name = "graalpython"; url = "https://github.com/graalvm/graalpython.git"; rev = "vm-${version}"; }];
-
-  ninja-syntax = python27.pkgs.buildPythonPackage rec {
-    version = "1.7.2";
-    pname = "ninja_syntax";
-    doCheck = false;
-    src = python27.pkgs.fetchPypi {
-      inherit pname version;
-      sha256 = "07zg30m0khx55fv2gxxn7pqd549z0vk3x592mrdlk9l8krxwjb9l";
-    };
-  };
-
-  findbugs = fetchzip {
-    name   = "findbugs-3.0.0";
-    url    = "https://lafo.ssw.uni-linz.ac.at/pub/graal-external-deps/findbugs-3.0.0.zip";
-    sha256 = "0sf5f9h1s6fmhfigjy81i109j1ani5kzdr4njlpq0mnkkh9fpr7m";
-  };
-
-  python27withPackages = python27.withPackages (ps: [ ninja-syntax ]);
-
-in rec {
-
-  mx = stdenv.mkDerivation rec {
-    version = "5.247.1";
-    pname = "mx";
-    src = fetchFromGitHub {
-      owner  = "graalvm";
-      repo   = "mx";
-      rev    = version;
-      sha256 = "038qr49rqzkhj76nqd27h8fysssnlpdhmy23ks2y81xlxhlzkc59";
-    };
-    nativeBuildInputs = [ makeWrapper ];
-    prePatch = ''
-      cp mx.py bak_mx.py
-    '';
-    patches = [ ./001_mx.py.patch ];
-    postPatch = ''
-      mv mx.py internal_mx.py
-      mv bak_mx.py mx.py
-    '';
-    buildPhase = ''
-      substituteInPlace mx --replace /bin/pwd pwd
-
-      # avoid crash with 'ValueError: ZIP does not support timestamps before 1980'
-      substituteInPlace internal_mx.py --replace \
-        'zipfile.ZipInfo(arcname, time.localtime(getmtime(join(root, f)))[:6])' \
-        'zipfile.ZipInfo(arcname, time.strptime ("1 Jan 1980", "%d %b %Y"       )[:6])'
-    '';
-    installPhase = ''
-      mkdir -p $out/bin
-      cp -dpR * $out/bin
-      wrapProgram $out/bin/mx \
-        --prefix PATH : ${lib.makeBinPath [ python27withPackages mercurial ]} \
-        --set    FINDBUGS_HOME ${findbugs}
-      makeWrapper ${python27}/bin/python $out/bin/mx-internal \
-        --add-flags "$out/bin/internal_mx.py" \
-        --prefix PATH : ${lib.makeBinPath [ python27withPackages mercurial ]} \
-        --set    FINDBUGS_HOME ${findbugs}
-    '';
-    meta = with lib; {
-      homepage = "https://github.com/graalvm/mx";
-      description = "Command-line tool used for the development of Graal projects";
-      license = licenses.gpl2;
-      platforms = python27.meta.platforms;
-    };
-  };
-
-  jvmci8 = stdenv.mkDerivation rec {
-    version = "19.3-b05";
-    pname = "jvmci";
-    src = fetchFromGitHub {
-      owner  = "graalvm";
-      repo   = "graal-jvmci-8";
-      rev    = "jvmci-${version}";
-      sha256 =  "0j7my76vldbrvki9x1gn9ics3x2z96j05jdy4nflbpik8i396114";
-    };
-    buildInputs = [ mx mercurial openjdk ] ++ lib.optionals stdenv.isDarwin [
-      libobjc CoreFoundation Foundation JavaNativeFoundation JavaRuntimeSupport JavaVM xcodebuild Cocoa
-    ];
-    postUnpack = ''
-      # a fake mercurial dir to prevent mx crash and supply the version to mx
-      ( cd $sourceRoot
-        hg init
-        hg add
-        hg commit -m 'dummy commit'
-        hg tag      ${lib.escapeShellArg src.rev}
-        hg checkout ${lib.escapeShellArg src.rev}
-      )
-    '';
-    patches = [ ./004_mx_jvmci.py.patch ] ++
-              lib.optional stdenv.isDarwin [
-                ./008_remove_jfr.patch ];
-    postPatch =''
-      # The hotspot version name regex fix
-      substituteInPlace mx.jvmci/mx_jvmci.py \
-        --replace "\\d+.\\d+-b\\d+" "\\d+.\\d+-b[g\\d][a\\d]"
-      # darwin: https://github.com/oracle/graal/issues/1816
-      substituteInPlace src/share/vm/code/compiledIC.cpp \
-        --replace 'entry == false' '*entry == false'
-    '';
-    hardeningDisable = [ "fortify" ];
-    NIX_CFLAGS_COMPILE = toString (lib.optional stdenv.isDarwin [
-      "-Wno-reserved-user-defined-literal"
-      "-Wno-c++11-narrowing"
-    ] ++
-    lib.optional stdenv.isLinux [
-      "-Wno-error=format-overflow" # newly detected by gcc7
-      "-Wno-error=nonnull"
-    ]);
-
-    buildPhase = ''
-      export MX_ALT_OUTPUT_ROOT=$NIX_BUILD_TOP/mxbuild
-      export MX_CACHE_DIR=${makeMxCache jvmci8-mxcache}
-
-      mx-internal --primary-suite . --vm=server -v build -DFULL_DEBUG_SYMBOLS=0
-      mx-internal --primary-suite . --vm=server -v vm -version
-      mx-internal --primary-suite . --vm=server -v unittest
-    '';
-    installPhase = ''
-      mkdir -p $out
-      ${if stdenv.isDarwin
-        then "mv openjdk1.8.0_*/darwin-amd64/product/* $out"
-        else "mv openjdk1.8.0_*/linux-amd64/product/* $out"}
-      install -v -m0555 -D $MX_CACHE_DIR/hsdis*/hsdis.so $out/jre/lib/amd64/hsdis-amd64.so
-    '';
-    # copy-paste openjdk's preFixup
-    preFixup = ''
-      # Propagate the setJavaClassPath setup hook from the JRE so that
-      # any package that depends on the JRE has $CLASSPATH set up
-      # properly.
-      mkdir -p $out/nix-support
-      printWords ${setJavaClassPath} > $out/nix-support/propagated-build-inputs
-
-      # Set JAVA_HOME automatically.
-      mkdir -p $out/nix-support
-      cat <<EOF > $out/nix-support/setup-hook
-      if [ -z "\''${JAVA_HOME-}" ]; then export JAVA_HOME=$out; fi
-      EOF
-    '';
-    postFixup = openjdk.postFixup or null;
-    dontStrip = true; # stripped javac crashes with "segmentaion fault"
-    inherit (openjdk) meta;
-  };
-
-  graalvm8 = 	stdenv.mkDerivation rec {
-    inherit version;
-    pname = "graal";
-    src = fetchFromGitHub {
-      owner  = "oracle";
-      repo   = "graal";
-      rev    = "vm-${version}";
-      sha256 = "0v8zkmzkyhmmmvra5pp876d4i4ijrrw15j98ipayc7is02kwiwmq";
-    };
-
-    patches = [ ./002_setjmp.c.patch ./003_mx_truffle.py.patch ] ++
-              lib.optional stdenv.isDarwin [
-                ./009_remove_signedness_verifier.patch ./010_mx_substratevm.py
-              ];
-
-    nativeBuildInputs = [ gfortran ];
-
-    buildInputs = [ mx zlib.dev mercurial jvmci8 git llvm clang
-                    python27withPackages icu ruby bzip2 which
-                    readline bzip2 xz pcre curl ed
-                  ]  ++ lib.optional stdenv.isDarwin [
-                    CoreFoundation gcc.cc.lib libiconv perl openssl
-                  ];
-
-    postUnpack = ''
-      ${lib.optionalString stdenv.isLinux ''
-        cp ${stdenv.cc.cc}/include/c++/${lib.getVersion stdenv.cc.cc}/stdlib.h \
-          $sourceRoot/sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/include
-      ''}
-      cp ${truffleMake} $TMPDIR/truffle.make
-      rm $sourceRoot/truffle/src/libffi/patches/others/0001-Add-mx-bootstrap-Makefile.patch
-
-      # a fake mercurial dir to prevent mx crash and supply the version to mx
-      ( cd $sourceRoot
-        hg init
-        hg add
-        hg commit -m 'dummy commit'
-        hg tag      ${lib.escapeShellArg src.rev}
-        hg checkout ${lib.escapeShellArg src.rev}
-      )
-
-      # make a copy of jvmci8
-      mkdir $NIX_BUILD_TOP/jvmci8
-      cp -dpR ${jvmci8}/* $NIX_BUILD_TOP/jvmci8
-      chmod +w -R $NIX_BUILD_TOP/jvmci8
-      export MX_CACHE_DIR=${makeMxCache graal-mxcache}
-      export MX_GIT_CACHE_DIR=$NIX_BUILD_TOP/mxgitcache
-      ${makeMxGitCache graal-mxcachegit "$MX_GIT_CACHE_DIR"}
-      cd $TMPDIR
-    '';
-
-    postPatch = ''
-      substituteInPlace substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/headers/PosixDirectives.java \
-        --replace '<zlib.h>' '<${zlib.dev}/include/zlib.h>'
-      substituteInPlace substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/CCLinkerInvocation.java \
-        --replace 'cmd.add("-v");' 'cmd.add("-v"); cmd.add("-L${zlib}/lib");'
-
-      # For debugging native-image build, add this replace statement on CCompilerInvoker.java
-      # --replace '(String line : lines) {' '(String line : lines) {System.out.println("DEBUG: " + line);'
-      ${if stdenv.isLinux then ''
-          substituteInPlace substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/codegen/CCompilerInvoker.java \
-            --replace 'command.add(Platform.includedIn(Platform.WINDOWS.class) ? "CL" : "gcc");' \
-                      'command.add(Platform.includedIn(Platform.WINDOWS.class) ? "CL" : "${stdenv.cc}/bin/gcc");' ''
-        else ''
-          substituteInPlace substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/c/codegen/CCompilerInvoker.java \
-            --replace 'command.add(Platform.includedIn(Platform.WINDOWS.class) ? "CL" : "gcc");' \
-                      'command.add(Platform.includedIn(Platform.WINDOWS.class) ? "CL" : "${gcc.cc}/bin/gcc");
-                       command.add("-F"); command.add("${CoreFoundation}/Library/Frameworks");
-                       command.add("-framework"); command.add("CoreFoundation");'
-       ''}
-
-      # prevent cyclical imports caused by identical <include> names
-      substituteInPlace substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/CCLinkerInvocation.java \
-        --replace 'protected String compilerCommand = "cc";' 'protected String compilerCommand = "${stdenv.cc}/bin/cc";'
-      # dragonegg can't seem to compile on nix, so let's not require it
-      substituteInPlace sulong/mx.sulong/suite.py \
-        --replace '"requireDragonegg" : True,' '"requireDragonegg" : False,'
-      substituteInPlace truffle/mx.truffle/mx_truffle.py \
-        --replace 'os.path.relpath(self.subject.delegate.dir, self.subject.suite.vc_dir)' \
-                  'self.subject.delegate.dir'
-      substituteInPlace sulong/projects/bootstrap-toolchain-launchers/Makefile \
-        --replace /bin/bash ${bash}/bin/bash
-      # Patch the native-image template, as it will be run during build
-      chmod +x vm/mx.vm/launcher_template.sh && patchShebangs vm/mx.vm
-      # Prevent random errors from too low maxRuntimecompilemethods
-      substituteInPlace truffle/mx.truffle/macro-truffle.properties \
-        --replace '-H:MaxRuntimeCompileMethods=1400' \
-                  '-H:MaxRuntimeCompileMethods=28000'
-      ${lib.optionalString stdenv.isDarwin ''
-        substituteInPlace truffle/src/com.oracle.truffle.nfi.test.native/src/object.cc \
-          --replace '#include <stdlib.h>' ""
-      ''}
-      ${lib.optionalString stdenv.isLinux ''
-        substituteInPlace sulong/projects/com.oracle.truffle.llvm.libraries.bitcode/include/stdlib.h \
-          --replace '# include <cstdlib>' '# include "${stdenv.cc.cc}/include/c++/${lib.getVersion stdenv.cc.cc}/cstdlib"'
-      ''}
-    '';
-
-    buildPhase = ''
-      export MX_ALT_OUTPUT_ROOT=$NIX_BUILD_TOP/mxbuild
-      export MX_GIT_CACHE='refcache'
-      export JVMCI_VERSION_CHECK='ignore'
-      export JAVA_HOME=$NIX_BUILD_TOP/jvmci8
-      export FASTR_RELEASE=true
-      export PKG_LDFLAGS_OVERRIDE="-L${pcre.out}/lib -L${zlib}/lib -L${gfortran.cc.lib}/lib64"
-      ${lib.optionalString stdenv.isDarwin ''
-        export CC="gcc"
-        export CPP="gcc -E"
-        export NIX_CXXSTDLIB_LINK=""
-        export NIX_CXXSTDLIB_LINK_FOR_TARGET=""
-        export OPENSSL_PREFIX=$(realpath openssl)
-        # this fixes error: impure path 'LibFFIHeaderDirectives' used in link
-        export NIX_ENFORCE_PURITY=0
-      ''}
-      ( cd vm
-        mx-internal -v --suite sdk --suite compiler --suite vm --suite tools --suite regex --suite truffle \
-                       --dynamicimports /substratevm,/sulong,graal-js,graalpython,fastr,truffleruby build
-      )
-    '';
-
-    installPhase =
-      (if stdenv.isDarwin then ''
-      mkdir -p $out
-      rm -rf $MX_ALT_OUTPUT_ROOT/vm/darwin-amd64/GRAALVM_*STAGE1*
-      cp -rf $MX_ALT_OUTPUT_ROOT/vm/darwin-amd64/GRAALVM*/graalvm-unknown-${version}/* $out
-      ''
-       else ''
-      mkdir -p $out
-      rm -rf $MX_ALT_OUTPUT_ROOT/vm/linux-amd64/GRAALVM_*STAGE1*
-      cp -rf $MX_ALT_OUTPUT_ROOT/vm/linux-amd64/GRAALVM*/graalvm-unknown-${version}/* $out
-
-      # BUG workaround http://mail.openjdk.java.net/pipermail/graal-dev/2017-December/005141.html
-      substituteInPlace $out/jre/lib/security/java.security \
-        --replace file:/dev/random    file:/dev/./urandom \
-        --replace NativePRNGBlocking  SHA1PRNG
-      # copy static and dynamic libraries needed for static compilation
-      cp -rf ${glibc}/lib/* $out/jre/lib/svm/clibraries/linux-amd64/
-      cp ${glibc.static}/lib/* $out/jre/lib/svm/clibraries/linux-amd64/
-      cp ${zlib.static}/lib/libz.a $out/jre/lib/svm/clibraries/linux-amd64/libz.a
-    '');
-
-    inherit (jvmci8) preFixup;
-    dontStrip = true; # stripped javac crashes with "segmentaion fault"
-    doInstallCheck = true;
-    installCheckPhase = ''
-      echo ${lib.escapeShellArg ''
-               public class HelloWorld {
-                 public static void main(String[] args) {
-                   System.out.println("Hello World");
-                 }
-               }
-             ''} > HelloWorld.java
-      $out/bin/javac HelloWorld.java
-
-      # run on JVM with Graal Compiler
-      $out/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+UseJVMCICompiler HelloWorld
-      $out/bin/java -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:+UseJVMCICompiler HelloWorld | fgrep 'Hello World'
-
-      # Ahead-Of-Time compilation
-      $out/bin/native-image --no-server HelloWorld
-      ./helloworld
-      ./helloworld | fgrep 'Hello World'
-
-      ${lib.optionalString stdenv.isLinux
-        ''
-          # Ahead-Of-Time compilation with --static (supported on linux only)
-          $out/bin/native-image --no-server --static HelloWorld
-          ./helloworld
-          ./helloworld | fgrep 'Hello World'
-        ''}
-         '';
-    enableParallelBuilding = true;
-    passthru.home = graalvm8;
-
-    meta = with lib; {
-      homepage = "https://github.com/oracle/graal";
-      description = "High-Performance Polyglot VM";
-      license = licenses.gpl2;
-      maintainers = with maintainers; [ volth hlolli ];
-      platforms = [ "x86_64-linux" "x86_64-darwin" /*"aarch64-linux"*/ ];
-    };
-  };
-}

pkgs/development/compilers/graalvm/truffle.make

···
-# This Makefile is used by mx to bootstrap libffi build.
-
-# `make MX_VERBOSE=y` will report all lines executed. The actual value doesn't
-# matter as long as it's not empty.
-
-QUIETLY$(MX_VERBOSE) = @
-
-.PHONY: default
-
-default:
-	sed -i "s|-print-multi-os-directory||g" ../$(SOURCES)/configure
-	$(QUIETLY) echo CONFIGURE libffi
-	$(QUIETLY) mkdir ../$(OUTPUT)
-	$(QUIETLY) cd ../$(OUTPUT) && ../$(SOURCES)/configure $(CONFIGURE_ARGS)
-	$(QUIETLY) echo MAKE libffi
-	$(QUIETLY) $(MAKE) -C ../$(OUTPUT)

pkgs/development/compilers/nim/default.nix

···
   nimHost = parsePlatform stdenv.hostPlatform;
   nimTarget = parsePlatform stdenv.targetPlatform;
 
-  bootstrapCompiler = stdenv.mkDerivation rec {
+  bootstrapCompiler = let
+    revision = "561b417c65791cd8356b5f73620914ceff845d10";
+  in stdenv.mkDerivation {
     pname = "nim-bootstrap";
-    version = "0.20.0";
+    version = "g${lib.substring 0 7 revision}";
 
     src = fetchgit {
       # A Git checkout is much smaller than a GitHub tarball.
-      url = "https://github.com/nim-lang/csources.git";
-      rev = "v${version}";
-      sha256 = "0i6vsfy1sgapx43n226q8m0pvn159sw2mhp50zm3hhb9zfijanis";
+      url = "https://github.com/nim-lang/csources_v1.git";
+      rev = revision;
+      sha256 = "1c2k681knrha1zmf4abhb32i2wwd3nwflzylnqryxk753swla043";
     };
 
     enableParallelBuilding = true;

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

···
   gi-cairo-render = doJailbreak super.gi-cairo-render;
   gi-cairo-connector = doJailbreak super.gi-cairo-connector;
 
-  # Remove when https://github.com/gtk2hs/svgcairo/pull/10 gets merged.
-  svgcairo = appendPatch super.svgcairo (pkgs.fetchpatch {
-    url = "https://github.com/gtk2hs/svgcairo/commit/df6c6172b52ecbd32007529d86ba9913ba001306.patch";
-    sha256 = "128qrns56y139vfzg1rbyqfi2xn8gxsmpnxv3zqf4v5spsnprxwh";
+  svgcairo = overrideCabal super.svgcairo (drv: {
+    patches = [
+      # Remove when https://github.com/gtk2hs/svgcairo/pull/10 gets merged.
+      (pkgs.fetchpatch {
+        url = "https://github.com/gtk2hs/svgcairo/commit/df6c6172b52ecbd32007529d86ba9913ba001306.patch";
+        sha256 = "128qrns56y139vfzg1rbyqfi2xn8gxsmpnxv3zqf4v5spsnprxwh";
+      })
+      # The update here breaks svgcairo:
+      # https://github.com/NixOS/nixpkgs/commit/08fcd73d9dc9a28aa901210b259d9bfb3c228018
+      # and updating the call to the header with the correct name fixes it.
+      (pkgs.fetchpatch {
+        url = "https://github.com/dalpd/svgcairo/commit/4dc6d8d3a6c24be0b8c1fd73b282ff247e7b1e6f.patch";
+        sha256 = "1pq9ld9z67zsxj8vqjf82qwckcp69lvvnrjb7wsyb5jc6jaj3q0a";
+      })
+    ];
   });
 
   # Missing -Iinclude parameter to doc-tests (pull has been accepted, so should be resolved when 0.5.3 released)
···
   http3 = super.http3.overrideScope (self: super: {
     network = self.network_3_1_2_5;
   });
+
+  # Fixes https://github.com/NixOS/nixpkgs/issues/140613
+  # https://github.com/recursion-schemes/recursion-schemes/issues/128
+  recursion-schemes = appendPatch super.recursion-schemes ./patches/recursion-schemes-128.patch;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

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

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

···
     postPatch = "sed -i -e 's,<4.16,<4.17,' basement.cabal";
   });
 
+  base16-bytestring = appendPatch super.base16-bytestring (pkgs.fetchpatch {
+    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/base16-bytestring-1.0.1.0.patch";
+    sha256 = "19ajai9y04981zfpcdj1nlz44b12gjj4m1ncciijv43mnz82plji";
+  });
+
   # Duplicate Show instances in tests and library cause compiling tests to fail
   blaze-builder = appendPatch (dontCheck super.blaze-builder) (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/blaze-builder-0.4.2.1.patch";
     sha256 = "1h5ny3mlng69vwaabl3af8hlv4qi24wfw8s14lw2ksw1yjbgi0j8";
   });
 
-  cereal = appendPatch super.cereal (pkgs.fetchpatch {
+  cereal = appendPatch (doJailbreak super.cereal) (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/cereal-0.5.8.1.patch";
     sha256 = "03v4nxwz9y6viaa8anxcmp4zdf2clczv4pf9fqq6lnpplpz5i128";
   });
···
     sha256 = "1g48lrmqgd88hqvfq3klz7lsrpwrir2v1931myrhh6dy0d9pqj09";
   });
 
-  # cabal-install needs more recent versions of Cabal and base16-bytestring.
+  # cabal-install needs more recent versions of Cabal
   cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {
-    Cabal = null;
+    Cabal = self.Cabal_3_6_2_0;
   });
 
   doctest = appendPatch (dontCheck (doJailbreak super.doctest_0_18_1)) (pkgs.fetchpatch {
···
   type-equality = doJailbreak super.type-equality;
   vector = doJailbreak (dontCheck super.vector);
   vector-binary-instances = doJailbreak super.vector-binary-instances;
-  vector-th-unbox = doJailbreak super.vector-th-unbox;
   zlib = doJailbreak super.zlib;
+  indexed-traversable-instances = doJailbreak super.indexed-traversable-instances;
+
+  hpack = overrideCabal (doJailbreak super.hpack) (drv: {
+    # Cabal 3.6 seems to preserve comments when reading, which makes this test fail
+    # 2021-10-10: 9.2.1 is not yet supported (also no issue)
+    testFlags = [
+      "--skip=/Hpack/renderCabalFile/is inverse to readCabalFile/"
+    ] ++ drv.testFlags or [];
+  });
+
+  # Patch for TH code from head.hackage
+  vector-th-unbox = appendPatch (doJailbreak super.vector-th-unbox) (pkgs.fetchpatch {
+    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/vector-th-unbox-0.2.1.9.patch";
+    sha256 = "02bvvy3hx3cf4y4dr64zl5pjvq8giwk4286j5g1n6k8ikyn2403p";
+  });
+
+  # Patch for TH code from head.hackage
+  invariant = appendPatch (doJailbreak super.invariant) (pkgs.fetchpatch {
+    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/invariant-0.5.4.patch";
+    sha256 = "17gg8ck4r6qmlbcbpbnqzksgf5q7i891zs6axfzhas6ajncylxvc";
+  });
+
+  # base 4.15 support from head.hackage
+  lens = appendPatch (doJailbreak super.lens_5_0_1) (pkgs.fetchpatch {
+    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/lens-5.0.1.patch";
+    sha256 = "1s8qqg7ymvv94dnfnr1ragx91chh9y7ydc4jx25zn361wbn00pv7";
+  });
+
+  semigroupoids = overrideCabal super.semigroupoids (drv: {
+    # Patch from head.hackage for base 4.15 compat
+    patches = drv.patches or [] ++ [
+      (pkgs.fetchpatch {
+        url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/semigroupoids-5.3.5.patch";
+        sha256 = "0xrn1gv6b2n76522pk2nfp4z69kvp14l2zpif2f8zzz6cwcrx9w8";
+      })
+    ];
+    # acrobatics to make the patch apply
+    prePatch = ''
+      find . -type f | xargs -L 1 ${pkgs.buildPackages.dos2unix}/bin/dos2unix
+    '';
+    editedCabalFile = null;
+    revision = null;
+  });
 
   # Syntax error in tests fixed in https://github.com/simonmar/alex/commit/84b29475e057ef744f32a94bc0d3954b84160760
   alex = dontCheck super.alex;
···
   # The test suite indirectly depends on random, which leads to infinite recursion
   random = dontCheck super.random_1_2_1;
 
-  # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet
-  lens = super.lens_5_0_1;
-
   # 0.16.0 introduced support for GHC 9.0.x, stackage has 0.15.0
   memory = appendPatch super.memory_0_16_0 (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/memory-0.16.0.patch";
···
   # https://github.com/Soostone/retry/issues/71
   retry = dontCheck super.retry;
 
-  streaming-commons = appendPatch super.streaming-commons (pkgs.fetchpatch {
+  # Disable tests pending resolution of
+  # https://github.com/haskell/text/issues/380 or https://github.com/fpco/streaming-commons/issues/60
+  streaming-commons = dontCheck (appendPatch super.streaming-commons (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/streaming-commons-0.2.2.1.patch";
     sha256 = "04wi1jskr3j8ayh88kkx4irvhhgz0i7aj6fblzijy0fygikvidpy";
-  });
+  }));
 
   # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage
   hlint = super.hlint_3_3_4.overrideScope (self: super: {

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

···
   - commodities
   - commonmark-cli
   - commsec
-  - compactable
   - Compactable
   - compact-list
   - compact-map
···
   - flamethrower
   - flamingra
   - flat-maybe
+  - flatparse
   - flay
   - flexible-time
   - flickr
···
   - htssets
   - http2-client
   - http2-grpc-proto-lens
+  - http3
   - http-attoparsec
   - http-client-lens
   - http-client-request-modifiers
···
   - linear-algebra-cblas
   - linear-base
   - linear-code
+  - linear-generics
   - linear-maps
   - linear-opengl
   - linearscan
···
   - SVD2HS
   - svfactor
   - svg-builder-fork
-  - svgcairo
   - svgutils
   - svm-light-utils
   - svm-simple

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

···
     - pretty-simple
     - spago
     - termonad
+  dalpd:
+    - svgcairo
   domenkozar:
     - cachix
     - cachix-api

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

···
  - Shellac-haskeline
  - Shellac-readline
  - ShortestPathProblems
- - Shpadoinkle-backend-pardiff
- - Shpadoinkle-backend-static
- - Shpadoinkle-developer-tools
  - Shpadoinkle-disembodied
  - Shpadoinkle-examples
- - Shpadoinkle-html
  - Shpadoinkle-router
- - Shpadoinkle-template
- - Shpadoinkle-widgets
  - SimpleGL
  - SimpleLog
  - SimpleServer
···
  - claferwiki
  - clash
  - clash-ghc
- - clash-ghc_1_4_4
+ - clash-ghc_1_4_5
  - clash-lib
- - clash-lib_1_4_4
+ - clash-lib_1_4_5
  - clash-multisignal
  - clash-prelude-quickcheck
  - clash-shake
···
  - every-bit-counts
  - exception-monads-fd
  - exference
+ - exon
  - expand
  - expat-enumerator
  - expiring-containers
···
  - mkbndl
  - mlist
  - mmark-cli
+ - mmark-cli_0_0_5_1
  - mmark-ext
  - mmtl-base
  - moan
···
  - proto3-suite
  - protobuf-native
  - protocol-buffers-descriptor-fork
- - proton
  - psc-ide
  - puffytools
  - pugs-compat
···
  - xml-push
  - xml-query-xml-conduit
  - xml-query-xml-types
+ - xml-syntax
  - xml-tydom-conduit
  - xml2x
  - xmltv

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

···
        license = lib.licenses.bsd3;
      }) {};
 
+  "JuicyPixels_3_3_6" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
+     , primitive, transformers, vector, zlib
+     }:
+     mkDerivation {
+       pname = "JuicyPixels";
+       version = "3.3.6";
+       sha256 = "1f8giivsqxma19ax78dr7j4gir12iyfqn2mlsd27zzl8dn7dy6w1";
+       libraryHaskellDepends = [
+         base binary bytestring containers deepseq mtl primitive
+         transformers vector zlib
+       ];
+       description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "JuicyPixels-blp" = callPackage
     ({ mkDerivation, attoparsec, base, binary, bytestring, directory
      , filepath, hashable, JuicyPixels, optparse-simple, text-show
···
        ];
        description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-backend-snabbdom" = callPackage
···
        libraryHaskellDepends = [ base compactable Shpadoinkle text ];
        description = "A backend for rendering Shpadoinkle as Text";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-console" = callPackage
···
        ];
        description = "Chrome extension to aide in development";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-disembodied" = callPackage
···
        ];
        description = "A typed, template generated Html DSL, and helpers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-isreal" = callPackage
···
        ];
        description = "Read standard file formats into Shpadoinkle with Template Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shpadoinkle-widgets" = callPackage
···
        ];
        description = "A collection of common reusable types and components";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Shrub" = callPackage
···
        pname = "ValveValueKeyvalue";
        version = "1.0.1.0";
        sha256 = "05m75nhsz1a2zb59lkdmkv7wznljhr76k7qm2pia37dj8h5zywcy";
+       revision = "1";
+       editedCabalFile = "1d4n0kqypzrcbxaq43aiw5zaq12ncws5c50ckyzvky4cs208g0is";
        libraryHaskellDepends = [ base parsec ];
        description = "A Valve Value-keyvalue parser for Haskell made with Parsec";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.7.1";
-       sha256 = "1h9kz02s7ams9fw9x8k947nzji2b82s9xn2yvqzys14ypzc34qpn";
+       version = "0.7.2";
+       sha256 = "1hdiwm79qmf24rx1wcmc48ykbiy3pfnn0kbg77wfp0rnq7qlcknc";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aeson-commit_1_4" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, hspec, mtl, text }:
+     mkDerivation {
+       pname = "aeson-commit";
+       version = "1.4";
+       sha256 = "1xbck5hcbfqm2kc3yzrl1dzdmjl9zf84vc33ird3c50ny884amwa";
+       libraryHaskellDepends = [ aeson base mtl text ];
+       testHaskellDepends = [ aeson aeson-qq base hspec text ];
+       description = "Parse Aeson data with commitment";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aeson-compat" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base
      , base-compat, base-orphans, bytestring, containers, exceptions
···
      }:
      mkDerivation {
        pname = "aeson-match-qq";
-       version = "1.2.0";
-       sha256 = "000dna5xs5ybhr4vyla6ndj7ykk7lphg4dbcp7nn13746fnnggs2";
+       version = "1.3.0";
+       sha256 = "1jxw5rg8sj0913h9ldknhikpq7avlwj0lmqx613zsr9kv4yhz1qh";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either haskell-src-meta scientific
          template-haskell text unordered-containers vector
···
      }:
      mkDerivation {
        pname = "ansi-terminal-game";
-       version = "1.2.0.0";
-       sha256 = "167zld2dwb1l81w1n8iiqdgxx8805sirr9lsacn1ni8cfzzl2gf6";
+       version = "1.2.1.0";
+       sha256 = "1gzqf0dby0w25nbz6lzlb4b7jgxydv09wqfcvbcfjwn0wg76wfvc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "An interpreter for the Argh! programming language in wxHaskell";
        license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "argo" = callPackage
+    ({ mkDerivation, array, base, bytestring, deepseq, tasty
+     , tasty-bench, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "argo";
+       version = "0.2021.10.13";
+       sha256 = "1jlw1v0kzcapc0ziax15hxgvb86q7cby7dpsqlrygw0y72w05w9q";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ array base bytestring deepseq text ];
+       executableHaskellDepends = [ array base bytestring deepseq text ];
+       testHaskellDepends = [
+         array base bytestring deepseq tasty tasty-hunit tasty-quickcheck
+         text
+       ];
+       benchmarkHaskellDepends = [
+         array base bytestring deepseq tasty-bench text
+       ];
+       description = "Parse and render JSON";
+       license = lib.licenses.mit;
      }) {};
 
   "argon" = callPackage
···
        pname = "bitwise-enum";
        version = "1.0.1.0";
        sha256 = "0vmdr8csmxwab7s4nmqdfpqdssivh90fddk94i8wkwj1la867y1z";
+       revision = "1";
+       editedCabalFile = "0g4w46bv0pj52v3kfcc41g9m750il67fg78n54s91p6jam6l0r6h";
        libraryHaskellDepends = [
          aeson array base deepseq mono-traversable vector
        ];
···
        pname = "bloodhound";
        version = "0.16.0.0";
        sha256 = "0g4x2g0qmwgfrz39iwwagrr7p19fmmz1fpfk29bkmvqvbfvsjgqz";
+       revision = "1";
+       editedCabalFile = "129sx2n094p2y7k8hf1cpr84hw2z9lk37l1w515r85n09ckkyb2l";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers exceptions hashable
          http-client http-types mtl network-uri scientific semigroups semver
···
        pname = "bnb-staking-csvs";
        version = "0.2.0.0";
        sha256 = "1m2bd6cwlgavq3nri3xwbqim2zikzv1dxqf5a5gxkqra1qgbvm4v";
+       revision = "1";
+       editedCabalFile = "066nk1wjxlwh1dqhgr4yalch45w09p032whbvs5rin18airixyk3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bugzilla-redhat_0_3_3" = callPackage
+    ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
+     , containers, hspec, http-conduit, http-types, iso8601-time
+     , resourcet, text, time, transformers, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "bugzilla-redhat";
+       version = "0.3.3";
+       sha256 = "1nslky0rc868hyx11s0bvlz6r4mvagknhwmnlqvgcnlfbg6xni4d";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring connection containers
+         http-conduit http-types iso8601-time resourcet text time
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [ aeson base hspec time ];
+       description = "A Haskell interface to the Bugzilla native REST API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "build" = callPackage
     ({ mkDerivation, algebraic-graphs, base, containers, extra
      , filepath, mtl, random, transformers
···
        pname = "ca-province-codes";
        version = "1.0.0.0";
        sha256 = "1lhmmqn83v9bflm4x2nqbxx6pjh393id29syglinaqal4dvl5qq3";
+       revision = "1";
+       editedCabalFile = "0502zw8bbx6761s8dfnmbnw475y9x2ikk8s281j1fd1db3wdv17l";
        libraryHaskellDepends = [ aeson base text ];
        testHaskellDepends = [ aeson base hspec QuickCheck text ];
        description = "ISO 3166-2:CA Province Codes and Names";
···
        pname = "cereal";
        version = "0.5.8.1";
        sha256 = "1mqvd1iwzr50az4y24332x3g3wsrzw8j1iwph02vr7jbjfn8i7id";
+       revision = "1";
+       editedCabalFile = "02v1nivac478nzzykjbq3rawnqskxjc4sb54m6s5jcgbigfnb2x0";
        libraryHaskellDepends = [
          array base bytestring containers ghc-prim
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "clash-ghc_1_4_4" = callPackage
+  "clash-ghc_1_4_5" = callPackage
     ({ mkDerivation, array, base, bifunctors, bytestring, Cabal
      , clash-lib, clash-prelude, concurrent-supply, containers, deepseq
      , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim
···
      }:
      mkDerivation {
        pname = "clash-ghc";
-       version = "1.4.4";
-       sha256 = "0dcyf8q5n37v1arq7dyxbgg80j1dnh3i444v9p1p9rs93l2vfnab";
+       version = "1.4.5";
+       sha256 = "1qss6wic91fwbdjmi8bk5hwv282xs7rfxx4zhp0px5dqp2s8kc6v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "clash-lib_1_4_4" = callPackage
+  "clash-lib_1_4_5" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array
      , attoparsec, base, base16-bytestring, binary, bytestring
      , clash-prelude, concurrent-supply, containers, cryptohash-sha256
···
      }:
      mkDerivation {
        pname = "clash-lib";
-       version = "1.4.4";
-       sha256 = "1s04m806mdx12mbg30qrx8w75mavs5r8g7dmf5k1v9jn97jk4gvs";
+       version = "1.4.5";
+       sha256 = "1xbh513l3xg2xh7s9zkqxp2qwf9p2qhmp0xbj91r706av1cilyxi";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal array attoparsec base
···
        broken = true;
      }) {};
 
-  "clash-prelude_1_4_4" = callPackage
+  "clash-prelude_1_4_5" = callPackage
     ({ mkDerivation, array, arrows, base, bifunctors, binary
      , bytestring, Cabal, cabal-doctest, constraints, containers
      , criterion, data-binary-ieee754, data-default-class, deepseq
···
      }:
      mkDerivation {
        pname = "clash-prelude";
-       version = "1.4.4";
-       sha256 = "14304dc9s91blh8ljv8hd3h6gsz0nr83fzf83xkr6mxkdlhzknd4";
+       version = "1.4.5";
+       sha256 = "0hikw8n0agjq5x4rfnklb9wixdbcn8snfh3rzb4r8j5b187j1brk";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          array arrows base bifunctors binary bytestring constraints
···
        libraryHaskellDepends = [ base containers transformers vector ];
        description = "A typeclass for structures which can be catMaybed, filtered, and partitioned";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "compactmap" = callPackage
···
      }:
      mkDerivation {
        pname = "configuration-tools";
-       version = "0.6.0";
-       sha256 = "1lncsh3dfl8iz1yr2b0mmpcdyww3cbr3jglp85iqmpvzv66m2kbg";
+       version = "0.6.1";
+       sha256 = "1gindjq9vd0fmsw6smwd3syz3k3bfkzsgmchqg6jllr6bhgvykjy";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "consumers";
-       version = "2.2.0.4";
-       sha256 = "0rssm2ygr395djjzkrzcq3vylc83k58flwcpqb4cb3w1id55ph5r";
+       version = "2.2.0.5";
+       sha256 = "1ramqz680xfh47p5kijcp58nby687lm5vacfxpz57a3p01j39y8s";
        libraryHaskellDepends = [
          base containers exceptions extra hpqtypes lifted-base
          lifted-threads log-base monad-control monad-time mtl stm time
···
        pname = "deriving-aeson";
        version = "0.2.7";
        sha256 = "02mx8z1cgqn9wgwcp94am2g655hhn7sn12sikmm8jhbldnyv3ziz";
+       revision = "1";
+       editedCabalFile = "0qgkjl7h1d4w119a97wrsznnqys02mlkwv9hic1715swg0cp05ix";
        libraryHaskellDepends = [ aeson base ];
        testHaskellDepends = [ aeson base bytestring ];
        description = "Type driven generic aeson instance customisation";
···
      }:
      mkDerivation {
        pname = "distribution-nixpkgs";
-       version = "1.6.1";
-       sha256 = "136q893in07iw53m9pqr65h3mrnpvfda272bl4rq1b0z3hzpyhkm";
+       version = "1.6.2";
+       sha256 = "0kq4pf5dalifxd8qxz75fazfjspn36q0cmp8d1jd7w9zlzc3c4dz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers deepseq language-nix lens
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "doclayout_0_3_1" = callPackage
+  "doclayout_0_3_1_1" = callPackage
     ({ mkDerivation, base, containers, criterion, emojis, mtl, safe
      , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text
      }:
      mkDerivation {
        pname = "doclayout";
-       version = "0.3.1";
-       sha256 = "0cbb8l1m7w1ycf0pv8y9cbly9qxw3w5ngqbghj6qd5kk02my9zwj";
+       version = "0.3.1.1";
+       sha256 = "1p9kgjlf7y4p1symvkwndgs4lvyw2c45bsgld09y9r4aiqbhdrxp";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base containers emojis mtl safe text ];
        testHaskellDepends = [
···
        pname = "ede";
        version = "0.3.2.0";
        sha256 = "1y78l8b6wnl621nlfm3jwf9qskfnyd4ian1sxjsmk2jw22z1yp4d";
+       revision = "1";
+       editedCabalFile = "0zgz0d3qj8slkbsg4r7jdhnrr5zlq506hviq6kw20d78mafh16c0";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Monoidal Quasiquote Interpolation";
        license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exotic-list-monads" = callPackage
···
      }) {};
 
   "flatparse" = callPackage
-    ({ mkDerivation, attoparsec, base, bytesmith, bytestring
-     , containers, gauge, integer-gmp, megaparsec, parsec, primitive
+    ({ mkDerivation, attoparsec, base, bytestring, containers, gauge
+     , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive
      , template-haskell
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.2.2.0";
-       sha256 = "13cm882c2n0p52dwn802cqgfqrgkmlrb1kaxm2l89yfpb6wqynfz";
+       version = "0.3.0.0";
+       sha256 = "0x6q1dwk9zr9s7rx3knm127pjnkpcqmihdzajfcmvi0ayviq984i";
        libraryHaskellDepends = [
          base bytestring containers integer-gmp template-haskell
        ];
+       testHaskellDepends = [ base bytestring hspec HUnit ];
        benchmarkHaskellDepends = [
-         attoparsec base bytesmith bytestring gauge integer-gmp megaparsec
-         parsec primitive
+         attoparsec base bytestring gauge integer-gmp megaparsec parsec
+         primitive
        ];
        description = "High-performance parsing from strict bytestrings";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "flay" = callPackage
···
        testHaskellDepends = [ aeson base containers hspec mtl text ];
        description = "Parse and validate forms in JSON format";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "forma_1_2_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, hspec, mtl, text }:
+     mkDerivation {
+       pname = "forma";
+       version = "1.2.0";
+       sha256 = "13kyggzlf156d3d3mj453jwmafyz74vk4bim3f30zxyd6syl3m5v";
+       revision = "1";
+       editedCabalFile = "12336x0g41hp6brl4ynw0m32kj3n191945qfgp8xaabm5qrchinj";
+       libraryHaskellDepends = [ aeson base containers mtl text ];
+       testHaskellDepends = [ aeson base containers hspec mtl text ];
+       description = "Parse and validate forms in JSON format";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "formal" = callPackage
···
        pname = "geojson";
        version = "4.0.2";
        sha256 = "0csbg4pdh686bxk689968bi94njx78iv1sm5g6lp915pg6cfnd66";
+       revision = "1";
+       editedCabalFile = "1ry2z0hwacbdwpxjbz1zfwc24094776xqshqdkq23r2gfgyy3m3k";
        libraryHaskellDepends = [
          aeson base containers deepseq lens scientific semigroups text
          transformers validation vector
···
      }) {inherit (pkgs) geos;};
 
   "gerrit" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, directory
-     , http-client, http-client-tls, tasty, tasty-hunit, text
+    ({ mkDerivation, aeson, aeson-casing, base, bytestring, containers
+     , directory, http-client, http-client-openssl, tasty, tasty-hunit
+     , text, time
      }:
      mkDerivation {
        pname = "gerrit";
-       version = "0.1.0.0";
-       sha256 = "03lcf9xvyhypzkrs6lv7dnwsxnn52vnnl6mhsbbhmpv2bf59whq2";
+       version = "0.1.1.0";
+       sha256 = "0qkrcf0m2rq31sqd3fqij5c0yfp5pnzj2fx3dh9cwi7dqz24jwsg";
        libraryHaskellDepends = [
-         aeson base bytestring containers http-client http-client-tls text
+         aeson aeson-casing base bytestring containers http-client
+         http-client-openssl text time
        ];
        testHaskellDepends = [
-         aeson base bytestring directory tasty tasty-hunit
+         aeson base bytestring directory tasty tasty-hunit time
        ];
        description = "A gerrit client library";
        license = lib.licenses.asl20;
···
        pname = "gogol-core";
        version = "0.5.0";
        sha256 = "0xvlrx4hzhwp3slinh8apnxlgxmispjjnmwsfbpi4p9n451ilx93";
+       revision = "1";
+       editedCabalFile = "0k6nhsl0jh233ym25fh03nc2gja6q27hcav1kbs9lfpyf0qdvvyl";
        libraryHaskellDepends = [
          aeson attoparsec base bifunctors bytestring case-insensitive
          conduit dlist exceptions hashable http-api-data http-client
···
        pname = "haddock-library";
        version = "1.10.0";
        sha256 = "15ak06q8yp11xz1hwr0sg2jqi3r78p1n89ik05hicqvxl3awf1pq";
+       revision = "1";
+       editedCabalFile = "1r2mz68415wq3l194ryki8r8p7n7h21033m1ixrpd259s4yq6zdp";
        libraryHaskellDepends = [
          base bytestring containers parsec text transformers
        ];
···
      }:
      mkDerivation {
        pname = "io-manager";
-       version = "0.2.2";
-       pname = "io-manager";
+       version = "0.2.3";
+       sha256 = "10scykaf8kadvgvc5pxjdyn8zvxqmp5gkdy0n82p4mmf2chmdzqz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "io-manager";
        version = "0.1.2.0";
        pname = "io-manager";
+       revision = "1";
+       editedCabalFile = "1dbcvypi8kcrcy38wbvhaadhs2fwjw1kh3xzzq07ss30a7gg3k8y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "hpack_0_34_5" = callPackage
+    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
+     , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
+     , hspec-discover, http-client, http-client-tls, http-types, HUnit
+     , infer-license, interpolate, mockery, pretty, QuickCheck
+     , scientific, template-haskell, temporary, text, transformers
+     , unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "hpack";
+       version = "0.34.5";
+       sha256 = "0gmm6jgi1sgyilphww6apq1x04grqznm7xhyb7g1rj5j7my40ws2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       executableHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob http-client http-client-tls
+         http-types infer-license pretty scientific text transformers
+         unordered-containers vector yaml
+       ];
+       testHaskellDepends = [
+         aeson base bifunctors bytestring Cabal containers cryptonite
+         deepseq directory filepath Glob hspec http-client http-client-tls
+         http-types HUnit infer-license interpolate mockery pretty
+         QuickCheck scientific template-haskell temporary text transformers
+         unordered-containers vector yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A modern format for Haskell packages";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hpack-convert" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, base-compat, bytestring
      , Cabal, containers, deepseq, directory, filepath, Glob, hspec
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.12.0.0";
-       sha256 = "0pxidphf0qzfy5zv1q7qhp49bgglf3pqd6r91qq0iawnvgzcyi7z";
-       revision = "2";
-       editedCabalFile = "0gprlxfjdc6lxf2xazfr1wrna9whw6sh1jpv5rhp8bw0haslzl6j";
+       version = "1.12.0.1";
+       sha256 = "0qpydy2hg6fmwhwg0azgraxhjijfarns3syrv2an4ynfqcxrds9k";
+       revision = "1";
+       editedCabalFile = "1brrz8ddm0hw3c5w1mf1f8a14qk5c9wiav5a0l5fi6p1k86pfv4j";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra fields-json hpqtypes lifted-base log-base monad-control mtl
···
        license = lib.licenses.mit;
      }) {inherit (pkgs) lua5_3;};
 
+  "hslua_1_3_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, exceptions, lua5_3
+     , mtl, QuickCheck, quickcheck-instances, tasty, tasty-hunit
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "hslua";
+       version = "1.3.0.2";
+       sha256 = "0p39xm0mmxzs5x6aim11qkb7npn0d9h7li2kwfhry0dijd1vm18i";
+       configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ];
+       libraryHaskellDepends = [
+         base bytestring containers exceptions mtl text
+       ];
+       librarySystemDepends = [ lua5_3 ];
+       testHaskellDepends = [
+         base bytestring containers exceptions mtl QuickCheck
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
+       ];
+       description = "Bindings to Lua, an embeddable scripting language";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) lua5_3;};
+
   "hslua-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hashable, hslua, hspec
      , HUnit, ieee754, QuickCheck, quickcheck-instances, scientific
···
        pname = "hslua-module-text";
        version = "0.3.0.1";
        sha256 = "1vmd15n905i2pcsx748hz3h9kv5nnv74y663rj57q8mp0b40cbfl";
+       revision = "1";
+       editedCabalFile = "04y4rjfgzsz3q3m2d7ph97ligxlld74v6vhhmncj0riyxdfvy6p9";
        libraryHaskellDepends = [ base bytestring hslua text ];
        testHaskellDepends = [
          base hslua tasty tasty-hunit tasty-lua text
···
        testToolDepends = [ hspec-discover ];
        description = "HTTP/3 library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "httpd-shed" = callPackage
···
      }:
      mkDerivation {
        pname = "libarchive";
-       version = "3.0.3.0";
-       sha256 = "0zf2x317xkp7mnamm8aqp0wmc5xka6p6pljyadz0xbmy7ih55ylh";
+       version = "3.0.3.1";
+       sha256 = "1rkm6n2p41i6lxdfsrvpv5sbz2p3mgyp3xx6g437fcgjjbdsyx3q";
        revision = "1";
-       editedCabalFile = "0n0s9qfa6b0r2rwz834dlqqm68xz2hvlygzjw084dy85d6xmvl75";
+       editedCabalFile = "0r48nmczidz00l19cbmq05f766wipc9dwkqb3xsvbwwcazapbjkz";
        setupHaskellDepends = [ base Cabal chs-cabal ];
        libraryHaskellDepends = [
          base bytestring composition-prelude deepseq dlist filepath mtl
···
        ];
        description = "A simple library for linear codes (coding theory, error correction)";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "linear-generics" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, hspec, hspec-discover
+     , template-haskell, th-abstraction
+     }:
+     mkDerivation {
+       pname = "linear-generics";
+       version = "0.1.0.1";
+       sha256 = "0ck7gx1chrxyyn7lwbv4gn15zxgfgg7ai0i6404jprvvh72j7b8r";
+       libraryHaskellDepends = [
+         base containers ghc-prim template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base hspec template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Generic programming library for generalised deriving";
+       license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "matrix-client" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, base64, bytestring
-     , doctest, exceptions, hashable, hspec, http-client
+    ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base, base64
+     , bytestring, containers, exceptions, hashable, hspec, http-client
      , http-client-tls, http-types, retry, SHA, text, time
      , unordered-containers
      }:
      mkDerivation {
        pname = "matrix-client";
-       version = "0.1.1.0";
-       sha256 = "13ncklhrwb10g6pki1zsli1gnja01ic9scil4f5nky8hdmaw9jq2";
+       version = "0.1.2.0";
+       sha256 = "18n5il56p3hr6iax2d1m0b7vximc0z4jzj0dav0rhv3yrwy8p5w2";
        libraryHaskellDepends = [
-         aeson base base64 bytestring exceptions hashable http-client
-         http-client-tls http-types retry SHA text time unordered-containers
+         aeson aeson-casing base base64 bytestring containers exceptions
+         hashable http-client http-client-tls http-types retry SHA text time
+         unordered-containers
        ];
        testHaskellDepends = [
-         aeson aeson-pretty base base64 bytestring doctest exceptions
-         hashable hspec http-client http-client-tls http-types retry SHA
-         text time unordered-containers
+         aeson aeson-casing aeson-pretty base base64 bytestring containers
+         exceptions hashable hspec http-client http-client-tls http-types
+         retry SHA text time unordered-containers
        ];
        description = "A matrix client library";
        license = lib.licenses.asl20;
···
        pname = "mmark";
        version = "0.0.7.3";
        sha256 = "1gfl9jhqm1jaqxi0yxd8r4z3ai5c3f1wv53vjs0ln84qjpcqp30s";
-       revision = "1";
-       editedCabalFile = "19yg41grkliim428x9cqwcynmjvkh83mqfyxiv2dc6fvid6fmcrk";
+       revision = "2";
+       editedCabalFile = "01cd2k4jz3f2ryhxdya8biypxdl44236mnavfqx7fm7bkjz4j5x0";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base case-insensitive containers deepseq dlist email-validate
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "mmark-cli_0_0_5_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, directory
+     , ghc-syntax-highlighter, gitrev, lucid, megaparsec, mmark
+     , mmark-ext, optparse-applicative, stache, text
+     }:
+     mkDerivation {
+       pname = "mmark-cli";
+       version = "0.0.5.1";
+       sha256 = "1an1rc7gdl2209d3agxx1dfl61zsc2wg5nx9cwdf50spmlgs3cr0";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base bytestring directory ghc-syntax-highlighter gitrev lucid
+         megaparsec mmark mmark-ext optparse-applicative stache text
+       ];
+       description = "Command line interface to the MMark markdown processor";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mmark-ext" = callPackage
     ({ mkDerivation, base, foldl, ghc-syntax-highlighter, hspec
      , hspec-discover, lucid, microlens, mmark, modern-uri, skylighting
···
      }) {};
 
   "msu" = callPackage
-    ({ mkDerivation, base, directory, filepath, mtl, parsec, process
-       pname = "io-manager";
+    ({ mkDerivation, aeson, aeson-casing, base, bytestring, directory
+     , errors, filepath, hspec, parsec, process, unliftio, yaml
      }:
      mkDerivation {
        pname = "msu";
-       version = "0.0.2";
-       sha256 = "0bqzzk7y3dj60r02xn3cjlq955jzsrvcbq63pvav0w952bvxvx5c";
-       isLibrary = false;
+       version = "0.2.0.0";
+       sha256 = "15a0i7jwcqzl3ajw369xp0d9ixf0hcy9dblhywjrbalnml890sx4";
+       isLibrary = true;
        isExecutable = true;
-       executableHaskellDepends = [
-         base directory filepath mtl parsec process xdg-basedir
+       libraryHaskellDepends = [
+         aeson aeson-casing base bytestring directory parsec process
+         unliftio yaml
        ];
+       executableHaskellDepends = [ base directory filepath process ];
+       testHaskellDepends = [ base bytestring errors hspec ];
        description = "Monitor Setup Utility";
        license = lib.licenses.mit;
      }) {};
···
        pname = "mx-state-codes";
        version = "1.0.0.0";
        sha256 = "1jxw7hh24rqs1c5y4b7bmllvcwq3gsrrn0rixq9lzhn2915ykaq6";
+       revision = "1";
+       editedCabalFile = "1fl0953329z4an76287q1ic4hygzg3xzv2w0zv7dqgkpdz3qbjx7";
        libraryHaskellDepends = [ aeson base text ];
        testHaskellDepends = [ aeson base hspec QuickCheck text ];
        description = "ISO 3166-2:MX State Codes and Names";
···
      }:
      mkDerivation {
        pname = "nri-http";
-       version = "0.1.0.1";
-       sha256 = "11zrqfljnq922frbsyiwap8ayp8faq7cwbrmk0npg4qgv4gv2pz2";
+       version = "0.1.0.3";
+       sha256 = "1km4jv0g79455m3687cpihzz14pxg3wxw4r5b21mby7c8knzd1vl";
        libraryHaskellDepends = [
          aeson base bytestring conduit http-client http-client-tls
          http-types mime-types network-uri nri-observability nri-prelude
···
      }:
      mkDerivation {
        pname = "nri-kafka";
-       version = "0.1.0.0";
-       sha256 = "0ifdmli7arrlpmh1l4q974rv0bw3xirfk96xrahfab3zp36r4x3y";
+       version = "0.1.0.1";
+       sha256 = "0sybcf7lx0gqhi79h6d1rqx0ckyz38m86h87imrh4grgbikxaic5";
        libraryHaskellDepends = [
          aeson async base bytestring conduit containers hw-kafka-client
          nri-env-parser nri-observability nri-prelude safe-exceptions stm
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-observability_0_1_1_2" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
+     , bytestring, conduit, directory, hostname, http-client
+     , http-client-tls, nri-env-parser, nri-prelude, random
+     , safe-exceptions, stm, text, time, unordered-containers, uuid
+     }:
+     mkDerivation {
+       pname = "nri-observability";
+       version = "0.1.1.2";
+       sha256 = "0n4ap88ll5q86addjgfv8pf86zbnw1ic6wh7wc929fn4ygc6r2x5";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring conduit
+         directory hostname http-client http-client-tls nri-env-parser
+         nri-prelude random safe-exceptions stm text time
+         unordered-containers uuid
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base bugsnag-hs bytestring conduit
+         directory hostname http-client http-client-tls nri-env-parser
+         nri-prelude random safe-exceptions stm text time
+         unordered-containers uuid
+       ];
+       description = "Report log spans collected by nri-prelude";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-postgresql" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, filepath
-     , network, nri-env-parser, nri-observability, nri-prelude
-     , postgresql-typed, resource-pool, resourcet, safe-exceptions
-     , template-haskell, text, time
+    ({ mkDerivation, attoparsec, base, bytestring, filepath, network
+     , nri-env-parser, nri-observability, nri-prelude, postgresql-typed
+     , resource-pool, resourcet, safe-exceptions, template-haskell, text
+     , time
      }:
      mkDerivation {
        pname = "nri-postgresql";
-       version = "0.1.0.1";
-       sha256 = "1kl5wriqdshhc2fjaicj60hrwrw2c6y8vrq2pv4fagn0gxa78fvc";
+       version = "0.1.0.2";
+       sha256 = "0rm76z57zvvsswd0dyqmq7m1mrvamiff5kawkcwy4k4xkn4yl3py";
        libraryHaskellDepends = [
-         aeson attoparsec base bytestring filepath network nri-env-parser
+         attoparsec base bytestring filepath network nri-env-parser
          nri-observability nri-prelude postgresql-typed resource-pool
          resourcet safe-exceptions template-haskell text time
        ];
        testHaskellDepends = [
-         aeson attoparsec base bytestring filepath network nri-env-parser
+         attoparsec base bytestring filepath network nri-env-parser
          nri-observability nri-prelude postgresql-typed resource-pool
          resourcet safe-exceptions template-haskell text time
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "nri-prelude_0_6_0_4" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base
+     , bytestring, containers, directory, exceptions, filepath, ghc
+     , hedgehog, junit-xml, pretty-diff, pretty-show, safe-coloured-text
+     , safe-coloured-text-terminfo, safe-exceptions, terminal-size, text
+     , time, unix, vector
+     }:
+     mkDerivation {
+       pname = "nri-prelude";
+       version = "0.6.0.4";
+       sha256 = "0r2jgjrbjbkkvsk8ypg0d7r840qkadwinq0qyhng9bkjqrsrn78c";
+       libraryHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
+         pretty-show safe-coloured-text safe-coloured-text-terminfo
+         safe-exceptions terminal-size text time unix vector
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async auto-update base bytestring containers
+         directory exceptions filepath ghc hedgehog junit-xml pretty-diff
+         pretty-show safe-coloured-text safe-coloured-text-terminfo
+         safe-exceptions terminal-size text time unix vector
+       ];
+       description = "A Prelude inspired by the Elm programming language";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nri-redis" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, conduit, hedis
      , nri-env-parser, nri-observability, nri-prelude, resourcet
···
      }:
      mkDerivation {
        pname = "nri-redis";
-       version = "0.1.0.2";
-       sha256 = "12z515bs17ig8ps1kq2pp1c80r6cn0rldvqa6rzfgc1nrd0p8hc9";
+       version = "0.1.0.3";
+       sha256 = "1mdzqvnx7gzr8j99c8nza40y518jg8ajxfrvdvf90gvbglknimb0";
        libraryHaskellDepends = [
          aeson async base bytestring conduit hedis nri-env-parser
          nri-observability nri-prelude resourcet safe-exceptions text
···
      }:
      mkDerivation {
        pname = "nri-test-encoding";
-       version = "0.1.1.0";
-       sha256 = "0k21hyd0kbgdg3kmfwy20vf21r6963ygybz1v84wjmfzqbc5fcq5";
+       version = "0.1.1.1";
+       sha256 = "07hrkjbyp07p0yryx92q0bjqkkjji4d952sxcm9j2w5mdvlc08mq";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring filepath nri-prelude nri-redis
          servant servant-auth-server servant-server text
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ormolu_0_3_0_1" = callPackage
+  "ormolu_0_3_1_0" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, Cabal, containers
      , Diff, directory, dlist, exceptions, filepath, ghc-lib-parser
      , gitrev, hspec, hspec-discover, mtl, optparse-applicative, path
···
      }:
      mkDerivation {
        pname = "ormolu";
-       version = "0.3.0.1";
-       sha256 = "1cp543ff0gng6v5l251fklrk73yqfgbymx824ldc7inwybmd6z03";
+       version = "0.3.1.0";
+       sha256 = "1517z6bi8ifzdmfclmqdiipi6zcnxagymf1sxr43sj2ipkglg2rs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "pandora";
-       version = "0.4.6";
-       sha256 = "0x1wnrdbri1jcpi2iva69rw6bs6i9y192fymjamrab0w69bd9p4y";
+       version = "0.4.7";
+       sha256 = "1kda661i18kzrfj38si48n1shbqxh30p1sz97cb871ni2hlqsarj";
        description = "A box of patterns and paradigms";
        license = lib.licenses.mit;
      }) {};
···
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
+  "persistent_2_13_2_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , blaze-html, bytestring, conduit, containers, criterion, deepseq
+     , fast-logger, file-embed, hspec, http-api-data, lift-type
+     , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances
+     , resource-pool, resourcet, scientific, shakespeare, silently
+     , template-haskell, text, th-lift-instances, time, transformers
+     , unliftio, unliftio-core, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "persistent";
+       version = "2.13.2.1";
+       sha256 = "13lp9i94f57qhifdmr1vnsrra34526f7kqa1sybcaj2jh2v3q85k";
+       revision = "1";
+       editedCabalFile = "15lx2kd8ijn91h65nhzxmd50hmmybhs6x6qfg5wnl3ylcmgi6glg";
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-html bytestring
+         conduit containers fast-logger http-api-data lift-type monad-logger
+         mtl path-pieces resource-pool resourcet scientific silently
+         template-haskell text th-lift-instances time transformers unliftio
+         unliftio-core unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-html bytestring
+         conduit containers fast-logger hspec http-api-data monad-logger mtl
+         path-pieces QuickCheck quickcheck-instances resource-pool resourcet
+         scientific shakespeare silently template-haskell text
+         th-lift-instances time transformers unliftio unliftio-core
+         unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq file-embed template-haskell text
+       ];
+       description = "Type-safe, multi-backend data serialization";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ psibi ];
+     }) {};
+
   "persistent-audit" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , getopt-generics, hashable, hspec, mongoDB, persistent
···
        license = lib.licenses.mit;
      }) {};
 
+  "persistent-postgresql_2_13_2_1" = 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.2.1";
+       sha256 = "07pnr8m0nk43jaz6l293lzx4ivyqgnw94fjypazzm008b4irh7ir";
+       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-protobuf" = callPackage
     ({ mkDerivation, base, bytestring, persistent, protocol-buffers
      , protocol-buffers-descriptor, template-haskell, text
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.12.1.0";
-       sha256 = "1scjdf6k36vqd4cdnsqwwhbb97dsicarrc320w4ybikr1rk42phd";
+       version = "0.13.0.0";
+       sha256 = "1zpbcp3ij8j2vmss511kvrzwzymnjmzqs628hv0n9nnzvgma5nn7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "pid1_0_1_3_0" = callPackage
+    ({ mkDerivation, base, directory, process, unix }:
+     mkDerivation {
+       pname = "pid1";
+       version = "0.1.3.0";
+       sha256 = "1m2i03ncgn1y6h2352pnvhcqzif45505vlnxh11xngvjx47f85a1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory process unix ];
+       executableHaskellDepends = [ base ];
+       description = "Do signal handling and orphan reaping for Unix PID1 init processes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pidfile" = callPackage
     ({ mkDerivation, base, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "polysemy-check";
-       version = "0.3.0.0";
-       sha256 = "1m7m1mi7fbf1nj98c91qxhbnhyqxgb8y7ryj7bk1llinmp2lmwaz";
+       version = "0.5.0.0";
+       sha256 = "0ch8dzzap6f6bfdyy8i9xdna9l7d3yvx9m7z3pz9pjb19vjxa3f6";
        libraryHaskellDepends = [
          base containers kind-generics kind-generics-th polysemy QuickCheck
        ];
···
          transformers
        ];
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "proton-haskell" = callPackage
···
 
   "pure-zlib" = callPackage
     ({ mkDerivation, array, base, base-compat, bytestring
-     , bytestring-builder, containers, filepath, fingertree, HUnit
+     , bytestring-builder, containers, criterion, filepath, HUnit
      , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, time
      }:
      mkDerivation {
        pname = "pure-zlib";
-       version = "0.6.7";
-       sha256 = "1ddj88zk94gqqhxiyvkachvhwi5n2la4pfaf5vppkc9ma7sjhyhn";
+       version = "0.6.8";
+       sha256 = "10rlgzq6p93irnhlh8hzj040xbf8gn8swszbkrmaln0b2kk1mncb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base base-compat bytestring bytestring-builder containers
-         fingertree
        ];
        executableHaskellDepends = [ base base-compat bytestring ];
        testHaskellDepends = [
          base base-compat bytestring filepath HUnit QuickCheck tasty
          tasty-hunit tasty-quickcheck
        ];
-       benchmarkHaskellDepends = [ base base-compat bytestring time ];
+       benchmarkHaskellDepends = [
+         base base-compat bytestring criterion time
+       ];
        description = "A Haskell-only implementation of zlib / DEFLATE";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pureMD5_2_1_4" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cereal, crypto-api
+     , crypto-api-tests, pretty-hex, QuickCheck, tagged, test-framework
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "pureMD5";
+       version = "2.1.4";
+       sha256 = "0qwkvxwi9wh6knn69rg2hvc8ngmv1if77kmpcnp0xqr0l30fwavq";
+       libraryHaskellDepends = [
+         base binary bytestring cereal crypto-api tagged
+       ];
+       testHaskellDepends = [
+         base binary bytestring cereal crypto-api-tests pretty-hex
+         QuickCheck test-framework test-framework-quickcheck2
+       ];
+       description = "A Haskell-only implementation of the MD5 digest (hash) algorithm";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "purebred-email" = callPackage
     ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
      , case-insensitive, concise, deepseq, hedgehog, lens, QuickCheck
···
        pname = "reanimate-svg";
        version = "0.13.0.1";
        sha256 = "1h31r0lrslxqfayh06955p1kv35g42g3drmqp4miydk6zibyn091";
+       revision = "1";
+       editedCabalFile = "1g8cqw8a4vy7pp9ic02d49564vd61px2kld1pin0la9f3vk5f296";
        libraryHaskellDepends = [
          attoparsec base bytestring containers double-conversion hashable
          JuicyPixels lens linear mtl scientific text transformers vector xml
···
        maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
-  "req_3_9_1" = callPackage
+  "req_3_9_2" = callPackage
     ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder
      , bytestring, case-insensitive, connection, exceptions, hspec
      , hspec-core, hspec-discover, http-api-data, http-client
      , http-client-tls, http-types, modern-uri, monad-control, mtl
      , QuickCheck, retry, template-haskell, text, time, transformers
-     , transformers-base, unliftio-core, unordered-containers
+     , transformers-base, unliftio-core
      }:
      mkDerivation {
        pname = "req";
-       version = "3.9.1";
-       sha256 = "0468ah4142jrqp5l3pw4izrw6f6kznisan888b30jhif4c6xncr0";
-       revision = "3";
-       editedCabalFile = "0xx161kb3j1givixs489yhd6zgiscajbn6hdkf00pdkwqdy59k75";
+       version = "3.9.2";
+       sha256 = "17xkj5pypn4k6ncsahjc0h827kg3cyx5iy5q6iv1gvk8dwdiim0g";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson authenticate-oauth base blaze-builder bytestring
···
        testHaskellDepends = [
          aeson base blaze-builder bytestring case-insensitive hspec
          hspec-core http-client http-types modern-uri monad-control mtl
-         QuickCheck retry template-haskell text time unordered-containers
+         QuickCheck retry template-haskell text time
        ];
        testToolDepends = [ hspec-discover ];
        doCheck = false;
···
      }:
      mkDerivation {
        pname = "servant-benchmark";
-       version = "0.2.0.0";
-       sha256 = "0dxyq9n0v09287nz1nqb2m0bdyabdzqig9avpmx4viyf9xzyh6bd";
+       version = "0.1.2.0";
+       sha256 = "0lqqk410nx48g895pfxkbbk85b1ijs4bfl9zr2li2p7wwwc4gyi9";
+       revision = "3";
+       editedCabalFile = "17pj6n143lpk5nsr6j8j1a6fj45y1bv61jcm16m0fwsdmhv01866";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive http-media
          http-types QuickCheck servant text yaml
···
        pname = "solana-staking-csvs";
        version = "0.1.1.0";
        sha256 = "0ya63vgh0nf4p7hz6fj38m44wr77jj76bf2qxdgra3lpiziqsjd5";
-       revision = "1";
-       editedCabalFile = "14l72fkvvmiy1hmn2v3nxgx4s5z0zzyi3qf4l1i1cn54a0ln35q6";
+       revision = "2";
+       editedCabalFile = "1f55xdlmfj5g5r7dr71aw878g3ii9zaxj24znc370j2gd182nr13";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "stache_2_3_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, criterion
+     , deepseq, directory, file-embed, filepath, gitrev, hspec
+     , hspec-discover, hspec-megaparsec, megaparsec, mtl
+     , optparse-applicative, template-haskell, text, vector, yaml
+     }:
+     mkDerivation {
+       pname = "stache";
+       version = "2.3.1";
+       sha256 = "1a26pwg6y90588yf9sp18w4b2ahr64fxdhy1c3zv0c9pw7bv6k6q";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers deepseq directory filepath
+         megaparsec mtl template-haskell text vector
+       ];
+       executableHaskellDepends = [
+         aeson base filepath gitrev optparse-applicative text yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers file-embed hspec hspec-megaparsec
+         megaparsec template-haskell text yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         aeson base criterion deepseq megaparsec text
+       ];
+       description = "Mustache templates for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "stack" = callPackage
     ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array
      , async, attoparsec, base, base64-bytestring, bytestring, Cabal
···
        libraryPkgconfigDepends = [ librsvg ];
        description = "Binding to the libsvg-cairo library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       maintainers = with lib.maintainers; [ dalpd ];
      }) {inherit (pkgs) librsvg;};
 
   "svgone" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "tasty-silver_3_3" = callPackage
+  "tasty-silver_3_3_1" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
      , deepseq, directory, filepath, mtl, optparse-applicative, process
      , process-extras, regex-tdfa, silently, stm, tagged, tasty
···
      }:
      mkDerivation {
        pname = "tasty-silver";
-       version = "3.3";
-       sha256 = "1glhq2kkgnv5bf2664k7ph9kz9wcak758jb1jszl03wpv5c8idil";
+       version = "3.3.1";
+       sha256 = "1pd83mzx0iv3f396m09rxmgcpcfaya0a9818dl3h4vgw0hnqkmav";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring containers deepseq directory
          filepath mtl optparse-applicative process process-extras regex-tdfa
···
        pname = "tokyocabinet-haskell";
        version = "0.0.7";
        sha256 = "1fmj46wvl6ayx30r5r538vnygz32s1877m2f9zf7nb2zyiz5vmcb";
-       revision = "1";
-       editedCabalFile = "07kx002x3yh1klhxn9fq0bi2pfy4mdqacg3caqklmdl22dkh74lq";
+       revision = "2";
+       editedCabalFile = "0h9lc9cg5iwy9apjz48nwvblsmlkv7r5rvnivshvhys2xi1hfxja";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ tokyocabinet ];
        testHaskellDepends = [ base bytestring directory HUnit mtl ];
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.12.2";
-       sha256 = "1vypjnwvvvd0rw99qsb00jnwpq792s9x1wi62zdyzq9cwlf47ici";
+       version = "3.13";
+       sha256 = "14cb1fg0x0fy2bvjyjmxvbq2sm56ixzvz9sqacs7nak961yyvdy0";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.2";
-       sha256 = "05h54dzci8ahnxshrcd7l6bpg1q8llnrwycgpbpn12cf6ddmdc59";
+       version = "0.5.3";
+       sha256 = "16p1yn72il988phw4h8ixs0p2dgk96xg26yp9lgbpri1l0da8kiq";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
      }:
      mkDerivation {
        pname = "wai-handler-hal";
-       version = "0.1.0.0";
-       sha256 = "0sjw01k5dyhdi33ld1pd4mf9plpij0spzxf2b228cjyc8x5zx7rj";
-       revision = "2";
-       editedCabalFile = "0aj45x1czwd69hd4yxsc607njb1qwxz926izzh79axfkrzgiij9k";
+       version = "0.1.1.0";
+       sha256 = "1l9adjrh0iffph40pqymikr5h52ldlyp2q9l7qclcamwdwkawmz0";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive hal http-types
          network text unordered-containers vault wai
···
     ({ mkDerivation, base, mtl, time }:
      mkDerivation {
        pname = "watchdog";
-       version = "0.3";
-       sha256 = "0v8jbrnqg48x5ksdacsd0xazpxqv64ggzihg6k2y6pljqznrhn1i";
-       revision = "1";
-       editedCabalFile = "1hmjlva0pbvbbl3vcngqlqrisx32qzlc9pl96zh2rb6m25riisdg";
+       version = "0.3.1";
+       sha256 = "01zhj464c1lwjgb6zijqjlrzfcrknfmf2v2b2m1pmxy94jly2ww9";
        libraryHaskellDepends = [ base mtl time ];
        description = "Simple control structure to re-try an action with exponential backoff";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "witherable_0_4_2" = callPackage
+    ({ mkDerivation, base, base-orphans, containers, hashable
+     , indexed-traversable, indexed-traversable-instances, QuickCheck
+     , quickcheck-instances, tasty, tasty-quickcheck, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "witherable";
+       version = "0.4.2";
+       sha256 = "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br";
+       libraryHaskellDepends = [
+         base base-orphans containers hashable indexed-traversable
+         indexed-traversable-instances transformers unordered-containers
+         vector
+       ];
+       testHaskellDepends = [
+         base containers hashable QuickCheck quickcheck-instances tasty
+         tasty-quickcheck transformers unordered-containers vector
+       ];
+       description = "filterable traversable";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "witherable-class" = callPackage
     ({ mkDerivation, base, witherable }:
      mkDerivation {
···
        ];
        description = "An interpreter of \"xml-query\" queries for the \"xml-types\" documents";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "xml-syntax" = callPackage
+    ({ mkDerivation, array-builder, array-chunks, base, bytebuild
+     , byteslice, bytesmith, bytestring, primitive, tasty, tasty-hunit
+     , text-short
+     }:
+     mkDerivation {
+       pname = "xml-syntax";
+       version = "0.1.0.0";
+       sha256 = "1dbhh4rxvh0w17f9m2sd01bv6q20mg734wb87w6iqp4pv71mzhn3";
+       libraryHaskellDepends = [
+         array-builder array-chunks base bytebuild byteslice bytesmith
+         bytestring primitive text-short
+       ];
+       testHaskellDepends = [
+         base byteslice bytestring primitive tasty tasty-hunit
+       ];
+       description = "Parse XML from bytes";
+       license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
      }) {};
 
   "zoovisitor" = callPackage
-    ({ mkDerivation, base, hspec, uuid, Z-Data, Z-IO, zookeeper_mt }:
+    ({ mkDerivation, async, base, hspec, uuid, Z-Data, Z-IO
+     , zookeeper_mt
+     }:
      mkDerivation {
        pname = "zoovisitor";
-       version = "0.1.4.0";
-       sha256 = "163aixwxjnrbd9gzh73mys2zkbni3sjxmjyg7z374fa1k08rrxya";
+       version = "0.1.5.0";
+       sha256 = "0sksa3sjgd2yg2cj6vr9ssk52zlhap45c93cwslk3q788c8krr35";
        libraryHaskellDepends = [ base Z-Data Z-IO ];
        librarySystemDepends = [ zookeeper_mt ];
-       testHaskellDepends = [ base hspec uuid Z-Data ];
+       testHaskellDepends = [ async base hspec uuid Z-Data ];
        description = "A haskell binding to Apache Zookeeper C library(mt) using Haskell Z project";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;

pkgs/development/haskell-modules/patches/recursion-schemes-128.patch

···
+diff --git a/recursion-schemes.cabal b/recursion-schemes.cabal
+index c35f2c6..e692ade 100644
+--- a/recursion-schemes.cabal
++++ b/recursion-schemes.cabal
+@@ -93,6 +93,7 @@ library
+       Paths_recursion_schemes
+ 
+   ghc-options: -Wall
++  ghc-prof-options: -DPROFILING_ENABLED
+   if impl(ghc >= 8.6)
+     ghc-options: -Wno-star-is-type
+   default-language: Haskell2010
+diff --git a/src/Data/Functor/Foldable/TH.hs b/src/Data/Functor/Foldable/TH.hs
+index b3d5ac8..d4ef0e4 100644
+--- a/src/Data/Functor/Foldable/TH.hs
++++ b/src/Data/Functor/Foldable/TH.hs
+@@ -1,4 +1,7 @@
+ {-# LANGUAGE CPP, PatternGuards, Rank2Types #-}
++#if defined(PROFILING_ENABLED)
++{-# OPTIONS_GHC -O0 #-}
++#endif
+ module Data.Functor.Foldable.TH
+   ( MakeBaseFunctor(..)
+   , BaseRules

pkgs/development/interpreters/lua-5/build-lua-package.nix

···
 # propagate build dependencies so in case we have A -> B -> C,
 # C can import package A propagated by B
 , propagatedBuildInputs ? []
-, propagatedNativeBuildInputs ? []
 
 # used to disable derivation, useful for specific lua versions
 # TODO move from this setting meta.broken to a 'disabled' attribute on the
···
 # The latter is used to work-around luarocks having a problem with
 # multiple-output derivations as external deps:
 # https://github.com/luarocks/luarocks/issues/766<Paste>
-, externalDeps ? lib.unique (lib.filter (drv: !drv ? luaModule) (propagatedBuildInputs ++ buildInputs))
+, externalDeps ? []
 
 # Appended to the generated luarocks config
 , extraConfig ? ""
···
 let
   generatedRockspecFilename = "${rockspecDir}/${pname}-${version}.rockspec";
 
-
   # TODO fix warnings "Couldn't load rockspec for ..." during manifest
   # construction -- from initial investigation, appears it will require
   # upstream luarocks changes to fix cleanly (during manifest construction,
···
   luarocks_config = "luarocks-config.lua";
   luarocks_content = let
     generatedConfig = lua.pkgs.lib.generateLuarocksConfig {
-      inherit externalDeps;
+      externalDeps = externalDeps ++ externalDepsGenerated;
       inherit extraVariables;
       inherit rocksSubdir;
       inherit requiredLuaRocks;
···
   # Filter out the lua derivation itself from the Lua module dependency
   # closure, as it doesn't have a rock tree :)
   requiredLuaRocks = lib.filter (d: d ? luaModule)
-    (lua.pkgs.requiredLuaModules propagatedBuildInputs);
+    (lua.pkgs.requiredLuaModules luarocksDrv.propagatedBuildInputs);
 
   # example externalDeps': [ { name = "CRYPTO"; dep = pkgs.openssl; } ]
+  externalDepsGenerated = lib.unique (lib.filter (drv: !drv ? luaModule) (luarocksDrv.propagatedBuildInputs ++ luarocksDrv.buildInputs));
   externalDeps' = lib.filter (dep: !lib.isDerivation dep) externalDeps;
-in
-toLuaModule ( lua.stdenv.mkDerivation (
+
+  luarocksDrv = toLuaModule ( lua.stdenv.mkDerivation (
 builtins.removeAttrs attrs ["disabled" "checkInputs" "externalDeps" "extraVariables"] // {
 
   name = namePrefix + pname + "-" + version;
···
     runHook postConfigure
   '';
 
-  # TODO could be moved to configurePhase
   buildPhase = ''
     runHook preBuild
 
     nix_debug "Using LUAROCKS_CONFIG=$LUAROCKS_CONFIG"
 
-    LUAROCKS=luarocks
+    LUAROCKS=${lua.pkgs.luarocks}/bin/luarocks
     if (( ''${NIX_DEBUG:-0} >= 1 )); then
         LUAROCKS="$LUAROCKS --verbose"
     fi
···
   passthru = {
     inherit lua; # The lua interpreter
     inherit externalDeps;
+    inherit luarocks_content;
   } // passthru;
 
   meta = {
···
     maintainers = (meta.maintainers or []) ++ [ ];
     broken = disabled;
   } // meta;
-}))
+}));
+in
+  luarocksDrv

pkgs/development/lua-modules/default.nix

···
   overridenPackages = import ./overrides.nix { inherit pkgs; };
 
   generatedPackages = if (builtins.pathExists ./generated-packages.nix) then
-        pkgs.callPackage ./generated-packages.nix { } else (final: prev: {});
+    (final: prev: pkgs.callPackage ./generated-packages.nix { inherit (final) callPackage; } final prev) else (final: prev: {});
 
   extensible-self = lib.makeExtensible
     (extends overrides

pkgs/development/lua-modules/generated-packages.nix

···
-
 /* pkgs/development/lua-modules/generated-packages.nix is an auto-generated file -- DO NOT EDIT!
 Regenerate it with:
 nixpkgs$ ./maintainers/scripts/update-luarocks-packages
···
 You can customize the generated packages in pkgs/development/lua-modules/overrides.nix
 */
 
-{ self, stdenv, lib, fetchurl, fetchgit, ... } @ args:
-self: super:
-with self;
+{ self, stdenv, lib, fetchurl, fetchgit, callPackage, ... } @ args:
+final: prev:
 {
-alt-getopt = buildLuarocksPackage {
+alt-getopt = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "alt-getopt";
   version = "0.8.0-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ arobyn ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-argparse = buildLuarocksPackage {
+argparse = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "argparse";
   version = "scm-2";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A feature-rich command-line argument parser";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-basexx = buildLuarocksPackage {
+basexx = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "basexx";
   version = "scm-0";
   rockspecDir = "dist";
···
     sha256 = "1x0d24aaj4zld4ifr7mi8zwrym5shsfphmwx5jzw2zg22r6xzlz1";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A base2, base16, base32, base64 and base85 library for Lua";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-binaryheap = buildLuarocksPackage {
+binaryheap = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "binaryheap";
   version = "0.4-1";
 
···
     sha256 = "0f5l4nb5s7dycbkgh3rrl7pf0npcf9k6m2gr2bsn09fjyb3bdc8h";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vcunat ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-bit32 = buildLuarocksPackage {
+bit32 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "bit32";
   version = "5.3.0-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ lblasc ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-busted = buildLuarocksPackage {
+busted = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, lua_cliargs, luafilesystem, luasystem, dkjson, say, luassert, lua-term, penlight, mediator_lua
+}:
+buildLuarocksPackage {
   pname = "busted";
   version = "2.0.0-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1ps7b3f4diawfj637mibznaw4x08gn567pyni0m2s50hrnw4v8zx";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua lua_cliargs luafilesystem luasystem dkjson say luassert lua-term penlight mediator_lua ];
 
   meta = {
···
     description = "Elegant Lua unit testing.";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-cassowary = buildLuarocksPackage {
+cassowary = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, penlight
+}:
+buildLuarocksPackage {
   pname = "cassowary";
   version = "2.3.1-2";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/cassowary-2.3.1-2.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/cassowary-2.3.1-2.rockspec";
     sha256 = "04y882f9ai1jhk0zwla2g0fvl56a75rwnxhsl9r3m0qa5i0ia1i5";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua penlight ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ marsam alerque ];
     license.fullName = "Apache 2";
   };
-};
+}) {};
 
-compat53 = buildLuarocksPackage {
+compat53 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "compat53";
   version = "0.7-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1x3wv1qx7b2zlf3fh4q9pmi2xxkcdm024g7bf11rpv0yacnhran3";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vcunat ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-cosmo = buildLuarocksPackage {
+cosmo = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lpeg
+}:
+buildLuarocksPackage {
   pname = "cosmo";
   version = "16.06.04-1";
   knownRockspec = (fetchurl {
···
     maintainers = with lib.maintainers; [ marsam ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-coxpcall = buildLuarocksPackage {
+coxpcall = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit}:
+buildLuarocksPackage {
   pname = "coxpcall";
   version = "1.17.0-1";
   knownRockspec = (fetchurl {
···
     description = "Coroutine safe xpcall and pcall";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-cqueues = buildLuarocksPackage {
+cqueues = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "cqueues";
   version = "20200726.52-0";
   knownRockspec = (fetchurl {
···
     sha256 = "0lhd02ag3r1sxr2hx847rdjkddm04l1vf5234v5cz9bd4kfjw4cy";
   };
 
-  disabled = (lua.luaversion != "5.2");
+  disabled = with lua; (luaversion != "5.2");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vcunat ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-cyrussasl = buildLuarocksPackage {
+cyrussasl = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "cyrussasl";
   version = "1.1.0-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Cyrus SASL library for Lua 5.1+";
     license.fullName = "BSD";
   };
-};
+}) {};
 
-digestif = buildLuarocksPackage {
+digestif = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, lpeg
+}:
+buildLuarocksPackage {
   pname = "digestif";
   version = "dev-1";
 
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
   "url": "https://github.com/astoff/digestif",
-  "rev": "9f8f299cf7094d72edbd32a455869751246028b7",
-  "date": "2021-09-25T14:32:42+02:00",
-  "path": "/nix/store/ln1zx9cw2b7q4x5vzd6hv5nd01c1gsy3-digestif",
-  "sha256": "1cf14m03jvfs1mwaywfgv759jh0ha3pxrnyj7jxjxlsj6cim89v0",
+  "rev": "505ca88a54012be5534654238baaa457f8446fed",
+  "date": "2021-10-06T21:27:45+02:00",
+  "path": "/nix/store/6wvpy0nsr5yf78by3dg8m2m0h0kf9xk4-digestif",
+  "sha256": "1prv5nqskvilyyx3z9b2jiz72lwpz2xcas57qjpbv6qq5l2si1xm",
   "fetchLFS": false,
   "fetchSubmodules": true,
   "deepClone": false,
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.3");
+  disabled = with lua; (luaOlder "5.3");
   propagatedBuildInputs = [ lua lpeg ];
 
   meta = {
···
     description = "A code analyzer for TeX";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-dkjson = buildLuarocksPackage {
+dkjson = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "dkjson";
   version = "2.5-3";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/dkjson-2.5-3.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/dkjson-2.5-3.rockspec";
     sha256 = "18xngdzl2q207cil64aj81qi6qvj1g269pf07j5x4pbvamd6a1l3";
   }).outPath;
   src = fetchurl {
···
     sha256 = "14wanday1l7wj2lnpabbxw8rcsa0zbvcdi1w88rdr5gbsq3xwasm";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "David Kolf's JSON module for Lua";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-fifo = buildLuarocksPackage {
+fifo = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "fifo";
   version = "0.2-0";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/fifo-0.2-0.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/fifo-0.2-0.rockspec";
     sha256 = "0vr9apmai2cyra2n573nr3dyk929gzcs4nm1096jdxcixmvh2ymq";
   }).outPath;
   src = fetchurl {
···
     description = "A lua library/'class' that implements a FIFO";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-gitsigns-nvim = buildLuarocksPackage {
+gitsigns-nvim = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, plenary-nvim
+}:
+buildLuarocksPackage {
   pname = "gitsigns.nvim";
   version = "scm-1";
 
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
   "url": "https://github.com/lewis6991/gitsigns.nvim",
-  "rev": "7e5c1a831f555dc398dd1564489e2b8a5c867754",
-  "date": "2021-09-25T16:49:34+01:00",
-  "path": "/nix/store/a1h8xxb9w4kvvmq7q30m1ny2pq3zbmin-gitsigns.nvim",
-  "sha256": "02kssw0lpprf9k3il6gfd00gj9fbjbksipa4f6xqkgfdq5c9l9fr",
+  "rev": "552f114caeaec4ce97822cb55dfa7c7e5368136b",
+  "date": "2021-10-15T13:31:44+01:00",
+  "path": "/nix/store/40vkv3sc4h6gh9ac88k7pilszxmy38yv-gitsigns.nvim",
+  "sha256": "0qdafm3arjf8bcqpvv085dwzbikad3sr3xzvrn3gfa0dsls8pg6q",
   "fetchLFS": false,
   "fetchSubmodules": true,
   "deepClone": false,
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (lua.luaversion != "5.1");
+  disabled = with lua; (luaversion != "5.1");
   propagatedBuildInputs = [ lua plenary-nvim ];
 
   meta = {
···
     description = "Git signs written in pure lua";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-http = buildLuarocksPackage {
+http = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, compat53, bit32, cqueues, luaossl, basexx, lpeg, lpeg_patterns, binaryheap, fifo
+}:
+buildLuarocksPackage {
   pname = "http";
   version = "0.3-0";
   knownRockspec = (fetchurl {
···
     sha256 = "13xyj8qx42mzn1z4lwwdfd7ha06a720q4b7d04ir6vvp2fwp3s4q";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua compat53 bit32 cqueues luaossl basexx lpeg lpeg_patterns binaryheap fifo ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vcunat ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-inspect = buildLuarocksPackage {
+inspect = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "inspect";
   version = "3.1.1-0";
   knownRockspec = (fetchurl {
···
     sha256 = "1nz0yqhkd0nkymghrj99gb2id40g50drh4a96g3v5k7h1sbg94h2";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua table visualizer, ideal for debugging";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-ldbus = buildLuarocksPackage {
+ldbus = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "ldbus";
   version = "scm-0";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A Lua library to access dbus.";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-ldoc = buildLuarocksPackage {
+ldoc = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, penlight, markdown
+}:
+buildLuarocksPackage {
   pname = "ldoc";
   version = "scm-3";
 
···
     description = "A Lua Documentation Tool";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lgi = buildLuarocksPackage {
+lgi = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lgi";
   version = "0.9.2-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua bindings to GObject libraries";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-linenoise = buildLuarocksPackage {
+linenoise = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "linenoise";
   version = "0.9-1";
 
···
     sha256 = "177h6gbq89arwiwxah9943i8hl5gvd9wivnd1nhmdl7d8x0dn76c";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A binding for the linenoise command line library";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-ljsyscall = buildLuarocksPackage {
+ljsyscall = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "ljsyscall";
   version = "0.12-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1w9g36nhxv92cypjia7igg1xpfrn3dbs3hfy6gnnz5mx14v50abf";
   };
 
-  disabled = (lua.luaversion != "5.1");
+  disabled = with lua; (luaversion != "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ lblasc ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lpeg = buildLuarocksPackage {
+lpeg = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lpeg";
   version = "1.0.2-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/lpeg-1.0.2-1.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/lpeg-1.0.2-1.rockspec";
     sha256 = "08a8p5cwlwpjawk8sczb7bq2whdsng4mmhphahyklf1bkvl2li89";
   }).outPath;
   src = fetchurl {
···
     sha256 = "1zjzl7acvcdavmcg5l7wi12jd4rh95q9pl5aiww7hv0v0mv6bmj8";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vyp ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lpeg_patterns = buildLuarocksPackage {
+lpeg_patterns = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, lpeg
+}:
+buildLuarocksPackage {
   pname = "lpeg_patterns";
   version = "0.5-0";
   knownRockspec = (fetchurl {
···
     description = "a collection of LPEG patterns";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lpeglabel = buildLuarocksPackage {
+lpeglabel = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lpeglabel";
   version = "1.6.0-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1i02lsxj20iygqm8fy6dih1gh21lqk5qj1mv14wlrkaywnv35wcv";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Parsing Expression Grammars For Lua with Labeled Failures";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lpty = buildLuarocksPackage {
+lpty = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lpty";
   version = "1.2.2-1";
   knownRockspec = (fetchurl {
-    url    = "https://luafr.org/luarocks/lpty-1.2.2-1.rockspec";
+    url    = "https://luarocks.org/lpty-1.2.2-1.rockspec";
     sha256 = "04af4mhiqrw3br4qzz7yznw9zy2m50wddwzgvzkvhd99ng71fkzg";
   }).outPath;
   src = fetchurl {
···
     sha256 = "071mvz79wi9vr6hvrnb1rv19lqp1bh2fi742zkpv2sm1r9gy5rav";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A simple facility for lua to control other programs via PTYs.";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lrexlib-gnu = buildLuarocksPackage {
+lrexlib-gnu = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lrexlib-gnu";
   version = "2.9.1-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Regular expression library binding (GNU flavour).";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lrexlib-pcre = buildLuarocksPackage {
+lrexlib-pcre = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lrexlib-pcre";
   version = "2.9.1-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vyp ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lrexlib-posix = buildLuarocksPackage {
+lrexlib-posix = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lrexlib-posix";
   version = "2.9.1-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Regular expression library binding (POSIX flavour).";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lua-cjson = buildLuarocksPackage {
+lua-cjson = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-cjson";
   version = "2.1.0.6-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A fast JSON encoding/parsing module";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lua-cmsgpack = buildLuarocksPackage {
+lua-cmsgpack = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-cmsgpack";
   version = "0.4.0-0";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "MessagePack C implementation and bindings for Lua 5.1/5.2/5.3";
     license.fullName = "Two-clause BSD";
   };
-};
+}) {};
 
-lua-iconv = buildLuarocksPackage {
+lua-iconv = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lua-iconv";
   version = "7-3";
   knownRockspec = (fetchurl {
···
     sha256 = "02dg5x79fg5mwsycr0fj6w04zykdpiki9xjswkkwzdalqwaikny1";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua binding to the iconv";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lua-lsp = buildLuarocksPackage {
+lua-lsp = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, dkjson, lpeglabel, inspect
+}:
+buildLuarocksPackage {
   pname = "lua-lsp";
   version = "0.1.0-2";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua dkjson lpeglabel inspect ];
 
   meta = {
···
     description = "A Language Server implementation for lua, the language";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lua-messagepack = buildLuarocksPackage {
+lua-messagepack = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lua-messagepack";
   version = "0.5.2-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1jgi944d0vx4zs9lrphys9pw0wrsibip93sh141qjwymrjyjg1nc";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "a pure Lua implementation of the MessagePack serialization format";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lua-resty-http = buildLuarocksPackage {
+lua-resty-http = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-resty-http";
   version = "0.16.1-0";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua HTTP client cosocket driver for OpenResty / ngx_lua.";
     license.fullName = "2-clause BSD";
   };
-};
+}) {};
 
-lua-resty-jwt = buildLuarocksPackage {
+lua-resty-jwt = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, lua-resty-openssl
+}:
+buildLuarocksPackage {
   pname = "lua-resty-jwt";
   version = "0.2.3-0";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua lua-resty-openssl ];
 
   meta = {
···
     description = "JWT for ngx_lua and LuaJIT.";
     license.fullName = "Apache License Version 2";
   };
-};
+}) {};
 
-lua-resty-openidc = buildLuarocksPackage {
+lua-resty-openidc = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, lua-resty-http, lua-resty-session, lua-resty-jwt
+}:
+buildLuarocksPackage {
   pname = "lua-resty-openidc";
   version = "1.7.4-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua lua-resty-http lua-resty-session lua-resty-jwt ];
 
   meta = {
···
     description = "A library for NGINX implementing the OpenID Connect Relying Party (RP) and the OAuth 2.0 Resource Server (RS) functionality";
     license.fullName = "Apache 2.0";
   };
-};
+}) {};
 
-lua-resty-openssl = buildLuarocksPackage {
+lua-resty-openssl = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit}:
+buildLuarocksPackage {
   pname = "lua-resty-openssl";
   version = "0.7.5-1";
   knownRockspec = (fetchurl {
-    url    = "https://luafr.org/luarocks/lua-resty-openssl-0.7.5-1.rockspec";
+    url    = "https://luarocks.org/lua-resty-openssl-0.7.5-1.rockspec";
     sha256 = "13v14in9cgmjgarmy6br9629ns1qlhw7a30c061y6gncjannnv6y";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
     description = "No summary";
     license.fullName = "BSD";
   };
-};
+}) {};
 
-lua-resty-session = buildLuarocksPackage {
+lua-resty-session = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-resty-session";
   version = "3.8-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Session Library for OpenResty – Flexible and Secure";
     license.fullName = "BSD";
   };
-};
+}) {};
 
-lua-term = buildLuarocksPackage {
+lua-term = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl}:
+buildLuarocksPackage {
   pname = "lua-term";
   version = "0.7-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/lua-term-0.7-1.rockspec";
+    url    = "https://luafr.org/luarocks/lua-term-0.7-1.rockspec";
     sha256 = "0r9g5jw7pqr1dyj6w58dqlr7y7l0jp077n8nnji4phf10biyrvg2";
   }).outPath;
   src = fetchurl {
···
     description = "Terminal functions for Lua";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lua-toml = buildLuarocksPackage {
+lua-toml = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-toml";
   version = "2.0-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "toml decoder/encoder for Lua";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lua-yajl = buildLuarocksPackage {
+lua-yajl = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-yajl";
   version = "2.0-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/lua-yajl-2.0-1.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/lua-yajl-2.0-1.rockspec";
     sha256 = "0h600zgq5qc9z3cid1kr35q3qb98alg0m3qf0a3mfj33hya6pcxp";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ pstn ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lua-zlib = buildLuarocksPackage {
+lua-zlib = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "lua-zlib";
   version = "1.2-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ koral ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-lua_cliargs = buildLuarocksPackage {
+lua_cliargs = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lua_cliargs";
   version = "3.0-2";
 
···
     sha256 = "0vhpgmy9a8wlxp8a15pnfqfk0aj7pyyb5m41nnfxynx580a6y7cp";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A command-line argument parser.";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-luabitop = buildLuarocksPackage {
+luabitop = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luabitop";
   version = "1.0.2-3";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.3");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.3");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua Bit Operations Module";
     license.fullName = "MIT/X license";
   };
-};
+}) {};
 
-luacheck = buildLuarocksPackage {
+luacheck = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, argparse, luafilesystem
+}:
+buildLuarocksPackage {
   pname = "luacheck";
-  version = "0.24.0-2";
+  version = "0.25.0-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/luacheck-0.24.0-2.rockspec";
-    sha256 = "1x8n7w1mdr1bmmbw38syzi2612yyd7bbv4j2hnlk2k76qfcvkhf3";
+    url    = "https://luarocks.org/luacheck-0.25.0-1.rockspec";
+    sha256 = "11mvbpnykibg0dx9sdh5x9gpvrhkmvrw76qvjz337x83f8gmvy91";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
   "url": "https://github.com/luarocks/luacheck.git",
-  "rev": "6651c20d8495c380a49ca81662fcfd1ade6b2411",
-  "date": "2020-08-20T19:21:52-03:00",
-  "path": "/nix/store/8r4x8snxp0kjabn9bsxwh62pfczd8wma-luacheck",
-  "sha256": "08jsqibksdvpl6mvf8d6rlh5pii78hqm3fkhbkgzrs6k8kk5a7lf",
+  "rev": "abf7386a892df4ce566fef9e4640ddbf9af78411",
+  "date": "2021-08-10T12:19:20-03:00",
+  "path": "/nix/store/9cdlf6c3y0087qwh48ky8ysxxx3lirlj-luacheck",
+  "sha256": "1ymfkr0qmg6idrrxf9x6mfq14skag8h09kl2qlalwiykicrdljs1",
   "fetchLFS": false,
   "fetchSubmodules": true,
   "deepClone": false,
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua argparse luafilesystem ];
 
   meta = {
···
     description = "A static analyzer and a linter for Lua";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luacov = buildLuarocksPackage {
+luacov = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luacov";
   version = "0.15.0-1";
   knownRockspec = (fetchurl {
-    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luacov-0.15.0-1.rockspec";
+    url    = "https://luafr.org/luarocks/luacov-0.15.0-1.rockspec";
     sha256 = "18byfl23c73pazi60hsx0vd74hqq80mzixab76j36cyn8k4ni9db";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Coverage analysis tool for Lua scripts";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luadbi = buildLuarocksPackage {
+luadbi = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luadbi";
   version = "0.7.2-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Database abstraction layer";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luadbi-mysql = buildLuarocksPackage {
+luadbi-mysql = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luadbi
+}:
+buildLuarocksPackage {
   pname = "luadbi-mysql";
   version = "0.7.2-1";
   knownRockspec = (fetchurl {
-    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luadbi-mysql-0.7.2-1.rockspec";
+    url    = "https://luarocks.org/luadbi-mysql-0.7.2-1.rockspec";
     sha256 = "0gnyqnvcfif06rzzrdw6w6hchp4jrjiwm0rmfx2r8ljchj2bvml5";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua luadbi ];
 
   meta = {
···
     description = "Database abstraction layer";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luadbi-postgresql = buildLuarocksPackage {
+luadbi-postgresql = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luadbi
+}:
+buildLuarocksPackage {
   pname = "luadbi-postgresql";
   version = "0.7.2-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/luadbi-postgresql-0.7.2-1.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luadbi-postgresql-0.7.2-1.rockspec";
     sha256 = "07rx4agw4hjyzf8157apdwfqh9s26nqndmkr3wm7v09ygjvdjiix";
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua luadbi ];
 
   meta = {
···
     description = "Database abstraction layer";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luadbi-sqlite3 = buildLuarocksPackage {
+luadbi-sqlite3 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luadbi
+}:
+buildLuarocksPackage {
   pname = "luadbi-sqlite3";
   version = "0.7.2-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua luadbi ];
 
   meta = {
···
     description = "Database abstraction layer";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luaepnf = buildLuarocksPackage {
+luaepnf = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, lpeg
+}:
+buildLuarocksPackage {
   pname = "luaepnf";
   version = "0.3-2";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua lpeg ];
 
   meta = {
···
     description = "Extended PEG Notation Format (easy grammars for LPeg)";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luaevent = buildLuarocksPackage {
+luaevent = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luaevent";
   version = "0.4.6-1";
   knownRockspec = (fetchurl {
···
     sha256 = "0pbh315d3p7hxgzmbhphkcldxv2dadbka96131b8j5914nxvl4nx";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "libevent binding for Lua";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luaexpat = buildLuarocksPackage {
+luaexpat = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luaexpat";
   version = "1.3.0-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1hvxqngn0wf5642i5p3vcyhg3pmp102k63s9ry4jqyyqc1wkjq6h";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ arobyn flosse ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luaffi = buildLuarocksPackage {
+luaffi = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luaffi";
   version = "scm-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "FFI library for calling C functions from lua";
     license.fullName = "BSD";
   };
-};
+}) {};
 
-luafilesystem = buildLuarocksPackage {
+luafilesystem = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luafilesystem";
   version = "1.7.0-2";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ flosse ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-lualogging = buildLuarocksPackage {
+lualogging = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, luasocket
+}:
+buildLuarocksPackage {
   pname = "lualogging";
   version = "1.5.2-1";
   knownRockspec = (fetchurl {
···
     description = "A simple API to use logging features";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luaossl = buildLuarocksPackage {
+luaossl = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luaossl";
   version = "20200709-0";
   knownRockspec = (fetchurl {
···
     description = "Most comprehensive OpenSSL module in the Lua universe.";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luaposix = buildLuarocksPackage {
+luaposix = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, bit32, lua
+}:
+buildLuarocksPackage {
   pname = "luaposix";
   version = "34.1.1-1";
   knownRockspec = (fetchurl {
···
     sha256 = "1xqx764ji054jphxdhkynsmwzqzkfgxqfizxkf70za6qfrvnl3yh";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ bit32 lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vyp lblasc ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luarepl = buildLuarocksPackage {
+luarepl = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luarepl";
   version = "0.9-1";
   knownRockspec = (fetchurl {
···
     sha256 = "04xka7b84d9mrz3gyf8ywhw08xp65v8jrnzs8ry8k9540aqs721w";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A reusable REPL component for Lua, written in Lua";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luasec = buildLuarocksPackage {
+luasec = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luasocket
+}:
+buildLuarocksPackage {
   pname = "luasec";
   version = "1.0.2-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua luasocket ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ flosse ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luasocket = buildLuarocksPackage {
+luasocket = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luasocket";
   version = "3.0rc1-2";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/luasocket-3.0rc1-2.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luasocket-3.0rc1-2.rockspec";
     sha256 = "17fbkihp4zypv5wwgxz8dnghj37pf5bhpi2llg4gbljp1bl2f42c";
   }).outPath;
   src = fetchurl {
···
     sha256 = "0x0fg07cg08ybgkpzif7zmzaaq5ga979rxwd9rj95kfws9bbrl0y";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Network support for the Lua language";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luasql-sqlite3 = buildLuarocksPackage {
+luasql-sqlite3 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luasql-sqlite3";
   version = "2.6.0-1";
   knownRockspec = (fetchurl {
···
   }).outPath;
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
   "url": "https://github.com/keplerproject/luasql.git",
-  "rev": "69f68a858134d6adbe9b65a902dcd3f60cd6a7ce",
-  "date": "2021-08-27T15:17:22-03:00",
-  "path": "/nix/store/2374agarn72cnlnk2vripfy1zz2y50la-luasql",
-  "sha256": "13xs1g67d2p69x4wzxk1h97xh25388h0kkh9bjgw3l1yss9zlxhx",
+  "rev": "ce22164f63783afac9c644fd37c231e56fc097cb",
+  "date": "2021-10-14T09:38:24-03:00",
+  "path": "/nix/store/h8r8axcc76x7y6gwc2jzsmr7h2lqgbxa-luasql",
+  "sha256": "10gq3x7vqkafvfk9fs4039rl1xhnqpl2v60z4qpd96wbcy205gnk",
   "fetchLFS": false,
   "fetchSubmodules": true,
   "deepClone": false,
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vyp ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-luassert = buildLuarocksPackage {
+luassert = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, say
+}:
+buildLuarocksPackage {
   pname = "luassert";
   version = "1.8.0-0";
   knownRockspec = (fetchurl {
···
     sha256 = "0xlwlb32215524bg33svp1ci8mdvh9wykchl8dkhihpxcd526mar";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua say ];
 
   meta = {
···
     description = "Lua Assertions Extension";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-luasystem = buildLuarocksPackage {
+luasystem = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luasystem";
   version = "0.2.1-0";
   knownRockspec = (fetchurl {
···
     sha256 = "150bbklchh02gsvpngv56xrrlxxvwpqwrh0yy6z95fnvks7gd0qb";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Platform independent system calls for Lua.";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-luautf8 = buildLuarocksPackage {
+luautf8 = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luautf8";
   version = "0.1.3-1";
   knownRockspec = (fetchurl {
···
     sha256 = "02rf8jmazmi8rp3i5v4jsz0d7mrf1747qszsl8i2hv1sl0ik92r0";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ pstn ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luazip = buildLuarocksPackage {
+luazip = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "luazip";
   version = "1.2.7-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Library for reading files inside zip files";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-luuid = buildLuarocksPackage {
+luuid = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luuid";
   version = "20120509-2";
   knownRockspec = (fetchurl {
···
     sha256 = "1bfkj613d05yps3fivmz0j1bxf2zkg9g1yl0ifffgw0vy00hpnvm";
   };
 
-  disabled = (luaOlder "5.2") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.2") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "A library for UUID generation";
     license.fullName = "Public domain";
   };
-};
+}) {};
 
-luv = buildLuarocksPackage {
+luv = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "luv";
   version = "1.42.0-0";
   knownRockspec = (fetchurl {
···
     sha256 = "0dkzjkkm0h516ag6sfz5iji761y9slrcfw325f39zkda1sfql8mm";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Bare libuv bindings for lua";
     license.fullName = "Apache 2.0";
   };
-};
+}) {};
 
-lyaml = buildLuarocksPackage {
+lyaml = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "lyaml";
   version = "6.2.7-1";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/lyaml-6.2.7-1.rockspec";
+    url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/lyaml-6.2.7-1.rockspec";
     sha256 = "0m5bnzg24nyk35gcn4rydgzk0ysk1f6rslxwxd0w3drl1bg64zja";
   }).outPath;
   src = fetchurl {
···
     sha256 = "165mr3krf8g8070j4ax9z0j2plfbdwb8x2zk2hydpqaqa0kcdb0c";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ lblasc ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-markdown = buildLuarocksPackage {
+markdown = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "markdown";
   version = "0.33-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Markdown text-to-html markup system.";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-mediator_lua = buildLuarocksPackage {
+mediator_lua = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "mediator_lua";
   version = "1.1.2-0";
   knownRockspec = (fetchurl {
···
     sha256 = "16zzzhiy3y35v8advmlkzpryzxv5vji7727vwkly86q8sagqbxgs";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Event handling through channels";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-moonscript = buildLuarocksPackage {
+moonscript = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, lpeg, alt-getopt, luafilesystem
+}:
+buildLuarocksPackage {
   pname = "moonscript";
   version = "0.5.0-1";
   knownRockspec = (fetchurl {
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua lpeg alt-getopt luafilesystem ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ arobyn ];
     license.fullName = "MIT";
   };
-};
+}) {};
 
-mpack = buildLuarocksPackage {
+mpack = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl}:
+buildLuarocksPackage {
   pname = "mpack";
-  version = "1.0.8-0";
+  version = "1.0.9-0";
   knownRockspec = (fetchurl {
-    url    = "https://luarocks.org/mpack-1.0.8-0.rockspec";
-    sha256 = "0hhpamw2bydnfrild274faaan6v48918nhslnw3kvi9y36b4i5ha";
+    url    = "https://luarocks.org/mpack-1.0.9-0.rockspec";
+    sha256 = "1v10kmw3qw559bbm142z40ib26bwvcyi64qjrk0vf8v6n1mx8wcn";
   }).outPath;
   src = fetchurl {
-    url    = "https://github.com/libmpack/libmpack-lua/releases/download/1.0.8/libmpack-lua-1.0.8.tar.gz";
-    sha256 = "1sf93ffx7a3y1waknc4994l2yrxilrlf3hcp2cj2cvxmpm5inszd";
+    url    = "https://github.com/libmpack/libmpack-lua/releases/download/1.0.9/libmpack-lua-1.0.9.tar.gz";
+    sha256 = "17lyjmnbychacwahqgs128nb00xky777g7zw5wf20vrzkiq7xl0g";
   };
 
 
   meta = {
-    homepage = "https://github.com/libmpack/libmpack-lua/releases/download/1.0.8/libmpack-lua-1.0.8.tar.gz";
+    homepage = "https://github.com/libmpack/libmpack-lua";
     description = "Lua binding to libmpack";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-nvim-client = buildLuarocksPackage {
+nvim-client = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, mpack, luv, coxpcall
+}:
+buildLuarocksPackage {
   pname = "nvim-client";
   version = "0.2.2-1";
 
···
     sha256 = "1h736im524lq0vwlpihv9b317jarpkf3j13a25xl5qq8y8asm8mr";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua mpack luv coxpcall ];
 
   meta = {
···
     description = "Lua client to Nvim";
     license.fullName = "Apache";
   };
-};
+}) {};
 
-penlight = buildLuarocksPackage {
+penlight = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luafilesystem
+}:
+buildLuarocksPackage {
   pname = "penlight";
   version = "dev-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua luafilesystem ];
-  checkInputs = [ busted busted ];
-  doCheck = false;
 
   meta = {
     homepage = "https://lunarmodules.github.io/penlight";
···
     maintainers = with lib.maintainers; [ alerque ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-plenary-nvim = buildLuarocksPackage {
+plenary-nvim = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, luassert
+}:
+buildLuarocksPackage {
   pname = "plenary.nvim";
   version = "scm-1";
 
   src = fetchgit ( removeAttrs (builtins.fromJSON ''{
   "url": "https://github.com/nvim-lua/plenary.nvim",
-  "rev": "8c6cc07a68b65eb707be44598f0084647d495978",
-  "date": "2021-09-26T16:13:25+02:00",
-  "path": "/nix/store/j8hmr48blm4brq8rqv7b9m08vmalg8sp-plenary.nvim",
-  "sha256": "05h5n7jj33y9vs6gc8hqlfd628j6i33s3c8fmfl6ahxwfygx2wpd",
+  "rev": "80bb2b9bb74bdca38a46480b6f2e15af990406e4",
+  "date": "2021-10-06T19:20:08+02:00",
+  "path": "/nix/store/mw4r562qxr7giy1n43iylp3qb8ch0jqs-plenary.nvim",
+  "sha256": "11akcpxcp4m997a2y76ajknnmsifac2hj4nq9i4a8b1j08bxinim",
   "fetchLFS": false,
   "fetchSubmodules": true,
   "deepClone": false,
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ lua luassert ];
 
   meta = {
···
     description = "lua functions you don't want to write ";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-rapidjson = buildLuarocksPackage {
+rapidjson = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "rapidjson";
   version = "0.7.1-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Json module based on the very fast RapidJSON.";
     license.fullName = "MIT";
   };
-};
+}) {};
 
-readline = buildLuarocksPackage {
+readline = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua, luaposix
+}:
+buildLuarocksPackage {
   pname = "readline";
   version = "3.0-0";
   knownRockspec = (fetchurl {
···
     sha256 = "1rr2b7q8w3i4bm1i634sd6kzhw6v1fpnh53mj09af6xdq1rfhr5n";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua luaposix ];
 
   meta = {
···
     description = "Interface to the readline library";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-say = buildLuarocksPackage {
+say = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "say";
   version = "1.3-1";
 
···
     sha256 = "1jh76mxq9dcmv7kps2spwcc6895jmj2sf04i4y9idaxlicvwvs13";
   };
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Lua String Hashing/Indexing Library";
     license.fullName = "MIT <http://opensource.org/licenses/MIT>";
   };
-};
+}) {};
 
-std-_debug = buildLuarocksPackage {
+std-_debug = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "std._debug";
   version = "git-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     description = "Debug Hints Library";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-std-normalize = buildLuarocksPackage {
+std-normalize = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua, std-_debug
+}:
+buildLuarocksPackage {
   pname = "std.normalize";
   version = "git-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua std-_debug ];
 
   meta = {
···
     description = "Normalized Lua Functions";
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-stdlib = buildLuarocksPackage {
+stdlib = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchurl, lua
+}:
+buildLuarocksPackage {
   pname = "stdlib";
   version = "41.2.2-1";
   knownRockspec = (fetchurl {
···
     sha256 = "0is8i8lk4qq4afnan0vj1bwr8brialyrva7cjy43alzgwdphwynx";
   };
 
-  disabled = (luaOlder "5.1") || (luaAtLeast "5.5");
+  disabled = with lua; (luaOlder "5.1") || (luaAtLeast "5.5");
   propagatedBuildInputs = [ lua ];
 
   meta = {
···
     maintainers = with lib.maintainers; [ vyp ];
     license.fullName = "MIT/X11";
   };
-};
+}) {};
 
-vstruct = buildLuarocksPackage {
+vstruct = callPackage({ buildLuarocksPackage, luaOlder, luaAtLeast
+, fetchgit, lua
+}:
+buildLuarocksPackage {
   pname = "vstruct";
   version = "2.1.1-1";
 
···
 }
  '') ["date" "path"]) ;
 
-  disabled = (luaOlder "5.1");
+  disabled = with lua; (luaOlder "5.1");
   propagatedBuildInputs = [ lua ];
 
   meta = {
     homepage = "https://github.com/ToxicFrog/vstruct";
     description = "Lua library to manipulate binary data";
   };
-};
+}) {};
 
 
 }

pkgs/development/lua-modules/lib.nix

···
   in unique ([lua] ++ modules ++ concatLists (catAttrs "requiredLuaModules" modules));
   # Check whether a derivation provides a lua module.
   hasLuaModule = drv: drv ? luaModule;
+
+
+  /*
+  Use this to override the arguments passed to buildLuarocksPackage
+  */
+  overrideLuarocks = drv: f: (drv.override (args: args // {
+    buildLuarocksPackage = drv: (args.buildLuarocksPackage drv).override f;
+  })) // {
+    overrideScope = scope: overrideLuarocks (drv.overrideScope scope) f;
+  };
+
 in
 rec {
+  inherit overrideLuarocks;
   inherit hasLuaModule requiredLuaModules;
 
   luaPathList = [

pkgs/development/lua-modules/overrides.nix

···
-{ pkgs,  ... }:
-self: super:
-with super;
+{ pkgs }:
+final: prev:
+with prev;
 {
   ##########################################3
   #### manual fixes for generated packages
   ##########################################3
-  bit32 = super.bit32.override({
+  bit32 = prev.bit32.overrideAttrs(oa: {
     # Small patch in order to no longer redefine a Lua 5.2 function that Luajit
     # 2.1 also provides, see https://github.com/LuaJIT/LuaJIT/issues/325 for
     # more
···
     ];
   });
 
-  busted = super.busted.override({
+  busted = prev.busted.overrideAttrs(oa: {
     postConfigure = ''
       substituteInPlace ''${rockspecFilename} \
         --replace "'lua_cliargs = 3.0-1'," "'lua_cliargs >= 3.0-1',"
···
     '';
   });
 
-  cqueues = super.cqueues.override(rec {
-    # Parse out a version number without the Lua version inserted
-    version = with pkgs.lib; let
-      version' = super.cqueues.version;
-      rel = splitVersion version';
-      date = head rel;
-      rev = last (splitString "-" (last rel));
-    in "${date}-${rev}";
+  cqueues = (prev.lib.overrideLuarocks prev.cqueues (drv: {
     nativeBuildInputs = [
       pkgs.gnum4
     ];
···
       { name = "OPENSSL"; dep = pkgs.openssl; }
     ];
     disabled = luaOlder "5.1" || luaAtLeast "5.4";
+  })).overrideAttrs(oa: rec {
+    # Parse out a version number without the Lua version inserted
+    version = with pkgs.lib; let
+      version' = prev.cqueues.version;
+      rel = splitVersion version';
+      date = head rel;
+      rev = last (splitString "-" (last rel));
+    in "${date}-${rev}";
     # Upstream rockspec is pointlessly broken into separate rockspecs, per Lua
     # version, which doesn't work well for us, so modify it
-    postConfigure = let inherit (super.cqueues) pname; in ''
+    postConfigure = let inherit (prev.cqueues) pname; in ''
       # 'all' target auto-detects correct Lua version, which is fine for us as
       # we only have the right one available :)
       sed -Ei ''${rockspecFilename} \
···
     '';
   });
 
-  cyrussasl = super.cyrussasl.override({
+  cyrussasl = prev.lib.overrideLuarocks prev.cyrussasl (drv: {
     externalDeps = [
       { name = "LIBSASL"; dep = pkgs.cyrus_sasl; }
     ];
   });
 
-  http = super.http.override({
+  http = prev.http.overrideAttrs(oa: {
     patches = [
       (pkgs.fetchpatch {
         name = "invalid-state-progression.patch";
···
     */
   });
 
-  ldbus = super.ldbus.override({
+  ldbus = prev.lib.overrideLuarocks prev.ldbus (drv: {
     extraVariables = {
       DBUS_DIR="${pkgs.dbus.lib}";
       DBUS_ARCH_INCDIR="${pkgs.dbus.lib}/lib/dbus-1.0/include";
···
     ];
   });
 
-  ljsyscall = super.ljsyscall.override(rec {
+  ljsyscall = prev.ljsyscall.overrideAttrs(oa: rec {
     version = "unstable-20180515";
     # package hasn't seen any release for a long time
     src = pkgs.fetchFromGitHub {
···
     propagatedBuildInputs = with pkgs.lib; optional (!isLuaJIT) luaffi;
   });
 
-  lgi = super.lgi.override({
+  lgi = prev.lib.overrideLuarocks prev.lgi (drv: {
     nativeBuildInputs = [
       pkgs.pkg-config
     ];
···
     '';
   });
 
-  lrexlib-gnu = super.lrexlib-gnu.override({
+  lrexlib-gnu = prev.lib.overrideLuarocks prev.lrexlib-gnu (drv: {
     buildInputs = [
       pkgs.gnulib
     ];
   });
 
-  lrexlib-pcre = super.lrexlib-pcre.override({
+  lrexlib-pcre = prev.lib.overrideLuarocks prev.lrexlib-pcre (drv: {
     externalDeps = [
       { name = "PCRE"; dep = pkgs.pcre; }
     ];
   });
 
-  lrexlib-posix = super.lrexlib-posix.override({
+  lrexlib-posix = prev.lib.overrideLuarocks prev.lrexlib-posix (drv: {
     buildInputs = [
       pkgs.glibc.dev
     ];
   });
 
-  lua-iconv = super.lua-iconv.override({
+  lua-iconv = prev.lib.overrideLuarocks prev.lua-iconv (drv: {
     buildInputs = [
       pkgs.libiconv
     ];
   });
 
-  lua-lsp = super.lua-lsp.override({
+  lua-lsp = prev.lua-lsp.overrideAttrs(oa: {
     # until Alloyed/lua-lsp#28
     postConfigure = ''
       substituteInPlace ''${rockspecFilename} \
···
     '';
   });
 
-  lua-zlib = super.lua-zlib.override({
+  lua-zlib = prev.lib.overrideLuarocks prev.lua-zlib (drv: {
     buildInputs = [
       pkgs.zlib.dev
     ];
     disabled = luaOlder "5.1" || luaAtLeast "5.4";
   });
 
-  luadbi-mysql = super.luadbi-mysql.override({
+  luadbi-mysql = prev.lib.overrideLuarocks prev.luadbi-mysql (drv: {
     extraVariables = {
       # Can't just be /include and /lib, unfortunately needs the trailing 'mysql'
       MYSQL_INCDIR="${pkgs.libmysqlclient.dev}/include/mysql";
···
     ];
   });
 
-  luadbi-postgresql = super.luadbi-postgresql.override({
+  luadbi-postgresql = prev.lib.overrideLuarocks prev.luadbi-postgresql (drv: {
     buildInputs = [
       pkgs.postgresql
     ];
   });
 
-  luadbi-sqlite3 = super.luadbi-sqlite3.override({
+  luadbi-sqlite3 = prev.lib.overrideLuarocks prev.luadbi-sqlite3 (drv: {
     externalDeps = [
       { name = "SQLITE"; dep = pkgs.sqlite; }
     ];
   });
 
-  luaevent = super.luaevent.override({
+  luaevent = prev.lib.overrideLuarocks prev.luaevent (drv: {
     propagatedBuildInputs = [
       luasocket
     ];
···
     disabled = luaOlder "5.1" || luaAtLeast "5.4";
   });
 
-  luaexpat = super.luaexpat.override({
+  luaexpat = prev.lib.overrideLuarocks prev.luaexpat (drv: {
     externalDeps = [
       { name = "EXPAT"; dep = pkgs.expat; }
     ];
···
 
   # TODO Somehow automatically amend buildInputs for things that need luaffi
   # but are in luajitPackages?
-  luaffi = super.luaffi.override({
+  luaffi = prev.lib.overrideLuarocks prev.luaffi (drv: {
     # The packaged .src.rock version is pretty old, and doesn't work with Lua 5.3
     src = pkgs.fetchFromGitHub {
       owner = "facebook"; repo = "luaffifb";
       rev = "532c757e51c86f546a85730b71c9fef15ffa633d";
       sha256 = "1nwx6sh56zfq99rcs7sph0296jf6a9z72mxknn0ysw9fd7m1r8ig";
     };
-    knownRockspec = with super.luaffi; "${pname}-${version}.rockspec";
+    knownRockspec = with prev.luaffi; "${pname}-${version}.rockspec";
     disabled = luaOlder "5.1" || luaAtLeast "5.4" || isLuaJIT;
   });
 
-  luaossl = super.luaossl.override({
+  luaossl = prev.lib.overrideLuarocks prev.luaossl (drv: {
     externalDeps = [
       { name = "CRYPTO"; dep = pkgs.openssl; }
       { name = "OPENSSL"; dep = pkgs.openssl; }
     ];
   });
 
-  luasec = super.luasec.override({
+  luasec = prev.lib.overrideLuarocks prev.luasec (drv: {
     externalDeps = [
       { name = "OPENSSL"; dep = pkgs.openssl; }
     ];
   });
 
-  luasql-sqlite3 = super.luasql-sqlite3.override({
+  luasql-sqlite3 = prev.lib.overrideLuarocks prev.luasql-sqlite3 (drv: {
     externalDeps = [
       { name = "SQLITE"; dep = pkgs.sqlite; }
     ];
   });
 
-  luasystem = super.luasystem.override({
-    buildInputs = pkgs.lib.optionals pkgs.stdenv.isLinux [
-      pkgs.glibc
-    ];
-  });
+  luasystem = prev.lib.overrideLuarocks prev.luasystem (drv: { buildInputs = [ pkgs.glibc.out ]; });
 
-  luazip = super.luazip.override({
+  luazip = prev.lib.overrideLuarocks prev.luazip (drv: {
     buildInputs = [
       pkgs.zziplib
     ];
   });
 
-  lua-yajl = super.lua-yajl.override({
+  lua-yajl = prev.lib.overrideLuarocks prev.lua-yajl (drv: {
     buildInputs = [
       pkgs.yajl
     ];
   });
 
-  luuid = super.luuid.override(old: {
+  luuid = (prev.lib.overrideLuarocks prev.luuid (drv: {
     externalDeps = [
       { name = "LIBUUID"; dep = pkgs.libuuid; }
     ];
-    meta = old.meta // {
+    disabled = luaOlder "5.1" || (luaAtLeast "5.4");
+  })).overrideAttrs(oa: {
+    meta = oa.meta // {
       platforms = pkgs.lib.platforms.linux;
     };
     # Trivial patch to make it work in both 5.1 and 5.2.  Basically just the
···
     patches = [
       ./luuid.patch
     ];
-    postConfigure = let inherit (super.luuid) version pname; in ''
+    postConfigure = let inherit (prev.luuid) version pname; in ''
       sed -Ei ''${rockspecFilename} -e 's|lua >= 5.2|lua >= 5.1,|'
     '';
-    disabled = luaOlder "5.1" || (luaAtLeast "5.4");
   });
 
-  luv = super.luv.override({
+  luv = prev.lib.overrideLuarocks prev.luv (drv: {
     # Use system libuv instead of building local and statically linking
     # This is a hacky way to specify -DWITH_SHARED_LIBUV=ON which
     # is not possible with luarocks and the current luv rockspec
···
     buildInputs = [ pkgs.libuv ];
 
     passthru = {
-      libluv = self.luv.override ({
-        preBuild = self.luv.preBuild + ''
+      libluv = final.luv.overrideAttrs (oa: {
+        preBuild = final.luv.preBuild + ''
           sed -i 's,\(option(BUILD_MODULE.*\)ON,\1OFF,' CMakeLists.txt
           sed -i 's,\(option(BUILD_SHARED_LIBS.*\)OFF,\1ON,' CMakeLists.txt
           sed -i 's,${"\${.*INSTALL_INC_DIR}"},${placeholder "out"}/include/luv,' CMakeLists.txt
···
     };
   });
 
-  lyaml = super.lyaml.override({
+  lyaml = prev.lib.overrideLuarocks prev.lyaml (oa: {
     buildInputs = [
       pkgs.libyaml
     ];
   });
 
-  mpack = super.mpack.override({
+  mpack = prev.lib.overrideLuarocks prev.mpack (drv: {
     buildInputs = [ pkgs.libmpack ];
     # the rockspec doesn't use the makefile so you may need to export more flags
     USE_SYSTEM_LUA = "yes";
     USE_SYSTEM_MPACK = "yes";
   });
 
-  rapidjson = super.rapidjson.override({
+  rapidjson = prev.rapidjson.overrideAttrs(oa: {
     preBuild = ''
       sed -i '/set(CMAKE_CXX_FLAGS/d' CMakeLists.txt
       sed -i '/set(CMAKE_C_FLAGS/d' CMakeLists.txt
     '';
   });
 
-  readline = (super.readline.override ({
+  readline = (prev.lib.overrideLuarocks prev.readline (drv: {
     unpackCmd = ''
       unzip "$curSrc"
       tar xf *.tar.gz
     '';
-    propagatedBuildInputs = super.readline.propagatedBuildInputs ++ [ pkgs.readline ];
+    propagatedBuildInputs = prev.readline.propagatedBuildInputs ++ [ pkgs.readline.out ];
     extraVariables = rec {
       READLINE_INCDIR = "${pkgs.readline.dev}/include";
       HISTORY_INCDIR = READLINE_INCDIR;
···
     '';
   });
 
-  std-_debug = super.std-_debug.overrideAttrs(oa: {
+  std-_debug = prev.std-_debug.overrideAttrs(oa: {
     # run make to generate lib/std/_debug/version.lua
     preConfigure = ''
       make all
     '';
   });
 
-  std-normalize = super.std-normalize.overrideAttrs(oa: {
+  std-normalize = prev.std-normalize.overrideAttrs(oa: {
     # run make to generate lib/std/_debug/version.lua
     preConfigure = ''
       make all
···
 
   # TODO just while testing, remove afterwards
   # toVimPlugin should do it instead
-  gitsigns-nvim = super.gitsigns-nvim.overrideAttrs(oa: {
+  gitsigns-nvim = prev.gitsigns-nvim.overrideAttrs(oa: {
     nativeBuildInputs = oa.nativeBuildInputs or [] ++ [ pkgs.vimUtils.vimGenDocHook ];
   });
 
   # aliases
-  cjson = super.lua-cjson;
+  cjson = prev.lua-cjson;
 }

pkgs/development/ocaml-modules/yaml/default.nix

···
 { lib, fetchurl, buildDunePackage
 , dune-configurator
-, ppx_sexp_conv
-, bos, ctypes, fmt, logs, rresult, sexplib
+, bos, ctypes, fmt, logs, rresult
+, mdx, alcotest, crowbar, junit_alcotest, ezjsonm
 }:
 
 buildDunePackage rec {
   pname = "yaml";
-  version = "2.1.0";
+  version = "3.0.0";
 
   useDune2 = true;
 
   src = fetchurl {
     url = "https://github.com/avsm/ocaml-yaml/releases/download/v${version}/yaml-v${version}.tbz";
-    sha256 = "03g8vsh5jgi1cm5q78v15slgnzifp91fp7n4v1i7pa8yk0bkh585";
+    sha256 = "1iws6lbnrrd5hhmm7lczfvqp0aidx5xn7jlqk2s5rjfmj9qf4j2c";
   };
 
   buildInputs = [ dune-configurator ];
-  propagatedBuildInputs = [ bos ctypes fmt logs ppx_sexp_conv rresult sexplib ];
+  propagatedBuildInputs = [ bos ctypes rresult ];
+  checkInputs = [ fmt logs mdx alcotest crowbar junit_alcotest ezjsonm ];
 
   meta = {
     description = "Parse and generate YAML 1.1 files";

pkgs/development/ocaml-modules/yaml/yaml-sexp.nix

···
+{ lib, fetchurl, buildDunePackage, yaml, dune-configurator, ppx_sexp_conv, sexplib }:
+
+buildDunePackage rec {
+  pname = "yaml-sexp";
+
+  inherit (yaml) version src useDune2;
+
+  propagatedBuildInputs = [ yaml ppx_sexp_conv sexplib ];
+
+  meta = yaml.meta // {
+    description = "ocaml-yaml with sexp support";
+  };
+}

pkgs/development/tools/kustomize/kustomize-sops.nix

···
 
 buildGoModule rec {
   pname = "kustomize-sops";
-  version = "2.6.0";
+  version = "3.0.1";
 
   src = fetchFromGitHub {
     owner = "viaduct-ai";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-3dSWIDPIT4crsJuaB1TDfrUzobn8RfRlFAhqMXzZbKI=";
+    sha256 = "sha256-ZCEgv+2WC1XLDFdRtigkiWu81zLMHvmB8vvIBWN2UYY=";
   };
 
-  vendorSha256 = "sha256-+MVViFwaApGZZxCyTwLzIEWTZDbr7WSx7e/yGbJ309Y=";
+  vendorSha256 = "sha256-LFa0s2FBkw97P0CV+9JBmUAjaKVO+RzCX+iWGPUD9iA=";
 
   installPhase = ''
     mkdir -p $out/lib/viaduct.ai/v1/ksops-exec/

pkgs/development/tools/misc/luarocks/luarocks-nix.nix

···
   src = fetchFromGitHub {
     owner = "nix-community";
     repo = "luarocks-nix";
-    rev = "test-speedup";
-    sha256 = "sha256-WfzLSpIp0V7Ib4sjYvoJHF+/vHaieccvfVAr5W47QsQ=";
+    rev = "standalone";
+    sha256 = "sha256-53Zi+GTayO9EQTCIVrzPeRRHeIkHLqy0mHyBDzbcQQk=";
   };
   patches = [];
 

pkgs/development/tools/profiling/pprof/default.nix

···
-# This file was originally generated by https://github.com/kamilchm/go2nix v1.2.1
-{ lib, buildGoPackage, fetchgit }:
-
-buildGoPackage rec {
-  pname = "pprof-unstable";
-  version = "2018-08-15";
-  rev = "781f11b1fcf71fae9d185e7189b5e686f575075a";
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
 
-  goPackagePath = "github.com/google/pprof";
+buildGoModule rec {
+  pname = "pprof";
+  version = "unstable-2021-09-30";
 
-  src = fetchgit {
-    inherit rev;
-    url = "git://github.com/google/pprof";
-    sha256 = "1nvzwcj6h4q0lsjlri3bym4axgv848w3xz57iz5p0wz9lcd5jsmf";
+  src = fetchFromGitHub {
+    owner = "google";
+    repo = "pprof";
+    rev = "7fe48b4c820be13151ae35ce5a5e3f54f1b53eef";
+    sha256 = "05nr3igdigs1586qplwfm17hfw0v81jy745g6vayq7cbplljfjb1";
   };
 
-  goDeps = ./deps.nix;
+  vendorSha256 = "0yl8y3m2ia3cwxhmg1km8358a0225khimv6hcvras8r2glm69h3f";
 
   meta = with lib; {
     description = "A tool for visualization and analysis of profiling data";
     homepage = "https://github.com/google/pprof";
     license = licenses.asl20;
     longDescription = ''
-      pprof reads a collection of profiling samples in profile.proto format and generates reports to visualize and help analyze the data. It can generate both text and graphical reports (through the use of the dot visualization package).
+      pprof reads a collection of profiling samples in profile.proto format and
+      generates reports to visualize and help analyze the data. It can generate
+      both text and graphical reports (through the use of the dot visualization
+      package).
 
-      profile.proto is a protocol buffer that describes a set of callstacks and symbolization information. A common usage is to represent a set of sampled callstacks from statistical profiling. The format is described on the proto/profile.proto file. For details on protocol buffers, see https://developers.google.com/protocol-buffers
+      profile.proto is a protocol buffer that describes a set of callstacks and
+      symbolization information. A common usage is to represent a set of sampled
+      callstacks from statistical profiling. The format is described on the
+      proto/profile.proto file. For details on protocol buffers, see
+      https://developers.google.com/protocol-buffers
 
-      Profiles can be read from a local file, or over http. Multiple profiles of the same type can be aggregated or compared.
+      Profiles can be read from a local file, or over http. Multiple profiles of
+      the same type can be aggregated or compared.
 
-      If the profile samples contain machine addresses, pprof can symbolize them through the use of the native binutils tools (addr2line and nm).
+      If the profile samples contain machine addresses, pprof can symbolize them
+      through the use of the native binutils tools (addr2line and nm).
 
       This is not an official Google product.
     '';

pkgs/development/tools/profiling/pprof/deps.nix

···
-# This file was generated by https://github.com/kamilchm/go2nix v1.2.1
-[
-  {
-    goPackagePath = "github.com/chzyer/readline";
-    fetch = {
-      type = "git";
-      url = "https://github.com/chzyer/readline";
-      rev = "2972be24d48e78746da79ba8e24e8b488c9880de";
-      sha256 = "104q8dazj8yf6b089jjr82fy9h1g80zyyzvp3g8b44a7d8ngjj6r";
-    };
-  }
-  {
-    goPackagePath = "github.com/ianlancetaylor/demangle";
-    fetch = {
-      type = "git";
-      url = "https://github.com/ianlancetaylor/demangle";
-      rev = "fcd258a6f0b45dc345a407ee5568cf9a4d24a0ae";
-      sha256 = "10hdzq6n4mb13g8ddqvwjwx14djfyxhh0gjc888vdihzvhyqhvrp";
-    };
-  }
-]

pkgs/development/tools/wasm-bindgen-cli/Cargo.lock

···
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "add"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "adler32"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
-
-[[package]]
-name = "aho-corasick"
-version = "0.7.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
-dependencies = [
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61604a8f862e1d5c3229fdd78f8b02c68dcf73a4c4b05fd636d12240aaa242c1"
-
-[[package]]
-name = "arrayvec"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
-
-[[package]]
-name = "ascii"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbf56136a5198c7b01a49e3afcbef6cf84597273d298f54432926024107b0109"
-
-[[package]]
-name = "askama"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d298738b6e47e1034e560e5afe63aa488fea34e25ec11b855a76f0d7b8e73134"
-dependencies = [
- "askama_derive",
- "askama_escape",
- "askama_shared",
-]
-
-[[package]]
-name = "askama_derive"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2925c4c290382f9d2fa3d1c1b6a63fa1427099721ecca4749b154cc9c25522"
-dependencies = [
- "askama_shared",
- "proc-macro2",
- "syn",
-]
-
-[[package]]
-name = "askama_escape"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90c108c1a94380c89d2215d0ac54ce09796823cca0fd91b299cfff3b33e346fb"
-
-[[package]]
-name = "askama_shared"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2582b77e0f3c506ec4838a25fa8a5f97b9bed72bb6d3d272ea1c031d8bd373bc"
-dependencies = [
- "askama_escape",
- "humansize",
- "nom 6.2.1",
- "num-traits 0.2.14",
- "percent-encoding",
- "proc-macro2",
- "quote",
- "serde",
- "syn",
- "toml",
-]
-
-[[package]]
-name = "assert_cmd"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe"
-dependencies = [
- "bstr",
- "doc-comment",
- "predicates 2.0.3",
- "predicates-core",
- "predicates-tree",
- "wait-timeout",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
-
-[[package]]
-name = "base64"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
-dependencies = [
- "byteorder",
- "safemem",
-]
-
-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
-[[package]]
-name = "bitflags"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitvec"
-version = "0.19.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "bstr"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a40b47ad93e1a5404e6c18dec46b628214fee441c70f4ab5d6942142cc268a3d"
-dependencies = [
- "lazy_static",
- "memchr",
- "regex-automata",
-]
-
-[[package]]
-name = "buf_redux"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f"
-dependencies = [
- "memchr",
- "safemem",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9df67f7bf9ef8498769f994239c45613ef0c5899415fb58e9add412d2c1a538"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "bytes"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
-
-[[package]]
-name = "bytes"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
-
-[[package]]
-name = "canvas"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "cc"
-version = "1.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"
-
-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "char"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "chrono"
-version = "0.4.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
-dependencies = [
- "libc",
- "num-integer",
- "num-traits 0.2.14",
- "time 0.1.43",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "chunked_transfer"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"
-
-[[package]]
-name = "clap"
-version = "2.33.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
-dependencies = [
- "ansi_term",
- "atty",
- "bitflags 1.3.2",
- "strsim 0.8.0",
- "textwrap",
- "unicode-width",
- "vec_map",
-]
-
-[[package]]
-name = "closures"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "color_quant"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
-
-[[package]]
-name = "console_error_panic_hook"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
-dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "console_log"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "core-foundation"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6888e10551bb93e424d8df1d07f1a8b4fceb0001a3a4b048bfc47554946f47b3"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
- "lazy_static",
- "memoffset",
- "scopeguard",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
-dependencies = [
- "cfg-if 1.0.0",
- "lazy_static",
-]
-
-[[package]]
-name = "curl"
-version = "0.4.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaa3b8db7f3341ddef15786d250106334d4a6c4b0ae4a46cd77082777d9849b9"
-dependencies = [
- "curl-sys",
- "libc",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "socket2 0.4.2",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "curl-sys"
-version = "0.4.49+curl-7.79.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f44960aea24a786a46907b8824ebc0e66ca06bf4e4978408c7499620343483"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
- "vcpkg",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "deflate"
-version = "0.7.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707b6a7b384888a70c8d2e8650b3e60170dfc6a67bb4aa67b6dfca57af4bedb4"
-dependencies = [
- "adler32",
- "byteorder",
-]
-
-[[package]]
-name = "deno"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "diff"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
-
-[[package]]
-name = "difference"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
-
-[[package]]
-name = "difflib"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
-
-[[package]]
-name = "doc-comment"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
-
-[[package]]
-name = "docopt"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f3f119846c823f9eafcf953a8f6ffb6ed69bf6240883261a7f13b634579a51f"
-dependencies = [
- "lazy_static",
- "regex",
- "serde",
- "strsim 0.10.0",
-]
-
-[[package]]
-name = "dom"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "either"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
-
-[[package]]
-name = "encoding_rs"
-version = "0.8.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "enum_primitive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4551092f4d519593039259a9ed8daedf0da12e5109c5280338073eaeb81180"
-dependencies = [
- "num-traits 0.1.43",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
-dependencies = [
- "atty",
- "humantime",
- "log",
- "regex",
- "termcolor",
-]
-
-[[package]]
-name = "fetch"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "serde",
- "serde_derive",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "filetime"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "975ccf83d8d9d0d84682850a38c8169027be83368805971cc4f238c2b245bc98"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "float-cmp"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"
-dependencies = [
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
-[[package]]
-name = "form_urlencoded"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
-dependencies = [
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "fuchsia-zircon"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
-dependencies = [
- "bitflags 1.3.2",
- "fuchsia-zircon-sys",
-]
-
-[[package]]
-name = "fuchsia-zircon-sys"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
-
-[[package]]
-name = "funty"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"
-
-[[package]]
-name = "futures"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12aa0eb539080d55c3f2d45a67c3b58b6b0773c1a3ca2dfec66d58c97fd66ca"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5da6ba8c3bb3c165d3c7319fc1cc8304facf1fb8db99c5de877183c08a273888"
-dependencies = [
- "futures-core",
- "futures-sink",
-]
-
-[[package]]
-name = "futures-channel-preview"
-version = "0.3.0-alpha.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5e5f4df964fa9c1c2f8bddeb5c3611631cacd93baf810fc8bb2fb4b495c263a"
-dependencies = [
- "futures-core-preview",
-]
-
-[[package]]
-name = "futures-core"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d1c26957f23603395cd326b0ffe64124b818f4449552f960d815cfba83a53d"
-
-[[package]]
-name = "futures-core-preview"
-version = "0.3.0-alpha.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35b6263fb1ef523c3056565fa67b1d16f0a8604ff12b11b08c25f28a734c60a"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45025be030969d763025784f7f355043dc6bc74093e4ecc5000ca4dc50d8745c"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "522de2a0fe3e380f1bc577ba0474108faf3f6b18321dbf60b3b9c39a75073377"
-
-[[package]]
-name = "futures-lite"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
-dependencies = [
- "futures-core",
- "pin-project-lite 0.2.7",
-]
-
-[[package]]
-name = "futures-macro"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e4a4b95cea4b4ccbcf1c5675ca7c4ee4e9e75eb79944d07defde18068f79bb"
-dependencies = [
- "autocfg",
- "proc-macro-hack",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36ea153c13024fe480590b3e3d4cad89a0cfacecc24577b68f86c6ced9c2bc11"
-
-[[package]]
-name = "futures-task"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d3d00f4eddb73e498a54394f228cd55853bdf059259e8e7bc6e69d408892e99"
-
-[[package]]
-name = "futures-util"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36568465210a3a6ee45e1f165136d68671471a501e632e9a98d96872222b5481"
-dependencies = [
- "autocfg",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite 0.2.7",
- "pin-utils",
- "proc-macro-hack",
- "proc-macro-nested",
- "slab",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "gif"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e41945ba23db3bf51b24756d73d81acb4f28d85c3dccc32c6fae904438c25f"
-dependencies = [
- "color_quant",
- "lzw",
-]
-
-[[package]]
-name = "glob"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
-
-[[package]]
-name = "gloo"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ce6f2dfa9f57f15b848efa2aade5e1850dc72986b87a2b0752d44ca08f4967"
-dependencies = [
- "gloo-console-timer",
- "gloo-events",
- "gloo-file",
- "gloo-timers",
-]
-
-[[package]]
-name = "gloo-console-timer"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b48675544b29ac03402c6dffc31a912f716e38d19f7e74b78b7e900ec3c941ea"
-dependencies = [
- "web-sys",
-]
-
-[[package]]
-name = "gloo-events"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "088514ec8ef284891c762c88a66b639b3a730134714692ee31829765c5bc814f"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-file"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f9fecfe46b5dc3cc46f58e98ba580cc714f2c93860796d002eb3527a465ef49"
-dependencies = [
- "gloo-events",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-timers"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47204a46aaff920a1ea58b11d03dec6f704287d27561724a4631e450654a891f"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "guide-supported-types-examples"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "h2"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e4728fd124914ad25e99e3d15a9361a879f6620f63cb56bbb08f95abb97a535"
-dependencies = [
- "bytes 0.5.6",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
- "tracing-futures",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-
-[[package]]
-name = "heck"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
-dependencies = [
- "unicode-segmentation",
-]
-
-[[package]]
-name = "hello_world"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "http"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1323096b05d41827dadeaee54c9981958c0f94e670bc94ed80037d1a7b8b186b"
-dependencies = [
- "bytes 1.1.0",
- "fnv",
- "itoa",
-]
-
-[[package]]
-name = "http-body"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
-dependencies = [
- "bytes 0.5.6",
- "http",
-]
-
-[[package]]
-name = "httparse"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acd94fdbe1d4ff688b67b04eee2e17bd50995534a61539e45adfefb45e5e5503"
-
-[[package]]
-name = "httpdate"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "494b4d60369511e7dea41cf646832512a94e542f68bb9c49e54518e0f468eb47"
-
-[[package]]
-name = "humansize"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02296996cb8796d7c6e3bc2d9211b7802812d36999a51bb754123ead7d37d026"
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "hyper"
-version = "0.13.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a6f157065790a3ed2f88679250419b5cdd96e714a0d65f7797fd337186e96bb"
-dependencies = [
- "bytes 0.5.6",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project",
- "socket2 0.3.19",
- "tokio",
- "tower-service",
- "tracing",
- "want",
-]
-
-[[package]]
-name = "hyper-tls"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d979acc56dcb5b8dddba3917601745e877576475aa046df3226eabdecef78eed"
-dependencies = [
- "bytes 0.5.6",
- "hyper",
- "native-tls",
- "tokio",
- "tokio-tls",
-]
-
-[[package]]
-name = "id-arena"
-version = "2.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
-dependencies = [
- "rayon",
-]
-
-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "image"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95816db758249fe16f23a4e23f1a3a817fe11892dbfd1c5836f625324702158"
-dependencies = [
- "byteorder",
- "enum_primitive",
- "gif",
- "jpeg-decoder",
- "num-iter",
- "num-rational",
- "num-traits 0.1.43",
- "png",
- "scoped_threadpool",
-]
-
-[[package]]
-name = "import_js"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "indexmap"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
-[[package]]
-name = "inflate"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7e0062d2dc2f17d2f13750d95316ae8a2ff909af0fda957084f5defd87c43bb"
-
-[[package]]
-name = "iovec"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "ipnet"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9"
-
-[[package]]
-name = "itertools"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
-
-[[package]]
-name = "jpeg-decoder"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229d53d58899083193af11e15917b5640cd40b29ff475a1fe4ef725deb02d0f2"
-dependencies = [
- "rayon",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.55"
-dependencies = [
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
-]
-
-[[package]]
-name = "json"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "078e285eafdfb6c4b434e0d31e8cfcb5115b651496faca5749b88fafd4f23bfd"
-
-[[package]]
-name = "julia_set"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "kernel32-sys"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
-dependencies = [
- "winapi 0.2.8",
- "winapi-build",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "leb128"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
-
-[[package]]
-name = "lexical-core"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
-dependencies = [
- "arrayvec",
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "ryu",
- "static_assertions",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
-
-[[package]]
-name = "libz-sys"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "log"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "lzw"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d947cbb889ed21c2a84be6ffbaebf5b4e0f4340638cba0444907e38b56be084"
-
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
-[[package]]
-name = "memchr"
-version = "2.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
-
-[[package]]
-name = "memoffset"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "mime"
-version = "0.3.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
-
-[[package]]
-name = "mime_guess"
-version = "2.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212"
-dependencies = [
- "mime",
- "unicase",
-]
-
-[[package]]
-name = "mio"
-version = "0.6.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
-dependencies = [
- "cfg-if 0.1.10",
- "fuchsia-zircon",
- "fuchsia-zircon-sys",
- "iovec",
- "kernel32-sys",
- "libc",
- "log",
- "miow",
- "net2",
- "slab",
- "winapi 0.2.8",
-]
-
-[[package]]
-name = "miow"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
-dependencies = [
- "kernel32-sys",
- "net2",
- "winapi 0.2.8",
- "ws2_32-sys",
-]
-
-[[package]]
-name = "multipart"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00dec633863867f29cb39df64a397cdf4a6354708ddd7759f70c7fb51c5f9182"
-dependencies = [
- "buf_redux",
- "httparse",
- "log",
- "mime",
- "mime_guess",
- "quick-error",
- "rand",
- "safemem",
- "tempfile",
- "twoway",
-]
-
-[[package]]
-name = "native-tls"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d"
-dependencies = [
- "lazy_static",
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
-[[package]]
-name = "net2"
-version = "0.2.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae"
-dependencies = [
- "cfg-if 0.1.10",
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "no-std"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "nom"
-version = "5.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
-dependencies = [
- "memchr",
- "version_check",
-]
-
-[[package]]
-name = "nom"
-version = "6.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c5c51b9083a3c620fa67a2a635d1ce7d95b897e957d6b28ff9a5da960a103a6"
-dependencies = [
- "bitvec",
- "funty",
- "lexical-core",
- "memchr",
- "version_check",
-]
-
-[[package]]
-name = "normalize-line-endings"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
-
-[[package]]
-name = "num-integer"
-version = "0.1.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
-dependencies = [
- "autocfg",
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.1.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e"
-dependencies = [
- "num-integer",
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
-dependencies = [
- "num-traits 0.2.14",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
-
-[[package]]
-name = "openssl"
-version = "0.10.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d9facdb76fec0b73c406f125d44d86fdad818d66fef0531eec9233ca425ff4a"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
-
-[[package]]
-name = "openssl-src"
-version = "111.16.0+1.1.1l"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab2173f69416cf3ec12debb5823d244127d23a9b127d5a5189aa97c5fa2859f"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69df2d8dfc6ce3aaf44b40dec6f487d5a886516cf6879c49e98e0710f310a058"
-dependencies = [
- "autocfg",
- "cc",
- "libc",
- "openssl-src",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "percent-encoding"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
-
-[[package]]
-name = "performance"
-version = "0.1.0"
-dependencies = [
- "humantime",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "pin-project"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "576bc800220cc65dac09e99e97b08b358cfab6e17078de8dc5fee223bd2d0c08"
-dependencies = [
- "pin-project-internal",
-]
-
-[[package]]
-name = "pin-project-internal"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e8fe8163d14ce7f0cdac2e040116f22eac817edabff0be91e8aff7e9accf389"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pin-project-lite"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "257b64915a082f7811703966789728173279bdebb956b143dbcd23f6f970a777"
-
-[[package]]
-name = "pin-project-lite"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d31d11c69a6b52a174b42bdc0c30e5e11670f90788b2c471c31c1d17d449443"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c9b1041b4387893b91ee6746cddfc28516aff326a3519fb2adf820932c5e6cb"
-
-[[package]]
-name = "png"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb773e9a557edb568ce9935cf783e3cdcabe06a9449d41b3e5506d88e582c82"
-dependencies = [
- "bitflags 0.7.0",
- "deflate",
- "inflate",
- "num-iter",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
-
-[[package]]
-name = "predicates"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f49cfaf7fdaa3bfacc6fa3e7054e65148878354a5cfddcf661df4c851f8021df"
-dependencies = [
- "difference",
- "float-cmp",
- "normalize-line-endings",
- "predicates-core",
- "regex",
-]
-
-[[package]]
-name = "predicates"
-version = "2.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c6ce811d0b2e103743eec01db1c50612221f173084ce2f7941053e94b6bb474"
-dependencies = [
- "difflib",
- "itertools",
- "predicates-core",
-]
-
-[[package]]
-name = "predicates-core"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"
-
-[[package]]
-name = "predicates-tree"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "338c7be2905b732ae3984a2f40032b5e94fd8f52505b186c7d4d68d193445df7"
-dependencies = [
- "predicates-core",
- "termtree",
-]
-
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-hack"
-version = "0.5.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
-
-[[package]]
-name = "proc-macro-nested"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc3358ebc67bc8b7fa0c007f945b0b18226f78437d61bec735a9eb96b61ee70"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
-[[package]]
-name = "quote"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"
-
-[[package]]
-name = "rand"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "rayon"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
-dependencies = [
- "autocfg",
- "crossbeam-deque",
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "lazy_static",
- "num_cpus",
-]
-
-[[package]]
-name = "raytrace-parallel"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "futures-channel-preview",
- "js-sys",
- "rayon",
- "rayon-core",
- "raytracer",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "raytracer"
-version = "0.1.0"
-source = "git+https://github.com/alexcrichton/raytracer?branch=update-deps#42faa13859f7d8d47fd18be785c108003a207786"
-dependencies = [
- "image",
- "serde",
- "serde_derive",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "regex"
-version = "1.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a26af418b574bd56588335b3a3659a65725d4e636eb1016c2f9e3b38c7cc759"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "request-animation-frame"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "reqwest"
-version = "0.10.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0718f81a8e14c4dbb3b34cf23dc6aaf9ab8a0dfec160c534b3dbca1aaa21f47c"
-dependencies = [
- "base64 0.13.0",
- "bytes 0.5.6",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "http",
- "http-body",
- "hyper",
- "hyper-tls",
- "ipnet",
- "js-sys",
- "lazy_static",
- "log",
- "mime",
- "mime_guess",
- "native-tls",
- "percent-encoding",
- "pin-project-lite 0.2.7",
- "serde",
- "serde_urlencoded",
- "tokio",
- "tokio-tls",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "winreg",
-]
-
-[[package]]
-name = "rouille"
-version = "3.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc1bcf3b32bd9ef568402e750404c369ff172a6a34597c858f8ccf5f3bed013"
-dependencies = [
- "base64 0.13.0",
- "chrono",
- "filetime",
- "multipart",
- "num_cpus",
- "percent-encoding",
- "rand",
- "serde",
- "serde_derive",
- "serde_json",
- "sha1",
- "threadpool",
- "time 0.3.3",
- "tiny_http",
- "url",
-]
-
-[[package]]
-name = "rust-duck-typed-interfaces"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "rust-webassembly-weather-reports"
-version = "0.1.1"
-dependencies = [
- "chrono",
- "gloo",
- "json",
- "reqwest",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "safemem"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
-
-[[package]]
-name = "sample"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
-]
-
-[[package]]
-name = "schannel"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
-dependencies = [
- "lazy_static",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "scoped-tls"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"
-
-[[package]]
-name = "scoped_threadpool"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d51f5df5af43ab3f1360b429fa5e0152ac5ce8c0bd6485cae490332e96846a8"
-
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
-[[package]]
-name = "security-framework"
-version = "2.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525bc1abfda2e1998d152c45cf13e696f76d0a4972310b22fac1658b05df7c87"
-dependencies = [
- "bitflags 1.3.2",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
-]
-
-[[package]]
-name = "security-framework-sys"
-version = "2.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9dd14d83160b528b7bfd66439110573efcfbe281b17fc2ca9f39f550d619c7e"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.68"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_urlencoded"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9"
-dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "sha1"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2579985fda508104f7587689507983eadd6a6e84dd35d6d115361f530916fa0d"
-
-[[package]]
-name = "slab"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"
-
-[[package]]
-name = "socket2"
-version = "0.3.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "socket2"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516"
-dependencies = [
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "sourcefile"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bf77cb82ba8453b42b6ae1d692e4cdc92f9a47beaf89a847c8be83f4e328ad3"
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "strsim"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
-
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "structopt"
-version = "0.3.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf9d950ef167e25e0bdb073cf1d68e9ad2795ac826f2f3f59647817cf23c0bfa"
-dependencies = [
- "clap",
- "lazy_static",
- "structopt-derive",
-]
-
-[[package]]
-name = "structopt-derive"
-version = "0.4.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "134d838a2c9943ac3125cf6df165eda53493451b719f3255b2a26b85f772d0ba"
-dependencies = [
- "heck",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d010a1623fbd906d51d650a9916aaefc05ffa0e4053ff7fe601167f3e715d194"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "tempfile"
-version = "3.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "rand",
- "redox_syscall",
- "remove_dir_all",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "termcolor"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "termtree"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78fbf2dd23e79c28ccfa2472d3e6b3b189866ffef1aeb91f17c2d968b6586378"
-
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "threadpool"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
-dependencies = [
- "num_cpus",
-]
-
-[[package]]
-name = "time"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
-dependencies = [
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "time"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde1cf55178e0293453ba2cca0d5f8392a922e52aa958aee9c28ed02becc6d03"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "tiny_http"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce51b50006056f590c9b7c3808c3bd70f0d1101666629713866c227d6e58d39"
-dependencies = [
- "ascii",
- "chrono",
- "chunked_transfer",
- "log",
- "url",
-]
-
-[[package]]
-name = "tinyvec"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
-[[package]]
-name = "todomvc"
-version = "0.1.0"
-dependencies = [
- "askama",
- "console_error_panic_hook",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "tokio"
-version = "0.2.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6703a273949a90131b290be1fe7b039d0fc884aa1935860dfcbe056f28cd8092"
-dependencies = [
- "bytes 0.5.6",
- "fnv",
- "futures-core",
- "iovec",
- "lazy_static",
- "memchr",
- "mio",
- "pin-project-lite 0.1.12",
- "slab",
-]
-
-[[package]]
-name = "tokio-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
-[[package]]
-name = "tokio-util"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
-dependencies = [
- "bytes 0.5.6",
- "futures-core",
- "futures-sink",
- "log",
- "pin-project-lite 0.1.12",
- "tokio",
-]
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "tower-service"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
-
-[[package]]
-name = "tracing"
-version = "0.1.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "375a639232caf30edfc78e8d89b2d4c375515393e7af7e16f01cd96917fb2105"
-dependencies = [
- "cfg-if 1.0.0",
- "log",
- "pin-project-lite 0.2.7",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4ed65637b8390770814083d20756f87bfa2c21bf2f110babdc5438351746e4"
-dependencies = [
- "lazy_static",
-]
-
-[[package]]
-name = "tracing-futures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
-dependencies = [
- "pin-project",
- "tracing",
-]
-
-[[package]]
-name = "try-lock"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
-
-[[package]]
-name = "trybuild"
-version = "1.0.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbaccfa9796293406a02ec790614628c88d0b3246249a620ac1ee7076274716b"
-dependencies = [
- "glob",
- "lazy_static",
- "serde",
- "serde_json",
- "termcolor",
- "toml",
-]
-
-[[package]]
-name = "twoway"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "typescript-tests"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "unicase"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
-dependencies = [
- "version_check",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-segmentation"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
-[[package]]
-name = "url"
-version = "2.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
-dependencies = [
- "form_urlencoded",
- "idna",
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "vec_map"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
-
-[[package]]
-name = "version_check"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
-
-[[package]]
-name = "wait-timeout"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "walrus"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eb08e48cde54c05f363d984bb54ce374f49e242def9468d2e1b6c2372d291f8"
-dependencies = [
- "anyhow",
- "id-arena",
- "leb128",
- "log",
- "rayon",
- "walrus-macro",
- "wasmparser 0.77.0",
-]
-
-[[package]]
-name = "walrus-macro"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e5bd22c71e77d60140b0bd5be56155a37e5bd14e24f5f87298040d0cc40d7"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "want"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
-dependencies = [
- "log",
- "try-lock",
-]
-
-[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.78"
-dependencies = [
- "cfg-if 1.0.0",
- "js-sys",
- "serde",
- "serde_derive",
- "serde_json",
- "wasm-bindgen-futures",
- "wasm-bindgen-macro",
- "wasm-bindgen-test",
- "wasm-bindgen-test-crate-a",
- "wasm-bindgen-test-crate-b",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.78"
-dependencies = [
- "bumpalo",
- "lazy_static",
- "log",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-benchmark"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-cli"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "assert_cmd",
- "curl",
- "diff",
- "docopt",
- "env_logger",
- "log",
- "openssl",
- "predicates 1.0.8",
- "rayon",
- "rouille",
- "serde",
- "serde_derive",
- "serde_json",
- "tempfile",
- "walrus",
- "wasm-bindgen-cli-support",
- "wasm-bindgen-shared",
- "wit-printer",
- "wit-text",
- "wit-validator",
- "wit-walrus",
-]
-
-[[package]]
-name = "wasm-bindgen-cli-support"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "base64 0.9.3",
- "log",
- "rustc-demangle",
- "serde_json",
- "tempfile",
- "walrus",
- "wasm-bindgen-externref-xform",
- "wasm-bindgen-multi-value-xform",
- "wasm-bindgen-shared",
- "wasm-bindgen-threads-xform",
- "wasm-bindgen-wasm-conventions",
- "wasm-bindgen-wasm-interpreter",
- "wit-text",
- "wit-validator",
- "wit-walrus",
-]
-
-[[package]]
-name = "wasm-bindgen-externref-xform"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "rayon",
- "walrus",
- "wasmprinter",
- "wast 21.0.0",
- "wat",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.28"
-dependencies = [
- "cfg-if 1.0.0",
- "futures-channel-preview",
- "futures-core",
- "futures-lite",
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-test",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.78"
-dependencies = [
- "quote",
- "trybuild",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.78"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-multi-value-xform"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "rayon",
- "walrus",
- "wasmprinter",
- "wast 21.0.0",
- "wat",
-]
-
-[[package]]
-name = "wasm-bindgen-paint"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.78"
-
-[[package]]
-name = "wasm-bindgen-test"
-version = "0.3.28"
-dependencies = [
- "console_error_panic_hook",
- "js-sys",
- "scoped-tls",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-test-crate-a"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "wasm-bindgen-test-crate-b"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "wasm-bindgen-test-macro"
-version = "0.3.28"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "wasm-bindgen-threads-xform"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "walrus",
- "wasm-bindgen-wasm-conventions",
-]
-
-[[package]]
-name = "wasm-bindgen-wasm-conventions"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "walrus",
-]
-
-[[package]]
-name = "wasm-bindgen-wasm-interpreter"
-version = "0.2.78"
-dependencies = [
- "anyhow",
- "log",
- "tempfile",
- "walrus",
- "wasm-bindgen-wasm-conventions",
- "wat",
-]
-
-[[package]]
-name = "wasm-bindgen-webidl"
-version = "0.2.76"
-dependencies = [
- "anyhow",
- "env_logger",
- "heck",
- "lazy_static",
- "log",
- "proc-macro2",
- "quote",
- "sourcefile",
- "structopt",
- "syn",
- "wasm-bindgen-backend",
- "weedle",
-]
-
-[[package]]
-name = "wasm-in-wasm"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "wasm-in-wasm-imports"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "wasm-in-web-worker"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm2js"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "wasmparser"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a950e6a618f62147fd514ff445b2a0b53120d382751960797f85f058c7eda9b9"
-
-[[package]]
-name = "wasmparser"
-version = "0.77.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35c86d22e720a07d954ebbed772d01180501afe7d03d464f413bb5f8914a8d6"
-
-[[package]]
-name = "wasmparser"
-version = "0.80.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "449167e2832691a1bff24cde28d2804e90e09586a448c8e76984792c44334a6b"
-
-[[package]]
-name = "wasmprinter"
-version = "0.2.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf83acd0a74a68f7b96acddc6035af45a09659d53f877b73aa22c816ed3e71e7"
-dependencies = [
- "anyhow",
- "wasmparser 0.80.2",
-]
-
-[[package]]
-name = "wast"
-version = "21.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b1844f66a2bc8526d71690104c0e78a8e59ffa1597b7245769d174ebb91deb5"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wast"
-version = "38.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wat"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adcfaeb27e2578d2c6271a45609f4a055e6d7ba3a12eff35b1fd5ba147bdf046"
-dependencies = [
- "wast 38.0.1",
-]
-
-[[package]]
-name = "web-sys"
-version = "0.3.55"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
-]
-
-[[package]]
-name = "webaudio"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "webgl"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "webidl-tests"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "wasm-bindgen-webidl",
-]
-
-[[package]]
-name = "webrtc_datachannel"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "websockets"
-version = "0.1.0"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "webxr"
-version = "0.1.0"
-dependencies = [
- "futures",
- "js-sys",
- "serde",
- "serde_derive",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
-
-[[package]]
-name = "weedle"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "610950904727748ca09682e857f0d6d6437f0ca862f32f9229edba8cec8b2635"
-dependencies = [
- "nom 5.1.2",
-]
-
-[[package]]
-name = "winapi"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-build"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
-dependencies = [
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "winreg"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
-dependencies = [
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "wit-parser"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f5fd97866f4b9c8e1ed57bcf9446f3d0d8ba37e2dd01c3c612c046c053b06f7"
-dependencies = [
- "anyhow",
- "leb128",
- "wit-schema-version",
-]
-
-[[package]]
-name = "wit-printer"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f19ca44555a3c14d69acee6447a6e4f52771b0c6e5d8db3e42db3b90f6fce9"
-dependencies = [
- "anyhow",
- "wasmprinter",
- "wit-parser",
- "wit-schema-version",
-]
-
-[[package]]
-name = "wit-schema-version"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfee4a6a4716eefa0682e7a3b836152e894a3e4f34a9d6c2c3e1c94429bfe36a"
-
-[[package]]
-name = "wit-text"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33358e95c77d660f1c7c07f4a93c2bd89768965e844e3c50730bb4b42658df5f"
-dependencies = [
- "anyhow",
- "wast 21.0.0",
- "wit-writer",
-]
-
-[[package]]
-name = "wit-validator"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c11d93d925420e7872b226c4161849c32be38385ccab026b88df99d8ddc6ba6"
-dependencies = [
- "anyhow",
- "wasmparser 0.59.0",
- "wit-parser",
- "wit-schema-version",
-]
-
-[[package]]
-name = "wit-walrus"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad559e3e4c6404b2a6a675d44129d62a3836e3b951b90112fa1c5feb852757cd"
-dependencies = [
- "anyhow",
- "id-arena",
- "walrus",
- "wit-parser",
- "wit-schema-version",
- "wit-writer",
-]
-
-[[package]]
-name = "wit-writer"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2ad01ba5e9cbcff799a0689e56a153776ea694cec777f605938cb9880d41a09"
-dependencies = [
- "leb128",
- "wit-schema-version",
-]
-
-[[package]]
-name = "without-a-bundler"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "without-a-bundler-no-modules"
-version = "0.1.0"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "ws2_32-sys"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
-dependencies = [
- "winapi 0.2.8",
- "winapi-build",
-]
-
-[[package]]
-name = "wyz"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214"

pkgs/development/tools/wasm-bindgen-cli/default.nix

···
-{ rustPlatform
-, fetchFromGitHub
-, lib
+{ lib
+, rustPlatform
+, fetchCrate
+, nodejs
+, pkg-config
 , openssl
-, pkg-config
 , stdenv
 , curl
 , Security
···
   pname = "wasm-bindgen-cli";
   version = "0.2.78";
 
-  src =
-    let
-      tarball = fetchFromGitHub {
-        owner = "rustwasm";
-        repo = "wasm-bindgen";
-        rev = version;
-        hash = "sha256-1Z5d4gjZUic6Yrd+O8oLWYpJqAYGcByZYP0H1iInXHA=";
-      };
-    in
-    runCommand "source" { } ''
-      cp -R ${tarball} $out
-      chmod -R +w $out
-      cp ${./Cargo.lock} $out/Cargo.lock
-    '';
+  src = fetchCrate {
+    inherit pname version;
+    sha256 = "sha256-5s+HidnVfDV0AXA+/YcXNGVjv/E9JeK0Ttng4mCVX8M=";
+  };
+
+  cargoSha256 = "sha256-CbtjUFwowP/QqyAMCzmUiSib4EpRhQAmO4ekX00xYGE=";
 
-  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security curl ];
   nativeBuildInputs = [ pkg-config ];
 
-  cargoHash = "sha256-RixIEat7EzGzgSQTnPennePpiucmAatrDGhbFSfTajo=";
-  cargoBuildFlags = [ "-p" pname ];
+  buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ curl Security ];
+
+  checkInputs = [ nodejs ];
+
+  # other tests require it to be ran in the wasm-bindgen monorepo
+  cargoTestFlags = [ "--test=interface-types" ];
 
   meta = with lib; {
     homepage = "https://rustwasm.github.io/docs/wasm-bindgen/";
-    license = licenses.asl20;
+    license = with licenses; [ asl20 /* or */ mit ];
     description = "Facilitating high-level interactions between wasm modules and JavaScript";
     maintainers = with maintainers; [ ma27 nitsky rizary ];
-    platforms = platforms.unix;
+    mainProgram = "wasm-bindgen";
   };
 }

pkgs/games/runescape-launcher/default.nix

···
+{ stdenv, lib, buildFHSUserEnv, dpkg, glibc, gcc-unwrapped, autoPatchelfHook, fetchurl, wrapGAppsHook
+, gnome2, xorg
+, libSM, libXxf86vm, libX11, glib, pango, cairo, gtk2-x11, zlib, openssl
+, libpulseaudio
+, SDL2, xorg_sys_opengl, libGL
+}:
+let
+
+  runescape = stdenv.mkDerivation rec {
+    pname = "runescape-launcher";
+    version = "2.2.9";
+
+    src = fetchurl {
+      url = "https://content.runescape.com/downloads/ubuntu/pool/non-free/r/${pname}/${pname}_${version}_amd64.deb";
+      sha256 = "0r5v1pwh0aas31b1d3pkrc8lqmqz9b4fml2b4kxmg5xzp677h271";
+    };
+
+    nativeBuildInputs = [
+      autoPatchelfHook
+      wrapGAppsHook
+      dpkg
+    ];
+
+    buildInputs = [
+      glibc
+      gcc-unwrapped
+      libSM
+      libXxf86vm
+      libX11
+      glib
+      pango
+      cairo
+      gtk2-x11
+      zlib
+      openssl
+    ];
+
+    runtimeDependencies = [
+      libpulseaudio
+      libGL
+      SDL2
+      xorg_sys_opengl
+      openssl
+      zlib
+    ];
+
+    dontUnpack = true;
+
+    preBuild = ''
+      export DH_VERBOSE=1
+    '';
+
+    envVarsWithXmodifiers = ''
+      export MESA_GLSL_CACHE_DIR=~/Jagex
+      export GDK_SCALE=2
+      unset XMODIFIERS
+    '';
+
+    installPhase = ''
+      mkdir -p $out/bin $out/share
+      dpkg -x $src $out
+
+      patchShebangs $out/usr/bin/runescape-launcher
+      substituteInPlace $out/usr/bin/runescape-launcher \
+        --replace "unset XMODIFIERS" "$envVarsWithXmodifiers" \
+        --replace "/usr/share/games/runescape-launcher/runescape" "$out/share/games/runescape-launcher/runescape"
+
+      cp -r $out/usr/bin $out/
+      cp -r $out/usr/share $out/
+
+      rm -r $out/usr
+    '';
+
+
+    meta = with lib; {
+      description = "Launcher for RuneScape 3, the current main RuneScape";
+      homepage = "https://www.runescape.com/";
+      license = licenses.unfree;
+      maintainers = with lib.maintainers; [ grburst ];
+      platforms = [ "x86_64-linux" ];
+    };
+  };
+
+in
+
+  /*
+  * We can patch the runescape launcher, but it downloads a client at runtime and checks it for changes.
+  * For that we need use a buildFHSUserEnv.
+  * FHS simulates a classic linux shell
+  */
+  buildFHSUserEnv {
+   name = "RuneScape";
+   targetPkgs = pkgs: [
+     runescape
+     dpkg glibc gcc-unwrapped
+     libSM libXxf86vm libX11 glib pango cairo gtk2-x11 zlib openssl
+     libpulseaudio
+     xorg.libX11
+     SDL2 xorg_sys_opengl libGL
+   ];
+   multiPkgs = pkgs: [ libGL ];
+   runScript = "runescape-launcher";
+}

pkgs/misc/vim-plugins/generated.nix

···
 
   better-escape-nvim = buildVimPluginFrom2Nix {
     pname = "better-escape.nvim";
-    version = "2021-10-09";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "max397574";
       repo = "better-escape.nvim";
-      rev = "a644df43e4607df2e645cb7b6f50ede79fffe477";
-      sha256 = "1kjc1h35xfqgsqbg00hsvg52wkjskfilxxsxnnlimcsv9v8iadmh";
+      rev = "bbb8b0e3d1b1088a1db6b5ece776a41709929128";
+      sha256 = "1xiaywjy12rj25qdq5ys8ayrwlw9p9frpjzzagx1p6zgp03jpq63";
     };
     meta.homepage = "https://github.com/max397574/better-escape.nvim/";
   };
···
 
   chadtree = buildVimPluginFrom2Nix {
     pname = "chadtree";
-    version = "2021-10-17";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "chadtree";
-      rev = "63259154cae7c01a877cd493c7ff53d8bbaf36a8";
-      sha256 = "0072yqwcs23j1q5akybc9q933lg3davrbh10rjqs690b8p69rz0p";
+      rev = "47071cacfb9bcd5ac86dddb1e3ef272ca7ac254d";
+      sha256 = "1b2dx5j44441xgfk3dj8f135kim38fnp2s8rpf098q8r2gn3zv8d";
     };
     meta.homepage = "https://github.com/ms-jpq/chadtree/";
   };
···
 
   comment-nvim = buildVimPluginFrom2Nix {
     pname = "comment.nvim";
-    version = "2021-10-17";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "numtostr";
       repo = "comment.nvim";
-      rev = "a86384dc153e86a9a3cbec1436a8acfa4b07690d";
-      sha256 = "043nczs67sa7i2nmmadhrd52d3yzjr1kcm3bgb4q5zig1a7r4dcj";
+      rev = "5365cc7f1fc2522ffa1b560830d3125372928d6a";
+      sha256 = "0lvcl3pykcry35r6c9fxmjklzvzz7lpxfchbz1qgadpq45pidyir";
     };
     meta.homepage = "https://github.com/numtostr/comment.nvim/";
   };
···
 
   conflict-marker-vim = buildVimPluginFrom2Nix {
     pname = "conflict-marker.vim";
-    version = "2020-09-23";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "rhysd";
       repo = "conflict-marker.vim";
-      rev = "6a9b8f92a57ea8a90cbf62c960db9e5894be2d7a";
-      sha256 = "0vw5kvnmwwia65gni97vk42b9s47r3p5bglrhpcxsvs3f4s250vq";
+      rev = "22b6133116795ea8fb6705ddca981aa8faecedda";
+      sha256 = "0rh3c1sl145hwyh6idwgyqbrgnwvd91spxc5qs2hfr1xsh53ssx2";
     };
     meta.homepage = "https://github.com/rhysd/conflict-marker.vim/";
   };
···
 
   floobits-neovim = buildVimPluginFrom2Nix {
     pname = "floobits-neovim";
-    version = "2018-08-01";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "floobits";
       repo = "floobits-neovim";
-      rev = "29ab2ed4bd5c879df0bd6df313a776155eb98ad8";
-      sha256 = "0bnncn3waw9birpd51j27hrzlriz8dk4naxdajmbwznwcnbkkgwx";
+      rev = "dbfa051e4f097dfa3f46997a2019556a62861258";
+      sha256 = "1zsr1536qf7zqdskpshf366m333w66hfjrfdw3ws5yz2l7kq5bcm";
     };
     meta.homepage = "https://github.com/floobits/floobits-neovim/";
   };
···
 
   gitlinker-nvim = buildVimPluginFrom2Nix {
     pname = "gitlinker.nvim";
-    version = "2021-10-12";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "ruifm";
       repo = "gitlinker.nvim";
-      rev = "a727080a527cb0f01843b59e9c445d7c4dce0f12";
-      sha256 = "0mbnbiikavl6p0jsaal7vmxafrzdcn59xngwszx16qw8f00l76hw";
+      rev = "a6fb6d1ec2746fc18f81433648416edfb1a96d43";
+      sha256 = "0c417li0jx970h8qkgrww7ifzjjknfi26i7n13qx96c5axjxady5";
     };
     meta.homepage = "https://github.com/ruifm/gitlinker.nvim/";
   };
···
 
   lightspeed-nvim = buildVimPluginFrom2Nix {
     pname = "lightspeed.nvim";
-    version = "2021-10-09";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "ggandor";
       repo = "lightspeed.nvim";
-      rev = "0836af9ad0c4bb913c8e00595bb25620c894fb97";
-      sha256 = "0vj84656vifg5c47m2pj7sfp9gz5ikpq9n0p57047d8r1arw50xg";
+      rev = "d2d47534b00d6fcd16cabab8ec8a6cd15c40ebf3";
+      sha256 = "13yb0srx7g9yf6rrr0bycxr4kac1ip1a1nzz27hamfkq3l9rcgn5";
     };
     meta.homepage = "https://github.com/ggandor/lightspeed.nvim/";
   };
···
 
   null-ls-nvim = buildVimPluginFrom2Nix {
     pname = "null-ls.nvim";
-    version = "2021-10-15";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "null-ls.nvim";
-      rev = "f9d3acd1a4e3b7e6d84951754fbdaadb196ae0fd";
-      sha256 = "15jk540qb2zwpq3vh31skdl1gn9v6y28vqv9jrw78fjmhrs99lld";
+      rev = "9534bda66ec8e919bace771bec74678b50b87a88";
+      sha256 = "0n61rf8qg8kqxa9hmf7jvnrj36xqi5ml9h3kfwszzbjmq89533kw";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";
   };
···
 
   nvim-cmp = buildVimPluginFrom2Nix {
     pname = "nvim-cmp";
-    version = "2021-10-16";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "hrsh7th";
       repo = "nvim-cmp";
-      rev = "4ecf2a24265626a2c00427394deb4747c7b9d5dc";
-      sha256 = "1p134wb9g2ki0gn7aqhsh64frcx5n00npkcj1lgnzcc4cc95p7d4";
+      rev = "a6a98856c3986de675bc40c9c98b7458fb19e95c";
+      sha256 = "0x0hzymvna939iscz0llm64ic28iinh4bn6xihv8afgm693j3jbi";
     };
     meta.homepage = "https://github.com/hrsh7th/nvim-cmp/";
   };
···
 
   nvim-lsp-ts-utils = buildVimPluginFrom2Nix {
     pname = "nvim-lsp-ts-utils";
-    version = "2021-10-03";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "nvim-lsp-ts-utils";
-      rev = "efa321ad03fbffeca699bc04ca1a59db0c54d16f";
-      sha256 = "1bxj37jfcq6vrxpl5cslzmg03aqf2i13i71birvcvlw6n4p3kbbm";
+      rev = "cae4c06308c1ba4f2fdde31836fd98de3fc3e2b5";
+      sha256 = "1s2jbl4wpylvqfc4mrycd211xsi1p97r8r579fccjxpswvsm4bbk";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/nvim-lsp-ts-utils/";
   };
···
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "9661d267f64a872a451dab0453b2b951e55cef27";
-      sha256 = "0hv77ridsxi5n2qibrp9a66kbmlw1c9yl8gpakr1iz2hhazq58x9";
+      rev = "7f902f952944aa708c78138f6536c0dc55aec3a2";
+      sha256 = "1n8srlrfliak2587r30la87x3jgl9iq1x8jdxlhrx7i874ha3ykp";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
   };
···
 
   plenary-nvim = buildVimPluginFrom2Nix {
     pname = "plenary.nvim";
-    version = "2021-10-06";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "nvim-lua";
       repo = "plenary.nvim";
-      rev = "80bb2b9bb74bdca38a46480b6f2e15af990406e4";
-      sha256 = "11akcpxcp4m997a2y76ajknnmsifac2hj4nq9i4a8b1j08bxinim";
+      rev = "901b96d37a30be0504c97cc2c05d3a99b4cca842";
+      sha256 = "14nkpj4x9213waqsy93sdgnll42s4dxxpq5kv6g8w015drjrbwhv";
     };
     meta.homepage = "https://github.com/nvim-lua/plenary.nvim/";
   };
···
 
   rainbow = buildVimPluginFrom2Nix {
     pname = "rainbow";
-    version = "2020-05-28";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "luochen1990";
       repo = "rainbow";
-      rev = "4d15633cdaf61602e1d9fd216a77fc02e0881b2d";
-      sha256 = "168mbdf2h3zhkqrdyyhh0pbkjdvxwida80rdwk8ml97mxxii8ziw";
+      rev = "e96f502eb0e88968858a2cb0348c8e2253637bcc";
+      sha256 = "02lj86yrqjpcs83z4qfh3nhiy4nsq1fdrrcy3x56701zsiml511i";
     };
     meta.homepage = "https://github.com/luochen1990/rainbow/";
   };
···
 
   registers-nvim = buildVimPluginFrom2Nix {
     pname = "registers.nvim";
-    version = "2021-10-16";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "tversteeg";
       repo = "registers.nvim";
-      rev = "6445f9131d872d6bf2236ea301e5d400a96f961d";
-      sha256 = "0g60vks084jcajv1rsjnkn4idcwvzfbwqwnpkcw0xh009p71wyjd";
+      rev = "35227ec930cfa836f9a82bfdc3afc302b68a372f";
+      sha256 = "1pcc5bhacs6h0bxr3ksr6bwdgl75irqwmiwk4l3dwifdj1arhvq7";
     };
     meta.homepage = "https://github.com/tversteeg/registers.nvim/";
   };
···
 
   syntastic = buildVimPluginFrom2Nix {
     pname = "syntastic";
-    version = "2021-09-06";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "vim-syntastic";
       repo = "syntastic";
-      rev = "97bf9ec720662af51ae403b6dfe720d4a24bfcbc";
-      sha256 = "0rcivwwvb6hmd420jkgy8gnzyv78z0bb8gw6232qrwf9m2lskzad";
+      rev = "d086f49d389e1c2d58211b1f92cf20c9f63dc325";
+      sha256 = "0cnd2m1dnx69657dpckiiy1slx2fpnpggm3qs0nzm5rm3qpzx185";
     };
     meta.homepage = "https://github.com/vim-syntastic/syntastic/";
   };
···
 
   vim-fugitive = buildVimPluginFrom2Nix {
     pname = "vim-fugitive";
-    version = "2021-10-17";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-fugitive";
-      rev = "93f41ace7dc068cf89314bcea23bdf8da686407a";
-      sha256 = "0hbif3hndmn7jll4w1kci6x3j7379wmpp9rnxg8rlbbnyxl2fpxj";
+      rev = "4d29c1d6a0def18923b4762c8f85ca3ee5ae6c83";
+      sha256 = "1m8qw6pqgyvfnbph8xwpsvgwdyapsg2abxbpqvsjhcg6ylbxfx17";
     };
     meta.homepage = "https://github.com/tpope/vim-fugitive/";
   };
···
 
   vim-go = buildVimPluginFrom2Nix {
     pname = "vim-go";
-    version = "2021-10-11";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "fatih";
       repo = "vim-go";
-      rev = "f75762b6252fcdcfe6167e895e8171fb1ecfcd34";
-      sha256 = "0xgzl4ms1x9gp6pa5krasks106958cr69kza1ybqy56kbngghzq0";
+      rev = "66ce1595569513a23e3e0dc7aeb8bcacec3b220c";
+      sha256 = "0bcbrbyqbn993g1i5py2ix8rnsvcxzyhn9fbk7c08257l2i7cc6x";
     };
     meta.homepage = "https://github.com/fatih/vim-go/";
   };
···
 
   vim-lsp-cxx-highlight = buildVimPluginFrom2Nix {
     pname = "vim-lsp-cxx-highlight";
-    version = "2021-04-29";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "jackguo380";
       repo = "vim-lsp-cxx-highlight";
-      rev = "9e42350272a413a51ce9a93b00c98682815ff7c1";
-      sha256 = "1nsac8f2c0lj42a77wxcv3k6i8sbpm5ghip6nx7yz0dj7zd4xm10";
+      rev = "679db721db12c2a1c3ae7addf2cc17ae9a26cf08";
+      sha256 = "064sqa11hnnxj6fnnp9dvd7m367ywg6vzwvqxawqv3cwvgr7123w";
     };
     meta.homepage = "https://github.com/jackguo380/vim-lsp-cxx-highlight/";
   };
···
 
   vim-sneak = buildVimPluginFrom2Nix {
     pname = "vim-sneak";
-    version = "2021-07-11";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "justinmk";
       repo = "vim-sneak";
-      rev = "95374ad3e4b5ef902854e8f4bcfa9a7a31a91d71";
-      sha256 = "0ns80kjirk72l5lapl7m32ybyr5q71p2mr8a45ihh1k2dlc2wv06";
+      rev = "94c2de47ab301d476a2baec9ffda07367046bec9";
+      sha256 = "110f06rf1m6p0asr5h4sr80wpwji3krwna5vdn6aakvcr8a7qqdi";
     };
     meta.homepage = "https://github.com/justinmk/vim-sneak/";
   };
···
 
   vim-test = buildVimPluginFrom2Nix {
     pname = "vim-test";
-    version = "2021-10-15";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "vim-test";
       repo = "vim-test";
-      rev = "5fe8ada99a3c711c8db65eb341c3f631043c4a26";
-      sha256 = "1vz28llgmjybg2hgxlv6d9q69f7lhj32id531p2hlnhxl49s9jbn";
+      rev = "2052bd926c37b5c828dd07c47ac676102ca34a0e";
+      sha256 = "1lyx57jryxx5r9s60hg3v6y0kx5p2qc408nl8zhffqhzzmxvkgp9";
     };
     meta.homepage = "https://github.com/vim-test/vim-test/";
   };
···
 
   vim-ultest = buildVimPluginFrom2Nix {
     pname = "vim-ultest";
-    version = "2021-10-05";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "rcarriga";
       repo = "vim-ultest";
-      rev = "7861d1925baef8fe3fa313affdfbdcaa6b2af26f";
-      sha256 = "165klmixdch1nc9cxdldl5yg4q79q58riw0mg0mahqvvr5m1yrw3";
+      rev = "71290da8930cddb946758e108f01a9546c5dda75";
+      sha256 = "0jjb8b20dy65rjfmhhxq4jlcpdfqvmi4ianc6h2m6n08h5a4iw61";
     };
     meta.homepage = "https://github.com/rcarriga/vim-ultest/";
   };
···
 
   vim-unimpaired = buildVimPluginFrom2Nix {
     pname = "vim-unimpaired";
-    version = "2021-09-24";
+    version = "2021-10-18";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-unimpaired";
-      rev = "39f195d7e66141d7f1fa683927547026501e9961";
-      sha256 = "0bbiv32brznns82v8s0s2fylcn4j5d3vw4x2kp5h6zb4lqgya30q";
+      rev = "e4006d68cd4f390efef935bc09be0ce3bd022e72";
+      sha256 = "048n8p7bjpcwdk924glqkwkp10fl813ffrjsagwwzsnakax3da5f";
     };
     meta.homepage = "https://github.com/tpope/vim-unimpaired/";
   };
···
 
   vimtex = buildVimPluginFrom2Nix {
     pname = "vimtex";
-    version = "2021-10-13";
+    version = "2021-10-17";
     src = fetchFromGitHub {
       owner = "lervag";
       repo = "vimtex";
-      rev = "4b3ceb9eb7f0e12c239d7ef4262728491aee89ba";
-      sha256 = "1q3ygk39pbm2bhq463c0rc7zqm5zzg2ln2k1qka1v2i4ghngaszi";
+      rev = "0824ade4187472fcdc1634f462da84b3cfc5931f";
+      sha256 = "0p7308x3yy9n43jhpggqb1vmz39k00ckx3svpxbckwh9y21hjxnc";
     };
     meta.homepage = "https://github.com/lervag/vimtex/";
   };

pkgs/servers/http/nginx/quic.nix

···
 callPackage ./generic.nix args {
   src = fetchhg {
     url = "https://hg.nginx.org/nginx-quic";
-    rev = "5b0c229ba5fe"; # branch=quic
-    sha256 = "1bb6n6b4nkc1cfllj75lwr4gjijl8883bkcvq8ncg7r4s5xs7r90";
+    rev = "404de224517e"; # branch=quic
+    sha256 = "00x8djp3hqnq60jzpddfrj0v23j2fbl27jyw609ha3wqkkbxrip9";
   };
 
   preConfigure = ''

pkgs/tools/backup/btrbk/default.nix

···
-{ lib, stdenv, fetchurl, bash, btrfs-progs, openssh, perl, perlPackages
-, util-linux, asciidoc, asciidoctor, mbuffer, makeWrapper, nixosTests }:
+{ lib
+, stdenv
+, fetchurl
+, bash
+, btrfs-progs
+, openssh
+, perl
+, perlPackages
+, util-linux
+, asciidoc
+, asciidoctor
+, mbuffer
+, makeWrapper
+, genericUpdater
+, curl
+, writeShellScript
+, nixosTests
+}:
 
 stdenv.mkDerivation rec {
   pname = "btrbk";
-  version = "0.29.1";
+  version = "0.31.3";
 
   src = fetchurl {
     url = "https://digint.ch/download/btrbk/releases/${pname}-${version}.tar.xz";
-    sha256 = "153inyvvnl17hq1w3nsa783havznaykdam2yrj775bmi2wg6fvwn";
+    sha256 = "1lx7vnf386nsik8mxrrfyx1h7mkqk5zs26sy0s0lynfxcm4lkxb2";
   };
 
   nativeBuildInputs = [ asciidoc asciidoctor makeWrapper ];
···
     done
 
     # Tainted Mode disables PERL5LIB
-    substituteInPlace btrbk --replace "perl -T" "perl"
+    substituteInPlace btrbk \
+      --replace "perl -T" "perl" \
+      --replace "\$0" "\$ENV{'program_name'}"
 
     # Fix SSH filter script
     sed -i '/^export PATH/d' ssh_filter_btrbk.sh
···
   '';
 
   preFixup = ''
-    wrapProgram $out/sbin/btrbk \
+    wrapProgram $out/bin/btrbk \
       --set PERL5LIB $PERL5LIB \
+      --run 'export program_name=$0' \
       --prefix PATH ':' "${lib.makeBinPath [ btrfs-progs bash mbuffer openssh ]}"
   '';
 
   passthru.tests.btrbk = nixosTests.btrbk;
 
+  passthru.updateScript = genericUpdater {
+    inherit pname version;
+    versionLister = writeShellScript "btrbk-versionLister" ''
+      echo "# Versions for $1:" >> "$2"
+      ${curl}/bin/curl -s https://digint.ch/download/btrbk/releases/ | ${perl}/bin/perl -lne 'print $1 if /btrbk-([0-9.]*)\.tar/'
+    '';
+  };
+
   meta = with lib; {
     description = "A backup tool for btrfs subvolumes";
     homepage = "https://digint.ch/btrbk";
-    license = licenses.gpl3;
+    license = licenses.gpl3Only;
     platforms = platforms.unix;
     maintainers = with maintainers; [ asymmetric ];
   };

pkgs/tools/misc/bandwidth/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "bandwidth";
-  version = "1.10.1";
+  version = "1.10.4";
 
   src = fetchurl {
     url = "https://zsmith.co/archives/${pname}-${version}.tar.gz";
-    sha256 = "sha256-trya+/cBNIittQAc5tcykZbImeISqIolO/Y8uOI0jGk=";
+    sha256 = "sha256-e/eP2rA7ElFrh2Z4qTzRGR/cxY1UI6s+LQ9Og1x46/I=";
   };
 
   postPatch = ''

pkgs/tools/misc/lesspipe/default.nix

···
-{ lib, stdenv, fetchFromGitHub, substituteAll, perl, file, ncurses }:
+{ lib, stdenv, fetchFromGitHub, substituteAll, perl, file, ncurses, bash }:
 
 stdenv.mkDerivation rec {
   pname = "lesspipe";
   version = "1.85";
 
-  buildInputs = [ perl ];
-  preConfigure = "patchShebangs .";
+  nativeBuildInputs = [ perl ];
+  buildInputs = [ perl bash ];
+  strictDeps = true;
+  preConfigure = ''
+    patchShebangs --build configure
+  '';
+  configureFlags = [ "--shell=${bash}/bin/bash" "--yes" ];
+  configurePlatforms = [];
+  dontBuild = true;
 
   src = fetchFromGitHub {
     owner = "wofr06";
···
       file = "${file}/bin/file";
       tput = "${ncurses}/bin/tput";
     })
+    ./override-shell-detection.patch
   ];
 
   meta = with lib; {

pkgs/tools/misc/lesspipe/override-shell-detection.patch

···
+--- a/configure
++++ b/configure
+@@ -101,7 +101,8 @@
+ open OUT, ">lesspipe.sh.tmp";
+ my $in = 1;
+ my $anyin;
+-my $shell = check_shell_vers();
++my $shell = $opt_shell;
++print OUT "#!$shell\n";
+ # ask if syntax highlighting should be included
+ $ifsyntax = '';
+ if ($opt_yes) {

pkgs/tools/networking/vopono/default.nix

···
+{ lib
+, fetchCrate
+, rustPlatform
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "vopono";
+  version = "0.8.6";
+
+  src = fetchCrate {
+    inherit pname version;
+    sha256 = "0dsyav755mggnsybj7iwvdqbqzz0gfd3j9vh0hmg5b7pbffanzvy";
+  };
+
+  cargoHash = "sha256:187mi36dgr2f1klqclci175zqgyrm0b6awrcnav63vira7hqz076";
+
+  meta = with lib; {
+    description = "Run applications through VPN connections in network namespaces";
+    homepage = "https://github.com/jamesmcm/vopono";
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.romildo ];
+  };
+}

pkgs/tools/networking/ytcc/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "ytcc";
-  version = "2.5.0";
+  version = "2.5.1";
 
   src = fetchFromGitHub {
     owner = "woefe";
     repo = "ytcc";
     rev = "v${version}";
-    sha256 = "0d5zlj5c9n8kq38sq2napc2pnqq866v8jpsyg07q5yjcjwlmihap";
+    sha256 = "1w2frcy51kwsvd486awhpl5kkm11zj1nw3nnv9337316gfs213nw";
   };
 
   nativeBuildInputs = [ gettext ];

pkgs/tools/system/auto-cpufreq/default.nix

···
 
 python3Packages.buildPythonPackage rec {
   pname = "auto-cpufreq";
-  version = "1.7.0";
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "AdnanHodzic";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0b6j26glg1ffihdr2h7dlr1lrbhkclgp17dxmkjgg5gk4mhz799r";
+    sha256 = "1r27ydv258c6pc82za0wq8q8fj0j3r50c8wxc6r7dwr6wx8q3asx";
   };
 
   propagatedBuildInputs = with python3Packages; [ click distro psutil ];

pkgs/tools/wayland/swaycwd/default.nix

···
-{ lib, nimPackages, fetchFromGitLab
+{ lib
+, nimPackages
+, fetchFromGitLab
 , enableShells ? [ "bash" "zsh" "fish" "sh" "posh" ]
 }:
+nimPackages.buildNimPackage rec{
 
-nimPackages.buildNimPackage {
-    name = "swaycwd";
-    version = "0.0.1";
+  name = "swaycwd";
+  version = "0.0.2";
 
-    src = fetchFromGitLab {
-      owner = "cab404";
-      repo = "swaycwd";
-      rev = "aca81695ec2102b9bca6f5bae364f69a8b9d399f";
-      hash = "sha256-MkyY3wWByQo0l0J28xKDfGtxfazVPRyZHCObl9Fszh4=";
-    };
+  src = fetchFromGitLab {
+    owner = "cab404";
+    repo = name;
+    rev = "v${version}";
+    hash = "sha256-OZWOPtOqcX+fVQCxWntrn98EzFu70WH55rfYCPDMSKk=";
+  };
 
-    preConfigure = ''
-      {
-        echo 'let enabledShells: seq[string] = @${builtins.toJSON enableShells}'
-        echo 'export enabledShells'
-      } > shells.nim
-      cat << EOF > swaycwd.nimble
-      srcDir = "."
-      bin = "swaycwd"
-      EOF
-    '';
+  preConfigure = ''
+    {
+      echo 'let enabledShells: seq[string] = @${builtins.toJSON enableShells}'
+      echo 'export enabledShells'
+    } > shells.nim
+    cat << EOF > swaycwd.nimble
+    srcDir = "."
+    bin = "swaycwd"
+    EOF
+  '';
 
-    nimFlags = [ "--opt:speed" ];
+  nimFlags = [ "--opt:speed" ];
 
-    meta = with lib; {
-      homepage = "https://gitlab.com/cab404/swaycwd";
-      description = "Returns cwd for shell in currently focused sway window, or home directory if cannot find shell";
-      maintainers = with maintainers; [ cab404 ];
-      platforms = platforms.linux;
-      license = licenses.gpl3Only;
-    };
+  meta = with lib; {
+    homepage = "https://gitlab.com/cab404/swaycwd";
+    description = "Returns cwd for shell in currently focused sway window, or home directory if cannot find shell";
+    maintainers = with maintainers; [ cab404 ];
+    platforms = platforms.linux;
+    license = licenses.gpl3Only;
+  };
 }

pkgs/top-level/aliases.nix

···
   google-musicmanager = throw "google-musicmanager has been removed because Google Play Music was discontinued"; # added 2021-03-07
   googleAuthenticator = google-authenticator; # added 2016-10-16
   grantlee5 = libsForQt5.grantlee;  # added 2015-12-19
+  graalvm8 = graalvm8-ce;
+  graalvm11 = graalvm11-ce;
   gsettings_desktop_schemas = gsettings-desktop-schemas; # added 2018-02-25
   gtk_doc = gtk-doc; # added 2018-02-25
   guileCairo = guile-cairo; # added 2017-09-24
···
   jbuilder = dune_1; # added 2018-09-09
   jikes = throw "jikes was deprecated on 2019-10-07: abandoned by upstream";
   joseki = apache-jena-fuseki; # added 2016-02-28
+  jvmci8 = throw "graalvm8 and its tools were deprecated in favor of graalvm8-ce"; # added 2021-10-15
   json_glib = json-glib; # added 2018-02-25
   kdecoration-viewer = throw "kdecoration-viewer has been removed from nixpkgs, as there is no upstream activity"; # 2020-06-16
   k9copy = throw "k9copy has been removed from nixpkgs, as there is no upstream activity"; # 2020-11-06
···
   mpv-with-scripts = self.wrapMpv self.mpv-unwrapped { }; # added 2020-05-22
   multipath_tools = multipath-tools;  # added 2016-01-21
   mupen64plus1_5 = mupen64plus; # added 2016-02-12
+  mx = throw "graalvm8 and its tools were deprecated in favor of graalvm8-ce"; # added 2021-10-15
   mxisd = throw "mxisd has been removed from nixpkgs as it has reached end of life, see https://github.com/kamax-matrix/mxisd/blob/535e0a5b96ab63cb0ddef90f6f42c5866407df95/EOL.md#end-of-life-notice . ma1sd may be a suitable alternative."; # added 2021-04-15
   mysqlWorkbench = mysql-workbench; # added 2017-01-19
   nagiosPluginsOfficial = monitoring-plugins;

pkgs/top-level/all-packages.nix

···
 
   ventoy-bin = callPackage ../tools/cd-dvd/ventoy-bin { };
 
+  vopono = callPackage ../tools/networking/vopono { };
+
   xcd = callPackage ../tools/misc/xcd { };
 
   xtrt = callPackage ../tools/archivers/xtrt { };
···
 
   git-fame = callPackage ../applications/version-management/git-and-tools/git-fame {};
 
-  git-fast-export = callPackage ../applications/version-management/git-and-tools/fast-export { mercurial = mercurial_4; };
+  git-fast-export = callPackage ../applications/version-management/git-and-tools/fast-export { };
 
   git-filter-repo = callPackage ../applications/version-management/git-and-tools/git-filter-repo {
     pythonPackages = python3Packages;
···
 
   runelite = callPackage ../games/runelite { };
 
+  runescape = callPackage ../games/runescape-launcher { };
+
   runningx = callPackage ../tools/X11/runningx { };
 
   rund = callPackage ../development/tools/rund { };
···
 
   wasm-bindgen-cli = callPackage ../development/tools/wasm-bindgen-cli {
     inherit (darwin.apple_sdk.frameworks) Security;
+    nodejs = nodejs_latest;
   };
 
   welkin = callPackage ../tools/graphics/welkin {};
···
 
   openjdk = openjdk16;
   openjdk_headless = openjdk16_headless;
-
-  inherit (callPackages ../development/compilers/graalvm {
-    gcc = if stdenv.targetPlatform.isDarwin then gcc8 else gcc;
-    inherit (darwin.apple_sdk.frameworks)
-      CoreFoundation Foundation JavaNativeFoundation
-      JavaVM JavaRuntimeSupport Cocoa;
-    inherit (darwin) libiconv libobjc libresolv;
-  }) mx jvmci8 graalvm8;
 
   graalvmCEPackages =
     recurseIntoAttrs (callPackage ../development/compilers/graalvm/community-edition {
···
 
   ucs-fonts = callPackage ../data/fonts/ucs-fonts
     { inherit (buildPackages.xorg) fonttosfnt mkfontscale; };
+
+  bront_fonts = callPackage ../data/fonts/bront { };
 
   ultimate-oldschool-pc-font-pack = callPackage ../data/fonts/ultimate-oldschool-pc-font-pack { };
 

pkgs/top-level/ocaml-packages.nix

···
 
     yaml = callPackage ../development/ocaml-modules/yaml { };
 
+    yaml-sexp = callPackage ../development/ocaml-modules/yaml/yaml-sexp.nix { };
+
     yojson = callPackage ../development/ocaml-modules/yojson { };
 
     z3 = callPackage ../development/ocaml-modules/z3 {

pkgs/top-level/release-haskell.nix

···
   compilerNames = lib.mapAttrs (name: _: name) pkgs.haskell.packages;
 
   # list of all compilers to test specific packages on
-  all = with compilerNames; [
+  released = with compilerNames; [
     ghc884
     ghc8107
     ghc901
···
       # and to confirm that critical packages for the
       # package sets (like Cabal, jailbreak-cabal) are
       # working as expected.
-      cabal-install = all;
-      Cabal_3_6_2_0 = with compilerNames; [ ghc884 ghc8107 ghc901 ghc921 ];
-      cabal2nix-unstable = all;
-      funcmp = all;
-      haskell-language-server = all;
-      hoogle = all;
-      hsdns = all;
-      jailbreak-cabal = all;
-      language-nix = all;
-      nix-paths = all;
-      titlecase = all;
-      ghc-api-compat = all;
+      cabal-install = released ++ [ compilerNames.ghc921 ];
+      Cabal_3_6_2_0 = released ++ [ compilerNames.ghc921 ];
+      cabal2nix = released ++ [ compilerNames.ghc921 ];
+      cabal2nix-unstable = released ++ [ compilerNames.ghc921 ];
+      funcmp = released ++ [ compilerNames.ghc921 ];
+      haskell-language-server = released;
+      hoogle = released;
+      hsdns = released ++ [ compilerNames.ghc921 ];
+      jailbreak-cabal = released ++ [ compilerNames.ghc921 ];
+      language-nix = released ++ [ compilerNames.ghc921 ];
+      nix-paths = released ++ [ compilerNames.ghc921 ];
+      titlecase = released ++ [ compilerNames.ghc921 ];
+      ghc-api-compat = released;
     })
     {
       mergeable = pkgs.releaseTools.aggregate {