Merge master into staging-next

doc/build-helpers/fetchers.chapter.md

···
 
 Used with Git. Expects `url` to a Git repo, `rev`, and `hash`. `rev` in this case can be full the git commit id (SHA1 hash) or a tag name like `refs/tags/v1.0`.
 
+If you want to fetch a tag you should pass the `tag` parameter instead of `rev` which has the same effect as setting `rev = "refs/tags"/${version}"`.
+This is safer than just setting `rev = version` w.r.t. possible branch and tag name conflicts.
+
 Additionally, the following optional arguments can be given:
 
 *`fetchSubmodules`* (Boolean)
···
 
 ## `fetchFromGitHub` {#fetchfromgithub}
 
-`fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `hash` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available, but `hash` is currently preferred.
+`fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. If you need to fetch a tag however, you should prefer to use the `tag` parameter which achieves this in a safer way with less boilerplate. Finally, `hash` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available, but `hash` is currently preferred.
 
 To use a different GitHub instance, use `githubBase` (defaults to `"github.com"`).
 

doc/languages-frameworks/dotnet.section.md

···
   name = "dotnet-env";
   packages = [
     (with dotnetCorePackages; combinePackages [
-      sdk_6_0
-      sdk_7_0
+      sdk_8_0
+      sdk_9_0
     ])
   ];
 }
 ```
 
-This will produce a dotnet installation that has the dotnet 6.0 7.0 sdk. The first sdk listed will have it's cli utility present in the resulting environment. Example info output:
+This will produce a dotnet installation that has the dotnet 8.0 9.0 sdk. The first sdk listed will have it's cli utility present in the resulting environment. Example info output:
 
 ```ShellSession
 $ dotnet --info
 .NET SDK:
- Version:   7.0.202
- Commit:    6c74320bc3
+ Version:           9.0.100
+ Commit:            59db016f11
+ Workload version:  9.0.100-manifests.3068a692
+ MSBuild version:   17.12.7+5b8665660
 
 Runtime Environment:
  OS Name:     nixos
- OS Version:  23.05
+ OS Version:  25.05
  OS Platform: Linux
  RID:         linux-x64
- Base Path:   /nix/store/n2pm44xq20hz7ybsasgmd7p3yh31gnh4-dotnet-sdk-7.0.202/sdk/7.0.202/
+ Base Path:   /nix/store/a03c70i7x6rjdr6vikczsp5ck3v6rixh-dotnet-sdk-9.0.100/share/dotnet/sdk/9.0.100/
+
+.NET workloads installed:
+There are no installed workloads to display.
+Configured to use loose manifests when installing new manifests.
 
 Host:
-  Version:      7.0.4
+  Version:      9.0.0
   Architecture: x64
-  Commit:       0a396acafe
+  Commit:       9d5a6a9aa4
 
 .NET SDKs installed:
-  6.0.407 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/sdk]
-  7.0.202 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/sdk]
+  8.0.404 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/sdk]
+  9.0.100 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/sdk]
 
 .NET runtimes installed:
-  Microsoft.AspNetCore.App 6.0.15 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/shared/Microsoft.AspNetCore.App]
-  Microsoft.AspNetCore.App 7.0.4 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/shared/Microsoft.AspNetCore.App]
-  Microsoft.NETCore.App 6.0.15 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/shared/Microsoft.NETCore.App]
-  Microsoft.NETCore.App 7.0.4 [/nix/store/3b19303vwrhv0xxz1hg355c7f2hgxxgd-dotnet-core-combined/shared/Microsoft.NETCore.App]
+  Microsoft.AspNetCore.App 8.0.11 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/shared/Microsoft.AspNetCore.App]
+  Microsoft.AspNetCore.App 9.0.0 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/shared/Microsoft.AspNetCore.App]
+  Microsoft.NETCore.App 8.0.11 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/shared/Microsoft.NETCore.App]
+  Microsoft.NETCore.App 9.0.0 [/nix/store/6wlrjiy10wg766490dcmp6x64zb1vc8j-dotnet-core-combined/share/dotnet/shared/Microsoft.NETCore.App]
 
 Other architectures found:
   None
···
 
   buildInputs = [ referencedProject ]; # `referencedProject` must contain `nupkg` in the folder structure.
 
-  dotnet-sdk = dotnetCorePackages.sdk_6_0;
-  dotnet-runtime = dotnetCorePackages.runtime_6_0;
+  dotnet-sdk = dotnetCorePackages.sdk_8_0;
+  dotnet-runtime = dotnetCorePackages.runtime_8_0;
 
   executables = [ "foo" ]; # This wraps "$out/lib/$pname/foo" to `$out/bin/foo`.
   executables = []; # Don't install any executables.

maintainers/maintainer-list.nix

···
     githubId = 6987136;
     keys = [ { fingerprint = "2C6D 37D4 6AA1 DCDA BE8D  F346 43E2 CF4C 01B9 4940"; } ];
   };
+  BastianAsmussen = {
+    name = "Bastian Asmussen";
+    email = "[e-mail]";
+    github = "BastianAsmussen";
+    githubId = 76102128;
+    keys = [ { fingerprint = "3B11 7469 0893 85E7 16C2  7CD9 0FE5 A355 DBC9 2568"; } ];
+  };
   basvandijk = {
     email = "[e-mail]";
     github = "basvandijk";
···
     github = "DianaOlympos";
     githubId = 15774340;
     name = "Thomas Depierre";
+  };
+  DictXiong = {
+    email = "[e-mail]";
+    github = "DictXiong";
+    githubId = 41772157;
+    name = "Dict Xiong";
   };
   diegolelis = {
     email = "[e-mail]";
···
     githubId = 1202012;
     name = "Ignat Loskutov";
   };
+  lostmsu = {
+    email = "[e-mail]";
+    github = "lostmsu";
+    githubId = 239520;
+    matrix = "@lostmsu:matrix.org";
+    name = "Victor Nova";
+  };
   lostnet = {
     email = "[e-mail]";
     github = "lostnet";
···
     githubId = 293035;
     name = "Shawn Dellysse";
   };
+  ShawnToubeau = {
+    name = "Shawn Toubeau";
+    email = "[e-mail]";
+    github = "ShawnToubeau";
+    githubId = 22332636;
+  };
   shayne = {
     email = "[e-mail]";
     github = "shayne";
···
     github = "traverseda";
     githubId = 2125828;
     name = "Alex Davies";
+  };
+  travgm = {
+    email = "[e-mail]";
+    github = "travgm";
+    githubId = 99630881;
+    name = "Travis Montoya";
   };
   travisbhartwell = {
     email = "[e-mail]";

nixos/modules/services/databases/victoriametrics.nix

···
       serviceConfig = {
         ExecStart = lib.escapeShellArgs (
           startCLIList
-          ++ lib.optionals (cfg.prometheusConfig != null) [ "-promscrape.config=${prometheusConfigYml}" ]
+          ++ lib.optionals (cfg.prometheusConfig != {}) [ "-promscrape.config=${prometheusConfigYml}" ]
         );
 
         DynamicUser = true;

nixos/modules/services/monitoring/vmagent.nix

···
         CacheDirectory = "vmagent";
         ExecStart = lib.escapeShellArgs (
           startCLIList
-          ++ lib.optionals (cfg.prometheusConfig != null) ["-promscrape.config=${prometheusConfigYml}"]
+          ++ lib.optionals (cfg.prometheusConfig != {}) ["-promscrape.config=${prometheusConfigYml}"]
         );
         LoadCredential = lib.optional (cfg.remoteWrite.basicAuthPasswordFile != null) [
           "remote_write_basic_auth_password:${cfg.remoteWrite.basicAuthPasswordFile}"

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

···
 { config, lib, pkgs, ... }:
 
-with lib;
 let
+  inherit (lib)
+    any
+    attrsets
+    attrByPath
+    catAttrs
+    collect
+    concatMapStrings
+    concatStringsSep
+    escape
+    escapeShellArg
+    escapeShellArgs
+    hasInfix
+    isAttrs
+    isList
+    isStorePath
+    isString
+    mapAttrs
+    mapAttrsToList
+    optionalString
+    optionals
+    replaceStrings
+    splitString
+    substring
+    versionOlder
+
+    fileContents
+    readFile
+
+    literalExpression
+    literalMD
+    mkBefore
+    mkEnableOption
+    mkIf
+    mkMerge
+    mkOption
+    mkOptionType
+    mkPackageOption
+    types;
+
   cfg = config.services.akkoma;
   ex = cfg.config;
   db = ex.":pleroma"."Pleroma.Repo";
   web = ex.":pleroma"."Pleroma.Web.Endpoint";
+
+  format = pkgs.formats.elixirConf { elixir = cfg.package.elixirPackage; };
+  inherit (format.lib)
+    mkAtom
+    mkMap
+    mkRaw
+    mkTuple;
 
   isConfined = config.systemd.services.akkoma.confinement.enable;
   hasSmtp = (attrByPath [ ":pleroma" "Pleroma.Emails.Mailer" "adapter" "value" ] null ex) == "Swoosh.Adapters.SMTP";
···
       passAsFile = [ "code" ];
     } ''elixir "$codePath" >"$out"'');
 
-  format = pkgs.formats.elixirConf { elixir = cfg.package.elixirPackage; };
   configFile = format.generate "config.exs"
     (replaceSec
       (attrsets.updateManyAttrsByPath [{
         path = [ ":pleroma" "Pleroma.Web.Endpoint" "http" "ip" ];
         update = addr:
           if isAbsolutePath addr
-            then format.lib.mkTuple
-              [ (format.lib.mkAtom ":local") addr ]
-            else format.lib.mkRaw (erlAddr addr);
+            then mkTuple
+              [ (mkAtom ":local") addr ]
+            else mkRaw (erlAddr addr);
       }] cfg.config));
 
   writeShell = { name, text, runtimeInputs ? [ ] }:
···
         AKKOMA_CONFIG_PATH="''${RUNTIME_DIRECTORY%%:*}/config.exs" \
         ERL_EPMD_ADDRESS="${cfg.dist.address}" \
         ERL_EPMD_PORT="${toString cfg.dist.epmdPort}" \
-        ERL_FLAGS=${lib.escapeShellArg (lib.escapeShellArgs ([
+        ERL_FLAGS=${escapeShellArg (escapeShellArgs ([
           "-kernel" "inet_dist_use_interface" (erlAddr cfg.dist.address)
           "-kernel" "inet_dist_listen_min" (toString cfg.dist.portMin)
           "-kernel" "inet_dist_listen_max" (toString cfg.dist.portMax)
···
               "Pleroma.Repo" = mkOption {
                 type = elixirValue;
                 default = {
-                  adapter = format.lib.mkRaw "Ecto.Adapters.Postgres";
+                  adapter = mkRaw "Ecto.Adapters.Postgres";
                   socket_dir = "/run/postgresql";
                   username = cfg.user;
                   database = "akkoma";
···
               in {
                 base_url = mkOption {
                     type = types.nonEmptyStr;
-                    default = if lib.versionOlder config.system.stateVersion "24.05"
+                    default = if versionOlder config.system.stateVersion "24.05"
                               then "${httpConf.scheme}://${httpConf.host}:${builtins.toString httpConf.port}/media/"
                               else null;
                     defaultText = literalExpression ''
···
               ":frontends" = mkOption {
                 type = elixirValue;
                 default = mapAttrs
-                  (key: val: format.lib.mkMap { name = val.name; ref = val.ref; })
+                  (key: val: mkMap { name = val.name; ref = val.ref; })
                   cfg.frontends;
                 defaultText = literalExpression ''
                   lib.mapAttrs (key: val:
···
                 };
                 base_url = mkOption {
                     type = types.nullOr types.nonEmptyStr;
-                    default = if lib.versionOlder config.system.stateVersion "24.05"
+                    default = if versionOlder config.system.stateVersion "24.05"
                               then "${httpConf.scheme}://${httpConf.host}:${builtins.toString httpConf.port}"
                               else null;
                     defaultText = literalExpression ''
···
               ":backends" = mkOption {
                 type = types.listOf elixirValue;
                 visible = false;
-                default = with format.lib; [
+                default = [
                   (mkTuple [ (mkRaw "ExSyslogger") (mkAtom ":ex_syslogger") ])
                 ];
               };
···
 
                 level = mkOption {
                   type = types.nonEmptyStr;
-                  apply = format.lib.mkAtom;
+                  apply = mkAtom;
                   default = ":info";
                   example = ":warning";
                   description = ''
···
               ":data_dir" = mkOption {
                 type = elixirValue;
                 internal = true;
-                default = format.lib.mkRaw ''
+                default = mkRaw ''
                   Path.join(System.fetch_env!("CACHE_DIRECTORY"), "tzdata")
                 '';
               };
···
     };
   };
 
-  meta.maintainers = with maintainers; [ mvs ];
+  meta.maintainers = with lib.maintainers; [ mvs ];
   meta.doc = ./akkoma.md;
 }

nixos/modules/virtualisation/oci-containers.nix

···
-{ config, options, lib, pkgs, ... }:
+{
+  config,
+  options,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 let
···
   defaultBackend = options.virtualisation.oci-containers.backend.default;
 
   containerOptions =
-    { ... }: {
+    { ... }:
+    {
 
       options = {
 
···
         };
 
         cmd = mkOption {
-          type =  with types; listOf str;
-          default = [];
+          type = with types; listOf str;
+          default = [ ];
           description = "Commandline arguments to pass to the image's entrypoint.";
           example = literalExpression ''
             ["--port=9000"]
···
 
         labels = mkOption {
           type = with types; attrsOf str;
-          default = {};
+          default = { };
           description = "Labels to attach to the container at runtime.";
           example = literalExpression ''
             {
···
 
         environment = mkOption {
           type = with types; attrsOf str;
-          default = {};
+          default = { };
           description = "Environment variables to set for this container.";
           example = literalExpression ''
             {
               DATABASE_HOST = "db.example.com";
               DATABASE_PORT = "3306";
             }
-        '';
+          '';
         };
 
         environmentFiles = mkOption {
           type = with types; listOf path;
-          default = [];
+          default = [ ];
           description = "Environment files for this container.";
           example = literalExpression ''
             [
               /path/to/.env
               /path/to/.env.secret
             ]
-        '';
+          '';
         };
 
         log-driver = mkOption {
···
 
         ports = mkOption {
           type = with types; listOf str;
-          default = [];
+          default = [ ];
           description = ''
             Network ports to publish from the container to the outer host.
 
···
 
         volumes = mkOption {
           type = with types; listOf str;
-          default = [];
+          default = [ ];
           description = ''
             List of volumes to attach to this container.
 
···
 
         dependsOn = mkOption {
           type = with types; listOf str;
-          default = [];
+          default = [ ];
           description = ''
             Define which other containers this one depends on. They will be added to both After and Requires for the unit.
 
···
 
         preRunExtraOptions = mkOption {
           type = with types; listOf str;
-          default = [];
+          default = [ ];
           description = "Extra options for {command}`${defaultBackend}` that go before the `run` argument.";
-          example = [ "--runtime" "runsc" ];
+          example = [
+            "--runtime"
+            "runsc"
+          ];
         };
 
         extraOptions = mkOption {
           type = with types; listOf str;
-          default = [];
+          default = [ ];
           description = "Extra options for {command}`${defaultBackend} run`.";
           example = literalExpression ''
             ["--network=host"]
···
         };
 
         autoStart = mkOption {
-          type = types.bool;
+          type = with types; bool;
           default = true;
           description = ''
             When enabled, the container is automatically started on boot.
             If this option is set to false, the container has to be started on-demand via its service.
           '';
         };
+
+        pull = mkOption {
+          type =
+            with types;
+            enum [
+              "always"
+              "missing"
+              "never"
+              "newer"
+            ];
+          default = "missing";
+          description = ''
+            Image pull policy for the container. Must be one of: always, missing, never, newer
+          '';
+        };
+
+        capAdd = mkOption {
+          type = with types; lazyAttrsOf (nullOr bool);
+          default = { };
+          description = ''
+            Capabilities to add to container
+          '';
+          example = literalExpression ''
+            {
+              SYS_ADMIN = true;
+            {
+          '';
+        };
+
+        capDrop = mkOption {
+          type = with types; lazyAttrsOf (nullOr bool);
+          default = { };
+          description = ''
+            Capabilities to drop from container
+          '';
+          example = literalExpression ''
+            {
+              SYS_ADMIN = true;
+            {
+          '';
+        };
+
+        devices = mkOption {
+          type = with types; listOf str;
+          default = [ ];
+          description = ''
+            List of devices to attach to this container.
+          '';
+          example = literalExpression ''
+            [
+              "/dev/dri:/dev/dri"
+            ]
+          '';
+        };
+
+        privileged = mkOption {
+          type = with types; bool;
+          default = false;
+          description = ''
+            Give extended privileges to the container
+          '';
+        };
+
+        networks = mkOption {
+          type = with types; listOf str;
+          default = [ ];
+          description = ''
+            Networks to attach the container to
+          '';
+        };
       };
     };
 
-  isValidLogin = login: login.username != null && login.passwordFile != null && login.registry != null;
+  isValidLogin =
+    login: login.username != null && login.passwordFile != null && login.registry != null;
 
-  mkService = name: container: let
-    dependsOn = map (x: "${cfg.backend}-${x}.service") container.dependsOn;
-    escapedName = escapeShellArg name;
-    preStartScript = pkgs.writeShellApplication {
-      name = "pre-start";
-      runtimeInputs = [ ];
-      text = ''
-        ${cfg.backend} rm -f ${name} || true
-        ${optionalString (isValidLogin container.login) ''
-          # try logging in, if it fails, check if image exists locally
-          ${cfg.backend} login \
-          ${container.login.registry} \
-          --username ${container.login.username} \
-          --password-stdin < ${container.login.passwordFile} \
-          || ${cfg.backend} image inspect ${container.image} >/dev/null \
-          || { echo "image doesn't exist locally and login failed" >&2 ; exit 1; }
-        ''}
-        ${optionalString (container.imageFile != null) ''
-          ${cfg.backend} load -i ${container.imageFile}
-        ''}
-        ${optionalString (container.imageStream != null) ''
-          ${container.imageStream} | ${cfg.backend} load
-        ''}
-        ${optionalString (cfg.backend == "podman") ''
-          rm -f /run/podman-${escapedName}.ctr-id
-        ''}
-      '';
-    };
-  in {
-    wantedBy = [] ++ optional (container.autoStart) "multi-user.target";
-    wants = lib.optional (container.imageFile == null && container.imageStream == null)  "network-online.target";
-    after = lib.optionals (cfg.backend == "docker") [ "docker.service" "docker.socket" ]
-            # if imageFile or imageStream is not set, the service needs the network to download the image from the registry
-            ++ lib.optionals (container.imageFile == null && container.imageStream == null) [ "network-online.target" ]
-            ++ dependsOn;
-    requires = dependsOn;
-    environment = proxy_env;
+  mkService =
+    name: container:
+    let
+      dependsOn = map (x: "${cfg.backend}-${x}.service") container.dependsOn;
+      escapedName = escapeShellArg name;
+      preStartScript = pkgs.writeShellApplication {
+        name = "pre-start";
+        runtimeInputs = [ ];
+        text = ''
+          ${cfg.backend} rm -f ${name} || true
+          ${optionalString (isValidLogin container.login) ''
+            # try logging in, if it fails, check if image exists locally
+            ${cfg.backend} login \
+            ${container.login.registry} \
+            --username ${container.login.username} \
+            --password-stdin < ${container.login.passwordFile} \
+            || ${cfg.backend} image inspect ${container.image} >/dev/null \
+            || { echo "image doesn't exist locally and login failed" >&2 ; exit 1; }
+          ''}
+          ${optionalString (container.imageFile != null) ''
+            ${cfg.backend} load -i ${container.imageFile}
+          ''}
+          ${optionalString (container.imageStream != null) ''
+            ${container.imageStream} | ${cfg.backend} load
+          ''}
+          ${optionalString (cfg.backend == "podman") ''
+            rm -f /run/podman-${escapedName}.ctr-id
+          ''}
+        '';
+      };
+    in
+    {
+      wantedBy = [ ] ++ optional (container.autoStart) "multi-user.target";
+      wants = lib.optional (
+        container.imageFile == null && container.imageStream == null
+      ) "network-online.target";
+      after =
+        lib.optionals (cfg.backend == "docker") [
+          "docker.service"
+          "docker.socket"
+        ]
+        # if imageFile or imageStream is not set, the service needs the network to download the image from the registry
+        ++ lib.optionals (container.imageFile == null && container.imageStream == null) [
+          "network-online.target"
+        ]
+        ++ dependsOn;
+      requires = dependsOn;
+      environment = proxy_env;
 
-    path =
-      if cfg.backend == "docker" then [ config.virtualisation.docker.package ]
-      else if cfg.backend == "podman" then [ config.virtualisation.podman.package ]
-      else throw "Unhandled backend: ${cfg.backend}";
+      path =
+        if cfg.backend == "docker" then
+          [ config.virtualisation.docker.package ]
+        else if cfg.backend == "podman" then
+          [ config.virtualisation.podman.package ]
+        else
+          throw "Unhandled backend: ${cfg.backend}";
 
-    script = concatStringsSep " \\\n  " ([
-      "exec ${cfg.backend} "
-    ]  ++ map escapeShellArg container.preRunExtraOptions ++ [
-      "run"
-      "--rm"
-      "--name=${escapedName}"
-      "--log-driver=${container.log-driver}"
-    ] ++ optional (container.entrypoint != null)
-      "--entrypoint=${escapeShellArg container.entrypoint}"
-      ++ optional (container.hostname != null)
-      "--hostname=${escapeShellArg container.hostname}"
-      ++ lib.optionals (cfg.backend == "podman") [
-        "--cidfile=/run/podman-${escapedName}.ctr-id"
-        "--cgroups=no-conmon"
-        "--sdnotify=conmon"
-        "-d"
-        "--replace"
-      ] ++ (mapAttrsToList (k: v: "-e ${escapeShellArg k}=${escapeShellArg v}") container.environment)
-      ++ map (f: "--env-file ${escapeShellArg f}") container.environmentFiles
-      ++ map (p: "-p ${escapeShellArg p}") container.ports
-      ++ optional (container.user != null) "-u ${escapeShellArg container.user}"
-      ++ map (v: "-v ${escapeShellArg v}") container.volumes
-      ++ (mapAttrsToList (k: v: "-l ${escapeShellArg k}=${escapeShellArg v}") container.labels)
-      ++ optional (container.workdir != null) "-w ${escapeShellArg container.workdir}"
-      ++ map escapeShellArg container.extraOptions
-      ++ [container.image]
-      ++ map escapeShellArg container.cmd
-    );
+      script = concatStringsSep " \\\n  " (
+        [
+          "exec ${cfg.backend} "
+        ]
+        ++ map escapeShellArg container.preRunExtraOptions
+        ++ [
+          "run"
+          "--rm"
+          "--name=${escapedName}"
+          "--log-driver=${container.log-driver}"
+        ]
+        ++ optional (container.entrypoint != null) "--entrypoint=${escapeShellArg container.entrypoint}"
+        ++ optional (container.hostname != null) "--hostname=${escapeShellArg container.hostname}"
+        ++ lib.optionals (cfg.backend == "podman") [
+          "--cidfile=/run/podman-${escapedName}.ctr-id"
+          "--cgroups=no-conmon"
+          "--sdnotify=conmon"
+          "-d"
+          "--replace"
+        ]
+        ++ (mapAttrsToList (k: v: "-e ${escapeShellArg k}=${escapeShellArg v}") container.environment)
+        ++ map (f: "--env-file ${escapeShellArg f}") container.environmentFiles
+        ++ map (p: "-p ${escapeShellArg p}") container.ports
+        ++ optional (container.user != null) "-u ${escapeShellArg container.user}"
+        ++ map (v: "-v ${escapeShellArg v}") container.volumes
+        ++ (mapAttrsToList (k: v: "-l ${escapeShellArg k}=${escapeShellArg v}") container.labels)
+        ++ optional (container.workdir != null) "-w ${escapeShellArg container.workdir}"
+        ++ optional (container.privileged) "--privileged"
+        ++ mapAttrsToList (k: _: "--cap-add=${escapeShellArg k}") (
+          filterAttrs (_: v: v == true) container.capAdd
+        )
+        ++ mapAttrsToList (k: _: "--cap-drop=${escapeShellArg k}") (
+          filterAttrs (_: v: v == true) container.capDrop
+        )
+        ++ map (d: "--device=${escapeShellArg d}") container.devices
+        ++ map (n: "--network=${escapeShellArg n}") container.networks
+        ++ [ "--pull ${escapeShellArg container.pull}" ]
+        ++ map escapeShellArg container.extraOptions
+        ++ [ container.image ]
+        ++ map escapeShellArg container.cmd
+      );
 
-    preStop = if cfg.backend == "podman"
-      then "podman stop --ignore --cidfile=/run/podman-${escapedName}.ctr-id"
-      else "${cfg.backend} stop ${name} || true";
+      preStop =
+        if cfg.backend == "podman" then
+          "podman stop --ignore --cidfile=/run/podman-${escapedName}.ctr-id"
+        else
+          "${cfg.backend} stop ${name} || true";
 
-    postStop = if cfg.backend == "podman"
-      then "podman rm -f --ignore --cidfile=/run/podman-${escapedName}.ctr-id"
-      else "${cfg.backend} rm -f ${name} || true";
+      postStop =
+        if cfg.backend == "podman" then
+          "podman rm -f --ignore --cidfile=/run/podman-${escapedName}.ctr-id"
+        else
+          "${cfg.backend} rm -f ${name} || true";
 
-    serviceConfig = {
-      ### There is no generalized way of supporting `reload` for docker
-      ### containers. Some containers may respond well to SIGHUP sent to their
-      ### init process, but it is not guaranteed; some apps have other reload
-      ### mechanisms, some don't have a reload signal at all, and some docker
-      ### images just have broken signal handling.  The best compromise in this
-      ### case is probably to leave ExecReload undefined, so `systemctl reload`
-      ### will at least result in an error instead of potentially undefined
-      ### behaviour.
-      ###
-      ### Advanced users can still override this part of the unit to implement
-      ### a custom reload handler, since the result of all this is a normal
-      ### systemd service from the perspective of the NixOS module system.
-      ###
-      # ExecReload = ...;
-      ###
-      ExecStartPre = [ "${preStartScript}/bin/pre-start" ];
-      TimeoutStartSec = 0;
-      TimeoutStopSec = 120;
-      Restart = "always";
-    } // optionalAttrs (cfg.backend == "podman") {
-      Environment="PODMAN_SYSTEMD_UNIT=podman-${name}.service";
-      Type="notify";
-      NotifyAccess="all";
+      serviceConfig =
+        {
+          ### There is no generalized way of supporting `reload` for docker
+          ### containers. Some containers may respond well to SIGHUP sent to their
+          ### init process, but it is not guaranteed; some apps have other reload
+          ### mechanisms, some don't have a reload signal at all, and some docker
+          ### images just have broken signal handling.  The best compromise in this
+          ### case is probably to leave ExecReload undefined, so `systemctl reload`
+          ### will at least result in an error instead of potentially undefined
+          ### behaviour.
+          ###
+          ### Advanced users can still override this part of the unit to implement
+          ### a custom reload handler, since the result of all this is a normal
+          ### systemd service from the perspective of the NixOS module system.
+          ###
+          # ExecReload = ...;
+          ###
+          ExecStartPre = [ "${preStartScript}/bin/pre-start" ];
+          TimeoutStartSec = 0;
+          TimeoutStopSec = 120;
+          Restart = "always";
+        }
+        // optionalAttrs (cfg.backend == "podman") {
+          Environment = "PODMAN_SYSTEMD_UNIT=podman-${name}.service";
+          Type = "notify";
+          NotifyAccess = "all";
+        };
     };
-  };
 
-in {
+in
+{
   imports = [
-    (
-      lib.mkChangedOptionModule
-      [ "docker-containers"  ]
-      [ "virtualisation" "oci-containers" ]
-      (oldcfg: {
-        backend = "docker";
-        containers = lib.mapAttrs (n: v: builtins.removeAttrs (v // {
-          extraOptions = v.extraDockerOptions or [];
-        }) [ "extraDockerOptions" ]) oldcfg.docker-containers;
-      })
-    )
+    (lib.mkChangedOptionModule [ "docker-containers" ] [ "virtualisation" "oci-containers" ] (oldcfg: {
+      backend = "docker";
+      containers = lib.mapAttrs (
+        n: v:
+        builtins.removeAttrs (
+          v
+          // {
+            extraOptions = v.extraDockerOptions or [ ];
+          }
+        ) [ "extraDockerOptions" ]
+      ) oldcfg.docker-containers;
+    }))
   ];
 
   options.virtualisation.oci-containers = {
 
     backend = mkOption {
-      type = types.enum [ "podman" "docker" ];
+      type = types.enum [
+        "podman"
+        "docker"
+      ];
       default = if versionAtLeast config.system.stateVersion "22.05" then "podman" else "docker";
       description = "The underlying Docker implementation to use.";
     };
 
     containers = mkOption {
-      default = {};
+      default = { };
       type = types.attrsOf (types.submodule containerOptions);
       description = "OCI (Docker) containers to run as systemd services.";
     };
 
   };
 
-  config = lib.mkIf (cfg.containers != {}) (lib.mkMerge [
-    {
-      systemd.services = mapAttrs' (n: v: nameValuePair "${cfg.backend}-${n}" (mkService n v)) cfg.containers;
+  config = lib.mkIf (cfg.containers != { }) (
+    lib.mkMerge [
+      {
+        systemd.services = mapAttrs' (
+          n: v: nameValuePair "${cfg.backend}-${n}" (mkService n v)
+        ) cfg.containers;
 
-      assertions =
-        let
-          toAssertion = _: { imageFile, imageStream, ... }:
-            { assertion = imageFile == null || imageStream == null;
+        assertions =
+          let
+            toAssertion =
+              _:
+              { imageFile, imageStream, ... }:
+              {
+                assertion = imageFile == null || imageStream == null;
 
-              message = "You can only define one of imageFile and imageStream";
-            };
+                message = "You can only define one of imageFile and imageStream";
+              };
 
-        in
+          in
           lib.mapAttrsToList toAssertion cfg.containers;
-    }
-    (lib.mkIf (cfg.backend == "podman") {
-      virtualisation.podman.enable = true;
-    })
-    (lib.mkIf (cfg.backend == "docker") {
-      virtualisation.docker.enable = true;
-    })
-  ]);
+      }
+      (lib.mkIf (cfg.backend == "podman") {
+        virtualisation.podman.enable = true;
+      })
+      (lib.mkIf (cfg.backend == "docker") {
+        virtualisation.docker.enable = true;
+      })
+    ]
+  );
 
 }

nixos/tests/networking/networkd-and-scripted.nix

···
         };
       };
       testScript = ''
-          start_all()
+          router.start()
+          router.systemctl("start network-online.target")
+          router.wait_for_unit("network-online.target")
 
+          client.start()
           client.wait_for_unit("network.target")
-          router.systemctl("start network-online.target")
-          router.wait_for_unit("network-online.target")
 
           with subtest("Wait until we have an ip address on each interface"):
               client.wait_until_succeeds("ip addr show dev enp1s0 | grep -q '192.168.1'")

nixos/tests/oci-containers.nix

···
             image = "nginx-container";
             imageStream = pkgs.dockerTools.examples.nginxStream;
             ports = ["8181:80"];
+            capAdd = {
+              CAP_AUDIT_READ = true;
+            };
+            capDrop = {
+              CAP_AUDIT_WRITE = true;
+            };
+            privileged = false;
+            devices = [
+              "/dev/random:/dev/random"
+            ];
           };
         };
 
···
     };
 
     testScript = ''
+      import json
+
       start_all()
       ${backend}.wait_for_unit("${backend}-nginx.service")
       ${backend}.wait_for_open_port(8181)
       ${backend}.wait_until_succeeds("curl -f http://localhost:8181 | grep Hello")
+      output = json.loads(${backend}.succeed("${backend} inspect nginx --format json").strip())[0]
       ${backend}.succeed("systemctl stop ${backend}-nginx.service", timeout=10)
+      assert output['HostConfig']['CapAdd'] == ["CAP_AUDIT_READ"]
+      assert output['HostConfig']['CapDrop'] == ${if backend == "docker" then "[\"CAP_AUDIT_WRITE\"]" else "[]"} # Rootless podman runs with no capabilities so it cannot drop them
+      assert output['HostConfig']['Privileged'] == False
+      assert output['HostConfig']['Devices'] == [{'PathOnHost': '/dev/random', 'PathInContainer': '/dev/random', 'CgroupPermissions': '${if backend == "docker" then "rwm" else ""}'}]
     '';
   };
 

nixos/tests/victoriametrics/default.nix

···
 {
   remote-write = import ./remote-write.nix { inherit system pkgs; };
   vmalert = import ./vmalert.nix { inherit system pkgs; };
+  external-promscrape-config = import ./external-promscrape-config.nix { inherit system pkgs; };
 }

nixos/tests/victoriametrics/external-promscrape-config.nix

···
+import ../make-test-python.nix (
+  {
+    lib,
+    pkgs,
+    ...
+  }:
+  let
+    nodeExporterPort = 9100;
+    promscrapeConfig = {
+      global = {
+        scrape_interval = "2s";
+      };
+      scrape_configs = [
+        {
+          job_name = "node";
+          static_configs = [
+            {
+              targets = [
+                "node:${toString nodeExporterPort}"
+              ];
+            }
+          ];
+        }
+      ];
+    };
+    settingsFormat = pkgs.formats.yaml { };
+    promscrapeConfigYaml = settingsFormat.generate "prometheusConfig.yaml" promscrapeConfig;
+  in
+  {
+    name = "victoriametrics-external-promscrape-config";
+    meta = with pkgs.lib.maintainers; {
+      maintainers = [
+        ryan4yin
+      ];
+    };
+
+    nodes = {
+      victoriametrics =
+        {
+          config,
+          pkgs,
+          ...
+        }:
+        {
+          environment.systemPackages = [ pkgs.jq ];
+          networking.firewall.allowedTCPPorts = [ 8428 ];
+          services.victoriametrics = {
+            enable = true;
+            extraOptions = [
+              "-promscrape.config=${toString promscrapeConfigYaml}"
+            ];
+          };
+        };
+
+      node =
+        { ... }:
+        {
+          services.prometheus.exporters.node = {
+            enable = true;
+            openFirewall = true;
+          };
+        };
+    };
+
+    testScript = ''
+      node.wait_for_unit("prometheus-node-exporter")
+      node.wait_for_open_port(${toString nodeExporterPort})
+
+      victoriametrics.wait_for_unit("victoriametrics")
+      victoriametrics.wait_for_open_port(8428)
+
+
+      promscrape_config = victoriametrics.succeed("journalctl -u victoriametrics -o cat | grep 'promscrape.config'")
+      assert '${toString promscrapeConfigYaml}' in promscrape_config
+
+      victoriametrics.wait_until_succeeds(
+        "curl -sf 'http://localhost:8428/api/v1/query?query=node_exporter_build_info\{instance=\"node:9100\"\}' | "
+        + "jq '.data.result[0].value[1]' | grep '\"1\"'"
+      )
+    '';
+  }
+)

pkgs/applications/editors/emacs/elisp-packages/manual-packages/ebuild-mode/package.nix

···
     homepage = "https://gitweb.gentoo.org/proj/ebuild-mode.git/";
     description = "Major modes for Gentoo package files";
     license = lib.licenses.gpl2Plus;
-    maintainers = with lib.maintainers; [ qyliss ];
+    maintainers = with lib.maintainers; [ ];
   };
 }

pkgs/applications/editors/vscode/extensions/default.nix

···
         };
       };
 
+      ltex-plus.vscode-ltex-plus = buildVscodeMarketplaceExtension {
+        mktplcRef = {
+          name = "vscode-ltex-plus";
+          publisher = "ltex-plus";
+          version = "15.3.0";
+          hash = "sha256-hkHFDLeH+kJ7MJIYtXmCfi8LlCGujy/yPotwkZDrmHY=";
+        };
+        meta = {
+          description = "VS Code extension for grammar/spell checking using LanguageTool with support for LaTeX, Markdown, and others";
+          downloadPage = "https://marketplace.visualstudio.com/items?itemName=ltex-plus.vscode-ltex-plus";
+          homepage = "https://github.com/ltex-plus/vscode-ltex-plus";
+          license = lib.licenses.mpl20;
+          maintainers = with lib.maintainers; [ thtrf ];
+        };
+      };
+
       lucperkins.vrl-vscode = buildVscodeMarketplaceExtension {
         mktplcRef = {
           publisher = "lucperkins";

pkgs/applications/misc/pdfstudio/common.nix

···
-{ pname
-, program
-, src
-, year
-, version
-, desktopName
-, longDescription
-, broken ? false
-, buildFHSEnv
-, extraBuildInputs ? [ ]
-, jdk
-, stdenv
-, lib
-, dpkg
-, makeDesktopItem
-, copyDesktopItems
-, autoPatchelfHook
-, sane-backends
-, cups
+{
+  pname,
+  program,
+  src,
+  year,
+  version,
+  desktopName,
+  longDescription,
+  broken ? false,
+  buildFHSEnv,
+  extraBuildInputs ? [ ],
+  jdk,
+  stdenv,
+  lib,
+  dpkg,
+  makeDesktopItem,
+  copyDesktopItems,
+  autoPatchelfHook,
+  sane-backends,
+  cups,
 }:
 let
   thisPackage = stdenv.mkDerivation rec {
···
     strictDeps = true;
 
     buildInputs = [
-      sane-backends #for libsane.so.1
+      sane-backends # for libsane.so.1
     ] ++ extraBuildInputs;
 
     nativeBuildInputs = [
···
 # Package with cups in FHS sandbox, because JAVA bin expects "/usr/bin/lpr" for printing.
 buildFHSEnv {
   inherit pname version;
+
   targetPkgs = pkgs: [
     cups
     thisPackage
   ];
+
   runScript = "${program}${year}";
 
   # link desktop item and icon into FHS user environment
···
     ln -s ${thisPackage}/share/pixmaps/*.png "$out/share/pixmaps/"
   '';
 
-  meta = with lib; {
+  meta = {
     inherit broken;
     homepage = "https://www.qoppa.com/${pname}/";
     description = "Easy to use, full-featured PDF editing software";
     longDescription = longDescription;
-    sourceProvenance = with sourceTypes; [
+    sourceProvenance = with lib.sourceTypes; [
       binaryBytecode
       binaryNativeCode
     ];
-    license = licenses.unfree;
-    platforms = platforms.linux;
+    license = lib.licenses.unfree;
+    platforms = lib.platforms.linux;
     mainProgram = pname;
-    maintainers = [ maintainers.pwoelfel ];
+    maintainers = with lib.maintainers; [ pwoelfel ];
   };
 }

pkgs/applications/misc/pdfstudio/default.nix

···
 # - year identifies the year portion of the version, defaults to most recent year.
 # - pname is either "pdfstudio${year}" or "pdfstudioviewer".
 
-{ lib
-, stdenv
-, program ? "pdfstudio"
-, year ? "2023"
-, fetchurl
-, callPackage
-, jdk11
-, jdk17
+{
+  lib,
+  stdenv,
+  program ? "pdfstudio",
+  year ? "2024",
+  fetchurl,
+  callPackage,
+  jdk11,
+  jdk17,
 }:
 let
   longDescription = ''
     PDF Studio is an easy to use, full-featured PDF editing software. This is the standard/pro edition, which requires a license. For the free PDF Studio Viewer see the package pdfstudioviewer.
   '';
   pname = if (program == "pdfstudio") then "${program}${year}" else program;
-  desktopName =
-    if (program == "pdfstudio")
-    then "PDF Studio ${year}"
-    else "PDF Studio Viewer";
+  desktopName = if (program == "pdfstudio") then "PDF Studio ${year}" else "PDF Studio Viewer";
   dot2dash = str: builtins.replaceStrings [ "." ] [ "_" ] str;
 in
 {
   pdfstudioviewer = callPackage ./common.nix rec {
-    inherit desktopName pname program year;
-    version = "${year}.0.3";
+    inherit
+      desktopName
+      pname
+      program
+      year
+      ;
+    version = "${year}.0.1";
     longDescription = ''
       PDF Studio Viewer is an easy to use, full-featured PDF editing software. This is the free edition. For the standard/pro edition, see the package pdfstudio.
     '';
     src = fetchurl {
-      url = "https://download.qoppa.com/pdfstudioviewer/PDFStudioViewer_linux64.deb";
-      sha256 = "sha256-JQx5yJLjwW4VRXLM+/VNDXFN8ZcHJxlxyKDIzc++hEs=";
+      url = "https://web.archive.org/web/20241201121627/https://download.qoppa.com/pdfstudioviewer/PDFStudioViewer_linux64.deb";
+      hash = "sha256-hxReGuyGsBiEr7wWxWzQUQvxk11sgF9HkJ07L9i+e+0=";
     };
     jdk = jdk17;
   };
 
   pdfstudio2021 = callPackage ./common.nix rec {
-    inherit desktopName longDescription pname program year;
+    inherit
+      desktopName
+      longDescription
+      pname
+      program
+      year
+      ;
     version = "${year}.2.2";
     src = fetchurl {
       url = "https://download.qoppa.com/pdfstudio/v${year}/PDFStudio_v${dot2dash version}_linux64.deb";
-      sha256 = "sha256-HdkwRMqwquAaW6l3AukGReFtw2f5n36tZ8vXo6QiPvU=";
+      hash = "sha256-HdkwRMqwquAaW6l3AukGReFtw2f5n36tZ8vXo6QiPvU=";
     };
     extraBuildInputs = [
-      (lib.getLib stdenv.cc.cc)  # for libstdc++.so.6 and libgomp.so.1
+      (lib.getLib stdenv.cc.cc) # for libstdc++.so.6 and libgomp.so.1
     ];
     jdk = jdk11;
   };
 
   pdfstudio2022 = callPackage ./common.nix rec {
-    inherit desktopName longDescription pname program year;
+    inherit
+      desktopName
+      longDescription
+      pname
+      program
+      year
+      ;
     version = "${year}.2.5";
     src = fetchurl {
       url = "https://download.qoppa.com/pdfstudio/v${year}/PDFStudio_v${dot2dash version}_linux64.deb";
-      sha256 = "sha256-3faZyWUnFe//S+gOskWhsZ6jzHw67FRsv/xP77R1jj4=";
+      hash = "sha256-3faZyWUnFe//S+gOskWhsZ6jzHw67FRsv/xP77R1jj4=";
     };
     extraBuildInputs = [
-      (lib.getLib stdenv.cc.cc)  # for libstdc++.so.6 and libgomp.so.1
+      (lib.getLib stdenv.cc.cc) # for libstdc++.so.6 and libgomp.so.1
     ];
     jdk = jdk17;
   };
 
   pdfstudio2023 = callPackage ./common.nix rec {
-    inherit desktopName longDescription pname program year;
-    version = "${year}.0.3";
+    inherit
+      desktopName
+      longDescription
+      pname
+      program
+      year
+      ;
+    version = "${year}.0.4";
     src = fetchurl {
       url = "https://download.qoppa.com/pdfstudio/v${year}/PDFStudio_v${dot2dash version}_linux64.deb";
-      sha256 = "sha256-Po7BMmEWoC46rP7tUwZT9Ji/Wi8lKc6WN8x47fx2DXg=";
+      hash = "sha256-TTh0yzpCOpxFKGfrakvnu1Y+l9NI0nfWlVuvSWpkRkE=";
     };
     extraBuildInputs = [
-      (lib.getLib stdenv.cc.cc)  # for libstdc++.so.6 and libgomp.so.1
+      (lib.getLib stdenv.cc.cc) # for libstdc++.so.6 and libgomp.so.1
     ];
     jdk = jdk17;
   };
 
   pdfstudio2024 = callPackage ./common.nix rec {
-    inherit desktopName longDescription pname program year;
+    inherit
+      desktopName
+      longDescription
+      pname
+      program
+      year
+      ;
     version = "${year}.0.0";
     src = fetchurl {
       url = "https://download.qoppa.com/pdfstudio/v${year}/PDFStudio_v${dot2dash version}_linux64.deb";
-      sha256 = "sha256-9TMSKtBE0+T7wRnBgtUjRr/JUmCaYdyD/7y0ML37wCM=";
+      hash = "sha256-9TMSKtBE0+T7wRnBgtUjRr/JUmCaYdyD/7y0ML37wCM=";
     };
     extraBuildInputs = [
-      (lib.getLib stdenv.cc.cc)  # for libstdc++.so.6 and libgomp.so.1
+      (lib.getLib stdenv.cc.cc) # for libstdc++.so.6 and libgomp.so.1
     ];
     jdk = jdk17;
   };
 
-}.${pname}
+}
+.${pname}

pkgs/applications/networking/instant-messengers/element/pin.nix

···
 {
-  "version" = "1.11.86";
+  "version" = "1.11.87";
   "hashes" = {
-    "desktopSrcHash" = "sha256-GP5KnXL63J0076cVu0OpodlNT7Ypeso4iGrQNKq/17M=";
-    "desktopYarnHash" = "0bcq89nmx03h106hp875mv482d4r1xahdsimw3cs5c592zl50kx2";
-    "webSrcHash" = "sha256-cqB77ffTbFLoNsGjXUOb2tdlXhSIS3X1/oDXOzOn99s=";
-    "webYarnHash" = "1cwj77a997lb4229ngry0b6kip1ggs82b9v126rzfgzavvwh9k1v";
+    "desktopSrcHash" = "sha256-rIxuXMHQVJrbfWibpiIBmTkXKHrBqnTMiBYIP8VOIH4=";
+    "desktopYarnHash" = "05qs1an3mbqsfn1nmgwagp564lqvyrbkyj58z5h2cbczqbavnxxz";
+    "webSrcHash" = "sha256-FcXYwYCx//fqWuUKRqTTntlT7jVBD1Heayg4T7ACHmc=";
+    "webYarnHash" = "0anamnfm5g4nj7wp18byi49x38aia490qfard2d34myzjgiby8v3";
   };
 }

pkgs/applications/science/math/wxmaxima/default.nix

···
 
 stdenv.mkDerivation (finalAttrs:{
   pname = "wxmaxima";
-  version = "24.08.0";
+  version = "24.11.0";
 
   src = fetchFromGitHub {
     owner = "wxMaxima-developers";
     repo = "wxmaxima";
     rev = "Version-${finalAttrs.version}";
-    hash = "sha256-W9sZlCPi+pz37OQoICnRGQR2hoe/UciMN6NIzDgHNPQ=";
+    hash = "sha256-3tGMkxp7nadD+LNluIiyPf55Daf7N1MPTH62U8/GxuA=";
   };
 
   buildInputs = [

pkgs/applications/video/davinci-resolve/default.nix

···
   davinci = (
     stdenv.mkDerivation rec {
       pname = "davinci-resolve${lib.optionalString studioVariant "-studio"}";
-      version = "19.0.2";
+      version = "19.1";
 
       nativeBuildInputs = [
         (appimage-run.override { buildFHSEnv = buildFHSEnvChroot; } )
···
           outputHashAlgo = "sha256";
           outputHash =
             if studioVariant
-            then "sha256-q11stWFWRDUebAUzGH23R3Spd3EdDG85+6yB/srYCJY="
-            else "sha256-dYTrO0wpIN68WhBovmYLK5uWOQ1nubpSyKqPCDMPMiM=";
+            then "sha256-uEUZt0TQ4XrAag6NoCPUtYSnkwpwh3BNlol1z/EmP9E="
+            else "sha256-3VVyfXT/mZFuf2GGkNS47ErSdAGpdUUwwwKY19zBBZo=";
 
           impureEnvVars = lib.fetchers.proxyImpureEnvVars;
 

pkgs/applications/video/haruna/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "haruna";
-  version = "1.1.2";
+  version = "1.2.1";
 
   src = fetchFromGitLab {
     owner = "multimedia";
     repo = "haruna";
     rev = "v${version}";
-    hash = "sha256-PjELW0evn53gIbScrM2bYEpb9U/TE/lOCD2DiJ1aodo=";
+    hash = "sha256-RxHCs5NiKORikbTyNwRD27aQfX5id4K/Lp1bQ8cAwVo=";
     domain = "invent.kde.org";
   };
 

pkgs/applications/virtualization/docker/default.nix

···
       , runcRev, runcHash
       , containerdRev, containerdHash
       , tiniRev, tiniHash
-      , buildxSupport ? true, composeSupport ? true, sbomSupport ? false
+      , buildxSupport ? true, composeSupport ? true, sbomSupport ? false, initSupport ? false
       # package dependencies
       , stdenv, fetchFromGitHub, fetchpatch, buildGoModule
       , makeWrapper, installShellFiles, pkg-config, glibc
       , go-md2man, go, containerd, runc, tini, libtool
-      , sqlite, iproute2, docker-buildx, docker-compose, docker-sbom
+      , sqlite, iproute2, docker-buildx, docker-compose, docker-sbom, docker-init
       , iptables, e2fsprogs, xz, util-linux, xfsprogs, gitMinimal
       , procps, rootlesskit, slirp4netns, fuse-overlayfs, nixosTests
       , clientOnly ? !stdenv.hostPlatform.isLinux, symlinkJoin
···
 
     plugins = lib.optional buildxSupport docker-buildx
       ++ lib.optional composeSupport docker-compose
-      ++ lib.optional sbomSupport docker-sbom;
+      ++ lib.optional sbomSupport docker-sbom
+      ++ lib.optional initSupport docker-init;
     pluginsRef = symlinkJoin { name = "docker-plugins"; paths = plugins; };
   in
   buildGoModule (lib.optionalAttrs (!clientOnly) {

pkgs/applications/virtualization/singularity/packages.nix

···
     callPackage
       (import ./generic.nix rec {
         pname = "apptainer";
-        version = "1.3.5";
+        version = "1.3.6";
         projectName = "apptainer";
 
         src = fetchFromGitHub {
           owner = "apptainer";
           repo = "apptainer";
           rev = "refs/tags/v${version}";
-          hash = "sha256-yBUCUHc9vgyKFqAOHXQjAYQnmN0yXSIvkpR/s3LNAmk=";
+          hash = "sha256-ZdSo9bKZ7Q1xwMe4SR840U3+fVpKwtiZQA5KDM5qF9M=";
         };
 
         # Update by running

pkgs/applications/window-managers/hyprwm/hyprland-plugins/hyprscroller.nix

···
 
 mkHyprlandPlugin hyprland {
   pluginName = "hyprscroller";
-  version = "0-unstable-2024-11-23";
+  version = "0-unstable-2024-11-29";
 
   src = fetchFromGitHub {
     owner = "dawsers";
     repo = "hyprscroller";
-    rev = "f1e09fd86d0fff30aff0b9ca2e429c7331bab5ac";
-    hash = "sha256-5j7IqHKiXfmaq193ltGX4/150NA1YWNXNB1GIFwEfuc=";
+    rev = "50a87a8a7dc56494a5b71e95182ef4b907d71448";
+    hash = "sha256-4Gzj0HWovu0hzzw+2zEXne7vDmP6yIK2GmtURB1EZxQ=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/build-support/fetchgit/default.nix

···
 lib.makeOverridable (lib.fetchers.withNormalizedHash { } (
 # NOTE Please document parameter additions or changes in
 #   doc/build-helpers/fetchers.chapter.md
-{ url, rev ? "HEAD", leaveDotGit ? deepClone
+{ url
+, tag ? null
+, rev ? null
+, leaveDotGit ? deepClone
 , outputHash ? lib.fakeHash, outputHashAlgo ? null
 , fetchSubmodules ? true, deepClone ? false
 , branchName ? null
 , sparseCheckout ? []
 , nonConeMode ? false
-, name ? urlToName url rev
+, name ? null
 , # Shell code executed after the file has been fetched
   # successfully. This can do things like check or transform the file.
   postFetch ? ""
···
 assert deepClone -> leaveDotGit;
 assert nonConeMode -> (sparseCheckout != []);
 
+let
+  revWithTag =
+    let
+      warningMsg = "fetchgit requires one of either `rev` or `tag` to be provided (not both).";
+      otherIsNull = other: lib.assertMsg (other == null) warningMsg;
+    in
+    if tag != null then
+      assert (otherIsNull rev);
+      "refs/tags/${tag}"
+    else if rev != null then
+      assert (otherIsNull tag);
+      rev
+    else
+      # FIXME fetching HEAD if no rev or tag is provided is problematic at best
+      "HEAD";
+in
+
 if builtins.isString sparseCheckout then
   # Changed to throw on 2023-06-04
   throw "Please provide directories/patterns for sparse checkout as a list of strings. Passing a (multi-line) string is not supported any more."
 else
 stdenvNoCC.mkDerivation {
-  inherit name;
+  name = if name != null then name else urlToName url revWithTag;
+
   builder = ./builder.sh;
   fetcher = ./nix-prefetch-git;
 
···
   # > from standard in as a newline-delimited list instead of from the arguments.
   sparseCheckout = builtins.concatStringsSep "\n" sparseCheckout;
 
-  inherit url rev leaveDotGit fetchLFS fetchSubmodules deepClone branchName nonConeMode postFetch;
+  inherit url leaveDotGit fetchLFS fetchSubmodules deepClone branchName nonConeMode postFetch;
+  rev = revWithTag;
 
   postHook = if netrcPhase == null then null else ''
     ${netrcPhase}

pkgs/build-support/fetchgithub/default.nix

···
 { lib, fetchgit, fetchzip }:
 
 lib.makeOverridable (
-{ owner, repo, rev, name ? "source"
+{ owner, repo
+, tag ? null
+, rev ? null
+, name ? "source"
 , fetchSubmodules ? false, leaveDotGit ? null
 , deepClone ? false, private ? false, forceFetchGit ? false
 , fetchLFS ? false
···
 , ... # For hash agility
 }@args:
 
+assert (lib.assertMsg (lib.xor (tag == null) (rev == null)) "fetchFromGitHub requires one of either `rev` or `tag` to be provided (not both).");
+
 let
 
   position = (if args.meta.description or null != null
     then builtins.unsafeGetAttrPos "description" args.meta
-    else builtins.unsafeGetAttrPos "rev" args
+    else if tag != null then
+      builtins.unsafeGetAttrPos "tag" args
+    else
+      builtins.unsafeGetAttrPos "rev" args
   );
   baseUrl = "https://${githubBase}/${owner}/${repo}";
   newMeta = meta // {
···
     # to indicate where derivation originates, similar to make-derivation.nix's mkDerivation
     position = "${position.file}:${toString position.line}";
   };
-  passthruAttrs = removeAttrs args [ "owner" "repo" "rev" "fetchSubmodules" "forceFetchGit" "private" "githubBase" "varPrefix" ];
+  passthruAttrs = removeAttrs args [ "owner" "repo" "tag" "rev" "fetchSubmodules" "forceFetchGit" "private" "githubBase" "varPrefix" ];
   varBase = "NIX${lib.optionalString (varPrefix != null) "_${varPrefix}"}_GITHUB_PRIVATE_";
   useFetchGit = fetchSubmodules || (leaveDotGit == true) || deepClone || forceFetchGit || fetchLFS || (sparseCheckout != []);
   # We prefer fetchzip in cases we don't need submodules as the hash
···
 
   fetcherArgs = (if useFetchGit
     then {
-      inherit rev deepClone fetchSubmodules sparseCheckout fetchLFS; url = gitRepoUrl;
+      inherit tag rev deepClone fetchSubmodules sparseCheckout fetchLFS; url = gitRepoUrl;
     } // lib.optionalAttrs (leaveDotGit != null) { inherit leaveDotGit; }
     else {
-      url = "${baseUrl}/archive/${rev}.tar.gz";
+      url = "${baseUrl}/archive/${if tag != null then "refs/tags/${tag}" else rev}.tar.gz";
 
       passthru = {
         inherit gitRepoUrl;

pkgs/by-name/ad/adw-gtk3/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "adw-gtk3";
-  version = "5.5";
+  version = "5.6";
 
   src = fetchFromGitHub {
     owner = "lassekongo83";
     repo = "adw-gtk3";
-    rev = "v${finalAttrs.version}";
-    sha256 = "sha256-WW6lJmGNn+e0jXu319SSX6e6POWfdgsIeg/U1vmwy1U=";
+    rev = "refs/tags/v${finalAttrs.version}";
+    hash = "sha256-S/H6JGXwEgiqmcH1W+ZyHYOkk0gQtKG9Q3BiI2IjnEM=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/al/alt-tab-macos/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "alt-tab-macos";
-  version = "7.4.0";
+  version = "7.7.0";
 
   src = fetchurl {
     url = "https://github.com/lwouis/alt-tab-macos/releases/download/v${finalAttrs.version}/AltTab-${finalAttrs.version}.zip";
-    hash = "sha256-uCernCv52gZUxyn9LxsZGxd33z0y0YoEHEZ4mf4Ve4Y=";
+    hash = "sha256-ASFlOYOy1uAKPJyrohFmdCD0JwJybJahpaRTiz9rFUk=";
   };
 
   sourceRoot = ".";

pkgs/by-name/au/auto-editor/package.nix

···
+{
+  lib,
+  python3Packages,
+  fetchFromGitHub,
+  replaceVars,
+  ffmpeg,
+  yt-dlp,
+}:
+
+python3Packages.buildPythonApplication rec {
+  pname = "auto-editor";
+  version = "24w29a";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "WyattBlue";
+    repo = "auto-editor";
+    rev = "refs/tags/${version}";
+    hash = "sha256-2/6IqwMlaWobOlDr/h2WV2OqkxqVmUI65XsyBphTbpA=";
+  };
+
+  patches = [
+    (replaceVars ./set-exe-paths.patch {
+      ffmpeg = lib.getExe ffmpeg;
+      yt_dlp = lib.getExe yt-dlp;
+    })
+  ];
+
+  postPatch = ''
+    # pyav is a fork of av, but has since mostly been un-forked
+    substituteInPlace pyproject.toml \
+        --replace-fail '"pyav==12.2.*"' '"av"'
+  '';
+
+  # our patch file also removes the dependency on ae-ffmpeg
+  pythonRemoveDeps = [ "ae-ffmpeg" ];
+
+  build-system = with python3Packages; [
+    setuptools
+  ];
+
+  dependencies = with python3Packages; [
+    av
+    numpy
+  ];
+
+  checkPhase = ''
+    runHook preCheck
+
+    $out/bin/auto-editor test all
+
+    runHook postCheck
+  '';
+
+  pythonImportsCheck = [ "auto_editor" ];
+
+  meta = {
+    changelog = "https://github.com/WyattBlue/auto-editor/releases/tag/${version}";
+    description = "Command line application for automatically editing video and audio by analyzing a variety of methods, most notably audio loudness";
+    homepage = "https://auto-editor.com/";
+    license = lib.licenses.unlicense;
+    mainProgram = "auto-editor";
+    maintainers = with lib.maintainers; [ tomasajt ];
+  };
+}

pkgs/by-name/au/auto-editor/set-exe-paths.patch

···
+diff --git a/auto_editor/ffwrapper.py b/auto_editor/ffwrapper.py
+index b6df2d4..8409032 100644
+--- a/auto_editor/ffwrapper.py
++++ b/auto_editor/ffwrapper.py
+@@ -30,13 +30,7 @@ class FFmpeg:
+                 return ff_location
+             if my_ffmpeg:
+                 return "ffmpeg"
+-
+-            try:
+-                import ae_ffmpeg
+-
+-                return ae_ffmpeg.get_path()
+-            except ImportError:
+-                return "ffmpeg"
++            return "@ffmpeg@"
+ 
+         self.debug = debug
+         self.show_cmd = show_cmd
+diff --git a/auto_editor/utils/types.py b/auto_editor/utils/types.py
+index ccd6581..a66e5e3 100644
+--- a/auto_editor/utils/types.py
++++ b/auto_editor/utils/types.py
+@@ -218,7 +218,7 @@ def resolution(val: str | None) -> tuple[int, int] | None:
+ 
+ @dataclass
+ class Args:
+-    yt_dlp_location: str = "yt-dlp"
++    yt_dlp_location: str = "@yt_dlp@"
+     download_format: str | None = None
+     output_format: str | None = None
+     yt_dlp_extras: str | None = None

pkgs/by-name/ca/caprine/001-disable-auto-update.patch

···
+From 5da393e32336534222c77659ff138a4e512e6a1f Mon Sep 17 00:00:00 2001
+From: Austin Horstman <[e-mail]>
+Date: Wed, 4 Dec 2024 13:23:15 -0600
+Subject: [PATCH] Disable autoUpdate
+
+---
+ source/index.ts | 12 ------------
+ 1 file changed, 12 deletions(-)
+
+diff --git a/source/index.ts b/source/index.ts
+index b8511949a..205c513fe 100644
+--- a/source/index.ts
++++ b/source/index.ts
+@@ -14,7 +14,6 @@ import {
+ 	nativeTheme,
+ } from 'electron';
+ import {ipcMain as ipc} from 'electron-better-ipc';
+-import {autoUpdater} from 'electron-updater';
+ import electronDl from 'electron-dl';
+ import electronContextMenu from 'electron-context-menu';
+ import electronLocalshortcut from 'electron-localshortcut';
+@@ -65,17 +64,6 @@ if (!config.get('hardwareAcceleration')) {
+ 	app.disableHardwareAcceleration();
+ }
+
+-if (!is.development && config.get('autoUpdate')) {
+-	(async () => {
+-		const FOUR_HOURS = 1000 * 60 * 60 * 4;
+-		setInterval(async () => {
+-			await autoUpdater.checkForUpdatesAndNotify();
+-		}, FOUR_HOURS);
+-
+-		await autoUpdater.checkForUpdatesAndNotify();
+-	})();
+-}
+-
+ let mainWindow: BrowserWindow;
+ let isQuitting = false;
+ let previousMessageCount = 0;

pkgs/by-name/ca/caprine/package.nix

···
   makeDesktopItem,
   copyDesktopItems,
   electron,
+  nix-update-script,
 }:
 
 buildNpmPackage rec {
   pname = "caprine";
-  version = "2.60.1";
+  version = "2.60.3";
 
   src = fetchFromGitHub {
     owner = "sindresorhus";
     repo = "caprine";
     rev = "v${version}";
-    hash = "sha256-y4W295i7FhgJC3SlwSr801fLOGJY1WF136bbkkBUvyw=";
+    hash = "sha256-yfCilJ62m7nKe8B+4puwAbNgr2g1P7HaKIhFINdv0/k=";
   };
 
   ELECTRON_SKIP_BINARY_DOWNLOAD = "1";
 
-  npmDepsHash = "sha256-JHaUc2p+wHsqWtls8xquHK9qnypuCrR0AQMGxcrTsC0=";
+  npmDepsHash = "sha256-hNOAplCSXrO4NZqDTkmhf0oZVeGRUHr2Y/Qdx2RIV9c=";
 
   nativeBuildInputs = [ copyDesktopItems ];
 
···
         -c.electronDist=electron-dist \
         -c.electronVersion=${electron.version}
   '';
+
+  patches = [ ./001-disable-auto-update.patch ];
 
   installPhase = ''
     runHook preInstall
···
       terminal = false;
     })
   ];
+
+  passthru.updateScript = nix-update-script { };
 
   meta = {
     changelog = "https://github.com/sindresorhus/caprine/releases/tag/${src.rev}";

pkgs/by-name/co/commonsCompress/package.nix

···
 { lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "1.26.2";
+  version = "1.27.1";
   pname = "commons-compress";
 
   src = fetchurl {
     url    = "mirror://apache/commons/compress/binaries/${pname}-${version}-bin.tar.gz";
-    sha256 = "sha256-EyGbVhcsuEhLfKh0TPFjySFd9/Z8BEBhkslpfdu4er8=";
+    sha256 = "sha256-psD9VseWxx2ovdUGjEbUCm+fjnQ/D2S70NuyZ2nsXwA=";
   };
 
   installPhase = ''

pkgs/by-name/co/commonsIo/package.nix

···
 { lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  version = "2.17.0";
+  version = "2.18.0";
   pname = "commons-io";
 
   src = fetchurl {
     url    = "mirror://apache/commons/io/binaries/${pname}-${version}-bin.tar.gz";
-    sha256 = "sha256-4CM53Ujdtt0E9zAg9ytOa7UIw5bGNz/zrZqKJOQM9bg=";
+    sha256 = "sha256-qrB4cLnvaTQaZJWrrDO8IYsYI2hp6/nN7nCRcFhKTeE=";
   };
 
   installPhase = ''

pkgs/by-name/dc/dclock/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  haskellPackages,
+}:
+
+haskellPackages.mkDerivation {
+  pname = "dclock";
+  version = "0.1.0";
+
+  src = fetchFromGitHub {
+    owner = "travgm";
+    repo = "dclock";
+    rev = "main";
+    sha256 = "sha256-IJsbEg1dFiyIJSlVWy8x+tsa49YxLK8mNkJESFyUQoU=";
+  };
+
+  isLibrary = false;
+  isExecutable = true;
+  jailbreak = true;
+  doCheck = false;
+
+  executableHaskellDepends = with haskellPackages; [
+    base
+    QuickCheck
+    ansi-terminal
+    hspec
+    hspec-discover
+    lens
+    machines
+    optparse-applicative
+    text
+    time
+    process
+  ];
+
+  description = "Decimal clock that breaks your day into a 1000 decimal minutes";
+  homepage = "https://github.com/travgm/dclock";
+  license = lib.licenses.mit;
+  maintainers = with lib.maintainers; [ travgm ];
+  mainProgram = "dclock";
+}

pkgs/by-name/de/dependency-track/package.nix

···
   nixosTests,
 }:
 let
-  version = "4.12.1";
+  version = "4.12.2";
 
   frontend = buildNpmPackage {
     pname = "dependency-track-frontend";
···
     owner = "DependencyTrack";
     repo = "dependency-track";
     rev = version;
-    hash = "sha256-Gx7tGkibSu+v4gGKC61EFwUsdruMh0t2gTnnNazjqco=";
+    hash = "sha256-wn4HnOFhV02oq66LwBIOVzU+ehXemCuzOWcDASG/47c=";
   };
 
   patches = [
···
   '';
 
   mvnJdk = jre_headless;
-  mvnHash = "sha256-4QtWvsIFiS4d55y45tj3RLE4YYdXLrqpzqS7mOqRWYw=";
+  mvnHash = "sha256-x1/b8LoXyGxCQiu7QB60XSpiufTk/y4492mOraFnRKY=";
   manualMvnArtifacts = [ "com.coderplus.maven.plugins:copy-rename-maven-plugin:1.0.1" ];
   buildOffline = true;
 

pkgs/by-name/do/docker-init/package.nix

···
+{
+  stdenv,
+  fetchurl,
+  zstd,
+  lib,
+}:
+stdenv.mkDerivation (finalAttrs: {
+  pname = "docker-init";
+  version = "v1.3.0";
+  tag = "157355";
+
+  src = fetchurl {
+    url = "https://desktop.docker.com/linux/main/amd64/${finalAttrs.tag}/docker-desktop-x86_64.pkg.tar.zst";
+    hash = "sha256-ysZorPBmoUvTJFFKDbZgQxPamONJKcXezmMrpZSVpwY=";
+  };
+
+  nativeBuildInputs = [
+    zstd
+  ];
+
+  unpackPhase = ''
+    runHook preUnpack
+    tar --zstd -xvf $src
+    runHook postUnpack
+  '';
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out/{bin,libexec/docker/cli-plugins}
+
+    cp usr/lib/docker/cli-plugins/docker-init $out/libexec/docker/cli-plugins
+    ln -s $out/libexec/docker/cli-plugins/docker-init $out/bin/docker-init
+    runHook postInstall
+  '';
+
+  meta = {
+    description = "Creates Docker-related starter files for your project";
+    homepage = "https://docs.docker.com/reference/cli/docker/init";
+    downloadPage = "https://docs.docker.com/desktop/release-notes/#4320";
+    mainProgram = "docker-init";
+    license = lib.licenses.unfree;
+    platforms = [ "x86_64-linux" ];
+    badPlatforms = lib.platforms.darwin;
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
+    maintainers = with lib.maintainers; [ BastianAsmussen ];
+  };
+})

pkgs/by-name/do/door-knocker/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "door-knocker";
-  version = "0.5.0";
+  version = "0.6.0";
 
   src = fetchFromGitea {
     domain = "codeberg.org";
     owner = "tytan652";
     repo = "door-knocker";
     rev = finalAttrs.version;
-    hash = "sha256-932zUfCEN24hZxkCX9uJ2HpvmLNdTtbkXvv50Hu7KxE=";
+    hash = "sha256-n25Bcn1SJuTTRhl8u4M0DF5bAuWV2KVkFfMU65+np78=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/do/dotnet-ef/package.nix

···
+{ buildDotnetGlobalTool, lib }:
+
+buildDotnetGlobalTool {
+  pname = "dotnet-ef";
+  version = "9.0.0";
+
+  nugetHash = "sha256-/Ru/H2WXX/SCqF2s0M1DJkaw+6Nikm+ccrveqiOXggA=";
+
+  meta = {
+    description = "The Entity Framework Core tools help with design-time development tasks.";
+    longDescription = ''
+      The Entity Framework Core tools help with design-time development tasks.
+      They're primarily used to manage Migrations and to scaffold a DbContext and entity types by reverse engineering the schema of a database.
+    '';
+    downloadPage = "https://www.nuget.org/packages/dotnet-ef";
+    homepage = "https://learn.microsoft.com/en-us/ef/core/cli/dotnet";
+    changelog = "https://learn.microsoft.com/en-us/ef/core/what-is-new/";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ lostmsu ];
+    mainProgram = "dotnet-ef";
+  };
+}

pkgs/by-name/el/element-call/package.nix

···
   inherit (stdenv.hostPlatform) system;
   throwSystem = throw "Unsupported system: ${system}";
   offlineCacheHash = {
-    x86_64-linux = "sha256-g4PWB1EstNB7gd/yZyrXf+U8Py8OLeea0gDlEXhInhU=";
-    aarch64-linux = "sha256-g4PWB1EstNB7gd/yZyrXf+U8Py8OLeea0gDlEXhInhU=";
-    x86_64-darwin = "sha256-g4PWB1EstNB7gd/yZyrXf+U8Py8OLeea0gDlEXhInhU=";
-    aarch64-darwin = "sha256-g4PWB1EstNB7gd/yZyrXf+U8Py8OLeea0gDlEXhInhU=";
+    x86_64-linux = "sha256-bjWPoci9j3LZnOfDgmRVqQp1L2tXBwHQOryn+p5B1Mc=";
+    aarch64-linux = "sha256-bjWPoci9j3LZnOfDgmRVqQp1L2tXBwHQOryn+p5B1Mc=";
+    x86_64-darwin = "sha256-bjWPoci9j3LZnOfDgmRVqQp1L2tXBwHQOryn+p5B1Mc=";
+    aarch64-darwin = "sha256-bjWPoci9j3LZnOfDgmRVqQp1L2tXBwHQOryn+p5B1Mc=";
   }.${system} or throwSystem;
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "element-call";
-  version = "0.6.3";
+  version = "0.7.1";
 
   src = fetchFromGitHub {
     owner = "element-hq";
     repo = "element-call";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-PyxqUhnlWfcACsoFYrppO7g5e74jI4/xxXBi6oWyWsg=";
+    hash = "sha256-HmkFr2DroN1uNNH2pnRwE7vsJsEPLYU6yhroiuR/E6Q=";
   };
 
   offlineCache = fetchYarnDeps {

pkgs/by-name/gn/gnome-network-displays/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "gnome-network-displays";
-  version = "0.93.0";
+  version = "0.94.0";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gnome-network-displays/${lib.versions.majorMinor finalAttrs.version}/gnome-network-displays-${finalAttrs.version}.tar.xz";
-    sha256 = "sha256-xxvR8zR+Yglo0e9HRrSFPbgEriYpcRN5K0SXg/D0Oo4=";
+    sha256 = "sha256-FzNaA2Our7gb8FgEmYjRtphGVcQt3pw+wQNyLHtKI4M=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/go/google-alloydb-auth-proxy/package.nix

···
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+  nix-update-script,
+}:
+
+buildGoModule rec {
+  pname = "google-alloydb-auth-proxy";
+  version = "1.11.3";
+
+  src = fetchFromGitHub {
+    owner = "GoogleCloudPlatform";
+    repo = "alloydb-auth-proxy";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-MjLnGsZ4xoZpyjJQbBd3vihIA2sZ7AAhnW8Xtu7Au+U=";
+  };
+
+  subPackages = [ "." ];
+
+  vendorHash = "sha256-uUv/PqfuMAAwfcD2Sk36NcDoVWTrIVNxfoKM7cpFG5A=";
+
+  checkFlags = [
+    "-short"
+  ];
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "Utility for connecting securely to your AlloyDB instances";
+    longDescription = ''
+      The AlloyDB Auth Proxy is a binary that provides IAM-based authorization and encryption when connecting to an AlloyDB instance.
+
+      See the Connecting Overview page for more information on connecting to an AlloyDB instance, or the About the proxy page for details on how the AlloyDB Auth Proxy works.
+    '';
+    homepage = "https://github.com/GoogleCloudPlatform/alloydb-auth-proxy";
+    changelog = "https://github.com/GoogleCloudPlatform/alloydb-auth-proxy/releases/tag/v${version}";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ ShawnToubeau ];
+    mainProgram = "alloydb-auth-proxy";
+  };
+}

pkgs/by-name/ha/handbrake/package.nix

···
     VideoToolbox
     ;
   inherit (darwin) libobjc;
-  version = "1.8.2";
+  version = "1.9.0";
 
   src = fetchFromGitHub {
     owner = "HandBrake";
     repo = "HandBrake";
     # uses version commit for logic in version.txt
-    rev = "77f199ab02ff2e3bca4ca653e922e9fef67dec43";
-    hash = "sha256-vxvmyo03NcO2Nbjg76JLZqmYw7RiK4FehiB+iE3CgOw=";
+    rev = "fa9154a20f3f64fdc183a097e6b63f7fd4bc6cab";
+    hash = "sha256-Asf8NgYk4xxIkevYA0B62T8CTSaB7SHq0lHXkawVxb8=";
   };
 
   # Handbrake maintains a set of ffmpeg patches. In particular, these
···
   # https://github.com/HandBrake/HandBrake/issues/4029
   # base ffmpeg version is specified in:
   # https://github.com/HandBrake/HandBrake/blob/master/contrib/ffmpeg/module.defs
-  ffmpeg-version = "7.0.2";
+  ffmpeg-version = "7.1";
   ffmpeg-hb =
     (ffmpeg_7-full.override {
       version = ffmpeg-version;
-      hash = "sha256-6bcTxMt0rH/Nso3X7zhrFNkkmWYtxsbUqVQKh25R1Fs=";
+      hash = "sha256-erTkv156VskhYEJWjpWFvHjmcr2hr6qgUi28Ho8NFYk=";
     }).overrideAttrs
       (old: {
         patches = (old.patches or [ ]) ++ [
···
           "${src}/contrib/ffmpeg/A02-movenc-write-3gpp-track-titl-tag.patch"
           "${src}/contrib/ffmpeg/A03-mov-read-3gpp-udta-tags.patch"
           "${src}/contrib/ffmpeg/A04-movenc-write-3gpp-track-names-tags-for-all-available.patch"
-          "${src}/contrib/ffmpeg/A05-dvdsubdec-fix-processing-of-partial-packets.patch"
-          "${src}/contrib/ffmpeg/A06-dvdsubdec-return-number-of-bytes-used.patch"
-          "${src}/contrib/ffmpeg/A07-dvdsubdec-use-pts-of-initial-packet.patch"
-          "${src}/contrib/ffmpeg/A08-dvdsubdec-do-not-discard-zero-sized-rects.patch"
-          "${src}/contrib/ffmpeg/A09-ccaption_dec-fix-pts-in-real_time-mode.patch"
-          "${src}/contrib/ffmpeg/A10-matroskaenc-aac-extradata-updated.patch"
-          "${src}/contrib/ffmpeg/A11-videotoolbox-disable-H.264-10-bit-on-Intel-macOS.patch"
+          "${src}/contrib/ffmpeg/A05-avformat-mov-add-support-audio-fallback-track-ref.patch"
+          "${src}/contrib/ffmpeg/A06-dvdsubdec-fix-processing-of-partial-packets.patch"
+          "${src}/contrib/ffmpeg/A07-dvdsubdec-return-number-of-bytes-used.patch"
+          "${src}/contrib/ffmpeg/A08-dvdsubdec-use-pts-of-initial-packet.patch"
+          "${src}/contrib/ffmpeg/A09-dvdsubdec-add-an-option-to-output-subtitles-with-emp.patch"
+          "${src}/contrib/ffmpeg/A10-ccaption_dec-fix-pts-in-real_time-mode.patch"
+          "${src}/contrib/ffmpeg/A11-avformat-matroskaenc-return-error-if-aac-extradata-c.patch"
+          "${src}/contrib/ffmpeg/A12-videotoolbox-disable-H.264-10-bit-on-Intel-macOS-it-.patch"
 
           # patch to fix <https://github.com/HandBrake/HandBrake/issues/5011>
           # commented out because it causes ffmpeg's filter-pixdesc-p010le test to fail.
-          # "${src}/contrib/ffmpeg/A12-libswscale-fix-yuv420p-to-p01xle-color-conversion-bu.patch"
+          # "${src}/contrib/ffmpeg/A13-libswscale-fix-yuv420p-to-p01xle-color-conversion-bu.patch"
 
-          "${src}/contrib/ffmpeg/A13-qsv-fix-decode-10bit-hdr.patch"
-          "${src}/contrib/ffmpeg/A14-amfenc-Add-support-for-pict_type-field.patch"
-          "${src}/contrib/ffmpeg/A15-amfenc-Fixes-the-color-information-in-the-ou.patch"
-          "${src}/contrib/ffmpeg/A16-amfenc-HDR-metadata.patch"
-          "${src}/contrib/ffmpeg/A17-av1dec-dovi-rpu.patch"
-          "${src}/contrib/ffmpeg/A18-avformat-mov-add-support-audio-fallback-track-ref.patch"
+          "${src}/contrib/ffmpeg/A14-hevc_mp4toannexb.c-fix-qsv-decode-of-10bit-hdr.patch"
+          "${src}/contrib/ffmpeg/A15-Expose-the-unmodified-Dolby-Vision-RPU-T35-buffers.patch"
+          "${src}/contrib/ffmpeg/A16-avcodec-amfenc-Add-support-for-on-demand-key-frames.patch"
+          "${src}/contrib/ffmpeg/A17-avcodec-amfenc-properly-set-primaries-transfer-and-m.patch"
+          "${src}/contrib/ffmpeg/A18-Revert-avcodec-amfenc-GPU-driver-version-check.patch"
+          "${src}/contrib/ffmpeg/A19-lavc-pgssubdec-Add-graphic-plane-and-cropping.patch"
+          "${src}/contrib/ffmpeg/A28-enable-av1_mf-encoder.patch"
+          "${src}/contrib/ffmpeg/A29-Revert-lavc-Check-codec_whitelist-early-in-avcodec_o.patch"
         ];
       });
 
   x265-hb = x265.overrideAttrs (old: {
+    version = "4.1";
+    sourceRoot = "x265_4.1/source";
+    src = fetchurl {
+      url = "https://bitbucket.org/multicoreware/x265_git/downloads/x265_4.1.tar.gz";
+      hash = "sha256-oxaZxqiYBrdLAVHl5qffZd5LSQUEgv5ev4pDedevjyk=";
+    };
     # nixpkgs' x265 sourceRoot is x265-.../source whereas handbrake's x265 patches
     # are written with respect to the parent directory instead of that source directory.
     # patches which don't cleanly apply are commented out.
···
       (old.postPatch or "")
       + ''
         pushd ..
-        patch -p1 < ${src}/contrib/x265/A01-threads-priority.patch
-        patch -p1 < ${src}/contrib/x265/A02-threads-pool-adjustments.patch
-        patch -p1 < ${src}/contrib/x265/A03-sei-length-crash-fix.patch
-        patch -p1 < ${src}/contrib/x265/A04-ambient-viewing-enviroment-sei.patch
-        # patch -p1 < ${src}/contrib/x265/A05-memory-leaks.patch
-        # patch -p1 < ${src}/contrib/x265/A06-crosscompile-fix.patch
+        patch -p1 < ${src}/contrib/x265/A01-Do-not-set-thread-priority-on-Windows.patch
+        # patch -p1 < ${src}/contrib/x265/A02-Apple-Silicon-tuning.patch
+        patch -p1 < ${src}/contrib/x265/A03-fix-crash-when-SEI-length-is-variable.patch
+        patch -p1 < ${src}/contrib/x265/A04-implement-ambient-viewing-environment-sei.patch
+        # patch -p1 < ${src}/contrib/x265/A05-Fix-Dolby-Vision-RPU-memory-management.patch
+        # patch -p1 < ${src}/contrib/x265/A06-Simplify-macOS-cross-compilation.patch
+        # patch -p1 < ${src}/contrib/x265/A07-add-new-matrix-coefficients-from-H.273-v3.patch
         popd
       '';
   });
···
     optional
     optionals
     optionalString
-    versions
     ;
 
   self = stdenv.mkDerivation rec {
···
       };
     };
 
-    meta = with lib; {
+    meta = {
       homepage = "https://handbrake.fr/";
       description = "Tool for converting video files and ripping DVDs";
       longDescription = ''
···
         CLI - `HandbrakeCLI`
         GTK GUI - `ghb`
       '';
-      license = licenses.gpl2Only;
-      maintainers = with maintainers; [
+      license = lib.licenses.gpl2Only;
+      maintainers = with lib.maintainers; [
         Anton-Latukha
         wmertens
       ];
       mainProgram = "HandBrakeCLI";
-      platforms = with platforms; unix;
+      platforms = with lib.platforms; unix;
       broken = stdenv.hostPlatform.isDarwin; # https://github.com/NixOS/nixpkgs/pull/297984#issuecomment-2016503434
     };
   };

pkgs/by-name/ib/ibm-plex/hashes.nix

···
   "sans-devanagari" = "sha256-K57OVqcH5r9tZx8NFEoz1P3xpUooqpF7xxJzNmnObwE=";
   "sans-thai" = "sha256-JZVbvZdj+IfBthiqivOXHrvAUe392M9ECGsiJkm0saE=";
   "sans-thai-looped" = "sha256-cry/Ctwt1bsrdbvWkJIYWLjsvV6a1lLFsT85znqERnw=";
+  "sans-sc" = "sha256-Q3cEVlR/UkNZaGIhNMIdojId6fHmAsZdLwMsKq1zLRY=";
   "sans-tc" = "sha256-kZvzSK6fEjfVMR4kxC4lxtD7GskqvJZx8BBJVT4T9MU=";
   "sans-kr" = "sha256-FsHxMvLlI4yylgG96DOZIdW2DYpk7I+c5QgkVIkNZIE=";
   "sans-jp" = "sha256-hUl/SSkN6q3pDTtrY2mJepw3ljhhLJskGbxfsTl9TuI=";

pkgs/by-name/ib/ibm-plex/update.sh

···
     "sans-devanagari"
     "sans-thai"
     "sans-thai-looped"
+    "sans-sc"
     "sans-tc"
     "sans-kr"
     "sans-jp"

pkgs/by-name/in/intel-gmmlib/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "intel-gmmlib";
-  version = "22.5.2";
+  version = "22.5.4";
 
   src = fetchFromGitHub {
     owner = "intel";
     repo = "gmmlib";
     rev = "intel-gmmlib-${version}";
-    hash = "sha256-vc4Jk+XAXf/lq5ouCP+04YBuyeypl0XSOPUT1YkL+7A=";
+    hash = "sha256-BxWWTUVAvU3dpbcPvCvXbh5npRT5t4S3d4m2/cCj36g=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/by-name/ko/kopia/package.nix

···
 
 buildGoModule rec {
   pname = "kopia";
-  version = "0.17.0";
+  version = "0.18.2";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-Bqy9eFUvUgSdyChzh52qqPVvMi+3ad01koxVgnibbLk=";
+    hash = "sha256-7gQlBLmHvqsXXmSYllfsDJRx9VjW0AH7bXf6cG6lGOI=";
   };
 
-  vendorHash = "sha256-/NMp64JeCQjCcEYkE6lYzu/E+irTcwkmDCJhB04ALFY=";
-
-  doCheck = false;
+  vendorHash = "sha256-lCUEL7rtnv8/86ZTHM4HsYplDnWj1xsFh83JKW6qRrk=";
 
   subPackages = [ "." ];
 

pkgs/by-name/lo/lombok/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "lombok";
-  version = "1.18.34";
+  version = "1.18.36";
 
   src = fetchurl {
     url = "https://projectlombok.org/downloads/lombok-${version}.jar";
-    sha256 = "sha256-wn1rKv9WJB0bB/y8xrGDcJ5rQyyA9zdO6x2CPobUuBo=";
+    sha256 = "sha256-c7awW2otNltwC6sI0w+U3p0zZJC8Cszlthgf70jL8Y4=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/by-name/lu/lunacy/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "lunacy";
-  version = "10.0.1";
+  version = "10.9.0";
 
   src = fetchurl {
     url = "https://lcdn.icons8.com/setup/Lunacy_${finalAttrs.version}.deb";
-    hash = "sha256-roD/bKv1N2sru/tZ6Zl1J2AyY1mgj2ssB2a42kwBNHM=";
+    hash = "sha256-z5EUztSbU/8G0UE6UVgtIu6iQUY40PZYy1jDbjPIuv8=";
   };
 
   buildInputs = [

pkgs/by-name/ma/mariadb-galera/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mariadb-galera";
-  version = "26.4.20";
+  version = "26.4.21";
 
   src = fetchFromGitHub {
     owner = "codership";
     repo = "galera";
     rev = "release_${version}";
-    hash = "sha256-R2YQtAuqPkOtcvjS5PPcqAqu153N2+0/WjZt96ZSI1A=";
+    hash = "sha256-mXnQOs2WNdXORBqcfQPgDoJjbyrpypGDOkgP09JZ9Qo=";
     fetchSubmodules = true;
   };
 

pkgs/by-name/ni/nickel/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "nickel";
-  version = "1.8.1";
+  version = "1.9.0";
 
   src = fetchFromGitHub {
     owner = "tweag";
     repo = "nickel";
     rev = "refs/tags/${version}";
-    hash = "sha256-hlcF04m3SI66d1C9U1onog2QoEMfqtHb7V++47ZmeW4=";
+    hash = "sha256-chIpZqs1tyXk4YQBlF4K/Ofrn1CrijbYant9+SSppGU=";
   };
 
-  cargoHash = "sha256-VFjZb7lsqOSt5Rc94dhS4Br/5i/HXPHZMqC1c0/LzHU=";
+  cargoHash = "sha256-MaMzwvvWP+vmdBVCefXI6dehuTyPcPW2b6KdarxjBjA=";
 
   cargoBuildFlags = [ "-p nickel-lang-cli" "-p nickel-lang-lsp" ];
 
···
   ];
 
   outputs = [ "out" "nls" ];
+
+  # This fixes the way comrak is defined as a dependency, without the sed the build fails:
+  #
+  # cargo metadata failure: error: Package `nickel-lang-core v0.10.0
+  # (/build/source/core)` does not have feature `comrak`. It has an optional
+  # dependency with that name, but that dependency uses the "dep:" syntax in
+  # the features table, so it does not have an implicit feature with that name.
+  preBuild = ''
+    sed -i 's/dep:comrak/comrak/' core/Cargo.toml
+  '';
 
   postInstall = ''
     mkdir -p $nls/bin

pkgs/by-name/ni/nimdow/package.nix

···
 buildNimPackage (finalAttrs: {
   pname = "nimdow";
 
-  version = "0.7.39";
+  version = "0.7.40";
 
   src = fetchFromGitHub {
     owner = "avahe-kellenberger";
     repo = "nimdow";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-9gYlVuKDHCs6yaY1b6dJgwQUJdko6npjom4ab7nKZ7w=";
+    hash = "sha256-Q+oUmQ2ABl2nOSnHJYCrqN7dees4JBZgkb9OF4XFr5M=";
   };
 
   lockFile = ./lock.json;

pkgs/by-name/on/oneanime/package.nix

···
+{
+  lib,
+  fetchFromGitHub,
+  flutter324,
+  autoPatchelfHook,
+  wrapGAppsHook3,
+  makeDesktopItem,
+  pkg-config,
+  copyDesktopItems,
+  alsa-lib,
+  libepoxy,
+  libpulseaudio,
+  libdrm,
+  mesa,
+  xdg-user-dirs,
+  libva,
+  libva1,
+  libvdpau,
+  buildGoModule,
+}:
+let
+  libopencc = buildGoModule rec {
+    pname = "libopencc";
+    version = "1.0.0";
+
+    src = fetchFromGitHub {
+      owner = "Predidit";
+      repo = "open_chinese_convert_bridge";
+      rev = "refs/tags/${version}";
+      hash = "sha256-kC5+rIBOcwn9POvQlKEzuYKKcbhuqVs+pFd4JSFgINQ=";
+    };
+
+    vendorHash = "sha256-ADODygC9VRCdeuxnkK4396yBny/ClRUdG3zAujPzpOM=";
+
+    buildPhase = ''
+      runHook preBuild
+
+      go build -buildmode=c-shared -o ./libopencc.so
+
+      runHook postBuild
+    '';
+
+    installPhase = ''
+      runHook preInstall
+
+      install -Dm0755 ./libopencc.so $out/lib/libopencc.so
+
+      runHook postInstall
+    '';
+
+    meta = {
+      homepage = "https://github.com/Predidit/open_chinese_convert_bridge";
+      license = with lib.licenses; [ gpl3Plus ];
+      maintainers = with lib.maintainers; [ aucub ];
+    };
+  };
+in
+flutter324.buildFlutterApplication rec {
+  pname = "oneanime";
+  version = "1.3.6";
+
+  src = fetchFromGitHub {
+    owner = "Predidit";
+    repo = "oneAnime";
+    rev = "refs/tags/${version}";
+    hash = "sha256-CespZRb2JDc6FltEdibBOFd9BmkWGT8RSMbOC7cuA18=";
+  };
+
+  pubspecLock = lib.importJSON ./pubspec.lock.json;
+
+  desktopItems = [
+    (makeDesktopItem {
+      name = "oneanime";
+      exec = "oneanime";
+      icon = "oneanime";
+      desktopName = "oneAnime";
+    })
+  ];
+
+  nativeBuildInputs = [
+    pkg-config
+    autoPatchelfHook
+    wrapGAppsHook3
+    copyDesktopItems
+  ];
+
+  buildInputs = [
+    alsa-lib
+    libepoxy
+    libpulseaudio
+    libdrm
+    mesa
+  ];
+
+  postPatch = ''
+    substituteInPlace lib/pages/init_page.dart \
+      --replace-fail "lib/opencc.so" "${libopencc}/lib/libopencc.so"
+  '';
+
+  postInstall = ''
+    install -Dm0644 ./assets/images/logo/logo_android_2.png  $out/share/pixmaps/oneanime.png
+    ln -s ${lib.getLib libva}/lib/libva.so.2 $out/app/${pname}/lib/libva.so.2
+    ln -s ${lib.getLib libva1}/lib/libva.so.1 $out/app/${pname}/lib/libva.so.1
+    ln -s ${lib.getLib libvdpau}/lib/libvdpau.so.1  $out/app/${pname}/lib/libvdpau.so.1
+  '';
+
+  extraWrapProgramArgs = ''
+    --prefix PATH : ${lib.makeBinPath [ xdg-user-dirs ]}
+  '';
+
+  meta = {
+    description = "Anime1 third-party client with bullet screen";
+    homepage = "https://github.com/Predidit/oneAnime";
+    mainProgram = "oneanime";
+    license = with lib.licenses; [ gpl3Plus ];
+    maintainers = with lib.maintainers; [ aucub ];
+    platforms = [ "x86_64-linux" ]; # mdk-sdk of nixpkgs currently only has x64
+  };
+}

pkgs/by-name/on/oneanime/pubspec.lock.json

···
+{
+  "packages": {
+    "_fe_analyzer_shared": {
+      "dependency": "transitive",
+      "description": {
+        "name": "_fe_analyzer_shared",
+        "sha256": "f256b0c0ba6c7577c15e2e4e114755640a875e885099367bf6e012b19314c834",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "72.0.0"
+    },
+    "_macros": {
+      "dependency": "transitive",
+      "description": "dart",
+      "source": "sdk",
+      "version": "0.3.2"
+    },
+    "adaptive_theme": {
+      "dependency": "direct main",
+      "description": {
+        "name": "adaptive_theme",
+        "sha256": "f4ee609b464e5efc68131d9d15ba9aa1de4e3b5ede64be17781c6e19a52d637d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.6.0"
+    },
+    "analyzer": {
+      "dependency": "transitive",
+      "description": {
+        "name": "analyzer",
+        "sha256": "b652861553cd3990d8ed361f7979dc6d7053a9ac8843fa73820ab68ce5410139",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.7.0"
+    },
+    "archive": {
+      "dependency": "transitive",
+      "description": {
+        "name": "archive",
+        "sha256": "cb6a278ef2dbb298455e1a713bda08524a175630ec643a242c399c932a0a1f7d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.6.1"
+    },
+    "args": {
+      "dependency": "transitive",
+      "description": {
+        "name": "args",
+        "sha256": "bf9f5caeea8d8fe6721a9c358dd8a5c1947b27f1cfaa18b39c301273594919e6",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.6.0"
+    },
+    "async": {
+      "dependency": "transitive",
+      "description": {
+        "name": "async",
+        "sha256": "947bfcf187f74dbc5e146c9eb9c0f10c9f8b30743e341481c1e2ed3ecc18c20c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.11.0"
+    },
+    "audio_video_progress_bar": {
+      "dependency": "direct main",
+      "description": {
+        "name": "audio_video_progress_bar",
+        "sha256": "552b1f73c56c4c88407999e0a8507176f60c56de3e6d63bc20a0eab48467d4c9",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.3"
+    },
+    "auto_injector": {
+      "dependency": "transitive",
+      "description": {
+        "name": "auto_injector",
+        "sha256": "d2e204bc46d7349795364884d07ba79fe6a0f3a84a651b70dcbb68d82dcebab0",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.5"
+    },
+    "boolean_selector": {
+      "dependency": "transitive",
+      "description": {
+        "name": "boolean_selector",
+        "sha256": "6cfb5af12253eaf2b368f07bacc5a80d1301a071c73360d746b7f2e32d762c66",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.1"
+    },
+    "build": {
+      "dependency": "transitive",
+      "description": {
+        "name": "build",
+        "sha256": "80184af8b6cb3e5c1c4ec6d8544d27711700bc3e6d2efad04238c7b5290889f0",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.1"
+    },
+    "build_config": {
+      "dependency": "transitive",
+      "description": {
+        "name": "build_config",
+        "sha256": "bf80fcfb46a29945b423bd9aad884590fb1dc69b330a4d4700cac476af1708d1",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.1"
+    },
+    "build_daemon": {
+      "dependency": "transitive",
+      "description": {
+        "name": "build_daemon",
+        "sha256": "79b2aef6ac2ed00046867ed354c88778c9c0f029df8a20fe10b5436826721ef9",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.0.2"
+    },
+    "build_resolvers": {
+      "dependency": "transitive",
+      "description": {
+        "name": "build_resolvers",
+        "sha256": "339086358431fa15d7eca8b6a36e5d783728cf025e559b834f4609a1fcfb7b0a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.2"
+    },
+    "build_runner": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "build_runner",
+        "sha256": "028819cfb90051c6b5440c7e574d1896f8037e3c96cf17aaeb054c9311cfbf4d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.13"
+    },
+    "build_runner_core": {
+      "dependency": "transitive",
+      "description": {
+        "name": "build_runner_core",
+        "sha256": "f8126682b87a7282a339b871298cc12009cb67109cfa1614d6436fb0289193e0",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "7.3.2"
+    },
+    "built_collection": {
+      "dependency": "transitive",
+      "description": {
+        "name": "built_collection",
+        "sha256": "376e3dd27b51ea877c28d525560790aee2e6fbb5f20e2f85d5081027d94e2100",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "5.1.1"
+    },
+    "built_value": {
+      "dependency": "transitive",
+      "description": {
+        "name": "built_value",
+        "sha256": "c7913a9737ee4007efedaffc968c049fd0f3d0e49109e778edc10de9426005cb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "8.9.2"
+    },
+    "canvas_danmaku": {
+      "dependency": "direct main",
+      "description": {
+        "name": "canvas_danmaku",
+        "sha256": "6e220df0edd62c6787b24e00c05a24b570a716cfe9c61452f214c4ab0958374f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.2.0"
+    },
+    "characters": {
+      "dependency": "transitive",
+      "description": {
+        "name": "characters",
+        "sha256": "04a925763edad70e8443c99234dc3328f442e811f1d8fd1a72f1c8ad0f69a605",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.0"
+    },
+    "checked_yaml": {
+      "dependency": "transitive",
+      "description": {
+        "name": "checked_yaml",
+        "sha256": "feb6bed21949061731a7a75fc5d2aa727cf160b91af9a3e464c5e3a32e28b5ff",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.3"
+    },
+    "cli_util": {
+      "dependency": "transitive",
+      "description": {
+        "name": "cli_util",
+        "sha256": "c05b7406fdabc7a49a3929d4af76bcaccbbffcbcdcf185b082e1ae07da323d19",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.4.1"
+    },
+    "clock": {
+      "dependency": "transitive",
+      "description": {
+        "name": "clock",
+        "sha256": "cb6d7f03e1de671e34607e909a7213e31d7752be4fb66a86d29fe1eb14bfb5cf",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.1"
+    },
+    "code_builder": {
+      "dependency": "transitive",
+      "description": {
+        "name": "code_builder",
+        "sha256": "f692079e25e7869c14132d39f223f8eec9830eb76131925143b2129c4bb01b37",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.10.0"
+    },
+    "collection": {
+      "dependency": "transitive",
+      "description": {
+        "name": "collection",
+        "sha256": "ee67cb0715911d28db6bf4af1026078bd6f0128b07a5f66fb2ed94ec6783c09a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.18.0"
+    },
+    "connectivity_plus": {
+      "dependency": "direct main",
+      "description": {
+        "name": "connectivity_plus",
+        "sha256": "876849631b0c7dc20f8b471a2a03142841b482438e3b707955464f5ffca3e4c3",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.1.0"
+    },
+    "connectivity_plus_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "connectivity_plus_platform_interface",
+        "sha256": "42657c1715d48b167930d5f34d00222ac100475f73d10162ddf43e714932f204",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.1"
+    },
+    "convert": {
+      "dependency": "transitive",
+      "description": {
+        "name": "convert",
+        "sha256": "b30acd5944035672bc15c6b7a8b47d773e41e2f17de064350988c5d02adb1c68",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.1.2"
+    },
+    "cookie_jar": {
+      "dependency": "direct main",
+      "description": {
+        "name": "cookie_jar",
+        "sha256": "a6ac027d3ed6ed756bfce8f3ff60cb479e266f3b0fdabd6242b804b6765e52de",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.0.8"
+    },
+    "crypto": {
+      "dependency": "transitive",
+      "description": {
+        "name": "crypto",
+        "sha256": "1e445881f28f22d6140f181e07737b22f1e099a5e1ff94b0af2f9e4a463f4855",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.6"
+    },
+    "csslib": {
+      "dependency": "transitive",
+      "description": {
+        "name": "csslib",
+        "sha256": "706b5707578e0c1b4b7550f64078f0a0f19dec3f50a178ffae7006b0a9ca58fb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.0"
+    },
+    "csv": {
+      "dependency": "transitive",
+      "description": {
+        "name": "csv",
+        "sha256": "c6aa2679b2a18cb57652920f674488d89712efaf4d3fdf2e537215b35fc19d6c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.0.0"
+    },
+    "cupertino_icons": {
+      "dependency": "direct main",
+      "description": {
+        "name": "cupertino_icons",
+        "sha256": "ba631d1c7f7bef6b729a622b7b752645a2d076dba9976925b8f25725a30e1ee6",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.8"
+    },
+    "dart_style": {
+      "dependency": "transitive",
+      "description": {
+        "name": "dart_style",
+        "sha256": "7856d364b589d1f08986e140938578ed36ed948581fbc3bc9aef1805039ac5ab",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.7"
+    },
+    "dbus": {
+      "dependency": "transitive",
+      "description": {
+        "name": "dbus",
+        "sha256": "365c771ac3b0e58845f39ec6deebc76e3276aa9922b0cc60840712094d9047ac",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.7.10"
+    },
+    "device_info_plus": {
+      "dependency": "direct main",
+      "description": {
+        "name": "device_info_plus",
+        "sha256": "a7fd703482b391a87d60b6061d04dfdeab07826b96f9abd8f5ed98068acc0074",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "10.1.2"
+    },
+    "device_info_plus_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "device_info_plus_platform_interface",
+        "sha256": "282d3cf731045a2feb66abfe61bbc40870ae50a3ed10a4d3d217556c35c8c2ba",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "7.0.1"
+    },
+    "dio": {
+      "dependency": "direct main",
+      "description": {
+        "name": "dio",
+        "sha256": "5598aa796bbf4699afd5c67c0f5f6e2ed542afc956884b9cd58c306966efc260",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "5.7.0"
+    },
+    "dio_cookie_manager": {
+      "dependency": "direct main",
+      "description": {
+        "name": "dio_cookie_manager",
+        "sha256": "e79498b0f632897ff0c28d6e8178b4bc6e9087412401f618c31fa0904ace050d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.1.1"
+    },
+    "dio_web_adapter": {
+      "dependency": "transitive",
+      "description": {
+        "name": "dio_web_adapter",
+        "sha256": "33259a9276d6cea88774a0000cfae0d861003497755969c92faa223108620dc8",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.0"
+    },
+    "fake_async": {
+      "dependency": "transitive",
+      "description": {
+        "name": "fake_async",
+        "sha256": "511392330127add0b769b75a987850d136345d9227c6b94c96a04cf4a391bf78",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.1"
+    },
+    "ffi": {
+      "dependency": "direct main",
+      "description": {
+        "name": "ffi",
+        "sha256": "16ed7b077ef01ad6170a3d0c57caa4a112a38d7a2ed5602e0aca9ca6f3d98da6",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.3"
+    },
+    "ffigen": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "ffigen",
+        "sha256": "dead012f29db2be71ea152458f5eab600de98fbc244e01088ae6bf2616bceca7",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "11.0.0"
+    },
+    "file": {
+      "dependency": "transitive",
+      "description": {
+        "name": "file",
+        "sha256": "a3b4f84adafef897088c160faf7dfffb7696046cb13ae90b508c2cbc95d3b8d4",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "7.0.1"
+    },
+    "fixnum": {
+      "dependency": "transitive",
+      "description": {
+        "name": "fixnum",
+        "sha256": "b6dc7065e46c974bc7c5f143080a6764ec7a4be6da1285ececdc37be96de53be",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.1"
+    },
+    "flutter": {
+      "dependency": "direct main",
+      "description": "flutter",
+      "source": "sdk",
+      "version": "0.0.0"
+    },
+    "flutter_displaymode": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_displaymode",
+        "sha256": "42c5e9abd13d28ed74f701b60529d7f8416947e58256e6659c5550db719c57ef",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.6.0"
+    },
+    "flutter_launcher_icons": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_launcher_icons",
+        "sha256": "526faf84284b86a4cb36d20a5e45147747b7563d921373d4ee0559c54fcdbcea",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.13.1"
+    },
+    "flutter_lints": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "flutter_lints",
+        "sha256": "a25a15ebbdfc33ab1cd26c63a6ee519df92338a9c10f122adda92938253bef04",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.3"
+    },
+    "flutter_localizations": {
+      "dependency": "direct main",
+      "description": "flutter",
+      "source": "sdk",
+      "version": "0.0.0"
+    },
+    "flutter_mobx": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_mobx",
+        "sha256": "859fbf452fa9c2519d2700b125dd7fb14c508bbdd7fb65e26ca8ff6c92280e2e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.1+1"
+    },
+    "flutter_modular": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_modular",
+        "sha256": "bc17a1eb1da676b9111e59d27834fb6673bdea01aead12f0803a0847ff9d451c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.3.4"
+    },
+    "flutter_open_chinese_convert": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_open_chinese_convert",
+        "sha256": "70bdff033615b3b235da3aab8c8db1be3dbfdad3bdc80555b0346698cc3947a5",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.5.1"
+    },
+    "flutter_plugin_android_lifecycle": {
+      "dependency": "transitive",
+      "description": {
+        "name": "flutter_plugin_android_lifecycle",
+        "sha256": "9b78450b89f059e96c9ebb355fa6b3df1d6b330436e0b885fb49594c41721398",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.23"
+    },
+    "flutter_smart_dialog": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_smart_dialog",
+        "sha256": "7932ab58440379094c6a568efc329d322c6dd740e5a553080f2d56a71ed53752",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.9.8+3"
+    },
+    "flutter_test": {
+      "dependency": "direct dev",
+      "description": "flutter",
+      "source": "sdk",
+      "version": "0.0.0"
+    },
+    "flutter_volume_controller": {
+      "dependency": "direct main",
+      "description": {
+        "name": "flutter_volume_controller",
+        "sha256": "fa4c36dfe7ef7f423704f34ab8e64e00b4a30a90aa6e56f251e9dba649efcd7f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.2"
+    },
+    "flutter_web_plugins": {
+      "dependency": "transitive",
+      "description": "flutter",
+      "source": "sdk",
+      "version": "0.0.0"
+    },
+    "frontend_server_client": {
+      "dependency": "transitive",
+      "description": {
+        "name": "frontend_server_client",
+        "sha256": "f64a0333a82f30b0cca061bc3d143813a486dc086b574bfb233b7c1372427694",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.0.0"
+    },
+    "fvp": {
+      "dependency": "direct main",
+      "description": {
+        "name": "fvp",
+        "sha256": "040aa12beccd5bc60631259f27a481c4abc11a389aa4f57a47b643f58fe0b060",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.26.1"
+    },
+    "glob": {
+      "dependency": "transitive",
+      "description": {
+        "name": "glob",
+        "sha256": "0e7014b3b7d4dac1ca4d6114f82bf1782ee86745b9b42a92c9289c23d8a0ab63",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.2"
+    },
+    "graphs": {
+      "dependency": "transitive",
+      "description": {
+        "name": "graphs",
+        "sha256": "741bbf84165310a68ff28fe9e727332eef1407342fca52759cb21ad8177bb8d0",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.2"
+    },
+    "hive": {
+      "dependency": "direct main",
+      "description": {
+        "name": "hive",
+        "sha256": "8dcf6db979d7933da8217edcec84e9df1bdb4e4edc7fc77dbd5aa74356d6d941",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.3"
+    },
+    "hive_flutter": {
+      "dependency": "direct main",
+      "description": {
+        "name": "hive_flutter",
+        "sha256": "dca1da446b1d808a51689fb5d0c6c9510c0a2ba01e22805d492c73b68e33eecc",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.0"
+    },
+    "hive_generator": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "hive_generator",
+        "sha256": "06cb8f58ace74de61f63500564931f9505368f45f98958bd7a6c35ba24159db4",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.1"
+    },
+    "html": {
+      "dependency": "direct main",
+      "description": {
+        "name": "html",
+        "sha256": "3a7812d5bcd2894edf53dfaf8cd640876cf6cef50a8f238745c8b8120ea74d3a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.15.4"
+    },
+    "http": {
+      "dependency": "transitive",
+      "description": {
+        "name": "http",
+        "sha256": "b9c29a161230ee03d3ccf545097fccd9b87a5264228c5d348202e0f0c28f9010",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.2.2"
+    },
+    "http_multi_server": {
+      "dependency": "transitive",
+      "description": {
+        "name": "http_multi_server",
+        "sha256": "97486f20f9c2f7be8f514851703d0119c3596d14ea63227af6f7a481ef2b2f8b",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.2.1"
+    },
+    "http_parser": {
+      "dependency": "transitive",
+      "description": {
+        "name": "http_parser",
+        "sha256": "2aa08ce0341cc9b354a498388e30986515406668dbcc4f7c950c3e715496693b",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.0.2"
+    },
+    "image": {
+      "dependency": "transitive",
+      "description": {
+        "name": "image",
+        "sha256": "f31d52537dc417fdcde36088fdf11d191026fd5e4fae742491ebd40e5a8bea7d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.3.0"
+    },
+    "intl": {
+      "dependency": "transitive",
+      "description": {
+        "name": "intl",
+        "sha256": "d6f56758b7d3014a48af9701c085700aac781a92a87a62b1333b46d8879661cf",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.19.0"
+    },
+    "io": {
+      "dependency": "transitive",
+      "description": {
+        "name": "io",
+        "sha256": "2ec25704aba361659e10e3e5f5d672068d332fc8ac516421d483a11e5cbd061e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.4"
+    },
+    "js": {
+      "dependency": "transitive",
+      "description": {
+        "name": "js",
+        "sha256": "c1b2e9b5ea78c45e1a0788d29606ba27dc5f71f019f32ca5140f61ef071838cf",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.7.1"
+    },
+    "json2yaml": {
+      "dependency": "transitive",
+      "description": {
+        "name": "json2yaml",
+        "sha256": "da94630fbc56079426fdd167ae58373286f603371075b69bf46d848d63ba3e51",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.1"
+    },
+    "json_annotation": {
+      "dependency": "transitive",
+      "description": {
+        "name": "json_annotation",
+        "sha256": "1ce844379ca14835a50d2f019a3099f419082cfdd231cd86a142af94dd5c6bb1",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.9.0"
+    },
+    "leak_tracker": {
+      "dependency": "transitive",
+      "description": {
+        "name": "leak_tracker",
+        "sha256": "3f87a60e8c63aecc975dda1ceedbc8f24de75f09e4856ea27daf8958f2f0ce05",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "10.0.5"
+    },
+    "leak_tracker_flutter_testing": {
+      "dependency": "transitive",
+      "description": {
+        "name": "leak_tracker_flutter_testing",
+        "sha256": "932549fb305594d82d7183ecd9fa93463e9914e1b67cacc34bc40906594a1806",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.5"
+    },
+    "leak_tracker_testing": {
+      "dependency": "transitive",
+      "description": {
+        "name": "leak_tracker_testing",
+        "sha256": "6ba465d5d76e67ddf503e1161d1f4a6bc42306f9d66ca1e8f079a47290fb06d3",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.1"
+    },
+    "lints": {
+      "dependency": "transitive",
+      "description": {
+        "name": "lints",
+        "sha256": "0a217c6c989d21039f1498c3ed9f3ed71b354e69873f13a8dfc3c9fe76f1b452",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.1"
+    },
+    "logging": {
+      "dependency": "transitive",
+      "description": {
+        "name": "logging",
+        "sha256": "c8245ada5f1717ed44271ed1c26b8ce85ca3228fd2ffdb75468ab01979309d61",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.0"
+    },
+    "macros": {
+      "dependency": "transitive",
+      "description": {
+        "name": "macros",
+        "sha256": "0acaed5d6b7eab89f63350bccd82119e6c602df0f391260d0e32b5e23db79536",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.1.2-main.4"
+    },
+    "matcher": {
+      "dependency": "transitive",
+      "description": {
+        "name": "matcher",
+        "sha256": "d2323aa2060500f906aa31a895b4030b6da3ebdcc5619d14ce1aada65cd161cb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.12.16+1"
+    },
+    "material_color_utilities": {
+      "dependency": "transitive",
+      "description": {
+        "name": "material_color_utilities",
+        "sha256": "f7142bb1154231d7ea5f96bc7bde4bda2a0945d2806bb11670e30b850d56bdec",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.11.1"
+    },
+    "meta": {
+      "dependency": "transitive",
+      "description": {
+        "name": "meta",
+        "sha256": "bdb68674043280c3428e9ec998512fb681678676b3c54e773629ffe74419f8c7",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.15.0"
+    },
+    "mime": {
+      "dependency": "transitive",
+      "description": {
+        "name": "mime",
+        "sha256": "41a20518f0cb1256669420fdba0cd90d21561e560ac240f26ef8322e45bb7ed6",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.0"
+    },
+    "mobx": {
+      "dependency": "direct main",
+      "description": {
+        "name": "mobx",
+        "sha256": "63920b27b32ad1910adfe767ab1750e4c212e8923232a1f891597b362074ea5e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.3+2"
+    },
+    "mobx_codegen": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "mobx_codegen",
+        "sha256": "8e0d8653a0c720ad933cd8358f6f89f740ce89203657c13f25bea772ef1fff7c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.6.1"
+    },
+    "modular_core": {
+      "dependency": "transitive",
+      "description": {
+        "name": "modular_core",
+        "sha256": "bd60317c81cff3a510aca19d6ddd661c7c79e3cba97b9f39e9ad199156ff255d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.3.3"
+    },
+    "nested": {
+      "dependency": "transitive",
+      "description": {
+        "name": "nested",
+        "sha256": "03bac4c528c64c95c722ec99280375a6f2fc708eec17c7b3f07253b626cd2a20",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.0"
+    },
+    "nm": {
+      "dependency": "transitive",
+      "description": {
+        "name": "nm",
+        "sha256": "2c9aae4127bdc8993206464fcc063611e0e36e72018696cd9631023a31b24254",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.5.0"
+    },
+    "package_config": {
+      "dependency": "transitive",
+      "description": {
+        "name": "package_config",
+        "sha256": "1c5b77ccc91e4823a5af61ee74e6b972db1ef98c2ff5a18d3161c982a55448bd",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.0"
+    },
+    "package_info_plus": {
+      "dependency": "transitive",
+      "description": {
+        "name": "package_info_plus",
+        "sha256": "df3eb3e0aed5c1107bb0fdb80a8e82e778114958b1c5ac5644fb1ac9cae8a998",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "8.1.0"
+    },
+    "package_info_plus_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "package_info_plus_platform_interface",
+        "sha256": "ac1f4a4847f1ade8e6a87d1f39f5d7c67490738642e2542f559ec38c37489a66",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.1"
+    },
+    "path": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path",
+        "sha256": "087ce49c3f0dc39180befefc60fdb4acd8f8620e5682fe2476afd0b3688bb4af",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.9.0"
+    },
+    "path_provider": {
+      "dependency": "direct main",
+      "description": {
+        "name": "path_provider",
+        "sha256": "fec0d61223fba3154d87759e3cc27fe2c8dc498f6386c6d6fc80d1afdd1bf378",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.4"
+    },
+    "path_provider_android": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path_provider_android",
+        "sha256": "c464428172cb986b758c6d1724c603097febb8fb855aa265aeecc9280c294d4a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.12"
+    },
+    "path_provider_foundation": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path_provider_foundation",
+        "sha256": "f234384a3fdd67f989b4d54a5d73ca2a6c422fa55ae694381ae0f4375cd1ea16",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.0"
+    },
+    "path_provider_linux": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path_provider_linux",
+        "sha256": "f7a1fe3a634fe7734c8d3f2766ad746ae2a2884abe22e241a8b301bf5cac3279",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.1"
+    },
+    "path_provider_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path_provider_platform_interface",
+        "sha256": "88f5779f72ba699763fa3a3b06aa4bf6de76c8e5de842cf6f29e2e06476c2334",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.2"
+    },
+    "path_provider_windows": {
+      "dependency": "transitive",
+      "description": {
+        "name": "path_provider_windows",
+        "sha256": "bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.0"
+    },
+    "petitparser": {
+      "dependency": "transitive",
+      "description": {
+        "name": "petitparser",
+        "sha256": "c15605cd28af66339f8eb6fbe0e541bfe2d1b72d5825efc6598f3e0a31b9ad27",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.0.2"
+    },
+    "platform": {
+      "dependency": "transitive",
+      "description": {
+        "name": "platform",
+        "sha256": "5d6b1b0036a5f331ebc77c850ebc8506cbc1e9416c27e59b439f917a902a4984",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.1.6"
+    },
+    "plugin_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "plugin_platform_interface",
+        "sha256": "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.8"
+    },
+    "pool": {
+      "dependency": "transitive",
+      "description": {
+        "name": "pool",
+        "sha256": "20fe868b6314b322ea036ba325e6fc0711a22948856475e2c2b6306e8ab39c2a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.5.1"
+    },
+    "provider": {
+      "dependency": "direct main",
+      "description": {
+        "name": "provider",
+        "sha256": "c8a055ee5ce3fd98d6fc872478b03823ffdb448699c6ebdbbc71d59b596fd48c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.1.2"
+    },
+    "pub_semver": {
+      "dependency": "transitive",
+      "description": {
+        "name": "pub_semver",
+        "sha256": "40d3ab1bbd474c4c2328c91e3a7df8c6dd629b79ece4c4bd04bee496a224fb0c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.4"
+    },
+    "pubspec_parse": {
+      "dependency": "transitive",
+      "description": {
+        "name": "pubspec_parse",
+        "sha256": "c799b721d79eb6ee6fa56f00c04b472dcd44a30d258fac2174a6ec57302678f8",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.0"
+    },
+    "quiver": {
+      "dependency": "transitive",
+      "description": {
+        "name": "quiver",
+        "sha256": "ea0b925899e64ecdfbf9c7becb60d5b50e706ade44a85b2363be2a22d88117d2",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.2.2"
+    },
+    "result_dart": {
+      "dependency": "transitive",
+      "description": {
+        "name": "result_dart",
+        "sha256": "3c69c864a08df0f413a86be211d07405e9a53cc1ac111e3cc8365845a0fb5288",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.1"
+    },
+    "screen_brightness": {
+      "dependency": "direct main",
+      "description": {
+        "name": "screen_brightness",
+        "sha256": "7d4ac84ae26b37c01d6f5db7123a72db7933e1f2a2a8c369a51e08f81b3178d8",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_brightness_android": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_brightness_android",
+        "sha256": "8c69d3ac475e4d625e7fa682a3a51a69ff59abe5b4a9e57f6ec7d830a6c69bd6",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_brightness_ios": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_brightness_ios",
+        "sha256": "f08f70ca1ac3e30719764b5cfb8b3fe1e28163065018a41b3e6f243ab146c2f1",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_brightness_macos": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_brightness_macos",
+        "sha256": "70c2efa4534e22b927e82693488f127dd4a0f008469fccf4f0eefe9061bbdd6a",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_brightness_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_brightness_platform_interface",
+        "sha256": "9f3ebf7f22d5487e7676fe9ddaf3fc55b6ff8057707cf6dc0121c7dfda346a16",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_brightness_windows": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_brightness_windows",
+        "sha256": "c8e12a91cf6dd912a48bd41fcf749282a51afa17f536c3460d8d05702fb89ffa",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "screen_pixel": {
+      "dependency": "direct main",
+      "description": {
+        "name": "screen_pixel",
+        "sha256": "b7310d81d98289ba1d6fb381ec95094b30b43ee1e901fefb65a3cf4de7d77e6b",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.0.3"
+    },
+    "screen_retriever": {
+      "dependency": "transitive",
+      "description": {
+        "name": "screen_retriever",
+        "sha256": "6ee02c8a1158e6dae7ca430da79436e3b1c9563c8cf02f524af997c201ac2b90",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.1.9"
+    },
+    "shared_preferences": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences",
+        "sha256": "746e5369a43170c25816cc472ee016d3a66bc13fcf430c0bc41ad7b4b2922051",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.2"
+    },
+    "shared_preferences_android": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_android",
+        "sha256": "3b9febd815c9ca29c9e3520d50ec32f49157711e143b7a4ca039eb87e8ade5ab",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.3"
+    },
+    "shared_preferences_foundation": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_foundation",
+        "sha256": "07e050c7cd39bad516f8d64c455f04508d09df104be326d8c02551590a0d513d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.5.3"
+    },
+    "shared_preferences_linux": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_linux",
+        "sha256": "580abfd40f415611503cae30adf626e6656dfb2f0cee8f465ece7b6defb40f2f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.1"
+    },
+    "shared_preferences_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_platform_interface",
+        "sha256": "57cbf196c486bc2cf1f02b85784932c6094376284b3ad5779d1b1c6c6a816b80",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.1"
+    },
+    "shared_preferences_web": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_web",
+        "sha256": "d2ca4132d3946fec2184261726b355836a82c33d7d5b67af32692aff18a4684e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.2"
+    },
+    "shared_preferences_windows": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shared_preferences_windows",
+        "sha256": "94ef0f72b2d71bc3e700e025db3710911bd51a71cefb65cc609dd0d9a982e3c1",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.4.1"
+    },
+    "shelf": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shelf",
+        "sha256": "ad29c505aee705f41a4d8963641f91ac4cee3c8fad5947e033390a7bd8180fa4",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.4.1"
+    },
+    "shelf_web_socket": {
+      "dependency": "transitive",
+      "description": {
+        "name": "shelf_web_socket",
+        "sha256": "073c147238594ecd0d193f3456a5fe91c4b0abbcc68bf5cd95b36c4e194ac611",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.0.0"
+    },
+    "sky_engine": {
+      "dependency": "transitive",
+      "description": "flutter",
+      "source": "sdk",
+      "version": "0.0.99"
+    },
+    "slang": {
+      "dependency": "direct main",
+      "description": {
+        "name": "slang",
+        "sha256": "a466773de768eb95bdf681e0a92e7c8010d44bb247b62130426c83ece33aeaed",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.32.0"
+    },
+    "slang_build_runner": {
+      "dependency": "direct dev",
+      "description": {
+        "name": "slang_build_runner",
+        "sha256": "b2e0c63f3c801a4aa70b4ca43173893d6eb7d5a421fc9d97ad983527397631b3",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.32.0"
+    },
+    "slang_flutter": {
+      "dependency": "direct main",
+      "description": {
+        "name": "slang_flutter",
+        "sha256": "1a98e878673996902fa5ef0b61ce5c245e41e4d25640d18af061c6aab917b0c7",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.32.0"
+    },
+    "source_gen": {
+      "dependency": "transitive",
+      "description": {
+        "name": "source_gen",
+        "sha256": "14658ba5f669685cd3d63701d01b31ea748310f7ab854e471962670abcf57832",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.5.0"
+    },
+    "source_helper": {
+      "dependency": "transitive",
+      "description": {
+        "name": "source_helper",
+        "sha256": "6adebc0006c37dd63fe05bca0a929b99f06402fc95aa35bf36d67f5c06de01fd",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.3.4"
+    },
+    "source_span": {
+      "dependency": "transitive",
+      "description": {
+        "name": "source_span",
+        "sha256": "53e943d4206a5e30df338fd4c6e7a077e02254531b138a15aec3bd143c1a8b3c",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.10.0"
+    },
+    "sprintf": {
+      "dependency": "transitive",
+      "description": {
+        "name": "sprintf",
+        "sha256": "1fc9ffe69d4df602376b52949af107d8f5703b77cda567c4d7d86a0693120f23",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "7.0.0"
+    },
+    "stack_trace": {
+      "dependency": "transitive",
+      "description": {
+        "name": "stack_trace",
+        "sha256": "73713990125a6d93122541237550ee3352a2d84baad52d375a4cad2eb9b7ce0b",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.11.1"
+    },
+    "stream_channel": {
+      "dependency": "transitive",
+      "description": {
+        "name": "stream_channel",
+        "sha256": "ba2aa5d8cc609d96bbb2899c28934f9e1af5cddbd60a827822ea467161eb54e7",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.2"
+    },
+    "stream_transform": {
+      "dependency": "transitive",
+      "description": {
+        "name": "stream_transform",
+        "sha256": "14a00e794c7c11aa145a170587321aedce29769c08d7f58b1d141da75e3b1c6f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.0"
+    },
+    "string_scanner": {
+      "dependency": "transitive",
+      "description": {
+        "name": "string_scanner",
+        "sha256": "556692adab6cfa87322a115640c11f13cb77b3f076ddcc5d6ae3c20242bedcde",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.2.0"
+    },
+    "term_glyph": {
+      "dependency": "transitive",
+      "description": {
+        "name": "term_glyph",
+        "sha256": "a29248a84fbb7c79282b40b8c72a1209db169a2e0542bce341da992fe1bc7e84",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.2.1"
+    },
+    "test_api": {
+      "dependency": "transitive",
+      "description": {
+        "name": "test_api",
+        "sha256": "5b8a98dafc4d5c4c9c72d8b31ab2b23fc13422348d2997120294d3bac86b4ddb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.7.2"
+    },
+    "timing": {
+      "dependency": "transitive",
+      "description": {
+        "name": "timing",
+        "sha256": "70a3b636575d4163c477e6de42f247a23b315ae20e86442bebe32d3cabf61c32",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.0.1"
+    },
+    "typed_data": {
+      "dependency": "transitive",
+      "description": {
+        "name": "typed_data",
+        "sha256": "f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.4.0"
+    },
+    "universal_io": {
+      "dependency": "transitive",
+      "description": {
+        "name": "universal_io",
+        "sha256": "1722b2dcc462b4b2f3ee7d188dad008b6eb4c40bbd03a3de451d82c78bba9aad",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.2"
+    },
+    "url_launcher": {
+      "dependency": "direct main",
+      "description": {
+        "name": "url_launcher",
+        "sha256": "9d06212b1362abc2f0f0d78e6f09f726608c74e3b9462e8368bb03314aa8d603",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.3.1"
+    },
+    "url_launcher_android": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_android",
+        "sha256": "8fc3bae0b68c02c47c5c86fa8bfa74471d42687b0eded01b78de87872db745e2",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.3.12"
+    },
+    "url_launcher_ios": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_ios",
+        "sha256": "e43b677296fadce447e987a2f519dcf5f6d1e527dc35d01ffab4fff5b8a7063e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.3.1"
+    },
+    "url_launcher_linux": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_linux",
+        "sha256": "e2b9622b4007f97f504cd64c0128309dfb978ae66adbe944125ed9e1750f06af",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.2.0"
+    },
+    "url_launcher_macos": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_macos",
+        "sha256": "769549c999acdb42b8bcfa7c43d72bf79a382ca7441ab18a808e101149daf672",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.2.1"
+    },
+    "url_launcher_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_platform_interface",
+        "sha256": "552f8a1e663569be95a8190206a38187b531910283c3e982193e4f2733f01029",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.2"
+    },
+    "url_launcher_web": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_web",
+        "sha256": "772638d3b34c779ede05ba3d38af34657a05ac55b06279ea6edd409e323dca8e",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.3"
+    },
+    "url_launcher_windows": {
+      "dependency": "transitive",
+      "description": {
+        "name": "url_launcher_windows",
+        "sha256": "44cf3aabcedde30f2dba119a9dea3b0f2672fbe6fa96e85536251d678216b3c4",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.1.3"
+    },
+    "uuid": {
+      "dependency": "transitive",
+      "description": {
+        "name": "uuid",
+        "sha256": "a5be9ef6618a7ac1e964353ef476418026db906c4facdedaa299b7a2e71690ff",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "4.5.1"
+    },
+    "vector_math": {
+      "dependency": "transitive",
+      "description": {
+        "name": "vector_math",
+        "sha256": "80b3257d1492ce4d091729e3a67a60407d227c27241d6927be0130c98e741803",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.1.4"
+    },
+    "video_player": {
+      "dependency": "direct main",
+      "description": {
+        "name": "video_player",
+        "sha256": "4a8c3492d734f7c39c2588a3206707a05ee80cef52e8c7f3b2078d430c84bc17",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.9.2"
+    },
+    "video_player_android": {
+      "dependency": "transitive",
+      "description": {
+        "name": "video_player_android",
+        "sha256": "2800d68d6d5b4c22da62453568ed68e63c35bea524d4fa42062e53d6bb591433",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.7.13"
+    },
+    "video_player_avfoundation": {
+      "dependency": "transitive",
+      "description": {
+        "name": "video_player_avfoundation",
+        "sha256": "cd5ab8a8bc0eab65ab0cea40304097edc46da574c8c1ecdee96f28cd8ef3792f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.6.2"
+    },
+    "video_player_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "video_player_platform_interface",
+        "sha256": "229d7642ccd9f3dc4aba169609dd6b5f3f443bb4cc15b82f7785fcada5af9bbb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.2.3"
+    },
+    "video_player_web": {
+      "dependency": "transitive",
+      "description": {
+        "name": "video_player_web",
+        "sha256": "6dcdd298136523eaf7dfc31abaf0dfba9aa8a8dbc96670e87e9d42b6f2caf774",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.3.2"
+    },
+    "vm_service": {
+      "dependency": "transitive",
+      "description": {
+        "name": "vm_service",
+        "sha256": "5c5f338a667b4c644744b661f309fb8080bb94b18a7e91ef1dbd343bed00ed6d",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "14.2.5"
+    },
+    "wakelock_plus": {
+      "dependency": "direct main",
+      "description": {
+        "name": "wakelock_plus",
+        "sha256": "bf4ee6f17a2fa373ed3753ad0e602b7603f8c75af006d5b9bdade263928c0484",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.2.8"
+    },
+    "wakelock_plus_platform_interface": {
+      "dependency": "transitive",
+      "description": {
+        "name": "wakelock_plus_platform_interface",
+        "sha256": "422d1cdbb448079a8a62a5a770b69baa489f8f7ca21aef47800c726d404f9d16",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.2.1"
+    },
+    "watcher": {
+      "dependency": "transitive",
+      "description": {
+        "name": "watcher",
+        "sha256": "3d2ad6751b3c16cf07c7fca317a1413b3f26530319181b37e3b9039b84fc01d8",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.0"
+    },
+    "web": {
+      "dependency": "transitive",
+      "description": {
+        "name": "web",
+        "sha256": "cd3543bd5798f6ad290ea73d210f423502e71900302dde696f8bff84bf89a1cb",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.0"
+    },
+    "web_socket": {
+      "dependency": "transitive",
+      "description": {
+        "name": "web_socket",
+        "sha256": "3c12d96c0c9a4eec095246debcea7b86c0324f22df69893d538fcc6f1b8cce83",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.1.6"
+    },
+    "web_socket_channel": {
+      "dependency": "transitive",
+      "description": {
+        "name": "web_socket_channel",
+        "sha256": "9f187088ed104edd8662ca07af4b124465893caf063ba29758f97af57e61da8f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.0.1"
+    },
+    "win32": {
+      "dependency": "transitive",
+      "description": {
+        "name": "win32",
+        "sha256": "e1d0cc62e65dc2561f5071fcbccecf58ff20c344f8f3dc7d4922df372a11df1f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "5.7.1"
+    },
+    "win32_registry": {
+      "dependency": "transitive",
+      "description": {
+        "name": "win32_registry",
+        "sha256": "21ec76dfc731550fd3e2ce7a33a9ea90b828fdf19a5c3bcf556fa992cfa99852",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.5"
+    },
+    "window_manager": {
+      "dependency": "direct main",
+      "description": {
+        "name": "window_manager",
+        "sha256": "ab8b2a7f97543d3db2b506c9d875e637149d48ee0c6a5cb5f5fd6e0dac463792",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "0.4.2"
+    },
+    "xdg_directories": {
+      "dependency": "transitive",
+      "description": {
+        "name": "xdg_directories",
+        "sha256": "7a3f37b05d989967cdddcbb571f1ea834867ae2faa29725fd085180e0883aa15",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "1.1.0"
+    },
+    "xml": {
+      "dependency": "transitive",
+      "description": {
+        "name": "xml",
+        "sha256": "b015a8ad1c488f66851d762d3090a21c600e479dc75e68328c52774040cf9226",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "6.5.0"
+    },
+    "yaml": {
+      "dependency": "transitive",
+      "description": {
+        "name": "yaml",
+        "sha256": "75769501ea3489fca56601ff33454fe45507ea3bfb014161abc3b43ae25989d5",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "3.1.2"
+    },
+    "yaml_edit": {
+      "dependency": "transitive",
+      "description": {
+        "name": "yaml_edit",
+        "sha256": "e9c1a3543d2da0db3e90270dbb1e4eebc985ee5e3ffe468d83224472b2194a5f",
+        "url": "https://pub.dev"
+      },
+      "source": "hosted",
+      "version": "2.2.1"
+    }
+  },
+  "sdks": {
+    "dart": ">=3.5.0 <4.0.0",
+    "flutter": ">=3.24.4"
+  }
+}

pkgs/by-name/pt/ptyxis/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "ptyxis";
-  version = "47.4";
+  version = "47.5";
 
   src = fetchFromGitLab {
     domain = "gitlab.gnome.org";
     owner = "chergert";
     repo = "ptyxis";
     rev = finalAttrs.version;
-    hash = "sha256-G2WesIaz+eYiDExyMi6Ww2cHMthuxAX5b+B68dz6Yb0=";
+    hash = "sha256-h5e+H4Tf7T1poM1Srf/ZINk5chScXNFLaEqtlMgrhHs=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ra/raycast/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "raycast";
-  version = "1.86.0";
+  version = "1.87.2";
 
   src = fetchurl {
     name = "Raycast.dmg";
     url = "https://releases.raycast.com/releases/${finalAttrs.version}/download?build=universal";
-    hash = "sha256-UvMPRLCaGgunpVwoF0Nbz+7Gma7zQP+nMMh5Cvqn0MA=";
+    hash = "sha256-w4jrtrKCATUsFkMVsGee88pYiL1bahHaSy9emCh2GJE=";
   };
 
   dontPatch = true;

pkgs/by-name/re/reviewdog/package.nix

···
 
 buildGoModule rec {
   pname = "reviewdog";
-  version = "0.20.2";
+  version = "0.20.3";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-UB2cylJn90TE3ng9JaPwmpbkhuPOmRnlS/eCZSjfqwQ=";
+    hash = "sha256-B0gu6vhbnhMx2CNQzQlIIwsycBup6bnmAk/1C6F/AWE=";
   };
 
-  vendorHash = "sha256-hFmUhA35J1c2Mp7SeaJF4+Jid8GfdsEiF7lEdPoYbS4=";
+  vendorHash = "sha256-k7o2r9CQNDVGgCGoYZ02nK443eolN+UGdEp2ItEkURg=";
 
   doCheck = false;
 

pkgs/by-name/ro/roslyn-ls/deps.nix

···
   (fetchNuGet { pname = "Humanizer.Core"; version = "2.14.1"; hash = "sha256-EXvojddPu+9JKgOG9NSQgUTfWq1RpOYw7adxDPKDJ6o="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/humanizer.core/2.14.1/humanizer.core.2.14.1.nupkg"; })
   (fetchNuGet { pname = "ICSharpCode.Decompiler"; version = "8.1.1.7464"; hash = "sha256-71/e9zuQIfqRXOiWxZkUFW/tMAj63nE8tg/sR7bGzuM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/icsharpcode.decompiler/8.1.1.7464/icsharpcode.decompiler.8.1.1.7464.nupkg"; })
   (fetchNuGet { pname = "MessagePack"; version = "2.5.108"; hash = "sha256-+vMXyEbfutY5WOFuFnNF24uLcKJTTdntVrVlSJH4yjI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack/2.5.108/messagepack.2.5.108.nupkg"; })
+  (fetchNuGet { pname = "MessagePack"; version = "2.5.124"; hash = "sha256-3ZUXCiDKpD82W+prJ5yLFm/gmztNsm8W0NPRs74bgrw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack/2.5.124/messagepack.2.5.124.nupkg"; })
   (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.5.108"; hash = "sha256-u3Qu8UftNIz3oIzQUMa7Z0G6VzmDLcAnAeNQ3lB3YVk="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack.annotations/2.5.108/messagepack.annotations.2.5.108.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace"; version = "9.0.0-preview.24366.2"; hash = "sha256-SUZfSiONzmTwDQsaTd7VTkE6IrzSu80giAPwrjvuY7M="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.aspnetcore.razor.externalaccess.roslynworkspace/9.0.0-preview.24366.2/microsoft.aspnetcore.razor.externalaccess.roslynworkspace.9.0.0-preview.24366.2.nupkg"; })
+  (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.5.124"; hash = "sha256-4zgAUW6py8CA2hMGUUrHr7Q6vKeRBqOCmcKgAR9fRGg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/messagepack.annotations/2.5.124/messagepack.annotations.2.5.124.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace"; version = "9.0.0-preview.24555.12"; hash = "sha256-SMOU22F2xZkFM6KRRETeRR79BuVccALMGH+zcgyqq4M="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.aspnetcore.razor.externalaccess.roslynworkspace/9.0.0-preview.24555.12/microsoft.aspnetcore.razor.externalaccess.roslynworkspace.9.0.0-preview.24555.12.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "8.0.0"; hash = "sha256-9aWmiwMJKrKr9ohD1KSuol37y+jdDxPGJct3m2/Bknw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.bcl.asyncinterfaces/8.0.0/microsoft.bcl.asyncinterfaces.8.0.0.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.Build"; version = "17.10.4"; hash = "sha256-yaElGdmgcELCXR5fIe5/ingMx2qS/PM3tZGTPNHHjXo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build/17.10.4/microsoft.build.17.10.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.Build"; version = "17.12.0-preview-24426-07"; hash = "sha256-OHQd2npzibOaNSR2sq3NrKKtAALOmnIARmFoBaXiJ0k="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.build/17.12.0-preview-24426-07/microsoft.build.17.12.0-preview-24426-07.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build"; version = "17.3.4"; hash = "sha256-LHtjk4vxeVSLzAKAcG8BN+S20d2sUR2DAOsSXLNIy5U="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.build/17.3.4/microsoft.build.17.3.4.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build"; version = "17.7.2"; hash = "sha256-k35nFdPxC8t0zAltVSmAJtsepp/ubNIjPOsJ6k8jSqM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build/17.7.2/microsoft.build.17.7.2.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.Build.Framework"; version = "17.10.4"; hash = "sha256-J9N2VDoyd2P0e4PLhI3XsYsiyE0vKSIerhglV0FW+Bk="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.framework/17.10.4/microsoft.build.framework.17.10.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.Build.Framework"; version = "17.12.0-preview-24426-07"; hash = "sha256-p5JNAp442gjiu14gfM4eF477iT9Ttac8ALHXISbsecs="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.build.framework/17.12.0-preview-24426-07/microsoft.build.framework.17.12.0-preview-24426-07.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Framework"; version = "17.3.4"; hash = "sha256-p2JG7pMBGfDVP6sOzBOqOkImZmwotlGvfS+8BjjVYf8="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.build.framework/17.3.4/microsoft.build.framework.17.3.4.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Framework"; version = "17.7.2"; hash = "sha256-fNWmVQYFTJDveAGmxEdNqJRAczV6+Ep8RA8clKBJFqw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.framework/17.7.2/microsoft.build.framework.17.7.2.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Locator"; version = "1.6.10"; hash = "sha256-hOFFiQiCNkkDqt0Ad/4Y/sggj4t0zWXmfGjE+I/cqqM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.locator/1.6.10/microsoft.build.locator.1.6.10.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.Build.Tasks.Core"; version = "17.10.4"; hash = "sha256-paqlEbSdV5euFvWQ4khlIcsTxIGQ1/YpoM/XXDQSPBY="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.tasks.core/17.10.4/microsoft.build.tasks.core.17.10.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.Build.Tasks.Core"; version = "17.12.0-preview-24426-07"; hash = "sha256-2igOkxetlTeRv2Xq5wVcQXU7hxdP43yMJq3aK6vndoI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.build.tasks.core/17.12.0-preview-24426-07/microsoft.build.tasks.core.17.12.0-preview-24426-07.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Tasks.Core"; version = "17.3.4"; hash = "sha256-0RA95pD6zHBf1lgYyrrAuEuNeGwuCgGxNdhEJ0cJUCs="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.build.tasks.core/17.3.4/microsoft.build.tasks.core.17.3.4.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Tasks.Core"; version = "17.7.2"; hash = "sha256-OrV/qWgZHzGlNUmaSfX5wDBcmg1aQeF3/OUHpSH+uZU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.tasks.core/17.7.2/microsoft.build.tasks.core.17.7.2.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.Build.Utilities.Core"; version = "17.10.4"; hash = "sha256-eHEObY1YqK/+hOJmUzSu7u/dKp/OX5qQOWk07rEUReQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.utilities.core/17.10.4/microsoft.build.utilities.core.17.10.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.Build.Utilities.Core"; version = "17.12.0-preview-24426-07"; hash = "sha256-np372GONmrZJ8ppPxjZrvtofA5gTnUf2n/Pn9f02ilo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.build.utilities.core/17.12.0-preview-24426-07/microsoft.build.utilities.core.17.12.0-preview-24426-07.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Utilities.Core"; version = "17.3.4"; hash = "sha256-SfZxr5xDANnDnC1HCUgho2H9MnF6n51cM47Rrf07fWw="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.build.utilities.core/17.3.4/microsoft.build.utilities.core.17.3.4.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Build.Utilities.Core"; version = "17.7.2"; hash = "sha256-oatF0KfuP1nb4+OLNKg2/R/ZLO4EiACaO5leaxMEY4A="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.build.utilities.core/17.7.2/microsoft.build.utilities.core.17.7.2.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.3.4"; hash = "sha256-qDzTfZBSCvAUu9gzq2k+LOvh6/eRvJ9++VCNck/ZpnE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.codeanalysis.analyzers/3.3.4/microsoft.codeanalysis.analyzers.3.3.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.11.0"; hash = "sha256-hQ2l6E6PO4m7i+ZsfFlEx+93UsLPo4IY3wDkNG11/Sw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.codeanalysis.analyzers/3.11.0/microsoft.codeanalysis.analyzers.3.11.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.AnalyzerUtilities"; version = "3.3.0"; hash = "sha256-nzFs+H0FFEgZzjl/bcmWyQQVKS2PncS6kMYHOqrxXSw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.codeanalysis.analyzerutilities/3.3.0/microsoft.codeanalysis.analyzerutilities.3.3.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.BannedApiAnalyzers"; version = "3.11.0-beta1.24081.1"; hash = "sha256-5UN//A8oc2w+UoxAwWmXWRXykQD+2mpa1hbJrAfh2Lg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a54510f9-4b2c-4e69-b96a-6096683aaa1f/nuget/v3/flat2/microsoft.codeanalysis.bannedapianalyzers/3.11.0-beta1.24081.1/microsoft.codeanalysis.bannedapianalyzers.3.11.0-beta1.24081.1.nupkg"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "4.1.0"; hash = "sha256-g3RLyeHfdOOF6H89VLJi06/k8/eJ6j2dgNYZ/MBdfNU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.codeanalysis.common/4.1.0/microsoft.codeanalysis.common.4.1.0.nupkg"; })
···
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.PublicApiAnalyzers"; version = "3.11.0-beta1.24081.1"; hash = "sha256-nXx0MSYXVzdr0jcNo9aZLocZU1ywN+n/vdD2kYBh5TI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a54510f9-4b2c-4e69-b96a-6096683aaa1f/nuget/v3/flat2/microsoft.codeanalysis.publicapianalyzers/3.11.0-beta1.24081.1/microsoft.codeanalysis.publicapianalyzers.3.11.0-beta1.24081.1.nupkg"; })
   (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.7.0"; hash = "sha256-Enknv2RsFF68lEPdrf5M+BpV1kHoLTVRApKUwuk/pj0="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.csharp/4.7.0/microsoft.csharp.4.7.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.DiaSymReader"; version = "2.0.0"; hash = "sha256-8hotZmh8Rb6Q6oD9Meb74SvAdbDo39Y/1m8h43HHjjw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.diasymreader/2.0.0/microsoft.diasymreader.2.0.0.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.DotNet.Arcade.Sdk"; version = "9.0.0-beta.24459.6"; hash = "sha256-XuqUYxeGP0Wj9ExlKuOc3OwpVGAlDxrJ7Mip2IiT35c="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/1a5f89f6-d8da-4080-b15f-242650c914a8/nuget/v3/flat2/microsoft.dotnet.arcade.sdk/9.0.0-beta.24459.6/microsoft.dotnet.arcade.sdk.9.0.0-beta.24459.6.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.DotNet.Arcade.Sdk"; version = "9.0.0-beta.24572.2"; hash = "sha256-dTYFN1KH3grxcf/On6GLW5WdFliq91Y37DeWDCwiryM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/1a5f89f6-d8da-4080-b15f-242650c914a8/nuget/v3/flat2/microsoft.dotnet.arcade.sdk/9.0.0-beta.24572.2/microsoft.dotnet.arcade.sdk.9.0.0-beta.24572.2.nupkg"; })
   (fetchNuGet { pname = "Microsoft.DotNet.XliffTasks"; version = "9.0.0-beta.24076.5"; hash = "sha256-5cREL85PwcDwo4yyc2Eh908HQ/Cm36w9uZSIvVELZH0="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/1a5f89f6-d8da-4080-b15f-242650c914a8/nuget/v3/flat2/microsoft.dotnet.xlifftasks/9.0.0-beta.24076.5/microsoft.dotnet.xlifftasks.9.0.0-beta.24076.5.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "8.0.0"; hash = "sha256-9BPsASlxrV8ilmMCjdb3TiUcm5vFZxkBnAI/fNBSEyA="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.configuration/8.0.0/microsoft.extensions.configuration.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "8.0.0"; hash = "sha256-4eBpDkf7MJozTZnOwQvwcfgRKQGcNXe0K/kF+h5Rl8o="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.configuration.abstractions/8.0.0/microsoft.extensions.configuration.abstractions.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "8.0.0"; hash = "sha256-GanfInGzzoN2bKeNwON8/Hnamr6l7RTpYLA49CNXD9Q="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.configuration.binder/8.0.0/microsoft.extensions.configuration.binder.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "8.0.0"; hash = "sha256-+qIDR8hRzreCHNEDtUcPfVHQdurzWPo/mqviCH78+EQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.dependencyinjection/8.0.0/microsoft.extensions.dependencyinjection.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "8.0.0"; hash = "sha256-75KzEGWjbRELczJpCiJub+ltNUMMbz5A/1KQU+5dgP8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.dependencyinjection.abstractions/8.0.0/microsoft.extensions.dependencyinjection.abstractions.8.0.0.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.FileSystemGlobbing"; version = "8.0.0"; hash = "sha256-+Oz41JR5jdcJlCJOSpQIL5OMBNi+1Hl2d0JUHfES7sU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.filesystemglobbing/8.0.0/microsoft.extensions.filesystemglobbing.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "8.0.0"; hash = "sha256-Meh0Z0X7KyOEG4l0RWBcuHHihcABcvCyfUXgasmQ91o="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.logging/8.0.0/microsoft.extensions.logging.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "8.0.0"; hash = "sha256-Jmddjeg8U5S+iBTwRlVAVLeIHxc4yrrNgqVMOB7EjM4="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.logging.abstractions/8.0.0/microsoft.extensions.logging.abstractions.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Logging.Configuration"; version = "8.0.0"; hash = "sha256-mzmstNsVjKT0EtQcdAukGRifD30T82BMGYlSu8k4K7U="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.logging.configuration/8.0.0/microsoft.extensions.logging.configuration.8.0.0.nupkg"; })
···
   (fetchNuGet { pname = "Microsoft.Extensions.Options.ConfigurationExtensions"; version = "8.0.0"; hash = "sha256-A5Bbzw1kiNkgirk5x8kyxwg9lLTcSngojeD+ocpG1RI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.options.configurationextensions/8.0.0/microsoft.extensions.options.configurationextensions.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "8.0.0"; hash = "sha256-FU8qj3DR8bDdc1c+WeGZx/PCZeqqndweZM9epcpXjSo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.extensions.primitives/8.0.0/microsoft.extensions.primitives.8.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.IO.Redist"; version = "6.0.1"; hash = "sha256-IaATAy1M/MEBTid0mQiTrHj4aTwo2POCtckxSbLc3lU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.io.redist/6.0.1/microsoft.io.redist.6.0.1.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.10.4"; hash = "sha256-nXY7YaIx6sXn7aMqpF4bW4d2J5U1KNb9sXqRSd8MpOc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.10.4/microsoft.net.stringtools.17.10.4.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.3.4"; hash = "sha256-xLPrrL8iS3gNMIa/C/Wv0fBfHIehUHeQ4Y+F+gbqkhk="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.net.stringtools/17.3.4/microsoft.net.stringtools.17.3.4.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.12.0-preview-24426-07"; hash = "sha256-yoReTrCOhI6ud3v6fLGi5ivS0RuBDhDWw/giD9+bYOk="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.net.stringtools/17.12.0-preview-24426-07/microsoft.net.stringtools.17.12.0-preview-24426-07.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.4.0"; hash = "sha256-+9uBaUDZ3roUJwyYJUL30Mz+3C6LE16FzfQKgS0Yveo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.4.0/microsoft.net.stringtools.17.4.0.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.6.3"; hash = "sha256-H2Qw8x47WyFOd/VmgRmGMc+uXySgUv68UISgK8Frsjw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.6.3/microsoft.net.stringtools.17.6.3.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.7.2"; hash = "sha256-hQE07TCgcQuyu9ZHVq2gPDb0+xe8ECJUdrgh17bJP4o="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.net.stringtools/17.7.2/microsoft.net.stringtools.17.7.2.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "5.0.0"; hash = "sha256-LIcg1StDcQLPOABp4JRXIs837d7z0ia6+++3SF3jl1c="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.platforms/5.0.0/microsoft.netcore.platforms.5.0.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; hash = "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.targets/1.1.0/microsoft.netcore.targets.1.1.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.3"; hash = "sha256-WLsf1NuUfRWyr7C7Rl9jiua9jximnVvzy6nk2D2bVRc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netcore.targets/1.1.3/microsoft.netcore.targets.1.1.3.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETFramework.ReferenceAssemblies"; version = "1.0.3"; hash = "sha256-FBoJP5DHZF0QHM0xLm9yd4HJZVQOuSpSKA+VQRpphEE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netframework.referenceassemblies/1.0.3/microsoft.netframework.referenceassemblies.1.0.3.nupkg"; })
   (fetchNuGet { pname = "Microsoft.NETFramework.ReferenceAssemblies.net472"; version = "1.0.3"; hash = "sha256-/6ClVwo5+RE5kWTQWB/93vmbXj37ql8iDlziKWm89Xw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.netframework.referenceassemblies.net472/1.0.3/microsoft.netframework.referenceassemblies.net472.1.0.3.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.ServiceHub.Analyzers"; version = "4.5.31"; hash = "sha256-lf2FS26yjXAxLIht8qeQp4YXWGuVbu2xzoOyxQOOLV8="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.servicehub.analyzers/4.5.31/microsoft.servicehub.analyzers.4.5.31.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.ServiceHub.Analyzers"; version = "4.7.32-beta"; hash = "sha256-vYKNtk5BauoAwUt2g+0GodmRZ9JWHWfFIBrcOPFHuyQ="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.servicehub.analyzers/4.7.32-beta/microsoft.servicehub.analyzers.4.7.32-beta.nupkg"; })
   (fetchNuGet { pname = "Microsoft.ServiceHub.Client"; version = "4.2.1017"; hash = "sha256-Achfy4EpZfcIOf02P8onWJH1cte+rP9ZAy94Gf4MVCA="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/2a239fd0-3e21-40b0-b9d6-bc122fec7eb2/nuget/v3/flat2/microsoft.servicehub.client/4.2.1017/microsoft.servicehub.client.4.2.1017.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.ServiceHub.Framework"; version = "4.5.31"; hash = "sha256-KHFz3F+cgK6dWqHW33ihCQXaTUg/v+LFwW0v+PG596E="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.servicehub.framework/4.5.31/microsoft.servicehub.framework.4.5.31.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.ServiceHub.Framework"; version = "4.7.32-beta"; hash = "sha256-QGtg9LL8FRRjDiMn5sJYPn1gliSzzxokyMVsa1uvDfs="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.servicehub.framework/4.7.32-beta/microsoft.servicehub.framework.4.7.32-beta.nupkg"; })
   (fetchNuGet { pname = "Microsoft.ServiceHub.Resources"; version = "4.2.1017"; hash = "sha256-6nq1jsXLThMritNI1CZj5Batfo/0W0Pt2iLY72yZGNw="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/2a239fd0-3e21-40b0-b9d6-bc122fec7eb2/nuget/v3/flat2/microsoft.servicehub.resources/4.2.1017/microsoft.servicehub.resources.4.2.1017.nupkg"; })
   (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "17.5.0"; hash = "sha256-M8Ct2u3RaTxWip0XBLPtL2xeGsYz1rjKgfsV++nZDPg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.testplatform.objectmodel/17.5.0/microsoft.testplatform.objectmodel.17.5.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.TestPlatform.TranslationLayer"; version = "17.5.0"; hash = "sha256-rVgeXl/F8jqXJhQcrm2tV6jvsYHA6UF+5crLVr4GZBA="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.testplatform.translationlayer/17.5.0/microsoft.testplatform.translationlayer.17.5.0.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Composition"; version = "17.10.37"; hash = "sha256-Lq0XlMb7eqfMsu+NsptjCZReU3vRH5+JGvPU1VbuyEY="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.composition/17.10.37/microsoft.visualstudio.composition.17.10.37.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Composition.Analyzers"; version = "17.10.37"; hash = "sha256-pckf7uZKhMSLxGHtrR2P3qdeNTtEDjAJGvagQ0Oocww="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.composition.analyzers/17.10.37/microsoft.visualstudio.composition.analyzers.17.10.37.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Composition"; version = "17.12.17-preview"; hash = "sha256-RxakGlbjWXC28F50Z5Ayez5gVsmCeyPqOKw3aBCKrDc="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.composition/17.12.17-preview/microsoft.visualstudio.composition.17.12.17-preview.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Composition.Analyzers"; version = "17.12.17-preview"; hash = "sha256-tZ7SmS9wq1f7FJMLo+c5YRdeAoJ7ZHemhgtXiTTzqIU="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.composition.analyzers/17.12.17-preview/microsoft.visualstudio.composition.analyzers.17.12.17-preview.nupkg"; })
   (fetchNuGet { pname = "Microsoft.VisualStudio.RemoteControl"; version = "16.3.52"; hash = "sha256-J/egIc9ovDi1MUrnyKnpadECQqAB1WUUyrbxINv4zRE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.remotecontrol/16.3.52/microsoft.visualstudio.remotecontrol.16.3.52.nupkg"; })
   (fetchNuGet { pname = "Microsoft.VisualStudio.Setup.Configuration.Interop"; version = "3.2.2146"; hash = "sha256-ic5h0cmHIaowJfItTLXLnmFhIg4NhaoMoWVAFMHKdzQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.setup.configuration.interop/3.2.2146/microsoft.visualstudio.setup.configuration.interop.3.2.2146.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Telemetry"; version = "17.11.8"; hash = "sha256-w6VeYf5feF1HGpz8g7u7ytEXH3Ve8LLkG+SM4uNpDj4="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.telemetry/17.11.8/microsoft.visualstudio.telemetry.17.11.8.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading"; version = "17.11.20"; hash = "sha256-yuNMLu4qKQpHcYHP2JN45u/dY8wvGHGaFFuHKizupcE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.threading/17.11.20/microsoft.visualstudio.threading.17.11.20.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading.Analyzers"; version = "17.11.20"; hash = "sha256-mHYVKapahjHlrzeJ6JpQAtugg+Ub3IzesYSJ+UTybAU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.threading.analyzers/17.11.20/microsoft.visualstudio.threading.analyzers.17.11.20.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Telemetry"; version = "17.12.32"; hash = "sha256-HkAQyMovZEABmgcaaSo/DOyRbx+pyVOZGxEm7GEKd2E="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.telemetry/17.12.32/microsoft.visualstudio.telemetry.17.12.32.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading"; version = "17.12.13-preview"; hash = "sha256-StuzZma2nOXFJ5Al9AZZPo0kM4FrTgHYz2ji+zKgtlM="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.threading/17.12.13-preview/microsoft.visualstudio.threading.17.12.13-preview.nupkg"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading.Analyzers"; version = "17.12.13-preview"; hash = "sha256-wrCnLYNSujq8fcpmjm/yTTY7uVOPAjpJA+1X8ujuVbA="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/microsoft.visualstudio.threading.analyzers/17.12.13-preview/microsoft.visualstudio.threading.analyzers.17.12.13-preview.nupkg"; })
   (fetchNuGet { pname = "Microsoft.VisualStudio.Utilities.Internal"; version = "16.3.73"; hash = "sha256-zwk4jWuCw2ANhG00TnwT9JE7n/h2EQkYKeq6o966ilo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.utilities.internal/16.3.73/microsoft.visualstudio.utilities.internal.16.3.73.nupkg"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Validation"; version = "17.6.11"; hash = "sha256-Lkjp9Ove4+CFP06x/toYpJEiAinuTfn/o+oh0fW3pGM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.validation/17.6.11/microsoft.visualstudio.validation.17.6.11.nupkg"; })
   (fetchNuGet { pname = "Microsoft.VisualStudio.Validation"; version = "17.8.8"; hash = "sha256-sB8GLRiJHX3Py7qeBUnUANiDWhyPtISon6HQs+8wKms="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.visualstudio.validation/17.8.8/microsoft.visualstudio.validation.17.8.8.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; hash = "sha256-mBNDmPXNTW54XLnPAUwBRvkIORFM7/j0D0I2SyQPDEg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.win32.primitives/4.3.0/microsoft.win32.primitives.4.3.0.nupkg"; })
   (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "5.0.0"; hash = "sha256-9kylPGfKZc58yFqNKa77stomcoNnMeERXozWJzDcUIA="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/microsoft.win32.registry/5.0.0/microsoft.win32.registry.5.0.0.nupkg"; })
-  (fetchNuGet { pname = "Nerdbank.Streams"; version = "2.10.69"; hash = "sha256-a0hXKhR7dv6Vm4rlUOD2ffBKG49CC3wzXLCHeTz1ms4="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/nerdbank.streams/2.10.69/nerdbank.streams.2.10.69.nupkg"; })
+  (fetchNuGet { pname = "Nerdbank.Streams"; version = "2.11.79"; hash = "sha256-1bzibVcSH8LJMR8Nb6Q0q/7fieTgxRnVY4C1RvRbrrI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/nerdbank.streams/2.11.79/nerdbank.streams.2.11.79.nupkg"; })
   (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.0"; hash = "sha256-Pp7fRylai8JrE1O+9TGfIEJrAOmnWTJRLWE+qJBahK0="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/netstandard.library/2.0.0/netstandard.library.2.0.0.nupkg"; })
   (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.3"; hash = "sha256-Prh2RPebz/s8AzHb2sPHg3Jl8s31inv9k+Qxd293ybo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/netstandard.library/2.0.3/netstandard.library.2.0.3.nupkg"; })
   (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.3"; hash = "sha256-hy/BieY4qxBWVVsDqqOPaLy1QobiIapkbrESm6v2PHc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/newtonsoft.json/13.0.3/newtonsoft.json.13.0.3.nupkg"; })
···
   (fetchNuGet { pname = "SQLitePCLRaw.lib.e_sqlite3"; version = "2.1.0"; hash = "sha256-XsObwf7Fza9G1JCZvQ+SqMqQUdZNU3WcJYYp3cqfc8U="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/sqlitepclraw.lib.e_sqlite3/2.1.0/sqlitepclraw.lib.e_sqlite3.2.1.0.nupkg"; })
   (fetchNuGet { pname = "SQLitePCLRaw.provider.dynamic_cdecl"; version = "2.1.0"; hash = "sha256-2JLlOroGdfziGi+VpgBjtm9IHofG976T+9lZb+fQRok="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/sqlitepclraw.provider.dynamic_cdecl/2.1.0/sqlitepclraw.provider.dynamic_cdecl.2.1.0.nupkg"; })
   (fetchNuGet { pname = "SQLitePCLRaw.provider.e_sqlite3"; version = "2.1.0"; hash = "sha256-VkGdCCECj+0oaha/QsyfF9CQoaurC/KO2RHR2GaI77w="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/sqlitepclraw.provider.e_sqlite3/2.1.0/sqlitepclraw.provider.e_sqlite3.2.1.0.nupkg"; })
-  (fetchNuGet { pname = "StreamJsonRpc"; version = "2.18.48"; hash = "sha256-/vjpwKMFoJfSf+uKEjmWzW/HdIfDGMLb7el91ni6gFQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/streamjsonrpc/2.18.48/streamjsonrpc.2.18.48.nupkg"; })
+  (fetchNuGet { pname = "StreamJsonRpc"; version = "2.20.8-beta"; hash = "sha256-cELu//Ad7sAITbq/i5ISi4g1Mvf9mUIYT6vDTukUjQY="; url = "https://pkgs.dev.azure.com/azure-public/3ccf6661-f8ce-4e8a-bb2e-eff943ddd3c7/_packaging/491596af-6d2d-439e-80bb-1ebb3b54f9a8/nuget/v3/flat2/streamjsonrpc/2.20.8-beta/streamjsonrpc.2.20.8-beta.nupkg"; })
   (fetchNuGet { pname = "System.Buffers"; version = "4.5.1"; hash = "sha256-wws90sfi9M7kuCPWkv1CEYMJtCqx9QB/kj0ymlsNaxI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.buffers/4.5.1/system.buffers.4.5.1.nupkg"; })
   (fetchNuGet { pname = "System.CodeDom"; version = "7.0.0"; hash = "sha256-7IPt39cY+0j0ZcRr/J45xPtEjnSXdUJ/5ai3ebaYQiE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.codedom/7.0.0/system.codedom.7.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; hash = "sha256-afY7VUtD6w/5mYqrce8kQrvDIfS2GXDINDh73IjxJKc="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.collections/4.3.0/system.collections.4.3.0.nupkg"; })
   (fetchNuGet { pname = "System.Collections.Immutable"; version = "8.0.0"; hash = "sha256-F7OVjKNwpqbUh8lTidbqJWYi476nsq9n+6k0+QVRo3w="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.collections.immutable/8.0.0/system.collections.immutable.8.0.0.nupkg"; })
-  (fetchNuGet { pname = "System.CommandLine"; version = "2.0.0-beta4.24324.3"; hash = "sha256-YjxPnyDiCahE9Ip+un1uoXpW6+pXBCRQNL0juRLZJDE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/516521bf-6417-457e-9a9c-0a4bdfde03e7/nuget/v3/flat2/system.commandline/2.0.0-beta4.24324.3/system.commandline.2.0.0-beta4.24324.3.nupkg"; })
+  (fetchNuGet { pname = "System.CommandLine"; version = "2.0.0-beta4.24528.1"; hash = "sha256-C1CMTF8ejnnk9h6Yih8ajWeNiQK6czWZTgBSEhGZNGQ="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/516521bf-6417-457e-9a9c-0a4bdfde03e7/nuget/v3/flat2/system.commandline/2.0.0-beta4.24528.1/system.commandline.2.0.0-beta4.24528.1.nupkg"; })
   (fetchNuGet { pname = "System.ComponentModel.Composition"; version = "8.0.0"; hash = "sha256-MnKdjE/qIvAmEeRc3gOn5uJhT0TI3UnUJPjj3TLHFQo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.componentmodel.composition/8.0.0/system.componentmodel.composition.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Composition"; version = "8.0.0"; hash = "sha256-rA118MFj6soKN++BvD3y9gXAJf0lZJAtGARuznG5+Xg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.composition/8.0.0/system.composition.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Composition.AttributedModel"; version = "8.0.0"; hash = "sha256-n3aXiBAFIlQicSRLiNtLh++URSUxRBLggsjJ8OMNRpo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.composition.attributedmodel/8.0.0/system.composition.attributedmodel.8.0.0.nupkg"; })
···
   (fetchNuGet { pname = "System.Configuration.ConfigurationManager"; version = "8.0.0"; hash = "sha256-xhljqSkNQk8DMkEOBSYnn9lzCSEDDq4yO910itptqiE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.configuration.configurationmanager/8.0.0/system.configuration.configurationmanager.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Data.DataSetExtensions"; version = "4.5.0"; hash = "sha256-qppO0L8BpI7cgaStqBhn6YJYFjFdSwpXlRih0XFsaT4="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.data.datasetextensions/4.5.0/system.data.datasetextensions.4.5.0.nupkg"; })
   (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-fkA79SjPbSeiEcrbbUsb70u9B7wqbsdM9s1LnoKj0gM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.debug/4.3.0/system.diagnostics.debug.4.3.0.nupkg"; })
-  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "8.0.0"; hash = "sha256-+aODaDEQMqla5RYZeq0Lh66j+xkPYxykrVvSCmJQ+Vs="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.diagnosticsource/8.0.0/system.diagnostics.diagnosticsource.8.0.0.nupkg"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "8.0.1"; hash = "sha256-zmwHjcJgKcbkkwepH038QhcnsWMJcHys+PEbFGC0Jgo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.diagnosticsource/8.0.1/system.diagnostics.diagnosticsource.8.0.1.nupkg"; })
   (fetchNuGet { pname = "System.Diagnostics.EventLog"; version = "8.0.0"; hash = "sha256-rt8xc3kddpQY4HEdghlBeOK4gdw5yIj4mcZhAVtk2/Y="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.eventlog/8.0.0/system.diagnostics.eventlog.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Diagnostics.PerformanceCounter"; version = "7.0.0"; hash = "sha256-t+l5WgfxivrZhWKjr0rpqtCcNXyRgytsGgWf/BIv5PU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.performancecounter/7.0.0/system.diagnostics.performancecounter.7.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Diagnostics.Process"; version = "4.3.0"; hash = "sha256-Rzo24qXhuJDDgrGNHr2eQRHhwLmsYmWDqAg/P5fOlzw="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.diagnostics.process/4.3.0/system.diagnostics.process.4.3.0.nupkg"; })
···
   (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.7.0"; hash = "sha256-GUnQeGo/DtvZVQpFnESGq7lJcjB30/KnDY7Kd2G/ElE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.emit.ilgeneration/4.7.0/system.reflection.emit.ilgeneration.4.7.0.nupkg"; })
   (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.7.0"; hash = "sha256-V0Wz/UUoNIHdTGS9e1TR89u58zJjo/wPUWw6VaVyclU="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.emit.lightweight/4.7.0/system.reflection.emit.lightweight.4.7.0.nupkg"; })
   (fetchNuGet { pname = "System.Reflection.Metadata"; version = "8.0.0"; hash = "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.metadata/8.0.0/system.reflection.metadata.8.0.0.nupkg"; })
-  (fetchNuGet { pname = "System.Reflection.MetadataLoadContext"; version = "6.0.0"; hash = "sha256-82aeU8c4rnYPLL3ba1ho1fxfpYQt5qrSK5e6ES+OTsY="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.metadataloadcontext/6.0.0/system.reflection.metadataloadcontext.6.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Reflection.MetadataLoadContext"; version = "7.0.0"; hash = "sha256-VYl6SFD130K9Aw4eJH16ApJ9Sau4Xu0dcxEip2veuTI="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.metadataloadcontext/7.0.0/system.reflection.metadataloadcontext.7.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Reflection.MetadataLoadContext"; version = "8.0.0"; hash = "sha256-jS5XPZiHjY2CJFnLSxL6U7lMrU3ZknvB4EOgMbG0LEo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.metadataloadcontext/8.0.0/system.reflection.metadataloadcontext.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; hash = "sha256-5ogwWB4vlQTl3jjk1xjniG2ozbFIjZTL9ug0usZQuBM="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.primitives/4.3.0/system.reflection.primitives.4.3.0.nupkg"; })
···
   (fetchNuGet { pname = "System.Security.Cryptography.Xml"; version = "7.0.1"; hash = "sha256-CH8+JVC8LyCSW75/6ZQ7ecMbSOAE1c16z4dG8JTp01w="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.security.cryptography.xml/7.0.1/system.security.cryptography.xml.7.0.1.nupkg"; })
   (fetchNuGet { pname = "System.Security.Permissions"; version = "8.0.0"; hash = "sha256-+YUPY+3HnTmfPLZzr+5qEk0RqalCbFZBgLXee1yCH1M="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.security.permissions/8.0.0/system.security.permissions.8.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; hash = "sha256-rjudVUHdo8pNJg2EVEn0XxxwNo5h2EaYo+QboPkXlYk="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.security.principal/4.3.0/system.security.principal.4.3.0.nupkg"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; hash = "sha256-mbdLVUcEwe78p3ZnB6jYsizNEqxMaCAWI3tEQNhRQAE="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.security.principal.windows/4.3.0/system.security.principal.windows.4.3.0.nupkg"; })
   (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "5.0.0"; hash = "sha256-CBOQwl9veFkrKK2oU8JFFEiKIh/p+aJO+q9Tc2Q/89Y="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.security.principal.windows/5.0.0/system.security.principal.windows.5.0.0.nupkg"; })
   (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; hash = "sha256-GctHVGLZAa/rqkBNhsBGnsiWdKyv6VDubYpGkuOkBLg="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.text.encoding/4.3.0/system.text.encoding.4.3.0.nupkg"; })
   (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "7.0.0"; hash = "sha256-eCKTVwumD051ZEcoJcDVRGnIGAsEvKpfH3ydKluHxmo="; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.text.encoding.codepages/7.0.0/system.text.encoding.codepages.7.0.0.nupkg"; })

pkgs/by-name/ro/roslyn-ls/package.nix

···
   pname = "roslyn-ls";
   dotnet-sdk =
     with dotnetCorePackages;
-    combinePackages [
-      sdk_6_0
-      sdk_7_0
-      sdk_8_0
-      sdk_9_0
-    ];
+    sdk_9_0
+    // {
+      inherit
+        (combinePackages [
+          sdk_9_0
+          sdk_8_0
+          # NOTE: we should be able to remove net6.0 after upstream removes from here:
+          # https://github.com/dotnet/roslyn/blob/6cc106c0eaa9b0ae070dba3138a23aeab9b50c13/eng/targets/TargetFrameworks.props#L20
+          sdk_6_0
+        ])
+        packages
+        targetPackages
+        ;
+    };
   # need sdk on runtime as well
   dotnet-runtime = dotnetCorePackages.sdk_9_0;
   rid = dotnetCorePackages.systemToDotnetRid stdenvNoCC.targetPlatform.system;
···
 buildDotnetModule rec {
   inherit pname dotnet-sdk dotnet-runtime;
 
-  vsVersion = "2.49.25";
+  vsVersion = "2.59.14";
   src = fetchFromGitHub {
     owner = "dotnet";
     repo = "roslyn";
     rev = "VSCode-CSharp-${vsVersion}";
-    hash = "sha256-1amL+K6gf7qJtODxyBtaswhJSLbMrl2LqpmLAArNpW0=";
+    hash = "sha256-tzBIqXBtPGupBBvHTFO93w6f5qCgllWY420xtjf9o3g=";
   };
 
   # versioned independently from vscode-csharp
   # "roslyn" in here:
   # https://github.com/dotnet/vscode-csharp/blob/main/package.json
-  version = "4.12.0-3.24470.4";
+  version = "4.13.0-3.24577.4";
   projectFile = "src/LanguageServer/${project}/${project}.csproj";
   useDotnetFromEnv = true;
   nugetDeps = ./deps.nix;
···
   '';
 
   dotnetFlags = [
+    "-p:TargetRid=${rid}"
     # this removes the Microsoft.WindowsDesktop.App.Ref dependency
     "-p:EnableWindowsTargeting=false"
-    # see this comment: https://github.com/NixOS/nixpkgs/pull/318497#issuecomment-2256096471
-    # we can remove below line after https://github.com/dotnet/roslyn/issues/73439 is fixed
-    "-p:UsingToolMicrosoftNetCompilers=false"
-    "-p:TargetRid=${rid}"
   ];
 
   # two problems solved here:

pkgs/by-name/rp/rpPPPoE/package.nix

···
-{ lib, stdenv, fetchurl, ppp } :
+{ lib, stdenv, fetchFromGitHub, ppp } :
 let
 in
 stdenv.mkDerivation rec {
   pname = "rp-pppoe";
-  version = "3.12";
+  version = "4.0";
 
-  src = fetchurl {
-    url = "https://www.roaringpenguin.com/files/download/rp-pppoe-${version}.tar.gz";
-    sha256 = "1hl6rjvplapgsyrap8xj46kc9kqwdlm6ya6gp3lv0ihm0c24wy80";
+  src = fetchFromGitHub {
+    owner = "dfskoll";
+    repo = "rp-pppoe";
+    rev = version;
+    hash = "sha256-2y26FVxVn8sU9/E2yJeJmbhAeOB0Go7EUPMU9H58H6U=";
   };
 
   buildInputs = [ ppp ];
···
     export PPPD=${ppp}/sbin/pppd
   '';
 
-  configureFlags = lib.optionals (stdenv.buildPlatform != stdenv.hostPlatform) [ "rpppoe_cv_pack_bitfields=rev" ];
+  configureFlags = [ "--enable-plugin=${ppp}/include" ] ++ lib.optionals (stdenv.buildPlatform != stdenv.hostPlatform) [ "rpppoe_cv_pack_bitfields=rev" ];
 
   postConfigure = ''
     sed -i Makefile -e 's@DESTDIR)/etc/ppp@out)/etc/ppp@'
+    sed -i Makefile -e 's@/etc/ppp/plugins@$(out)/lib@'
     sed -i Makefile -e 's@PPPOESERVER_PPPD_OPTIONS=@&$(out)@'
+    sed -i Makefile -e '/# Directory created by rp-pppoe for kernel-mode plugin/d'
   '';
 
   makeFlags = [ "AR:=$(AR)" ];
···
   meta = with lib; {
     description = "Roaring Penguin Point-to-Point over Ethernet tool";
     platforms = platforms.linux;
-    homepage = "https://www.roaringpenguin.com/products/pppoe";
+    homepage = "https://github.com/dfskoll/rp-pppoe";
     license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ DictXiong ];
   };
 }

pkgs/by-name/sa/sakura/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "sakura";
-  version = "3.8.7";
+  version = "3.8.8";
 
   src = fetchFromGitHub {
     owner = "dabisu";
     repo = "sakura";
     rev = "SAKURA_${lib.replaceStrings [ "." ] [ "_" ] finalAttrs.version}";
-    hash = "sha256-mDYwqRPezHEgLyZlJQ6taTQiP9HDWmN09mapfp7/TPs=";
+    hash = "sha256-YeZIYIfFgkK5nxMHq9mslrjIWTRAebhXyzXv5hTmOpI=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/sc/scarab/deps.nix

···
+# This file was automatically generated by passthru.fetch-deps.
+# Please dont edit it manually, your changes might get overwritten!
+
+{ fetchNuGet }: [
+  (fetchNuGet { pname = "Avalonia"; version = "11.0.0"; hash = "sha256-7QE0MtD1QDiG3gRx5xW33E33BXyEtASQSw+Wi3Lmy3E="; })
+  (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2023020321"; hash = "sha256-TWop9cvak6cMv2vrA/GlpuYBxS8Fuj5UmupGIV7Q5Ks="; })
+  (fetchNuGet { pname = "Avalonia.AvaloniaEdit"; version = "11.0.0"; hash = "sha256-8lJBbbUn6RP4+8qO7VMDdL334o6hTf3Lj3EgIA75K4o="; })
+  (fetchNuGet { pname = "Avalonia.BuildServices"; version = "0.0.28"; hash = "sha256-7NQWQl3xrBDOXhGihCkt5DIrws48KyDGon/7+gPzMDU="; })
+  (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.0"; hash = "sha256-xzbJvbOYGHtd8rtKgsMTtOarbVQ8mIvs7IruODv8jxs="; })
+  (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.0"; hash = "sha256-Ukvt2JebIWb+y1x77EAVl2Nbay92OX30k5TdwElvjGI="; })
+  (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.0"; hash = "sha256-jopgP4nMzEqrMuzCpUSd30j1uNMS8vcCO125U8YKwyM="; })
+  (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.0"; hash = "sha256-6dqx4JIrmjnDDa1mhI7CCiKPfaIR1qDK+ZZrl1OgnYw="; })
+  (fetchNuGet { pname = "Avalonia.Fonts.Inter"; version = "11.0.0"; hash = "sha256-VaWAQk1+LlaKokkAg2je5jKUajmIySJ65Dh5KE+ac+0="; })
+  (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.0"; hash = "sha256-Q18zDlzjXApnV1hANvh/OQGmKSdB/ajZ84bTgRhFWhA="; })
+  (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.0"; hash = "sha256-UOf5jXEGg6tTnWgX8qLQ5raythkusO/gN5BjHtC+/Mg="; })
+  (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "11.0.0"; hash = "sha256-EBugQUNJI6xw21jul16bineWU0y5aCAZ/XUJqYQzF7o="; })
+  (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.0"; hash = "sha256-gkVpdbk/0RDM7Hhq0jwZwltDpTsGRmbX+ZFTjWYYoKw="; })
+  (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.0"; hash = "sha256-A01nrs3Ij1eTo6tPmu7++T1K+Wo/H/9LvpeuOUGbQeU="; })
+  (fetchNuGet { pname = "Avalonia.Svg"; version = "11.0.0.1"; hash = "sha256-7p/doak1h7bNtjAvnELCR5WtiGmCbFkrSF5Wds3rwSg="; })
+  (fetchNuGet { pname = "Avalonia.Svg.Skia"; version = "11.0.0.1"; hash = "sha256-zpkQcv1tF45cUV+POzhND52ntUcV2qU0e7ww3HB+3K8="; })
+  (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.0"; hash = "sha256-temZl8DKFuhIewVQDAqq1b+sF1RLfZ8CoZ0Eho41h+M="; })
+  (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.0"; hash = "sha256-o+bNmGBLiQoBTPXb6Ban1AmwvR6bbKmTE5HY6EslV7Y="; })
+  (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.0"; hash = "sha256-zyA2ZKathdIO48GjfG0bQdWjGLgd7ohIGw8O7mX+pL0="; })
+  (fetchNuGet { pname = "Castle.Core"; version = "5.1.1"; hash = "sha256-oVkQB+ON7S6Q27OhXrTLaxTL0kWB58HZaFFuiw4iTrE="; })
+  (fetchNuGet { pname = "ColorTextBlock.Avalonia"; version = "11.0.0-d1"; hash = "sha256-8EEmUYrMLBdZ4gNolsiBTkFWjRTB3TWVXkH0H8J1xe0="; })
+  (fetchNuGet { pname = "ColorTextBlock.Avalonia"; version = "11.0.2"; hash = "sha256-FmaYhszWp/VCIp4BUnWXGMQr62WzVNUo/IKEbN59bX8="; })
+  (fetchNuGet { pname = "coverlet.collector"; version = "1.3.0"; hash = "sha256-HoiYZuABqQdt6Sm1KvMm4MLLYCyWuB4DT6WZp2BqxUw="; })
+  (fetchNuGet { pname = "DryIoc.dll"; version = "5.4.1"; hash = "sha256-xhbD2H92TyN4LtP+HIywa6emLsOZDhoxqbGeeAtTarU="; })
+  (fetchNuGet { pname = "DryIoc.Microsoft.DependencyInjection"; version = "6.2.0"; hash = "sha256-C06B0tj3qFkVVGL0kSflf88As4t9TRaw/++N05Zaz0c="; })
+  (fetchNuGet { pname = "DynamicData"; version = "7.9.5"; hash = "sha256-3XjOMuFathku9oWyss360+Ze5UMP7tSmUbMoax7qONU="; })
+  (fetchNuGet { pname = "ExCSS"; version = "4.1.4"; hash = "sha256-7dKCwRC+Jt4CTLz9LF3LpmaB8ch1HFrcan7CmM3toPg="; })
+  (fetchNuGet { pname = "FakeItEasy"; version = "8.0.0-alpha.1.10"; hash = "sha256-+FLBsGvUV+B17vhqNRmWYOUAWa0zI5pYPlcJGb1iIhE="; })
+  (fetchNuGet { pname = "Fizzler"; version = "1.2.1"; hash = "sha256-FROW1WzitXTauf2Hn7YejOLqNKN2Nd+Q2etFB1pYsvA="; })
+  (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.3"; hash = "sha256-4tbdgUabPjlkBm3aUFeocj4Fdslmms2olDFpzOLyqoQ="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.3"; hash = "sha256-3xwVfNfKTkuLdnT+e3bfG9tNTdEmar7ByzY+NTlUKLg="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.3"; hash = "sha256-ZohUEaovj/sRB4rjuJIOq6S9eim3m+qMlpHIebNDTRQ="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.3"; hash = "sha256-ZsiBGpXfODHUHPgU/50k9QR/j6Klo7rsB0SUt8zYcBA="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.3"; hash = "sha256-5GSzM5IUoOwK+zJg0d74WlT3n1VZly8pKlyjiqVocCI="; })
+  (fetchNuGet { pname = "HtmlAgilityPack"; version = "1.11.42"; hash = "sha256-y1sdZXb4+wjvH5gmwyBZOn5CLid7lTHgxEsy13BgdjM="; })
+  (fetchNuGet { pname = "JetBrains.Annotations"; version = "2023.2.0"; hash = "sha256-Um10fSmO+21I7f+lbzzVq5e8GBijJ9amTvOlt362p1s="; })
+  (fetchNuGet { pname = "Markdown.Avalonia"; version = "11.0.2"; hash = "sha256-UxkZQezuimp+K2y+MQvB4tcj2lqmodku585diu9wods="; })
+  (fetchNuGet { pname = "Markdown.Avalonia.Html"; version = "11.0.2"; hash = "sha256-mBxg9ETSWmcS5HuaNTxqy9RCAvBuaUAb44619GghX/Y="; })
+  (fetchNuGet { pname = "Markdown.Avalonia.Svg"; version = "11.0.2"; hash = "sha256-4wdhRhwBTTA0+1S8Z1rj/EzuLDOk/h+tYBPW+9VXvug="; })
+  (fetchNuGet { pname = "Markdown.Avalonia.SyntaxHigh"; version = "11.0.2"; hash = "sha256-F+A56Zw+smQJhB4Wd8P1Bcm0jqSBUw7y21S4GDnIJzY="; })
+  (fetchNuGet { pname = "Markdown.Avalonia.Tight"; version = "11.0.0-d1"; hash = "sha256-0ze59lFF8zq7ylWlu5roKAfrsn2ESbZ41LptjvmYSU8="; })
+  (fetchNuGet { pname = "Markdown.Avalonia.Tight"; version = "11.0.2"; hash = "sha256-9P3/ZCF1psp8VoZMzJJlnoqz2y2EytmBGDc4QXIS4tc="; })
+  (fetchNuGet { pname = "MessageBox.Avalonia"; version = "2.3.1-rc1"; hash = "sha256-inBUfNAFAD+OgQ3/9830uOd7mx+GTgTRKrsoXtLD+48="; })
+  (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; hash = "sha256-VdwpP5fsclvNqJuppaOvwEwv2ofnAI5ZSz2V+UEdLF0="; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.36"; hash = "sha256-9jDkWbjw/nd8yqdzVTagCuqr6owJ/DUMi4BlUZT4hWU="; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.36"; hash = "sha256-JQULJyF0ivLoUU1JaFfK/HHg+/qzpN7V2RR2Cc+WlQ4="; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.36"; hash = "sha256-zUsVIpV481vMLAXaLEEUpEMA9/f1HGOnvaQnaWdzlyY="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; hash = "sha256-KDbCfsBWSJ5ohEXUKp1s1LX9xA2NPvXE/xVzj68EdC0="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; hash = "sha256-3G9vSc/gHH7FWgOySLTut1+eEaf3H66qcPOvNPLOx4o="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; hash = "sha256-i/r3V/No/VzqmJlWxpGoirvlbJDbBPa/ONZtzYrxuc4="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; hash = "sha256-fA9Qu+vTyMZ9REzxJ4aMg/SHCDRk4q9k4ZGUdynoHnA="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; hash = "sha256-866jMHp8kbc1FYpKuUWnd7ViU6kGJTAxPcL/IjXrT0I="; })
+  (fetchNuGet { pname = "Microsoft.CodeCoverage"; version = "16.7.1"; hash = "sha256-pHVwPobSO66j5rn+mU3g3asXZKJGO3oj840VQobhWbk="; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; hash = "sha256-0huoqR2CJ3Z9Q2peaKD09TV3E6saYSqDGZ290K8CrH8="; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; hash = "sha256-a3dAiPaVuky0wpcHmpTVtAQJNGZ2v91/oArA+dpJgj8="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "7.0.0"; hash = "sha256-N2DHyHiaNvYDQ77f8HI0gE0uIX2aj/rvejVGdCXRP4g="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "7.0.0"; hash = "sha256-55lsa2QdX1CJn1TpW1vTnkvbGXKCeE9P0O6AkW49LaA="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "7.0.0"; hash = "sha256-rr/NXIZ/3FG5FYGrHD7iIIr12AksP4CnfUy1YvEdDa8="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "7.0.0"; hash = "sha256-uoMkX/TnwP0YabThacTMmyxdc9itQp73CN7xEFFox74="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "7.0.0"; hash = "sha256-pj9I/2HpCU7bLu002/Bb5NF+ofUrJ3IyH7yVqfP8IC0="; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "7.0.0"; hash = "sha256-AGnfNNDvZDGZ0Er9JQxeyLoUbVH+jfXF3anFr12qk6w="; })
+  (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "16.7.1"; hash = "sha256-yE1At8TgGCK3xQip5kpF1aPT722escTNsaIrcuSNHXs="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.36"; hash = "sha256-9lC/LYnthYhjkWWz2kkFCvlA5LJOv11jdt59SDnpdy0="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.36"; hash = "sha256-VFRDzx7LJuvI5yzKdGmw/31NYVbwHWPKQvueQt5xc10="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.36"; hash = "sha256-9LZgVoIFF8qNyUu8kdJrYGLutMF/cL2K82HN2ywwlx8="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.36"; hash = "sha256-k3rxvUhCEU0pVH8KgEMtkPiSOibn+nBh+0zT2xIfId8="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.36"; hash = "sha256-U8wJ2snSDFqeAgDVLXjnniidC7Cr5aJ1/h/BMSlyu0c="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; hash = "sha256-mZotlGZqtrqDSoBrZhsxFe6fuOv5/BIo0w2Z2x0zVAU="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; hash = "sha256-FeM40ktcObQJk4nMYShB61H/E8B7tIKfl9ObJ0IOcCM="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; hash = "sha256-gYQQO7zsqG+OtN4ywYQyfsiggS2zmxw4+cPXlK+FB5Q="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; hash = "sha256-lxxw/Gy32xHi0fLgFWNj4YTFBSBkjx5l6ucmbTyf7V4="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; hash = "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="; })
+  (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "16.7.1"; hash = "sha256-wKuZ0tdSRd74JWnkQHKWI5qasojIkF1imLf9lxL0LWk="; })
+  (fetchNuGet { pname = "Microsoft.TestPlatform.TestHost"; version = "16.7.1"; hash = "sha256-GlL8dJCdJoTxAT1v3CpTY68oKNvJfmDjQPom27MBM/Y="; })
+  (fetchNuGet { pname = "Microsoft.Toolkit.HighPerformance"; version = "7.1.2"; hash = "sha256-qzNmWXboGnrGTRESKFv0WZ5oxRg30XDODxpRgCsoiaI="; })
+  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; hash = "sha256-mBNDmPXNTW54XLnPAUwBRvkIORFM7/j0D0I2SyQPDEg="; })
+  (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; hash = "sha256-N9EVZbl5w1VnMywGXyaVWzT9lh84iaJ3aD48hIBk1zA="; })
+  (fetchNuGet { pname = "NETStandard.Library"; version = "1.6.1"; hash = "sha256-iNan1ix7RtncGWC9AjAZ2sk70DoxOsmEOgQ10fXm4Pw="; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; hash = "sha256-mYCBrgUhIJFzRuLLV9SIiIFHovzfR8Uuqfg6e08EnlU="; })
+  (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.0.0"; hash = "sha256-WWLh+v9Y9as+WURW8tUPowQB8HWIiVJzbpKzEWTdMqI="; })
+  (fetchNuGet { pname = "Projektanker.Icons.Avalonia"; version = "6.6.0-rc1.1"; hash = "sha256-UiY/xQ86e4SrkFpaYFgSEGcPpgkxie5y6KsGlp9gShM="; })
+  (fetchNuGet { pname = "Projektanker.Icons.Avalonia.FontAwesome"; version = "6.6.0-rc1.1"; hash = "sha256-rIcR1IlWjVO8cTW5Q93PCXnljNI3S/WQv+o4YXR77dc="; })
+  (fetchNuGet { pname = "PropertyChanged.SourceGenerator"; version = "1.0.8"; hash = "sha256-piqoZmrDv/JSotsAoYsW33ry4YepELfRMZz9qINszxc="; })
+  (fetchNuGet { pname = "ReactiveUI"; version = "18.3.1"; hash = "sha256-1rf4icGRKTR3XIWJpkQJCG7ObRM+72ITB5K+ND1is9M="; })
+  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; hash = "sha256-4PGZqyWhZ6/HCTF2KddDsbmTTjxs2oW79YfkberDZS8="; })
+  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tools"; version = "4.3.0"; hash = "sha256-8yLKFt2wQxkEf7fNfzB+cPUCjYn2qbqNgQ1+EeY2h/I="; })
+  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tracing"; version = "4.3.0"; hash = "sha256-dsmTLGvt8HqRkDWP8iKVXJCS+akAzENGXKPV18W2RgI="; })
+  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; hash = "sha256-PaiITTFI2FfPylTEk7DwzfKeiA/g/aooSU1pDcdwWLU="; })
+  (fetchNuGet { pname = "runtime.any.System.Globalization.Calendars"; version = "4.3.0"; hash = "sha256-AYh39tgXJVFu8aLi9Y/4rK8yWMaza4S4eaxjfcuEEL4="; })
+  (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.3.0"; hash = "sha256-vej7ySRhyvM3pYh/ITMdC25ivSd0WLZAaIQbYj/6HVE="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.3.0"; hash = "sha256-ns6f++lSA+bi1xXgmW1JkWFb2NaMD+w+YNTfMvyAiQk="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.3.0"; hash = "sha256-Y2AnhOcJwJVYv7Rp6Jz6ma0fpITFqJW+8rsw106K2X8="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.3.0"; hash = "sha256-LkPXtiDQM3BcdYkAm5uSNOiz3uF4J45qpxn5aBiqNXQ="; })
+  (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.3.0"; hash = "sha256-9EvnmZslLgLLhJ00o5MWaPuJQlbUFcUF8itGQNVkcQ4="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.3.0"; hash = "sha256-qwhNXBaJ1DtDkuRacgHwnZmOZ1u9q7N8j0cWOLYOELM="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.3.0"; hash = "sha256-PQRACwnSUuxgVySO1840KvqCC9F8iI9iTzxNW0RcBS4="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.3.0"; hash = "sha256-Kaw5PnLYIiqWbsoF3VKJhy7pkpoGsUwn4ZDCKscbbzA="; })
+  (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.3.0"; hash = "sha256-Q18B9q26MkWZx68exUfQT30+0PGmpFlDgaF0TnaIGCs="; })
+  (fetchNuGet { pname = "runtime.any.System.Text.Encoding.Extensions"; version = "4.3.0"; hash = "sha256-6MYj0RmLh4EVqMtO/MRqBi0HOn5iG4x9JimgCCJ+EFM="; })
+  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; hash = "sha256-agdOM0NXupfHbKAQzQT8XgbI9B8hVEh+a/2vqeHctg4="; })
+  (fetchNuGet { pname = "runtime.any.System.Threading.Timer"; version = "4.3.0"; hash = "sha256-BgHxXCIbicVZtpgMimSXixhFC3V+p5ODqeljDjO8hCs="; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-LXUPLX3DJxsU1Pd3UwjO1PO9NM2elNEDXeu2Mu/vNps="; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-qeSqaUI80+lqw5MK4vMpmO0CZaqrmYktwp6L+vQAb0I="; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-SrHqT9wrCBsxILWtaJgGKd6Odmxm8/Mh7Kh0CUkZVzA="; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; hash = "sha256-ZBZaodnjvLXATWpXXakFgcy6P+gjhshFXmglrL5xD5Y="; })
+  (fetchNuGet { pname = "runtime.native.System.IO.Compression"; version = "4.3.0"; hash = "sha256-DWnXs4vlKoU6WxxvCArTJupV6sX3iBbZh8SbqfHace8="; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.3.0"; hash = "sha256-c556PyheRwpYhweBjSfIwEyZHnAUB8jWioyKEcp/2dg="; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; hash = "sha256-2IhBv0i6pTcOyr8FFIyfPEaaCHUmJZ8DYwLUwJ+5waw="; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-Jy01KhtcCl2wjMpZWH+X3fhHcVn+SyllWFY8zWlz/6I="; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-wyv00gdlqf8ckxEdV7E+Ql9hJIoPcmYEuyeWb5Oz3mM="; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-zi+b4sCFrA9QBiSGDD7xPV27r3iHGlV99gpyVUjRmc4="; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; hash = "sha256-serkd4A7F6eciPiPJtUyJyxzdAtupEcWIZQ9nptEzIM="; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-gybQU6mPgaWV3rBG2dbH6tT3tBq8mgze3PROdsuWnX0="; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-VsP72GVveWnGUvS/vjOQLv1U80H2K8nZ4fDAmI61Hm4="; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-4yKGa/IrNCKuQ3zaDzILdNPD32bNdy6xr5gdJigyF5g="; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-HmdJhhRsiVoOOCcUvAwdjpMRiyuSwdcgEv2j9hxi+Zc="; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-pVFUKuPPIx0edQKjzRon3zKq8zhzHEzko/lc01V/jdw="; })
+  (fetchNuGet { pname = "runtime.unix.Microsoft.Win32.Primitives"; version = "4.3.0"; hash = "sha256-LZb23lRXzr26tRS5aA0xyB08JxiblPDoA7HBvn6awXg="; })
+  (fetchNuGet { pname = "runtime.unix.System.Console"; version = "4.3.0"; hash = "sha256-AHkdKShTRHttqfMjmi+lPpTuCrM5vd/WRy6Kbtie190="; })
+  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-ReoazscfbGH+R6s6jkg5sIEHWNEvjEoHtIsMbpc7+tI="; })
+  (fetchNuGet { pname = "runtime.unix.System.IO.FileSystem"; version = "4.3.0"; hash = "sha256-Pf4mRl6YDK2x2KMh0WdyNgv0VUNdSKVDLlHqozecy5I="; })
+  (fetchNuGet { pname = "runtime.unix.System.Net.Primitives"; version = "4.3.0"; hash = "sha256-pHJ+I6i16MV6m77uhTC6GPY6jWGReE3SSP3fVB59ti0="; })
+  (fetchNuGet { pname = "runtime.unix.System.Net.Sockets"; version = "4.3.0"; hash = "sha256-IvgOeA2JuBjKl5yAVGjPYMPDzs9phb3KANs95H9v1w4="; })
+  (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; hash = "sha256-c5tXWhE/fYbJVl9rXs0uHh3pTsg44YD1dJvyOA0WoMs="; })
+  (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-l8S9gt6dk3qYG6HYonHtdlYtBKyPb29uQ6NDjmrt3V4="; })
+  (fetchNuGet { pname = "Semi.Avalonia"; version = "11.0.0"; hash = "sha256-se/sc0QsAhzTv82JmBHoJ1jcmokqDZih8eEEX8CkR8s="; })
+  (fetchNuGet { pname = "Serilog"; version = "3.0.1"; hash = "sha256-cfcZXT2eQ4K6RQ0twDYPN5jkDpG9dYqpmHJX4zWrL+o="; })
+  (fetchNuGet { pname = "Serilog.Extensions.Logging"; version = "7.0.0"; hash = "sha256-Wf0Kb6YhvvIXNI0P/uOQP691DdlKuoNohpKMkp18bWE="; })
+  (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "4.1.0"; hash = "sha256-MXIj6YJ4GQbUS8553InMUZPPEfr8h33q2GtAhyu88+Y="; })
+  (fetchNuGet { pname = "Serilog.Sinks.Debug"; version = "2.0.0"; hash = "sha256-/PLVAE33lTdUEXdahkI5ddFiGZufWnvfsOodQsFB8sQ="; })
+  (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; hash = "sha256-GKy9hwOdlu2W0Rw8LiPyEwus+sDtSOTl8a5l9uqz+SQ="; })
+  (fetchNuGet { pname = "SerilogAnalyzer"; version = "0.15.0"; hash = "sha256-NG0osFNhuVIHDUOd3ZUpygSd0foH3C2QwECURL9nA00="; })
+  (fetchNuGet { pname = "ShimSkiaSharp"; version = "1.0.0.1"; hash = "sha256-j9V8IDg7vmnWNV65pDZ/wgj5wKLcmb4Fdbf8vbcP6sc="; })
+  (fetchNuGet { pname = "SkiaSharp"; version = "2.88.3"; hash = "sha256-WyMAjnQt8ZsuWpGLI89l/f4bHvv+cg7FdTAL7CtJBvs="; })
+  (fetchNuGet { pname = "SkiaSharp.HarfBuzz"; version = "2.88.3"; hash = "sha256-ykTtwAzO+ne5Wmss/IDvfUlR84wG5Xx0/AOC590Xvys="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.3"; hash = "sha256-eExWAAURgnwwm2fRwsK/rf+TeOAPs2n02XZzC0zeUjU="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.3"; hash = "sha256-8G4swiLMr6XS3kjfO/YC1PyoVdfSq7nxZthZZ+KTKqQ="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.3"; hash = "sha256-/SkV2pIZnt0ziSKB7gt7U2Rltk2Id+zOzbmqgfWUtvA="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.3"; hash = "sha256-2PhMTwRHitT13KCKiZltKIFieAvNY4jBmVZ2ndVynA8="; })
+  (fetchNuGet { pname = "Splat"; version = "14.4.1"; hash = "sha256-i1yzIVpKdFjZMI4J8H970nZCxszklgDitYTEKKz0zA8="; })
+  (fetchNuGet { pname = "Splat"; version = "14.6.37"; hash = "sha256-UPRwJetwHR31Z7sw7c0dojnvlFAmDNQEF7RXssiMQuY="; })
+  (fetchNuGet { pname = "Splat"; version = "14.7.1"; hash = "sha256-RzNQU8tTstC1MBZL6D11Ivq69pmPvl+A9eT9zXhdSOc="; })
+  (fetchNuGet { pname = "Splat.Microsoft.Extensions.DependencyInjection"; version = "14.6.37"; hash = "sha256-xq6jSI/go1Lt6hs1nhK5Gmqs0imX6iJF6vLXGWQEC98="; })
+  (fetchNuGet { pname = "Splat.Serilog"; version = "14.7.1"; hash = "sha256-EjoEF7a7qyJRVhyTVJUfoIoPwhFKfrSTVXdn1aVIvHU="; })
+  (fetchNuGet { pname = "Svg.Custom"; version = "1.0.0.1"; hash = "sha256-bRCllLNP+95+xov0ttRzvAgqCJ/x/BfOFPooVNcNngI="; })
+  (fetchNuGet { pname = "Svg.Model"; version = "1.0.0.1"; hash = "sha256-xrOGrMYTWvblI0BMMhVMv9Vm2x9rlJfRhvsb5Zel1E8="; })
+  (fetchNuGet { pname = "Svg.Skia"; version = "1.0.0.1"; hash = "sha256-fsuiMVlaDaZpHq387kugQhFPpIuW0E5KMZ6J8O09iPw="; })
+  (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; hash = "sha256-yg95LNQOwFlA1tWxXdQkVyJqT4AnoDc+ACmrNvzGiZg="; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.3.0"; hash = "sha256-XqZWb4Kd04960h4U9seivjKseGA/YEIpdplfHYHQ9jk="; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.0.11"; hash = "sha256-puoFMkx4Z55C1XPxNw3np8nzNGjH+G24j43yTIsDRL0="; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; hash = "sha256-afY7VUtD6w/5mYqrce8kQrvDIfS2GXDINDh73IjxJKc="; })
+  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.3.0"; hash = "sha256-KMY5DfJnDeIsa13DpqvyN8NkReZEMAFnlmNglVoFIXI="; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.6.0"; hash = "sha256-gnu+8nN48GAd4GRgeB5cAQmW7VnCubL/8h7zO377fd0="; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; hash = "sha256-GdwSIjLMM0uVfE56VUSLVNgpW0B//oCeSFj8/hSlbM8="; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "7.0.0"; hash = "sha256-9an2wbxue2qrtugYES9awshQg+KfJqajhnhs45kQIdk="; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; hash = "sha256-15yE2NoT9vmL9oGCaxHClQR1jLW1j1ef5hHMg55xRso="; })
+  (fetchNuGet { pname = "System.Console"; version = "4.3.0"; hash = "sha256-Xh3PPBZr0pDbDaK8AEHbdGz7ePK6Yi1ZyRWI1JM6mbo="; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.0.11"; hash = "sha256-P+rSQJVoN6M56jQbs76kZ9G3mAWFdtF27P/RijN8sj4="; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-fkA79SjPbSeiEcrbbUsb70u9B7wqbsdM9s1LnoKj0gM="; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.3.0"; hash = "sha256-OFJRb0ygep0Z3yDBLwAgM/Tkfs4JCDtsNhwDH9cd1Xw="; })
+  (fetchNuGet { pname = "System.Diagnostics.EventLog"; version = "6.0.0"; hash = "sha256-zUXIQtAFKbiUMKCrXzO4mOTD5EUphZzghBYKXprowSM="; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.0.1"; hash = "sha256-vSBqTbmWXylvRa37aWyktym+gOpsvH43mwr6A962k6U="; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.3.0"; hash = "sha256-gVOv1SK6Ape0FQhCVlNOd9cvQKBvMxRX9K0JPVi8w0Y="; })
+  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.3.0"; hash = "sha256-hCETZpHHGVhPYvb4C0fh4zs+8zv4GPoixagkLZjpa9Q="; })
+  (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; hash = "sha256-/9EaAbEeOjELRSMZaImS1O8FmUe8j4WuFUw1VOrPyAo="; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.0.11"; hash = "sha256-qWqFVxuXioesVftv2RVJZOnmojUvRjb7cS3Oh3oTit4="; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; hash = "sha256-k75gjOYimIQtLBD5NDzwwi3ZMUBPRW3jmc3evDMMJbU="; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.0.11"; hash = "sha256-rbSgc2PIEc2c2rN6LK3qCREAX3DqA2Nq1WcLrZYsDBw="; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; hash = "sha256-caL0pRmFSEsaoeZeWN5BTQtGrAtaQPwFi8YOZPZG5rI="; })
+  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; hash = "sha256-uNOD0EOVFgnS2fMKvMiEtI9aOw00+Pfy/H+qucAQlPc="; })
+  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; hash = "sha256-mmJWA27T0GRVuFP9/sj+4TrR4GJWrzNIk2PDrbr7RQk="; })
+  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; hash = "sha256-V6oyQFwWb8NvGxAwvzWnhPxy9dKOfj/XBM3tEC5aHrw="; })
+  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; hash = "sha256-ruynQHekFP5wPrDiVyhNiRIXeZ/I9NpjK5pU+HPDiRY="; })
+  (fetchNuGet { pname = "System.IO.Abstractions"; version = "19.2.29"; hash = "sha256-CTB8tE7mtG2ZCi4mRo8pS8IRsRkgIXdcD9yM94eJRbQ="; })
+  (fetchNuGet { pname = "System.IO.Abstractions.TestingHelpers"; version = "19.2.29"; hash = "sha256-2psTGHZlJESXZcPdpCw6pAHOApmn4b+qmbhWWxTZQSE="; })
+  (fetchNuGet { pname = "System.IO.Compression"; version = "4.3.0"; hash = "sha256-f5PrQlQgj5Xj2ZnHxXW8XiOivaBvfqDao9Sb6AVinyA="; })
+  (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.3.0"; hash = "sha256-WQl+JgWs+GaRMeiahTFUbrhlXIHapzcpTFXbRvAtvvs="; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; hash = "sha256-4VKXFgcGYCTWVXjAlniAVq0dO3o5s8KHylg2wg2/7k0="; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; hash = "sha256-vNIYnvlayuVj0WfRfYKpDrhDptlhp1pN8CYmlVd2TXw="; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; hash = "sha256-IpigKMomqb6pmYWkrlf0ZdpILtRluX2cX5sOKVW0Feg="; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; hash = "sha256-LMnfg8Vwavs9cMnq9nNH8IWtAtSfk0/Fy4s4Rt9r1kg="; })
+  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.0"; hash = "sha256-xfjF4UqTMJpf8KsBWUyJlJkzPTOO/H5MW023yTYNQSA="; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.1.0"; hash = "sha256-ZQpFtYw5N1F1aX0jUK3Tw+XvM5tnlnshkTCNtfVA794="; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; hash = "sha256-R5uiSL3l6a3XrXSSL6jz+q/PcyVQzEAByiuXZNSqD/A="; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.1.0"; hash = "sha256-7zqB+FXgkvhtlBzpcZyd81xczWP0D3uWssyAGw3t7b4="; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; hash = "sha256-+3pvhZY7rip8HCbfdULzjlC9FPZFpYoQxhkcuFm2wk8="; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; hash = "sha256-3sCEfzO4gj5CYGctl9ZXQRRhwAraMQfse7yzKoRe65E="; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; hash = "sha256-UoBB7WPDp2Bne/fwxKF0nE8grJ6FzTMXdT/jfsphj8Q="; })
+  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; hash = "sha256-eGZwCBExWsnirWBHyp2sSSSXp6g7I6v53qNmwPgtJ5c="; })
+  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; hash = "sha256-MY7Z6vOtFMbEKaLW9nOSZeAjcWpwCtdO7/W1mkGZBzE="; })
+  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.3.0"; hash = "sha256-il7dr5VT/QWDg/0cuh+4Es2u8LY//+qqiY9BZmYxSus="; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; hash = "sha256-qdSTIFgf2htPS+YhLGjAGiLN8igCYJnCCo6r78+Q+c8="; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.0.12"; hash = "sha256-MudZ/KYcvYsn2cST3EE049mLikrNkmE7QoUoYKKby+s="; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; hash = "sha256-gtmRkWP2Kwr3nHtDh0yYtce38z1wrGzb6fjm4v8wN6Q="; })
+  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; hash = "sha256-fVfgcoP4AVN1E5wHZbKBIOPYZ/xBeSIdsNF+bdukIRM="; })
+  (fetchNuGet { pname = "System.Reactive"; version = "5.0.0"; hash = "sha256-M5Z8pw8rVb8ilbnTdaOptzk5VFd5DlKa7zzCpuytTtE="; })
+  (fetchNuGet { pname = "System.Reactive.Linq"; version = "5.0.0"; hash = "sha256-K2t5JSmwsqWtYZj9IUGUdnCJaJlhCII07KtHP8Iu4B4="; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.1.0"; hash = "sha256-idZHGH2Yl/hha1CM4VzLhsaR8Ljo/rV7TYe7mwRJSMs="; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; hash = "sha256-NQSZRpZLvtPWDlvmMIdGxcVuyUnw92ZURo0hXsEshXY="; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.0.1"; hash = "sha256-F1MvYoQWHCY89/O4JBwswogitqVvKuVfILFqA7dmuHk="; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; hash = "sha256-5LhkDmhy2FkSxulXR+bsTtMzdU3VyyuZzsxp7/DwyIU="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.0.1"; hash = "sha256-YG+eJBG5P+5adsHiw/lhJwvREnvdHw6CJyS8ZV4Ujd0="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; hash = "sha256-mKRknEHNls4gkRwrEgi39B+vSaAz/Gt3IALtS98xNnA="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.0.1"; hash = "sha256-uVvNOnL64CPqsgZP2OLqNmxdkZl6Q0fTmKmv9gcBi+g="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; hash = "sha256-rKx4a9yZKcajloSZHr4CKTVJ6Vjh95ni+zszPxWjh2I="; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.0.1"; hash = "sha256-NsfmzM9G/sN3H8X2cdnheTGRsh7zbRzvegnjDzDH/FQ="; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; hash = "sha256-mMOCYzUenjd4rWIfq7zIX9PFYk/daUyF0A8l1hbydAk="; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; hash = "sha256-Wo+MiqhcP9dQ6NuFGrQTw6hpbJORFwp+TBNTq2yhGp8="; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.0.1"; hash = "sha256-SFSfpWEyCBMAOerrMCOiKnpT+UAWTvRcmoRquJR6Vq0="; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; hash = "sha256-5ogwWB4vlQTl3jjk1xjniG2ozbFIjZTL9ug0usZQuBM="; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.1.0"; hash = "sha256-R0YZowmFda+xzKNR4kKg7neFoE30KfZwp/IwfRSKVK4="; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; hash = "sha256-4U4/XNQAnddgQIHIJq3P2T80hN0oPdU2uCeghsDTWng="; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.0.1"; hash = "sha256-cZ2/3/fczLjEpn6j3xkgQV9ouOVjy4Kisgw5xWw9kSw="; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; hash = "sha256-idiOD93xbbrbwwSnD4mORA9RYi/D/U48eRUsn/WnWGo="; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; hash = "sha256-FViNGM/4oWtlP6w0JC0vJU+k9efLKZ+yaXrnEeabDQo="; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; hash = "sha256-51813WXpBIsuA6fUtE5XaRQjcWdQ2/lmEokJt97u0Rg="; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; hash = "sha256-UvyoDV8O0oY3HPG1GbA56YVdvwTGEfjYR5gW1O7IK4U="; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "6.0.0"; hash = "sha256-bEG1PnDp7uKYz/OgLOWs3RWwQSVYm+AnPwVmAmcgp2I="; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.1.0"; hash = "sha256-X7DZ5CbPY7jHs20YZ7bmcXs9B5Mxptu/HnBUvUnNhGc="; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-wLDHmozr84v1W2zYCWYxxj0FR0JDYHSVRaRuDm0bd/o="; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; hash = "sha256-j2QgVO9ZOjv7D1het98CoFpjoYgxjupuIhuBUmLLH7w="; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; hash = "sha256-KJ5aXoGpB56Y6+iepBkdpx/AfaJDAitx4vrkLqR7gms="; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.1.0"; hash = "sha256-QceAYlJvkPRJc/+5jR+wQpNNI3aqGySWWSO30e/FfQY="; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; hash = "sha256-8sDH+WUJfCR+7e4nfpftj/+lstEiZixWUBueR2zmHgI="; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.3.0"; hash = "sha256-MYpl6/ZyC6hjmzWRIe+iDoldOMW1mfbwXsduAnXIKGA="; })
+  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.3.0"; hash = "sha256-P5jHCgMbgFMYiONvzmaKFeOqcAIDPu/U8bOVrNPYKqc="; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.1.1"; hash = "sha256-80B05oxJbPLGq2pGOSl6NlZvintX9A1CNpna2aN0WRA="; })
+  (fetchNuGet { pname = "System.Security.Claims"; version = "4.3.0"; hash = "sha256-Fua/rDwAqq4UByRVomAxMPmDBGd5eImRqHVQIeSxbks="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.3.0"; hash = "sha256-tAJvNSlczYBJ3Ed24Ae27a55tq/n4D3fubNQdwcKWA8="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.3.0"; hash = "sha256-u17vy6wNhqok91SrVLno2M1EzLHZm6VMca85xbVChsw="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.3.0"; hash = "sha256-oefdTU/Z2PWU9nlat8uiRDGq/PGZoSPRgkML11pmvPQ="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.3.0"; hash = "sha256-Yuge89N6M+NcblcvXMeyHZ6kZDfwBv3LPMDiF8HhJss="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-DL+D2sc2JrQiB4oAcUggTFyD8w3aLEjJfod5JPe+Oz4="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.3.0"; hash = "sha256-fnFi7B3SnVj5a+BbgXnbjnGNvWrCEU6Hp/wjsjWz318="; })
+  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.3.0"; hash = "sha256-MG3V/owDh273GCUPsGGraNwaVpcydupl3EtPXj6TVG0="; })
+  (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; hash = "sha256-rjudVUHdo8pNJg2EVEn0XxxwNo5h2EaYo+QboPkXlYk="; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; hash = "sha256-mbdLVUcEwe78p3ZnB6jYsizNEqxMaCAWI3tEQNhRQAE="; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; hash = "sha256-PEailOvG05CVgPTyKLtpAgRydlSHmtd5K0Y8GSHY2Lc="; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; hash = "sha256-GctHVGLZAa/rqkBNhsBGnsiWdKyv6VDubYpGkuOkBLg="; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; hash = "sha256-PIhkv59IXjyiuefdhKxS9hQfEwO9YWRuNudpo53HQfw="; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; hash = "sha256-+kf7J3dEhgCbnCM5vHYlsTm5/R/Ud0Jr6elpHm922iI="; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; hash = "sha256-vufHXg8QAKxHlujPHHcrtGwAqFmsCD6HKjfDAiHyAYc="; })
+  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "7.0.0"; hash = "sha256-tF8qt9GZh/nPy0mEnj6nKLG4Lldpoi/D8xM5lv2CoYQ="; })
+  (fetchNuGet { pname = "System.Text.Json"; version = "7.0.0"; hash = "sha256-198zqA6NR4lGCKgpdy/ptkS0jsYRT6KUjewtfi4Fi2k="; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.1.0"; hash = "sha256-x6OQN6MCN7S0fJ6EFTfv4rczdUWjwuWE9QQ0P6fbh9c="; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; hash = "sha256-VLCk1D1kcN2wbAe3d0YQM/PqCsPHOuqlBY1yd2Yo+K0="; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; hash = "sha256-mob1Zv3qLQhQ1/xOLXZmYqpniNUMCfn02n8ZkaAhqac="; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; hash = "sha256-ZDQ3dR4pzVwmaqBg4hacZaVenQ/3yAF/uV7BXZXjiWc="; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; hash = "sha256-5SLxzFg1df6bTm2t09xeI01wa5qQglqUwwJNlQPJIVs="; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; hash = "sha256-Z5rXfJ1EXp3G32IKZGiZ6koMjRu0n8C1NGrwpdIen4w="; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.0.0"; hash = "sha256-+YdcPkMhZhRbMZHnfsDwpNbUkr31X7pQFGxXYcAPZbE="; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; hash = "sha256-X2hQ5j+fxcmnm88Le/kSavjiGOmkcumBGTZKBLvorPc="; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; hash = "sha256-owSpY8wHlsUXn5xrfYAiu847L6fAKethlvYx97Ri1ng="; })
+  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; hash = "sha256-wW0QdvssRoaOfQLazTGSnwYTurE4R8FxDx70pYkL+gg="; })
+  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.3.0"; hash = "sha256-pmhslmhQhP32TWbBzoITLZ4BoORBqYk25OWbru04p9s="; })
+  (fetchNuGet { pname = "System.ValueTuple"; version = "4.5.0"; hash = "sha256-niH6l2fU52vAzuBlwdQMw0OEoRS/7E1w5smBFoqSaAI="; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.0.11"; hash = "sha256-haZAFFQ9Sl2DhfvEbdx2YRqKEoxNMU5STaqpMmXw0zA="; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; hash = "sha256-QQ8KgU0lu4F5Unh+TbechO//zaAGZ4MfgvW72Cn1hzA="; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.0.11"; hash = "sha256-KPz1kxe0RUBM+aoktJ/f9p51GudMERU8Pmwm//HdlFg="; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.3.0"; hash = "sha256-rWtdcmcuElNOSzCehflyKwHkDRpiOhJJs8CeQ0l1CCI="; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions"; version = "19.2.29"; hash = "sha256-/WRBPWmUeiVDsj5HDXum1O5gJB2VZG93uEytNvhK7gE="; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.TestingHelpers"; version = "19.2.29"; hash = "sha256-ZfmcWG0jhZuub3Xm/6iOSC+v7Ua/DXaJYCsJ6TwSJ8g="; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.Wrappers"; version = "19.2.29"; hash = "sha256-fzhNO4mkQuf9iKIMV/f3HTzA4+bHPMtzCCeYyMkv07k="; })
+  (fetchNuGet { pname = "Tmds.DBus.Protocol"; version = "0.15.0"; hash = "sha256-4gk2vXDjKFaBh82gTkwg3c/5GRjiH+bvM5elfDSbKTU="; })
+  (fetchNuGet { pname = "xunit"; version = "2.4.1"; hash = "sha256-QGDuE0ZnsxyEJONP8GcJ80PmPeb+OawwdSW8y72aw3U="; })
+  (fetchNuGet { pname = "xunit.abstractions"; version = "2.0.3"; hash = "sha256-0D1y/C34iARI96gb3bAOG8tcGPMjx+fMabTPpydGlAM="; })
+  (fetchNuGet { pname = "xunit.analyzers"; version = "0.10.0"; hash = "sha256-8lRZhogXHYksa9ChnkFXpBnTMlLlYIvu3Av7qQYWwJY="; })
+  (fetchNuGet { pname = "xunit.assert"; version = "2.4.1"; hash = "sha256-hl1cMSakAlwkpFEchxCNMdvQie6PMJ1uFrhzgOC3vsY="; })
+  (fetchNuGet { pname = "xunit.core"; version = "2.4.1"; hash = "sha256-KgUgAIJIPHQ5VQ4FiB+i5u2JXSYxmvMCV8zXP4kcy9o="; })
+  (fetchNuGet { pname = "xunit.extensibility.core"; version = "2.4.1"; hash = "sha256-oACVOrvF4XmKFr+8ZqPVpjbopZgeRwaXveJGW2XUeIA="; })
+  (fetchNuGet { pname = "xunit.extensibility.execution"; version = "2.4.1"; hash = "sha256-KmKEdgsUq4zuQJ2saJA0YT1CIZ2AuhZL5V7cF2Cncd0="; })
+  (fetchNuGet { pname = "xunit.runner.visualstudio"; version = "2.4.3"; hash = "sha256-42axn0yDDiJWKV8UEYzYWgiKbpc6mHh9M/eeylYGLUg="; })
+]

pkgs/by-name/sm/smug/package.nix

···
 
 buildGoModule rec {
   pname = "smug";
-  version = "0.3.5";
+  version = "0.3.6";
 
   subPackages = [ "." ];
 
···
     owner = "ivaaaan";
     repo = "smug";
     rev = "v${version}";
-    sha256 = "sha256-5n4EmkcHv6pw1gd9VUtJRR3QdRJsu5DYYsozJ25uggs=";
+    sha256 = "sha256-9So81tZwQa3rQYgVO+KjOlTVIzlm/e2K5C/qULZeA7U=";
   };
 
   vendorHash = "sha256-vaDUzVRmpmNn8/vUPeR1U5N6T4llFRIk9A1lum8uauU=";

pkgs/by-name/so/soundsource/package.nix

···
 }:
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "soundsource";
-  version = "5.7.3";
+  version = "5.7.4";
 
   src = fetchurl {
-    url = "https://web.archive.org/web/20241112212337/https://cdn.rogueamoeba.com/soundsource/download/SoundSource.zip";
-    sha256 = "sha256-Eup7oiq8vVn2MqxJxE/Z2LtDMdluczHusRJ9uoW3X84=";
+    url = "https://web.archive.org/web/20241204215222/https://cdn.rogueamoeba.com/soundsource/download/SoundSource.zip";
+    hash = "sha256-zDIlhwczwXVPOV90EKF9pjO2CKlOEeFsqx17nIXaElw=";
   };
+
   dontUnpack = true;
 
   nativeBuildInputs = [ unzip ];
···
   installPhase = ''
     runHook preInstall
 
-    mkdir -p $out/Applications
-    unzip -d $out/Applications $src
+    mkdir -p "$out/Applications"
+    unzip -d "$out/Applications" $src
 
     runHook postInstall
   '';
 
-  meta = with lib; {
+  meta = {
+    changelog = "https://rogueamoeba.com/support/releasenotes/?product=SoundSource";
     description = "Sound controller for macOS";
     homepage = "https://rogueamoeba.com/soundsource";
-    license = licenses.unfree;
-    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
-    maintainers = with maintainers; [
+    license = lib.licenses.unfree;
+    maintainers = with lib.maintainers; [
       emilytrau
       donteatoreo
     ];
-    platforms = platforms.darwin;
+    platforms = lib.platforms.darwin;
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
   };
 })

pkgs/by-name/st/stats/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "stats";
-  version = "2.11.18";
+  version = "2.11.19";
 
   src = fetchurl {
     url = "https://github.com/exelban/stats/releases/download/v${finalAttrs.version}/Stats.dmg";
-    hash = "sha256-xEU897PE8LniQJijp83oSbHllck3pyediMqz/bzgFyE=";
+    hash = "sha256-aJ9b8/mWZmYPbS9Er6sMoMAIS7G0AoPT/7gnEx7SsGw=";
   };
 
   sourceRoot = ".";

pkgs/by-name/su/supabase-cli/package.nix

···
 
 buildGoModule rec {
   pname = "supabase-cli";
-  version = "1.210.1";
+  version = "2.0.0";
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = "cli";
     rev = "v${version}";
-    hash = "sha256-QQfuoM+CQIvQarEkfKlca8RBZkreesyjrrfSxrpUlCg=";
+    hash = "sha256-+5mcbI3pu9pahmUQnx8i2wctX/jF/CPTVaHJoH+Go4M=";
   };
 
-  vendorHash = "sha256-akNozQxElu+/BA5tDXRUPlMrQ2DBm2i713ZrQbwC4I0=";
+  vendorHash = "sha256-nBUV8oeoZc7N8FqEbx2Cjw4XsZW3JShv3/H58qk8JEo=";
 
   ldflags = [
     "-s"

pkgs/by-name/ta/tagparser/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "tagparser";
-  version = "12.3.1";
+  version = "12.4.0";
 
   src = fetchFromGitHub {
     owner = "Martchus";
     repo = "tagparser";
     rev = "v${version}";
-    hash = "sha256-ihrtUd9R8Tdkuv0kdIZNzBDrhwmsC3LNDsmoCroSMPM=";
+    hash = "sha256-wVdE1lgSQsH4g10/lxa8bZlYT141Vd7gRhefxyz8kRM=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/by-name/te/television/package.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "television";
-  version = "0.5.1";
+  version = "0.5.3";
 
   src = fetchFromGitHub {
     owner = "alexpasmantier";
     repo = "television";
     rev = "refs/tags/" + version;
-    hash = "sha256-mbf39AcW7MYu0A6D7poX6TChJccqweBvUbzJ1Ib+ABI=";
+    hash = "sha256-xYfaFs0a37maeLdnlEGVsocWWym41EOZ9dsuFXc1hMY=";
   };
 
-  cargoHash = "sha256-aWEqPIAcq5ZWCf0ZOYnswmj2dR0+41D1HMna0TAhxcE=";
+  cargoHash = "sha256-z12FeXQ2IpDZQYqnt6MPkLeW4Ul3XphSI38ikM/YizY=";
 
   passthru = {
     tests.version = testers.testVersion {

pkgs/by-name/te/termshot/go-mod.patch

···
+diff --git a/go.mod b/go.mod
+index 6627fb1..a3397a9 100644
+--- a/go.mod
++++ b/go.mod
+@@ -1,6 +1,6 @@
+ module github.com/homeport/termshot
+ 
+-go 1.20
++go 1.22.0
+ 
+ require (
+ 	github.com/creack/pty v1.1.23

pkgs/by-name/te/termshot/package.nix

···
 }:
 buildGoModule rec {
   pname = "termshot";
-  version = "0.2.8";
+  version = "0.2.12";
 
   src = fetchFromGitHub {
     owner = "homeport";
     repo = "termshot";
     rev = "v${version}";
-    hash = "sha256-cCtae2O9P9czivNVcytJKz3tQ41TaqokZcTOwt2v6jk=";
+    hash = "sha256-ua2tFyOjLeqOpipLoSisASqwjqGEFdkxd2qHybZ1VDU=";
   };
 
-  vendorHash = "sha256-ji2B9Gr1oQGouGH2hBpTyfjbht6bRfIeLcdTBhmmIwk=";
+  vendorHash = "sha256-JweKjKvShiimFHQwRtoVuongWqqGIPcPz77qEVNec+M=";
+
+  patches = [./go-mod.patch];
 
   ldflags = [
     "-s"

pkgs/by-name/ti/timeular/package.nix

···
 }:
 
 let
-  version = "6.8.4";
+  version = "6.8.5";
   pname = "timeular";
 
   src = fetchurl {
     url = "https://s3.amazonaws.com/timeular-desktop-packages/linux/production/Timeular-${version}.AppImage";
-    hash = "sha256-0x8Ra6NlYnYCcRTmEzFTBYOtUIaMBtL4/0293gxxeS0=";
+    hash = "sha256-hawVddF6jt0/fTL0bWAoK82F7mqskQLEO6w7/HBLLxQ=";
   };
 
   appimageContents = appimageTools.extractType2 {

pkgs/by-name/wg/wgpu-native/examples.nix

···
+{
+  lib,
+  stdenv,
+  cmake,
+  pkg-config,
+  ninja,
+  makeWrapper,
+  wgpu-native,
+  glfw,
+  wayland,
+  xorg,
+  vulkan-loader,
+
+  version,
+  src,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  inherit version src;
+  pname = "wgpu-native-examples";
+
+  sourceRoot = "${src.name}/examples";
+
+  postPatch = ''
+    substituteInPlace ./CMakeLists.txt \
+      --replace-fail 'add_subdirectory(vendor/glfw)' 'find_package(glfw3 3.4 REQUIRED)'
+  '';
+
+  strictDeps = true;
+
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+    ninja
+    makeWrapper
+  ];
+
+  buildInputs =
+    [
+      wgpu-native
+      glfw
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isLinux [
+      wayland
+      xorg.libX11
+      xorg.libXrandr
+    ];
+
+  runtimeInputs = lib.optionals stdenv.hostPlatform.isLinux [
+    # Without wayland in library path, this warning is raised:
+    # "No windowing system present. Using surfaceless platform"
+    wayland
+    # Without vulkan-loader present, wgpu won't find any adapter
+    vulkan-loader
+  ];
+
+  makeWrapperArgs = lib.optionals (finalAttrs.runtimeInputs != [ ]) [
+    "--prefix LD_LIBRARY_PATH : ${builtins.toString (lib.makeLibraryPath finalAttrs.runtimeInputs)}"
+  ];
+
+  installPhase = ''
+    runHook preInstall
+
+    concatTo makeWrapperArgsArray makeWrapperArgs
+
+    # find all executables that have the same name as their directory
+    for executable in $(find . -regex '.*\(/[^/]*\)\1' -type f -executable)
+    do
+      target="$(basename "$(dirname "$executable")")"
+      install -Dm755 $executable -t $out/bin
+      mkdir -p $out/share/$target
+      wrapProgram $out/bin/$target --chdir $out/share/$target "''${makeWrapperArgsArray[@]}"
+
+      # The examples expect their shaders in the CWD, so we copy them into the store
+      # and wrap the examples to run in the directory containing the shader.
+      for shader in $(find ../$target -type f -name '*.wgsl'); do
+        install -Dm644 $shader $out/share/$target/
+      done
+    done
+
+    runHook postInstall
+  '';
+
+  meta = wgpu-native.meta // {
+    description = "Examples for the native WebGPU implementation based on wgpu-core";
+    mainProgram = "triangle";
+  };
+})

pkgs/by-name/wg/wgpu-native/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  rustPlatform,
+  fixDarwinDylibNames,
+  vulkan-loader,
+  nix-update-script,
+  callPackage,
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "wgpu-native";
+  version = "22.1.0.5";
+
+  src = fetchFromGitHub {
+    owner = "gfx-rs";
+    repo = "wgpu-native";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-lEUHRU7+sFWtEYTOB2F+SmMNG8nrjro3IL7BgYuIGgM=";
+    fetchSubmodules = true;
+  };
+
+  outputs = [
+    "out"
+    "dev"
+  ];
+
+  useFetchCargoVendor = true;
+  cargoHash = "sha256-frlGlUqyKa3PTRbpLhcnUvu+SX64V/CnZGa6+ADxKCo=";
+
+  nativeBuildInputs = [
+    rustPlatform.bindgenHook
+  ] ++ lib.optional stdenv.hostPlatform.isDarwin fixDarwinDylibNames;
+
+  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
+    vulkan-loader
+  ];
+
+  postInstall = ''
+    rm $out/lib/libwgpu_native.a
+    install -Dm644 ./ffi/wgpu.h -t $dev/include/webgpu
+    install -Dm644 ./ffi/webgpu-headers/webgpu.h -t $dev/include/webgpu
+  '';
+
+  passthru = {
+    updateScript = nix-update-script { };
+    examples = callPackage ./examples.nix {
+      inherit version src;
+    };
+  };
+
+  meta = {
+    description = "Native WebGPU implementation based on wgpu-core";
+    homepage = "https://github.com/gfx-rs/wgpu-native";
+    license = with lib.licenses; [
+      mit
+      asl20
+    ];
+    maintainers = with lib.maintainers; [ niklaskorz ];
+  };
+}

pkgs/by-name/wi/wikiman/fix-paths.patch

···
+diff --git a/wikiman.sh b/wikiman.sh
+index 89a436e..adc6510 100755
+--- a/wikiman.sh
++++ b/wikiman.sh
+@@ -46,38 +46,7 @@ if printenv WIKIMAN_TUI_PREVIEW >/dev/null; then
+ fi
+ 
+ init() {
+-
+-	# BSD compatibility: Installation prefix
+-
+-	case "$(dirname "$0")" in
+-		"$HOME/bin"|"$HOME/.local/bin")
+-			conf_sys_usr="$HOME/.local/share";
+-			conf_sys_etc="${XDG_CONFIG_HOME:-"$HOME/.config"}/wikiman";;
+-		'/bin'|'/sbin'|'/usr/bin'|'/usr/sbin')
+-			conf_sys_usr='/usr';
+-			conf_sys_etc='/etc';;
+-		'/usr/local/bin'|'/usr/local/sbin')
+-			conf_sys_usr='/usr/local';
+-			conf_sys_etc='/usr/local/etc';;
+-		*)
+-			case "$(dirname "$(command -v wikiman)")" in
+-				"$HOME/bin"|"$HOME/.local/bin")
+-					echo 'warning: unsupported installation path, using fallback for user install' 1>&2;
+-					conf_sys_usr="$HOME/.local/share";
+-					conf_sys_etc="${XDG_CONFIG_HOME:-"$HOME/.config"}/wikiman";;
+-				'/bin'|'/sbin'|'/usr/bin'|'/usr/sbin')
+-					echo 'warning: unsupported installation path, using fallback for Linux' 1>&2;
+-					conf_sys_usr='/usr';
+-					conf_sys_etc='/etc';;
+-				'/usr/local/bin'|'/usr/local/sbin')
+-					echo 'warning: unsupported installation path, using fallback for BSD' 1>&2;
+-					conf_sys_usr='/usr/local';
+-					conf_sys_etc='/usr/local/etc';;
+-				*)
+-					echo 'error: unsupported installation path - failed to establish fallback' 1>&2;
+-					exit 5;;
+-			esac;;
+-	esac
++	conf_sys_etc="/etc/xdg/wikiman/wikiman.conf"
+ 
+ 	export conf_sys_usr
+ 	export conf_sys_etc

pkgs/by-name/wi/wikiman/package.nix

···
+{
+  lib,
+  stdenvNoCC,
+  fetchFromGitHub,
+  makeWrapper,
+
+  fzf,
+  ripgrep,
+  gawk,
+  w3m,
+  coreutils,
+  parallel,
+
+  nix-update-script,
+}:
+stdenvNoCC.mkDerivation (finalAttrs: {
+  pname = "wikiman";
+  version = "2.13.2";
+
+  src = fetchFromGitHub {
+    owner = "filiparag";
+    repo = "wikiman";
+    rev = "refs/tags/${finalAttrs.version}";
+    hash = "sha256-gk/9PVIRw9OQrdCSS+LcniXDYNcHUQUxZ2XGQCwpHaI=";
+  };
+
+  patches = [ ./fix-paths.patch ];
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  makeFlags = [ "prefix=${placeholder "out"}" ];
+
+  postInstall = ''
+    mv $out/usr/* $out
+    rmdir $out/usr
+  '';
+
+  postFixup =
+    let
+      runtimeDependencies = [
+        fzf
+        ripgrep
+        gawk
+        w3m
+        coreutils
+        parallel
+      ];
+    in
+    ''
+      wrapProgram $out/bin/wikiman \
+        --prefix PATH : "${lib.makeBinPath runtimeDependencies}":$out/bin \
+        --set "conf_sys_usr" "$out"
+    '';
+
+  # Couldn't do a versionCheckHook since the script fails when no sources are found.
+  # Even when just printing the version. Yeah.
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "Offline search engine for manual pages, Arch Wiki, Gentoo Wiki and other documentation";
+    homepage = "https://github.com/filiparag/wikiman";
+    license = with lib.licenses; [ mit ];
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ pluiedev ];
+    mainProgram = "wikiman";
+  };
+})

pkgs/by-name/xa/xapp/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xapp";
-  version = "2.8.6";
+  version = "2.8.7";
 
   outputs = [ "out" "dev" ];
 
···
     owner = "linuxmint";
     repo = pname;
     rev = version;
-    hash = "sha256-OQfP0XPBQrxJDrKb5PEqpBtinkQ35NMUbsYnxhbuehU=";
+    hash = "sha256-PMTsaY04rML2vmVIOWArYqWmGvpTtA1DpFw3ZAtu+oU=";
   };
 
   # Recommended by upstream, which enables the build of xapp-debug.

pkgs/by-name/xe/xed-editor/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xed-editor";
-  version = "3.6.7";
+  version = "3.6.9";
 
   src = fetchFromGitHub {
     owner = "linuxmint";
     repo = "xed";
     rev = version;
-    hash = "sha256-hQy06+/8rJIvHK7uKyMsIMH0qAZgza/2l/hOHDMOgo4=";
+    hash = "sha256-QPP7LWAiyKt7YBX88qlLS7PucQODH/c/j5WAbO9SF6k=";
   };
 
   patches = [

pkgs/by-name/xr/xreader/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xreader";
-  version = "4.2.2";
+  version = "4.2.3";
 
   src = fetchFromGitHub {
     owner = "linuxmint";
     repo = pname;
     rev = version;
-    hash = "sha256-c3oZ+PAsu180mlriQlF86TCBAnehLBv9Nc0SCtSkUuQ=";
+    hash = "sha256-qBnnxygkAn1wF3gtqR0At1e1e+sx1/2MoSWqmshW5Qg=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/yt/ytdl-sub/package.nix

···
     hash = "sha256-YMki+1rC726RtbZceoVbcpk/Gi3F81xxERQjpqLjn+A=";
   };
 
+  pythonRelaxDeps = [
+    "yt-dlp"
+  ];
+
   build-system = with python3Packages; [
     setuptools
     wheel

pkgs/desktops/gnome/extensions/extensionOverrides.nix

···
 { lib
+, fetchzip
 , ddcutil
 , easyeffects
 , gjs
···
     ];
   }))
 
-  (patchExtension "[e-mail]" (old: {
-    patches = [
-      (substituteAll {
-        src = ./extensionOverridesPatches/pano_at_elhan.io.patch;
-        inherit gsound libgda;
-      })
-    ];
+  (patchExtension "[e-mail]" (final: prev: {
+    version = "v23-alpha3";
+    src = fetchzip {
+      url = "https://github.com/oae/gnome-shell-pano/releases/download/${final.version}/[e-mail]";
+      hash = "sha256-LYpxsl/PC8hwz0ZdH5cDdSZPRmkniBPUCqHQxB4KNhc=";
+      stripRoot = false;
+    };
+    preInstall = ''
+      substituteInPlace extension.js \
+        --replace-fail "import Gda from 'gi://Gda?version>=5.0'" "imports.gi.GIRepository.Repository.prepend_search_path('${libgda}/lib/girepository-1.0'); const Gda = (await import('gi://Gda')).default" \
+        --replace-fail "import GSound from 'gi://GSound'" "imports.gi.GIRepository.Repository.prepend_search_path('${gsound}/lib/girepository-1.0'); const GSound = (await import('gi://GSound')).default"
+    '';
   }))
 
   (patchExtension "[e-mail]" (old: {

pkgs/desktops/gnome/extensions/extensionOverridesPatches/pano_at_elhan.io.patch

···
-diff --git a/__nix-prepend-search-paths.js b/__nix-prepend-search-paths.js
-new file mode 100644
-index 0000000..bf3071b
---- /dev/null
-+++ b/__nix-prepend-search-paths.js
-@@ -0,0 +1,3 @@
-+import GIRepository from 'gi://GIRepository';
-+GIRepository.Repository.prepend_search_path('@gsound@/lib/girepository-1.0');
-+GIRepository.Repository.prepend_search_path('@libgda@/lib/girepository-1.0');
-diff --git a/extension.js b/extension.js
-index a3d6741..6a38850 100644
---- a/extension.js
-+++ b/extension.js
-@@ -1,3 +1,4 @@
-+import './__nix-prepend-search-paths.js';
- import Gio from 'gi://Gio';
- import GLib from 'gi://GLib';
- import Shell from 'gi://Shell';
-diff --git a/prefs.js b/prefs.js
-index 5dd94eb..634b2ef 100644
---- a/prefs.js
-+++ b/prefs.js
-@@ -1,3 +1,4 @@
-+import './__nix-prepend-search-paths.js';
- import Gdk from 'gi://Gdk';
- import Gtk from 'gi://Gtk';
- import { ExtensionPreferences } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';

pkgs/desktops/mate/mate-notification-daemon/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mate-notification-daemon";
-  version = "1.28.1";
+  version = "1.28.3";
 
   src = fetchurl {
     url = "https://pub.mate-desktop.org/releases/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    hash = "sha256-//71U76hW+z/XtQNZOGMI9O2ScRZnMHrHoL3BTOFOzQ=";
+    hash = "sha256-4Azssf+fdbnMwmRFWORDQ7gJQe20A3fdgQDtOSKt9BM=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/physics/rivet/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rivet";
-  version = "4.0.1";
+  version = "4.0.2";
 
   src = fetchurl {
     url = "https://www.hepforge.org/archive/rivet/Rivet-${version}.tar.bz2";
-    hash = "sha256-ToaS1uilOWHHeYPra6SJPDdlzyP3BXieTYZb5Iku/3k=";
+    hash = "sha256-ZaOzb0K/94LtJ2eTDmaeCbFAiZYF15cvyPd3hbSogsA=";
   };
 
   latex = texliveBasic.withPackages (ps: with ps; [

pkgs/development/python-modules/django-leaflet/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-leaflet";
-  version = "0.30.1";
+  version = "0.31.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "django_leaflet";
     inherit version;
-    hash = "sha256-jsG2RcUe0Zob9GAZVKSIr8iPPubqqsh679uhUioNR0Y=";
+    hash = "sha256-+yt1+Er/YNQFhlkwDzGnEVVMZdEout5fqAiGN/sHUfc=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "mockito";
-  version = "1.5.1";
+  version = "1.5.3";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-QFYkCRcVzDlU4vo5zFDlCNWXeNTS+1bI23v6X1k9MwM=";
+    hash = "sha256-txkoQOfXDsJGOcxeGO/uXUGMg62GwP0r9+ccPkKuCqc=";
   };
 
   nativeBuildInputs = [ hatchling ];

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

···
   lib,
   buildPythonPackage,
   fetchPypi,
+  setuptools,
   requests,
 }:
 
 buildPythonPackage rec {
   pname = "nlpcloud";
-  version = "1.1.46";
-  format = "setuptools";
+  version = "1.1.47";
+  pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-NmNu1Rf6mN+Q8FdpeNYQ508ksqkIV7oOp8CrlDN1qPU=";
+    hash = "sha256-zj6hurPEzNlbrD6trq+zQHBNg4lJMGw+XHV51rBa9Mk=";
   };
 
-  propagatedBuildInputs = [ requests ];
+  build-system = [ setuptools ];
+
+  dependencies = [ requests ];
 
   # upstream has no tests
   doCheck = false;

pkgs/development/python-modules/oslo-log/default.nix

···
   lib,
   stdenv,
   buildPythonPackage,
-  fetchPypi,
-  eventlet,
+  fetchFromGitHub,
+
+  # build-system
+  setuptools,
+
+  # dependencies
   oslo-config,
   oslo-context,
   oslo-serialization,
   oslo-utils,
-  oslotest,
   pbr,
+  python-dateutil,
   pyinotify,
-  python-dateutil,
+
+  # tests
+  eventlet,
+  oslotest,
   pytestCheckHook,
-  pythonOlder,
-  setuptools,
 }:
 
 buildPythonPackage rec {
   pname = "oslo-log";
-  version = "6.1.2";
+  version = "6.2.0";
   pyproject = true;
 
-  disabled = pythonOlder "3.8";
-
-  src = fetchPypi {
-    pname = "oslo.log";
-    inherit version;
-    hash = "sha256-92gEffnXBsSE3WZl3LvqKJAh1Iy3zlq/eh9poJSR9f4=";
+  src = fetchFromGitHub {
+    owner = "openstack";
+    repo = "oslo.log";
+    rev = "refs/tags/${version}";
+    hash = "sha256-IEhIhGE95zZiWp602rFc+NLco/Oyx9XEL5e2RExNBMs=";
   };
+
+  # Manually set version because prb wants to get it from the git upstream repository (and we are
+  # installing from tarball instead)
+  PBR_VERSION = version;
 
   build-system = [ setuptools ];
 
···
 
   pythonImportsCheck = [ "oslo_log" ];
 
-  meta = with lib; {
+  __darwinAllowLocalNetworking = true;
+
+  meta = {
     description = "oslo.log library";
     mainProgram = "convert-json";
     homepage = "https://github.com/openstack/oslo.log";
-    license = licenses.asl20;
-    maintainers = teams.openstack.members;
+    license = lib.licenses.asl20;
+    maintainers = lib.teams.openstack.members;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "plaid-python";
-  version = "27.0.0";
+  version = "28.0.0";
   pyproject = true;
 
   disabled = pythonOlder "3.6";
···
   src = fetchPypi {
     pname = "plaid_python";
     inherit version;
-    hash = "sha256-nMDAJs9W2L3/wB7lOP5hMYF0ytqMVgDLOYzn9UsUVEw=";
+    hash = "sha256-JA4KH7zxSlxAyKHEsJ4YH8oAI2/s1ELwPrXwmi1HhYo=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "python-openstackclient";
-  version = "7.2.0";
+  version = "7.2.1";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-9je3W78PU3iZJjzVMSPXPxBZ0vMYY5xSLJA9zBJ7O5I=";
+    hash = "sha256-65q+VrUnJiRbmb37U5ps1RlsBSA5gJcDxlxpBJ5Eyjk=";
   };
 
   build-system = [

pkgs/development/python-modules/recurring-ical-events/default.nix

···
 
 buildPythonPackage rec {
   pname = "recurring-ical-events";
-  version = "3.3.3";
+  version = "3.3.4";
 
   disabled = pythonOlder "3.8";
 
···
     owner = "niccokunzmann";
     repo = "python-recurring-ical-events";
     rev = "refs/tags/v${version}";
-    hash = "sha256-gEatTTpRiqtDAn+JtoJuVHPYKmEkc5saw3hy4ZYZfX8=";
+    hash = "sha256-3KlmJJmak3X9adUlcmclnCv9D1Ddr+woFokrinZBYoE=";
   };
 
   build-system = [ setuptools ];
-
-  pythonRelaxDeps = [ "x-wr-timezone" ];
 
   dependencies = [
     icalendar

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  pytestCheckHook,
+  setuptools,
+  numpy,
+  torch,
+}:
+
+buildPythonPackage rec {
+  pname = "roma";
+  version = "1.5.1";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "naver";
+    repo = "roma";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-DuQjnHoZKQF/xnFMYb0OXhycsRcK4oHoocq6o+NoGRs=";
+  };
+
+  build-system = [
+    setuptools
+  ];
+
+  dependencies = [
+    numpy
+    torch
+  ];
+
+  nativeCheckInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "roma"
+  ];
+
+  meta = {
+    description = "Lightweight library to deal with 3D rotations in PyTorch";
+    homepage = "https://github.com/naver/roma";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ nim65s ];
+  };
+}

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

···
 }:
 
 buildPythonPackage rec {
-  version = "3.5.16";
+  version = "3.5.17";
   format = "setuptools";
   pname = "rpy2";
 
   disabled = isPyPy;
   src = fetchPypi {
     inherit version pname;
-    hash = "sha256-g34vdFg2WKXEwzl2GnP5Q08z75ztPjDGTadWIWXCgBs=";
+    hash = "sha256-2/8Iww89eRYZImI4WKWztoo/uo7hdH1q9BvEumjz1YI=";
   };
 
   patches = [

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchPypi,
+
+  # build-system
+  setuptools,
+
+  # dependencies
+  fsspec,
+  numpy,
+  packaging,
+  psutil,
+  pyre-extensions,
+  tabulate,
+  tensorboard,
+  torch,
+  tqdm,
+  typing-extensions,
+}:
+
+buildPythonPackage rec {
+  pname = "torchtnt";
+  version = "0.2.4";
+  pyproject = true;
+
+  # no tag / releases on github
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-Js9OcYllr8KT52FYtHKDciBVvPeelNDmfnC12/YcDJs=";
+  };
+
+  # requirements.txt is not included in Pypi archive
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace-fail 'read_requirements("requirements.txt")' "[]" \
+      --replace-fail 'read_requirements("dev-requirements.txt")' "[]"
+  '';
+
+  build-system = [
+    setuptools
+  ];
+
+  dependencies = [
+    fsspec
+    numpy
+    packaging
+    psutil
+    pyre-extensions
+    setuptools
+    tabulate
+    tensorboard
+    torch
+    tqdm
+    typing-extensions
+  ];
+
+  pythonImportsCheck = [
+    "torchtnt"
+  ];
+
+  # Tests are not included in Pypi archive
+  doCheck = false;
+
+  meta = {
+    description = "Lightweight library for PyTorch training tools and utilities";
+    homepage = "https://github.com/pytorch/tnt";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ nim65s ];
+  };
+}

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

···
 {
   lib,
-  fetchPypi,
+  fetchFromGitHub,
   buildPythonPackage,
+  setuptools,
   zope-interface,
-  mock,
+  pytestCheckHook,
   pythonOlder,
 }:
 
 buildPythonPackage rec {
   pname = "transaction";
-  version = "4.0";
-  format = "setuptools";
+  version = "5.0";
+  pyproject = true;
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.8";
 
-  src = fetchPypi {
-    inherit pname version;
-    hash = "sha256-aANduRP2DRvhL2Vj0gHaqzbIPnY94ViZ/4M48m5eYvI=";
+  src = fetchFromGitHub {
+    owner = "zopefoundation";
+    repo = "transaction";
+    rev = "refs/tags/${version}";
+    hash = "sha256-8yvA2dvB69+EqsAa+hc93rgg6D64lcajl6JgFabhjwY=";
   };
 
-  propagatedBuildInputs = [
+  postPatch = ''
+    substituteInPlace pyproject.toml \
+      --replace-fail "setuptools<74" "setuptools"
+  '';
+
+  build-system = [
+    setuptools
+  ];
+
+  dependencies = [
     zope-interface
-    mock
+  ];
+
+  nativeCheckInputs = [
+    pytestCheckHook
   ];
 
   pythonImportsCheck = [ "transaction" ];
 
-  meta = with lib; {
+  meta = {
     description = "Transaction management";
     homepage = "https://transaction.readthedocs.io/";
     changelog = "https://github.com/zopefoundation/transaction/blob/${version}/CHANGES.rst";
-    license = licenses.zpl20;
-    maintainers = [ ];
+    license = lib.licenses.zpl21;
+    maintainers = with lib.maintainers; [ nickcao ];
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "yattag";
-  version = "1.16.0";
+  version = "1.16.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-CXgke5dU2fRONwPGQ3Srn6hy0Y3pWsV3L9/dPD8NBwY=";
+    hash = "sha256-uqjyVOfqXT4GGCga0v9WEODlNgs2COaVwpv7OynQUfQ=";
   };
 
   pythonImportsCheck = [ "yattag" ];

pkgs/development/python-modules/zope-exceptions/default.nix

···
 {
   lib,
   buildPythonPackage,
-  fetchPypi,
+  fetchFromGitHub,
   pythonOlder,
   setuptools,
   zope-interface,
···
 
 buildPythonPackage rec {
   pname = "zope-exceptions";
-  version = "5.1";
+  version = "5.2";
   pyproject = true;
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.8";
 
-  src = fetchPypi {
-    pname = "zope.exceptions";
-    inherit version;
-    hash = "sha256-YRtMSUbDAWDbS3u9TzhhOzJoSvFn0xllCvm3O8ew6Xg=";
+  src = fetchFromGitHub {
+    owner = "zopefoundation";
+    repo = "zope.exceptions";
+    rev = "refs/tags/${version}";
+    hash = "sha256-jbzUUB6ifTfxiGEiyAmsDoDLyRVuZPgIsN8mCNJkv4Q=";
   };
 
-  nativeBuildInputs = [ setuptools ];
+  build-system = [
+    setuptools
+  ];
 
-  propagatedBuildInputs = [ zope-interface ];
+  dependencies = [
+    setuptools
+    zope-interface
+  ];
 
   # circular deps
   doCheck = false;
 
   pythonImportsCheck = [ "zope.exceptions" ];
 
-  meta = with lib; {
+  meta = {
     description = "Exception interfaces and implementations";
     homepage = "https://pypi.python.org/pypi/zope.exceptions";
     changelog = "https://github.com/zopefoundation/zope.exceptions/blob/${version}/CHANGES.rst";
-    license = licenses.zpl21;
-    maintainers = [ ];
+    license = lib.licenses.zpl21;
+    maintainers = with lib.maintainers; [ nickcao ];
   };
 }

pkgs/servers/monitoring/prometheus/nginx-exporter.nix

···
 
 buildGoModule rec {
   pname = "nginx_exporter";
-  version = "1.3.0";
+  version = "1.4.0";
 
   src = fetchFromGitHub {
     owner = "nginxinc";
     repo = "nginx-prometheus-exporter";
     rev = "v${version}";
-    sha256 = "sha256-TcQXYZsr3hjE93GfeBt8AJLuQQA7UM+wv1SmCnqON+M=";
+    sha256 = "sha256-aA6wQjTVkyEx+f1xBdrvN05NGqnJkgLVwrNLSh5+Ll0=";
   };
 
-  vendorHash = "sha256-qmyqAbwQYgUFFQwCLakQGta2XMGCbCOvCB93S8/TWIs=";
+  vendorHash = "sha256-ua3Cm1VXRs3M58vJ/fEt7SH+ZYegt0WjOGRV/iU8qZk=";
 
   ldflags = let t = "github.com/prometheus/common/version"; in [
     "-s"

pkgs/tools/filesystems/juicefs/default.nix

···
 
 buildGoModule rec {
   pname = "juicefs";
-  version = "1.2.1";
+  version = "1.2.2";
 
   src = fetchFromGitHub {
     owner = "juicedata";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-qTJU5o0wjHu3M8zMwMm6/QTAqD2JvCg9XnxfW77MCoI=";
+    hash = "sha256-DQ3JdP1HKWORPkcP4HJ32eg6aaockZfG+FQhBJnZCFQ=";
   };
 
-  vendorHash = "sha256-y5ao4C24Py8NmZLZlpoz3C7TvUe5vsI74QdzQ7LAh6o=";
+  vendorHash = "sha256-fHmLTAn4W8KMtZ1Ov4gBQTUpzHqQnipGSQs5hr1MD3w=";
 
   excludedPackages = [ "sdk/java/libjfs" ];
 

pkgs/tools/games/scarab/default.nix pkgs/by-name/sc/scarab/package.nix

···
 
   src = fetchFromGitHub {
     owner = "fifty-six";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "sha256-z1hmMrfeoYyjVEPPjWvUfKUKsOS7UsocSWMYrFY+/kI=";
+    repo = "scarab";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-z1hmMrfeoYyjVEPPjWvUfKUKsOS7UsocSWMYrFY+/kI=";
   };
 
-  dotnet-sdk = dotnetCorePackages.sdk_6_0;
+  dotnet-sdk = dotnetCorePackages.sdk_8_0;
   nugetDeps = ./deps.nix;
   projectFile = "Scarab/Scarab.csproj";
   testProjectFile = "Scarab.Tests/Scarab.Tests.csproj";
   executables = [ "Scarab" ];
 
-  preConfigureNuGet = ''
-    # This should really be in the upstream nuget.config
-    dotnet nuget add source https://api.nuget.org/v3/index.json \
-      -n nuget.org --configfile NuGet.Config
+  postPatch = ''
+    substituteInPlace Scarab/Scarab.csproj Scarab.Tests/Scarab.Tests.csproj \
+      --replace-fail 'net6.0' 'net8.0'
   '';
 
   runtimeDeps = [
···
       name = "scarab";
       exec = "Scarab";
       icon = "scarab";
-      comment = meta.description;
+      comment = "Hollow Knight mod installer and manager";
       type = "Application";
       categories = [ "Game" ];
     })

pkgs/tools/games/scarab/deps.nix

···
-# This file was automatically generated by passthru.fetch-deps.
-# Please dont edit it manually, your changes might get overwritten!
-
-{ fetchNuGet }: [
-  (fetchNuGet { pname = "Avalonia"; version = "11.0.0"; sha256 = "0wfbwrr8p5hg9f809d44gh2zfkfwnwayfw84vs33hh7ms0r380gd"; })
-  (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2023020321"; sha256 = "1az4s1g22ipak9a3xfh55z2h3rm6lpqh7svbpw6ag4ysrgsjjsjd"; })
-  (fetchNuGet { pname = "Avalonia.AvaloniaEdit"; version = "11.0.0"; sha256 = "12ibz472083iiz5zskd1ivigggbl0d9yv3nazgw17s97nmnl2lpj"; })
-  (fetchNuGet { pname = "Avalonia.BuildServices"; version = "0.0.28"; sha256 = "0d9hyc1zmyvzlb320arwrv12ncp45llq98hibv711b7ibm11dm7c"; })
-  (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.0"; sha256 = "06wgzhxkivlaxkn8p61wainsprml2g1q4jmvy9fpn64qnfywjdn7"; })
-  (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.0"; sha256 = "0qlcdx4w1pcljgs7sfbn5xmmnqwp2m0fqyswrgz6c8cvjzcfsjsj"; })
-  (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.0"; sha256 = "08y31b357fax7c1ggwhjsfwgaj6zkm2abhpc6amlmk6ci4zn12lf"; })
-  (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.0"; sha256 = "134xl19rfswnz75a1mhil9yqy8haqa788rmd1p1kk6ibjbhb3np9"; })
-  (fetchNuGet { pname = "Avalonia.Fonts.Inter"; version = "11.0.0"; sha256 = "1vbkk97jhy9qwix25jc875m98cp6vrl86029la55cbky9m1819am"; })
-  (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.0"; sha256 = "042s8lc83lw6ygcsiza14wlsc09rgzw3ch2qaxkhlp73bh736ps3"; })
-  (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.0"; sha256 = "1j7wpv81wqwh6zhfzc1f36vb5dp6s2ig45v8km9sp0q6f66zkrsh"; })
-  (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "11.0.0"; sha256 = "1fhp6f2aj2bmzlcj0s5r9i9rcxwakdg9gvjqvdqaq8s98d0s06qh"; })
-  (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.0"; sha256 = "1b5031k8slwiz7bncih67fjl6ny234yd4skqxk611l9zp5snjic2"; })
-  (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.0"; sha256 = "1ra1kd0kkblppr5zy7rzdbwllggrzvp9lkxblf9mg3y8rnp6fk83"; })
-  (fetchNuGet { pname = "Avalonia.Svg"; version = "11.0.0.1"; sha256 = "0a61xg6pcmjy90mmjv42d64av5a7q919qbrhnv6vd1rmm6hxv7zf"; })
-  (fetchNuGet { pname = "Avalonia.Svg.Skia"; version = "11.0.0.1"; sha256 = "1bywgrqdqc5wgcsabnhm8yssg78g9lw3p3sza5f8w5vdzmr116ff"; })
-  (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.0"; sha256 = "1qw76n78c14xl419yzabahbsrgymm850ql05gd4fh5naq2brksdm"; })
-  (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.0"; sha256 = "1djp4m5yin4i2f9sjv4v3syv02fllwbfinzm9h0hm2abc2ccvrm3"; })
-  (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.0"; sha256 = "1gd4zrjyw3hg3d48ivhxp0ca7ma13dnpr8y1wc7d51ddlrj3c86g"; })
-  (fetchNuGet { pname = "Castle.Core"; version = "5.1.1"; sha256 = "1caf4878nvjid3cw3rw18p9cn53brfs5x8dkvf82xvcdwc3i0nd1"; })
-  (fetchNuGet { pname = "ColorTextBlock.Avalonia"; version = "11.0.0-d1"; sha256 = "1vf5fp11zx21bsakbpf12j6mchafh749cs03w9cifb6ci98jchgh"; })
-  (fetchNuGet { pname = "ColorTextBlock.Avalonia"; version = "11.0.2"; sha256 = "0zvdgpg6r142zhldam5kcpmjpi0qjxsm40cy491gb9ynrj39hrhn"; })
-  (fetchNuGet { pname = "coverlet.collector"; version = "1.3.0"; sha256 = "0k65d9hag6d59w1ixf4n5ihcphp04vrjmd99x5nhga81w1k9i20y"; })
-  (fetchNuGet { pname = "DryIoc.dll"; version = "5.4.1"; sha256 = "1dbaac5pi7mim4qil3lrqcpad9vbn261rznk5rw26kvngzcc65n6"; })
-  (fetchNuGet { pname = "DryIoc.Microsoft.DependencyInjection"; version = "6.2.0"; sha256 = "0iygbabd73ggzyq1ckbxifrh1kvzwlkr3x32ahamka7pv3982khb"; })
-  (fetchNuGet { pname = "DynamicData"; version = "7.9.5"; sha256 = "1m9qx8g6na5ka6kd9vhg8gjmxrnkzb6v5cl5yqp1kdjsw4rcwy6x"; })
-  (fetchNuGet { pname = "ExCSS"; version = "4.1.4"; sha256 = "1y50xp6rihkydbf5l73mr3qq2rm6rdfjrzdw9h1dw9my230q5lpd"; })
-  (fetchNuGet { pname = "FakeItEasy"; version = "8.0.0-alpha.1.10"; sha256 = "0492cayij2ap7rc9l8rkmmch1rb0jqckaspqxrsy0myldfqc2lpq"; })
-  (fetchNuGet { pname = "Fizzler"; version = "1.2.1"; sha256 = "1w5jb1d0figbv68dydbnlcsfmqlc3sv9z1zxp7d79dg2dkarc4qm"; })
-  (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.3"; sha256 = "115aybicqs9ijjlcv6k6r5v0agkjm1bm1nkd0rj3jglv8s0xvmp2"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.3"; sha256 = "1f18ahwkaginrg0vwsi6s56lvnqvvxv7pzklfs5lnknasxy1a76z"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.3"; sha256 = "052d8frpkj4ijs6fm6xp55xbv95b1s9biqwa0w8zp3rgm88m9236"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.3"; sha256 = "043hv36bg5240znbm8x5la7py17m4jfzy57q3ka32f6zjld83j36"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.3"; sha256 = "08khd2jqm8sw58ljz5srangzfm2sz3gd2q1jzc5fr80lj8rv6r74"; })
-  (fetchNuGet { pname = "HtmlAgilityPack"; version = "1.11.42"; sha256 = "0cvnc1qdfcjbqkh335bv4wp44zisb4hc69lq3zphiyzqfrjisnyb"; })
-  (fetchNuGet { pname = "JetBrains.Annotations"; version = "2023.2.0"; sha256 = "0nx7nrzbg9gk9skdc9x330cbr5xbsly6z9gzxm46vywf55yp8vaj"; })
-  (fetchNuGet { pname = "Markdown.Avalonia"; version = "11.0.2"; sha256 = "1nx1f3pqlpffwwpdk8d6bbd27mz2q45k3gkc5dz6m2pfxi0ij6ak"; })
-  (fetchNuGet { pname = "Markdown.Avalonia.Html"; version = "11.0.2"; sha256 = "1xjz45lg9dcfwcdl0sbfy0145m6bd8y3b6kvwh96fnnj8ks6074q"; })
-  (fetchNuGet { pname = "Markdown.Avalonia.Svg"; version = "11.0.2"; sha256 = "1s5yazazpmhkc2nizzm46cnfwk7wwdd6gg2lzcs30k813i3621z3"; })
-  (fetchNuGet { pname = "Markdown.Avalonia.SyntaxHigh"; version = "11.0.2"; sha256 = "0di7r0wiif2lvgr0wlw1lj7b9j85yp1pf5hyhh4n9ciykklkkq0p"; })
-  (fetchNuGet { pname = "Markdown.Avalonia.Tight"; version = "11.0.0-d1"; sha256 = "0ks9k3wqwvdssiwbcjc4gnrfn1r8x2dbp9amraxkmws5a7vbjdyk"; })
-  (fetchNuGet { pname = "Markdown.Avalonia.Tight"; version = "11.0.2"; sha256 = "1mz229r42f1p320xkjl45pdv72lycn9cqk46arycm9km45jgzzgl"; })
-  (fetchNuGet { pname = "MessageBox.Avalonia"; version = "2.3.1-rc1"; sha256 = "13zvqg95wa5v5b8h8kl63ydpprxqyk6zgzqdh673y005s1y58w4a"; })
-  (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; sha256 = "0p9c3m0zk59x9dcqw077hzd2yk60myisbacvm36mnwpcjwzjkp2m"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; sha256 = "0bbl0jpqywqmzz2gagld1p2gvdfldjfjmm25hil9wj2nq1zc4di8"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; sha256 = "12n7rvr39bzkf2maw7zplw8rwpxpxss4ich3bb2pw770rx4nyvyw"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; sha256 = "1kmry65csvfn72zzc16vj1nfbfwam28wcmlrk3m5rzb8ydbzgylb"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; sha256 = "0w0yx0lpg54iw5jazqk46h48gx43ij32gwac8iywdj6kxfxm03vw"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; sha256 = "0hjgxcsj5zy27lqk0986m59n5dbplx2vjjla2lsvg4bwg8qa7bpk"; })
-  (fetchNuGet { pname = "Microsoft.CodeCoverage"; version = "16.7.1"; sha256 = "1farw63445cdyciplfs6l9j1gayxw16rkzmrwsiswfyjhqz70xd4"; })
-  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj"; })
-  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "7.0.0"; sha256 = "121zs4jp8iimgbpzm3wsglhjwkc06irg1pxy8c1zcdlsg34cfq1p"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "7.0.0"; sha256 = "181d7mp9307fs17lyy42f8cxnjwysddmpsalky4m0pqxcimnr6g7"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "7.0.0"; sha256 = "1bqd3pqn5dacgnkq0grc17cgb2i0w8z1raw12nwm3p3zhrfcvgxf"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "7.0.0"; sha256 = "1gn7d18i1wfy13vrwhmdv1rmsb4vrk26kqdld4cgvh77yigj90xs"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "7.0.0"; sha256 = "0b90zkrsk5dw3wr749rbynhpxlg4bgqdnd7d5vdlw2g9c7zlhgx6"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "7.0.0"; sha256 = "1b4km9fszid9vp2zb3gya5ni9fn8bq62bzaas2ck2r7gs0sdys80"; })
-  (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "16.7.1"; sha256 = "0yqxipj74ax2n76w9ccydppx78ym8m5fda88qnvj4670qjvl0kf8"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; sha256 = "1507hnpr9my3z4w1r6xk5n0s1j3y6a2c2cnynj76za7cphxi1141"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
-  (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "16.7.1"; sha256 = "0s9dyh99gzdpk1i5v468i2r9m6i3jrr41r394pwdwiajsz99kay0"; })
-  (fetchNuGet { pname = "Microsoft.TestPlatform.TestHost"; version = "16.7.1"; sha256 = "1xik06rxn9ps83in0zn9vcl2ibv3acmdqvrx07qq89lxj1sgqlhs"; })
-  (fetchNuGet { pname = "Microsoft.Toolkit.HighPerformance"; version = "7.1.2"; sha256 = "18l950mq0l8s1z771l9p332ni7jryidjh4hi9p37l6p8frcnccxb"; })
-  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })
-  (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; sha256 = "0c6pcj088g1yd1vs529q3ybgsd2vjlk5y1ic6dkmbhvrp5jibl9p"; })
-  (fetchNuGet { pname = "NETStandard.Library"; version = "1.6.1"; sha256 = "1z70wvsx2d847a2cjfii7b83pjfs34q05gb037fdjikv5kbagml8"; })
-  (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; sha256 = "0mcy0i7pnfpqm4pcaiyzzji4g0c8i3a5gjz28rrr28110np8304r"; })
-  (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.0.0"; sha256 = "18ijvmj13cwjdrrm52c8fpq021531zaz4mj4b4zapxaqzzxf2qjr"; })
-  (fetchNuGet { pname = "Projektanker.Icons.Avalonia"; version = "6.6.0-rc1.1"; sha256 = "04sac2grc1mbx1rfx29i16k0yrqh29c60njsj2mq8yrs1z2ky9jj"; })
-  (fetchNuGet { pname = "Projektanker.Icons.Avalonia.FontAwesome"; version = "6.6.0-rc1.1"; sha256 = "1mzdgds62f7apy8gajrpsa6fay89rzfl7f9mf6y573ani7a131xc"; })
-  (fetchNuGet { pname = "PropertyChanged.SourceGenerator"; version = "1.0.8"; sha256 = "05ygdj1sizcw678vf459hzhz4ynz2s5s206vl99g5gy3d9kaham6"; })
-  (fetchNuGet { pname = "ReactiveUI"; version = "18.3.1"; sha256 = "1lxkc8yk9glj0w9n5vry2dnwwvh8152ad2c5bivk8aciq64zidyn"; })
-  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; sha256 = "0bv5qgm6vr47ynxqbnkc7i797fdi8gbjjxii173syrx14nmrkwg0"; })
-  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "1wl76vk12zhdh66vmagni66h5xbhgqq7zkdpgw21jhxhvlbcl8pk"; })
-  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn"; })
-  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x"; })
-  (fetchNuGet { pname = "runtime.any.System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201"; })
-  (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.3.0"; sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.3.0"; sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.3.0"; sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.3.0"; sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf"; })
-  (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.3.0"; sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.3.0"; sha256 = "0bh5bi25nk9w9xi8z23ws45q5yia6k7dg3i4axhfqlnj145l011x"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19"; })
-  (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.3.0"; sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3"; })
-  (fetchNuGet { pname = "runtime.any.System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8"; })
-  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va"; })
-  (fetchNuGet { pname = "runtime.any.System.Threading.Timer"; version = "4.3.0"; sha256 = "0aw4phrhwqz9m61r79vyfl5la64bjxj8l34qnrcwb28v49fg2086"; })
-  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d"; })
-  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59"; })
-  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa"; })
-  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4"; })
-  (fetchNuGet { pname = "runtime.native.System.IO.Compression"; version = "4.3.0"; sha256 = "1vvivbqsk6y4hzcid27pqpm5bsi6sc50hvqwbcx8aap5ifrxfs8d"; })
-  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.3.0"; sha256 = "1n6rgz5132lcibbch1qlf0g9jk60r0kqv087hxc0lisy50zpm7kk"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "1b61p6gw1m02cc1ry996fl49liiwky6181dzr873g9ds92zl326q"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97"; })
-  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3"; })
-  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "10yc8jdrwgcl44b4g93f1ds76b176bajd3zqi2faf5rvh1vy9smi"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3"; })
-  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn"; })
-  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5"; })
-  (fetchNuGet { pname = "runtime.unix.Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0y61k9zbxhdi0glg154v30kkq7f8646nif8lnnxbvkjpakggd5id"; })
-  (fetchNuGet { pname = "runtime.unix.System.Console"; version = "4.3.0"; sha256 = "1pfpkvc6x2if8zbdzg9rnc5fx51yllprl8zkm5npni2k50lisy80"; })
-  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "1lps7fbnw34bnh3lm31gs5c0g0dh7548wfmb8zz62v0zqz71msj5"; })
-  (fetchNuGet { pname = "runtime.unix.System.IO.FileSystem"; version = "4.3.0"; sha256 = "14nbkhvs7sji5r1saj2x8daz82rnf9kx28d3v2qss34qbr32dzix"; })
-  (fetchNuGet { pname = "runtime.unix.System.Net.Primitives"; version = "4.3.0"; sha256 = "0bdnglg59pzx9394sy4ic66kmxhqp8q8bvmykdxcbs5mm0ipwwm4"; })
-  (fetchNuGet { pname = "runtime.unix.System.Net.Sockets"; version = "4.3.0"; sha256 = "03npdxzy8gfv035bv1b9rz7c7hv0rxl5904wjz51if491mw0xy12"; })
-  (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; sha256 = "1jx02q6kiwlvfksq1q9qr17fj78y5v6mwsszav4qcz9z25d5g6vk"; })
-  (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; sha256 = "0pnxxmm8whx38dp6yvwgmh22smknxmqs5n513fc7m4wxvs1bvi4p"; })
-  (fetchNuGet { pname = "Semi.Avalonia"; version = "11.0.0"; sha256 = "1js7lk05y171y6hrh39ai6ddqn17x08ri2fdpz9iq0ic8iryrvxi"; })
-  (fetchNuGet { pname = "Serilog"; version = "3.0.1"; sha256 = "1sigmcsy6mvjk2lqlxdxj47f961p1wvc0b8d8nx84hwy7mfikxvi"; })
-  (fetchNuGet { pname = "Serilog.Extensions.Logging"; version = "7.0.0"; sha256 = "0qbdgjfr534jhrl87fjav46pbbrzj3izw3wd6hbz5gi1lrphmzar"; })
-  (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "4.1.0"; sha256 = "1rpkphmqfh3bv3m7v1zwz88wz4sirj4xqyff9ga0c6bqhblj6wii"; })
-  (fetchNuGet { pname = "Serilog.Sinks.Debug"; version = "2.0.0"; sha256 = "1i7j870l47gan3gpnnlzkccn5lbm7518cnkp25a3g5gp9l0dbwpw"; })
-  (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })
-  (fetchNuGet { pname = "SerilogAnalyzer"; version = "0.15.0"; sha256 = "0k83cyzl9520q282vp07zb8rs16a56axv7a31l3m5fb1afq2hv9l"; })
-  (fetchNuGet { pname = "ShimSkiaSharp"; version = "1.0.0.1"; sha256 = "1iza1yvvvz5pfl2vx6fwlb0gj262gwva9fay6pb6kgiv70h7rmcg"; })
-  (fetchNuGet { pname = "SkiaSharp"; version = "2.88.3"; sha256 = "1yq694myq2rhfp2hwwpyzcg1pzpxcp7j72wib8p9pw9dfj7008sv"; })
-  (fetchNuGet { pname = "SkiaSharp.HarfBuzz"; version = "2.88.3"; sha256 = "0axz2zfyg0h3zis7rr86ikrm2jbxxy0gqb3bbawpgynf1k0fsi6a"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.3"; sha256 = "0dajvr60nwvnv7s6kcqgw1w97zxdpz1c5lb7kcq7r0hi0l05ck3q"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.3"; sha256 = "191ajgi6fnfqcvqvkayjsxasiz6l0bv3pps8vv9abbyc4b12qvph"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.3"; sha256 = "1w5njksq3amrrp7fqxw89nv6ar2kgc5yx092i4rxv7hrjbd1aagx"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.3"; sha256 = "03wwfbarsxjnk70qhqyd1dw65098dncqk2m0vksx92j70i7lry6q"; })
-  (fetchNuGet { pname = "Splat"; version = "14.4.1"; sha256 = "03ycyjn2ii44npi015p4rk344xnjgdzz02cf63cmhx2ab8hv6p4b"; })
-  (fetchNuGet { pname = "Splat"; version = "14.6.37"; sha256 = "1rj2ik4b4mxl2w2d8316a2afyfd23p6ysc5vczsis7bhxcjp1x2h"; })
-  (fetchNuGet { pname = "Splat"; version = "14.7.1"; sha256 = "1rs8bmwcvzg4yn05zglgk7vbmyi2flyyhjqn62sx1cjkrd9m0cs7"; })
-  (fetchNuGet { pname = "Splat.Microsoft.Extensions.DependencyInjection"; version = "14.6.37"; sha256 = "1pqb0ij1kmzjx92j5slp579aqshsp499wd8vxbnm58z0ix4a7bn6"; })
-  (fetchNuGet { pname = "Splat.Serilog"; version = "14.7.1"; sha256 = "0xdw92jxarvpan9v8zja2710z2m03yam94qwar8j5axvnqbh8fhj"; })
-  (fetchNuGet { pname = "Svg.Custom"; version = "1.0.0.1"; sha256 = "00ly1pbm8a7s2k71gz7ikw42l25wfgabdx4bqrzdxysgnfaaa43d"; })
-  (fetchNuGet { pname = "Svg.Model"; version = "1.0.0.1"; sha256 = "0kyllnbya6zvhv8rg53b3zdndmdz9hak4k204gjzcnhkqsn8dcy6"; })
-  (fetchNuGet { pname = "Svg.Skia"; version = "1.0.0.1"; sha256 = "1z487pnz12cy6554xl4nifj4y4a2l15yxz5d3rlsc3asb4qs5jvy"; })
-  (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya"; })
-  (fetchNuGet { pname = "System.Buffers"; version = "4.3.0"; sha256 = "0fgns20ispwrfqll4q1zc1waqcmylb3zc50ys9x8zlwxh9pmd9jy"; })
-  (fetchNuGet { pname = "System.Collections"; version = "4.0.11"; sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6"; })
-  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
-  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.3.0"; sha256 = "0wi10md9aq33jrkh2c24wr2n9hrpyamsdhsxdcnf43b7y86kkii8"; })
-  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.6.0"; sha256 = "1pbxzdz3pwqyybzv5ff2b7nrc281bhg7hq34w0fn1w3qfgrbwyw2"; })
-  (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; sha256 = "1kvcllagxz2q92g81zkz81djkn2lid25ayjfgjalncyc68i15p0r"; })
-  (fetchNuGet { pname = "System.Collections.Immutable"; version = "7.0.0"; sha256 = "1n9122cy6v3qhsisc9lzwa1m1j62b8pi2678nsmnlyvfpk0zdagm"; })
-  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p"; })
-  (fetchNuGet { pname = "System.Console"; version = "4.3.0"; sha256 = "1flr7a9x920mr5cjsqmsy9wgnv3lvd0h1g521pdr1lkb2qycy7ay"; })
-  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.0.11"; sha256 = "0gmjghrqmlgzxivd2xl50ncbglb7ljzb66rlx8ws6dv8jm0d5siz"; })
-  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
-  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.3.0"; sha256 = "0z6m3pbiy0qw6rn3n209rrzf9x1k4002zh90vwcrsym09ipm2liq"; })
-  (fetchNuGet { pname = "System.Diagnostics.EventLog"; version = "6.0.0"; sha256 = "08y1x2d5w2hnhkh9r1998pjc7r4qp0rmzax062abha85s11chifd"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.0.1"; sha256 = "19cknvg07yhakcvpxg3cxa0bwadplin6kyxd8mpjjpwnp56nl85x"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "0in3pic3s2ddyibi8cvgl102zmvp9r9mchh82ns9f0ms4basylw1"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4"; })
-  (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; sha256 = "02n8rzm58dac2np8b3xw8ychbvylja4nh6938l5k2fhyn40imlgz"; })
-  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.0.11"; sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9"; })
-  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
-  (fetchNuGet { pname = "System.Globalization"; version = "4.0.11"; sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d"; })
-  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
-  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq"; })
-  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
-  (fetchNuGet { pname = "System.IO.Abstractions"; version = "19.2.29"; sha256 = "1d25i63zg36w1xf7f89036qi3hjb567lc9if1acnvd769ss7qc09"; })
-  (fetchNuGet { pname = "System.IO.Abstractions.TestingHelpers"; version = "19.2.29"; sha256 = "08a1v4a5nmmqk6mbzqd7k41cw0d478na9pf3cnbl8935fqc176ys"; })
-  (fetchNuGet { pname = "System.IO.Compression"; version = "4.3.0"; sha256 = "084zc82yi6yllgda0zkgl2ys48sypiswbiwrv7irb3r0ai1fp4vz"; })
-  (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.3.0"; sha256 = "1yxy5pq4dnsm9hlkg9ysh5f6bf3fahqqb6p8668ndy5c0lk7w2ar"; })
-  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1"; })
-  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw"; })
-  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612"; })
-  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c"; })
-  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.0"; sha256 = "08211lvckdsdbd67xz4f6cyk76cli565j0dby1grlc4k9bhwby65"; })
-  (fetchNuGet { pname = "System.Linq"; version = "4.1.0"; sha256 = "1ppg83svb39hj4hpp5k7kcryzrf3sfnm08vxd5sm2drrijsla2k5"; })
-  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
-  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.1.0"; sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg"; })
-  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
-  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
-  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j"; })
-  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq"; })
-  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii"; })
-  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.3.0"; sha256 = "1ssa65k6chcgi6mfmzrznvqaxk8jp0gvl77xhf1hbzakjnpxspla"; })
-  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })
-  (fetchNuGet { pname = "System.ObjectModel"; version = "4.0.12"; sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj"; })
-  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
-  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx"; })
-  (fetchNuGet { pname = "System.Reactive"; version = "5.0.0"; sha256 = "1lafmpnadhiwxyd543kraxa3jfdpm6ipblxrjlibym9b1ykpr5ik"; })
-  (fetchNuGet { pname = "System.Reactive.Linq"; version = "5.0.0"; sha256 = "07p05v13yixbxhs84231k5l8jw3nji0j3zcqc6nsbcmh54jpjsrb"; })
-  (fetchNuGet { pname = "System.Reflection"; version = "4.1.0"; sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9"; })
-  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.0.1"; sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.0.1"; sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.0.1"; sha256 = "1s4b043zdbx9k39lfhvsk68msv1nxbidhkq6nbm27q7sf8xcsnxr"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
-  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.0.1"; sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn"; })
-  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
-  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; sha256 = "17qsl5nanlqk9iz0l5wijdn6ka632fs1m1fvx18dfgswm258r3ss"; })
-  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.0.1"; sha256 = "1bangaabhsl4k9fg8khn83wm6yial8ik1sza7401621jc6jrym28"; })
-  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
-  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.1.0"; sha256 = "1bjli8a7sc7jlxqgcagl9nh8axzfl11f4ld3rjqsyxc516iijij7"; })
-  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
-  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.0.1"; sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi"; })
-  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "6.0.0"; sha256 = "0qm741kh4rh57wky16sq4m0v05fxmkjjr87krycf5vp9f0zbahbc"; })
-  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.1.0"; sha256 = "0rw4rm4vsm3h3szxp9iijc3ksyviwsv6f63dng3vhqyg4vjdkc2z"; })
-  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.1.0"; sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.3.0"; sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii"; })
-  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.3.0"; sha256 = "19rav39sr5dky7afygh309qamqqmi9kcwvz3i0c5700v0c5cg61z"; })
-  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.1.1"; sha256 = "042rfjixknlr6r10vx2pgf56yming8lkjikamg3g4v29ikk78h7k"; })
-  (fetchNuGet { pname = "System.Security.Claims"; version = "4.3.0"; sha256 = "0jvfn7j22l3mm28qjy3rcw287y9h65ha4m940waaxah07jnbzrhn"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.3.0"; sha256 = "03sq183pfl5kp7gkvq77myv7kbpdnq3y0xj7vi4q1kaw54sny0ml"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.3.0"; sha256 = "1k468aswafdgf56ab6yrn7649kfqx2wm9aslywjam1hdmk5yypmv"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.3.0"; sha256 = "1x5wcrddf2s3hb8j78cry7yalca4lb5vfnkrysagbn6r9x6xvrx1"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.3.0"; sha256 = "1jr6w70igqn07k5zs1ph6xja97hxnb3mqbspdrff6cvssgrixs32"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0givpvvj8yc7gv4lhb6s1prq6p2c4147204a0wib89inqzd87gqc"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.3.0"; sha256 = "0pyzncsv48zwly3lw4f2dayqswcfvdwq2nz0dgwmi7fj3pn64wby"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.3.0"; sha256 = "0valjcz5wksbvijylxijjxb1mp38mdhv03r533vnx1q3ikzdav9h"; })
-  (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf"; })
-  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
-  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })
-  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs"; })
-  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
-  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "7.0.0"; sha256 = "1151hbyrcf8kyg1jz8k9awpbic98lwz9x129rg7zk1wrs6vjlpxl"; })
-  (fetchNuGet { pname = "System.Text.Json"; version = "7.0.0"; sha256 = "0scb0lp7wbgcinaa4kqiqs7b8i5nx4ppfad81138jiwd1sl37pyp"; })
-  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.1.0"; sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7"; })
-  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l"; })
-  (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls"; })
-  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.0.0"; sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
-  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1"; })
-  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.3.0"; sha256 = "1nx773nsx6z5whv8kaa1wjh037id2f1cxhb69pvgv12hd2b6qs56"; })
-  (fetchNuGet { pname = "System.ValueTuple"; version = "4.5.0"; sha256 = "00k8ja51d0f9wrq4vv5z2jhq8hy31kac2rg0rv06prylcybzl8cy"; })
-  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.0.11"; sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5"; })
-  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1"; })
-  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.0.11"; sha256 = "0n4lvpqzy9kc7qy1a4acwwd7b7pnvygv895az5640idl2y9zbz18"; })
-  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.3.0"; sha256 = "08h8fm4l77n0nd4i4fk2386y809bfbwqb7ih9d7564ifcxr5ssxd"; })
-  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions"; version = "19.2.29"; sha256 = "00gf9bw3dbacp1vnyr4m3lj61vnllrxhsiryn91jaylld4yl2r7x"; })
-  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.TestingHelpers"; version = "19.2.29"; sha256 = "1j1728yfj29bc24pc3dz8vnsybs8islgzrkmdyp9p193dmc9ryb5"; })
-  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.Wrappers"; version = "19.2.29"; sha256 = "1ffk5z4wi61711rwng67wviw0g0xyzvmf352i3yyfhm4i4xlsf3z"; })
-  (fetchNuGet { pname = "Tmds.DBus.Protocol"; version = "0.15.0"; sha256 = "0d99kcs7r9cp6gpyc7z230czkkyx4164x86dhy0mca73f2ykc2g2"; })
-  (fetchNuGet { pname = "xunit"; version = "2.4.1"; sha256 = "0xf3kaywpg15flqaqfgywqyychzk15kz0kz34j21rcv78q9ywq20"; })
-  (fetchNuGet { pname = "xunit.abstractions"; version = "2.0.3"; sha256 = "00wl8qksgkxld76fgir3ycc5rjqv1sqds6x8yx40927q5py74gfh"; })
-  (fetchNuGet { pname = "xunit.analyzers"; version = "0.10.0"; sha256 = "15n02q3akyqbvkp8nq75a8rd66d4ax0rx8fhdcn8j78pi235jm7j"; })
-  (fetchNuGet { pname = "xunit.assert"; version = "2.4.1"; sha256 = "1imynzh80wxq2rp9sc4gxs4x1nriil88f72ilhj5q0m44qqmqpc6"; })
-  (fetchNuGet { pname = "xunit.core"; version = "2.4.1"; sha256 = "1nnb3j4kzmycaw1g76ii4rfqkvg6l8gqh18falwp8g28h802019a"; })
-  (fetchNuGet { pname = "xunit.extensibility.core"; version = "2.4.1"; sha256 = "103qsijmnip2pnbhciqyk2jyhdm6snindg5z2s57kqf5pcx9a050"; })
-  (fetchNuGet { pname = "xunit.extensibility.execution"; version = "2.4.1"; sha256 = "1pbilxh1gp2ywm5idfl0klhl4gb16j86ib4x83p8raql1dv88qia"; })
-  (fetchNuGet { pname = "xunit.runner.visualstudio"; version = "2.4.3"; sha256 = "0j1d0rbcm7pp6dypi61sjxp8l22sv261252z55b243l39jgv2rp3"; })
-]

pkgs/tools/inputmethods/ibus/default.nix

···
 
 let
   python3Runtime = python3.withPackages (ps: with ps; [ pygobject3 ]);
-  python3BuildEnv = python3.buildEnv.override {
+  python3BuildEnv = python3.pythonOnBuildForHost.buildEnv.override {
     # ImportError: No module named site
     postBuild = ''
       makeWrapper ${glib.dev}/bin/gdbus-codegen $out/bin/gdbus-codegen --unset PYTHONPATH
···
     # The `AX_PROG_{CC,CXX}_FOR_BUILD` autoconf macros can pick up unwrapped GCC binaries,
     # so we set `{CC,CXX}_FOR_BUILD` to override that behavior.
     # https://github.com/NixOS/nixpkgs/issues/21751
-    "CC_FOR_BUILD=${stdenv.cc}/bin/cc"
-    "CXX_FOR_BUILD=${stdenv.cc}/bin/c++"
+    "CC_FOR_BUILD=${buildPackages.stdenv.cc}/bin/${buildPackages.stdenv.cc.targetPrefix}cc"
+    "CXX_FOR_BUILD=${buildPackages.stdenv.cc}/bin/${buildPackages.stdenv.cc.targetPrefix}c++"
+    "GLIB_COMPILE_RESOURCES=${lib.getDev buildPackages.glib}/bin/glib-compile-resources"
+    "PKG_CONFIG_VAPIGEN_VAPIGEN=${lib.getBin buildPackages.vala}/bin/vapigen"
     "--disable-memconf"
     (lib.enableFeature (dconf != null) "dconf")
     (lib.enableFeature (libnotify != null) "libnotify")
···
     "--enable-install-tests"
     "--with-unicode-emoji-dir=${unicode-emoji}/share/unicode/emoji"
     "--with-emoji-annotation-dir=${cldr-annotations}/share/unicode/cldr/common/annotations"
+    "--with-python=${python3BuildEnv.interpreter}"
     "--with-ucd-dir=${unicode-character-database}/share/unicode"
   ];
 
   makeFlags = [
     "test_execsdir=${placeholder "installedTests"}/libexec/installed-tests/ibus"
     "test_sourcesdir=${placeholder "installedTests"}/share/installed-tests/ibus"
+  ];
+
+
+  depsBuildBuild = [
+    pkg-config
   ];
 
   nativeBuildInputs = [
···
     json-glib
     libnotify
     libdbusmenu-gtk3
+    vala # for share/vala/Makefile.vapigen (PKG_CONFIG_VAPIGEN_VAPIGEN)
   ] ++ lib.optionals withWayland [
     libxkbcommon
     wayland

pkgs/top-level/all-packages.nix

···
 
   ronin = callPackage ../tools/security/ronin { };
 
-  scarab = callPackage ../tools/games/scarab { };
-
   inherit (callPackage ../development/libraries/sdbus-cpp { }) sdbus-cpp sdbus-cpp_2;
 
   sdkmanager = with python3Packages; toPythonApplication sdkmanager;

pkgs/top-level/python-packages.nix

···
 
   rollbar = callPackage ../development/python-modules/rollbar { };
 
+  roma = callPackage ../development/python-modules/roma { };
+
   roman = callPackage ../development/python-modules/roman { };
 
   romy = callPackage ../development/python-modules/romy { };
···
   torchsde = callPackage ../development/python-modules/torchsde { };
 
   torchsummary = callPackage ../development/python-modules/torchsummary { };
+
+  torchtnt = callPackage ../development/python-modules/torchtnt { };
 
   torchvision = callPackage ../development/python-modules/torchvision { };