commit 7f01b5d24b1f4a1eb9c340a17e9564ffaa74c907 · pyrox.dev/nixpkgs

+36

lib/attrsets.nix

···

       738
       738
        
           sets:

     

       739
       739
        
           zipAttrsWith (name: values: values) sets;

     

       740
       740
        
       

     

       741
       741
       +
         /*

     

       742
       742
       +
           Merge a list of attribute sets together using the `//` operator.

     

       743
       743
       +
           In case of duplicate attributes, values from later list elements take precedence over earlier ones.

     

       744
       744
       +
           The result is the same as `foldl mergeAttrs { }`, but the performance is better for large inputs.

     

       745
       745
       +
           For n list elements, each with an attribute set containing m unique attributes, the complexity of this operation is O(nm log n).

     

       746
       746
       +
       

     

       747
       747
       +
           Type:

     

       748
       748
       +
             mergeAttrsList :: [ Attrs ] -> Attrs

     

       749
       749
       +
       

     

       750
       750
       +
           Example:

     

       751
       751
       +
             mergeAttrsList [ { a = 0; b = 1; } { c = 2; d = 3; } ]

     

       752
       752
       +
             => { a = 0; b = 1; c = 2; d = 3; }

     

       753
       753
       +
             mergeAttrsList [ { a = 0; } { a = 1; } ]

     

       754
       754
       +
             => { a = 1; }

     

       755
       755
       +
         */

     

       756
       756
       +
         mergeAttrsList = list:

     

       757
       757
       +
           let

     

       758
       758
       +
             # `binaryMerge start end` merges the elements at indices `index` of `list` such that `start <= index < end`

     

       759
       759
       +
             # Type: Int -> Int -> Attrs

     

       760
       760
       +
             binaryMerge = start: end:

     

       761
       761
       +
               # assert start < end; # Invariant

     

       762
       762
       +
               if end - start >= 2 then

     

       763
       763
       +
                 # If there's at least 2 elements, split the range in two, recurse on each part and merge the result

     

       764
       764
       +
                 # The invariant is satisfied because each half will have at least 1 element

     

       765
       765
       +
                 binaryMerge start (start + (end - start) / 2)

     

       766
       766
       +
                 // binaryMerge (start + (end - start) / 2) end

     

       767
       767
       +
               else

     

       768
       768
       +
                 # Otherwise there will be exactly 1 element due to the invariant, in which case we just return it directly

     

       769
       769
       +
                 elemAt list start;

     

       770
       770
       +
           in

     

       771
       771
       +
           if list == [ ] then

     

       772
       772
       +
             # Calling binaryMerge as below would not satisfy its invariant

     

       773
       773
       +
             { }

     

       774
       774
       +
           else

     

       775
       775
       +
             binaryMerge 0 (length list);

     

       776
       776
       +
       

     

       741
       777
        
       

     

       742
       778
        
         /* Does the same as the update operator '//' except that attributes are

     

       743
       779
        
            merged until the given predicate is verified.  The predicate should

+25

lib/tests/misc.nix

···

       609
       609
        
           };

     

       610
       610
        
         };

     

       611
       611
        
       

     

       612
       612
       +
       

     

       613
       613
       +
         testMergeAttrsListExample1 = {

     

       614
       614
       +
           expr = attrsets.mergeAttrsList [ { a = 0; b = 1; } { c = 2; d = 3; } ];

     

       615
       615
       +
           expected = { a = 0; b = 1; c = 2; d = 3; };

     

       616
       616
       +
         };

     

       617
       617
       +
         testMergeAttrsListExample2 = {

     

       618
       618
       +
           expr = attrsets.mergeAttrsList [ { a = 0; } { a = 1; } ];

     

       619
       619
       +
           expected = { a = 1; };

     

       620
       620
       +
         };

     

       621
       621
       +
         testMergeAttrsListExampleMany =

     

       622
       622
       +
           let

     

       623
       623
       +
             list = genList (n:

     

       624
       624
       +
               listToAttrs (genList (m:

     

       625
       625
       +
                 let

     

       626
       626
       +
                   # Integer divide n by two to create duplicate attributes

     

       627
       627
       +
                   str = "halfn${toString (n / 2)}m${toString m}";

     

       628
       628
       +
                 in

     

       629
       629
       +
                 nameValuePair str str

     

       630
       630
       +
               ) 100)

     

       631
       631
       +
             ) 100;

     

       632
       632
       +
           in {

     

       633
       633
       +
             expr = attrsets.mergeAttrsList list;

     

       634
       634
       +
             expected = foldl' mergeAttrs { } list;

     

       635
       635
       +
           };

     

       636
       636
       +
       

     

       612
       637
        
         # code from the example

     

       613
       638
        
         testRecursiveUpdateUntil = {

     

       614
       639
        
           expr = recursiveUpdateUntil (path: l: r: path == ["foo"]) {

maintainers/maintainer-list.nix

···

       15847
       15847
        
           githubId = 16734772;

     

       15848
       15848
        
           name = "Sumner Evans";

     

       15849
       15849
        
         };

     

       15850
       15850
       +
         sund3RRR = {

     

       15851
       15851
       +
           email = "evenquantity@gmail.com";

     

       15852
       15852
       +
           github = "sund3RRR";

     

       15853
       15853
       +
           githubId = 73298492;

     

       15854
       15854
       +
           name = "Mikhail Kiselev";

     

       15855
       15855
       +
         };

     

       15850
       15856
        
         suominen = {

     

       15851
       15857
        
           email = "kimmo@suominen.com";

     

       15852
       15858
        
           github = "suominen";

maintainers/scripts/luarocks-packages.csv

···

       86
       86
        
       luv,,,,1.44.2-1,,

     

       87
       87
        
       lush.nvim,https://github.com/rktjmp/lush.nvim,,,,,teto

     

       88
       88
        
       lyaml,,,,,,lblasc

     

       89
       89
       +
       magick,,,,,,donovanglover

     

       89
       90
        
       markdown,,,,,,

     

       90
       91
        
       mediator_lua,,,,,,

     

       91
       92
        
       mpack,,,,,,

nixos/doc/manual/default.nix

···

       63
       63
        
             optionIdPrefix = "test-opt-";

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
       +
         testDriverMachineDocstrings = pkgs.callPackage

     

       67
       67
       +
           ../../../nixos/lib/test-driver/nixos-test-driver-docstrings.nix {};

     

       68
       68
       +
       

     

       66
       69
        
         prepareManualFromMD = ''

     

       67
       70
        
           cp -r --no-preserve=all $inputs/* .

     

       68
       71
        
       

     
···

       80
       83
        
             --replace \

     

       81
       84
        
               '@NIXOS_TEST_OPTIONS_JSON@' \

     

       82
       85
        
               ${testOptionsDoc.optionsJSON}/share/doc/nixos/options.json

     

       86
       86
       +
           sed -e '/@PYTHON_MACHINE_METHODS@/ {' -e 'r ${testDriverMachineDocstrings}/machine-methods.md' -e 'd' -e '}' \

     

       87
       87
       +
             -i ./development/writing-nixos-tests.section.md

     

       83
       88
        
         '';

     

       84
       89
        
       

     

       85
       90
        
       in rec {

+1 -204

nixos/doc/manual/development/writing-nixos-tests.section.md

···

       139
       139
        
       

     

       140
       140
        
       The following methods are available on machine objects:

     

       141
       141
        
       

     

       142
       142
       -
       `start`

     

       143
       143
       -
       

     

       144
       144
       -
       :   Start the virtual machine. This method is asynchronous --- it does

     

       145
       145
       -
           not wait for the machine to finish booting.

     

       146
       146
       -
       

     

       147
       147
       -
       `shutdown`

     

       148
       148
       -
       

     

       149
       149
       -
       :   Shut down the machine, waiting for the VM to exit.

     

       150
       150
       -
       

     

       151
       151
       -
       `crash`

     

       152
       152
       -
       

     

       153
       153
       -
       :   Simulate a sudden power failure, by telling the VM to exit

     

       154
       154
       -
           immediately.

     

       155
       155
       -
       

     

       156
       156
       -
       `block`

     

       157
       157
       -
       

     

       158
       158
       -
       :   Simulate unplugging the Ethernet cable that connects the machine to

     

       159
       159
       -
           the other machines.

     

       160
       160
       -
       

     

       161
       161
       -
       `unblock`

     

       162
       162
       -
       

     

       163
       163
       -
       :   Undo the effect of `block`.

     

       164
       164
       -
       

     

       165
       165
       -
       `screenshot`

     

       166
       166
       -
       

     

       167
       167
       -
       :   Take a picture of the display of the virtual machine, in PNG format.

     

       168
       168
       -
           The screenshot is linked from the HTML log.

     

       169
       169
       -
       

     

       170
       170
       -
       `get_screen_text_variants`

     

       171
       171
       -
       

     

       172
       172
       -
       :   Return a list of different interpretations of what is currently

     

       173
       173
       -
           visible on the machine's screen using optical character

     

       174
       174
       -
           recognition. The number and order of the interpretations is not

     

       175
       175
       -
           specified and is subject to change, but if no exception is raised at

     

       176
       176
       -
           least one will be returned.

     

       177
       177
       -
       

     

       178
       178
       -
           ::: {.note}

     

       179
       179
       -
           This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       180
       180
       -
           :::

     

       181
       181
       -
       

     

       182
       182
       -
       `get_screen_text`

     

       183
       183
       -
       

     

       184
       184
       -
       :   Return a textual representation of what is currently visible on the

     

       185
       185
       -
           machine's screen using optical character recognition.

     

       186
       186
       -
       

     

       187
       187
       -
           ::: {.note}

     

       188
       188
       -
           This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       189
       189
       -
           :::

     

       190
       190
       -
       

     

       191
       191
       -
       `send_monitor_command`

     

       192
       192
       -
       

     

       193
       193
       -
       :   Send a command to the QEMU monitor. This is rarely used, but allows

     

       194
       194
       -
           doing stuff such as attaching virtual USB disks to a running

     

       195
       195
       -
           machine.

     

       196
       196
       -
       

     

       197
       197
       -
       `send_key`

     

       198
       198
       -
       

     

       199
       199
       -
       :   Simulate pressing keys on the virtual keyboard, e.g.,

     

       200
       200
       -
           `send_key("ctrl-alt-delete")`.

     

       201
       201
       -
       

     

       202
       202
       -
       `send_chars`

     

       203
       203
       -
       

     

       204
       204
       -
       :   Simulate typing a sequence of characters on the virtual keyboard,

     

       205
       205
       -
           e.g., `send_chars("foobar\n")` will type the string `foobar`

     

       206
       206
       -
           followed by the Enter key.

     

       207
       207
       -
       

     

       208
       208
       -
       `send_console`

     

       209
       209
       -
       

     

       210
       210
       -
       :   Send keys to the kernel console. This allows interaction with the systemd

     

       211
       211
       -
           emergency mode, for example. Takes a string that is sent, e.g.,

     

       212
       212
       -
           `send_console("\n\nsystemctl default\n")`.

     

       213
       213
       -
       

     

       214
       214
       -
       `execute`

     

       215
       215
       -
       

     

       216
       216
       -
       :   Execute a shell command, returning a list `(status, stdout)`.

     

       217
       217
       -
       

     

       218
       218
       -
           Commands are run with `set -euo pipefail` set:

     

       219
       219
       -
       

     

       220
       220
       -
           -   If several commands are separated by `;` and one fails, the

     

       221
       221
       -
               command as a whole will fail.

     

       222
       222
       -
       

     

       223
       223
       -
           -   For pipelines, the last non-zero exit status will be returned

     

       224
       224
       -
               (if there is one; otherwise zero will be returned).

     

       225
       225
       -
       

     

       226
       226
       -
           -   Dereferencing unset variables fails the command.

     

       227
       227
       -
       

     

       228
       228
       -
           -   It will wait for stdout to be closed.

     

       229
       229
       -
       

     

       230
       230
       -
           If the command detaches, it must close stdout, as `execute` will wait

     

       231
       231
       -
           for this to consume all output reliably. This can be achieved by

     

       232
       232
       -
           redirecting stdout to stderr `>&2`, to `/dev/console`, `/dev/null` or

     

       233
       233
       -
           a file. Examples of detaching commands are `sleep 365d &`, where the

     

       234
       234
       -
           shell forks a new process that can write to stdout and `xclip -i`, where

     

       235
       235
       -
           the `xclip` command itself forks without closing stdout.

     

       236
       236
       -
       

     

       237
       237
       -
           Takes an optional parameter `check_return` that defaults to `True`.

     

       238
       238
       -
           Setting this parameter to `False` will not check for the return code

     

       239
       239
       -
           and return -1 instead. This can be used for commands that shut down

     

       240
       240
       -
           the VM and would therefore break the pipe that would be used for

     

       241
       241
       -
           retrieving the return code.

     

       242
       242
       -
       

     

       243
       243
       -
           A timeout for the command can be specified (in seconds) using the optional

     

       244
       244
       -
           `timeout` parameter, e.g., `execute(cmd, timeout=10)` or

     

       245
       245
       -
           `execute(cmd, timeout=None)`. The default is 900 seconds.

     

       246
       246
       -
       

     

       247
       247
       -
       `succeed`

     

       248
       248
       -
       

     

       249
       249
       -
       :   Execute a shell command, raising an exception if the exit status is

     

       250
       250
       -
           not zero, otherwise returning the standard output. Similar to `execute`,

     

       251
       251
       -
           except that the timeout is `None` by default. See `execute` for details on

     

       252
       252
       -
           command execution.

     

       253
       253
       -
       

     

       254
       254
       -
       `fail`

     

       255
       255
       -
       

     

       256
       256
       -
       :   Like `succeed`, but raising an exception if the command returns a zero

     

       257
       257
       -
           status.

     

       258
       258
       -
       

     

       259
       259
       -
       `wait_until_succeeds`

     

       260
       260
       -
       

     

       261
       261
       -
       :   Repeat a shell command with 1-second intervals until it succeeds.

     

       262
       262
       -
           Has a default timeout of 900 seconds which can be modified, e.g.

     

       263
       263
       -
           `wait_until_succeeds(cmd, timeout=10)`. See `execute` for details on

     

       264
       264
       -
           command execution.

     

       265
       265
       -
       

     

       266
       266
       -
       `wait_until_fails`

     

       267
       267
       -
       

     

       268
       268
       -
       :   Like `wait_until_succeeds`, but repeating the command until it fails.

     

       269
       269
       -
       

     

       270
       270
       -
       `wait_for_unit`

     

       271
       271
       -
       

     

       272
       272
       -
       :   Wait until the specified systemd unit has reached the "active"

     

       273
       273
       -
           state.

     

       274
       274
       -
       

     

       275
       275
       -
       `wait_for_file`

     

       276
       276
       -
       

     

       277
       277
       -
       :   Wait until the specified file exists.

     

       278
       278
       -
       

     

       279
       279
       -
       `wait_for_open_port`

     

       280
       280
       -
       

     

       281
       281
       -
       :   Wait until a process is listening on the given TCP port and IP address

     

       282
       282
       -
           (default `localhost`).

     

       283
       283
       -
       

     

       284
       284
       -
       `wait_for_closed_port`

     

       285
       285
       -
       

     

       286
       286
       -
       :   Wait until nobody is listening on the given TCP port and IP address

     

       287
       287
       -
           (default `localhost`).

     

       288
       288
       -
       

     

       289
       289
       -
       `wait_for_x`

     

       290
       290
       -
       

     

       291
       291
       -
       :   Wait until the X11 server is accepting connections.

     

       292
       292
       -
       

     

       293
       293
       -
       `wait_for_text`

     

       294
       294
       -
       

     

       295
       295
       -
       :   Wait until the supplied regular expressions matches the textual

     

       296
       296
       -
           contents of the screen by using optical character recognition (see

     

       297
       297
       -
           `get_screen_text` and `get_screen_text_variants`).

     

       298
       298
       -
       

     

       299
       299
       -
           ::: {.note}

     

       300
       300
       -
           This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       301
       301
       -
           :::

     

       302
       302
       -
       

     

       303
       303
       -
       `wait_for_console_text`

     

       304
       304
       -
       

     

       305
       305
       -
       :   Wait until the supplied regular expressions match a line of the

     

       306
       306
       -
           serial console output. This method is useful when OCR is not

     

       307
       307
       -
           possible or accurate enough.

     

       308
       308
       -
       

     

       309
       309
       -
       `wait_for_window`

     

       310
       310
       -
       

     

       311
       311
       -
       :   Wait until an X11 window has appeared whose name matches the given

     

       312
       312
       -
           regular expression, e.g., `wait_for_window("Terminal")`.

     

       313
       313
       -
       

     

       314
       314
       -
       `copy_from_host`

     

       315
       315
       -
       

     

       316
       316
       -
       :   Copies a file from host to machine, e.g.,

     

       317
       317
       -
           `copy_from_host("myfile", "/etc/my/important/file")`.

     

       318
       318
       -
       

     

       319
       319
       -
           The first argument is the file on the host. The file needs to be

     

       320
       320
       -
           accessible while building the nix derivation. The second argument is

     

       321
       321
       -
           the location of the file on the machine.

     

       322
       322
       -
       

     

       323
       323
       -
       `systemctl`

     

       324
       324
       -
       

     

       325
       325
       -
       :   Runs `systemctl` commands with optional support for

     

       326
       326
       -
           `systemctl --user`

     

       327
       327
       -
       

     

       328
       328
       -
           ```py

     

       329
       329
       -
           machine.systemctl("list-jobs --no-pager") # runs `systemctl list-jobs --no-pager`

     

       330
       330
       -
           machine.systemctl("list-jobs --no-pager", "any-user") # spawns a shell for `any-user` and runs `systemctl --user list-jobs --no-pager`

     

       331
       331
       -
           ```

     

       332
       332
       -
       

     

       333
       333
       -
       `shell_interact`

     

       334
       334
       -
       

     

       335
       335
       -
       :   Allows you to directly interact with the guest shell. This should

     

       336
       336
       -
           only be used during test development, not in production tests.

     

       337
       337
       -
           Killing the interactive session with `Ctrl-d` or `Ctrl-c` also ends

     

       338
       338
       -
           the guest session.

     

       339
       339
       -
       

     

       340
       340
       -
       `console_interact`

     

       341
       341
       -
       

     

       342
       342
       -
       :   Allows you to directly interact with QEMU's stdin. This should

     

       343
       343
       -
           only be used during test development, not in production tests.

     

       344
       344
       -
           Output from QEMU is only read line-wise. `Ctrl-c` kills QEMU and

     

       345
       345
       -
           `Ctrl-d` closes console and returns to the test runner.

     

       142
       142
       +
       @PYTHON_MACHINE_METHODS@

     

       346
       143
        
       

     

       347
       144
        
       To test user units declared by `systemd.user.services` the optional

     

       348
       145
        
       `user` argument can be used:

+66

nixos/lib/test-driver/extract-docstrings.py

···

       1
       1
       +
       import ast

     

       2
       2
       +
       import sys

     

       3
       3
       +
       

     

       4
       4
       +
       """

     

       5
       5
       +
       This program takes all the Machine class methods and prints its methods in

     

       6
       6
       +
       markdown-style. These can then be included in the NixOS test driver

     

       7
       7
       +
       markdown style, assuming the docstrings themselves are also in markdown.

     

       8
       8
       +
       

     

       9
       9
       +
       These are included in the test driver documentation in the NixOS manual.

     

       10
       10
       +
       See https://nixos.org/manual/nixos/stable/#ssec-machine-objects

     

       11
       11
       +
       

     

       12
       12
       +
       The python input looks like this:

     

       13
       13
       +
       

     

       14
       14
       +
       ```py

     

       15
       15
       +
       ...

     

       16
       16
       +
       

     

       17
       17
       +
       class Machine(...):

     

       18
       18
       +
           ...

     

       19
       19
       +
       

     

       20
       20
       +
           def some_function(self, param1, param2):

     

       21
       21
       +
               ""

     

       22
       22
       +
               documentation string of some_function.

     

       23
       23
       +
               foo bar baz.

     

       24
       24
       +
               ""

     

       25
       25
       +
               ...

     

       26
       26
       +
       ```

     

       27
       27
       +
       

     

       28
       28
       +
       Output will be:

     

       29
       29
       +
       

     

       30
       30
       +
       ```markdown

     

       31
       31
       +
       ...

     

       32
       32
       +
       

     

       33
       33
       +
       some_function(param1, param2)

     

       34
       34
       +
       

     

       35
       35
       +
       :   documentation string of some_function.

     

       36
       36
       +
           foo bar baz.

     

       37
       37
       +
       

     

       38
       38
       +
       ...

     

       39
       39
       +
       ```

     

       40
       40
       +
       

     

       41
       41
       +
       """

     

       42
       42
       +
       

     

       43
       43
       +
       assert len(sys.argv) == 2

     

       44
       44
       +
       

     

       45
       45
       +
       with open(sys.argv[1], "r") as f:

     

       46
       46
       +
           module = ast.parse(f.read())

     

       47
       47
       +
       

     

       48
       48
       +
       class_definitions = (node for node in module.body if isinstance(node, ast.ClassDef))

     

       49
       49
       +
       

     

       50
       50
       +
       machine_class = next(filter(lambda x: x.name == "Machine", class_definitions))

     

       51
       51
       +
       assert machine_class is not None

     

       52
       52
       +
       

     

       53
       53
       +
       function_definitions = [

     

       54
       54
       +
           node for node in machine_class.body if isinstance(node, ast.FunctionDef)

     

       55
       55
       +
       ]

     

       56
       56
       +
       function_definitions.sort(key=lambda x: x.name)

     

       57
       57
       +
       

     

       58
       58
       +
       for f in function_definitions:

     

       59
       59
       +
           docstr = ast.get_docstring(f)

     

       60
       60
       +
           if docstr is not None:

     

       61
       61
       +
               args = ", ".join((a.arg for a in f.args.args[1:]))

     

       62
       62
       +
               args = f"({args})"

     

       63
       63
       +
       

     

       64
       64
       +
               docstr = "\n".join((f"    {l}" for l in docstr.strip().splitlines()))

     

       65
       65
       +
       

     

       66
       66
       +
               print(f"{f.name}{args}\n\n:{docstr[1:]}\n")

+13

nixos/lib/test-driver/nixos-test-driver-docstrings.nix

···

       1
       1
       +
       { runCommand

     

       2
       2
       +
       , python3

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         env = { nativeBuildInputs = [ python3 ]; };

     

       7
       7
       +
       in

     

       8
       8
       +
       

     

       9
       9
       +
       runCommand "nixos-test-driver-docstrings" env ''

     

       10
       10
       +
         mkdir $out

     

       11
       11
       +
         python3 ${./extract-docstrings.py} ${./test_driver/machine.py} \

     

       12
       12
       +
           > $out/machine-methods.md

     

       13
       13
       +
       ''

+191 -34

nixos/lib/test-driver/test_driver/machine.py

···

       416
       416
        
               return answer

     

       417
       417
        
       

     

       418
       418
        
           def send_monitor_command(self, command: str) -> str:

     

       419
       419
       +
               """

     

       420
       420
       +
               Send a command to the QEMU monitor. This allows attaching

     

       421
       421
       +
               virtual USB disks to a running machine, among other things.

     

       422
       422
       +
               """

     

       419
       423
        
               self.run_callbacks()

     

       420
       424
        
               message = f"{command}\n".encode()

     

       421
       425
        
               assert self.monitor is not None

     
···

       425
       429
        
           def wait_for_unit(

     

       426
       430
        
               self, unit: str, user: Optional[str] = None, timeout: int = 900

     

       427
       431
        
           ) -> None:

     

       428
       428
       -
               """Wait for a systemd unit to get into "active" state.

     

       429
       429
       -
               Throws exceptions on "failed" and "inactive" states as well as

     

       430
       430
       -
               after timing out.

     

       432
       432
       +
               """

     

       433
       433
       +
               Wait for a systemd unit to get into "active" state.

     

       434
       434
       +
               Throws exceptions on "failed" and "inactive" states as well as after

     

       435
       435
       +
               timing out.

     

       431
       436
        
               """

     

       432
       437
        
       

     

       433
       438
        
               def check_active(_: Any) -> bool:

     
···

       476
       481
        
               )

     

       477
       482
        
       

     

       478
       483
        
           def systemctl(self, q: str, user: Optional[str] = None) -> Tuple[int, str]:

     

       484
       484
       +
               """

     

       485
       485
       +
               Runs `systemctl` commands with optional support for

     

       486
       486
       +
               `systemctl --user`

     

       487
       487
       +
       

     

       488
       488
       +
               ```py

     

       489
       489
       +
               # run `systemctl list-jobs --no-pager`

     

       490
       490
       +
               machine.systemctl("list-jobs --no-pager")

     

       491
       491
       +
       

     

       492
       492
       +
               # spawn a shell for `any-user` and run

     

       493
       493
       +
               # `systemctl --user list-jobs --no-pager`

     

       494
       494
       +
               machine.systemctl("list-jobs --no-pager", "any-user")

     

       495
       495
       +
               ```

     

       496
       496
       +
               """

     

       479
       497
        
               if user is not None:

     

       480
       498
        
                   q = q.replace("'", "\\'")

     

       481
       499
        
                   return self.execute(

     
···

       520
       538
        
               check_output: bool = True,

     

       521
       539
        
               timeout: Optional[int] = 900,

     

       522
       540
        
           ) -> Tuple[int, str]:

     

       541
       541
       +
               """

     

       542
       542
       +
               Execute a shell command, returning a list `(status, stdout)`.

     

       543
       543
       +
       

     

       544
       544
       +
               Commands are run with `set -euo pipefail` set:

     

       545
       545
       +
       

     

       546
       546
       +
               -   If several commands are separated by `;` and one fails, the

     

       547
       547
       +
                   command as a whole will fail.

     

       548
       548
       +
       

     

       549
       549
       +
               -   For pipelines, the last non-zero exit status will be returned

     

       550
       550
       +
                   (if there is one; otherwise zero will be returned).

     

       551
       551
       +
       

     

       552
       552
       +
               -   Dereferencing unset variables fails the command.

     

       553
       553
       +
       

     

       554
       554
       +
               -   It will wait for stdout to be closed.

     

       555
       555
       +
       

     

       556
       556
       +
               If the command detaches, it must close stdout, as `execute` will wait

     

       557
       557
       +
               for this to consume all output reliably. This can be achieved by

     

       558
       558
       +
               redirecting stdout to stderr `>&2`, to `/dev/console`, `/dev/null` or

     

       559
       559
       +
               a file. Examples of detaching commands are `sleep 365d &`, where the

     

       560
       560
       +
               shell forks a new process that can write to stdout and `xclip -i`, where

     

       561
       561
       +
               the `xclip` command itself forks without closing stdout.

     

       562
       562
       +
       

     

       563
       563
       +
               Takes an optional parameter `check_return` that defaults to `True`.

     

       564
       564
       +
               Setting this parameter to `False` will not check for the return code

     

       565
       565
       +
               and return -1 instead. This can be used for commands that shut down

     

       566
       566
       +
               the VM and would therefore break the pipe that would be used for

     

       567
       567
       +
               retrieving the return code.

     

       568
       568
       +
       

     

       569
       569
       +
               A timeout for the command can be specified (in seconds) using the optional

     

       570
       570
       +
               `timeout` parameter, e.g., `execute(cmd, timeout=10)` or

     

       571
       571
       +
               `execute(cmd, timeout=None)`. The default is 900 seconds.

     

       572
       572
       +
               """

     

       523
       573
        
               self.run_callbacks()

     

       524
       574
        
               self.connect()

     

       525
       575
        
       

     
···

       555
       605
        
               return (rc, output.decode(errors="replace"))

     

       556
       606
        
       

     

       557
       607
        
           def shell_interact(self, address: Optional[str] = None) -> None:

     

       558
       558
       -
               """Allows you to interact with the guest shell for debugging purposes.

     

       559
       559
       -
       

     

       560
       560
       -
               @address string passed to socat that will be connected to the guest shell.

     

       561
       561
       -
               Check the `Running Tests interactivly` chapter of NixOS manual for an example.

     

       608
       608
       +
               """

     

       609
       609
       +
               Allows you to directly interact with the guest shell. This should

     

       610
       610
       +
               only be used during test development, not in production tests.

     

       611
       611
       +
               Killing the interactive session with `Ctrl-d` or `Ctrl-c` also ends

     

       612
       612
       +
               the guest session.

     

       562
       613
        
               """

     

       563
       614
        
               self.connect()

     

       564
       615
        
       

     
···

       577
       628
        
                   pass

     

       578
       629
        
       

     

       579
       630
        
           def console_interact(self) -> None:

     

       580
       580
       -
               """Allows you to interact with QEMU's stdin

     

       581
       581
       -
       

     

       582
       582
       -
               The shell can be exited with Ctrl+D. Note that Ctrl+C is not allowed to be used.

     

       583
       583
       -
               QEMU's stdout is read line-wise.

     

       584
       584
       -
       

     

       585
       585
       -
               Should only be used during test development, not in the production test."""

     

       631
       631
       +
               """

     

       632
       632
       +
               Allows you to directly interact with QEMU's stdin, by forwarding

     

       633
       633
       +
               terminal input to the QEMU process.

     

       634
       634
       +
               This is for use with the interactive test driver, not for production

     

       635
       635
       +
               tests, which run unattended.

     

       636
       636
       +
               Output from QEMU is only read line-wise. `Ctrl-c` kills QEMU and

     

       637
       637
       +
               `Ctrl-d` closes console and returns to the test runner.

     

       638
       638
       +
               """

     

       586
       639
        
               self.log("Terminal is ready (there is no prompt):")

     

       587
       640
        
       

     

       588
       641
        
               assert self.process

     
···

       599
       652
        
                   self.send_console(char.decode())

     

       600
       653
        
       

     

       601
       654
        
           def succeed(self, *commands: str, timeout: Optional[int] = None) -> str:

     

       602
       602
       -
               """Execute each command and check that it succeeds."""

     

       655
       655
       +
               """

     

       656
       656
       +
               Execute a shell command, raising an exception if the exit status is

     

       657
       657
       +
               not zero, otherwise returning the standard output. Similar to `execute`,

     

       658
       658
       +
               except that the timeout is `None` by default. See `execute` for details on

     

       659
       659
       +
               command execution.

     

       660
       660
       +
               """

     

       603
       661
        
               output = ""

     

       604
       662
        
               for command in commands:

     

       605
       663
        
                   with self.nested(f"must succeed: {command}"):

     
···

       611
       669
        
               return output

     

       612
       670
        
       

     

       613
       671
        
           def fail(self, *commands: str, timeout: Optional[int] = None) -> str:

     

       614
       614
       -
               """Execute each command and check that it fails."""

     

       672
       672
       +
               """

     

       673
       673
       +
               Like `succeed`, but raising an exception if the command returns a zero

     

       674
       674
       +
               status.

     

       675
       675
       +
               """

     

       615
       676
        
               output = ""

     

       616
       677
        
               for command in commands:

     

       617
       678
        
                   with self.nested(f"must fail: {command}"):

     
···

       622
       683
        
               return output

     

       623
       684
        
       

     

       624
       685
        
           def wait_until_succeeds(self, command: str, timeout: int = 900) -> str:

     

       625
       625
       -
               """Wait until a command returns success and return its output.

     

       686
       686
       +
               """

     

       687
       687
       +
               Repeat a shell command with 1-second intervals until it succeeds.

     

       688
       688
       +
               Has a default timeout of 900 seconds which can be modified, e.g.

     

       689
       689
       +
               `wait_until_succeeds(cmd, timeout=10)`. See `execute` for details on

     

       690
       690
       +
               command execution.

     

       626
       691
        
               Throws an exception on timeout.

     

       627
       692
        
               """

     

       628
       693
        
               output = ""

     
···

       637
       702
        
                   return output

     

       638
       703
        
       

     

       639
       704
        
           def wait_until_fails(self, command: str, timeout: int = 900) -> str:

     

       640
       640
       -
               """Wait until a command returns failure.

     

       641
       641
       -
               Throws an exception on timeout.

     

       705
       705
       +
               """

     

       706
       706
       +
               Like `wait_until_succeeds`, but repeating the command until it fails.

     

       642
       707
        
               """

     

       643
       708
        
               output = ""

     

       644
       709
        
       

     
···

       690
       755
        
                   retry(tty_matches)

     

       691
       756
        
       

     

       692
       757
        
           def send_chars(self, chars: str, delay: Optional[float] = 0.01) -> None:

     

       758
       758
       +
               """

     

       759
       759
       +
               Simulate typing a sequence of characters on the virtual keyboard,

     

       760
       760
       +
               e.g., `send_chars("foobar\n")` will type the string `foobar`

     

       761
       761
       +
               followed by the Enter key.

     

       762
       762
       +
               """

     

       693
       763
        
               with self.nested(f"sending keys {repr(chars)}"):

     

       694
       764
        
                   for char in chars:

     

       695
       765
        
                       self.send_key(char, delay, log=False)

     

       696
       766
        
       

     

       697
       767
        
           def wait_for_file(self, filename: str) -> None:

     

       698
       698
       -
               """Waits until the file exists in machine's file system."""

     

       768
       768
       +
               """

     

       769
       769
       +
               Waits until the file exists in the machine's file system.

     

       770
       770
       +
               """

     

       699
       771
        
       

     

       700
       772
        
               def check_file(_: Any) -> bool:

     

       701
       773
        
                   status, _ = self.execute(f"test -e {filename}")

     
···

       705
       777
        
                   retry(check_file)

     

       706
       778
        
       

     

       707
       779
        
           def wait_for_open_port(self, port: int, addr: str = "localhost") -> None:

     

       780
       780
       +
               """

     

       781
       781
       +
               Wait until a process is listening on the given TCP port and IP address

     

       782
       782
       +
               (default `localhost`).

     

       783
       783
       +
               """

     

       784
       784
       +
       

     

       708
       785
        
               def port_is_open(_: Any) -> bool:

     

       709
       786
        
                   status, _ = self.execute(f"nc -z {addr} {port}")

     

       710
       787
        
                   return status == 0

     
···

       713
       790
        
                   retry(port_is_open)

     

       714
       791
        
       

     

       715
       792
        
           def wait_for_closed_port(self, port: int, addr: str = "localhost") -> None:

     

       793
       793
       +
               """

     

       794
       794
       +
               Wait until nobody is listening on the given TCP port and IP address

     

       795
       795
       +
               (default `localhost`).

     

       796
       796
       +
               """

     

       797
       797
       +
       

     

       716
       798
        
               def port_is_closed(_: Any) -> bool:

     

       717
       799
        
                   status, _ = self.execute(f"nc -z {addr} {port}")

     

       718
       800
        
                   return status != 0

     
···

       766
       848
        
                   self.connected = True

     

       767
       849
        
       

     

       768
       850
        
           def screenshot(self, filename: str) -> None:

     

       851
       851
       +
               """

     

       852
       852
       +
               Take a picture of the display of the virtual machine, in PNG format.

     

       853
       853
       +
               The screenshot will be available in the derivation output.

     

       854
       854
       +
               """

     

       769
       855
        
               if "." not in filename:

     

       770
       856
        
                   filename += ".png"

     

       771
       857
        
               if "/" not in filename:

     
···

       795
       881
        
                   )

     

       796
       882
        
       

     

       797
       883
        
           def copy_from_host(self, source: str, target: str) -> None:

     

       798
       798
       -
               """Copy a file from the host into the guest via the `shared_dir` shared

     

       799
       799
       -
               among all the VMs (using a temporary directory).

     

       884
       884
       +
               """

     

       885
       885
       +
               Copies a file from host to machine, e.g.,

     

       886
       886
       +
               `copy_from_host("myfile", "/etc/my/important/file")`.

     

       887
       887
       +
       

     

       888
       888
       +
               The first argument is the file on the host. Note that the "host" refers

     

       889
       889
       +
               to the environment in which the test driver runs, which is typically the

     

       890
       890
       +
               Nix build sandbox.

     

       891
       891
       +
       

     

       892
       892
       +
               The second argument is the location of the file on the machine that will

     

       893
       893
       +
               be written to.

     

       894
       894
       +
       

     

       895
       895
       +
               The file is copied via the `shared_dir` directory which is shared among

     

       896
       896
       +
               all the VMs (using a temporary directory).

     

       897
       897
       +
               The access rights bits will mimic the ones from the host file and

     

       898
       898
       +
               user:group will be root:root.

     

       800
       899
        
               """

     

       801
       900
        
               host_src = Path(source)

     

       802
       901
        
               vm_target = Path(target)

     
···

       848
       947
        
                   return _perform_ocr_on_screenshot(screenshot_path, model_ids)

     

       849
       948
        
       

     

       850
       949
        
           def get_screen_text_variants(self) -> List[str]:

     

       950
       950
       +
               """

     

       951
       951
       +
               Return a list of different interpretations of what is currently

     

       952
       952
       +
               visible on the machine's screen using optical character

     

       953
       953
       +
               recognition. The number and order of the interpretations is not

     

       954
       954
       +
               specified and is subject to change, but if no exception is raised at

     

       955
       955
       +
               least one will be returned.

     

       956
       956
       +
       

     

       957
       957
       +
               ::: {.note}

     

       958
       958
       +
               This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       959
       959
       +
               :::

     

       960
       960
       +
               """

     

       851
       961
        
               return self._get_screen_text_variants([0, 1, 2])

     

       852
       962
        
       

     

       853
       963
        
           def get_screen_text(self) -> str:

     

       964
       964
       +
               """

     

       965
       965
       +
               Return a textual representation of what is currently visible on the

     

       966
       966
       +
               machine's screen using optical character recognition.

     

       967
       967
       +
       

     

       968
       968
       +
               ::: {.note}

     

       969
       969
       +
               This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       970
       970
       +
               :::

     

       971
       971
       +
               """

     

       854
       972
        
               return self._get_screen_text_variants([2])[0]

     

       855
       973
        
       

     

       856
       974
        
           def wait_for_text(self, regex: str) -> None:

     

       975
       975
       +
               """

     

       976
       976
       +
               Wait until the supplied regular expressions matches the textual

     

       977
       977
       +
               contents of the screen by using optical character recognition (see

     

       978
       978
       +
               `get_screen_text` and `get_screen_text_variants`).

     

       979
       979
       +
       

     

       980
       980
       +
               ::: {.note}

     

       981
       981
       +
               This requires [`enableOCR`](#test-opt-enableOCR) to be set to `true`.

     

       982
       982
       +
               :::

     

       983
       983
       +
               """

     

       984
       984
       +
       

     

       857
       985
        
               def screen_matches(last: bool) -> bool:

     

       858
       986
        
                   variants = self.get_screen_text_variants()

     

       859
       987
        
                   for text in variants:

     
···

       870
       998
        
       

     

       871
       999
        
           def wait_for_console_text(self, regex: str, timeout: int | None = None) -> None:

     

       872
       1000
        
               """

     

       873
       873
       -
               Wait for the provided regex to appear on console.

     

       874
       874
       -
               For each reads,

     

       875
       875
       -
       

     

       876
       876
       -
               If timeout is None, timeout is infinite.

     

       877
       877
       -
       

     

       878
       878
       -
               `timeout` is in seconds.

     

       1001
       1001
       +
               Wait until the supplied regular expressions match a line of the

     

       1002
       1002
       +
               serial console output.

     

       1003
       1003
       +
               This method is useful when OCR is not possible or inaccurate.

     

       879
       1004
        
               """

     

       880
       1005
        
               # Buffer the console output, this is needed

     

       881
       1006
        
               # to match multiline regexes.

     
···

       903
       1028
        
           def send_key(

     

       904
       1029
        
               self, key: str, delay: Optional[float] = 0.01, log: Optional[bool] = True

     

       905
       1030
        
           ) -> None:

     

       1031
       1031
       +
               """

     

       1032
       1032
       +
               Simulate pressing keys on the virtual keyboard, e.g.,

     

       1033
       1033
       +
               `send_key("ctrl-alt-delete")`.

     

       1034
       1034
       +
       

     

       1035
       1035
       +
               Please also refer to the QEMU documentation for more information on the

     

       1036
       1036
       +
               input syntax: https://en.wikibooks.org/wiki/QEMU/Monitor#sendkey_keys

     

       1037
       1037
       +
               """

     

       906
       1038
        
               key = CHAR_TO_KEY.get(key, key)

     

       907
       1039
        
               context = self.nested(f"sending key {repr(key)}") if log else nullcontext()

     

       908
       1040
        
               with context:

     
···

       911
       1043
        
                       time.sleep(delay)

     

       912
       1044
        
       

     

       913
       1045
        
           def send_console(self, chars: str) -> None:

     

       1046
       1046
       +
               r"""

     

       1047
       1047
       +
               Send keys to the kernel console. This allows interaction with the systemd

     

       1048
       1048
       +
               emergency mode, for example. Takes a string that is sent, e.g.,

     

       1049
       1049
       +
               `send_console("\n\nsystemctl default\n")`.

     

       1050
       1050
       +
               """

     

       914
       1051
        
               assert self.process

     

       915
       1052
        
               assert self.process.stdin

     

       916
       1053
        
               self.process.stdin.write(chars.encode())

     

       917
       1054
        
               self.process.stdin.flush()

     

       918
       1055
        
       

     

       919
       1056
        
           def start(self, allow_reboot: bool = False) -> None:

     

       1057
       1057
       +
               """

     

       1058
       1058
       +
               Start the virtual machine. This method is asynchronous --- it does

     

       1059
       1059
       +
               not wait for the machine to finish booting.

     

       1060
       1060
       +
               """

     

       920
       1061
        
               if self.booted:

     

       921
       1062
        
                   return

     

       922
       1063
        
       

     
···

       974
       1115
        
               rootlog.log("if you want to keep the VM state, pass --keep-vm-state")

     

       975
       1116
        
       

     

       976
       1117
        
           def shutdown(self) -> None:

     

       1118
       1118
       +
               """

     

       1119
       1119
       +
               Shut down the machine, waiting for the VM to exit.

     

       1120
       1120
       +
               """

     

       977
       1121
        
               if not self.booted:

     

       978
       1122
        
                   return

     

       979
       1123
        
       

     
···

       982
       1126
        
               self.wait_for_shutdown()

     

       983
       1127
        
       

     

       984
       1128
        
           def crash(self) -> None:

     

       1129
       1129
       +
               """

     

       1130
       1130
       +
               Simulate a sudden power failure, by telling the VM to exit immediately.

     

       1131
       1131
       +
               """

     

       985
       1132
        
               if not self.booted:

     

       986
       1133
        
                   return

     

       987
       1134
        
       

     
···

       999
       1146
        
               self.connected = False

     

       1000
       1147
        
       

     

       1001
       1148
        
           def wait_for_x(self) -> None:

     

       1002
       1002
       -
               """Wait until it is possible to connect to the X server.  Note that

     

       1003
       1003
       -
               testing the existence of /tmp/.X11-unix/X0 is insufficient.

     

       1149
       1149
       +
               """

     

       1150
       1150
       +
               Wait until it is possible to connect to the X server.

     

       1004
       1151
        
               """

     

       1005
       1152
        
       

     

       1006
       1153
        
               def check_x(_: Any) -> bool:

     
···

       1023
       1170
        
               ).splitlines()

     

       1024
       1171
        
       

     

       1025
       1172
        
           def wait_for_window(self, regexp: str) -> None:

     

       1173
       1173
       +
               """

     

       1174
       1174
       +
               Wait until an X11 window has appeared whose name matches the given

     

       1175
       1175
       +
               regular expression, e.g., `wait_for_window("Terminal")`.

     

       1176
       1176
       +
               """

     

       1026
       1177
        
               pattern = re.compile(regexp)

     

       1027
       1178
        
       

     

       1028
       1179
        
               def window_is_visible(last_try: bool) -> bool:

     
···

       1043
       1194
        
               self.succeed(f"sleep {secs}")

     

       1044
       1195
        
       

     

       1045
       1196
        
           def forward_port(self, host_port: int = 8080, guest_port: int = 80) -> None:

     

       1046
       1046
       -
               """Forward a TCP port on the host to a TCP port on the guest.

     

       1197
       1197
       +
               """

     

       1198
       1198
       +
               Forward a TCP port on the host to a TCP port on the guest.

     

       1047
       1199
        
               Useful during interactive testing.

     

       1048
       1200
        
               """

     

       1049
       1201
        
               self.send_monitor_command(f"hostfwd_add tcp::{host_port}-:{guest_port}")

     

       1050
       1202
        
       

     

       1051
       1203
        
           def block(self) -> None:

     

       1052
       1052
       -
               """Make the machine unreachable by shutting down eth1 (the multicast

     

       1053
       1053
       -
               interface used to talk to the other VMs).  We keep eth0 up so that

     

       1054
       1054
       -
               the test driver can continue to talk to the machine.

     

       1204
       1204
       +
               """

     

       1205
       1205
       +
               Simulate unplugging the Ethernet cable that connects the machine to

     

       1206
       1206
       +
               the other machines.

     

       1207
       1207
       +
               This happens by shutting down eth1 (the multicast interface used to talk

     

       1208
       1208
       +
               to the other VMs). eth0 is kept online to still enable the test driver

     

       1209
       1209
       +
               to communicate with the machine.

     

       1055
       1210
        
               """

     

       1056
       1211
        
               self.send_monitor_command("set_link virtio-net-pci.1 off")

     

       1057
       1212
        
       

     

       1058
       1213
        
           def unblock(self) -> None:

     

       1059
       1059
       -
               """Make the machine reachable."""

     

       1214
       1214
       +
               """

     

       1215
       1215
       +
               Undo the effect of `block`.

     

       1216
       1216
       +
               """

     

       1060
       1217
        
               self.send_monitor_command("set_link virtio-net-pci.1 on")

     

       1061
       1218
        
       

     

       1062
       1219
        
           def release(self) -> None:

+5 -1

nixos/lib/testing/driver.nix

···

       65
       65
        
                 echo "${builtins.toString vlanNames}" >> testScriptWithTypes

     

       66
       66
        
                 echo -n "$testScript" >> testScriptWithTypes

     

       67
       67
        
       

     

       68
       68
       -
                 cat -n testScriptWithTypes

     

       68
       68
       +
                 echo "Running type check (enable/disable: config.skipTypeCheck)"

     

       69
       69
       +
                 echo "See https://nixos.org/manual/nixos/stable/#test-opt-skipTypeCheck"

     

       69
       70
        
       

     

       70
       71
        
                 mypy  --no-implicit-optional \

     

       71
       72
        
                       --pretty \

     
···

       79
       80
        
       

     

       80
       81
        
               ${testDriver}/bin/generate-driver-symbols

     

       81
       82
        
               ${lib.optionalString (!config.skipLint) ''

     

       83
       83
       +
                 echo "Linting test script (enable/disable: config.skipLint)"

     

       84
       84
       +
                 echo "See https://nixos.org/manual/nixos/stable/#test-opt-skipLint"

     

       85
       85
       +
       

     

       82
       86
        
                 PYFLAKES_BUILTINS="$(

     

       83
       87
        
                   echo -n ${lib.escapeShellArg (lib.concatStringsSep "," pythonizedNames)},

     

       84
       88
        
                   < ${lib.escapeShellArg "driver-symbols"}

+126

pkgs/applications/audio/bitwig-studio/bitwig-studio5.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , fetchurl

     

       3
       3
       +
       , alsa-lib

     

       4
       4
       +
       , atk

     

       5
       5
       +
       , cairo

     

       6
       6
       +
       , dpkg

     

       7
       7
       +
       , ffmpeg

     

       8
       8
       +
       , freetype

     

       9
       9
       +
       , gdk-pixbuf

     

       10
       10
       +
       , glib

     

       11
       11
       +
       , gtk3

     

       12
       12
       +
       , harfbuzz

     

       13
       13
       +
       , lib

     

       14
       14
       +
       , libglvnd

     

       15
       15
       +
       , libjack2

     

       16
       16
       +
       , libjpeg

     

       17
       17
       +
       , libxkbcommon

     

       18
       18
       +
       , makeWrapper

     

       19
       19
       +
       , pango

     

       20
       20
       +
       , pipewire

     

       21
       21
       +
       , pulseaudio

     

       22
       22
       +
       , wrapGAppsHook

     

       23
       23
       +
       , xdg-utils

     

       24
       24
       +
       , xorg

     

       25
       25
       +
       , zlib

     

       26
       26
       +
       }:

     

       27
       27
       +
       

     

       28
       28
       +
       stdenv.mkDerivation rec {

     

       29
       29
       +
         pname = "bitwig-studio";

     

       30
       30
       +
         version = "5.0";

     

       31
       31
       +
       

     

       32
       32
       +
         src = fetchurl {

     

       33
       33
       +
           url = "https://downloads.bitwig.com/stable/${version}/${pname}-${version}.deb";

     

       34
       34
       +
           sha256 = "sha256-0/S/aNoQA1nAdnr8nUWVLwzrDm+MHqmGIIjPW5YIr7s=";

     

       35
       35
       +
         };

     

       36
       36
       +
       

     

       37
       37
       +
         nativeBuildInputs = [ dpkg makeWrapper wrapGAppsHook ];

     

       38
       38
       +
       

     

       39
       39
       +
         unpackCmd = ''

     

       40
       40
       +
           mkdir -p root

     

       41
       41
       +
           dpkg-deb -x $curSrc root

     

       42
       42
       +
         '';

     

       43
       43
       +
       

     

       44
       44
       +
         dontBuild = true;

     

       45
       45
       +
         dontWrapGApps = true; # we only want $gappsWrapperArgs here

     

       46
       46
       +
       

     

       47
       47
       +
         buildInputs = with xorg; [

     

       48
       48
       +
           alsa-lib

     

       49
       49
       +
           atk

     

       50
       50
       +
           cairo

     

       51
       51
       +
           freetype

     

       52
       52
       +
           gdk-pixbuf

     

       53
       53
       +
           glib

     

       54
       54
       +
           gtk3

     

       55
       55
       +
           harfbuzz

     

       56
       56
       +
           libglvnd

     

       57
       57
       +
           libjack2

     

       58
       58
       +
           # libjpeg8 is required for converting jpeg's to colour palettes

     

       59
       59
       +
           libjpeg

     

       60
       60
       +
           libxcb

     

       61
       61
       +
           libXcursor

     

       62
       62
       +
           libX11

     

       63
       63
       +
           libXtst

     

       64
       64
       +
           libxkbcommon

     

       65
       65
       +
           pango

     

       66
       66
       +
           pipewire

     

       67
       67
       +
           pulseaudio

     

       68
       68
       +
           stdenv.cc.cc.lib

     

       69
       69
       +
           xcbutil

     

       70
       70
       +
           xcbutilwm

     

       71
       71
       +
           zlib

     

       72
       72
       +
         ];

     

       73
       73
       +
       

     

       74
       74
       +
         installPhase = ''

     

       75
       75
       +
           runHook preInstall

     

       76
       76
       +
       

     

       77
       77
       +
           mkdir -p $out/bin

     

       78
       78
       +
           cp -r opt/bitwig-studio $out/libexec

     

       79
       79
       +
           ln -s $out/libexec/bitwig-studio $out/bin/bitwig-studio

     

       80
       80
       +
           cp -r usr/share $out/share

     

       81
       81
       +
           substitute usr/share/applications/com.bitwig.BitwigStudio.desktop \

     

       82
       82
       +
             $out/share/applications/com.bitwig.BitwigStudio.desktop \

     

       83
       83
       +
             --replace /usr/bin/bitwig-studio $out/bin/bitwig-studio

     

       84
       84
       +
       

     

       85
       85
       +
             runHook postInstall

     

       86
       86
       +
         '';

     

       87
       87
       +
       

     

       88
       88
       +
         postFixup = ''

     

       89
       89
       +
           # patchelf fails to set rpath on BitwigStudioEngine, so we use

     

       90
       90
       +
           # the LD_LIBRARY_PATH way

     

       91
       91
       +
       

     

       92
       92
       +
           find $out -type f -executable \

     

       93
       93
       +
             -not -name '*.so.*' \

     

       94
       94
       +
             -not -name '*.so' \

     

       95
       95
       +
             -not -name '*.jar' \

     

       96
       96
       +
             -not -name 'jspawnhelper' \

     

       97
       97
       +
             -not -path '*/resources/*' | \

     

       98
       98
       +
           while IFS= read -r f ; do

     

       99
       99
       +
             patchelf --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" $f

     

       100
       100
       +
             # make xdg-open overrideable at runtime

     

       101
       101
       +
             wrapProgram $f \

     

       102
       102
       +
               "''${gappsWrapperArgs[@]}" \

     

       103
       103
       +
               --prefix PATH : "${lib.makeBinPath [ ffmpeg ]}" \

     

       104
       104
       +
               --suffix PATH : "${lib.makeBinPath [ xdg-utils ]}" \

     

       105
       105
       +
               --suffix LD_LIBRARY_PATH : "${lib.strings.makeLibraryPath buildInputs}"

     

       106
       106
       +
           done

     

       107
       107
       +
       

     

       108
       108
       +
           find $out -type f -executable -name 'jspawnhelper' | \

     

       109
       109
       +
           while IFS= read -r f ; do

     

       110
       110
       +
             patchelf --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" $f

     

       111
       111
       +
           done

     

       112
       112
       +
         '';

     

       113
       113
       +
       

     

       114
       114
       +
         meta = with lib; {

     

       115
       115
       +
           description = "A digital audio workstation";

     

       116
       116
       +
           longDescription = ''

     

       117
       117
       +
             Bitwig Studio is a multi-platform music-creation system for

     

       118
       118
       +
             production, performance and DJing, with a focus on flexible

     

       119
       119
       +
             editing tools and a super-fast workflow.

     

       120
       120
       +
           '';

     

       121
       121
       +
           homepage = "https://www.bitwig.com/";

     

       122
       122
       +
           license = licenses.unfree;

     

       123
       123
       +
           platforms = [ "x86_64-linux" ];

     

       124
       124
       +
           maintainers = with maintainers; [ bfortz michalrus mrVanDalo ];

     

       125
       125
       +
         };

     

       126
       126
       +
       }

+293 -293

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

···

       125
       125
        
       

     

       126
       126
        
         Ionide-vim = buildVimPluginFrom2Nix {

     

       127
       127
        
           pname = "Ionide-vim";

     

       128
       128
       -
           version = "2023-07-04";

     

       128
       128
       +
           version = "2023-07-17";

     

       129
       129
        
           src = fetchFromGitHub {

     

       130
       130
        
             owner = "ionide";

     

       131
       131
        
             repo = "Ionide-vim";

     

       132
       132
       -
             rev = "22a70da864c5c304c958561efb1ed5eb2ada780c";

     

       133
       133
       -
             sha256 = "0ha8r4xkiiyisagmraqps2jv46bdjrm6hhcgr11cll3gk3rwh28f";

     

       132
       132
       +
             rev = "8435bae84b26b602dbb68399661b3989915cc4d3";

     

       133
       133
       +
             sha256 = "0bsy6mnnz24w35r6sn6gzjzbrkqm7v6wqpd8db7p7fika6l1kzm5";

     

       134
       134
        
           };

     

       135
       135
        
           meta.homepage = "https://github.com/ionide/Ionide-vim/";

     

       136
       136
        
         };

     
···

       173
       173
        
       

     

       174
       174
        
         LazyVim = buildVimPluginFrom2Nix {

     

       175
       175
        
           pname = "LazyVim";

     

       176
       176
       -
           version = "2023-07-10";

     

       176
       176
       +
           version = "2023-07-16";

     

       177
       177
        
           src = fetchFromGitHub {

     

       178
       178
        
             owner = "LazyVim";

     

       179
       179
        
             repo = "LazyVim";

     

       180
       180
       -
             rev = "a38bf3001dc5576110cb0bbcacc262526ddf7bb9";

     

       181
       181
       -
             sha256 = "1ng6dcnyccs43ikwp1pf6df520iaqa952lszadxm60mha4m2490r";

     

       180
       180
       +
             rev = "fb1f29c32c516601b4074d113202482769ef030e";

     

       181
       181
       +
             sha256 = "0df0q7r9bwyidaxhzgmysi6awhrra8a37pjiv9pykd1rnq5gdl99";

     

       182
       182
        
           };

     

       183
       183
        
           meta.homepage = "https://github.com/LazyVim/LazyVim/";

     

       184
       184
        
         };

     

       185
       185
        
       

     

       186
       186
        
         LeaderF = buildVimPluginFrom2Nix {

     

       187
       187
        
           pname = "LeaderF";

     

       188
       188
       -
           version = "2023-07-11";

     

       188
       188
       +
           version = "2023-07-16";

     

       189
       189
        
           src = fetchFromGitHub {

     

       190
       190
        
             owner = "Yggdroot";

     

       191
       191
        
             repo = "LeaderF";

     

       192
       192
       -
             rev = "49af82180b22c3c2ff8d9d1e82a7ab1486cd052b";

     

       193
       193
       -
             sha256 = "14lq3yjvxdmpsxp1n1qkcb2nvl23q0r157vizr5kkgy00v194ifd";

     

       192
       192
       +
             rev = "ed13a2ff5fd6dfbbc9fdc15bea43ec03a6e8dbb6";

     

       193
       193
       +
             sha256 = "0cliyrfq4xf4zmg9innfbdvnz2g76ii71cqdb54gpfbgwmriljnl";

     

       194
       194
        
           };

     

       195
       195
        
           meta.homepage = "https://github.com/Yggdroot/LeaderF/";

     

       196
       196
        
         };

     
···

       305
       305
        
       

     

       306
       306
        
         SchemaStore-nvim = buildVimPluginFrom2Nix {

     

       307
       307
        
           pname = "SchemaStore.nvim";

     

       308
       308
       -
           version = "2023-07-10";

     

       308
       308
       +
           version = "2023-07-17";

     

       309
       309
        
           src = fetchFromGitHub {

     

       310
       310
        
             owner = "b0o";

     

       311
       311
        
             repo = "SchemaStore.nvim";

     

       312
       312
       -
             rev = "bdba0106f6e33fffb8e2ffea0162ce5565b18840";

     

       313
       313
       -
             sha256 = "0z02xxgnfxcpwc39fwqc47wdphgbxlcasksfj1p8lgrmw1q0p0kn";

     

       312
       312
       +
             rev = "0682f56392ddc86cf5e6b2af76a63bc48ad4ed84";

     

       313
       313
       +
             sha256 = "12kcyk5gw103a9mxwwildjy4dicqjbgh89xgxbgs56gdpcg7gb80";

     

       314
       314
        
           };

     

       315
       315
        
           meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";

     

       316
       316
        
         };

     
···

       377
       377
        
       

     

       378
       378
        
         SpaceVim = buildVimPluginFrom2Nix {

     

       379
       379
        
           pname = "SpaceVim";

     

       380
       380
       -
           version = "2023-07-10";

     

       380
       380
       +
           version = "2023-07-16";

     

       381
       381
        
           src = fetchFromGitHub {

     

       382
       382
        
             owner = "SpaceVim";

     

       383
       383
        
             repo = "SpaceVim";

     

       384
       384
       -
             rev = "69cddda85747b77608a8f7a86111e812409475a8";

     

       385
       385
       -
             sha256 = "135c0ilpq83cgcsc0gknyazzfv2pl0ll8crpa8gaxlb5g9vh8r70";

     

       384
       384
       +
             rev = "3e96e1325f15acdf7e9f13f360c434222bfe6090";

     

       385
       385
       +
             sha256 = "0qvjqmpfw6ljhsda2n5cb7vm3p3s38maiywy60s7nbnldl1l1d01";

     

       386
       386
        
           };

     

       387
       387
        
           meta.homepage = "https://github.com/SpaceVim/SpaceVim/";

     

       388
       388
        
         };

     
···

       502
       502
        
           src = fetchFromGitHub {

     

       503
       503
        
             owner = "stevearc";

     

       504
       504
        
             repo = "aerial.nvim";

     

       505
       505
       -
             rev = "e22facd3a696f4690f888e16ddaba585c8173e4e";

     

       506
       506
       -
             sha256 = "08zpnsvj1qbiz7c3n23hhbb7n24yzmamfajka2kyffl5fprgph0i";

     

       505
       505
       +
             rev = "fb1f08c9f90e8b0c04b2f2c5d95d06288a14c5b2";

     

       506
       506
       +
             sha256 = "1429srq5gkw37b4hb05cxp0lxjqgfawak3b8vbdphg79zr9imwn8";

     

       507
       507
        
             fetchSubmodules = true;

     

       508
       508
        
           };

     

       509
       509
        
           meta.homepage = "https://github.com/stevearc/aerial.nvim/";

     
···

       583
       583
        
       

     

       584
       584
        
         alpha-nvim = buildVimPluginFrom2Nix {

     

       585
       585
        
           pname = "alpha-nvim";

     

       586
       586
       -
           version = "2023-06-09";

     

       586
       586
       +
           version = "2023-07-16";

     

       587
       587
        
           src = fetchFromGitHub {

     

       588
       588
        
             owner = "goolord";

     

       589
       589
        
             repo = "alpha-nvim";

     

       590
       590
       -
             rev = "9e33db324b8bb7a147bce9ea5496686ee859461d";

     

       591
       591
       -
             sha256 = "0l5nwrdnb27a1sszivkzqf8q1isqkg07yh8p9f268m0433h8n0hf";

     

       590
       590
       +
             rev = "e4fc5e29b731bdf55d204c5c6a11dc3be70f3b65";

     

       591
       591
       +
             sha256 = "150hx42qpi25m6774f8y3di8lb7g3yca74q5l439v50prsxdh262";

     

       592
       592
        
           };

     

       593
       593
        
           meta.homepage = "https://github.com/goolord/alpha-nvim/";

     

       594
       594
        
         };

     
···

       1159
       1159
        
       

     

       1160
       1160
        
         bufferline-nvim = buildVimPluginFrom2Nix {

     

       1161
       1161
        
           pname = "bufferline.nvim";

     

       1162
       1162
       -
           version = "2023-07-10";

     

       1162
       1162
       +
           version = "2023-07-17";

     

       1163
       1163
        
           src = fetchFromGitHub {

     

       1164
       1164
        
             owner = "akinsho";

     

       1165
       1165
        
             repo = "bufferline.nvim";

     

       1166
       1166
       -
             rev = "cd27a52ecdfed7f14a41b61b7976f155e3d593c7";

     

       1167
       1167
       -
             sha256 = "0fcabl395y2qhnnabhakdkhk9f18vh9wkx1pmsdvkizs0hnhxlx3";

     

       1166
       1166
       +
             rev = "09b18b89ad2a2c2258a10bc06747f01bc1a42d0d";

     

       1167
       1167
       +
             sha256 = "0najr4nrgmik07xzrh30dz7yckr08mwbhhgz0z6anpyril45hq35";

     

       1168
       1168
        
           };

     

       1169
       1169
        
           meta.homepage = "https://github.com/akinsho/bufferline.nvim/";

     

       1170
       1170
        
         };

     
···

       1243
       1243
        
       

     

       1244
       1244
        
         chadtree = buildVimPluginFrom2Nix {

     

       1245
       1245
        
           pname = "chadtree";

     

       1246
       1246
       -
           version = "2023-07-09";

     

       1246
       1246
       +
           version = "2023-07-17";

     

       1247
       1247
        
           src = fetchFromGitHub {

     

       1248
       1248
        
             owner = "ms-jpq";

     

       1249
       1249
        
             repo = "chadtree";

     

       1250
       1250
       -
             rev = "99e0d388e0cfc265d98a1eb228e7e8708bef5219";

     

       1251
       1251
       -
             sha256 = "1a2dahpqm9nvpk58a8jppnmhdj22yd03a1b9a17nks174cvbjdkv";

     

       1250
       1250
       +
             rev = "193b4a53f2c2dc8bc61446f184ce55171ae1adf3";

     

       1251
       1251
       +
             sha256 = "104xdph0v2724qhkqc7jbwl90cafpswl14v19z560qxrc0y7fcir";

     

       1252
       1252
        
           };

     

       1253
       1253
        
           meta.homepage = "https://github.com/ms-jpq/chadtree/";

     

       1254
       1254
        
         };

     
···

       2023
       2023
        
       

     

       2024
       2024
        
         codeium-vim = buildVimPluginFrom2Nix {

     

       2025
       2025
        
           pname = "codeium.vim";

     

       2026
       2026
       -
           version = "2023-07-11";

     

       2026
       2026
       +
           version = "2023-07-18";

     

       2027
       2027
        
           src = fetchFromGitHub {

     

       2028
       2028
        
             owner = "Exafunction";

     

       2029
       2029
        
             repo = "codeium.vim";

     

       2030
       2030
       -
             rev = "3803ab16cd1e3160edae55fc5dd5e78b1d71e5d4";

     

       2031
       2031
       -
             sha256 = "09haj4j1d8gry6537g7mzllac2drwnb5kib6np4ml9sylr6x72lp";

     

       2030
       2030
       +
             rev = "e918c00ac5ace55b3ea7d7a3585343b02c227617";

     

       2031
       2031
       +
             sha256 = "0qjrildzh7zwxvlk5ac0n68w13m12gzdx0sf21rzmjhrqyfwmzkn";

     

       2032
       2032
        
           };

     

       2033
       2033
        
           meta.homepage = "https://github.com/Exafunction/codeium.vim/";

     

       2034
       2034
        
         };

     
···

       2083
       2083
        
       

     

       2084
       2084
        
         command-t = buildVimPluginFrom2Nix {

     

       2085
       2085
        
           pname = "command-t";

     

       2086
       2086
       -
           version = "2022-12-16";

     

       2086
       2086
       +
           version = "2023-07-14";

     

       2087
       2087
        
           src = fetchFromGitHub {

     

       2088
       2088
        
             owner = "wincent";

     

       2089
       2089
        
             repo = "command-t";

     

       2090
       2090
       -
             rev = "23d2860931dcbcbdfb3543bed002e35d7b3b898b";

     

       2091
       2091
       -
             sha256 = "0wqpyzggaxqplwi9w7ivndjkfisjv8f3lqw5dw7dps5zdk042svn";

     

       2090
       2090
       +
             rev = "9a1343c396178dc55ccc1166bf1eb434b5c18c43";

     

       2091
       2091
       +
             sha256 = "0qwkbf9yn7lwvihp3qdgd2kc85i6i3cca7spi2pcjsnf74bykqm8";

     

       2092
       2092
        
           };

     

       2093
       2093
        
           meta.homepage = "https://github.com/wincent/command-t/";

     

       2094
       2094
        
         };

     
···

       2251
       2251
        
       

     

       2252
       2252
        
         conjure = buildVimPluginFrom2Nix {

     

       2253
       2253
        
           pname = "conjure";

     

       2254
       2254
       -
           version = "2023-06-11";

     

       2254
       2254
       +
           version = "2023-07-11";

     

       2255
       2255
        
           src = fetchFromGitHub {

     

       2256
       2256
        
             owner = "Olical";

     

       2257
       2257
        
             repo = "conjure";

     

       2258
       2258
       -
             rev = "31a1626273e2bab479b6b8416a137f9edaba7daa";

     

       2259
       2259
       -
             sha256 = "1dcwp8sziahrgks2fdczvvfvnb7v9md2izpjw8r9cwvlx030g5lr";

     

       2258
       2258
       +
             rev = "2482871cbe0d1b85d331465cf7f065d5d2a7e2ac";

     

       2259
       2259
       +
             sha256 = "1jmlpf0k9zf6djblpphxlwsg6l0nhfxni67z8gzmawxg8a300kgg";

     

       2260
       2260
        
           };

     

       2261
       2261
        
           meta.homepage = "https://github.com/Olical/conjure/";

     

       2262
       2262
        
         };

     
···

       2323
       2323
        
       

     

       2324
       2324
        
         coq-artifacts = buildVimPluginFrom2Nix {

     

       2325
       2325
        
           pname = "coq.artifacts";

     

       2326
       2326
       -
           version = "2023-07-09";

     

       2326
       2326
       +
           version = "2023-07-16";

     

       2327
       2327
        
           src = fetchFromGitHub {

     

       2328
       2328
        
             owner = "ms-jpq";

     

       2329
       2329
        
             repo = "coq.artifacts";

     

       2330
       2330
       -
             rev = "e6a2ec767a98a21ebe9b247d80e462544e3f9397";

     

       2331
       2331
       -
             sha256 = "1rg3w4v6q1kl14jkfiamwmmq4a6spz7s5piznhdsn1j21d0l3b1f";

     

       2330
       2330
       +
             rev = "5ee6d770bb7a305d72c77d83352a2ae494b45a8f";

     

       2331
       2331
       +
             sha256 = "09xs3qcq0l4agldgy4nb8vilgzna4r852hnnl5cxbyxpjmk3xx0w";

     

       2332
       2332
        
           };

     

       2333
       2333
        
           meta.homepage = "https://github.com/ms-jpq/coq.artifacts/";

     

       2334
       2334
        
         };

     

       2335
       2335
        
       

     

       2336
       2336
        
         coq-thirdparty = buildVimPluginFrom2Nix {

     

       2337
       2337
        
           pname = "coq.thirdparty";

     

       2338
       2338
       -
           version = "2023-07-09";

     

       2338
       2338
       +
           version = "2023-07-16";

     

       2339
       2339
        
           src = fetchFromGitHub {

     

       2340
       2340
        
             owner = "ms-jpq";

     

       2341
       2341
        
             repo = "coq.thirdparty";

     

       2342
       2342
       -
             rev = "ac313e324861e353bf6ddf5286160d10cb202da3";

     

       2343
       2343
       -
             sha256 = "107jsagw15ab7whjxaygmd2aqd3a3jkm6d6vz513r5b7jrhclcbh";

     

       2342
       2342
       +
             rev = "0fb2082030fb9e922a1aa4951a98aa16ecbb81c0";

     

       2343
       2343
       +
             sha256 = "080dhva21q6g8iz2xrpswrp5lbwvyg39kh8sfbz1yb9s0b884byw";

     

       2344
       2344
        
           };

     

       2345
       2345
        
           meta.homepage = "https://github.com/ms-jpq/coq.thirdparty/";

     

       2346
       2346
        
         };

     
···

       2359
       2359
        
       

     

       2360
       2360
        
         coq_nvim = buildVimPluginFrom2Nix {

     

       2361
       2361
        
           pname = "coq_nvim";

     

       2362
       2362
       -
           version = "2023-07-09";

     

       2362
       2362
       +
           version = "2023-07-17";

     

       2363
       2363
        
           src = fetchFromGitHub {

     

       2364
       2364
        
             owner = "ms-jpq";

     

       2365
       2365
        
             repo = "coq_nvim";

     

       2366
       2366
       -
             rev = "02cf0fc1fb5af0805d87c7c4ecb396ffe92b8dc2";

     

       2367
       2367
       -
             sha256 = "057ym4bhfich5hfbnsx7lb82d1rrsa3a3nzblfzhvaipb6sn05by";

     

       2366
       2366
       +
             rev = "9135326d588259cef9d5eb5d49d2a1b5ed76c25c";

     

       2367
       2367
       +
             sha256 = "1jfwh6jc3lmsrsqaarm8wcqw0wb4wiyznbj2v41wi5nw4pq32pif";

     

       2368
       2368
        
           };

     

       2369
       2369
        
           meta.homepage = "https://github.com/ms-jpq/coq_nvim/";

     

       2370
       2370
        
         };

     
···

       2479
       2479
        
       

     

       2480
       2480
        
         ctrlp-vim = buildVimPluginFrom2Nix {

     

       2481
       2481
        
           pname = "ctrlp.vim";

     

       2482
       2482
       -
           version = "2022-08-03";

     

       2482
       2482
       +
           version = "2023-07-16";

     

       2483
       2483
        
           src = fetchFromGitHub {

     

       2484
       2484
        
             owner = "ctrlpvim";

     

       2485
       2485
        
             repo = "ctrlp.vim";

     

       2486
       2486
       -
             rev = "8b4a9523632049b3b373de1233bef346073b8982";

     

       2487
       2487
       -
             sha256 = "0g7mymqgncnmc326xysx9rlhja5601b18sn4hbpr7p49sqqspyv4";

     

       2486
       2486
       +
             rev = "7c972cb19c8544c681ca345c64ec39e04f4651cc";

     

       2487
       2487
       +
             sha256 = "15li2j26xxa90z6ci675whljym2sc6br6jxs2x4in5m1gv3qj36x";

     

       2488
       2488
        
           };

     

       2489
       2489
        
           meta.homepage = "https://github.com/ctrlpvim/ctrlp.vim/";

     

       2490
       2490
        
         };

     
···

       2841
       2841
        
       

     

       2842
       2842
        
         deoplete-nvim = buildVimPluginFrom2Nix {

     

       2843
       2843
        
           pname = "deoplete.nvim";

     

       2844
       2844
       -
           version = "2023-04-22";

     

       2844
       2844
       +
           version = "2023-07-14";

     

       2845
       2845
        
           src = fetchFromGitHub {

     

       2846
       2846
        
             owner = "Shougo";

     

       2847
       2847
        
             repo = "deoplete.nvim";

     

       2848
       2848
       -
             rev = "82db30626e411e99b0274b8d6c99bce561cb0394";

     

       2849
       2849
       -
             sha256 = "0ras9hh57al5vap7ksp8rs3ih7fffswv8is39xfkks4jjwg4b1sf";

     

       2848
       2848
       +
             rev = "b3a03b25ecabcca444827b312e10439f8836289f";

     

       2849
       2849
       +
             sha256 = "0zbp5h0mf8v8hvxjr72p1nm91s20fn63ayx7h8zj2m55x8x7r8wg";

     

       2850
       2850
        
           };

     

       2851
       2851
        
           meta.homepage = "https://github.com/Shougo/deoplete.nvim/";

     

       2852
       2852
        
         };

     
···

       2961
       2961
        
       

     

       2962
       2962
        
         dracula-nvim = buildVimPluginFrom2Nix {

     

       2963
       2963
        
           pname = "dracula.nvim";

     

       2964
       2964
       -
           version = "2023-07-10";

     

       2964
       2964
       +
           version = "2023-07-16";

     

       2965
       2965
        
           src = fetchFromGitHub {

     

       2966
       2966
        
             owner = "Mofiqul";

     

       2967
       2967
        
             repo = "dracula.nvim";

     

       2968
       2968
       -
             rev = "608ebc389514674213a74f1d173c00f85bebc008";

     

       2969
       2969
       -
             sha256 = "0h43r4zlh14pwxzm8d76xm68vaxwdpn6z56ybzzmv7vcr9kpgm50";

     

       2968
       2968
       +
             rev = "948d237241b91389c8c2f109885b91cd2574b8bb";

     

       2969
       2969
       +
             sha256 = "09cgyskfmqnp0gl1qbwfij8a6r6c0frgbj39zjx15frbhraygpdb";

     

       2970
       2970
        
           };

     

       2971
       2971
        
           meta.homepage = "https://github.com/Mofiqul/dracula.nvim/";

     

       2972
       2972
        
         };

     

       2973
       2973
        
       

     

       2974
       2974
        
         dressing-nvim = buildVimPluginFrom2Nix {

     

       2975
       2975
        
           pname = "dressing.nvim";

     

       2976
       2976
       -
           version = "2023-06-26";

     

       2976
       2976
       +
           version = "2023-07-17";

     

       2977
       2977
        
           src = fetchFromGitHub {

     

       2978
       2978
        
             owner = "stevearc";

     

       2979
       2979
        
             repo = "dressing.nvim";

     

       2980
       2980
       -
             rev = "e6eff7a5a950a853c3903d906dbcea03f778db5f";

     

       2981
       2981
       -
             sha256 = "180whgmdfgsv5xbnrk4jndisafv4v59vi8001ikq4k08wm3ah634";

     

       2980
       2980
       +
             rev = "39611852fd7bbac117e939a26759bb37361f0c90";

     

       2981
       2981
       +
             sha256 = "19j6c9byrxjiv067lc7s6f34854nnxwcla8vil6g41f67m3810k7";

     

       2982
       2982
        
           };

     

       2983
       2983
        
           meta.homepage = "https://github.com/stevearc/dressing.nvim/";

     

       2984
       2984
        
         };

     
···

       3155
       3155
        
       

     

       3156
       3156
        
         executor-nvim = buildVimPluginFrom2Nix {

     

       3157
       3157
        
           pname = "executor.nvim";

     

       3158
       3158
       -
           version = "2023-05-23";

     

       3158
       3158
       +
           version = "2023-07-12";

     

       3159
       3159
        
           src = fetchFromGitHub {

     

       3160
       3160
        
             owner = "google";

     

       3161
       3161
        
             repo = "executor.nvim";

     

       3162
       3162
       -
             rev = "c1c8d69dceefbfa299c43c8b69433e2adcb0ed02";

     

       3163
       3163
       -
             sha256 = "0wld79mrjwr6v13an9v6lx57yfdpad13x06gqxzhr5by0z404bdn";

     

       3162
       3162
       +
             rev = "0fc98a2d05a0662af2d7c55899c79635bb05ac5a";

     

       3163
       3163
       +
             sha256 = "0mh13s9v7mkkq2zh4wmq273gv0nf7p6rn4hiwnk3zw053g9jpvzi";

     

       3164
       3164
        
           };

     

       3165
       3165
        
           meta.homepage = "https://github.com/google/executor.nvim/";

     

       3166
       3166
        
         };

     
···

       3324
       3324
        
       

     

       3325
       3325
        
         flash-nvim = buildVimPluginFrom2Nix {

     

       3326
       3326
        
           pname = "flash.nvim";

     

       3327
       3327
       -
           version = "2023-07-07";

     

       3327
       3327
       +
           version = "2023-07-16";

     

       3328
       3328
        
           src = fetchFromGitHub {

     

       3329
       3329
        
             owner = "folke";

     

       3330
       3330
        
             repo = "flash.nvim";

     

       3331
       3331
       -
             rev = "a8da6ff212c1885ecde26af477207742959c67d7";

     

       3332
       3332
       -
             sha256 = "1x7nrncpd9fj3mk74m1x0n1jzdyi6h5sw53mghd3ydyb4cqrg2pj";

     

       3331
       3331
       +
             rev = "c92ecbff98fdc8770c283aa3934349e6889195dd";

     

       3332
       3332
       +
             sha256 = "0pfc3fwhgj7kjf85pvhib0cp1qiq8rak63fb5nnkv2220nvdpb0c";

     

       3333
       3333
        
           };

     

       3334
       3334
        
           meta.homepage = "https://github.com/folke/flash.nvim/";

     

       3335
       3335
        
         };

     
···

       3348
       3348
        
       

     

       3349
       3349
        
         flit-nvim = buildVimPluginFrom2Nix {

     

       3350
       3350
        
           pname = "flit.nvim";

     

       3351
       3351
       -
           version = "2023-06-23";

     

       3351
       3351
       +
           version = "2023-07-13";

     

       3352
       3352
        
           src = fetchFromGitHub {

     

       3353
       3353
        
             owner = "ggandor";

     

       3354
       3354
        
             repo = "flit.nvim";

     

       3355
       3355
       -
             rev = "5c9a78b97f7f4301473ea5e37501b5b1d4da167b";

     

       3356
       3356
       -
             sha256 = "1d8zjmynl3qjkv5r8rcf11185gwnrs72pl7xh0f0ckd08gl4ra0c";

     

       3355
       3355
       +
             rev = "498b3a4864e697f1ed1145e518c4c78c776c55d8";

     

       3356
       3356
       +
             sha256 = "0w56zv254hpw57zgwzaikj9ciyksvkbd0brynhgcaby8s6hhhgil";

     

       3357
       3357
        
           };

     

       3358
       3358
        
           meta.homepage = "https://github.com/ggandor/flit.nvim/";

     

       3359
       3359
        
         };

     
···

       3420
       3420
        
       

     

       3421
       3421
        
         formatter-nvim = buildVimPluginFrom2Nix {

     

       3422
       3422
        
           pname = "formatter.nvim";

     

       3423
       3423
       -
           version = "2023-04-30";

     

       3423
       3423
       +
           version = "2023-07-13";

     

       3424
       3424
        
           src = fetchFromGitHub {

     

       3425
       3425
        
             owner = "mhartington";

     

       3426
       3426
        
             repo = "formatter.nvim";

     

       3427
       3427
       -
             rev = "fa4f2729cc2909db599169f22d8e55632d4c8d59";

     

       3428
       3428
       -
             sha256 = "0hv79gdg7cgqr3a8vw1ysc48f6i3b8xabbglxspm5mbpf22c8xbk";

     

       3427
       3427
       +
             rev = "9bf2e7e294b00bac87c6123c889828ee08dc9b46";

     

       3428
       3428
       +
             sha256 = "0hmlh6qcra7sfq0i989cxs5jmgk6774bljzvq9m17ybwj3imb14f";

     

       3429
       3429
        
           };

     

       3430
       3430
        
           meta.homepage = "https://github.com/mhartington/formatter.nvim/";

     

       3431
       3431
        
         };

     
···

       3444
       3444
        
       

     

       3445
       3445
        
         friendly-snippets = buildVimPluginFrom2Nix {

     

       3446
       3446
        
           pname = "friendly-snippets";

     

       3447
       3447
       -
           version = "2023-07-09";

     

       3447
       3447
       +
           version = "2023-07-18";

     

       3448
       3448
        
           src = fetchFromGitHub {

     

       3449
       3449
        
             owner = "rafamadriz";

     

       3450
       3450
        
             repo = "friendly-snippets";

     

       3451
       3451
       -
             rev = "6e0afe3be0ba43ef03d495a529de8fb22721c0d0";

     

       3452
       3452
       -
             sha256 = "1rzipwl5slmv56fb84yy2isxfqydjydx2ns8sxydkhkk0pz25wrp";

     

       3451
       3451
       +
             rev = "ea84a710262cb2c286d439070bad37d36fd3db25";

     

       3452
       3452
       +
             sha256 = "0w9x4q7mf1p3g2mk16zhsnznlqk4rd2cc4gwwvafc1hgcqvv5ycc";

     

       3453
       3453
        
           };

     

       3454
       3454
        
           meta.homepage = "https://github.com/rafamadriz/friendly-snippets/";

     

       3455
       3455
        
         };

     
···

       3552
       3552
        
       

     

       3553
       3553
        
         fzf-lua = buildVimPluginFrom2Nix {

     

       3554
       3554
        
           pname = "fzf-lua";

     

       3555
       3555
       -
           version = "2023-07-10";

     

       3555
       3555
       +
           version = "2023-07-18";

     

       3556
       3556
        
           src = fetchFromGitHub {

     

       3557
       3557
        
             owner = "ibhagwan";

     

       3558
       3558
        
             repo = "fzf-lua";

     

       3559
       3559
       -
             rev = "63bfdd54d1ba5af042a6be350aba4299b7a0f5a3";

     

       3560
       3560
       -
             sha256 = "0l08xmgadwgjr37icv7cqxyfz8yb4fkb9hrv7760588yjkl6gdda";

     

       3559
       3559
       +
             rev = "1bba731df46feb1751dca1632268aae41ed5ac15";

     

       3560
       3560
       +
             sha256 = "08qv4zslrqrg67gbazk2sllcgx4hakl5fgrlcv7bd6r0djiv673y";

     

       3561
       3561
        
           };

     

       3562
       3562
        
           meta.homepage = "https://github.com/ibhagwan/fzf-lua/";

     

       3563
       3563
        
         };

     

       3564
       3564
        
       

     

       3565
       3565
        
         fzf-vim = buildVimPluginFrom2Nix {

     

       3566
       3566
        
           pname = "fzf.vim";

     

       3567
       3567
       -
           version = "2023-06-09";

     

       3567
       3567
       +
           version = "2023-07-17";

     

       3568
       3568
        
           src = fetchFromGitHub {

     

       3569
       3569
        
             owner = "junegunn";

     

       3570
       3570
        
             repo = "fzf.vim";

     

       3571
       3571
       -
             rev = "1dcdb21db618055134cd611f4f5918f6d00a5df0";

     

       3572
       3572
       -
             sha256 = "0655iypmf7nafrwhrj09v5cgwfsg8dnqgkrpxlb2z2b5wji79cx7";

     

       3571
       3571
       +
             rev = "e0d131d95364edf940a70127fcb5748b86e6955e";

     

       3572
       3572
       +
             sha256 = "04g1albh3f865vy7wp9zp4njpazf4haiynxpzy4j0x44wfnchl2j";

     

       3573
       3573
        
           };

     

       3574
       3574
        
           meta.homepage = "https://github.com/junegunn/fzf.vim/";

     

       3575
       3575
        
         };

     
···

       3720
       3720
        
       

     

       3721
       3721
        
         gitsigns-nvim = buildNeovimPlugin {

     

       3722
       3722
        
           pname = "gitsigns.nvim";

     

       3723
       3723
       -
           version = "2023-07-10";

     

       3723
       3723
       +
           version = "2023-07-17";

     

       3724
       3724
        
           src = fetchFromGitHub {

     

       3725
       3725
        
             owner = "lewis6991";

     

       3726
       3726
        
             repo = "gitsigns.nvim";

     

       3727
       3727
       -
             rev = "48c3ae8ec74cb83f9570ceb0c5ab8217db7a2220";

     

       3728
       3728
       -
             sha256 = "0v0il2wwgca58gv4jl70gwimnh0qy8swmlxqaw0yl0yj68pgv6ba";

     

       3727
       3727
       +
             rev = "1e01b2958aebb79f1c33e7427a1bac131a678e0d";

     

       3728
       3728
       +
             sha256 = "0zci7smildfn9zs7wdqhyc094xz9fiijw4y1m97csb79425ccpq4";

     

       3729
       3729
        
           };

     

       3730
       3730
        
           meta.homepage = "https://github.com/lewis6991/gitsigns.nvim/";

     

       3731
       3731
        
         };

     
···

       3828
       3828
        
       

     

       3829
       3829
        
         goto-preview = buildVimPluginFrom2Nix {

     

       3830
       3830
        
           pname = "goto-preview";

     

       3831
       3831
       -
           version = "2023-03-17";

     

       3831
       3831
       +
           version = "2023-07-16";

     

       3832
       3832
        
           src = fetchFromGitHub {

     

       3833
       3833
        
             owner = "rmagatti";

     

       3834
       3834
        
             repo = "goto-preview";

     

       3835
       3835
       -
             rev = "82ce83ae589be7a59e4ec5cfbbf82d9f5eb8bded";

     

       3836
       3836
       -
             sha256 = "1hl8nlvp8rlycpkfwyl10lzd5ilxw33mfv1a39isrsa7l7ql75b9";

     

       3835
       3835
       +
             rev = "c5fd9d8d90aef85a97f6abae6f9fe51d445e62b4";

     

       3836
       3836
       +
             sha256 = "0xvshq43326z3czqlqr56b9lybap27g0pswrmz7m9501svizb90v";

     

       3837
       3837
        
           };

     

       3838
       3838
        
           meta.homepage = "https://github.com/rmagatti/goto-preview/";

     

       3839
       3839
        
         };

     
···

       3983
       3983
        
       

     

       3984
       3984
        
         haskell-tools-nvim = buildNeovimPlugin {

     

       3985
       3985
        
           pname = "haskell-tools.nvim";

     

       3986
       3986
       -
           version = "2023-07-09";

     

       3986
       3986
       +
           version = "2023-07-17";

     

       3987
       3987
        
           src = fetchFromGitHub {

     

       3988
       3988
        
             owner = "MrcJkb";

     

       3989
       3989
        
             repo = "haskell-tools.nvim";

     

       3990
       3990
       -
             rev = "b2e3ecdc3d94bf489126c040be27a8af80733453";

     

       3991
       3991
       -
             sha256 = "1yhnib92inqs3ww00bwimidpbzfi17xiv2ifjyprpfyx1kk76h33";

     

       3990
       3990
       +
             rev = "9bc54093737c100c78c6c51ec0478b14e2d8f2fd";

     

       3991
       3991
       +
             sha256 = "0nl9rx0ps00a7c669nh11s7qmn02w1l4y9a0g9sqhz4k8zk65dyj";

     

       3992
       3992
        
           };

     

       3993
       3993
        
           meta.homepage = "https://github.com/MrcJkb/haskell-tools.nvim/";

     

       3994
       3994
        
         };

     
···

       4079
       4079
        
       

     

       4080
       4080
        
         himalaya-vim = buildVimPluginFrom2Nix {

     

       4081
       4081
        
           pname = "himalaya-vim";

     

       4082
       4082
       -
           version = "2023-02-15";

     

       4082
       4082
       +
           version = "2023-07-17";

     

       4083
       4083
        
           src = fetchgit {

     

       4084
       4084
        
             url = "https://git.sr.ht/~soywod/himalaya-vim";

     

       4085
       4085
       -
             rev = "64fb17067cf5dbf5349726b9ed1b1b38065cdb82";

     

       4086
       4086
       -
             sha256 = "13d5vs35bmzr4dj2anj2k7scmx647ddsyz941sjaajsyff37bvsv";

     

       4085
       4085
       +
             rev = "479c49fd46899144d24b78dbd81d64cc0c05ffc7";

     

       4086
       4086
       +
             sha256 = "0as0dxkf37pfqk878rq1d3dfdl2d724plabgs0cy3lkg20x389i4";

     

       4087
       4087
        
           };

     

       4088
       4088
        
           meta.homepage = "https://git.sr.ht/~soywod/himalaya-vim";

     

       4089
       4089
        
         };

     
···

       4306
       4306
        
       

     

       4307
       4307
        
         indentLine = buildVimPluginFrom2Nix {

     

       4308
       4308
        
           pname = "indentLine";

     

       4309
       4309
       -
           version = "2022-09-07";

     

       4309
       4309
       +
           version = "2023-07-14";

     

       4310
       4310
        
           src = fetchFromGitHub {

     

       4311
       4311
        
             owner = "Yggdroot";

     

       4312
       4312
        
             repo = "indentLine";

     

       4313
       4313
       -
             rev = "d15d63bf9c4a74a02470d4bc8ecce53df13e3a75";

     

       4314
       4314
       -
             sha256 = "079r951hg2z2cjlb4sh8iz4pvivlinbvidpgq66ddlv4v5q5yg34";

     

       4313
       4313
       +
             rev = "b96a75985736da969ac38b72a7716a8c57bdde98";

     

       4314
       4314
       +
             sha256 = "0g5rvgn6919wbg4xpiwzkq6c1nhsg2lmxmqg3fj75fk71glcggcp";

     

       4315
       4315
        
           };

     

       4316
       4316
        
           meta.homepage = "https://github.com/Yggdroot/indentLine/";

     

       4317
       4317
        
         };

     
···

       4402
       4402
        
       

     

       4403
       4403
        
         iron-nvim = buildVimPluginFrom2Nix {

     

       4404
       4404
        
           pname = "iron.nvim";

     

       4405
       4405
       -
           version = "2023-07-04";

     

       4405
       4405
       +
           version = "2023-07-13";

     

       4406
       4406
        
           src = fetchFromGitHub {

     

       4407
       4407
        
             owner = "Vigemus";

     

       4408
       4408
        
             repo = "iron.nvim";

     

       4409
       4409
       -
             rev = "f603de5263be81782125a9c3010182f55b7d1dfc";

     

       4410
       4410
       -
             sha256 = "04ss0jv0jliwab8mq7hdwz3m0y8scfp4y3irr3lhidfg9fcmwhs4";

     

       4409
       4409
       +
             rev = "7f876ee3e1f4ea1e5284b1b697cdad5b256e8046";

     

       4410
       4410
       +
             sha256 = "0yf7sykk6dvzmnzwphfmi3s3jmr9iab1aqszx6ir5915zy3wrwvl";

     

       4411
       4411
        
           };

     

       4412
       4412
        
           meta.homepage = "https://github.com/Vigemus/iron.nvim/";

     

       4413
       4413
        
         };

     
···

       4619
       4619
        
       

     

       4620
       4620
        
         lazy-nvim = buildVimPluginFrom2Nix {

     

       4621
       4621
        
           pname = "lazy.nvim";

     

       4622
       4622
       -
           version = "2023-07-09";

     

       4622
       4622
       +
           version = "2023-07-16";

     

       4623
       4623
        
           src = fetchFromGitHub {

     

       4624
       4624
        
             owner = "folke";

     

       4625
       4625
        
             repo = "lazy.nvim";

     

       4626
       4626
       -
             rev = "da8b00581a52f5f87ad2aba9f52171fda7491f18";

     

       4627
       4627
       -
             sha256 = "1b2h6fzj54jwjqkqhd51lfw4mdqdiam9426zdxaic9nbjai7rjps";

     

       4626
       4626
       +
             rev = "25beed5e2e935ebc00d7e3eed1dc502df3c40e39";

     

       4627
       4627
       +
             sha256 = "08f7ajqmd06bxpxmrqybqib1ixvq6k65y8lrsgiykjbwld59x2sk";

     

       4628
       4628
        
           };

     

       4629
       4629
        
           meta.homepage = "https://github.com/folke/lazy.nvim/";

     

       4630
       4630
        
         };

     

       4631
       4631
        
       

     

       4632
       4632
        
         lazygit-nvim = buildVimPluginFrom2Nix {

     

       4633
       4633
        
           pname = "lazygit.nvim";

     

       4634
       4634
       -
           version = "2023-06-03";

     

       4634
       4634
       +
           version = "2023-07-15";

     

       4635
       4635
        
           src = fetchFromGitHub {

     

       4636
       4636
        
             owner = "kdheepak";

     

       4637
       4637
        
             repo = "lazygit.nvim";

     

       4638
       4638
       -
             rev = "3466e48439601445e26c65635421625886f2d0c0";

     

       4639
       4639
       -
             sha256 = "1w8qrgkvg7hivxlcr17l787gkyc0whi6iwgfl4chbcrll9ddj3r9";

     

       4638
       4638
       +
             rev = "146c6294bf0b4db1572fa7232039aaa9003a52b9";

     

       4639
       4639
       +
             sha256 = "0pbp4b4g57xpk9r3mxisgm2frr80wh25f8izwg1k5fg3izvar60g";

     

       4640
       4640
        
           };

     

       4641
       4641
        
           meta.homepage = "https://github.com/kdheepak/lazygit.nvim/";

     

       4642
       4642
        
         };

     
···

       4679
       4679
        
       

     

       4680
       4680
        
         leap-nvim = buildVimPluginFrom2Nix {

     

       4681
       4681
        
           pname = "leap.nvim";

     

       4682
       4682
       -
           version = "2023-07-04";

     

       4682
       4682
       +
           version = "2023-07-17";

     

       4683
       4683
        
           src = fetchFromGitHub {

     

       4684
       4684
        
             owner = "ggandor";

     

       4685
       4685
        
             repo = "leap.nvim";

     

       4686
       4686
       -
             rev = "8facf2eb6a378fd7691dce8c8a7b2726823e2408";

     

       4687
       4687
       -
             sha256 = "185zil8r41dz981qjmj241zri5iswfafqsx9racvsg87gcvysggn";

     

       4686
       4686
       +
             rev = "7eeeb3ff74ff8cabd583a061492e76c1c6d2bac8";

     

       4687
       4687
       +
             sha256 = "0dqplrxdx4j62r7xsjr1dfgws92sx4dbqiw95ry1c0iv8923vbv4";

     

       4688
       4688
        
           };

     

       4689
       4689
        
           meta.homepage = "https://github.com/ggandor/leap.nvim/";

     

       4690
       4690
        
         };

     
···

       4871
       4871
        
       

     

       4872
       4872
        
         lir-nvim = buildVimPluginFrom2Nix {

     

       4873
       4873
        
           pname = "lir.nvim";

     

       4874
       4874
       -
           version = "2023-06-05";

     

       4874
       4874
       +
           version = "2023-07-12";

     

       4875
       4875
        
           src = fetchFromGitHub {

     

       4876
       4876
        
             owner = "tamago324";

     

       4877
       4877
        
             repo = "lir.nvim";

     

       4878
       4878
       -
             rev = "959ac31dae906fb71181c2e75ace62ffb1fff8c8";

     

       4879
       4879
       -
             sha256 = "1r4m1nifavshj1g17sxcxfw449jamfc4ffdpil44g9wr7rjwv0hj";

     

       4878
       4878
       +
             rev = "969e95bd07ec315b5efc53af69c881278c2b74fa";

     

       4879
       4879
       +
             sha256 = "1rrmsib2frr4x00kl07v9acva8wa75fbpvpwq8yvdyjy1zgmir7q";

     

       4880
       4880
        
           };

     

       4881
       4881
        
           meta.homepage = "https://github.com/tamago324/lir.nvim/";

     

       4882
       4882
        
         };

     
···

       5027
       5027
        
       

     

       5028
       5028
        
         lsp-zero-nvim = buildVimPluginFrom2Nix {

     

       5029
       5029
        
           pname = "lsp-zero.nvim";

     

       5030
       5030
       -
           version = "2023-06-20";

     

       5030
       5030
       +
           version = "2023-07-16";

     

       5031
       5031
        
           src = fetchFromGitHub {

     

       5032
       5032
        
             owner = "VonHeikemen";

     

       5033
       5033
        
             repo = "lsp-zero.nvim";

     

       5034
       5034
       -
             rev = "de0e7d7c75cb032107d4a728aa0a63a61d8e5909";

     

       5035
       5035
       -
             sha256 = "04x9hmshjfy11fsxjk51w0axafm05iiw3gja2jyj4mrh95lpzrwl";

     

       5034
       5034
       +
             rev = "7e1675e9e90ee08b859d75aa65609e480e55f752";

     

       5035
       5035
       +
             sha256 = "0qfznb6zc5gd65zz04h6qzd214xwaqgb7828fpnml7r5a2jnqv18";

     

       5036
       5036
        
           };

     

       5037
       5037
        
           meta.homepage = "https://github.com/VonHeikemen/lsp-zero.nvim/";

     

       5038
       5038
        
         };

     
···

       5146
       5146
        
       

     

       5147
       5147
        
         luasnip = buildVimPluginFrom2Nix {

     

       5148
       5148
        
           pname = "luasnip";

     

       5149
       5149
       -
           version = "2023-07-10";

     

       5149
       5149
       +
           version = "2023-07-18";

     

       5150
       5150
        
           src = fetchFromGitHub {

     

       5151
       5151
        
             owner = "l3mon4d3";

     

       5152
       5152
        
             repo = "luasnip";

     

       5153
       5153
       -
             rev = "45a4e899ca8f54936fe32ead6bba65f2a8d42e12";

     

       5154
       5154
       -
             sha256 = "00d3bdpx26n61yy3rq7z44wlpryiqpccjnv6kjrp9gjsydh4a471";

     

       5153
       5153
       +
             rev = "1f72e43a446961a1372c54038882c1d36e105cab";

     

       5154
       5154
       +
             sha256 = "10wlakfhjfmpgbp069ni7q81ksr0q1dpcm3yfb62jk4zx9hy8q6k";

     

       5155
       5155
        
             fetchSubmodules = true;

     

       5156
       5156
        
           };

     

       5157
       5157
        
           meta.homepage = "https://github.com/l3mon4d3/luasnip/";

     
···

       5243
       5243
        
       

     

       5244
       5244
        
         mason-lspconfig-nvim = buildVimPluginFrom2Nix {

     

       5245
       5245
        
           pname = "mason-lspconfig.nvim";

     

       5246
       5246
       -
           version = "2023-07-10";

     

       5246
       5246
       +
           version = "2023-07-14";

     

       5247
       5247
        
           src = fetchFromGitHub {

     

       5248
       5248
        
             owner = "williamboman";

     

       5249
       5249
        
             repo = "mason-lspconfig.nvim";

     

       5250
       5250
       -
             rev = "796008869e67ef27a5aa5ac44c08ce2a60b89f55";

     

       5251
       5251
       -
             sha256 = "1l8nkjdl4k66yas0wrzddk83k7z73kcylqb0cv7h2v7f2d2y79ng";

     

       5250
       5250
       +
             rev = "828a538ac8419f586c010996aefa5df6eb7c250b";

     

       5251
       5251
       +
             sha256 = "0pl2s2im38pcvkj8qklmkcihli4634hf77zykhkbx18ip84v3j2a";

     

       5252
       5252
        
           };

     

       5253
       5253
        
           meta.homepage = "https://github.com/williamboman/mason-lspconfig.nvim/";

     

       5254
       5254
        
         };

     

       5255
       5255
        
       

     

       5256
       5256
        
         mason-tool-installer-nvim = buildVimPluginFrom2Nix {

     

       5257
       5257
        
           pname = "mason-tool-installer.nvim";

     

       5258
       5258
       -
           version = "2023-06-12";

     

       5258
       5258
       +
           version = "2023-07-13";

     

       5259
       5259
        
           src = fetchFromGitHub {

     

       5260
       5260
        
             owner = "WhoIsSethDaniel";

     

       5261
       5261
        
             repo = "mason-tool-installer.nvim";

     

       5262
       5262
       -
             rev = "49e3efe743d846d80da5a4757d4f7e563a96cb84";

     

       5263
       5263
       -
             sha256 = "1g5aha7jjw36wl2ji1i4gwa623x8v6agyxdqv68k7dsbid6kqj3r";

     

       5262
       5262
       +
             rev = "031903fefbf59371502092ef9e22cab9161d90ba";

     

       5263
       5263
       +
             sha256 = "1za6shsh5ykdv9ivf971b3ckfxk25p8lsd9qdgrmm5bag6vih8cl";

     

       5264
       5264
        
           };

     

       5265
       5265
        
           meta.homepage = "https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim/";

     

       5266
       5266
        
         };

     
···

       5291
       5291
        
       

     

       5292
       5292
        
         material-nvim = buildVimPluginFrom2Nix {

     

       5293
       5293
        
           pname = "material.nvim";

     

       5294
       5294
       -
           version = "2023-07-06";

     

       5294
       5294
       +
           version = "2023-07-11";

     

       5295
       5295
        
           src = fetchFromGitHub {

     

       5296
       5296
        
             owner = "marko-cerovac";

     

       5297
       5297
        
             repo = "material.nvim";

     

       5298
       5298
       -
             rev = "c7631d373d3ae02ef502ec6b8620a8ff36ab922e";

     

       5299
       5299
       -
             sha256 = "192xaw1k2sa5m92f046g6nbp4jw3yxb8xzzk33824h03adykblcl";

     

       5298
       5298
       +
             rev = "1ecaa2d065a1ea308bd7702a77c2bf35ede8f536";

     

       5299
       5299
       +
             sha256 = "04fd3rm4lzf29vpma2ylh19qcsms81qs6nlzwji8la3d78zr09n3";

     

       5300
       5300
        
           };

     

       5301
       5301
        
           meta.homepage = "https://github.com/marko-cerovac/material.nvim/";

     

       5302
       5302
        
         };

     
···

       5351
       5351
        
       

     

       5352
       5352
        
         mini-nvim = buildVimPluginFrom2Nix {

     

       5353
       5353
        
           pname = "mini.nvim";

     

       5354
       5354
       -
           version = "2023-07-11";

     

       5354
       5354
       +
           version = "2023-07-17";

     

       5355
       5355
        
           src = fetchFromGitHub {

     

       5356
       5356
        
             owner = "echasnovski";

     

       5357
       5357
        
             repo = "mini.nvim";

     

       5358
       5358
       -
             rev = "4766f80acf4df22385adb36bf3a166752848f179";

     

       5359
       5359
       -
             sha256 = "0n2zx64489qgmrr2w1j83rpi9j759p4w6xqnga23sxbsxgvvj60r";

     

       5358
       5358
       +
             rev = "34acb9bd6d2f88c57d21f6a261ddba6a740651f7";

     

       5359
       5359
       +
             sha256 = "049szg72fa9ym3l2nsqfxp8p4qwrnvy2qm5pxhx292frpf5fsbr6";

     

       5360
       5360
        
           };

     

       5361
       5361
        
           meta.homepage = "https://github.com/echasnovski/mini.nvim/";

     

       5362
       5362
        
         };

     
···

       5423
       5423
        
       

     

       5424
       5424
        
         monokai-pro-nvim = buildVimPluginFrom2Nix {

     

       5425
       5425
        
           pname = "monokai-pro.nvim";

     

       5426
       5426
       -
           version = "2023-06-25";

     

       5426
       5426
       +
           version = "2023-07-16";

     

       5427
       5427
        
           src = fetchFromGitHub {

     

       5428
       5428
        
             owner = "loctvl842";

     

       5429
       5429
        
             repo = "monokai-pro.nvim";

     

       5430
       5430
       -
             rev = "cb351c21a46e12df53e0650a5a1ee1b9d27b9a98";

     

       5431
       5431
       -
             sha256 = "0hknggiy49h1zfi0yvnxz9xv5r3jnriz5jrp8nyc1m3zwirmrir3";

     

       5430
       5430
       +
             rev = "0f200f880eea0ffddfd4b24f6f9f2cf9c17a7efc";

     

       5431
       5431
       +
             sha256 = "1g7vawsx40fbl6h2y6ajycygmmd753wy2i4q9ix902p150rzrs4b";

     

       5432
       5432
        
           };

     

       5433
       5433
        
           meta.homepage = "https://github.com/loctvl842/monokai-pro.nvim/";

     

       5434
       5434
        
         };

     
···

       5699
       5699
        
       

     

       5700
       5700
        
         neo-tree-nvim = buildVimPluginFrom2Nix {

     

       5701
       5701
        
           pname = "neo-tree.nvim";

     

       5702
       5702
       -
           version = "2023-07-03";

     

       5702
       5702
       +
           version = "2023-07-17";

     

       5703
       5703
        
           src = fetchFromGitHub {

     

       5704
       5704
        
             owner = "nvim-neo-tree";

     

       5705
       5705
        
             repo = "neo-tree.nvim";

     

       5706
       5706
       -
             rev = "7f6fa04dbd8e8c79d1af33bc90e856b65d8641da";

     

       5707
       5707
       -
             sha256 = "1hq3gxqv5jsih4cj78y8shn5ncna3hi8mwzgkl2qjhy490vc7kpa";

     

       5706
       5706
       +
             rev = "293395c80224fd6f179dffc1c641430c85f999b0";

     

       5707
       5707
       +
             sha256 = "17blgl5fnr83mzkxv10xa0rhkr6yc65q43m48m8907l3m8252dmn";

     

       5708
       5708
        
           };

     

       5709
       5709
        
           meta.homepage = "https://github.com/nvim-neo-tree/neo-tree.nvim/";

     

       5710
       5710
        
         };

     
···

       5735
       5735
        
       

     

       5736
       5736
        
         neodark-vim = buildVimPluginFrom2Nix {

     

       5737
       5737
        
           pname = "neodark.vim";

     

       5738
       5738
       -
           version = "2022-11-13";

     

       5738
       5738
       +
           version = "2023-07-15";

     

       5739
       5739
        
           src = fetchFromGitHub {

     

       5740
       5740
        
             owner = "KeitaNakamura";

     

       5741
       5741
        
             repo = "neodark.vim";

     

       5742
       5742
       -
             rev = "d11dc6e8b32aeb64a3abc5f7d94d5569070bb4bc";

     

       5743
       5743
       -
             sha256 = "0fxf8qcj6kh7j9mdnx2ncpnnxg37nbf6gs11d0nw27ihqc92xx1c";

     

       5742
       5742
       +
             rev = "2488bf42b197cb09f7807e35a58d3fe56ef1776b";

     

       5743
       5743
       +
             sha256 = "0ihkhhkgqvsm67kx41mr8zrir5wkk43pnq4kd8nbl467m1k88nxa";

     

       5744
       5744
        
           };

     

       5745
       5745
        
           meta.homepage = "https://github.com/KeitaNakamura/neodark.vim/";

     

       5746
       5746
        
         };

     

       5747
       5747
        
       

     

       5748
       5748
        
         neodev-nvim = buildVimPluginFrom2Nix {

     

       5749
       5749
        
           pname = "neodev.nvim";

     

       5750
       5750
       -
           version = "2023-07-11";

     

       5750
       5750
       +
           version = "2023-07-17";

     

       5751
       5751
        
           src = fetchFromGitHub {

     

       5752
       5752
        
             owner = "folke";

     

       5753
       5753
        
             repo = "neodev.nvim";

     

       5754
       5754
       -
             rev = "fed7f27480ac6bda777cb36f2d6737c8ccc580fe";

     

       5755
       5755
       -
             sha256 = "19763byainb613r1xkk2grahbqxwvfiycg3ljz5cmmi9y82z7n2f";

     

       5754
       5754
       +
             rev = "17e89aabab209d7cdd3a205dce0678894fb3ffcd";

     

       5755
       5755
       +
             sha256 = "198mzx35xrhkwpacw93qcg5pvafilx7fl2gb7r20ds381w4jvbpk";

     

       5756
       5756
        
           };

     

       5757
       5757
        
           meta.homepage = "https://github.com/folke/neodev.nvim/";

     

       5758
       5758
        
         };

     
···

       5783
       5783
        
       

     

       5784
       5784
        
         neogit = buildVimPluginFrom2Nix {

     

       5785
       5785
        
           pname = "neogit";

     

       5786
       5786
       -
           version = "2023-07-07";

     

       5786
       5786
       +
           version = "2023-07-17";

     

       5787
       5787
        
           src = fetchFromGitHub {

     

       5788
       5788
        
             owner = "NeogitOrg";

     

       5789
       5789
        
             repo = "neogit";

     

       5790
       5790
       -
             rev = "1b6edb56e8c754494be1564912d33e50ddd8a023";

     

       5791
       5791
       -
             sha256 = "0qm74hapfq4lghka7ipkppxlan1c37gjf89wqslclj7q40cplm32";

     

       5790
       5790
       +
             rev = "bd7203e1f18ed72d1450688075f4d8f0b1c4f024";

     

       5791
       5791
       +
             sha256 = "0gibh9i6dk3cvj48vs7npc82h44xlx1qqcvx1552nisz9v4mrnxl";

     

       5792
       5792
        
           };

     

       5793
       5793
        
           meta.homepage = "https://github.com/NeogitOrg/neogit/";

     

       5794
       5794
        
         };

     
···

       5915
       5915
        
       

     

       5916
       5916
        
         neotest = buildVimPluginFrom2Nix {

     

       5917
       5917
        
           pname = "neotest";

     

       5918
       5918
       -
           version = "2023-06-15";

     

       5918
       5918
       +
           version = "2023-07-15";

     

       5919
       5919
        
           src = fetchFromGitHub {

     

       5920
       5920
        
             owner = "nvim-neotest";

     

       5921
       5921
        
             repo = "neotest";

     

       5922
       5922
       -
             rev = "e46eae5739c470aa011ee43108ea8a730736174e";

     

       5923
       5923
       -
             sha256 = "0jwvasiv4y8dcg14h8b6n9fzma84bk0y3d8h5rydzg2351wk145m";

     

       5922
       5922
       +
             rev = "fb0b31ae1dcdc7d68af5c66db4434ae5ebeffcfc";

     

       5923
       5923
       +
             sha256 = "0qgfhfmsbvh93bl621syfx7c275if2zx22vrm3pm77lk83z8q039";

     

       5924
       5924
        
           };

     

       5925
       5925
        
           meta.homepage = "https://github.com/nvim-neotest/neotest/";

     

       5926
       5926
        
         };

     
···

       5975
       5975
        
       

     

       5976
       5976
        
         neotest-go = buildVimPluginFrom2Nix {

     

       5977
       5977
        
           pname = "neotest-go";

     

       5978
       5978
       -
           version = "2023-07-01";

     

       5978
       5978
       +
           version = "2023-07-16";

     

       5979
       5979
        
           src = fetchFromGitHub {

     

       5980
       5980
        
             owner = "nvim-neotest";

     

       5981
       5981
        
             repo = "neotest-go";

     

       5982
       5982
       -
             rev = "05535cb2cfe3ce5c960f65784896d40109572f89";

     

       5983
       5983
       -
             sha256 = "0mg1cacs6hd2f0pgrggd94f88yaq99ic9xw3a3hiyywcx7apkz94";

     

       5982
       5982
       +
             rev = "f2580cad67ef0181403cf65858ab638ffd3ede9f";

     

       5983
       5983
       +
             sha256 = "0lvbqyqcz35964akcq5xmg69xw37jpf8202k27zy10f160swff8j";

     

       5984
       5984
        
           };

     

       5985
       5985
        
           meta.homepage = "https://github.com/nvim-neotest/neotest-go/";

     

       5986
       5986
        
         };

     

       5987
       5987
        
       

     

       5988
       5988
        
         neotest-haskell = buildVimPluginFrom2Nix {

     

       5989
       5989
        
           pname = "neotest-haskell";

     

       5990
       5990
       -
           version = "2023-07-09";

     

       5990
       5990
       +
           version = "2023-07-17";

     

       5991
       5991
        
           src = fetchFromGitHub {

     

       5992
       5992
        
             owner = "MrcJkb";

     

       5993
       5993
        
             repo = "neotest-haskell";

     

       5994
       5994
       -
             rev = "f7d028916583af59e554bbc7b01255f53b931417";

     

       5995
       5995
       -
             sha256 = "1wwxfwa9vqphr9qkpg2y195dqdk5qy3apivmja5abb98kvp761xx";

     

       5994
       5994
       +
             rev = "41e22bafacd20d0a0afbbd045c7f9763c7b8b57a";

     

       5995
       5995
       +
             sha256 = "1dijxhpklz3yjkispdld1qf9jcfsr46f1j0lw4vgg9k20f5sb0sm";

     

       5996
       5996
        
           };

     

       5997
       5997
        
           meta.homepage = "https://github.com/MrcJkb/neotest-haskell/";

     

       5998
       5998
        
         };

     
···

       6071
       6071
        
       

     

       6072
       6072
        
         neotest-rust = buildVimPluginFrom2Nix {

     

       6073
       6073
        
           pname = "neotest-rust";

     

       6074
       6074
       -
           version = "2023-07-01";

     

       6074
       6074
       +
           version = "2023-07-17";

     

       6075
       6075
        
           src = fetchFromGitHub {

     

       6076
       6076
        
             owner = "rouge8";

     

       6077
       6077
        
             repo = "neotest-rust";

     

       6078
       6078
       -
             rev = "6dce8963e5395adf079bf22e931dfce65d3fed25";

     

       6079
       6079
       -
             sha256 = "0mg71ha951di5srw6g6whdpjjmbqrg47n2d5ana2q9svqmgrd0cc";

     

       6078
       6078
       +
             rev = "d1dfe0f51f3a1def715d1fdd6918341176592c23";

     

       6079
       6079
       +
             sha256 = "0iaxkp43q42zg08ggkp3n1p7y6dwfij3g9dm0d93wwgcg86ync53";

     

       6080
       6080
        
           };

     

       6081
       6081
        
           meta.homepage = "https://github.com/rouge8/neotest-rust/";

     

       6082
       6082
        
         };

     
···

       6335
       6335
        
       

     

       6336
       6336
        
         noice-nvim = buildVimPluginFrom2Nix {

     

       6337
       6337
        
           pname = "noice.nvim";

     

       6338
       6338
       -
           version = "2023-07-01";

     

       6338
       6338
       +
           version = "2023-07-17";

     

       6339
       6339
        
           src = fetchFromGitHub {

     

       6340
       6340
        
             owner = "folke";

     

       6341
       6341
        
             repo = "noice.nvim";

     

       6342
       6342
       -
             rev = "6c87c1d11c38180fb72bf8f45518a0a3e081afc1";

     

       6343
       6343
       -
             sha256 = "0y0fwll3a421r0px9x2d8mq2nj00w6ahilwmrvmhvnazjgqd074j";

     

       6342
       6342
       +
             rev = "bfd2368b3f1fdd5766885b0115238d1f47113c6d";

     

       6343
       6343
       +
             sha256 = "18dijmm8c49whkn1dlb8w6sj6f6999zzymv9ri416v4jamiwd3gj";

     

       6344
       6344
        
           };

     

       6345
       6345
        
           meta.homepage = "https://github.com/folke/noice.nvim/";

     

       6346
       6346
        
         };

     
···

       6479
       6479
        
       

     

       6480
       6480
        
         nvim-autopairs = buildVimPluginFrom2Nix {

     

       6481
       6481
        
           pname = "nvim-autopairs";

     

       6482
       6482
       -
           version = "2023-06-18";

     

       6482
       6482
       +
           version = "2023-07-14";

     

       6483
       6483
        
           src = fetchFromGitHub {

     

       6484
       6484
        
             owner = "windwp";

     

       6485
       6485
        
             repo = "nvim-autopairs";

     

       6486
       6486
       -
             rev = "e8f7dd7a72de3e7b6626c050a802000e69d53ff0";

     

       6487
       6487
       -
             sha256 = "0lk78zvmf5cyyq4nmrzybi7dbpbwx499r0la4wza9h1gp4l7xvy7";

     

       6486
       6486
       +
             rev = "ae5b41ce880a6d850055e262d6dfebd362bb276e";

     

       6487
       6487
       +
             sha256 = "0bka3gy9all6axkdpbp0q5adspl6vrdws9my9gllszjndsjrdvvf";

     

       6488
       6488
        
           };

     

       6489
       6489
        
           meta.homepage = "https://github.com/windwp/nvim-autopairs/";

     

       6490
       6490
        
         };

     
···

       6575
       6575
        
       

     

       6576
       6576
        
         nvim-cokeline = buildVimPluginFrom2Nix {

     

       6577
       6577
        
           pname = "nvim-cokeline";

     

       6578
       6578
       -
           version = "2023-07-06";

     

       6578
       6578
       +
           version = "2023-07-17";

     

       6579
       6579
        
           src = fetchFromGitHub {

     

       6580
       6580
        
             owner = "willothy";

     

       6581
       6581
        
             repo = "nvim-cokeline";

     

       6582
       6582
       -
             rev = "904dc18d017cdf5c7c52a6455fd2a8d6f9a8bc3b";

     

       6583
       6583
       -
             sha256 = "1wbfa9g22d2hshl2v0ksg5xmjhrdclqqq7zf33d9pxxr4bp62xyp";

     

       6582
       6582
       +
             rev = "d6d3e758698a00478ce5bbecb1c9e223478c4e91";

     

       6583
       6583
       +
             sha256 = "0aixbg4c5ihdk8s4cch2fyilfjzgbi9x28byrz1k7q1ah8hj1wak";

     

       6584
       6584
        
           };

     

       6585
       6585
        
           meta.homepage = "https://github.com/willothy/nvim-cokeline/";

     

       6586
       6586
        
         };

     
···

       6647
       6647
        
       

     

       6648
       6648
        
         nvim-coverage = buildVimPluginFrom2Nix {

     

       6649
       6649
        
           pname = "nvim-coverage";

     

       6650
       6650
       -
           version = "2023-05-26";

     

       6650
       6650
       +
           version = "2023-07-17";

     

       6651
       6651
        
           src = fetchFromGitHub {

     

       6652
       6652
        
             owner = "andythigpen";

     

       6653
       6653
        
             repo = "nvim-coverage";

     

       6654
       6654
       -
             rev = "8fcc71e01e93f305e334b59f902e545a70d0050f";

     

       6655
       6655
       -
             sha256 = "0d62vpbf03pbq4rs4yxywnn7j9wb90bahv1cx2wm5w4q6jgdgpk3";

     

       6654
       6654
       +
             rev = "214997f42d4e00b0fe37cd826a0be43cbf326e74";

     

       6655
       6655
       +
             sha256 = "0b1dwpdf167xgqpzh0mvldmnrzbqm9lcqi98l6ykl00ik7qdnvx9";

     

       6656
       6656
        
           };

     

       6657
       6657
        
           meta.homepage = "https://github.com/andythigpen/nvim-coverage/";

     

       6658
       6658
        
         };

     
···

       6671
       6671
        
       

     

       6672
       6672
        
         nvim-dap = buildVimPluginFrom2Nix {

     

       6673
       6673
        
           pname = "nvim-dap";

     

       6674
       6674
       -
           version = "2023-07-09";

     

       6674
       6674
       +
           version = "2023-07-17";

     

       6675
       6675
        
           src = fetchFromGitHub {

     

       6676
       6676
        
             owner = "mfussenegger";

     

       6677
       6677
        
             repo = "nvim-dap";

     

       6678
       6678
       -
             rev = "3bde6f786057fa29d8356559b2ae3a52d9317fba";

     

       6679
       6679
       -
             sha256 = "0mm3yhbidknz0rkbmsa32j4jnws9vfss8c6il833v0c4q7zm1jl5";

     

       6678
       6678
       +
             rev = "d17d1bba23ec72a157bd183c57840c39e323f515";

     

       6679
       6679
       +
             sha256 = "172wwzl1rmxn0as549kf7gm9hzpxarz6nxsb4wsaaxab0980idik";

     

       6680
       6680
        
           };

     

       6681
       6681
        
           meta.homepage = "https://github.com/mfussenegger/nvim-dap/";

     

       6682
       6682
        
         };

     

       6683
       6683
        
       

     

       6684
       6684
        
         nvim-dap-go = buildVimPluginFrom2Nix {

     

       6685
       6685
        
           pname = "nvim-dap-go";

     

       6686
       6686
       -
           version = "2023-05-23";

     

       6686
       6686
       +
           version = "2023-07-17";

     

       6687
       6687
        
           src = fetchFromGitHub {

     

       6688
       6688
        
             owner = "leoluz";

     

       6689
       6689
        
             repo = "nvim-dap-go";

     

       6690
       6690
       -
             rev = "cdf604a5703838f65fdee7c198f6cb59b563ef6f";

     

       6691
       6691
       -
             sha256 = "0iwwykp4ddw39blb8v3miw3l7xm0bsy6yzszb8pmli5cd6fgqf69";

     

       6690
       6690
       +
             rev = "64c622d5dd8c1dbfb78cdd637e6217da0f7facb9";

     

       6691
       6691
       +
             sha256 = "09ic1qlniwmzfikxcdk4zalnma7nhkly7nnzc4cvcxy6cw7w7i1p";

     

       6692
       6692
        
           };

     

       6693
       6693
        
           meta.homepage = "https://github.com/leoluz/nvim-dap-go/";

     

       6694
       6694
        
         };

     
···

       6707
       6707
        
       

     

       6708
       6708
        
         nvim-dap-ui = buildVimPluginFrom2Nix {

     

       6709
       6709
        
           pname = "nvim-dap-ui";

     

       6710
       6710
       -
           version = "2023-05-29";

     

       6710
       6710
       +
           version = "2023-07-14";

     

       6711
       6711
        
           src = fetchFromGitHub {

     

       6712
       6712
        
             owner = "rcarriga";

     

       6713
       6713
        
             repo = "nvim-dap-ui";

     

       6714
       6714
       -
             rev = "c020f660b02772f9f3d11f599fefad3268628a9e";

     

       6715
       6715
       -
             sha256 = "0w64jq8g57g6wacrz1yx9mfjmmd82qfcpia818lfa4594z1amfg3";

     

       6714
       6714
       +
             rev = "85b16ac2309d85c88577cd8ee1733ce52be8227e";

     

       6715
       6715
       +
             sha256 = "04ylr1jcj7bbcsrsx2z84savkf1yqaisymq7gsnhvzmbpxxwb96g";

     

       6716
       6716
        
           };

     

       6717
       6717
        
           meta.homepage = "https://github.com/rcarriga/nvim-dap-ui/";

     

       6718
       6718
        
         };

     
···

       6767
       6767
        
       

     

       6768
       6768
        
         nvim-gdb = buildVimPluginFrom2Nix {

     

       6769
       6769
        
           pname = "nvim-gdb";

     

       6770
       6770
       -
           version = "2023-07-10";

     

       6770
       6770
       +
           version = "2023-07-16";

     

       6771
       6771
        
           src = fetchFromGitHub {

     

       6772
       6772
        
             owner = "sakhnik";

     

       6773
       6773
        
             repo = "nvim-gdb";

     

       6774
       6774
       -
             rev = "48e18669eb7bb7d6e7cb3d86de1082924f5fddd2";

     

       6775
       6775
       -
             sha256 = "1jmx7sr5am4xz2id93c1g6a4pnd0ni361469i15qj4n757n90f8r";

     

       6774
       6774
       +
             rev = "cb3166d1eca0118f25c3fb98361e3eadaea66dcd";

     

       6775
       6775
       +
             sha256 = "18cdfai44a8wsvnj9nsan55p5p0lnabip5bvqidainagcs4rlq9n";

     

       6776
       6776
        
           };

     

       6777
       6777
        
           meta.homepage = "https://github.com/sakhnik/nvim-gdb/";

     

       6778
       6778
        
         };

     
···

       6791
       6791
        
       

     

       6792
       6792
        
         nvim-highlight-colors = buildVimPluginFrom2Nix {

     

       6793
       6793
        
           pname = "nvim-highlight-colors";

     

       6794
       6794
       -
           version = "2023-07-01";

     

       6794
       6794
       +
           version = "2023-07-13";

     

       6795
       6795
        
           src = fetchFromGitHub {

     

       6796
       6796
        
             owner = "brenoprata10";

     

       6797
       6797
        
             repo = "nvim-highlight-colors";

     

       6798
       6798
       -
             rev = "60ee461c30953d2d1dc3895d01af995b24cc6788";

     

       6799
       6799
       -
             sha256 = "09ikihpskymbawk5l4n4xc25dhmhywiwlsklimcwhj2bs4vngpa4";

     

       6798
       6798
       +
             rev = "e1c976a31d19c10e77b89e054310b1061acb5158";

     

       6799
       6799
       +
             sha256 = "0vw7314dz3ig5yd3msb0vp77x544sw27f2z54va7qwbwhx4125a3";

     

       6800
       6800
        
           };

     

       6801
       6801
        
           meta.homepage = "https://github.com/brenoprata10/nvim-highlight-colors/";

     

       6802
       6802
        
         };

     
···

       6875
       6875
        
       

     

       6876
       6876
        
         nvim-lightbulb = buildVimPluginFrom2Nix {

     

       6877
       6877
        
           pname = "nvim-lightbulb";

     

       6878
       6878
       -
           version = "2023-07-10";

     

       6878
       6878
       +
           version = "2023-07-12";

     

       6879
       6879
        
           src = fetchFromGitHub {

     

       6880
       6880
        
             owner = "kosayoda";

     

       6881
       6881
        
             repo = "nvim-lightbulb";

     

       6882
       6882
       -
             rev = "bb9ec720aa998252951627f811e8f39b76789e0a";

     

       6883
       6883
       -
             sha256 = "03anzn14a8fc14wzv9m98f2flhn4lcn66g4c053r1bc9p54k21p0";

     

       6882
       6882
       +
             rev = "6166029a136afd56cf23384fc31e8ba203a6e102";

     

       6883
       6883
       +
             sha256 = "119zcfz7s6a6rnc342nhh1zdrfbrqgyx425r4qmzkqvq7a15bvc1";

     

       6884
       6884
        
           };

     

       6885
       6885
        
           meta.homepage = "https://github.com/kosayoda/nvim-lightbulb/";

     

       6886
       6886
        
         };

     
···

       6899
       6899
        
       

     

       6900
       6900
        
         nvim-lint = buildVimPluginFrom2Nix {

     

       6901
       6901
        
           pname = "nvim-lint";

     

       6902
       6902
       -
           version = "2023-06-22";

     

       6902
       6902
       +
           version = "2023-07-17";

     

       6903
       6903
        
           src = fetchFromGitHub {

     

       6904
       6904
        
             owner = "mfussenegger";

     

       6905
       6905
        
             repo = "nvim-lint";

     

       6906
       6906
       -
             rev = "0b99416769e87231ce37aec64b4ed91feb43a98e";

     

       6907
       6907
       -
             sha256 = "0skmm7j2js0idqprns1jhknqnfvm88xxx3k0z3il0n2fibnd7kf3";

     

       6906
       6906
       +
             rev = "b401d64adb54c66de5a3c830beb3f6fced0831f1";

     

       6907
       6907
       +
             sha256 = "1gvaq9rhnz6m6qlkcyaljxjrl27i2d1sw208cv0022rara06j9nx";

     

       6908
       6908
        
           };

     

       6909
       6909
        
           meta.homepage = "https://github.com/mfussenegger/nvim-lint/";

     

       6910
       6910
        
         };

     
···

       6935
       6935
        
       

     

       6936
       6936
        
         nvim-lspconfig = buildVimPluginFrom2Nix {

     

       6937
       6937
        
           pname = "nvim-lspconfig";

     

       6938
       6938
       -
           version = "2023-07-08";

     

       6938
       6938
       +
           version = "2023-07-17";

     

       6939
       6939
        
           src = fetchFromGitHub {

     

       6940
       6940
        
             owner = "neovim";

     

       6941
       6941
        
             repo = "nvim-lspconfig";

     

       6942
       6942
       -
             rev = "deade69789089c3da15237697156334fb3e943f0";

     

       6943
       6943
       -
             sha256 = "09m1ix3wv3n7r5i5sakh3c7gh3zlvsnckjy4gkxhhpx5sdckw1h6";

     

       6942
       6942
       +
             rev = "ba3ec2527aa7aae9b989d69966174a22b7d1b1dd";

     

       6943
       6943
       +
             sha256 = "1wv6k3dp5sgg1bh1ww14kdgqjrzxpy5iqjdfb9w5847sxq0sgcnx";

     

       6944
       6944
        
           };

     

       6945
       6945
        
           meta.homepage = "https://github.com/neovim/nvim-lspconfig/";

     

       6946
       6946
        
         };

     
···

       7031
       7031
        
       

     

       7032
       7032
        
         nvim-navic = buildVimPluginFrom2Nix {

     

       7033
       7033
        
           pname = "nvim-navic";

     

       7034
       7034
       -
           version = "2023-07-08";

     

       7034
       7034
       +
           version = "2023-07-15";

     

       7035
       7035
        
           src = fetchFromGitHub {

     

       7036
       7036
        
             owner = "smiteshp";

     

       7037
       7037
        
             repo = "nvim-navic";

     

       7038
       7038
       -
             rev = "6e8850a524307814decc1b195a2c8a51482a9886";

     

       7039
       7039
       -
             sha256 = "1js5vdjc9rs2gi0g7b2lkwxs9assnykbc9i2f144b3ky7yhiisbw";

     

       7038
       7038
       +
             rev = "e6da6f74d89de65258ea7e98e22103ff5de6dcf5";

     

       7039
       7039
       +
             sha256 = "00nhcfhqsvaaaa94a7yxm29ass92k7a7q4g7khm7v8bsm6prxi3x";

     

       7040
       7040
        
           };

     

       7041
       7041
        
           meta.homepage = "https://github.com/smiteshp/nvim-navic/";

     

       7042
       7042
        
         };

     
···

       7151
       7151
        
       

     

       7152
       7152
        
         nvim-scrollview = buildVimPluginFrom2Nix {

     

       7153
       7153
        
           pname = "nvim-scrollview";

     

       7154
       7154
       -
           version = "2023-07-11";

     

       7154
       7154
       +
           version = "2023-07-18";

     

       7155
       7155
        
           src = fetchFromGitHub {

     

       7156
       7156
        
             owner = "dstein64";

     

       7157
       7157
        
             repo = "nvim-scrollview";

     

       7158
       7158
       -
             rev = "1c559f44cbde8a3637a48b6b5f44e201aff4e1cf";

     

       7159
       7159
       -
             sha256 = "1nybh0n5g2sz0n4j974i173zv5byqly5k26km88kygxa3dzlmqx8";

     

       7158
       7158
       +
             rev = "5b9be248b214c0f2fcfcc1b64a147c12fe40cbe8";

     

       7159
       7159
       +
             sha256 = "0xj4d4g446gfbyzk5wy43m3ri4dkgnx444ijn9y638x78mcwx4cc";

     

       7160
       7160
        
           };

     

       7161
       7161
        
           meta.homepage = "https://github.com/dstein64/nvim-scrollview/";

     

       7162
       7162
        
         };

     
···

       7199
       7199
        
       

     

       7200
       7200
        
         nvim-spider = buildVimPluginFrom2Nix {

     

       7201
       7201
        
           pname = "nvim-spider";

     

       7202
       7202
       -
           version = "2023-06-11";

     

       7202
       7202
       +
           version = "2023-07-12";

     

       7203
       7203
        
           src = fetchFromGitHub {

     

       7204
       7204
        
             owner = "chrisgrieser";

     

       7205
       7205
        
             repo = "nvim-spider";

     

       7206
       7206
       -
             rev = "04c6fc14d09823002dae486100745011fc3201ca";

     

       7207
       7207
       -
             sha256 = "14310nzyjw7z83m7lqgbw2g0924ikwqi4h6cg9xcmh9ydflvn4dd";

     

       7206
       7206
       +
             rev = "430d1772869f626c1b97c3d255cdcee5945e9b14";

     

       7207
       7207
       +
             sha256 = "0avy3zqayf8xljmwf59v6i4fdy9rp2r3xq2hknl9r2r0qbbr103r";

     

       7208
       7208
        
           };

     

       7209
       7209
        
           meta.homepage = "https://github.com/chrisgrieser/nvim-spider/";

     

       7210
       7210
        
         };

     
···

       7259
       7259
        
       

     

       7260
       7260
        
         nvim-tree-lua = buildVimPluginFrom2Nix {

     

       7261
       7261
        
           pname = "nvim-tree.lua";

     

       7262
       7262
       -
           version = "2023-07-09";

     

       7262
       7262
       +
           version = "2023-07-16";

     

       7263
       7263
        
           src = fetchFromGitHub {

     

       7264
       7264
        
             owner = "nvim-tree";

     

       7265
       7265
        
             repo = "nvim-tree.lua";

     

       7266
       7266
       -
             rev = "a708bd2413d467929b5019ec1bce7b1f428438bc";

     

       7267
       7267
       -
             sha256 = "1ss2dy68144jsf5ynfmv2nik2yklb3qxb547qq9nd04l3wj8f5n9";

     

       7266
       7266
       +
             rev = "3b62c6bf2c3f2973036aed609d02fd0ca9c3af35";

     

       7267
       7267
       +
             sha256 = "0k4n0b88qxm6h5fprapcf1rl9swdqcj0qp6ncjhahvangldsfv9g";

     

       7268
       7268
        
           };

     

       7269
       7269
        
           meta.homepage = "https://github.com/nvim-tree/nvim-tree.lua/";

     

       7270
       7270
        
         };

     

       7271
       7271
        
       

     

       7272
       7272
        
         nvim-treesitter = buildVimPluginFrom2Nix {

     

       7273
       7273
        
           pname = "nvim-treesitter";

     

       7274
       7274
       -
           version = "2023-07-11";

     

       7274
       7274
       +
           version = "2023-07-17";

     

       7275
       7275
        
           src = fetchFromGitHub {

     

       7276
       7276
        
             owner = "nvim-treesitter";

     

       7277
       7277
        
             repo = "nvim-treesitter";

     

       7278
       7278
       -
             rev = "3af1220e18034eb2ce7d1c8e77055bc3bf3c1c36";

     

       7279
       7279
       -
             sha256 = "0qbgh8hvnjb0dg8fqv9w5025sv2z8b9lwcgqpbdcsgqih2g6k84r";

     

       7278
       7278
       +
             rev = "44211e7f6e669b8a07e86abc533b292a30c32d62";

     

       7279
       7279
       +
             sha256 = "1255csfz0rvhafrljbilfnzwdq2ripnbvflxd862338fa1jflmlv";

     

       7280
       7280
        
           };

     

       7281
       7281
        
           meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter/";

     

       7282
       7282
        
         };

     

       7283
       7283
        
       

     

       7284
       7284
        
         nvim-treesitter-context = buildVimPluginFrom2Nix {

     

       7285
       7285
        
           pname = "nvim-treesitter-context";

     

       7286
       7286
       -
           version = "2023-06-29";

     

       7286
       7286
       +
           version = "2023-07-13";

     

       7287
       7287
        
           src = fetchFromGitHub {

     

       7288
       7288
        
             owner = "nvim-treesitter";

     

       7289
       7289
        
             repo = "nvim-treesitter-context";

     

       7290
       7290
       -
             rev = "63f3ffc50b0afc59be1015153d00922498085be8";

     

       7291
       7291
       -
             sha256 = "1jvsf80q8dxhdxbphrms755aj4ak58xacpzgs91v5jb5zjcvmsx9";

     

       7290
       7290
       +
             rev = "6f8f788738b968f24a108ee599c5be0031f94f06";

     

       7291
       7291
       +
             sha256 = "1a7gqxl2l5lhx282jd0hx0mc377scr8zv6xss7jsw55k6y4ad5h0";

     

       7292
       7292
        
           };

     

       7293
       7293
        
           meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter-context/";

     

       7294
       7294
        
         };

     
···

       7379
       7379
        
       

     

       7380
       7380
        
         nvim-ts-rainbow2 = buildVimPluginFrom2Nix {

     

       7381
       7381
        
           pname = "nvim-ts-rainbow2";

     

       7382
       7382
       -
           version = "2023-07-09";

     

       7382
       7382
       +
           version = "2023-07-12";

     

       7383
       7383
        
           src = fetchgit {

     

       7384
       7384
        
             url = "https://gitlab.com/HiPhish/nvim-ts-rainbow2";

     

       7385
       7385
       -
             rev = "d2ea7b31b805cf4b7a05d032d0ec9d356345d3df";

     

       7386
       7386
       -
             sha256 = "1xa6khjjq6l9269dnhsgkiq18hjf52f4dp0n622x8bmmxifql9ja";

     

       7385
       7385
       +
             rev = "b3120cd5ae9ca524af9cb602f41e12e301fa985f";

     

       7386
       7386
       +
             sha256 = "0mjg0pkd8wv8cfar30lkyywdrd3g5lz36bbsfb7lrqi7kbksyzxv";

     

       7387
       7387
        
           };

     

       7388
       7388
        
           meta.homepage = "https://gitlab.com/HiPhish/nvim-ts-rainbow2";

     

       7389
       7389
        
         };

     
···

       7402
       7402
        
       

     

       7403
       7403
        
         nvim-web-devicons = buildVimPluginFrom2Nix {

     

       7404
       7404
        
           pname = "nvim-web-devicons";

     

       7405
       7405
       -
           version = "2023-06-25";

     

       7405
       7405
       +
           version = "2023-07-16";

     

       7406
       7406
        
           src = fetchFromGitHub {

     

       7407
       7407
        
             owner = "nvim-tree";

     

       7408
       7408
        
             repo = "nvim-web-devicons";

     

       7409
       7409
       -
             rev = "9ab9b0b894b2388a9dbcdee5f00ce72e25d85bf9";

     

       7410
       7410
       -
             sha256 = "1i40jzpx710amxm7hgy0ac8pda6bsmkm4r110z691c1l0i90ppwl";

     

       7409
       7409
       +
             rev = "efbfed0567ef4bfac3ce630524a0f6c8451c5534";

     

       7410
       7410
       +
             sha256 = "12hi19zdwflqqg81n35b696hqalbyxvskf7w8qzygcxg3830kl8n";

     

       7411
       7411
        
           };

     

       7412
       7412
        
           meta.homepage = "https://github.com/nvim-tree/nvim-web-devicons/";

     

       7413
       7413
        
         };

     
···

       7510
       7510
        
       

     

       7511
       7511
        
         oil-nvim = buildVimPluginFrom2Nix {

     

       7512
       7512
        
           pname = "oil.nvim";

     

       7513
       7513
       -
           version = "2023-06-30";

     

       7513
       7513
       +
           version = "2023-07-18";

     

       7514
       7514
        
           src = fetchFromGitHub {

     

       7515
       7515
        
             owner = "stevearc";

     

       7516
       7516
        
             repo = "oil.nvim";

     

       7517
       7517
       -
             rev = "a5ff72a8da0df1042ee4c7705c301901062fa6d5";

     

       7518
       7518
       -
             sha256 = "105ldc37iywalh82snfr3rk750hz7vszi01ipzbfzd8hqvwr930g";

     

       7517
       7517
       +
             rev = "eaa20a6aee7c4df89d80ec8208de63ec2fa4d38a";

     

       7518
       7518
       +
             sha256 = "0zyp32nb0xa882i6rjwgs94icpmwpww22g7v1laz0ldm4vkn0qlj";

     

       7519
       7519
        
             fetchSubmodules = true;

     

       7520
       7520
        
           };

     

       7521
       7521
        
           meta.homepage = "https://github.com/stevearc/oil.nvim/";

     
···

       7547
       7547
        
       

     

       7548
       7548
        
         onedark-nvim = buildVimPluginFrom2Nix {

     

       7549
       7549
        
           pname = "onedark.nvim";

     

       7550
       7550
       -
           version = "2023-06-12";

     

       7550
       7550
       +
           version = "2023-07-13";

     

       7551
       7551
        
           src = fetchFromGitHub {

     

       7552
       7552
        
             owner = "navarasu";

     

       7553
       7553
        
             repo = "onedark.nvim";

     

       7554
       7554
       -
             rev = "462b45758ea94ff30ad48979268094590a6b7b7e";

     

       7555
       7555
       -
             sha256 = "0m7alckgwnqzv9zycrvpisnx8bg2n8057j8lvqjmx4fagfnr8nmh";

     

       7554
       7554
       +
             rev = "cae5fdf035ee92c407a29ee2ccfcff503d2be7f1";

     

       7555
       7555
       +
             sha256 = "0vnsihlwq930hm8f8j6h4ixbk4rrrmqjlkw9q5nd3x38k899iz0x";

     

       7556
       7556
        
           };

     

       7557
       7557
        
           meta.homepage = "https://github.com/navarasu/onedark.nvim/";

     

       7558
       7558
        
         };

     
···

       7847
       7847
        
       

     

       7848
       7848
        
         plenary-nvim = buildNeovimPlugin {

     

       7849
       7849
        
           pname = "plenary.nvim";

     

       7850
       7850
       -
           version = "2023-07-06";

     

       7850
       7850
       +
           version = "2023-07-17";

     

       7851
       7851
        
           src = fetchFromGitHub {

     

       7852
       7852
        
             owner = "nvim-lua";

     

       7853
       7853
        
             repo = "plenary.nvim";

     

       7854
       7854
       -
             rev = "bda256fab0eb66a15e8190937e417e6a14ee5d72";

     

       7855
       7855
       -
             sha256 = "1rsybpshyvzrfzn4dnbhqawn7inrmsfb84rmsklf781chzfjp49l";

     

       7854
       7854
       +
             rev = "267282a9ce242bbb0c5dc31445b6d353bed978bb";

     

       7855
       7855
       +
             sha256 = "10pw38dfzjrwzwkby9jmghafwwcph3az5z3h9c8v5kjh8iqls6x1";

     

       7856
       7856
        
           };

     

       7857
       7857
        
           meta.homepage = "https://github.com/nvim-lua/plenary.nvim/";

     

       7858
       7858
        
         };

     
···

       8161
       8161
        
       

     

       8162
       8162
        
         refactoring-nvim = buildVimPluginFrom2Nix {

     

       8163
       8163
        
           pname = "refactoring.nvim";

     

       8164
       8164
       -
           version = "2023-06-28";

     

       8164
       8164
       +
           version = "2023-07-14";

     

       8165
       8165
        
           src = fetchFromGitHub {

     

       8166
       8166
        
             owner = "theprimeagen";

     

       8167
       8167
        
             repo = "refactoring.nvim";

     

       8168
       8168
       -
             rev = "859289acc0fda13bf42834dbeef10b8c1148d444";

     

       8169
       8169
       -
             sha256 = "0nipkn9yfgy3606kkaiyq6rvmasq4jmivdnhr102bl86xsccm4yw";

     

       8168
       8168
       +
             rev = "7894b10078a1a70c9b26028f4373bf209968e9bc";

     

       8169
       8169
       +
             sha256 = "1bmqmxdp5940b9ymp73zjf1sl1m5405insj2v9jssx1cbby8pf14";

     

       8170
       8170
        
           };

     

       8171
       8171
        
           meta.homepage = "https://github.com/theprimeagen/refactoring.nvim/";

     

       8172
       8172
        
         };

     
···

       8209
       8209
        
       

     

       8210
       8210
        
         rest-nvim = buildNeovimPlugin {

     

       8211
       8211
        
           pname = "rest.nvim";

     

       8212
       8212
       -
           version = "2023-07-11";

     

       8212
       8212
       +
           version = "2023-07-16";

     

       8213
       8213
        
           src = fetchFromGitHub {

     

       8214
       8214
        
             owner = "rest-nvim";

     

       8215
       8215
        
             repo = "rest.nvim";

     

       8216
       8216
       -
             rev = "80283b7e384a533ff8296a97362f7b1a1c1af83f";

     

       8217
       8217
       -
             sha256 = "0a6vjc2dsj724nxi8szhhqx178ghif08qgib4g8lrvlix1lw56a8";

     

       8216
       8216
       +
             rev = "22673c848768ff25517154a5aebfebc0c77d0b4f";

     

       8217
       8217
       +
             sha256 = "1arfcrq4vh3hp4g8s6qib25cykn7v9ywfb8nv9mh8nivqryvmwvq";

     

       8218
       8218
        
           };

     

       8219
       8219
        
           meta.homepage = "https://github.com/rest-nvim/rest.nvim/";

     

       8220
       8220
        
         };

     
···

       8341
       8341
        
       

     

       8342
       8342
        
         satellite-nvim = buildVimPluginFrom2Nix {

     

       8343
       8343
        
           pname = "satellite.nvim";

     

       8344
       8344
       -
           version = "2023-07-11";

     

       8344
       8344
       +
           version = "2023-07-16";

     

       8345
       8345
        
           src = fetchFromGitHub {

     

       8346
       8346
        
             owner = "lewis6991";

     

       8347
       8347
        
             repo = "satellite.nvim";

     

       8348
       8348
       -
             rev = "eda3a7014a948e36c330934c7d49c7d86b2fb71d";

     

       8349
       8349
       -
             sha256 = "0rfasa1rzyrjid8nl0dzd7prj5ys0mg768znlsdhmn9wnh2lmnll";

     

       8348
       8348
       +
             rev = "723b893a5a2c1e2b77a82df229c19b57f33638e8";

     

       8349
       8349
       +
             sha256 = "0skzfg4y3ws4904b0kxlzzlqs0k6s072drhhiwrddlr6fjglpk5f";

     

       8350
       8350
        
           };

     

       8351
       8351
        
           meta.homepage = "https://github.com/lewis6991/satellite.nvim/";

     

       8352
       8352
        
         };

     
···

       8473
       8473
        
       

     

       8474
       8474
        
         sg-nvim = buildVimPluginFrom2Nix {

     

       8475
       8475
        
           pname = "sg.nvim";

     

       8476
       8476
       -
           version = "2023-06-28";

     

       8476
       8476
       +
           version = "2023-07-17";

     

       8477
       8477
        
           src = fetchFromGitHub {

     

       8478
       8478
        
             owner = "sourcegraph";

     

       8479
       8479
        
             repo = "sg.nvim";

     

       8480
       8480
       -
             rev = "3574508d9a48caeb8813bd58080024b8363589ce";

     

       8481
       8481
       -
             sha256 = "0s53nxvcyjp90frcvlpfpl5sn9x28kqfiw80bj2j8dbhkmz395k7";

     

       8480
       8480
       +
             rev = "fb17fe40387ff201d82fb7e10ddddb25a50ffbca";

     

       8481
       8481
       +
             sha256 = "1agi4d0wpmm5jz20ysv2m72mjxbns1rcb6xrgjc9g8rzxxsd58vz";

     

       8482
       8482
        
           };

     

       8483
       8483
        
           meta.homepage = "https://github.com/sourcegraph/sg.nvim/";

     

       8484
       8484
        
         };

     
···

       8750
       8750
        
       

     

       8751
       8751
        
         splitjoin-vim = buildVimPluginFrom2Nix {

     

       8752
       8752
        
           pname = "splitjoin.vim";

     

       8753
       8753
       -
           version = "2023-06-25";

     

       8753
       8753
       +
           version = "2023-07-12";

     

       8754
       8754
        
           src = fetchFromGitHub {

     

       8755
       8755
        
             owner = "AndrewRadev";

     

       8756
       8756
        
             repo = "splitjoin.vim";

     

       8757
       8757
       -
             rev = "95a700875530a1ad87232e472fab307ee2a553ba";

     

       8758
       8758
       -
             sha256 = "0gpj66dwx7qf7gk6qp7sxabfykfq5b8qgzcwm097mv1kzxyp9fxl";

     

       8757
       8757
       +
             rev = "4073ac528b5e552a6b4347cacca9899f74b98843";

     

       8758
       8758
       +
             sha256 = "1sa4dmckx44l6dhmxwgs9nslwz752fhslr2y84zb7gdjqd9w3wmm";

     

       8759
       8759
        
             fetchSubmodules = true;

     

       8760
       8760
        
           };

     

       8761
       8761
        
           meta.homepage = "https://github.com/AndrewRadev/splitjoin.vim/";

     
···

       9439
       9439
        
       

     

       9440
       9440
        
         telescope-nvim = buildNeovimPlugin {

     

       9441
       9441
        
           pname = "telescope.nvim";

     

       9442
       9442
       -
           version = "2023-07-06";

     

       9442
       9442
       +
           version = "2023-07-17";

     

       9443
       9443
        
           src = fetchFromGitHub {

     

       9444
       9444
        
             owner = "nvim-telescope";

     

       9445
       9445
        
             repo = "telescope.nvim";

     

       9446
       9446
       -
             rev = "276362a8020c6e94c7a76d49aa00d4923b0c02f3";

     

       9447
       9447
       -
             sha256 = "043rrifqhg5bsksqhfdc20f96i2s2xyd6qyga4918fr75sf8hmib";

     

       9446
       9446
       +
             rev = "47c755d737702df7a39b640c8d9c473a728be1df";

     

       9447
       9447
       +
             sha256 = "0k81q31y3r4kcaxrxami1f8ms4zn8ai61rvqhrlz5yvn4rcplnhy";

     

       9448
       9448
        
           };

     

       9449
       9449
        
           meta.homepage = "https://github.com/nvim-telescope/telescope.nvim/";

     

       9450
       9450
        
         };

     
···

       9692
       9692
        
       

     

       9693
       9693
        
         toggleterm-nvim = buildVimPluginFrom2Nix {

     

       9694
       9694
        
           pname = "toggleterm.nvim";

     

       9695
       9695
       -
           version = "2023-07-10";

     

       9695
       9695
       +
           version = "2023-07-17";

     

       9696
       9696
        
           src = fetchFromGitHub {

     

       9697
       9697
        
             owner = "akinsho";

     

       9698
       9698
        
             repo = "toggleterm.nvim";

     

       9699
       9699
       -
             rev = "83aa231fa414a5dcb72aed97437446a6ca5a81f2";

     

       9700
       9700
       -
             sha256 = "0dhbc9s9irzamlv7b8qdamixvh4nf1p7icszdbd8jwks9dfhm9mk";

     

       9699
       9699
       +
             rev = "00c13dccc78c09fa5da4c5edda990a363e75035e";

     

       9700
       9700
       +
             sha256 = "0fvz9rp8rr63pimhpzyx5a05qbgyzixbbglpvkd137bpvya2xigy";

     

       9701
       9701
        
           };

     

       9702
       9702
        
           meta.homepage = "https://github.com/akinsho/toggleterm.nvim/";

     

       9703
       9703
        
         };

     

       9704
       9704
        
       

     

       9705
       9705
        
         tokyonight-nvim = buildVimPluginFrom2Nix {

     

       9706
       9706
        
           pname = "tokyonight.nvim";

     

       9707
       9707
       -
           version = "2023-07-05";

     

       9707
       9707
       +
           version = "2023-07-13";

     

       9708
       9708
        
           src = fetchFromGitHub {

     

       9709
       9709
        
             owner = "folke";

     

       9710
       9710
        
             repo = "tokyonight.nvim";

     

       9711
       9711
       -
             rev = "284667adfff02b9a0adc65968c553c6096b543b6";

     

       9712
       9712
       -
             sha256 = "0r9scw1r8vd761pqf9zl2aly70xc04h8fqy17ra49p879sx254wd";

     

       9711
       9711
       +
             rev = "1ee11019f8a81dac989ae1db1a013e3d582e2033";

     

       9712
       9712
       +
             sha256 = "0ygrwps4riq37wxwzplw2jyxi7qc7yagypfd444vp0vklqnslvn7";

     

       9713
       9713
        
           };

     

       9714
       9714
        
           meta.homepage = "https://github.com/folke/tokyonight.nvim/";

     

       9715
       9715
        
         };

     
···

       9776
       9776
        
       

     

       9777
       9777
        
         trouble-nvim = buildVimPluginFrom2Nix {

     

       9778
       9778
        
           pname = "trouble.nvim";

     

       9779
       9779
       -
           version = "2023-06-24";

     

       9779
       9779
       +
           version = "2023-07-16";

     

       9780
       9780
        
           src = fetchFromGitHub {

     

       9781
       9781
        
             owner = "folke";

     

       9782
       9782
        
             repo = "trouble.nvim";

     

       9783
       9783
       -
             rev = "d99e2abd10808ef91738ce98a5c767e6a51df449";

     

       9784
       9784
       -
             sha256 = "0j5ypv22qahic4lch0k3vssxwnbdngyx2b5h532yn4jkjlph5y0y";

     

       9783
       9783
       +
             rev = "20d1b30d6925213abece21d35858a16e11d1e9fc";

     

       9784
       9784
       +
             sha256 = "0d040c803p81dfscla5xzf3nzldxl9aflvm6gj6byp8l6lmc1w49";

     

       9785
       9785
        
           };

     

       9786
       9786
        
           meta.homepage = "https://github.com/folke/trouble.nvim/";

     

       9787
       9787
        
         };

     
···

       9908
       9908
        
       

     

       9909
       9909
        
         unison = buildVimPluginFrom2Nix {

     

       9910
       9910
        
           pname = "unison";

     

       9911
       9911
       -
           version = "2023-07-10";

     

       9911
       9911
       +
           version = "2023-07-14";

     

       9912
       9912
        
           src = fetchFromGitHub {

     

       9913
       9913
        
             owner = "unisonweb";

     

       9914
       9914
        
             repo = "unison";

     

       9915
       9915
       -
             rev = "2db2ff26f1537d75e9c20e594344c4ea8459d344";

     

       9916
       9916
       -
             sha256 = "13xl7winslmalasc01x69zdnhr1q6amzg7808hmc97vj770y85rm";

     

       9915
       9915
       +
             rev = "e70a94267ac18d9552984f39bcf05a0eac17827f";

     

       9916
       9916
       +
             sha256 = "0sbf6r98ya7n7pmmqy8kk2n4ks55024x25xp9hm5f62dbnaz1i52";

     

       9917
       9917
        
           };

     

       9918
       9918
        
           meta.homepage = "https://github.com/unisonweb/unison/";

     

       9919
       9919
        
         };

     
···

       10352
       10352
        
       

     

       10353
       10353
        
         vim-airline = buildVimPluginFrom2Nix {

     

       10354
       10354
        
           pname = "vim-airline";

     

       10355
       10355
       -
           version = "2023-05-25";

     

       10355
       10355
       +
           version = "2023-07-13";

     

       10356
       10356
        
           src = fetchFromGitHub {

     

       10357
       10357
        
             owner = "vim-airline";

     

       10358
       10358
        
             repo = "vim-airline";

     

       10359
       10359
       -
             rev = "423fe9e2acbe64bd8637d0bedff132972d7603de";

     

       10360
       10360
       -
             sha256 = "0cy78kd37q9nzk9f9f3k2aip1bvrcqra4ka02v2pnyr4a00iripj";

     

       10359
       10359
       +
             rev = "cead8efb48fbd770757f74246fefd1a3c7bec8ef";

     

       10360
       10360
       +
             sha256 = "19h1y2wrapn3ig6ppm4rhjf0fw585dz5xqs2ajrxk63wwyfrrf71";

     

       10361
       10361
        
           };

     

       10362
       10362
        
           meta.homepage = "https://github.com/vim-airline/vim-airline/";

     

       10363
       10363
        
         };

     
···

       11588
       11588
        
       

     

       11589
       11589
        
         vim-fugitive = buildVimPluginFrom2Nix {

     

       11590
       11590
        
           pname = "vim-fugitive";

     

       11591
       11591
       -
           version = "2023-06-12";

     

       11591
       11591
       +
           version = "2023-07-04";

     

       11592
       11592
        
           src = fetchFromGitHub {

     

       11593
       11593
        
             owner = "tpope";

     

       11594
       11594
        
             repo = "vim-fugitive";

     

       11595
       11595
       -
             rev = "43f18ab9155c853a84ded560c6104e6300ad41da";

     

       11596
       11596
       -
             sha256 = "0s9kyid27bvpqb44hirqvjp33lf7hihw7yj0s2kwv9aif0k6mbw0";

     

       11595
       11595
       +
             rev = "b3b838d690f315a503ec4af8c634bdff3b200aaf";

     

       11596
       11596
       +
             sha256 = "1y4jvrja0d77hsr24mb9bfgls5vy12r8g2bmsbsx40zvmwnlh294";

     

       11597
       11597
        
           };

     

       11598
       11598
        
           meta.homepage = "https://github.com/tpope/vim-fugitive/";

     

       11599
       11599
        
         };

     
···

       11696
       11696
        
       

     

       11697
       11697
        
         vim-gitgutter = buildVimPluginFrom2Nix {

     

       11698
       11698
        
           pname = "vim-gitgutter";

     

       11699
       11699
       -
           version = "2023-06-16";

     

       11699
       11699
       +
           version = "2023-07-14";

     

       11700
       11700
        
           src = fetchFromGitHub {

     

       11701
       11701
        
             owner = "airblade";

     

       11702
       11702
        
             repo = "vim-gitgutter";

     

       11703
       11703
       -
             rev = "4a7ca061af2b199a9b97041270611439e8fa2b02";

     

       11704
       11704
       -
             sha256 = "1pqn6g925i4a88d4n9hxjb9fwr7ib7mwslxhl3cphzk0986ncdjf";

     

       11703
       11703
       +
             rev = "8a2f8199b689b93fe4391a8ba1d97dd84b86ebd6";

     

       11704
       11704
       +
             sha256 = "1jxp27mmp84gkjll0h96q9zbh8gs1dsb46cvqnbqvag1p3laxxlq";

     

       11705
       11705
        
           };

     

       11706
       11706
        
           meta.homepage = "https://github.com/airblade/vim-gitgutter/";

     

       11707
       11707
        
         };

     
···

       12129
       12129
        
       

     

       12130
       12130
        
         vim-isort = buildVimPluginFrom2Nix {

     

       12131
       12131
        
           pname = "vim-isort";

     

       12132
       12132
       -
           version = "2020-08-14";

     

       12132
       12132
       +
           version = "2023-07-12";

     

       12133
       12133
        
           src = fetchFromGitHub {

     

       12134
       12134
        
             owner = "fisadev";

     

       12135
       12135
        
             repo = "vim-isort";

     

       12136
       12136
       -
             rev = "94b1f1202899aa0b6e2cc20e6d1f133eafe24331";

     

       12137
       12137
       -
             sha256 = "16r2nsdapf3r0zjqwwbl0k8g2p81h9zs14b91dhskyvs0hvf7cfy";

     

       12136
       12136
       +
             rev = "757c2c830ba0365167460c26f304f3472dfa2ce2";

     

       12137
       12137
       +
             sha256 = "01la7hmf9z9iqv1n4lmsihsny6wsjzqa5c7prws88jkmryrvjxdb";

     

       12138
       12138
        
           };

     

       12139
       12139
        
           meta.homepage = "https://github.com/fisadev/vim-isort/";

     

       12140
       12140
        
         };

     
···

       12322
       12322
        
       

     

       12323
       12323
        
         vim-just = buildVimPluginFrom2Nix {

     

       12324
       12324
        
           pname = "vim-just";

     

       12325
       12325
       -
           version = "2023-07-09";

     

       12325
       12325
       +
           version = "2023-07-14";

     

       12326
       12326
        
           src = fetchFromGitHub {

     

       12327
       12327
        
             owner = "NoahTheDuke";

     

       12328
       12328
        
             repo = "vim-just";

     

       12329
       12329
       -
             rev = "ceabb579cf085cee5ebd361625c237cb565f5af3";

     

       12330
       12330
       -
             sha256 = "04vs5zl8l5pvddk267jfkzlkghiddn5pqgjf2aw86yfaaxg6i8r4";

     

       12329
       12329
       +
             rev = "f678f5ef3d6bc589e88b7f1da6e969a5f67a99dc";

     

       12330
       12330
       +
             sha256 = "1929imvqk77zi34x9h0kfvhwn7gagimsn2gr3zs0nq0ynfpx5h54";

     

       12331
       12331
        
           };

     

       12332
       12332
        
           meta.homepage = "https://github.com/NoahTheDuke/vim-just/";

     

       12333
       12333
        
         };

     
···

       12695
       12695
        
       

     

       12696
       12696
        
         vim-matchup = buildVimPluginFrom2Nix {

     

       12697
       12697
        
           pname = "vim-matchup";

     

       12698
       12698
       -
           version = "2023-07-11";

     

       12698
       12698
       +
           version = "2023-07-12";

     

       12699
       12699
        
           src = fetchFromGitHub {

     

       12700
       12700
        
             owner = "andymass";

     

       12701
       12701
        
             repo = "vim-matchup";

     

       12702
       12702
       -
             rev = "3c4ccc489002fe72b5d2e2ffc4b3b5a7d3ab65d8";

     

       12703
       12703
       -
             sha256 = "0mpvqlk8a7vms2j29mpfpkqa1pxsncqr7flsg6q6z3cdqcrgh1j2";

     

       12702
       12702
       +
             rev = "17cc05867cb3314761e4baa20115a27120f8e82c";

     

       12703
       12703
       +
             sha256 = "0hxp9akqxz7h2ly1qpiviqbgbk52mbxk88vvq6rxf2kb12sgbiag";

     

       12704
       12704
        
           };

     

       12705
       12705
        
           meta.homepage = "https://github.com/andymass/vim-matchup/";

     

       12706
       12706
        
         };

     
···

       13955
       13955
        
       

     

       13956
       13956
        
         vim-sneak = buildVimPluginFrom2Nix {

     

       13957
       13957
        
           pname = "vim-sneak";

     

       13958
       13958
       -
           version = "2022-10-27";

     

       13958
       13958
       +
           version = "2023-07-12";

     

       13959
       13959
        
           src = fetchFromGitHub {

     

       13960
       13960
        
             owner = "justinmk";

     

       13961
       13961
        
             repo = "vim-sneak";

     

       13962
       13962
       -
             rev = "93395f5b56eb203e4c8346766f258ac94ea81702";

     

       13963
       13963
       -
             sha256 = "0aylgy7k8k6f058z3zmz9vsmigff5f6lfjzciqyccksjaji9c0kr";

     

       13962
       13962
       +
             rev = "29ec9167d4a609f74c130b46265aa17eb2736e6a";

     

       13963
       13963
       +
             sha256 = "1n7y5i8zbr04n48n0l4k1xp76pgrbd2lx0pnj4278ply88hgfg9f";

     

       13964
       13964
        
           };

     

       13965
       13965
        
           meta.homepage = "https://github.com/justinmk/vim-sneak/";

     

       13966
       13966
        
         };

     
···

       15001
       15001
        
       

     

       15002
       15002
        
         vimtex = buildVimPluginFrom2Nix {

     

       15003
       15003
        
           pname = "vimtex";

     

       15004
       15004
       -
           version = "2023-07-05";

     

       15004
       15004
       +
           version = "2023-07-16";

     

       15005
       15005
        
           src = fetchFromGitHub {

     

       15006
       15006
        
             owner = "lervag";

     

       15007
       15007
        
             repo = "vimtex";

     

       15008
       15008
       -
             rev = "bab96ed04dd951b22663b08c670ff33960fc6419";

     

       15009
       15009
       -
             sha256 = "1mpy9wqdy3bpgsd1727pn2nxpjhhxlazfhcykccqcjnx2m1k00wa";

     

       15008
       15008
       +
             rev = "5e50cc0e96e8a8ffc6fd10d627d65b8d1354b5da";

     

       15009
       15009
       +
             sha256 = "1w8q37akfwid53blhznai6521hys1xyv3w7ivd9nq099zmxfz8qy";

     

       15010
       15010
        
           };

     

       15011
       15011
        
           meta.homepage = "https://github.com/lervag/vimtex/";

     

       15012
       15012
        
         };

     
···

       15121
       15121
        
       

     

       15122
       15122
        
         which-key-nvim = buildVimPluginFrom2Nix {

     

       15123
       15123
        
           pname = "which-key.nvim";

     

       15124
       15124
       -
           version = "2023-06-19";

     

       15124
       15124
       +
           version = "2023-07-16";

     

       15125
       15125
        
           src = fetchFromGitHub {

     

       15126
       15126
        
             owner = "folke";

     

       15127
       15127
        
             repo = "which-key.nvim";

     

       15128
       15128
       -
             rev = "d871f2b664afd5aed3dc1d1573bef2fb24ce0484";

     

       15129
       15129
       -
             sha256 = "00078wm0j2d2yzfqr1lvc7iawkzznbfzf7gq3c0g497pzhvhgl2q";

     

       15128
       15128
       +
             rev = "38b990f6eabf62014018b4aae70a97d7a6c2eb88";

     

       15129
       15129
       +
             sha256 = "08j58jc3ja1hbg15raj2xg3ff3wyjf09i42qda84b1iq0klrlxnp";

     

       15130
       15130
        
           };

     

       15131
       15131
        
           meta.homepage = "https://github.com/folke/which-key.nvim/";

     

       15132
       15132
        
         };

     
···

       15157
       15157
        
       

     

       15158
       15158
        
         wiki-vim = buildVimPluginFrom2Nix {

     

       15159
       15159
        
           pname = "wiki.vim";

     

       15160
       15160
       -
           version = "2023-07-06";

     

       15160
       15160
       +
           version = "2023-07-17";

     

       15161
       15161
        
           src = fetchFromGitHub {

     

       15162
       15162
        
             owner = "lervag";

     

       15163
       15163
        
             repo = "wiki.vim";

     

       15164
       15164
       -
             rev = "ba0dfb47cdd3018df2cc46ce045e93b5fbb394ca";

     

       15165
       15165
       -
             sha256 = "0gchas7sfb602cmwwqfbzd7g65ph1vvj1rc2rq5b828ncqin7ww5";

     

       15164
       15164
       +
             rev = "89f3f50bef0a461082d73f93ec0f3c0a0981a0b1";

     

       15165
       15165
       +
             sha256 = "19xqlak0n1apdjwxlbqv8bvvg2p1ciqbpkvdjlp62sq1a289wxaq";

     

       15166
       15166
        
           };

     

       15167
       15167
        
           meta.homepage = "https://github.com/lervag/wiki.vim/";

     

       15168
       15168
        
         };

     
···

       15446
       15446
        
       

     

       15447
       15447
        
         catppuccin-nvim = buildVimPluginFrom2Nix {

     

       15448
       15448
        
           pname = "catppuccin-nvim";

     

       15449
       15449
       -
           version = "2023-07-11";

     

       15449
       15449
       +
           version = "2023-07-17";

     

       15450
       15450
        
           src = fetchFromGitHub {

     

       15451
       15451
        
             owner = "catppuccin";

     

       15452
       15452
        
             repo = "nvim";

     

       15453
       15453
       -
             rev = "3ffd2f511f3dc6c01258923d7170ccaf1445634b";

     

       15454
       15454
       -
             sha256 = "0ry208p1lib2rnmfcph1k29lvm6cccnjvbbzmwrhjkp97m54ricl";

     

       15453
       15453
       +
             rev = "bfe91dfb3a19ffd4445e43611fcde68acbb3fed4";

     

       15454
       15454
       +
             sha256 = "00ijlgn3fz2y1f4wncjqrmfw902csshq46xvg7283yfzmf1rwzy8";

     

       15455
       15455
        
           };

     

       15456
       15456
        
           meta.homepage = "https://github.com/catppuccin/nvim/";

     

       15457
       15457
        
         };

     
···

       15506
       15506
        
       

     

       15507
       15507
        
         lspsaga-nvim-original = buildVimPluginFrom2Nix {

     

       15508
       15508
        
           pname = "lspsaga-nvim-original";

     

       15509
       15509
       -
           version = "2023-07-11";

     

       15509
       15509
       +
           version = "2023-07-16";

     

       15510
       15510
        
           src = fetchFromGitHub {

     

       15511
       15511
        
             owner = "nvimdev";

     

       15512
       15512
        
             repo = "lspsaga.nvim";

     

       15513
       15513
       -
             rev = "bed04d06547910b288f25c153b9bb181fecf52fa";

     

       15514
       15514
       -
             sha256 = "1l8x8gp40kpz35rizr0lx003pdv7rv32gr5imvyhlcdvg88g72ls";

     

       15513
       15513
       +
             rev = "95ec55dfd5355c90f1cee834bd415e1d2b5d9854";

     

       15514
       15514
       +
             sha256 = "129kb1dl0d0fh48xc42dcv17phg9dnmvfya1n9qc9p6721ymjm3y";

     

       15515
       15515
        
           };

     

       15516
       15516
        
           meta.homepage = "https://github.com/nvimdev/lspsaga.nvim/";

     

       15517
       15517
        
         };

     
···

       15554
       15554
        
       

     

       15555
       15555
        
         nvchad-ui = buildVimPluginFrom2Nix {

     

       15556
       15556
        
           pname = "nvchad-ui";

     

       15557
       15557
       -
           version = "2023-06-18";

     

       15557
       15557
       +
           version = "2023-07-14";

     

       15558
       15558
        
           src = fetchFromGitHub {

     

       15559
       15559
        
             owner = "nvchad";

     

       15560
       15560
        
             repo = "ui";

     

       15561
       15561
       -
             rev = "53b0d0b0e2a30e730865110eb2128dcfee7b87f6";

     

       15562
       15562
       -
             sha256 = "04vvklyiy9crg89flfmhkrf907d66j1pf050vzxbw2kida888lc5";

     

       15561
       15561
       +
             rev = "5545a7ef32cec4147c75156e59afd293305f639d";

     

       15562
       15562
       +
             sha256 = "1ysx0zic7jvlxidjghc1k2vrigh93d1wnqf74xgb14xzsrs3bgc6";

     

       15563
       15563
        
           };

     

       15564
       15564
        
           meta.homepage = "https://github.com/nvchad/ui/";

     

       15565
       15565
        
         };

     
···

       15590
       15590
        
       

     

       15591
       15591
        
         rose-pine = buildVimPluginFrom2Nix {

     

       15592
       15592
        
           pname = "rose-pine";

     

       15593
       15593
       -
           version = "2023-06-21";

     

       15593
       15593
       +
           version = "2023-07-15";

     

       15594
       15594
        
           src = fetchFromGitHub {

     

       15595
       15595
        
             owner = "rose-pine";

     

       15596
       15596
        
             repo = "neovim";

     

       15597
       15597
       -
             rev = "932adb0d9351186db047302de021bb2976756a07";

     

       15598
       15598
       -
             sha256 = "1kfq83vr483cizx14gghvckwnh44x20jbvqjac1y60fmk8b18plb";

     

       15597
       15597
       +
             rev = "76cae45b4e6716ee93afc78bd3860134935ea9d7";

     

       15598
       15598
       +
             sha256 = "0kxn0yx5qgygrdalvmhhzxfvdm275fbqbghni0anv919z052ghqk";

     

       15599
       15599
        
           };

     

       15600
       15600
        
           meta.homepage = "https://github.com/rose-pine/neovim/";

     

       15601
       15601
        
         };

+100 -89

pkgs/applications/editors/vim/plugins/nvim-treesitter/generated.nix

···

       27
       27
        
         };

     

       28
       28
        
         arduino = buildGrammar {

     

       29
       29
        
           language = "arduino";

     

       30
       30
       -
           version = "0.0.0+rev=787bc6e";

     

       30
       30
       +
           version = "0.0.0+rev=4de2f3e";

     

       31
       31
        
           src = fetchFromGitHub {

     

       32
       32
        
             owner = "ObserverOfTime";

     

       33
       33
        
             repo = "tree-sitter-arduino";

     

       34
       34
       -
             rev = "787bc6e1ca23092821231f6096438343f728ee6f";

     

       35
       35
       -
             hash = "sha256-PKjSNEy27Snu9B2eBZcOQYNXI/cnKhFdrBrePqcp7Rk=";

     

       34
       34
       +
             rev = "4de2f3e6235ee8659ecb7467c16ed13bde7fb272";

     

       35
       35
       +
             hash = "sha256-DeUp7M96PHQ652tvWSnsu1rSaQJyCCojAYfplccbJTc=";

     

       36
       36
        
           };

     

       37
       37
        
           meta.homepage = "https://github.com/ObserverOfTime/tree-sitter-arduino";

     

       38
       38
        
         };

     
···

       126
       126
        
         };

     

       127
       127
        
         c = buildGrammar {

     

       128
       128
        
           language = "c";

     

       129
       129
       -
           version = "0.0.0+rev=a60f1dd";

     

       129
       129
       +
           version = "0.0.0+rev=6adee19";

     

       130
       130
        
           src = fetchFromGitHub {

     

       131
       131
        
             owner = "tree-sitter";

     

       132
       132
        
             repo = "tree-sitter-c";

     

       133
       133
       -
             rev = "a60f1ddef4702fc8a82a9bfc207d0cf453d748bb";

     

       134
       134
       -
             hash = "sha256-7MNTbIQT+7ksV2vmrIZzBZM1BlCdGI7P0DYw0sP6hvU=";

     

       133
       133
       +
             rev = "6adee194587678b250608cdb808544f06bcd26e7";

     

       134
       134
       +
             hash = "sha256-A3bLZxkCru7uAOtz9J3I/nsIoRRWmoUUiPGaLtljrqw=";

     

       135
       135
        
           };

     

       136
       136
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-c";

     

       137
       137
        
         };

     
···

       159
       159
        
         };

     

       160
       160
        
         capnp = buildGrammar {

     

       161
       161
        
           language = "capnp";

     

       162
       162
       -
           version = "0.0.0+rev=7d5fa4e";

     

       162
       162
       +
           version = "0.0.0+rev=dc28c9f";

     

       163
       163
        
           src = fetchFromGitHub {

     

       164
       164
        
             owner = "amaanq";

     

       165
       165
        
             repo = "tree-sitter-capnp";

     

       166
       166
       -
             rev = "7d5fa4e94d3643ec15750106113be0d40f9fc1bb";

     

       167
       167
       -
             hash = "sha256-K83xouIGsv9EDLp4MSH9i6JE/GlAT72i3eJa58vR2gs=";

     

       166
       166
       +
             rev = "dc28c9f4212809eab74d10996086297853eb34e5";

     

       167
       167
       +
             hash = "sha256-4GcOBC5JJsfbdsIrQd33tSW2sz6ytjYGqWgFVFLH6sc=";

     

       168
       168
        
           };

     

       169
       169
        
           meta.homepage = "https://github.com/amaanq/tree-sitter-capnp";

     

       170
       170
        
         };

     
···

       280
       280
        
         };

     

       281
       281
        
         cuda = buildGrammar {

     

       282
       282
        
           language = "cuda";

     

       283
       283
       -
           version = "0.0.0+rev=c9ba632";

     

       283
       283
       +
           version = "0.0.0+rev=c5befe0";

     

       284
       284
        
           src = fetchFromGitHub {

     

       285
       285
        
             owner = "theHamsta";

     

       286
       286
        
             repo = "tree-sitter-cuda";

     

       287
       287
       -
             rev = "c9ba632aa68d24f32d2f97e356795f45f85e6c55";

     

       288
       288
       -
             hash = "sha256-2Wtkmlzhq+ShqFUnlofeFEN24toLaLD/O0/zSzbEZEE=";

     

       287
       287
       +
             rev = "c5befe09c99f5e88190574676ffa8eb29775d410";

     

       288
       288
       +
             hash = "sha256-wdv5TuNQl81n9CSyNkvAwCSPhfOs+DPwOT675WAphZE=";

     

       289
       289
        
           };

     

       290
       290
        
           meta.homepage = "https://github.com/theHamsta/tree-sitter-cuda";

     

       291
       291
        
         };

     
···

       403
       403
        
         };

     

       404
       404
        
         elixir = buildGrammar {

     

       405
       405
        
           language = "elixir";

     

       406
       406
       -
           version = "0.0.0+rev=7be3905";

     

       406
       406
       +
           version = "0.0.0+rev=2616034";

     

       407
       407
        
           src = fetchFromGitHub {

     

       408
       408
        
             owner = "elixir-lang";

     

       409
       409
        
             repo = "tree-sitter-elixir";

     

       410
       410
       -
             rev = "7be390548a870ca9cb1bd7f59ac92457bbec7bf5";

     

       411
       411
       -
             hash = "sha256-Id+c414ugW3PXOWx75ZMoN13qQdiyWs0cab9mNdT8/A=";

     

       410
       410
       +
             rev = "2616034f78ffa83ca6a521ebd7eee1868cb5c14c";

     

       411
       411
       +
             hash = "sha256-KY/qeIKWaXUCpA7hbK3ptfCg/cXoISa6mNYB7a0XY18=";

     

       412
       412
        
           };

     

       413
       413
        
           meta.homepage = "https://github.com/elixir-lang/tree-sitter-elixir";

     

       414
       414
        
         };

     
···

       438
       438
        
           language = "elvish";

     

       439
       439
        
           version = "0.0.0+rev=f32711e";

     

       440
       440
        
           src = fetchFromGitHub {

     

       441
       441
       -
             owner = "ckafi";

     

       441
       441
       +
             owner = "elves";

     

       442
       442
        
             repo = "tree-sitter-elvish";

     

       443
       443
        
             rev = "f32711e31e987fd5c2c002f3daba02f25c68672f";

     

       444
       444
        
             hash = "sha256-/3npcIfTH8w5ekLTb//ZCTxuSGhOXkUBaCq3WWcK2J4=";

     

       445
       445
        
           };

     

       446
       446
       -
           meta.homepage = "https://github.com/ckafi/tree-sitter-elvish";

     

       446
       446
       +
           meta.homepage = "https://github.com/elves/tree-sitter-elvish";

     

       447
       447
        
         };

     

       448
       448
        
         embedded_template = buildGrammar {

     

       449
       449
        
           language = "embedded_template";

     
···

       590
       590
        
         };

     

       591
       591
        
         gitattributes = buildGrammar {

     

       592
       592
        
           language = "gitattributes";

     

       593
       593
       -
           version = "0.0.0+rev=577a075";

     

       593
       593
       +
           version = "0.0.0+rev=19c716d";

     

       594
       594
        
           src = fetchFromGitHub {

     

       595
       595
        
             owner = "ObserverOfTime";

     

       596
       596
        
             repo = "tree-sitter-gitattributes";

     

       597
       597
       -
             rev = "577a075d46ea109905c5cb6179809df88da61ce9";

     

       598
       598
       -
             hash = "sha256-gBfLmNf7aaqMY3yMF7svFuqif43BAmmY1yYkvVcNUhI=";

     

       597
       597
       +
             rev = "19c716d2f45eac9529703413dc12aa8c76d13adc";

     

       598
       598
       +
             hash = "sha256-4fevdvH+Mi+MRURUcoDb9v511oaxBgP9U/OOODS/G+o=";

     

       599
       599
        
           };

     

       600
       600
        
           meta.homepage = "https://github.com/ObserverOfTime/tree-sitter-gitattributes";

     

       601
       601
        
         };

     
···

       645
       645
        
         };

     

       646
       646
        
         glsl = buildGrammar {

     

       647
       647
        
           language = "glsl";

     

       648
       648
       -
           version = "0.0.0+rev=53ca269";

     

       648
       648
       +
           version = "0.0.0+rev=7d76863";

     

       649
       649
        
           src = fetchFromGitHub {

     

       650
       650
        
             owner = "theHamsta";

     

       651
       651
        
             repo = "tree-sitter-glsl";

     

       652
       652
       -
             rev = "53ca269cae2a47b1b75791e2bfe843baeb02e903";

     

       653
       653
       -
             hash = "sha256-qDysihoyGlzAFvhnu6qOjNTIRT9ii/A1B1wNiZNlJs8=";

     

       652
       652
       +
             rev = "7d76863f2126ed3b246fead68f9591760d546c94";

     

       653
       653
       +
             hash = "sha256-X0Lqq7xrKEFVRAOh1AfvzeJQ5zv6RNwv583p69VkEpY=";

     

       654
       654
        
           };

     

       655
       655
        
           meta.homepage = "https://github.com/theHamsta/tree-sitter-glsl";

     

       656
       656
        
         };

     

       657
       657
        
         go = buildGrammar {

     

       658
       658
        
           language = "go";

     

       659
       659
       -
           version = "0.0.0+rev=7a4edcb";

     

       659
       659
       +
           version = "0.0.0+rev=8c8007e";

     

       660
       660
        
           src = fetchFromGitHub {

     

       661
       661
        
             owner = "tree-sitter";

     

       662
       662
        
             repo = "tree-sitter-go";

     

       663
       663
       -
             rev = "7a4edcbc376302efa8d6ba7e235070ab7ee3c4c8";

     

       664
       664
       -
             hash = "sha256-VvMsFU/HSccB7JetiuNj3O+K/vm6bmDwGWhozyec4Vc=";

     

       663
       663
       +
             rev = "8c8007eaee47702bb0291a3c7aeb004909baab4d";

     

       664
       664
       +
             hash = "sha256-K8mvDoQXSXwyyYQuwEcV6RBTZFbn4OSi7R1nGoQkDQU=";

     

       665
       665
        
           };

     

       666
       666
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-go";

     

       667
       667
        
         };

     
···

       722
       722
        
         };

     

       723
       723
        
         groovy = buildGrammar {

     

       724
       724
        
           language = "groovy";

     

       725
       725
       -
           version = "0.0.0+rev=54c7da8";

     

       725
       725
       +
           version = "0.0.0+rev=76e02db";

     

       726
       726
        
           src = fetchFromGitHub {

     

       727
       727
        
             owner = "Decodetalkers";

     

       728
       728
        
             repo = "tree-sitter-groovy";

     

       729
       729
       -
             rev = "54c7da8b167261e76c79513c0364a01836093526";

     

       730
       730
       -
             hash = "sha256-83JIW+oOKbpqormWiNjU6uI2WAknVnUAXNFSAvdq83o=";

     

       729
       729
       +
             rev = "76e02db5866dd2b096512103ed4d8f630cc32980";

     

       730
       730
       +
             hash = "sha256-H6Gp7MqGxU1oONq/w8p8pNR3Vhi68dvO+2aHw8anBTs=";

     

       731
       731
        
           };

     

       732
       732
        
           meta.homepage = "https://github.com/Decodetalkers/tree-sitter-groovy";

     

       733
       733
        
         };

     
···

       810
       810
        
         };

     

       811
       811
        
         hlsl = buildGrammar {

     

       812
       812
        
           language = "hlsl";

     

       813
       813
       -
           version = "0.0.0+rev=ddb6082";

     

       813
       813
       +
           version = "0.0.0+rev=b8fab02";

     

       814
       814
        
           src = fetchFromGitHub {

     

       815
       815
        
             owner = "theHamsta";

     

       816
       816
        
             repo = "tree-sitter-hlsl";

     

       817
       817
       -
             rev = "ddb608219fa99d56ed98de2d60f396f575cc6590";

     

       818
       818
       -
             hash = "sha256-UQTXdrHg4OfHnRgSAoo2gGZenE35NOypNeqUCsc4zdM=";

     

       817
       817
       +
             rev = "b8fab02e808bab41c49829fb5e4fb0ce7eab8d1a";

     

       818
       818
       +
             hash = "sha256-b/8KKGFqYj0gwDo3EgrRAufvXeuAEz6xvIBHBeVW0KE=";

     

       819
       819
        
           };

     

       820
       820
        
           meta.homepage = "https://github.com/theHamsta/tree-sitter-hlsl";

     

       821
       821
        
         };

     
···

       920
       920
        
         };

     

       921
       921
        
         java = buildGrammar {

     

       922
       922
        
           language = "java";

     

       923
       923
       -
           version = "0.0.0+rev=c194ee5";

     

       923
       923
       +
           version = "0.0.0+rev=6c8329e";

     

       924
       924
        
           src = fetchFromGitHub {

     

       925
       925
        
             owner = "tree-sitter";

     

       926
       926
        
             repo = "tree-sitter-java";

     

       927
       927
       -
             rev = "c194ee5e6ede5f26cf4799feead4a8f165dcf14d";

     

       928
       928
       -
             hash = "sha256-PNR1XajfELQuwYvCHm8778TzeUlxb9D+HrVF26lQk2E=";

     

       927
       927
       +
             rev = "6c8329e2da78fae78e87c3c6f5788a2b005a4afc";

     

       928
       928
       +
             hash = "sha256-pAo9hYhlLWjWB/n8nq/MzdMXbzOxcFzfrBCrj8xR/5g=";

     

       929
       929
        
           };

     

       930
       930
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-java";

     

       931
       931
        
         };

     

       932
       932
        
         javascript = buildGrammar {

     

       933
       933
        
           language = "javascript";

     

       934
       934
       -
           version = "0.0.0+rev=5720b24";

     

       934
       934
       +
           version = "0.0.0+rev=f772967";

     

       935
       935
        
           src = fetchFromGitHub {

     

       936
       936
        
             owner = "tree-sitter";

     

       937
       937
        
             repo = "tree-sitter-javascript";

     

       938
       938
       -
             rev = "5720b249490b3c17245ba772f6be4a43edb4e3b7";

     

       939
       939
       -
             hash = "sha256-rSkLSXdthOS9wzXsC8D1Z1P0vmOT+APzeesvlN7ta6U=";

     

       938
       938
       +
             rev = "f772967f7b7bc7c28f845be2420a38472b16a8ee";

     

       939
       939
       +
             hash = "sha256-rfOAn5S8E2RunlRyY1aTs7j0r6UGKH+732xdpk/5524=";

     

       940
       940
        
           };

     

       941
       941
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-javascript";

     

       942
       942
        
         };

     
···

       1008
       1008
        
         };

     

       1009
       1009
        
         julia = buildGrammar {

     

       1010
       1010
        
           language = "julia";

     

       1011
       1011
       -
           version = "0.0.0+rev=784364c";

     

       1011
       1011
       +
           version = "0.0.0+rev=d68ded9";

     

       1012
       1012
        
           src = fetchFromGitHub {

     

       1013
       1013
        
             owner = "tree-sitter";

     

       1014
       1014
        
             repo = "tree-sitter-julia";

     

       1015
       1015
       -
             rev = "784364cb9185ef8dc245de4b0b51e3a22503419d";

     

       1016
       1016
       -
             hash = "sha256-MPdDEVbIUsEQu84AB9k2Bhi3Oa47e9/tItGhKMfZLyU=";

     

       1015
       1015
       +
             rev = "d68ded9d5131878a2a06211ef0b47b72e70c6c08";

     

       1016
       1016
       +
             hash = "sha256-vPmZ9oA4t2LtQng88UNWkngwmpf2JLRlPOx/PM5mi80=";

     

       1017
       1017
        
           };

     

       1018
       1018
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-julia";

     

       1019
       1019
        
         };

     
···

       1253
       1253
        
         };

     

       1254
       1254
        
         nix = buildGrammar {

     

       1255
       1255
        
           language = "nix";

     

       1256
       1256
       -
           version = "0.0.0+rev=14b5361";

     

       1256
       1256
       +
           version = "0.0.0+rev=66e3e9c";

     

       1257
       1257
        
           src = fetchFromGitHub {

     

       1258
       1258
        
             owner = "cstrahan";

     

       1259
       1259
        
             repo = "tree-sitter-nix";

     

       1260
       1260
       -
             rev = "14b53610c9038500066c509b2e67de04775b97fe";

     

       1261
       1261
       -
             hash = "sha256-FNq/+Voqg534Nnm7rnv2daPwc9uFxNi1ce0m091jmRk=";

     

       1260
       1260
       +
             rev = "66e3e9ce9180ae08fc57372061006ef83f0abde7";

     

       1261
       1261
       +
             hash = "sha256-+o+f1TlhcrcCB3TNw1RyCjVZ+37e11nL+GWBPo0Mxxg=";

     

       1262
       1262
        
           };

     

       1263
       1263
        
           meta.homepage = "https://github.com/cstrahan/tree-sitter-nix";

     

       1264
       1264
        
         };

     
···

       1286
       1286
        
         };

     

       1287
       1287
        
         ocaml = buildGrammar {

     

       1288
       1288
        
           language = "ocaml";

     

       1289
       1289
       -
           version = "0.0.0+rev=3ad4d79";

     

       1289
       1289
       +
           version = "0.0.0+rev=ee871b5";

     

       1290
       1290
        
           src = fetchFromGitHub {

     

       1291
       1291
        
             owner = "tree-sitter";

     

       1292
       1292
        
             repo = "tree-sitter-ocaml";

     

       1293
       1293
       -
             rev = "3ad4d7988edf8b8a9780a1db7a5af657911dbfba";

     

       1294
       1294
       -
             hash = "sha256-OOBrAiKdw9dCy5oLPDzta0gQEkeRxNrJWmZFlDoENjg=";

     

       1293
       1293
       +
             rev = "ee871b50b845b6adaa22e85aa3c794a3fd49b1fb";

     

       1294
       1294
       +
             hash = "sha256-2WhK69OGHeQWQZPkBdfrybgxO2oDwHSn1c/AzQe9hAw=";

     

       1295
       1295
        
           };

     

       1296
       1296
        
           location = "ocaml";

     

       1297
       1297
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-ocaml";

     

       1298
       1298
        
         };

     

       1299
       1299
        
         ocaml_interface = buildGrammar {

     

       1300
       1300
        
           language = "ocaml_interface";

     

       1301
       1301
       -
           version = "0.0.0+rev=3ad4d79";

     

       1301
       1301
       +
           version = "0.0.0+rev=ee871b5";

     

       1302
       1302
        
           src = fetchFromGitHub {

     

       1303
       1303
        
             owner = "tree-sitter";

     

       1304
       1304
        
             repo = "tree-sitter-ocaml";

     

       1305
       1305
       -
             rev = "3ad4d7988edf8b8a9780a1db7a5af657911dbfba";

     

       1306
       1306
       -
             hash = "sha256-OOBrAiKdw9dCy5oLPDzta0gQEkeRxNrJWmZFlDoENjg=";

     

       1305
       1305
       +
             rev = "ee871b50b845b6adaa22e85aa3c794a3fd49b1fb";

     

       1306
       1306
       +
             hash = "sha256-2WhK69OGHeQWQZPkBdfrybgxO2oDwHSn1c/AzQe9hAw=";

     

       1307
       1307
        
           };

     

       1308
       1308
        
           location = "interface";

     

       1309
       1309
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-ocaml";

     

       1310
       1310
        
         };

     

       1311
       1311
        
         ocamllex = buildGrammar {

     

       1312
       1312
        
           language = "ocamllex";

     

       1313
       1313
       -
           version = "0.0.0+rev=fab854a";

     

       1313
       1313
       +
           version = "0.0.0+rev=c8f90e4";

     

       1314
       1314
        
           src = fetchFromGitHub {

     

       1315
       1315
        
             owner = "atom-ocaml";

     

       1316
       1316
        
             repo = "tree-sitter-ocamllex";

     

       1317
       1317
       -
             rev = "fab854a2de25b2284582bf7ed7f9970d19988c73";

     

       1318
       1318
       -
             hash = "sha256-UmBTzWgjgp0EKAfZEY0uJhvYLHzeNtrMGEUPogx3Op8=";

     

       1317
       1317
       +
             rev = "c8f90e42e1b9cf9e30b1669c386b8d9de992d201";

     

       1318
       1318
       +
             hash = "sha256-cFzurSuO64PwOuJz1Fa0GTDZ2hnT0dHl4NwQhXWQWIw=";

     

       1319
       1319
        
           };

     

       1320
       1320
        
           generate = true;

     

       1321
       1321
        
           meta.homepage = "https://github.com/atom-ocaml/tree-sitter-ocamllex";

     
···

       1377
       1377
        
         };

     

       1378
       1378
        
         perl = buildGrammar {

     

       1379
       1379
        
           language = "perl";

     

       1380
       1380
       -
           version = "0.0.0+rev=60aa138";

     

       1380
       1380
       +
           version = "0.0.0+rev=4a02376";

     

       1381
       1381
        
           src = fetchFromGitHub {

     

       1382
       1382
        
             owner = "ganezdragon";

     

       1383
       1383
        
             repo = "tree-sitter-perl";

     

       1384
       1384
       -
             rev = "60aa138f9e1db15becad53070f4d5898b0e8a98c";

     

       1385
       1385
       -
             hash = "sha256-GpgUSm/kFFXgJOSBVBxPQiMfykZUgxLdmQfDfJE3Jq8=";

     

       1384
       1384
       +
             rev = "4a023763f54dec0a6f986f5bd238af788a3f0584";

     

       1385
       1385
       +
             hash = "sha256-8mLzXxkc8m69KOQtIT02MCKeTCuwERT3/Kegf48IEls=";

     

       1386
       1386
        
           };

     

       1387
       1387
        
           meta.homepage = "https://github.com/ganezdragon/tree-sitter-perl";

     

       1388
       1388
        
         };

     
···

       1399
       1399
        
         };

     

       1400
       1400
        
         phpdoc = buildGrammar {

     

       1401
       1401
        
           language = "phpdoc";

     

       1402
       1402
       -
           version = "0.0.0+rev=2d20f39";

     

       1402
       1402
       +
           version = "0.0.0+rev=915a527";

     

       1403
       1403
        
           src = fetchFromGitHub {

     

       1404
       1404
        
             owner = "claytonrcarter";

     

       1405
       1405
        
             repo = "tree-sitter-phpdoc";

     

       1406
       1406
       -
             rev = "2d20f39476348c2682761ce7251914031a7c013f";

     

       1407
       1407
       -
             hash = "sha256-uJEUAMIJ/Bq0YhcQ78UxWcK4LM6qoum+Ett03qli+Os=";

     

       1406
       1406
       +
             rev = "915a527d5aafa81b31acf67fab31b0ac6b6319c0";

     

       1407
       1407
       +
             hash = "sha256-DYNJ/i+VBuTOxuphJn4nklTLfV7GuNP1RCCuf5qAYR4=";

     

       1408
       1408
        
           };

     

       1409
       1409
        
           meta.homepage = "https://github.com/claytonrcarter/tree-sitter-phpdoc";

     

       1410
       1410
        
         };

     
···

       1498
       1498
        
         };

     

       1499
       1499
        
         puppet = buildGrammar {

     

       1500
       1500
        
           language = "puppet";

     

       1501
       1501
       -
           version = "0.0.0+rev=843868b";

     

       1501
       1501
       +
           version = "0.0.0+rev=8e13a37";

     

       1502
       1502
        
           src = fetchFromGitHub {

     

       1503
       1503
        
             owner = "amaanq";

     

       1504
       1504
        
             repo = "tree-sitter-puppet";

     

       1505
       1505
       -
             rev = "843868bfb909b734bfb63778a5685fae4bf2a33f";

     

       1506
       1506
       -
             hash = "sha256-6fJNADrLVsIoho9G8qCsMKNDB5a32gUntug7Nh8pKEg=";

     

       1505
       1505
       +
             rev = "8e13a3768091703ac27ef1e5763e542af7f6dead";

     

       1506
       1506
       +
             hash = "sha256-vBxCqFsSF2kwUK5uNWDPvl7F+mcD8rdTzsckcab4vUU=";

     

       1507
       1507
        
           };

     

       1508
       1508
        
           meta.homepage = "https://github.com/amaanq/tree-sitter-puppet";

     

       1509
       1509
        
         };

     

       1510
       1510
        
         python = buildGrammar {

     

       1511
       1511
        
           language = "python";

     

       1512
       1512
       -
           version = "0.0.0+rev=db1d218";

     

       1512
       1512
       +
           version = "0.0.0+rev=7c8930b";

     

       1513
       1513
        
           src = fetchFromGitHub {

     

       1514
       1514
        
             owner = "tree-sitter";

     

       1515
       1515
        
             repo = "tree-sitter-python";

     

       1516
       1516
       -
             rev = "db1d218a4f8fb87145aabeb22ca3c35925c411fc";

     

       1517
       1517
       -
             hash = "sha256-v0pWQzO8M9w0ngTUO5eGoTTcBbVu7tRgA993zGfoNwI=";

     

       1516
       1516
       +
             rev = "7c8930b6388b5590ebef248853f144185a9eda1d";

     

       1517
       1517
       +
             hash = "sha256-6QXMocivEFGrmCFJdxz+z+FsAQ6MBd4kv7719gKO4Gg=";

     

       1518
       1518
        
           };

     

       1519
       1519
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-python";

     

       1520
       1520
        
         };

     
···

       1597
       1597
        
         };

     

       1598
       1598
        
         regex = buildGrammar {

     

       1599
       1599
        
           language = "regex";

     

       1600
       1600
       -
           version = "0.0.0+rev=e1cfca3";

     

       1600
       1600
       +
           version = "0.0.0+rev=17a3293";

     

       1601
       1601
        
           src = fetchFromGitHub {

     

       1602
       1602
        
             owner = "tree-sitter";

     

       1603
       1603
        
             repo = "tree-sitter-regex";

     

       1604
       1604
       -
             rev = "e1cfca3c79896ff79842f057ea13e529b66af636";

     

       1605
       1605
       -
             hash = "sha256-lDsr3sLrLf6wXu/juIA+bTtv1SBo+Jgwqw/6yBAE0kg=";

     

       1604
       1604
       +
             rev = "17a3293714312c691ef14217f60593a3d093381c";

     

       1605
       1605
       +
             hash = "sha256-3D+LOWRUamAdbegVfWD5yFcCjBucthPogOL/zWR78PY=";

     

       1606
       1606
        
           };

     

       1607
       1607
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-regex";

     

       1608
       1608
        
         };

     
···

       1628
       1628
        
           };

     

       1629
       1629
        
           meta.homepage = "https://github.com/bamonroe/tree-sitter-rnoweb";

     

       1630
       1630
        
         };

     

       1631
       1631
       +
         robot = buildGrammar {

     

       1632
       1632
       +
           language = "robot";

     

       1633
       1633
       +
           version = "0.0.0+rev=f1142bf";

     

       1634
       1634
       +
           src = fetchFromGitHub {

     

       1635
       1635
       +
             owner = "Hubro";

     

       1636
       1636
       +
             repo = "tree-sitter-robot";

     

       1637
       1637
       +
             rev = "f1142bfaa6acfce95e25d2c6d18d218f4f533927";

     

       1638
       1638
       +
             hash = "sha256-Nd38FJZsSEr3R7S6e8nyoJTqZbbDCtlcvwqWrjvz2d4=";

     

       1639
       1639
       +
           };

     

       1640
       1640
       +
           meta.homepage = "https://github.com/Hubro/tree-sitter-robot";

     

       1641
       1641
       +
         };

     

       1631
       1642
        
         ron = buildGrammar {

     

       1632
       1643
        
           language = "ron";

     

       1633
       1644
        
           version = "0.0.0+rev=ce6086b";

     
···

       1762
       1773
        
         };

     

       1763
       1774
        
         sql = buildGrammar {

     

       1764
       1775
        
           language = "sql";

     

       1765
       1765
       -
           version = "0.0.0+rev=e08036e";

     

       1776
       1776
       +
           version = "0.0.0+rev=9fc30c9";

     

       1766
       1777
        
           src = fetchFromGitHub {

     

       1767
       1778
        
             owner = "derekstride";

     

       1768
       1779
        
             repo = "tree-sitter-sql";

     

       1769
       1769
       -
             rev = "e08036ee4928b32fbebe55ac9336f81b7389e107";

     

       1770
       1770
       -
             hash = "sha256-x3vngL+36kO60eEFN0jvTzh9sCvsYvrzrvfMg08JL4w=";

     

       1780
       1780
       +
             rev = "9fc30c949f29747d34c254677d039c9df3c521b4";

     

       1781
       1781
       +
             hash = "sha256-EyZSbcjbPuaQGpi33YK+hpsod73yifk2hL+MCjn8R9M=";

     

       1771
       1782
        
           };

     

       1772
       1783
        
           meta.homepage = "https://github.com/derekstride/tree-sitter-sql";

     

       1773
       1784
        
         };

     
···

       1828
       1839
        
         };

     

       1829
       1840
        
         swift = buildGrammar {

     

       1830
       1841
        
           language = "swift";

     

       1831
       1831
       -
           version = "0.0.0+rev=56ecc99";

     

       1842
       1842
       +
           version = "0.0.0+rev=29541ac";

     

       1832
       1843
        
           src = fetchFromGitHub {

     

       1833
       1844
        
             owner = "alex-pinkus";

     

       1834
       1845
        
             repo = "tree-sitter-swift";

     

       1835
       1835
       -
             rev = "56ecc996e5765054fc25cdae5fbddfd75a64287b";

     

       1836
       1836
       -
             hash = "sha256-GH0HpxAprOlOLv8zqsP1O0/RbIn93FfdgAHp56Pyw9g=";

     

       1846
       1846
       +
             rev = "29541ac9bbe2090de75d0b1e70360b85bbda1fef";

     

       1847
       1847
       +
             hash = "sha256-jT7SdhxX5AlZP33oH7NISV+HvJwQwsXMXDWzHorgnIc=";

     

       1837
       1848
        
           };

     

       1838
       1849
        
           generate = true;

     

       1839
       1850
        
           meta.homepage = "https://github.com/alex-pinkus/tree-sitter-swift";

     
···

       1863
       1874
        
         };

     

       1864
       1875
        
         tablegen = buildGrammar {

     

       1865
       1876
        
           language = "tablegen";

     

       1866
       1866
       -
           version = "0.0.0+rev=e5e046e";

     

       1877
       1877
       +
           version = "0.0.0+rev=300f6a4";

     

       1867
       1878
        
           src = fetchFromGitHub {

     

       1868
       1879
        
             owner = "amaanq";

     

       1869
       1880
        
             repo = "tree-sitter-tablegen";

     

       1870
       1870
       -
             rev = "e5e046e1b221e25111175469f02f3cf336010857";

     

       1871
       1871
       -
             hash = "sha256-qh5AWLinsSwfbui7b3Vk7DRW3GaS4Avaa0iLeMmMFtM=";

     

       1881
       1881
       +
             rev = "300f6a490e71f895e644ed2deec6920860a2e107";

     

       1882
       1882
       +
             hash = "sha256-V4fEmiGPBAnZO+NAyA7FdlyjLSA0ByUfrCTbsdDOxc8=";

     

       1872
       1883
        
           };

     

       1873
       1884
        
           meta.homepage = "https://github.com/amaanq/tree-sitter-tablegen";

     

       1874
       1885
        
         };

     
···

       1953
       1964
        
         };

     

       1954
       1965
        
         tsx = buildGrammar {

     

       1955
       1966
        
           language = "tsx";

     

       1956
       1956
       -
           version = "0.0.0+rev=3429d8c";

     

       1967
       1967
       +
           version = "0.0.0+rev=e5fa28f";

     

       1957
       1968
        
           src = fetchFromGitHub {

     

       1958
       1969
        
             owner = "tree-sitter";

     

       1959
       1970
        
             repo = "tree-sitter-typescript";

     

       1960
       1960
       -
             rev = "3429d8c77d7a83e80032667f0642e6cb19d0c772";

     

       1961
       1961
       -
             hash = "sha256-qMzxxCx7u8fp+LhlSg6rvK0vMa0SXnJqSc4hgLcpZ7U=";

     

       1971
       1971
       +
             rev = "e5fa28f919e0b1ed1961af9adf9a1e7a71271104";

     

       1972
       1972
       +
             hash = "sha256-1kyW5tohk3byP/sWM7Edv8N3tWin65k7h+nkKBMQGAg=";

     

       1962
       1973
        
           };

     

       1963
       1974
        
           location = "tsx";

     

       1964
       1975
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-typescript";

     
···

       1987
       1998
        
         };

     

       1988
       1999
        
         typescript = buildGrammar {

     

       1989
       2000
        
           language = "typescript";

     

       1990
       1990
       -
           version = "0.0.0+rev=3429d8c";

     

       2001
       2001
       +
           version = "0.0.0+rev=e5fa28f";

     

       1991
       2002
        
           src = fetchFromGitHub {

     

       1992
       2003
        
             owner = "tree-sitter";

     

       1993
       2004
        
             repo = "tree-sitter-typescript";

     

       1994
       1994
       -
             rev = "3429d8c77d7a83e80032667f0642e6cb19d0c772";

     

       1995
       1995
       -
             hash = "sha256-qMzxxCx7u8fp+LhlSg6rvK0vMa0SXnJqSc4hgLcpZ7U=";

     

       2005
       2005
       +
             rev = "e5fa28f919e0b1ed1961af9adf9a1e7a71271104";

     

       2006
       2006
       +
             hash = "sha256-1kyW5tohk3byP/sWM7Edv8N3tWin65k7h+nkKBMQGAg=";

     

       1996
       2007
        
           };

     

       1997
       2008
        
           location = "typescript";

     

       1998
       2009
        
           meta.homepage = "https://github.com/tree-sitter/tree-sitter-typescript";

     
···

       2021
       2032
        
         };

     

       2022
       2033
        
         uxntal = buildGrammar {

     

       2023
       2034
        
           language = "uxntal";

     

       2024
       2024
       -
           version = "0.0.0+rev=14e4760";

     

       2035
       2035
       +
           version = "0.0.0+rev=4c5ecd6";

     

       2025
       2036
        
           src = fetchFromGitHub {

     

       2026
       2037
        
             owner = "amaanq";

     

       2027
       2038
        
             repo = "tree-sitter-uxntal";

     

       2028
       2028
       -
             rev = "14e47600afef0affffcbfbe1543381b1ac8fbc5c";

     

       2029
       2029
       -
             hash = "sha256-SgBWJ8b/9kMkSDafx+6eSl+FS4Hkd1Ei2ALhTLL7yRk=";

     

       2039
       2039
       +
             rev = "4c5ecd6326ebd61f6f9a22a370cbd100e0d601da";

     

       2040
       2040
       +
             hash = "sha256-vgeTsRJ3mlR02jXuucmXpszVOmusZwuV0xj/7sSs+WQ=";

     

       2030
       2041
        
           };

     

       2031
       2042
        
           meta.homepage = "https://github.com/amaanq/tree-sitter-uxntal";

     

       2032
       2043
        
         };

     
···

       2132
       2143
        
         };

     

       2133
       2144
        
         wing = buildGrammar {

     

       2134
       2145
        
           language = "wing";

     

       2135
       2135
       -
           version = "0.0.0+rev=755aef4";

     

       2146
       2146
       +
           version = "0.0.0+rev=1f8736f";

     

       2136
       2147
        
           src = fetchFromGitHub {

     

       2137
       2148
        
             owner = "winglang";

     

       2138
       2149
        
             repo = "wing";

     

       2139
       2139
       -
             rev = "755aef4e57da4a00da47e85b6aff976b007d500c";

     

       2140
       2140
       -
             hash = "sha256-EbTNiwZwzPWxf8VNUWX82x/Jz4RFCE1LDuzXwYiYQLs=";

     

       2150
       2150
       +
             rev = "1f8736fc86204a045644e0086bee68f7171e1967";

     

       2151
       2151
       +
             hash = "sha256-cguDviBdQPOLOwoM/jhGNasQyjN1IfLw5Eg9DVjnU1s=";

     

       2141
       2152
        
           };

     

       2142
       2153
        
           location = "libs/tree-sitter-wing";

     

       2143
       2154
        
           generate = true;

+1 -1

pkgs/applications/editors/vim/plugins/overrides.nix

···

       919
       919
        
               pname = "sg-nvim-rust";

     

       920
       920
        
               inherit (old) version src;

     

       921
       921
        
       

     

       922
       922
       -
               cargoHash = "sha256-IRp4avOvM2tz2oC1Cwr4W/d4i0pzawcZLP+c1+jnm+I=";

     

       922
       922
       +
               cargoHash = "sha256-ErXgFNx3bTp955p45xpW0vAfLMPbH8KQ+SQH6/TE3m4=";

     

       923
       923
        
       

     

       924
       924
        
               nativeBuildInputs = [ pkg-config ];

     

       925
       925

+1 -1

pkgs/applications/misc/goldendict/default.nix

···

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "goldendict";

     

       18
       18
        
           repo = pname;

     

       19
       19
       -
           rev = "v${version}";

     

       19
       19
       +
           rev = version;

     

       20
       20
        
           hash = "sha256-80o8y+mbzpyMQYUGHYs/zgQT23nLVCs7Jcr8FbbXn8M=";

     

       21
       21
        
         };

     

       22
       22

+6 -6

pkgs/applications/networking/browsers/chromium/upstream-info.json

···

       19
       19
        
           }

     

       20
       20
        
         },

     

       21
       21
        
         "beta": {

     

       22
       22
       -
           "version": "115.0.5790.40",

     

       23
       23
       -
           "sha256": "1ab034zrgyz0gwi0caz6y1nyr0p5yhbly50chnhvsr3k6gmidl58",

     

       24
       24
       -
           "sha256bin64": "02vzlz5z87n9lwdhxnzdzr5w85l3b828j0y1z6fzq7br90yr0pcw",

     

       22
       22
       +
           "version": "115.0.5790.90",

     

       23
       23
       +
           "sha256": "156k5cijkxj44r4cn14k7r2xa11xp0nwi7nsgxfmg3dfsay05s42",

     

       24
       24
       +
           "sha256bin64": "1b573bd19ywwy0k8570501az1cw3xnp6iy53zk1a1gawsn8f4pv5",

     

       25
       25
        
           "deps": {

     

       26
       26
        
             "gn": {

     

       27
       27
        
               "version": "2023-05-19",

     
···

       32
       32
        
           }

     

       33
       33
        
         },

     

       34
       34
        
         "dev": {

     

       35
       35
       -
           "version": "116.0.5845.14",

     

       36
       36
       -
           "sha256": "1b8ak0yg7ymz0siw81g47fdl12bj7f7gdw2nd5wlgj3h0g0b0675",

     

       37
       37
       -
           "sha256bin64": "1hnis5m5l6ygihmwsy6qk12lz6gjcndfdnssb3l9pd7v3qwfpkp2",

     

       35
       35
       +
           "version": "116.0.5845.32",

     

       36
       36
       +
           "sha256": "0migfx1snbsa9a42cv37x6bkpa9j7y3n6h6hs0w79ss1hxmmj2mi",

     

       37
       37
       +
           "sha256bin64": "1zdr2340lbkvwyw303954ba8cay44p9a5d6b9l693kcrgkf4z8bz",

     

       38
       38
        
           "deps": {

     

       39
       39
        
             "gn": {

     

       40
       40
        
               "version": "2023-06-09",

+5 -5

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

···

       1
       1
        
       {

     

       2
       2
       -
         "version" = "1.11.35";

     

       2
       2
       +
         "version" = "1.11.36";

     

       3
       3
        
         "hashes" = {

     

       4
       4
       -
           "desktopSrcHash" = "8BP7PC0ZqE3d0K1AxmG05Xh3Ze1dAOcBVW9ADW4YAjY=";

     

       5
       5
       -
           "desktopYarnHash" = "1k8ih7z9hxm38kbvnfimd0djwqlrs62s8i0hc6d6ii10l3binkzp";

     

       6
       6
       -
           "webSrcHash" = "IM1M8iygeya8hw0uVjV4EK/jGG4UyQUTviYAvAjI7k4=";

     

       7
       7
       -
           "webYarnHash" = "0lr5cgs8nhdjrv43pcyhq4ysrz8bncx0j969j82l0chq3nzdml5b";

     

       4
       4
       +
           "desktopSrcHash" = "MMTuyyUXur5Fy24aXPWtZbQLAaXR2R7coEi8ZOJo1YI=";

     

       5
       5
       +
           "desktopYarnHash" = "03wmdqnxzjrvdypwrb5z564liiqamwn6qmw2fww1mja8dkdkx5ng";

     

       6
       6
       +
           "webSrcHash" = "u+Y/iLRlTd5RkczF6qIaer9HKFnm8LUGP8ZnB/WfiGI=";

     

       7
       7
       +
           "webYarnHash" = "0s9ly1hr9jvb2asgjf6g5n5n5w6qh51wkwyl7ps891c0hv9m28zm";

     

       8
       8
        
         };

     

       9
       9
        
       }

+59 -34

pkgs/applications/networking/mullvad/openvpn.nix

···

       1
       1
        
       { lib

     

       2
       2
       +
       , stdenv

     

       2
       3
        
       , openvpn

     

       3
       4
        
       , fetchpatch

     

       4
       5
        
       , fetchurl

     

       5
       6
        
       , iproute2

     

       6
       6
       -
       , autoconf

     

       7
       7
       -
       , automake

     

       7
       7
       +
       , libnl

     

       8
       8
       +
       , autoreconfHook

     

       9
       9
       +
       , pkg-config

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       12
        
       openvpn.overrideAttrs (oldAttrs:

     

       11
       13
        
         let

     

       14
       14
       +
           inherit (lib) optional;

     

       12
       15
        
           fetchMullvadPatch = { commit, sha256 }: fetchpatch {

     

       13
       16
        
             url = "https://github.com/mullvad/openvpn/commit/${commit}.patch";

     

       14
       17
        
             inherit sha256;

     
···

       16
       19
        
         in

     

       17
       20
        
         rec {

     

       18
       21
        
           pname = "openvpn-mullvad";

     

       19
       19
       -
           version = "2.5.3";

     

       22
       22
       +
           version = "2.6.0";

     

       20
       23
        
       

     

       21
       24
        
           src = fetchurl {

     

       22
       25
        
             url = "https://swupdate.openvpn.net/community/releases/openvpn-${version}.tar.gz";

     

       23
       23
       -
             sha256 = "sha256-dfAETfRJQwVVynuZWit3qyTylG/cNmgwG47cI5hqX34=";

     

       26
       26
       +
             sha256 = "sha256-6+yTMmPJhQ72984SXi8iIUvmCxy7jM/xiJJkP+CDro8=";

     

       24
       27
        
           };

     

       25
       28
        
       

     

       26
       26
       -
           buildInputs = oldAttrs.buildInputs or [ ] ++ [

     

       27
       27
       -
             iproute2

     

       29
       29
       +
           nativeBuildInputs = oldAttrs.nativeBuildInputs or [ ] ++ [

     

       30
       30
       +
             autoreconfHook

     

       31
       31
       +
             pkg-config

     

       28
       32
        
           ];

     

       29
       33
        
       

     

       30
       30
       -
           configureFlags = oldAttrs.configureFlags  or [ ] ++ [

     

       31
       31
       -
             "--enable-iproute2"

     

       32
       32
       -
             "IPROUTE=${iproute2}/sbin/ip"

     

       33
       33
       -
           ];

     

       34
       34
       +
           buildInputs = oldAttrs.buildInputs or [ ]

     

       35
       35
       +
              ++ optional stdenv.isLinux [ libnl.dev ];

     

       36
       36
       +
       

     

       37
       37
       +
           configureFlags = [

     

       38
       38
       +
             # Assignement instead of appending to make sure to use exactly the flags required by mullvad

     

       34
       39
        
       

     

       35
       35
       -
           nativeBuildInputs = oldAttrs.nativeBuildInputs or [ ] ++ [

     

       36
       36
       -
             autoconf

     

       37
       37
       -
             automake

     

       40
       40
       +
             # Flags are based on https://github.com/mullvad/mullvadvpn-app-binaries/blob/main/Makefile#L17

     

       41
       41
       +
             "--enable-static"

     

       42
       42
       +
             "--disable-shared"

     

       43
       43
       +
             "--disable-debug"

     

       44
       44
       +
             "--disable-plugin-down-root"

     

       45
       45
       +
             "--disable-management"

     

       46
       46
       +
             "--disable-port-share"

     

       47
       47
       +
             "--disable-systemd"

     

       48
       48
       +
             "--disable-dependency-tracking"

     

       49
       49
       +
             "--disable-pkcs11"

     

       50
       50
       +
             "--disable-plugin-auth-pam"

     

       51
       51
       +
             "--enable-plugins"

     

       52
       52
       +
             "--disable-lzo"

     

       53
       53
       +
             "--disable-lz4"

     

       54
       54
       +
             "--enable-comp-stub"

     

       55
       55
       +
           ]

     

       56
       56
       +
           ++ optional stdenv.isLinux [

     

       57
       57
       +
             # Flags are based on https://github.com/mullvad/mullvadvpn-app-binaries/blob/main/Makefile#L35

     

       58
       58
       +
             "--enable-dco" # requires libnl

     

       59
       59
       +
             "--disable-iproute2"

     

       38
       60
        
           ];

     

       39
       61
        
       

     

       40
       62
        
           patches = oldAttrs.patches or [ ] ++ [

     

       41
       63
        
             # look at compare to find the relevant commits

     

       42
       42
       -
             # https://github.com/OpenVPN/openvpn/compare/release/2.5...mullvad:mullvad-patches

     

       64
       64
       +
             # https://github.com/OpenVPN/openvpn/compare/release/2.6...mullvad:mullvad-patches

     

       43
       65
        
             # used openvpn version is the latest tag ending with -mullvad

     

       44
       66
        
             # https://github.com/mullvad/openvpn/tags

     

       45
       67
        
             (fetchMullvadPatch {

     

       46
       68
        
               # "Reduce PUSH_REQUEST_INTERVAL to one second"

     

       47
       47
       -
               commit = "41e44158fc71bb6cc8cc6edb6ada3307765a12e8";

     

       48
       48
       -
               sha256 = "sha256-UoH0V6gTPdEuybFkWxdaB4zomt7rZeEUyXs9hVPbLb4=";

     

       49
       49
       -
             })

     

       50
       50
       -
             (fetchMullvadPatch {

     

       51
       51
       -
               # "Allow auth plugins to set a failure reason"

     

       52
       52
       -
               commit = "f51781c601e8c72ae107deaf25bf66f7c193e9cd";

     

       53
       53
       -
               sha256 = "sha256-+kwG0YElL16T0e+avHlI8gNQdAxneRS6fylv7QXvC1s=";

     

       69
       69
       +
               commit = "4084b49de84e64c56584a378e85faf37973b6d6d";

     

       70
       70
       +
               sha256 = "sha256-MmYeFSw6c/QJh0LqLgkx+UxrbtTVv6zEFcnYEqznR1c=";

     

       54
       71
        
             })

     

       55
       72
        
             (fetchMullvadPatch {

     

       56
       73
        
               # "Send an event to any plugins when authentication fails"

     

       57
       57
       -
               commit = "c2f810f966f2ffd68564d940b5b8946ea6007d5a";

     

       58
       58
       -
               sha256 = "sha256-PsKIxYwpLD66YaIpntXJM8OGcObyWBSAJsQ60ojvj30=";

     

       74
       74
       +
               commit = "f24de7922d70c6e1ae06acf18bce1f62d9fa6b07";

     

       75
       75
       +
               sha256 = "sha256-RvlQbR6/s4NorYeA6FL7tE6geg6MIoZJtHeYxkVbdwA=";

     

       59
       76
        
             })

     

       60
       77
        
             (fetchMullvadPatch {

     

       61
       78
        
               # "Shutdown when STDIN is closed"

     

       62
       62
       -
               commit = "879d6a3c0288b5443bbe1b94261655c329fc2e0e";

     

       63
       63
       -
               sha256 = "sha256-pRFY4r+b91/xAKXx6u5GLzouQySXuO5gH0kMGm77a3c=";

     

       64
       64
       -
             })

     

       65
       65
       -
             (fetchMullvadPatch {

     

       66
       66
       -
               # "Update TAP hardware ID"

     

       67
       67
       -
               commit = "7f71b37a3b25bec0b33a0e29780c222aef869e9d";

     

       68
       68
       -
               sha256 = "sha256-RF/GvD/ZvhLdt34wDdUT/yxa+IVWx0eY6WRdNWXxXeQ=";

     

       79
       79
       +
               commit = "81ae84271c044359b67991b15ebfb0cf9a32b3ad";

     

       80
       80
       +
               sha256 = "sha256-ilKMyU97ha2m0p1FD64aNQncnKo4Tyi/nATuD5yPmVw=";

     

       69
       81
        
             })

     

       70
       82
        
             (fetchMullvadPatch {

     

       71
       83
        
               # "Undo dependency on Python docutils"

     

       72
       72
       -
               commit = "abd3c6214529d9f4143cc92dd874d8743abea17c";

     

       73
       73
       -
               sha256 = "sha256-SC2RlpWHUDMAEKap1t60dC4hmalk3vok6xY+/xhC2U0=";

     

       84
       84
       +
               commit = "a5064b4b6c598b68d8cabc3f4006e5addef1ec1e";

     

       85
       85
       +
               sha256 = "sha256-+B6jxL0M+W5LzeukXkir26hn1OaYnycVNBwMYFq6gsE=";

     

       74
       86
        
             })

     

       75
       87
        
             (fetchMullvadPatch {

     

       76
       88
        
               # "Prevent signal when stdin is closed from being cleared (#10)"

     

       77
       77
       -
               commit = "b45b090c81e7b4f2dc938642af7a1e12f699f5c5";

     

       78
       78
       -
               sha256 = "sha256-KPTFmbuJhMI+AvaRuu30CPPLQAXiE/VApxlUCqbZFls=";

     

       89
       89
       +
               commit = "abe529e6d7f71228a036007c6c02624ec98ad6c1";

     

       90
       90
       +
               sha256 = "sha256-qJQeEtZO/+8kenXTKv4Bx6NltUYe8AwzXQtJcyhrjfc=";

     

       91
       91
       +
             })

     

       92
       92
       +
             (fetchMullvadPatch {

     

       93
       93
       +
               # "Disable libcap-ng"

     

       94
       94
       +
               commit = "598014de7c063fa4e8ba1fffa01434229faafd04";

     

       95
       95
       +
               sha256 = "sha256-+cFX5gmMuG6XFkTs6IV7utiKRF9E47F5Pgo93c+zBXo=";

     

       96
       96
       +
             })

     

       97
       97
       +
             (fetchMullvadPatch {

     

       98
       98
       +
               # "Remove libnsl dep"

     

       99
       99
       +
               commit = "845727e01ab3ec9bd58fcedb31b3cf2ebe2d5226";

     

       100
       100
       +
               sha256 = "sha256-Via62wKVfMWHTmO7xIXXO7b5k0KYHs1D0JVg3qnXkeM=";

     

       79
       101
        
             })

     

       80
       102
        
           ];

     

       103
       103
       +
           postPatch = oldAttrs.postPatch or "" + ''

     

       104
       104
       +
             rm ./configure

     

       105
       105
       +
           '';

     

       81
       106
        
       

     

       82
       107
        
           meta = oldAttrs.meta or { } // {

     

       83
       108
        
             description = "OpenVPN with Mullvad-specific patches applied";

+2 -2

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

···

       21
       21
        
       

     

       22
       22
        
       stdenv.mkDerivation rec {

     

       23
       23
        
         pname = "e16";

     

       24
       24
       -
         version = "1.0.27";

     

       24
       24
       +
         version = "1.0.28";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchurl {

     

       27
       27
        
           url = "mirror://sourceforge/enlightenment/e16-${version}.tar.xz";

     

       28
       28
       -
           hash = "sha256-Lr5OC14N6KTZNU3Ei4O9taYGL+1NZd5JmejYBmmELUE=";

     

       28
       28
       +
           hash = "sha256-k3W2IoBc75DNQ2QSjChsC/yVRO/aZT3E31Tl/njgH30=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         nativeBuildInputs = [

+2 -2

pkgs/desktops/gnome/apps/cheese/default.nix

···

       33
       33
        
       

     

       34
       34
        
       stdenv.mkDerivation rec {

     

       35
       35
        
         pname = "cheese";

     

       36
       36
       -
         version = "44.0.1";

     

       36
       36
       +
         version = "44.1";

     

       37
       37
        
       

     

       38
       38
        
         outputs = [ "out" "man" "devdoc" ];

     

       39
       39
        
       

     

       40
       40
        
         src = fetchurl {

     

       41
       41
        
           url = "mirror://gnome/sources/cheese/${lib.versions.major version}/${pname}-${version}.tar.xz";

     

       42
       42
       -
           sha256 = "2SJAEnLN1BXCknA+UsazZEZqCyDuHbMgJRZEwoNgb9Q=";

     

       42
       42
       +
           sha256 = "XyGFxMmeVN3yuLr2DIKBmVDlSVLhMuhjmHXz7cv49o4=";

     

       43
       43
        
         };

     

       44
       44
        
       

     

       45
       45
        
         nativeBuildInputs = [

+31

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

···

       2416
       2416
        
         };

     

       2417
       2417
        
       }) {};

     

       2418
       2418
        
       

     

       2419
       2419
       +
       magick = callPackage({ fetchgit, buildLuarocksPackage, lua }:

     

       2420
       2420
       +
       buildLuarocksPackage {

     

       2421
       2421
       +
         pname = "magick";

     

       2422
       2422
       +
         version = "1.6.0-1";

     

       2423
       2423
       +
         knownRockspec = (fetchurl {

     

       2424
       2424
       +
           url    = "mirror://luarocks/magick-1.6.0-1.rockspec";

     

       2425
       2425
       +
           sha256 = "1pg150xsxnqvlhxpiy17s9hm4dkc84v46mlwi9rhriynqz8qks9w";

     

       2426
       2426
       +
         }).outPath;

     

       2427
       2427
       +
         src = fetchgit ( removeAttrs (builtins.fromJSON ''{

     

       2428
       2428
       +
         "url": "https://github.com/leafo/magick.git",

     

       2429
       2429
       +
         "rev": "6971fa700c4d392130492a3925344b51c7cc54aa",

     

       2430
       2430
       +
         "date": "2022-03-10T20:02:11-08:00",

     

       2431
       2431
       +
         "path": "/nix/store/fpl99q09zg3qnk4kagxk1djabl1dm47l-magick",

     

       2432
       2432
       +
         "sha256": "01b9qsz27f929rz5z7vapqhazxak74sichdwkjwb219nlhrwfncm",

     

       2433
       2433
       +
         "fetchLFS": false,

     

       2434
       2434
       +
         "fetchSubmodules": true,

     

       2435
       2435
       +
         "deepClone": false,

     

       2436
       2436
       +
         "leaveDotGit": false

     

       2437
       2437
       +
       }

     

       2438
       2438
       +
        '') ["date" "path"]) ;

     

       2439
       2439
       +
       

     

       2440
       2440
       +
         disabled = (lua.luaversion != "5.1");

     

       2441
       2441
       +
         propagatedBuildInputs = [ lua ];

     

       2442
       2442
       +
       

     

       2443
       2443
       +
         meta = {

     

       2444
       2444
       +
           homepage = "git://github.com/leafo/magick.git";

     

       2445
       2445
       +
           description = "Lua bindings to ImageMagick & GraphicsMagick for LuaJIT using FFI";

     

       2446
       2446
       +
           license.fullName = "MIT";

     

       2447
       2447
       +
         };

     

       2448
       2448
       +
       }) {};

     

       2449
       2449
       +
       

     

       2419
       2450
        
       markdown = callPackage({ buildLuarocksPackage, luaAtLeast, fetchgit, luaOlder, lua }:

     

       2420
       2451
        
       buildLuarocksPackage {

     

       2421
       2452
        
         pname = "markdown";

+53

pkgs/development/lua-modules/magick.patch

···

       1
       1
       +
       diff --git a/magick/wand/lib.lua b/magick/wand/lib.lua

     

       2
       2
       +
       index 21940a0..0d103dc 100644

     

       3
       3
       +
       --- a/magick/wand/lib.lua

     

       4
       4
       +
       +++ b/magick/wand/lib.lua

     

       5
       5
       +
       @@ -134,15 +134,6 @@ get_filters = function()

     

       6
       6
       +
          local prefixes = {

     

       7
       7
       +
            "/usr/include/ImageMagick",

     

       8
       8
       +
            "/usr/local/include/ImageMagick",

     

       9
       9
       +
       -    unpack((function()

     

       10
       10
       +
       -      local _accum_0 = { }

     

       11
       11
       +
       -      local _len_0 = 1

     

       12
       12
       +
       -      for p in get_flags():gmatch("-I([^%s]+)") do

     

       13
       13
       +
       -        _accum_0[_len_0] = p

     

       14
       14
       +
       -        _len_0 = _len_0 + 1

     

       15
       15
       +
       -      end

     

       16
       16
       +
       -      return _accum_0

     

       17
       17
       +
       -    end)())

     

       18
       18
       +
          }

     

       19
       19
       +
          for _index_0 = 1, #prefixes do

     

       20
       20
       +
            local p = prefixes[_index_0]

     

       21
       21
       +
       @@ -204,12 +195,7 @@ try_to_load = function(...)

     

       22
       22
       +
                  break

     

       23
       23
       +
                end

     

       24
       24
       +
              end

     

       25
       25
       +
       -      if pcall(function()

     

       26
       26
       +
       -        out = ffi.load(name)

     

       27
       27
       +
       -      end) then

     

       28
       28
       +
       -        return out

     

       29
       29
       +
       -      end

     

       30
       30
       +
       -      _continue_0 = true

     

       31
       31
       +
       +      return ffi.load(name)

     

       32
       32
       +
            until true

     

       33
       33
       +
            if not _continue_0 then

     

       34
       34
       +
              break

     

       35
       35
       +
       @@ -217,17 +203,7 @@ try_to_load = function(...)

     

       36
       36
       +
          end

     

       37
       37
       +
          return error("Failed to load ImageMagick (" .. tostring(...) .. ")")

     

       38
       38
       +
        end

     

       39
       39
       +
       -lib = try_to_load("MagickWand", function()

     

       40
       40
       +
       -  local lname = get_flags():match("-l(MagickWand[^%s]*)")

     

       41
       41
       +
       -  local suffix

     

       42
       42
       +
       -  if ffi.os == "OSX" then

     

       43
       43
       +
       -    suffix = ".dylib"

     

       44
       44
       +
       -  elseif ffi.os == "Windows" then

     

       45
       45
       +
       -    suffix = ".dll"

     

       46
       46
       +
       -  else

     

       47
       47
       +
       -    suffix = ".so"

     

       48
       48
       +
       -  end

     

       49
       49
       +
       -  return lname and "lib" .. lname .. suffix

     

       50
       50
       +
       +lib = try_to_load("@nix_wand@", function()

     

       51
       51
       +
        end)

     

       52
       52
       +
        return {

     

       53
       53
       +
          lib = lib,

+20

pkgs/development/lua-modules/overrides.nix

···

       15
       15
        
       , gnulib

     

       16
       16
        
       , gnum4

     

       17
       17
        
       , gobject-introspection

     

       18
       18
       +
       , imagemagick

     

       18
       19
        
       , installShellFiles

     

       19
       20
        
       , lib

     

       20
       21
        
       , libevent

     
···

       475
       476
        
           buildInputs = [

     

       476
       477
        
             libyaml

     

       477
       478
        
           ];

     

       479
       479
       +
         });

     

       480
       480
       +
       

     

       481
       481
       +
         magick = prev.magick.overrideAttrs (oa: {

     

       482
       482
       +
           buildInputs = oa.buildInputs ++ [

     

       483
       483
       +
             imagemagick

     

       484
       484
       +
           ];

     

       485
       485
       +
       

     

       486
       486
       +
           # Fix MagickWand not being found in the pkg-config search path

     

       487
       487
       +
           patches = [

     

       488
       488
       +
             ./magick.patch

     

       489
       489
       +
           ];

     

       490
       490
       +
       

     

       491
       491
       +
           postPatch = ''

     

       492
       492
       +
             substituteInPlace magick/wand/lib.lua \

     

       493
       493
       +
               --replace @nix_wand@ ${imagemagick}/lib/libMagickWand-7.Q16HDRI.so

     

       494
       494
       +
           '';

     

       495
       495
       +
       

     

       496
       496
       +
           # Requires ffi

     

       497
       497
       +
           meta.broken = !isLuaJIT;

     

       478
       498
        
         });

     

       479
       499
        
       

     

       480
       500
        
         mpack = prev.mpack.overrideAttrs (drv: {

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "cpyparsing";

     

       12
       12
       -
         version = "2.4.7.2.1.1";

     

       12
       12
       +
         version = "2.4.7.2.1.2";

     

       13
       13
        
         format = "setuptools";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.7";

     
···

       18
       18
        
           owner = "evhub";

     

       19
       19
        
           repo = pname;

     

       20
       20
        
           rev = "refs/tags/v${version}";

     

       21
       21
       -
           hash = "sha256-ZJKWJhqhnTbTAf/48Whq2mSNIp/Ar17syFWvpD3w4fE=";

     

       21
       21
       +
           hash = "sha256-Y3EyX9Gjssez0DkD6dIaOpazNLy7rDYzjKO1u+lLGFI=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [

+2 -2

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

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "pyxbe";

     

       10
       10
       -
         version = "1.0.2";

     

       10
       10
       +
         version = "1.0.3";

     

       11
       11
        
         format = "setuptools";

     

       12
       12
        
       

     

       13
       13
        
         disabled = pythonOlder "3.7";

     
···

       16
       16
        
           owner = "mborgerson";

     

       17
       17
        
           repo = pname;

     

       18
       18
        
           rev = "refs/tags/v${version}";

     

       19
       19
       -
           hash = "sha256-sm8/Lcsk3aL8/MB0cVrKNb8MoQPxGCGpHkEPWv+mPdo=";

     

       19
       19
       +
           hash = "sha256-iLzGGgizUbaEG1xrNq4WDaWrGtcaLwAYgn4NGYiSDBo=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeCheckInputs = [

+3 -7

pkgs/development/python-modules/repeated-test/default.nix

···

       3
       3
        
       , fetchPypi

     

       4
       4
        
       , pythonOlder

     

       5
       5
        
       , setuptools-scm

     

       6
       6
       -
       , six

     

       7
       6
        
       , pytestCheckHook

     

       8
       7
        
       }:

     

       9
       8
        
       

     

       10
       9
        
       buildPythonPackage rec {

     

       11
       10
        
         pname = "repeated-test";

     

       12
       12
       -
         version = "2.3.1";

     

       11
       11
       +
         version = "2.3.3";

     

       13
       12
        
         format = "pyproject";

     

       14
       13
        
       

     

       15
       14
        
         disabled = pythonOlder "3.5";

     
···

       17
       16
        
         src = fetchPypi {

     

       18
       17
        
           pname = "repeated_test";

     

       19
       18
        
           inherit version;

     

       20
       20
       -
           hash = "sha256-TbVyQA7EjCSwo6qfDksbE8IU1ElkSCABEUBWy5j1KJc=";

     

       19
       19
       +
           hash = "sha256-3YPU8SL9rud5s0pnwwH5TJk1MXsDhdkDnZp/Oj6sgXs=";

     

       21
       20
        
         };

     

       22
       21
        
       

     

       23
       22
        
         nativeBuildInputs = [

     

       24
       23
        
           setuptools-scm

     

       25
       24
        
         ];

     

       26
       25
        
       

     

       27
       27
       -
         propagatedBuildInputs = [

     

       28
       28
       -
           six

     

       29
       29
       -
         ];

     

       30
       30
       -
       

     

       31
       26
        
         nativeCheckInputs = [

     

       32
       27
        
           pytestCheckHook

     

       33
       28
        
         ];

     
···

       39
       34
        
         meta = with lib; {

     

       40
       35
        
           description = "Unittest-compatible framework for repeating a test function over many fixtures";

     

       41
       36
        
           homepage = "https://github.com/epsy/repeated_test";

     

       37
       37
       +
           changelog = "https://github.com/epsy/repeated_test/releases/tag/v${version}";

     

       42
       38
        
           license = licenses.mit;

     

       43
       39
        
           maintainers = with maintainers; [ tjni ];

     

       44
       40
        
         };

+33

pkgs/development/tools/fatcat/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , gitUpdater

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       stdenv.mkDerivation rec {

     

       9
       9
       +
         pname = "fatcat";

     

       10
       10
       +
         version = "1.1.1";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchFromGitHub {

     

       13
       13
       +
           owner = "Gregwar";

     

       14
       14
       +
           repo = "fatcat";

     

       15
       15
       +
           rev = "v${version}";

     

       16
       16
       +
           hash = "sha256-/iGNVP7Bz/UZAR+dFxAKMKM9jm07h0x0F3VGpdxlHdk=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         nativeBuildInputs = [

     

       20
       20
       +
           cmake

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         passthru.updateScript = gitUpdater {

     

       24
       24
       +
           rev-prefix = "v";

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with lib; {

     

       28
       28
       +
           description = "FAT filesystems explore, extract, repair, and forensic tool";

     

       29
       29
       +
           homepage = "https://github.com/Gregwar/fatcat";

     

       30
       30
       +
           license = licenses.mit;

     

       31
       31
       +
           maintainers = with maintainers; [ cynerd ];

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+42

pkgs/development/tools/gi-crystal/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , crystal

     

       4
       4
       +
       , gobject-introspection

     

       5
       5
       +
       }:

     

       6
       6
       +
       crystal.buildCrystalPackage rec {

     

       7
       7
       +
         pname = "gi-crystal";

     

       8
       8
       +
         version = "0.17.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "hugopl";

     

       12
       12
       +
           repo = "gi-crystal";

     

       13
       13
       +
           rev = "v${version}";

     

       14
       14
       +
           hash = "sha256-DIH8L8P8lkWzzVUj1Tbf9oTUvu9X7OT66APyUHiDkYk=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         # Make sure gi-crystal picks up the name of the so or dylib and not the leading nix store path

     

       18
       18
       +
         # when the package name happens to start with “lib”.

     

       19
       19
       +
         patches = [ ./src.patch ./store-friendly-library-name.patch ];

     

       20
       20
       +
       

     

       21
       21
       +
         nativeBuildInputs = [ gobject-introspection ];

     

       22
       22
       +
         buildTargets = [ "generator" ];

     

       23
       23
       +
       

     

       24
       24
       +
         doCheck = false;

     

       25
       25
       +
         doInstallCheck = false;

     

       26
       26
       +
       

     

       27
       27
       +
         installPhase = ''

     

       28
       28
       +
           runHook preInstall

     

       29
       29
       +
       

     

       30
       30
       +
           mkdir $out

     

       31
       31
       +
           cp -r * $out

     

       32
       32
       +
       

     

       33
       33
       +
           runHook postInstall

     

       34
       34
       +
         '';

     

       35
       35
       +
       

     

       36
       36
       +
         meta = with lib; {

     

       37
       37
       +
           description = "GI Crystal is a binding generator used to generate Crystal bindings for GObject based libraries using GObject Introspection.";

     

       38
       38
       +
           homepage = "https://github.com/hugopl/gi-crystal";

     

       39
       39
       +
           mainProgram = "gi-crystal";

     

       40
       40
       +
           maintainers = with maintainers; [ sund3RRR ];

     

       41
       41
       +
         };

     

       42
       42
       +
       }

+57

pkgs/development/tools/gi-crystal/src.patch

···

       1
       1
       +
       --- a/src/generator/main.cr	2023-07-14 18:30:47.687581729 +0300

     

       2
       2
       +
       +++ b/src/generator/main.cr	2023-07-17 07:55:24.177630085 +0300

     

       3
       3
       +
       @@ -1,6 +1,8 @@

     

       4
       4
       +
        require "colorize"

     

       5
       5
       +
        require "log"

     

       6
       6
       +
        require "option_parser"

     

       7
       7
       +
       +require "file"

     

       8
       8
       +
       +require "file_utils"

     

       9
       9
       +
        

     

       10
       10
       +
        require "./binding_config"

     

       11
       11
       +
        require "./error"

     

       12
       12
       +
       @@ -43,7 +45,7 @@

     

       13
       13
       +
            end

     

       14
       14
       +
          end

     

       15
       15
       +
        

     

       16
       16
       +
       -  output_dir = Path.new(project_dir, "lib/gi-crystal/src/auto").normalize if output_dir.nil?

     

       17
       17
       +
       +  output_dir = Path.new(Dir.current, "lib/gi-crystal/src/auto").normalize if output_dir.nil?

     

       18
       18
       +
          extra_bindings = argv.map { |path| Path.new(path).expand.to_s }

     

       19
       19
       +
        

     

       20
       20
       +
          {output_dir:     output_dir,

     

       21
       21
       +
       @@ -74,11 +76,23 @@

     

       22
       22
       +
          end

     

       23
       23
       +
        end

     

       24
       24
       +
        

     

       25
       25
       +
       -private def find_bindings : Array(String)

     

       26
       26
       +
       -  find_pattern = Path.new(project_dir, "**/binding.yml").normalize

     

       27
       27
       +
       +private def find_bindings_yml(path) : Array(String)

     

       28
       28
       +
       +  find_pattern = File.join(path, "**/binding.yml")

     

       29
       29
       +
          Dir[find_pattern]

     

       30
       30
       +
        end

     

       31
       31
       +
        

     

       32
       32
       +
       +private def find_bindings : Array(String)

     

       33
       33
       +
       +  current_directory = Dir.current

     

       34
       34
       +
       +

     

       35
       35
       +
       +  bindings = find_bindings_yml(current_directory)

     

       36
       36
       +
       +  Dir.glob(File.join(current_directory, "**/*")).each do |path|

     

       37
       37
       +
       +      if File.symlink?(path)

     

       38
       38
       +
       +        bindings += find_bindings_yml(path)

     

       39
       39
       +
       +      end

     

       40
       40
       +
       +  end

     

       41
       41
       +
       +  bindings

     

       42
       42
       +
       +end

     

       43
       43
       +
       +

     

       44
       44
       +
        private def format_files(dir)

     

       45
       45
       +
          # We need to chdir into output dir since the formatter ignores everything under `lib` dir.

     

       46
       46
       +
          Dir.cd(dir) { `crystal tool format` }

     

       47
       47
       +
       @@ -102,7 +116,9 @@

     

       48
       48
       +
          Log.info { "Generating bindings at #{options[:output_dir]}" }

     

       49
       49
       +
        

     

       50
       50
       +
          Generator::DocRepo.disable! unless options[:doc_gen]

     

       51
       51
       +
       -

     

       52
       52
       +
       +  

     

       53
       53
       +
       +  FileUtils.cp_r(project_dir, File.join(Dir.current, "lib/gi-crystal"))

     

       54
       54
       +
       +  

     

       55
       55
       +
          binding_yamls = find_bindings.concat(options[:extra_bindings])

     

       56
       56
       +
          binding_yamls.each do |file|

     

       57
       57
       +
            Log.info { "Using binding config at #{file}" }

+10

pkgs/development/tools/gi-crystal/store-friendly-library-name.patch

···

       1
       1
       +
       --- a/src/generator/lib_gen.cr	1969-12-31 17:00:01.000000000 -0700

     

       2
       2
       +
       +++ b/src/generator/lib_gen.cr	2023-07-14 11:48:41.509397114 -0600

     

       3
       3
       +
       @@ -10,7 +10,7 @@

     

       4
       4
       +
        

     

       5
       5
       +
            private def libraries : Array(String)

     

       6
       6
       +
              namespace.shared_libraries.map do |library|

     

       7
       7
       +
       -        library[/lib([^\/]+)\.(?:so|.+?\.dylib).*/, 1]

     

       8
       8
       +
       +        library[/(?:\/[^\/]*)+\/lib([^\/]+)\.(?:so|.+?\.dylib).*/, 1]

     

       9
       9
       +
              end

     

       10
       10
       +
            end

+3 -3

pkgs/development/tools/jql/default.nix

···

       5
       5
        
       

     

       6
       6
        
       rustPlatform.buildRustPackage rec {

     

       7
       7
        
         pname = "jql";

     

       8
       8
       -
         version = "7.0.1";

     

       8
       8
       +
         version = "7.0.2";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "yamafaktory";

     

       12
       12
        
           repo = pname;

     

       13
       13
        
           rev = "jql-v${version}";

     

       14
       14
       -
           hash = "sha256-JGD+E5QWrtRX047Nrufl+wQJnJXqKTZkXcU4/uXA6l0=";

     

       14
       14
       +
           hash = "sha256-lYm+zgZkt/iVJgehJM44VqWbcR4kqt8rUSEsnz07tbU=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         cargoHash = "sha256-t3QACjuHMpJULEpEcUPCAF27LIrjtn4i7Ud0DfDa0ek=";

     

       17
       17
       +
         cargoHash = "sha256-Gav89ub4ccv/lCCqNYn9NvK4Q8udlu6YaZPhouHOVss=";

     

       18
       18
        
       

     

       19
       19
        
         meta = with lib; {

     

       20
       20
        
           description = "A JSON Query Language CLI tool built with Rust";

+34

pkgs/development/tools/rust/ra-multiplex/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , makeWrapper

     

       4
       4
       +
       , rustPlatform

     

       5
       5
       +
       , rust-analyzer

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       rustPlatform.buildRustPackage {

     

       9
       9
       +
         pname = "ra-multiplex";

     

       10
       10
       +
         version = "0.2.2";

     

       11
       11
       +
       

     

       12
       12
       +
         src = fetchFromGitHub {

     

       13
       13
       +
           owner = "pr2502";

     

       14
       14
       +
           repo = "ra-multiplex";

     

       15
       15
       +
           rev = "dcb5f83890cb91016b0a1590cc1b732606bb6ec1";

     

       16
       16
       +
           hash = "sha256-Hf4Gj9eXEP4gXiqNV4Jq0oiGLX3DtDF9At1feEZ+bUE=";

     

       17
       17
       +
         };

     

       18
       18
       +
       

     

       19
       19
       +
         cargoHash = "sha256-MeUtkPjOsL1kQ2W0Q1/OqhKDVXs4cECkATHISpyfp9U=";

     

       20
       20
       +
       

     

       21
       21
       +
         nativeBuildInputs = [ makeWrapper ];

     

       22
       22
       +
       

     

       23
       23
       +
         postInstall = ''

     

       24
       24
       +
           wrapProgram $out/bin/ra-multiplex \

     

       25
       25
       +
             --suffix PATH ${lib.makeBinPath [ rust-analyzer ]}

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         meta = with lib; {

     

       29
       29
       +
           description = "A multiplexer for rust-analyzer";

     

       30
       30
       +
           homepage = "https://github.com/pr2502/ra-multiplex";

     

       31
       31
       +
           license = with licenses; [ mit ];

     

       32
       32
       +
           maintainers = with maintainers; [ norfair ];

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+14 -19

pkgs/os-specific/linux/nvidia-x11/default.nix

···

       25
       25
        
         stable = if stdenv.hostPlatform.system == "i686-linux" then legacy_390 else latest;

     

       26
       26
        
       

     

       27
       27
        
         production = generic {

     

       28
       28
       -
           version = "535.54.03";

     

       29
       29
       -
           sha256_64bit = "sha256-RUdk9X6hueGRZqNw94vhDnHwYmQ4+xl/cm3DyvBbQII=";

     

       30
       30
       -
           sha256_aarch64 = "sha256-SUxW/Z8sJJ7bc/yhozTh8Wd2gKLsniJwKmXh1tJwUm8=";

     

       31
       31
       -
           openSha256 = "sha256-dp74UiiZfsQbZbAKHgFkLdRNyYbRlVMF3tIXcxok7FU";

     

       32
       32
       -
           settingsSha256 = "sha256-5yIdOAaYQCQ2CmCayD/a5opoQppjK56s9cDqLmm17ww=";

     

       33
       33
       -
           persistencedSha256 = "sha256-R5WCh09BSPjfifui0ODkCsdIXTowceNjLDq5XHwda08=";

     

       28
       28
       +
           version = "535.86.05";

     

       29
       29
       +
           sha256_64bit = "sha256-QH3wyjZjLr2Fj8YtpbixJP/DvM7VAzgXusnCcaI69ts=";

     

       30
       30
       +
           sha256_aarch64 = "sha256-ON++eWPDWHnm/NuJmDSYkR4sKKvCdX+kwxS7oA2M5zU=";

     

       31
       31
       +
           openSha256 = "sha256-qCYEQP54cT7G+VrLmuMT+RWIwuGdBhlbYTrCDcztfNs=";

     

       32
       32
       +
           settingsSha256 = "sha256-0NAxQosC+zPz5STpELuRKDMap4KudoPGWKL4QlFWjLQ=";

     

       33
       33
       +
           persistencedSha256 = "sha256-Ak4Wf59w9by08QJ0x15Zs5fHOhiIatiJfjBQfnY65Mg=";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
        
         latest = selectHighestVersion production (generic {

     
···

       79
       79
        
       

     

       80
       80
        
         # Last one supporting Kepler architecture

     

       81
       81
        
         legacy_470 = generic {

     

       82
       82
       -
           version = "470.182.03";

     

       83
       83
       -
           sha256_64bit = "sha256-PbwUCPxIuGXT3azvxF9KP8E7kLg6Yo7lRrAIKrLD/Hk=";

     

       84
       84
       -
           sha256_aarch64 = "sha256-FEoWikgQjZKkHvAHgtkxnDhB41GdYplZTttEUBit4QQ=";

     

       85
       85
       -
           settingsSha256 = "sha256-TRKQ4brLnCbBZt1smGSIHTfwW+wEFPWWPEwDxjVXN7s=";

     

       86
       86
       -
           persistencedSha256 = "sha256-fSJMx49z9trdNxx0iPI45oG57smvvhaqVNxsRnfXKCI=";

     

       82
       82
       +
           version = "470.199.02";

     

       83
       83
       +
           sha256_64bit = "sha256-/fggDt8RzjLDW0JiGjr4aV4RGnfEKL8MTTQ4tCjXaP0=";

     

       84
       84
       +
           sha256_aarch64 = "sha256-UmF7LszdrO2d+bOaoQYrTVKXUwDqzMy1UDBW5SPuZy4=";

     

       85
       85
       +
           settingsSha256 = "sha256-FkKPE4QV5IiVizGYUNUYoEXRpEhojt/cbH/I8iCn3hw=";

     

       86
       86
       +
           persistencedSha256 = "sha256-JP71wt3uCNOgheLNlQbW3DqVFQNTC5vj4y4COWKQzAs=";

     

       87
       87
        
       

     

       88
       88
        
           patchFlags = [ "-p1" "-d" "kernel" ];

     

       89
       89
        
           patches = [

     

       90
       90
       -
             # source: https://gist.github.com/joanbm/d10e9cbbbb8e245b6e7e27b2db338faf

     

       90
       90
       +
             # source: https://gist.github.com/joanbm/dfe8dc59af1c83e2530a1376b77be8ba

     

       91
       91
        
             (fetchpatch {

     

       92
       92
       -
               url = "https://gist.github.com/joanbm/d10e9cbbbb8e245b6e7e27b2db338faf/raw/f5d5238bdbaa16cd4008658a0f82b9dd84f1b38f/nvidia-470xx-fix-linux-6.3.patch";

     

       93
       93
       -
               hash = "sha256-mR+vXDHgVhWC0JeLgGlbNVCH8XTs7XnhEJS6BV75tI8=";

     

       94
       94
       -
             })

     

       95
       95
       -
             # source: https://gist.github.com/joanbm/77f0650d45747b9a4dc8e330ade2bf5c

     

       96
       96
       -
             (fetchpatch {

     

       97
       97
       -
               url = "https://gist.github.com/joanbm/77f0650d45747b9a4dc8e330ade2bf5c/raw/688b612624945926676de28059fe749203b4b549/nvidia-470xx-fix-linux-6.4.patch";

     

       98
       98
       -
               hash = "sha256-OyRmezyzqAi7mSJHDjsWQVocSsgJPTW5DvHDFVNX7Dk=";

     

       92
       92
       +
               url = "https://gist.github.com/joanbm/dfe8dc59af1c83e2530a1376b77be8ba/raw/37ff2b5ccf99f295ff958c9a44ca4ed4f42503b4/nvidia-470xx-fix-linux-6.5.patch";

     

       93
       93
       +
               hash = "sha256-s5r7nwuMva0BLy2qJBVKqNtnUN9am5+PptnVwNdzdbk=";

     

       99
       94
        
             })

     

       100
       95
        
           ];

     

       101
       96
        
         };

+5 -5

pkgs/servers/komga/default.nix

···

       2
       2
        
       , stdenvNoCC

     

       3
       3
        
       , fetchurl

     

       4
       4
        
       , makeWrapper

     

       5
       5
       -
       , jdk11_headless

     

       5
       5
       +
       , jdk17_headless

     

       6
       6
        
       , nixosTests

     

       7
       7
        
       }:

     

       8
       8
        
       

     

       9
       9
        
       stdenvNoCC.mkDerivation rec {

     

       10
       10
        
         pname = "komga";

     

       11
       11
       -
         version = "0.165.0";

     

       11
       11
       +
         version = "1.1.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchurl {

     

       14
       14
        
           url = "https://github.com/gotson/${pname}/releases/download/v${version}/${pname}-${version}.jar";

     

       15
       15
       -
           sha256 = "sha256-J8dpw7GzLJnLiiFSFVCoqZFQ6mI2z0zBZHdbmxMgmf8=";

     

       15
       15
       +
           sha256 = "sha256-uGzJgy+jfV11bZXvCMZAUdjuZasKCcv5rQBBUEidWQU=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [

     
···

       20
       20
        
         ];

     

       21
       21
        
       

     

       22
       22
        
         buildCommand = ''

     

       23
       23
       -
           makeWrapper ${jdk11_headless}/bin/java $out/bin/komga --add-flags "-jar $src"

     

       23
       23
       +
           makeWrapper ${jdk17_headless}/bin/java $out/bin/komga --add-flags "-jar $src"

     

       24
       24
        
         '';

     

       25
       25
        
       

     

       26
       26
        
         passthru.tests = {

     
···

       31
       31
        
           description = "Free and open source comics/mangas server";

     

       32
       32
        
           homepage = "https://komga.org/";

     

       33
       33
        
           license = licenses.mit;

     

       34
       34
       -
           platforms = jdk11_headless.meta.platforms;

     

       34
       34
       +
           platforms = jdk17_headless.meta.platforms;

     

       35
       35
        
           maintainers = with maintainers; [ govanify ];

     

       36
       36
        
         };

     

       37
       37

-12

pkgs/tools/games/pokefinder/cstddef.patch

···

       1
       1
       -
       diff --git a/Source/Core/Util/EncounterSlot.cpp b/Source/Core/Util/EncounterSlot.cpp

     

       2
       2
       -
       index adddbdab..71c98e83 100644

     

       3
       3
       -
       --- a/Source/Core/Util/EncounterSlot.cpp

     

       4
       4
       -
       +++ b/Source/Core/Util/EncounterSlot.cpp

     

       5
       5
       -
       @@ -20,6 +20,7 @@

     

       6
       6
       -
        #include "EncounterSlot.hpp"

     

       7
       7
       -
        #include <Core/Enum/Encounter.hpp>

     

       8
       8
       -
        #include <array>

     

       9
       9
       -
       +#include <cstddef>

     

       10
       10
       -
        

     

       11
       11
       -
        namespace

     

       12
       12
       -
        {

+38 -9

pkgs/tools/games/pokefinder/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       +
       , copyDesktopItems

     

       4
       4
       +
       , makeDesktopItem

     

       3
       5
        
       , fetchFromGitHub

     

       4
       6
        
       , cmake

     

       5
       7
        
       , qtbase

     

       6
       8
        
       , qttools

     

       7
       9
        
       , qtwayland

     

       10
       10
       +
       , imagemagick

     

       8
       11
        
       , wrapQtAppsHook

     

       9
       12
        
       , gitUpdater

     

       10
       13
        
       }:

     

       11
       14
        
       

     

       12
       15
        
       stdenv.mkDerivation rec {

     

       13
       16
        
         pname = "pokefinder";

     

       14
       14
       -
         version = "4.0.1";

     

       17
       17
       +
         version = "4.1.1";

     

       15
       18
        
       

     

       16
       19
        
         src = fetchFromGitHub {

     

       17
       20
        
           owner = "Admiral-Fish";

     

       18
       21
        
           repo = "PokeFinder";

     

       19
       22
        
           rev = "v${version}";

     

       20
       20
       -
           sha256 = "j7xgjNF8NWLFVPNItWcFM5WL8yPxgHxVX00x7lt45WI=";

     

       23
       23
       +
           sha256 = "fYBeWc9eYLbj4+ku1jwaO5ISL8a7WJnBHJ4qz4W8RHA=";

     

       21
       24
        
           fetchSubmodules = true;

     

       25
       25
       +
           # the repo has identical cmake and CMake folders, causing issues on macOS

     

       26
       26
       +
           postFetch = if stdenv.isDarwin then ''

     

       27
       27
       +
           mv $out/cmake $out/cmake.tmp

     

       28
       28
       +
           mv $out/cmake.tmp $out/CMake

     

       29
       29
       +
           '' else ''

     

       30
       30
       +
           rm -rf $out/cmake

     

       31
       31
       +
           '';

     

       22
       32
        
         };

     

       23
       33
        
       

     

       24
       24
       -
         patches = [ ./cstddef.patch ];

     

       34
       34
       +
         patches = [ ./set-desktop-file-name.patch ];

     

       25
       35
        
       

     

       26
       36
        
         postPatch = ''

     

       27
       37
        
           patchShebangs Source/Core/Resources/

     

       28
       38
        
         '';

     

       29
       39
        
       

     

       30
       30
       -
         installPhase = lib.optionalString (!stdenv.isDarwin) ''

     

       31
       31
       -
           install -D Source/Forms/PokeFinder $out/bin/PokeFinder

     

       32
       32
       -
         '' + lib.optionalString stdenv.isDarwin ''

     

       40
       40
       +
         installPhase = ''

     

       41
       41
       +
           runHook preInstall

     

       42
       42
       +
         '' + lib.optionalString (stdenv.isDarwin) ''

     

       33
       43
        
           mkdir -p $out/Applications

     

       34
       34
       -
           cp -R Source/Forms/PokeFinder.app $out/Applications

     

       44
       44
       +
           cp -R Source/PokeFinder.app $out/Applications

     

       45
       45
       +
         '' + lib.optionalString (!stdenv.isDarwin) ''

     

       46
       46
       +
           install -D Source/PokeFinder $out/bin/PokeFinder

     

       47
       47
       +
           mkdir -p $out/share/pixmaps

     

       48
       48
       +
           convert "$src/Source/Form/Images/pokefinder.ico[-1]" $out/share/pixmaps/pokefinder.png

     

       49
       49
       +
         '' + ''

     

       50
       50
       +
           runHook postInstall

     

       35
       51
        
         '';

     

       36
       52
        
       

     

       37
       37
       -
         nativeBuildInputs = [ cmake wrapQtAppsHook ];

     

       53
       53
       +
         nativeBuildInputs = [ cmake wrapQtAppsHook ] ++ lib.optionals (!stdenv.isDarwin) [ copyDesktopItems imagemagick ];

     

       54
       54
       +
       

     

       55
       55
       +
         desktopItems = [

     

       56
       56
       +
           (makeDesktopItem {

     

       57
       57
       +
             name = "pokefinder";

     

       58
       58
       +
             exec = "PokeFinder";

     

       59
       59
       +
             icon = "pokefinder";

     

       60
       60
       +
             comment = "Cross platform Pokémon RNG tool";

     

       61
       61
       +
             desktopName = "PokéFinder";

     

       62
       62
       +
             categories = [ "Utility" ];

     

       63
       63
       +
           })

     

       64
       64
       +
         ];

     

       38
       65
        
       

     

       39
       66
        
         buildInputs = [ qtbase qttools ]

     

       40
       67
        
           ++ lib.optionals stdenv.isLinux [ qtwayland ];

     

       41
       68
        
       

     

       42
       42
       -
         passthru.updateScript = gitUpdater { };

     

       69
       69
       +
         passthru.updateScript = gitUpdater {

     

       70
       70
       +
           rev-prefix = "v";

     

       71
       71
       +
         };

     

       43
       72
        
       

     

       44
       73
        
         meta = with lib; {

     

       45
       74
        
           homepage = "https://github.com/Admiral-Fish/PokeFinder";

+12

pkgs/tools/games/pokefinder/set-desktop-file-name.patch

···

       1
       1
       +
       diff --git a/Source/main.cpp b/Source/main.cpp

     

       2
       2
       +
       index 3e58a381..2e7e4a86 100644

     

       3
       3
       +
       --- a/Source/main.cpp

     

       4
       4
       +
       +++ b/Source/main.cpp

     

       5
       5
       +
       @@ -69,6 +69,7 @@ int main(int argc, char *argv[])

     

       6
       6
       +
        {

     

       7
       7
       +
            QApplication a(argc, argv);

     

       8
       8
       +
            a.setApplicationName("PokeFinder");

     

       9
       9
       +
       +    a.setDesktopFileName("pokefinder");

     

       10
       10
       +
            a.setOrganizationName("PokeFinder Team");

     

       11
       11
       +
        

     

       12
       12
       +
            Q_INIT_RESOURCE(resources);

+33

pkgs/tools/misc/cp210x-program/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , python3

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       python3.pkgs.buildPythonApplication rec {

     

       7
       7
       +
         pname = "cp210x-program";

     

       8
       8
       +
         version = "0.4.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "VCTLabs";

     

       12
       12
       +
           repo = "cp210x-program";

     

       13
       13
       +
           rev = "refs/tags/${version}";

     

       14
       14
       +
           sha256 = "sha256-IjKshP12WfFly9cPm6svD4qZW6cT8C7lOVrGenSqbfY=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         propagatedBuildInputs = with python3.pkgs; [

     

       18
       18
       +
           hexdump

     

       19
       19
       +
           pyusb

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         postInstall = ''

     

       23
       23
       +
           ln -s $out/bin/cp210x-program{.py,}

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           description = "EEPROM tool for Silabs CP210x USB-Serial adapter";

     

       28
       28
       +
           homepage = "https://github.com/VCTLabs/cp210x-program";

     

       29
       29
       +
           license = licenses.lgpl21Only; # plus/only status unclear

     

       30
       30
       +
           maintainers = with maintainers; [ ckie ];

     

       31
       31
       +
           mainProgram = "cp210x-program";

     

       32
       32
       +
         };

     

       33
       33
       +
       }

+12 -1

pkgs/top-level/all-packages.nix

···

       517
       517
        
       

     

       518
       518
        
         copilot-cli = callPackage ../tools/admin/copilot-cli { };

     

       519
       519
        
       

     

       520
       520
       +
         cp210x-program = callPackage ../tools/misc/cp210x-program { };

     

       521
       521
       +
       

     

       520
       522
        
         cp437 = callPackage ../tools/misc/cp437 { };

     

       521
       523
        
       

     

       522
       524
        
         cpm-cmake = callPackage ../development/tools/cpm-cmake { };

     
···

       8166
       8168
        
         ghostunnel = callPackage ../tools/networking/ghostunnel { };

     

       8167
       8169
        
       

     

       8168
       8170
        
         ghz = callPackage ../tools/networking/ghz { };

     

       8171
       8171
       +
       

     

       8172
       8172
       +
         gi-crystal = callPackage ../development/tools/gi-crystal { };

     

       8169
       8173
        
       

     

       8170
       8174
        
         gibberish-detector = with python3Packages; toPythonApplication gibberish-detector;

     

       8171
       8175
        
       

     
···

       16980
       16984
        
       

     

       16981
       16985
        
         ravedude = callPackage ../development/tools/rust/ravedude { };

     

       16982
       16986
        
       

     

       16987
       16987
       +
         ra-multiplex = callPackage ../development/tools/rust/ra-multiplex {};

     

       16988
       16988
       +
       

     

       16983
       16989
        
         rhack = callPackage ../development/tools/rust/rhack { };

     

       16984
       16990
        
         roogle = callPackage ../development/tools/rust/roogle { };

     

       16985
       16991
        
         rustfmt = rustPackages.rustfmt;

     
···

       18881
       18887
        
       

     

       18882
       18888
        
         fastgron = callPackage ../development/tools/fastgron { };

     

       18883
       18889
        
       

     

       18890
       18890
       +
         fatcat = callPackage ../development/tools/fatcat { };

     

       18891
       18891
       +
       

     

       18884
       18892
        
         findbugs = callPackage ../development/tools/analysis/findbugs { };

     

       18885
       18893
        
       

     

       18886
       18894
        
         findnewest = callPackage ../development/tools/misc/findnewest { };

     
···

       30192
       30200
        
         bitwig-studio4 =  callPackage ../applications/audio/bitwig-studio/bitwig-studio4.nix {

     

       30193
       30201
        
           libjpeg = libjpeg.override { enableJpeg8 = true; };

     

       30194
       30202
        
         };

     

       30203
       30203
       +
         bitwig-studio5 =  callPackage ../applications/audio/bitwig-studio/bitwig-studio5.nix {

     

       30204
       30204
       +
           libjpeg = libjpeg.override { enableJpeg8 = true; };

     

       30205
       30205
       +
         };

     

       30195
       30206
        
       

     

       30196
       30196
       -
         bitwig-studio = bitwig-studio4;

     

       30207
       30207
       +
         bitwig-studio = bitwig-studio5;

     

       30197
       30208
        
       

     

       30198
       30209
        
         bgpdump = callPackage ../tools/networking/bgpdump { };

     

       30199
       30210