···

       
242
       
 
       


     

       
243
       
 
       
# Docker tools

     

       
244
       
 
       
/pkgs/build-support/docker                   @roberth

     

       
245
       
-
       
/nixos/tests/docker-tools-overlay.nix        @roberth

     

       
246
       
-
       
/nixos/tests/docker-tools.nix                @roberth

     

       
247
       
-
       
/doc/builders/images/dockertools.xml         @roberth

     

       
248
       
 
       


     

       
249
       
 
       
# Blockchains

     

       
250
       
 
       
/pkgs/applications/blockchains  @mmahut @RaghavSood

     

···

       
242
       
 
       


     

       
243
       
 
       
# Docker tools

     

       
244
       
 
       
/pkgs/build-support/docker                   @roberth

     

       
245
       
+
       
/nixos/tests/docker-tools*                   @roberth

     

       
246
       
+
       
/doc/builders/images/dockertools.section.md  @roberth

     

       
0
       
 
       

     

       
247
       
 
       


     

       
248
       
 
       
# Blockchains

     

       
249
       
 
       
/pkgs/applications/blockchains  @mmahut @RaghavSood

     

···

       
8
       
 
       
# $ nix run nixpkgs.python3Packages.flake8 -c flake8 --ignore E501,E265 update.py

     

       
9
       
 
       


     

       
10
       
 
       
import argparse

     

       
0
       
 
       

     

       
11
       
 
       
import functools

     

       
12
       
 
       
import http

     

       
13
       
 
       
import json

     
···

       
28
       
 
       
from typing import Dict, List, Optional, Tuple, Union, Any, Callable

     

       
29
       
 
       
from urllib.parse import urljoin, urlparse

     

       
30
       
 
       
from tempfile import NamedTemporaryFile

     

       
31
       
-
       
from dataclasses import dataclass

     

       
32
       
 
       


     

       
33
       
 
       
import git

     

       
34
       
 
       


     
···

       
85
       
 
       
        headers["Authorization"] = f"token {token}"

     

       
86
       
 
       
    return urllib.request.Request(url, headers=headers)

     

       
87
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
88
       
 
       
class Repo:

     

       
89
       
 
       
    def __init__(

     

       
90
       
-
       
        self, uri: str, branch: str, alias: Optional[str]

     

       
91
       
 
       
    ) -> None:

     

       
92
       
 
       
        self.uri = uri

     

       
93
       
 
       
        '''Url to the repo'''

     

       
94
       
-
       
        self.branch = branch

     

       
95
       
-
       
        self.alias = alias

     

       
96
       
-
       
        self.redirect: Dict[str, str] = {}

     

       
97
       
 
       
        self.token = "dummy_token"

     

       
98
       
 
       


     

       
99
       
 
       
    @property

     

       
100
       
 
       
    def name(self):

     

       
101
       
 
       
        return self.uri.split('/')[-1]

     

       
102
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
103
       
 
       
    def __repr__(self) -> str:

     

       
104
       
 
       
        return f"Repo({self.name}, {self.uri})"

     

       
105
       
 
       


     
···

       
109
       
 
       


     

       
110
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
111
       
 
       
    def latest_commit(self) -> Tuple[str, datetime]:

     

       
0
       
 
       

     

       
112
       
 
       
        loaded = self._prefetch(None)

     

       
113
       
 
       
        updated = datetime.strptime(loaded['date'], "%Y-%m-%dT%H:%M:%S%z")

     

       
114
       
 
       


     
···

       
124
       
 
       
        return loaded

     

       
125
       
 
       


     

       
126
       
 
       
    def prefetch(self, ref: Optional[str]) -> str:

     

       
0
       
 
       

     

       
127
       
 
       
        loaded = self._prefetch(ref)

     

       
128
       
 
       
        return loaded["sha256"]

     

       
129
       
 
       


     
···

       
137
       
 
       


     

       
138
       
 
       
class RepoGitHub(Repo):

     

       
139
       
 
       
    def __init__(

     

       
140
       
-
       
        self, owner: str, repo: str, branch: str, alias: Optional[str]

     

       
141
       
 
       
    ) -> None:

     

       
142
       
 
       
        self.owner = owner

     

       
143
       
 
       
        self.repo = repo

     

       
144
       
 
       
        self.token = None

     

       
145
       
 
       
        '''Url to the repo'''

     

       
146
       
-
       
        super().__init__(self.url(""), branch, alias)

     

       
147
       
-
       
        log.debug("Instantiating github repo %s/%s", self.owner, self.repo)

     

       
148
       
 
       


     

       
149
       
 
       
    @property

     

       
150
       
 
       
    def name(self):

     

       
151
       
 
       
        return self.repo

     

       
152
       
 
       


     

       
153
       
 
       
    def url(self, path: str) -> str:

     

       
154
       
-
       
        return urljoin(f"https://github.com/{self.owner}/{self.name}/", path)

     

       
0
       
 
       

     

       
155
       
 
       


     

       
156
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
157
       
 
       
    def has_submodules(self) -> bool:

     
···

       
168
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
169
       
 
       
    def latest_commit(self) -> Tuple[str, datetime]:

     

       
170
       
 
       
        commit_url = self.url(f"commits/{self.branch}.atom")

     

       
0
       
 
       

     

       
171
       
 
       
        commit_req = make_request(commit_url, self.token)

     

       
172
       
 
       
        with urllib.request.urlopen(commit_req, timeout=10) as req:

     

       
173
       
 
       
            self._check_for_redirect(commit_url, req)

     
···

       
191
       
 
       
            new_owner, new_name = (

     

       
192
       
 
       
                urllib.parse.urlsplit(response_url).path.strip("/").split("/")[:2]

     

       
193
       
 
       
            )

     

       
194
       
-
       
            end_line = "\n" if self.alias is None else f" as {self.alias}\n"

     

       
195
       
-
       
            plugin_line = "{owner}/{name}" + end_line

     

       
196
       
 
       


     

       
197
       
-
       
            old_plugin = plugin_line.format(owner=self.owner, name=self.name)

     

       
198
       
-
       
            new_plugin = plugin_line.format(owner=new_owner, name=new_name)

     

       
199
       
-
       
            self.redirect[old_plugin] = new_plugin

     

       
200
       
 
       


     

       
201
       
 
       


     

       
202
       
 
       
    def prefetch(self, commit: str) -> str:

     
···

       
207
       
 
       
        return sha256

     

       
208
       
 
       


     

       
209
       
 
       
    def prefetch_github(self, ref: str) -> str:

     

       
210
       
-
       
        data = subprocess.check_output(

     

       
211
       
-
       
            ["nix-prefetch-url", "--unpack", self.url(f"archive/{ref}.tar.gz")]

     

       
212
       
-
       
        )

     

       
213
       
 
       
        return data.strip().decode("utf-8")

     

       
214
       
 
       


     

       
215
       
 
       
    def as_nix(self, plugin: "Plugin") -> str:

     
···

       
239
       
 
       
        else:

     

       
240
       
 
       
            return self.alias

     

       
241
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
242
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
243
       
 
       
class Plugin:

     

       
244
       
-
       
    def __init__(

     

       
245
       
-
       
        self,

     

       
246
       
-
       
        name: str,

     

       
247
       
-
       
        commit: str,

     

       
248
       
-
       
        has_submodules: bool,

     

       
249
       
-
       
        sha256: str,

     

       
250
       
-
       
        date: Optional[datetime] = None,

     

       
251
       
-
       
    ) -> None:

     

       
252
       
-
       
        self.name = name

     

       
253
       
-
       
        self.commit = commit

     

       
254
       
-
       
        self.has_submodules = has_submodules

     

       
255
       
-
       
        self.sha256 = sha256

     

       
256
       
-
       
        self.date = date

     

       
257
       
 
       


     

       
258
       
 
       
    @property

     

       
259
       
 
       
    def normalized_name(self) -> str:

     
···

       
270
       
 
       
        return copy

     

       
271
       
 
       


     

       
272
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
273
       
 
       


     

       
274
       
 
       
class Editor:

     

       
275
       
 
       
    """The configuration of the update script."""

     
···

       
298
       
 
       
        return get_current_plugins(self)

     

       
299
       
 
       


     

       
300
       
 
       
    def load_plugin_spec(self, config: FetchConfig, plugin_file) -> List[PluginDesc]:

     

       
301
       
-
       
        plugins = []

     

       
302
       
-
       
        with open(plugin_file) as f:

     

       
303
       
-
       
            for line in f:

     

       
304
       
-
       
                if line.startswith("#"):

     

       
305
       
-
       
                    continue

     

       
306
       
-
       
                plugin = parse_plugin_line(config, line)

     

       
307
       
-
       
                plugins.append(plugin)

     

       
308
       
-
       
        return plugins

     

       
309
       
 
       


     

       
310
       
 
       
    def generate_nix(self, plugins, outfile: str):

     

       
311
       
 
       
        '''Returns nothing for now, writes directly to outfile'''

     
···

       
316
       
 
       
        _prefetch = functools.partial(prefetch, cache=cache)

     

       
317
       
 
       


     

       
318
       
 
       
        def update() -> dict:

     

       
319
       
-
       
            plugin_names = self.load_plugin_spec(config, input_file)

     

       
320
       
 
       


     

       
321
       
 
       
            try:

     

       
322
       
 
       
                pool = Pool(processes=config.proc)

     

       
323
       
-
       
                results = pool.map(_prefetch, plugin_names)

     

       
324
       
 
       
            finally:

     

       
325
       
 
       
                cache.store()

     

       
326
       
 
       


     
···

       
423
       
 
       
    data = json.loads(out)

     

       
424
       
 
       
    plugins = []

     

       
425
       
 
       
    for name, attr in data.items():

     

       
0
       
 
       

     

       
426
       
 
       
        p = Plugin(name, attr["rev"], attr["submodules"], attr["sha256"])

     

       
427
       
 
       
        plugins.append(p)

     

       
428
       
 
       
    return plugins

     
···

       
431
       
 
       
def prefetch_plugin(

     

       
432
       
 
       
    p: PluginDesc,

     

       
433
       
 
       
    cache: "Optional[Cache]" = None,

     

       
434
       
-
       
) -> Tuple[Plugin, Dict[str, str]]:

     

       
435
       
 
       
    repo, branch, alias = p.repo, p.branch, p.alias

     

       
436
       
 
       
    name = alias or p.repo.name

     

       
437
       
 
       
    commit = None

     
···

       
454
       
 
       
    )

     

       
455
       
 
       


     

       
456
       
 
       


     

       
457
       
-
       
def fetch_plugin_from_pluginline(config: FetchConfig, plugin_line: str) -> Plugin:

     

       
458
       
-
       
    plugin, _ = prefetch_plugin(parse_plugin_line(config, plugin_line))

     

       
459
       
-
       
    return plugin

     

       
460
       
-
       


     

       
461
       
-
       


     

       
462
       
 
       
def print_download_error(plugin: str, ex: Exception):

     

       
463
       
 
       
    print(f"{plugin}: {ex}", file=sys.stderr)

     

       
464
       
 
       
    ex_traceback = ex.__traceback__

     
···

       
468
       
 
       
    ]

     

       
469
       
 
       
    print("\n".join(tb_lines))

     

       
470
       
 
       


     

       
471
       
-
       


     

       
472
       
 
       
def check_results(

     

       
473
       
-
       
    results: List[Tuple[PluginDesc, Union[Exception, Plugin], Dict[str, str]]]

     

       
474
       
-
       
) -> Tuple[List[Tuple[PluginDesc, Plugin]], Dict[str, str]]:

     

       
475
       
 
       
    ''' '''

     

       
476
       
 
       
    failures: List[Tuple[str, Exception]] = []

     

       
477
       
 
       
    plugins = []

     

       
478
       
-
       
    redirects: Dict[str, str] = {}

     

       
0
       
 
       

     

       
479
       
 
       
    for (pdesc, result, redirect) in results:

     

       
480
       
 
       
        if isinstance(result, Exception):

     

       
481
       
 
       
            failures.append((pdesc.name, result))

     
···

       
495
       
 
       


     

       
496
       
 
       
        sys.exit(1)

     

       
497
       
 
       


     

       
498
       
-
       
def make_repo(uri, branch, alias) -> Repo:

     

       
499
       
 
       
    '''Instantiate a Repo with the correct specialization depending on server (gitub spec)'''

     

       
500
       
 
       
    # dumb check to see if it's of the form owner/repo (=> github) or https://...

     

       
501
       
-
       
    res = uri.split('/')

     

       
502
       
-
       
    if len(res) <= 2:

     

       
503
       
-
       
        repo = RepoGitHub(res[0], res[1], branch, alias)

     

       
0
       
 
       

     

       
504
       
 
       
    else:

     

       
505
       
-
       
        repo = Repo(uri.strip(), branch, alias)

     

       
506
       
 
       
    return repo

     

       
507
       
 
       


     

       
508
       
-
       
def parse_plugin_line(config: FetchConfig, line: str) -> PluginDesc:

     

       
509
       
-
       
    branch = "HEAD"

     

       
510
       
-
       
    alias = None

     

       
511
       
-
       
    uri = line

     

       
512
       
-
       
    if " as " in uri:

     

       
513
       
-
       
        uri, alias = uri.split(" as ")

     

       
514
       
-
       
        alias = alias.strip()

     

       
515
       
-
       
    if "@" in uri:

     

       
516
       
-
       
        uri, branch = uri.split("@")

     

       
517
       
-
       


     

       
518
       
-
       
    repo = make_repo(uri.strip(), branch.strip(), alias)

     

       
519
       
-
       
    repo.token = config.github_token

     

       
520
       
-
       


     

       
521
       
-
       
    return PluginDesc(repo, branch.strip(), alias)

     

       
522
       
-
       


     

       
523
       
 
       


     

       
524
       
 
       
def get_cache_path(cache_file_name: str) -> Optional[Path]:

     

       
525
       
 
       
    xdg_cache = os.environ.get("XDG_CACHE_HOME", None)

     
···

       
585
       
 
       
        return (pluginDesc, e, {})

     

       
586
       
 
       


     

       
587
       
 
       


     

       
0
       
 
       

     

       
588
       
 
       
def rewrite_input(

     

       
589
       
 
       
    config: FetchConfig,

     

       
590
       
 
       
    input_file: Path,

     

       
591
       
 
       
    deprecated: Path,

     

       
592
       
-
       
    redirects: Dict[str, str] = None,

     

       
593
       
-
       
    append: Tuple = (),

     

       
0
       
 
       

     

       
594
       
 
       
):

     

       
595
       
-
       
    with open(input_file, "r") as f:

     

       
596
       
-
       
        lines = f.readlines()

     

       
597
       
 
       


     

       
598
       
-
       
    lines.extend(append)

     

       
599
       
 
       


     

       
600
       
 
       
    if redirects:

     

       
601
       
-
       
        lines = [redirects.get(line, line) for line in lines]

     

       
602
       
 
       


     

       
603
       
 
       
        cur_date_iso = datetime.now().strftime("%Y-%m-%d")

     

       
604
       
 
       
        with open(deprecated, "r") as f:

     

       
605
       
 
       
            deprecations = json.load(f)

     

       
606
       
 
       
        for old, new in redirects.items():

     

       
607
       
-
       
            old_plugin = fetch_plugin_from_pluginline(config, old)

     

       
608
       
-
       
            new_plugin = fetch_plugin_from_pluginline(config, new)

     

       
609
       
 
       
            if old_plugin.normalized_name != new_plugin.normalized_name:

     

       
610
       
 
       
                deprecations[old_plugin.normalized_name] = {

     

       
611
       
 
       
                    "new": new_plugin.normalized_name,

     
···

       
614
       
 
       
        with open(deprecated, "w") as f:

     

       
615
       
 
       
            json.dump(deprecations, f, indent=4, sort_keys=True)

     

       
616
       
 
       
            f.write("\n")

     

       
617
       
-
       


     

       
618
       
-
       
    lines = sorted(lines, key=str.casefold)

     

       
619
       
 
       


     

       
620
       
 
       
    with open(input_file, "w") as f:

     

       
621
       
-
       
        f.writelines(lines)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
622
       
 
       


     

       
623
       
 
       


     

       
624
       
 
       
def commit(repo: git.Repo, message: str, files: List[Path]) -> None:

     
···

       
660
       
 
       
            )

     

       
661
       
 
       


     

       
662
       
 
       
    for plugin_line in args.add_plugins:

     

       
663
       
-
       
        editor.rewrite_input(fetch_config, args.input_file, editor.deprecated, append=(plugin_line + "\n",))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
664
       
 
       
        update()

     

       
665
       
-
       
        plugin = fetch_plugin_from_pluginline(fetch_config, plugin_line)

     

       
666
       
 
       
        if autocommit:

     

       
667
       
 
       
            commit(

     

       
668
       
 
       
                nixpkgs_repo,

     

···

       
8
       
 
       
# $ nix run nixpkgs.python3Packages.flake8 -c flake8 --ignore E501,E265 update.py

     

       
9
       
 
       


     

       
10
       
 
       
import argparse

     

       
11
       
+
       
import csv

     

       
12
       
 
       
import functools

     

       
13
       
 
       
import http

     

       
14
       
 
       
import json

     
···

       
29
       
 
       
from typing import Dict, List, Optional, Tuple, Union, Any, Callable

     

       
30
       
 
       
from urllib.parse import urljoin, urlparse

     

       
31
       
 
       
from tempfile import NamedTemporaryFile

     

       
32
       
+
       
from dataclasses import dataclass, asdict

     

       
33
       
 
       


     

       
34
       
 
       
import git

     

       
35
       
 
       


     
···

       
86
       
 
       
        headers["Authorization"] = f"token {token}"

     

       
87
       
 
       
    return urllib.request.Request(url, headers=headers)

     

       
88
       
 
       


     

       
89
       
+
       


     

       
90
       
+
       
Redirects = Dict['Repo', 'Repo']

     

       
91
       
+
       


     

       
92
       
 
       
class Repo:

     

       
93
       
 
       
    def __init__(

     

       
94
       
+
       
        self, uri: str, branch: str

     

       
95
       
 
       
    ) -> None:

     

       
96
       
 
       
        self.uri = uri

     

       
97
       
 
       
        '''Url to the repo'''

     

       
98
       
+
       
        self._branch = branch

     

       
99
       
+
       
        # {old_uri: new_uri}

     

       
100
       
+
       
        self.redirect: Redirects = {}

     

       
101
       
 
       
        self.token = "dummy_token"

     

       
102
       
 
       


     

       
103
       
 
       
    @property

     

       
104
       
 
       
    def name(self):

     

       
105
       
 
       
        return self.uri.split('/')[-1]

     

       
106
       
 
       


     

       
107
       
+
       
    @property

     

       
108
       
+
       
    def branch(self):

     

       
109
       
+
       
        return self._branch or "HEAD"

     

       
110
       
+
       


     

       
111
       
+
       
    def __str__(self) -> str:

     

       
112
       
+
       
        return f"{self.uri}"

     

       
113
       
 
       
    def __repr__(self) -> str:

     

       
114
       
 
       
        return f"Repo({self.name}, {self.uri})"

     

       
115
       
 
       


     
···

       
119
       
 
       


     

       
120
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
121
       
 
       
    def latest_commit(self) -> Tuple[str, datetime]:

     

       
122
       
+
       
        log.debug("Latest commit")

     

       
123
       
 
       
        loaded = self._prefetch(None)

     

       
124
       
 
       
        updated = datetime.strptime(loaded['date'], "%Y-%m-%dT%H:%M:%S%z")

     

       
125
       
 
       


     
···

       
135
       
 
       
        return loaded

     

       
136
       
 
       


     

       
137
       
 
       
    def prefetch(self, ref: Optional[str]) -> str:

     

       
138
       
+
       
        print("Prefetching")

     

       
139
       
 
       
        loaded = self._prefetch(ref)

     

       
140
       
 
       
        return loaded["sha256"]

     

       
141
       
 
       


     
···

       
149
       
 
       


     

       
150
       
 
       
class RepoGitHub(Repo):

     

       
151
       
 
       
    def __init__(

     

       
152
       
+
       
        self, owner: str, repo: str, branch: str

     

       
153
       
 
       
    ) -> None:

     

       
154
       
 
       
        self.owner = owner

     

       
155
       
 
       
        self.repo = repo

     

       
156
       
 
       
        self.token = None

     

       
157
       
 
       
        '''Url to the repo'''

     

       
158
       
+
       
        super().__init__(self.url(""), branch)

     

       
159
       
+
       
        log.debug("Instantiating github repo owner=%s and repo=%s", self.owner, self.repo)

     

       
160
       
 
       


     

       
161
       
 
       
    @property

     

       
162
       
 
       
    def name(self):

     

       
163
       
 
       
        return self.repo

     

       
164
       
 
       


     

       
165
       
 
       
    def url(self, path: str) -> str:

     

       
166
       
+
       
        res = urljoin(f"https://github.com/{self.owner}/{self.repo}/", path)

     

       
167
       
+
       
        return res

     

       
168
       
 
       


     

       
169
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
170
       
 
       
    def has_submodules(self) -> bool:

     
···

       
181
       
 
       
    @retry(urllib.error.URLError, tries=4, delay=3, backoff=2)

     

       
182
       
 
       
    def latest_commit(self) -> Tuple[str, datetime]:

     

       
183
       
 
       
        commit_url = self.url(f"commits/{self.branch}.atom")

     

       
184
       
+
       
        log.debug("Sending request to %s", commit_url)

     

       
185
       
 
       
        commit_req = make_request(commit_url, self.token)

     

       
186
       
 
       
        with urllib.request.urlopen(commit_req, timeout=10) as req:

     

       
187
       
 
       
            self._check_for_redirect(commit_url, req)

     
···

       
205
       
 
       
            new_owner, new_name = (

     

       
206
       
 
       
                urllib.parse.urlsplit(response_url).path.strip("/").split("/")[:2]

     

       
207
       
 
       
            )

     

       
0
       
 
       

     

       
0
       
 
       

     

       
208
       
 
       


     

       
209
       
+
       
            new_repo = RepoGitHub(owner=new_owner, repo=new_name, branch=self.branch)

     

       
210
       
+
       
            self.redirect[self] = new_repo

     

       
0
       
 
       

     

       
211
       
 
       


     

       
212
       
 
       


     

       
213
       
 
       
    def prefetch(self, commit: str) -> str:

     
···

       
218
       
 
       
        return sha256

     

       
219
       
 
       


     

       
220
       
 
       
    def prefetch_github(self, ref: str) -> str:

     

       
221
       
+
       
        cmd = ["nix-prefetch-url", "--unpack", self.url(f"archive/{ref}.tar.gz")]

     

       
222
       
+
       
        log.debug("Running %s", cmd)

     

       
223
       
+
       
        data = subprocess.check_output(cmd)

     

       
224
       
 
       
        return data.strip().decode("utf-8")

     

       
225
       
 
       


     

       
226
       
 
       
    def as_nix(self, plugin: "Plugin") -> str:

     
···

       
250
       
 
       
        else:

     

       
251
       
 
       
            return self.alias

     

       
252
       
 
       


     

       
253
       
+
       
    def __lt__(self, other):

     

       
254
       
+
       
        return self.repo.name < other.repo.name

     

       
255
       
 
       


     

       
256
       
+
       
    @staticmethod

     

       
257
       
+
       
    def load_from_csv(config: FetchConfig, row: Dict[str, str]) -> 'PluginDesc':

     

       
258
       
+
       
        branch = row["branch"]

     

       
259
       
+
       
        repo = make_repo(row['repo'], branch.strip())

     

       
260
       
+
       
        repo.token = config.github_token

     

       
261
       
+
       
        return PluginDesc(repo, branch.strip(), row["alias"])

     

       
262
       
+
       


     

       
263
       
+
       


     

       
264
       
+
       
    @staticmethod

     

       
265
       
+
       
    def load_from_string(config: FetchConfig, line: str) -> 'PluginDesc':

     

       
266
       
+
       
        branch = "HEAD"

     

       
267
       
+
       
        alias = None

     

       
268
       
+
       
        uri = line

     

       
269
       
+
       
        if " as " in uri:

     

       
270
       
+
       
            uri, alias = uri.split(" as ")

     

       
271
       
+
       
            alias = alias.strip()

     

       
272
       
+
       
        if "@" in uri:

     

       
273
       
+
       
            uri, branch = uri.split("@")

     

       
274
       
+
       
        repo = make_repo(uri.strip(), branch.strip())

     

       
275
       
+
       
        repo.token = config.github_token

     

       
276
       
+
       
        return PluginDesc(repo, branch.strip(), alias)

     

       
277
       
+
       


     

       
278
       
+
       
@dataclass

     

       
279
       
 
       
class Plugin:

     

       
280
       
+
       
    name: str

     

       
281
       
+
       
    commit: str

     

       
282
       
+
       
    has_submodules: bool

     

       
283
       
+
       
    sha256: str

     

       
284
       
+
       
    date: Optional[datetime] = None

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
285
       
 
       


     

       
286
       
 
       
    @property

     

       
287
       
 
       
    def normalized_name(self) -> str:

     
···

       
298
       
 
       
        return copy

     

       
299
       
 
       


     

       
300
       
 
       


     

       
301
       
+
       
def load_plugins_from_csv(config: FetchConfig, input_file: Path,) -> List[PluginDesc]:

     

       
302
       
+
       
    log.debug("Load plugins from csv %s", input_file)

     

       
303
       
+
       
    plugins = []

     

       
304
       
+
       
    with open(input_file, newline='') as csvfile:

     

       
305
       
+
       
        log.debug("Writing into %s", input_file)

     

       
306
       
+
       
        reader = csv.DictReader(csvfile,)

     

       
307
       
+
       
        for line in reader:

     

       
308
       
+
       
            plugin = PluginDesc.load_from_csv(config, line)

     

       
309
       
+
       
            plugins.append(plugin)

     

       
310
       
+
       


     

       
311
       
+
       
    return plugins

     

       
312
       
 
       


     

       
313
       
 
       
class Editor:

     

       
314
       
 
       
    """The configuration of the update script."""

     
···

       
337
       
 
       
        return get_current_plugins(self)

     

       
338
       
 
       


     

       
339
       
 
       
    def load_plugin_spec(self, config: FetchConfig, plugin_file) -> List[PluginDesc]:

     

       
340
       
+
       
        '''CSV spec'''

     

       
341
       
+
       
        return load_plugins_from_csv(config, plugin_file)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
342
       
 
       


     

       
343
       
 
       
    def generate_nix(self, plugins, outfile: str):

     

       
344
       
 
       
        '''Returns nothing for now, writes directly to outfile'''

     
···

       
349
       
 
       
        _prefetch = functools.partial(prefetch, cache=cache)

     

       
350
       
 
       


     

       
351
       
 
       
        def update() -> dict:

     

       
352
       
+
       
            plugins = self.load_plugin_spec(config, input_file)

     

       
353
       
 
       


     

       
354
       
 
       
            try:

     

       
355
       
 
       
                pool = Pool(processes=config.proc)

     

       
356
       
+
       
                results = pool.map(_prefetch, plugins)

     

       
357
       
 
       
            finally:

     

       
358
       
 
       
                cache.store()

     

       
359
       
 
       


     
···

       
456
       
 
       
    data = json.loads(out)

     

       
457
       
 
       
    plugins = []

     

       
458
       
 
       
    for name, attr in data.items():

     

       
459
       
+
       
        print("get_current_plugins: name %s" % name)

     

       
460
       
 
       
        p = Plugin(name, attr["rev"], attr["submodules"], attr["sha256"])

     

       
461
       
 
       
        plugins.append(p)

     

       
462
       
 
       
    return plugins

     
···

       
465
       
 
       
def prefetch_plugin(

     

       
466
       
 
       
    p: PluginDesc,

     

       
467
       
 
       
    cache: "Optional[Cache]" = None,

     

       
468
       
+
       
) -> Tuple[Plugin, Redirects]:

     

       
469
       
 
       
    repo, branch, alias = p.repo, p.branch, p.alias

     

       
470
       
 
       
    name = alias or p.repo.name

     

       
471
       
 
       
    commit = None

     
···

       
488
       
 
       
    )

     

       
489
       
 
       


     

       
490
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
491
       
 
       
def print_download_error(plugin: str, ex: Exception):

     

       
492
       
 
       
    print(f"{plugin}: {ex}", file=sys.stderr)

     

       
493
       
 
       
    ex_traceback = ex.__traceback__

     
···

       
497
       
 
       
    ]

     

       
498
       
 
       
    print("\n".join(tb_lines))

     

       
499
       
 
       


     

       
0
       
 
       

     

       
500
       
 
       
def check_results(

     

       
501
       
+
       
    results: List[Tuple[PluginDesc, Union[Exception, Plugin], Redirects]]

     

       
502
       
+
       
) -> Tuple[List[Tuple[PluginDesc, Plugin]], Redirects]:

     

       
503
       
 
       
    ''' '''

     

       
504
       
 
       
    failures: List[Tuple[str, Exception]] = []

     

       
505
       
 
       
    plugins = []

     

       
506
       
+
       
    # {old: new} plugindesc

     

       
507
       
+
       
    redirects: Dict[Repo, Repo] = {}

     

       
508
       
 
       
    for (pdesc, result, redirect) in results:

     

       
509
       
 
       
        if isinstance(result, Exception):

     

       
510
       
 
       
            failures.append((pdesc.name, result))

     
···

       
524
       
 
       


     

       
525
       
 
       
        sys.exit(1)

     

       
526
       
 
       


     

       
527
       
+
       
def make_repo(uri: str, branch) -> Repo:

     

       
528
       
 
       
    '''Instantiate a Repo with the correct specialization depending on server (gitub spec)'''

     

       
529
       
 
       
    # dumb check to see if it's of the form owner/repo (=> github) or https://...

     

       
530
       
+
       
    res = urlparse(uri)

     

       
531
       
+
       
    if res.netloc in [ "github.com", ""]:

     

       
532
       
+
       
        res = res.path.strip('/').split('/')

     

       
533
       
+
       
        repo = RepoGitHub(res[0], res[1], branch)

     

       
534
       
 
       
    else:

     

       
535
       
+
       
        repo = Repo(uri.strip(), branch)

     

       
536
       
 
       
    return repo

     

       
537
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
538
       
 
       


     

       
539
       
 
       
def get_cache_path(cache_file_name: str) -> Optional[Path]:

     

       
540
       
 
       
    xdg_cache = os.environ.get("XDG_CACHE_HOME", None)

     
···

       
600
       
 
       
        return (pluginDesc, e, {})

     

       
601
       
 
       


     

       
602
       
 
       


     

       
603
       
+
       


     

       
604
       
 
       
def rewrite_input(

     

       
605
       
 
       
    config: FetchConfig,

     

       
606
       
 
       
    input_file: Path,

     

       
607
       
 
       
    deprecated: Path,

     

       
608
       
+
       
    # old pluginDesc and the new

     

       
609
       
+
       
    redirects: Dict[PluginDesc, PluginDesc] = {},

     

       
610
       
+
       
    append: List[PluginDesc] = [],

     

       
611
       
 
       
):

     

       
612
       
+
       
    plugins = load_plugins_from_csv(config, input_file,)

     

       
0
       
 
       

     

       
613
       
 
       


     

       
614
       
+
       
    plugins.extend(append)

     

       
615
       
 
       


     

       
616
       
 
       
    if redirects:

     

       
0
       
 
       

     

       
617
       
 
       


     

       
618
       
 
       
        cur_date_iso = datetime.now().strftime("%Y-%m-%d")

     

       
619
       
 
       
        with open(deprecated, "r") as f:

     

       
620
       
 
       
            deprecations = json.load(f)

     

       
621
       
 
       
        for old, new in redirects.items():

     

       
622
       
+
       
            old_plugin, _ = prefetch_plugin(old)

     

       
623
       
+
       
            new_plugin, _ = prefetch_plugin(new)

     

       
624
       
 
       
            if old_plugin.normalized_name != new_plugin.normalized_name:

     

       
625
       
 
       
                deprecations[old_plugin.normalized_name] = {

     

       
626
       
 
       
                    "new": new_plugin.normalized_name,

     
···

       
629
       
 
       
        with open(deprecated, "w") as f:

     

       
630
       
 
       
            json.dump(deprecations, f, indent=4, sort_keys=True)

     

       
631
       
 
       
            f.write("\n")

     

       
0
       
 
       

     

       
0
       
 
       

     

       
632
       
 
       


     

       
633
       
 
       
    with open(input_file, "w") as f:

     

       
634
       
+
       
        log.debug("Writing into %s", input_file)

     

       
635
       
+
       
        # fields = dataclasses.fields(PluginDesc)

     

       
636
       
+
       
        fieldnames = ['repo', 'branch', 'alias']

     

       
637
       
+
       
        writer = csv.DictWriter(f, fieldnames, dialect='unix', quoting=csv.QUOTE_NONE)

     

       
638
       
+
       
        writer.writeheader()

     

       
639
       
+
       
        for plugin in sorted(plugins):

     

       
640
       
+
       
            writer.writerow(asdict(plugin))

     

       
641
       
 
       


     

       
642
       
 
       


     

       
643
       
 
       
def commit(repo: git.Repo, message: str, files: List[Path]) -> None:

     
···

       
679
       
 
       
            )

     

       
680
       
 
       


     

       
681
       
 
       
    for plugin_line in args.add_plugins:

     

       
682
       
+
       
        pdesc = PluginDesc.load_from_string(fetch_config, plugin_line)

     

       
683
       
+
       
        append = [ pdesc ]

     

       
684
       
+
       
        editor.rewrite_input(fetch_config, args.input_file, editor.deprecated, append=append)

     

       
685
       
 
       
        update()

     

       
686
       
+
       
        plugin, _ = prefetch_plugin(pdesc, )

     

       
687
       
 
       
        if autocommit:

     

       
688
       
 
       
            commit(

     

       
689
       
 
       
                nixpkgs_repo,

     

···

       
866
       
 
       
          package.

     

       
867
       
 
       
        </para>

     

       
868
       
 
       
      </listitem>

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
869
       
 
       
    </itemizedlist>

     

       
870
       
 
       
  </section>

     

       
871
       
 
       
</section>

     

···

       
866
       
 
       
          package.

     

       
867
       
 
       
        </para>

     

       
868
       
 
       
      </listitem>

     

       
869
       
+
       
      <listitem>

     

       
870
       
+
       
        <para>

     

       
871
       
+
       
          The vim/kakoune plugin updater now reads from a CSV file:

     

       
872
       
+
       
          check

     

       
873
       
+
       
          <literal>pkgs/applications/editors/vim/plugins/vim-plugin-names</literal>

     

       
874
       
+
       
          out to see the new format

     

       
875
       
+
       
        </para>

     

       
876
       
+
       
      </listitem>

     

       
877
       
 
       
    </itemizedlist>

     

       
878
       
 
       
  </section>

     

       
879
       
 
       
</section>

     

···

       
282
       
 
       
- The NixOS test driver supports user services declared by `systemd.user.services`. The methods `waitForUnit`, `getUnitInfo`, `startJob` and `stopJob` provide an optional `$user` argument for that purpose.

     

       
283
       
 
       


     

       
284
       
 
       
- Enabling bash completion on NixOS, `programs.bash.enableCompletion`, will now also enable completion for the Nix command line tools by installing the [nix-bash-completions](https://github.com/hedning/nix-bash-completions) package.

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
282
       
 
       
- The NixOS test driver supports user services declared by `systemd.user.services`. The methods `waitForUnit`, `getUnitInfo`, `startJob` and `stopJob` provide an optional `$user` argument for that purpose.

     

       
283
       
 
       


     

       
284
       
 
       
- Enabling bash completion on NixOS, `programs.bash.enableCompletion`, will now also enable completion for the Nix command line tools by installing the [nix-bash-completions](https://github.com/hedning/nix-bash-completions) package.

     

       
285
       
+
       


     

       
286
       
+
       
- The vim/kakoune plugin updater now reads from a CSV file: check `pkgs/applications/editors/vim/plugins/vim-plugin-names` out to see the new format

     

···

       
170
       
 
       
      config.system.build.nixos-install

     

       
171
       
 
       
      config.system.build.nixos-enter

     

       
172
       
 
       
      nix

     

       
0
       
 
       

     

       
173
       
 
       
    ] ++ stdenv.initialPath);

     

       
174
       
 
       


     

       
175
       
 
       
  # I'm preserving the line below because I'm going to search for it across nixpkgs to consolidate

     

···

       
170
       
 
       
      config.system.build.nixos-install

     

       
171
       
 
       
      config.system.build.nixos-enter

     

       
172
       
 
       
      nix

     

       
173
       
+
       
      systemdMinimal

     

       
174
       
 
       
    ] ++ stdenv.initialPath);

     

       
175
       
 
       


     

       
176
       
 
       
  # I'm preserving the line below because I'm going to search for it across nixpkgs to consolidate

     

···

       
108
       
 
       


     

       
109
       
 
       
  fileSystems = filter utils.fsNeededForBoot config.system.build.fileSystems;

     

       
110
       
 
       


     

       
111
       
-
       
  fstab = pkgs.writeText "fstab" (lib.concatMapStringsSep "\n"

     

       
112
       
 
       
    ({ fsType, mountPoint, device, options, autoFormat, autoResize, ... }@fs: let

     

       
113
       
 
       
        opts = options ++ optional autoFormat "x-systemd.makefs" ++ optional autoResize "x-systemd.growfs";

     

       
114
       
 
       
      in "${device} /sysroot${mountPoint} ${fsType} ${lib.concatStringsSep "," opts}") fileSystems);

     
···

       
128
       
 
       
    name = "initrd-emergency-env";

     

       
129
       
 
       
    paths = map getBin cfg.initrdBin;

     

       
130
       
 
       
    pathsToLink = ["/bin" "/sbin"];

     

       
131
       
-
       
    # Make recovery easier

     

       
132
       
-
       
    postBuild = ''

     

       
133
       
-
       
      ln -s ${cfg.package.util-linux}/bin/mount $out/bin/

     

       
134
       
-
       
      ln -s ${cfg.package.util-linux}/bin/umount $out/bin/

     

       
135
       
-
       
    '';

     

       
136
       
 
       
  };

     

       
137
       
 
       


     

       
138
       
 
       
  initialRamdisk = pkgs.makeInitrdNG {

     
···

       
203
       
 
       
      '';

     

       
204
       
 
       
      type = types.listOf types.singleLineStr;

     

       
205
       
 
       
      default = [];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
206
       
 
       
    };

     

       
207
       
 
       


     

       
208
       
 
       
    suppressedStorePaths = mkOption {

     
···

       
342
       
 
       


     

       
343
       
 
       
  config = mkIf (config.boot.initrd.enable && cfg.enable) {

     

       
344
       
 
       
    system.build = { inherit initialRamdisk; };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
345
       
 
       
    boot.initrd.systemd = {

     

       
346
       
 
       
      initrdBin = [pkgs.bash pkgs.coreutils pkgs.kmod cfg.package] ++ config.system.fsPackages;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
347
       
 
       


     

       
348
       
 
       
      contents = {

     

       
349
       
 
       
        "/init".source = "${cfg.package}/lib/systemd/systemd";

     

···

       
108
       
 
       


     

       
109
       
 
       
  fileSystems = filter utils.fsNeededForBoot config.system.build.fileSystems;

     

       
110
       
 
       


     

       
111
       
+
       
  fstab = pkgs.writeText "initrd-fstab" (lib.concatMapStringsSep "\n"

     

       
112
       
 
       
    ({ fsType, mountPoint, device, options, autoFormat, autoResize, ... }@fs: let

     

       
113
       
 
       
        opts = options ++ optional autoFormat "x-systemd.makefs" ++ optional autoResize "x-systemd.growfs";

     

       
114
       
 
       
      in "${device} /sysroot${mountPoint} ${fsType} ${lib.concatStringsSep "," opts}") fileSystems);

     
···

       
128
       
 
       
    name = "initrd-emergency-env";

     

       
129
       
 
       
    paths = map getBin cfg.initrdBin;

     

       
130
       
 
       
    pathsToLink = ["/bin" "/sbin"];

     

       
131
       
+
       
    postBuild = concatStringsSep "\n" (mapAttrsToList (n: v: "ln -s '${v}' $out/bin/'${n}'") cfg.extraBin);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
132
       
 
       
  };

     

       
133
       
 
       


     

       
134
       
 
       
  initialRamdisk = pkgs.makeInitrdNG {

     
···

       
199
       
 
       
      '';

     

       
200
       
 
       
      type = types.listOf types.singleLineStr;

     

       
201
       
 
       
      default = [];

     

       
202
       
+
       
    };

     

       
203
       
+
       


     

       
204
       
+
       
    extraBin = mkOption {

     

       
205
       
+
       
      description = ''

     

       
206
       
+
       
        Tools to add to /bin

     

       
207
       
+
       
      '';

     

       
208
       
+
       
      example = literalExpression ''

     

       
209
       
+
       
        {

     

       
210
       
+
       
          umount = ''${pkgs.util-linux}/bin/umount;

     

       
211
       
+
       
        }

     

       
212
       
+
       
      '';

     

       
213
       
+
       
      type = types.attrsOf types.path;

     

       
214
       
+
       
      default = {};

     

       
215
       
 
       
    };

     

       
216
       
 
       


     

       
217
       
 
       
    suppressedStorePaths = mkOption {

     
···

       
351
       
 
       


     

       
352
       
 
       
  config = mkIf (config.boot.initrd.enable && cfg.enable) {

     

       
353
       
 
       
    system.build = { inherit initialRamdisk; };

     

       
354
       
+
       


     

       
355
       
+
       
    boot.initrd.availableKernelModules = [ "autofs4" ]; # systemd needs this for some features

     

       
356
       
+
       


     

       
357
       
 
       
    boot.initrd.systemd = {

     

       
358
       
 
       
      initrdBin = [pkgs.bash pkgs.coreutils pkgs.kmod cfg.package] ++ config.system.fsPackages;

     

       
359
       
+
       
      extraBin = {

     

       
360
       
+
       
        mount = "${cfg.package.util-linux}/bin/mount";

     

       
361
       
+
       
        umount = "${cfg.package.util-linux}/bin/umount";

     

       
362
       
+
       
      };

     

       
363
       
 
       


     

       
364
       
 
       
      contents = {

     

       
365
       
 
       
        "/init".source = "${cfg.package}/lib/systemd/systemd";

     

···

       
7
       
 
       
let

     

       
8
       
 
       


     

       
9
       
 
       
  remoteSystem =

     

       
10
       
-
       
    if pkgs.system == "aarch64-linux"

     

       
11
       
 
       
    then "x86_64-linux"

     

       
12
       
 
       
    else "aarch64-linux";

     

       
13
       
 
       


     
···

       
18
       
 
       


     

       
19
       
 
       
    # NOTE: Since this file can't control where the test will be _run_ we don't

     

       
20
       
 
       
    #       cross-compile _to_ a different system but _from_ a different system

     

       
21
       
-
       
    crossSystem = pkgs.system;

     

       
22
       
 
       
  };

     

       
23
       
 
       


     

       
24
       
 
       
  hello1 = remoteCrossPkgs.dockerTools.buildImage {

     

···

       
7
       
 
       
let

     

       
8
       
 
       


     

       
9
       
 
       
  remoteSystem =

     

       
10
       
+
       
    if pkgs.stdenv.hostPlatform.system == "aarch64-linux"

     

       
11
       
 
       
    then "x86_64-linux"

     

       
12
       
 
       
    else "aarch64-linux";

     

       
13
       
 
       


     
···

       
18
       
 
       


     

       
19
       
 
       
    # NOTE: Since this file can't control where the test will be _run_ we don't

     

       
20
       
 
       
    #       cross-compile _to_ a different system but _from_ a different system

     

       
21
       
+
       
    crossSystem = pkgs.stdenv.hostPlatform.system;

     

       
22
       
 
       
  };

     

       
23
       
 
       


     

       
24
       
 
       
  hello1 = remoteCrossPkgs.dockerTools.buildImage {

     

···

       
315
       
 
       
                "docker inspect ${pkgs.dockerTools.examples.cross.imageName} "

     

       
316
       
 
       
                + "| ${pkgs.jq}/bin/jq -r .[].Architecture"

     

       
317
       
 
       
            ).strip()

     

       
318
       
-
       
            == "${if pkgs.system == "aarch64-linux" then "amd64" else "arm64"}"

     

       
319
       
 
       
        )

     

       
320
       
 
       


     

       
321
       
 
       
    with subtest("buildLayeredImage doesn't dereference /nix/store symlink layers"):

     

···

       
315
       
 
       
                "docker inspect ${pkgs.dockerTools.examples.cross.imageName} "

     

       
316
       
 
       
                + "| ${pkgs.jq}/bin/jq -r .[].Architecture"

     

       
317
       
 
       
            ).strip()

     

       
318
       
+
       
            == "${if pkgs.stdenv.hostPlatform.system == "aarch64-linux" then "amd64" else "arm64"}"

     

       
319
       
 
       
        )

     

       
320
       
 
       


     

       
321
       
 
       
    with subtest("buildLayeredImage doesn't dereference /nix/store symlink layers"):

     

···

       
113
       
 
       
                  driver.find_element_by_css_selector('input#masterPasswordRetype').send_keys(

     

       
114
       
 
       
                    '${userPassword}'

     

       
115
       
 
       
                  )

     

       
116
       
-
       
                  driver.find_element_by_css_selector('input#acceptPolicies').click()

     

       
117
       
 
       


     

       
118
       
 
       
                  driver.find_element_by_xpath("//button[contains(., 'Submit')]").click()

     

       
119
       
 
       


     

···

       
113
       
 
       
                  driver.find_element_by_css_selector('input#masterPasswordRetype').send_keys(

     

       
114
       
 
       
                    '${userPassword}'

     

       
115
       
 
       
                  )

     

       
0
       
 
       

     

       
116
       
 
       


     

       
117
       
 
       
                  driver.find_element_by_xpath("//button[contains(., 'Submit')]").click()

     

       
118
       
 
       


     

···

       
1
       
-
       
alexherbo2/auto-pairs.kak

     

       
2
       
-
       
alexherbo2/replace-mode.kak

     

       
3
       
-
       
alexherbo2/sleuth.kak

     

       
4
       
-
       
andreyorst/fzf.kak

     

       
5
       
-
       
andreyorst/powerline.kak

     

       
6
       
-
       
basbebe/pandoc.kak

     

       
7
       
-
       
danr/kakoune-easymotion

     

       
8
       
-
       
Delapouite/kakoune-buffers

     

       
9
       
-
       
Delapouite/kakoune-registers

     

       
10
       
-
       
enricozb/tabs.kak@main

     

       
11
       
-
       
greenfork/active-window.kak

     

       
12
       
-
       
kakoune-editor/kakoune-extra-filetypes

     

       
13
       
-
       
kakounedotcom/connect.kak

     

       
14
       
-
       
kakounedotcom/prelude.kak

     

       
15
       
-
       
lePerdu/kakboard

     

       
16
       
-
       
listentolist/kakoune-rainbow

     

       
17
       
-
       
mayjs/openscad.kak

     

       
18
       
-
       
occivink/kakoune-buffer-switcher

     

       
19
       
-
       
occivink/kakoune-vertical-selection

     

       
0
       
 
       

     

···

       
1
       
+
       
repo,branch,alias

     

       
2
       
+
       
alexherbo2/auto-pairs.kak,,

     

       
3
       
+
       
alexherbo2/replace-mode.kak,,

     

       
4
       
+
       
alexherbo2/sleuth.kak,,

     

       
5
       
+
       
andreyorst/fzf.kak,,

     

       
6
       
+
       
andreyorst/powerline.kak,,

     

       
7
       
+
       
basbebe/pandoc.kak,,

     

       
8
       
+
       
danr/kakoune-easymotion,,

     

       
9
       
+
       
Delapouite/kakoune-buffers,,

     

       
10
       
+
       
Delapouite/kakoune-registers,,

     

       
11
       
+
       
enricozb/tabs.kak@main,,

     

       
12
       
+
       
greenfork/active-window.kak,,

     

       
13
       
+
       
kakoune-editor/kakoune-extra-filetypes,,

     

       
14
       
+
       
kakounedotcom/connect.kak,,

     

       
15
       
+
       
kakounedotcom/prelude.kak,,

     

       
16
       
+
       
lePerdu/kakboard,,

     

       
17
       
+
       
listentolist/kakoune-rainbow,,

     

       
18
       
+
       
mayjs/openscad.kak,,

     

       
19
       
+
       
occivink/kakoune-buffer-switcher,,

     

       
20
       
+
       
occivink/kakoune-vertical-selection,,

     

···

       
3
       
 
       


     

       
4
       
 
       
final: prev:

     

       
5
       
 
       
{

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       
  a-vim = buildVimPluginFrom2Nix {

     

       
7
       
 
       
    pname = "a.vim";

     

       
8
       
 
       
    version = "2010-11-06";

     
···

       
41
       
 
       


     

       
42
       
 
       
  aerial-nvim = buildVimPluginFrom2Nix {

     

       
43
       
 
       
    pname = "aerial.nvim";

     

       
44
       
-
       
    version = "2022-03-24";

     

       
45
       
 
       
    src = fetchFromGitHub {

     

       
46
       
 
       
      owner = "stevearc";

     

       
47
       
 
       
      repo = "aerial.nvim";

     

       
48
       
-
       
      rev = "b9f6067529ef123b8ace705ea356869f66aad320";

     

       
49
       
-
       
      sha256 = "1wcdshvq2nw1dx8xxzplvq519bzzb3qgf7lh0sqafjd19nzgwiji";

     

       
50
       
 
       
    };

     

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

     

       
52
       
 
       
  };

     
···

       
77
       
 
       


     

       
78
       
 
       
  ale = buildVimPluginFrom2Nix {

     

       
79
       
 
       
    pname = "ale";

     

       
80
       
-
       
    version = "2022-03-23";

     

       
81
       
 
       
    src = fetchFromGitHub {

     

       
82
       
 
       
      owner = "dense-analysis";

     

       
83
       
 
       
      repo = "ale";

     

       
84
       
-
       
      rev = "80dcd648d389965603246c2c5a4554e3e4aa184c";

     

       
85
       
-
       
      sha256 = "1a38q83sgv13aw3iy40mjzkg1wsc5zmf5mmkjqpdcgv5aixyb8m5";

     

       
86
       
 
       
    };

     

       
87
       
 
       
    meta.homepage = "https://github.com/dense-analysis/ale/";

     

       
88
       
 
       
  };

     
···

       
101
       
 
       


     

       
102
       
 
       
  aniseed = buildVimPluginFrom2Nix {

     

       
103
       
 
       
    pname = "aniseed";

     

       
104
       
-
       
    version = "2022-03-21";

     

       
105
       
 
       
    src = fetchFromGitHub {

     

       
106
       
 
       
      owner = "Olical";

     

       
107
       
 
       
      repo = "aniseed";

     

       
108
       
-
       
      rev = "bd79727af8a21037222a08ec9bcaf1c85488aaa4";

     

       
109
       
-
       
      sha256 = "0l4hvhmf9cgw921956rh97x6aqhjzs2jxsdnk2m38a9fr738hknk";

     

       
110
       
 
       
    };

     

       
111
       
 
       
    meta.homepage = "https://github.com/Olical/aniseed/";

     

       
112
       
 
       
  };

     
···

       
365
       
 
       


     

       
366
       
 
       
  better-escape-nvim = buildVimPluginFrom2Nix {

     

       
367
       
 
       
    pname = "better-escape.nvim";

     

       
368
       
-
       
    version = "2022-03-14";

     

       
369
       
 
       
    src = fetchFromGitHub {

     

       
370
       
 
       
      owner = "max397574";

     

       
371
       
 
       
      repo = "better-escape.nvim";

     

       
372
       
-
       
      rev = "d2efbf0093235525e81f537f8f4e63f23acedf06";

     

       
373
       
-
       
      sha256 = "1xx23v9jgpzdhyp1diyq0vc36vlxzljx36qnax2cms36kfnc398l";

     

       
374
       
 
       
    };

     

       
375
       
 
       
    meta.homepage = "https://github.com/max397574/better-escape.nvim/";

     

       
376
       
-
       
  };

     

       
377
       
-
       


     

       
378
       
-
       
  BetterLua-vim = buildVimPluginFrom2Nix {

     

       
379
       
-
       
    pname = "BetterLua.vim";

     

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

     

       
381
       
-
       
    src = fetchFromGitHub {

     

       
382
       
-
       
      owner = "euclidianAce";

     

       
383
       
-
       
      repo = "BetterLua.vim";

     

       
384
       
-
       
      rev = "d2d6c115575d09258a794a6f20ac60233eee59d5";

     

       
385
       
-
       
      sha256 = "1rvlx21kw8865dg6q97hx9i2s1n8mn1nyhn0m7dkx625pghsx3js";

     

       
386
       
-
       
    };

     

       
387
       
-
       
    meta.homepage = "https://github.com/euclidianAce/BetterLua.vim/";

     

       
388
       
 
       
  };

     

       
389
       
 
       


     

       
390
       
 
       
  bitbake-vim = buildVimPluginFrom2Nix {

     
···

       
461
       
 
       


     

       
462
       
 
       
  bufferline-nvim = buildVimPluginFrom2Nix {

     

       
463
       
 
       
    pname = "bufferline.nvim";

     

       
464
       
-
       
    version = "2022-03-21";

     

       
465
       
 
       
    src = fetchFromGitHub {

     

       
466
       
 
       
      owner = "akinsho";

     

       
467
       
 
       
      repo = "bufferline.nvim";

     

       
468
       
-
       
      rev = "e1202c6569353d03ef0cb3da11b839dba26854dd";

     

       
469
       
-
       
      sha256 = "1nd5pvbg0yw8jl4rn56dzhabmiwkvlzb8iv595rrkqdb2msdl4qx";

     

       
470
       
 
       
    };

     

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

     

       
472
       
-
       
  };

     

       
473
       
-
       


     

       
474
       
-
       
  BufOnly-vim = buildVimPluginFrom2Nix {

     

       
475
       
-
       
    pname = "BufOnly.vim";

     

       
476
       
-
       
    version = "2010-10-18";

     

       
477
       
-
       
    src = fetchFromGitHub {

     

       
478
       
-
       
      owner = "vim-scripts";

     

       
479
       
-
       
      repo = "BufOnly.vim";

     

       
480
       
-
       
      rev = "43dd92303979bdb234a3cb2f5662847f7a3affe7";

     

       
481
       
-
       
      sha256 = "1gvpaqvvxjma0dl1zai68bpv42608api4054appwkw9pgczkkcdl";

     

       
482
       
-
       
    };

     

       
483
       
-
       
    meta.homepage = "https://github.com/vim-scripts/BufOnly.vim/";

     

       
484
       
 
       
  };

     

       
485
       
 
       


     

       
486
       
 
       
  calendar-vim = buildVimPluginFrom2Nix {

     
···

       
507
       
 
       
    meta.homepage = "https://github.com/bkad/camelcasemotion/";

     

       
508
       
 
       
  };

     

       
509
       
 
       


     

       
510
       
-
       
  catppuccin-nvim = buildVimPluginFrom2Nix {

     

       
511
       
-
       
    pname = "catppuccin-nvim";

     

       
512
       
-
       
    version = "2022-03-20";

     

       
513
       
-
       
    src = fetchFromGitHub {

     

       
514
       
-
       
      owner = "catppuccin";

     

       
515
       
-
       
      repo = "nvim";

     

       
516
       
-
       
      rev = "f079dda3dc23450d69b4bad11bfbd9af2c77f6f3";

     

       
517
       
-
       
      sha256 = "1w0n96fbrkm3vdl64v1yzkly8wpcn5g9qflmpb8r1ww9hhig7a38";

     

       
518
       
-
       
    };

     

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

     

       
520
       
-
       
  };

     

       
521
       
-
       


     

       
522
       
 
       
  caw-vim = buildVimPluginFrom2Nix {

     

       
523
       
 
       
    pname = "caw.vim";

     

       
524
       
 
       
    version = "2021-09-20";

     
···

       
531
       
 
       
    meta.homepage = "https://github.com/tyru/caw.vim/";

     

       
532
       
 
       
  };

     

       
533
       
 
       


     

       
534
       
-
       
  chadtree = buildVimPluginFrom2Nix {

     

       
535
       
-
       
    pname = "chadtree";

     

       
536
       
-
       
    version = "2022-03-24";

     

       
537
       
-
       
    src = fetchFromGitHub {

     

       
538
       
-
       
      owner = "ms-jpq";

     

       
539
       
-
       
      repo = "chadtree";

     

       
540
       
-
       
      rev = "e9606bfa350f277d54a61742d560e6122dc4d32c";

     

       
541
       
-
       
      sha256 = "1vyg48ghr8fd15fh41pk5qlgngdqkw8gwhkkyq9hbvs2mxw8x80c";

     

       
542
       
-
       
    };

     

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

     

       
544
       
-
       
  };

     

       
545
       
-
       


     

       
546
       
 
       
  changeColorScheme-vim = buildVimPluginFrom2Nix {

     

       
547
       
 
       
    pname = "changeColorScheme.vim";

     

       
548
       
 
       
    version = "2010-10-18";

     
···

       
565
       
 
       
      sha256 = "0dm94kppbnky8y0gs1pdfs7vcc9hyp8lf6h33dw6ndqfnw3hd2ad";

     

       
566
       
 
       
    };

     

       
567
       
 
       
    meta.homepage = "https://github.com/sudormrfbin/cheatsheet.nvim/";

     

       
568
       
-
       
  };

     

       
569
       
-
       


     

       
570
       
-
       
  CheckAttach = buildVimPluginFrom2Nix {

     

       
571
       
-
       
    pname = "CheckAttach";

     

       
572
       
-
       
    version = "2019-05-08";

     

       
573
       
-
       
    src = fetchFromGitHub {

     

       
574
       
-
       
      owner = "chrisbra";

     

       
575
       
-
       
      repo = "CheckAttach";

     

       
576
       
-
       
      rev = "8f0b1350431d1d34655a147e6f1cfe6cb5dda5f7";

     

       
577
       
-
       
      sha256 = "1z9a40nbdjd3pnp28nfsi2bijsbaiphc0ia816f5flkchn07gmmj";

     

       
578
       
-
       
    };

     

       
579
       
-
       
    meta.homepage = "https://github.com/chrisbra/CheckAttach/";

     

       
580
       
 
       
  };

     

       
581
       
 
       


     

       
582
       
 
       
  ci_dark = buildVimPluginFrom2Nix {

     
···

       
821
       
 
       


     

       
822
       
 
       
  cmp-tabnine = buildVimPluginFrom2Nix {

     

       
823
       
 
       
    pname = "cmp-tabnine";

     

       
824
       
-
       
    version = "2022-01-26";

     

       
825
       
 
       
    src = fetchFromGitHub {

     

       
826
       
 
       
      owner = "tzachar";

     

       
827
       
 
       
      repo = "cmp-tabnine";

     

       
828
       
-
       
      rev = "2a051347190a22b738e9784426199b9db745e1da";

     

       
829
       
-
       
      sha256 = "1z3imhw4jgswd957aqhf1yf5dihb1k9dfd22abshziv45fb0fggy";

     

       
830
       
 
       
    };

     

       
831
       
 
       
    meta.homepage = "https://github.com/tzachar/cmp-tabnine/";

     

       
832
       
 
       
  };

     
···

       
881
       
 
       


     

       
882
       
 
       
  cmp_luasnip = buildVimPluginFrom2Nix {

     

       
883
       
 
       
    pname = "cmp_luasnip";

     

       
884
       
-
       
    version = "2022-03-26";

     

       
885
       
 
       
    src = fetchFromGitHub {

     

       
886
       
 
       
      owner = "saadparwaiz1";

     

       
887
       
 
       
      repo = "cmp_luasnip";

     

       
888
       
-
       
      rev = "85f2767842a35064f61128b71b8dab1e38c413c4";

     

       
889
       
-
       
      sha256 = "13s04x9vx3n854q9abb0knls5aycxigbwqgllfmp2xgaycgxqksa";

     

       
890
       
 
       
    };

     

       
891
       
 
       
    meta.homepage = "https://github.com/saadparwaiz1/cmp_luasnip/";

     

       
892
       
 
       
  };

     
···

       
987
       
 
       
    meta.homepage = "https://github.com/iamcco/coc-tailwindcss/";

     

       
988
       
 
       
  };

     

       
989
       
 
       


     

       
990
       
-
       
  coc-nvim = buildVimPluginFrom2Nix {

     

       
991
       
-
       
    pname = "coc.nvim";

     

       
992
       
-
       
    version = "2022-03-26";

     

       
993
       
-
       
    src = fetchFromGitHub {

     

       
994
       
-
       
      owner = "neoclide";

     

       
995
       
-
       
      repo = "coc.nvim";

     

       
996
       
-
       
      rev = "16e74f9b31d20b8dfc8933132beed4c175d824ea";

     

       
997
       
-
       
      sha256 = "0nrfm8517fz31qrg0gfh888q7wcbxxkbpcp39ycvwkdfxpq1bzwr";

     

       
998
       
-
       
    };

     

       
999
       
-
       
    meta.homepage = "https://github.com/neoclide/coc.nvim/";

     

       
1000
       
-
       
  };

     

       
1001
       
-
       


     

       
1002
       
 
       
  codi-vim = buildVimPluginFrom2Nix {

     

       
1003
       
 
       
    pname = "codi.vim";

     

       
1004
       
 
       
    version = "2022-03-20";

     
···

       
1035
       
 
       
    meta.homepage = "https://github.com/lilydjwg/colorizer/";

     

       
1036
       
 
       
  };

     

       
1037
       
 
       


     

       
1038
       
-
       
  Colour-Sampler-Pack = buildVimPluginFrom2Nix {

     

       
1039
       
-
       
    pname = "Colour-Sampler-Pack";

     

       
1040
       
-
       
    version = "2012-11-30";

     

       
1041
       
-
       
    src = fetchFromGitHub {

     

       
1042
       
-
       
      owner = "vim-scripts";

     

       
1043
       
-
       
      repo = "Colour-Sampler-Pack";

     

       
1044
       
-
       
      rev = "05cded87b2ef29aaa9e930230bb88e23abff4441";

     

       
1045
       
-
       
      sha256 = "03v2r18sfgs0xbgy9p56pxfdg0lsk6m7wyr5hw63wm1nzpwiipg3";

     

       
1046
       
-
       
    };

     

       
1047
       
-
       
    meta.homepage = "https://github.com/vim-scripts/Colour-Sampler-Pack/";

     

       
1048
       
-
       
  };

     

       
1049
       
-
       


     

       
1050
       
 
       
  command-t = buildVimPluginFrom2Nix {

     

       
1051
       
 
       
    pname = "command-t";

     

       
1052
       
 
       
    version = "2022-02-25";

     
···

       
1062
       
 
       


     

       
1063
       
 
       
  comment-nvim = buildVimPluginFrom2Nix {

     

       
1064
       
 
       
    pname = "comment.nvim";

     

       
1065
       
-
       
    version = "2022-03-25";

     

       
1066
       
 
       
    src = fetchFromGitHub {

     

       
1067
       
 
       
      owner = "numtostr";

     

       
1068
       
 
       
      repo = "comment.nvim";

     

       
1069
       
-
       
      rev = "03b2a8f81102f2994f4888760e0f08385d841c3f";

     

       
1070
       
-
       
      sha256 = "1ilzpdyis41p1x6wbkavjpva5hvxclagw6hjn76vpmwibnz99pfy";

     

       
1071
       
 
       
    };

     

       
1072
       
 
       
    meta.homepage = "https://github.com/numtostr/comment.nvim/";

     

       
1073
       
 
       
  };

     
···

       
1206
       
 
       


     

       
1207
       
 
       
  conjure = buildVimPluginFrom2Nix {

     

       
1208
       
 
       
    pname = "conjure";

     

       
1209
       
-
       
    version = "2022-02-15";

     

       
1210
       
 
       
    src = fetchFromGitHub {

     

       
1211
       
 
       
      owner = "Olical";

     

       
1212
       
 
       
      repo = "conjure";

     

       
1213
       
-
       
      rev = "6c53d863c0843be0f68a138def146d6b8f725b22";

     

       
1214
       
-
       
      sha256 = "1f5z99ac72433f2nj714fk6xd76mq7yr5i5z1afwgrhx61zbwn5h";

     

       
1215
       
 
       
    };

     

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

     

       
1217
       
 
       
  };

     
···

       
1254
       
 
       


     

       
1255
       
 
       
  coq_nvim = buildVimPluginFrom2Nix {

     

       
1256
       
 
       
    pname = "coq_nvim";

     

       
1257
       
-
       
    version = "2022-03-26";

     

       
1258
       
 
       
    src = fetchFromGitHub {

     

       
1259
       
 
       
      owner = "ms-jpq";

     

       
1260
       
 
       
      repo = "coq_nvim";

     

       
1261
       
-
       
      rev = "ad255350b66809d4af3aae75f4fb4dd576a06ab4";

     

       
1262
       
-
       
      sha256 = "17l6ajaj03d5v8abi8m754ypqwhz1nw232n15y8av15ll0pb7gk0";

     

       
1263
       
 
       
    };

     

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

     

       
1265
       
-
       
  };

     

       
1266
       
-
       


     

       
1267
       
-
       
  Coqtail = buildVimPluginFrom2Nix {

     

       
1268
       
-
       
    pname = "Coqtail";

     

       
1269
       
-
       
    version = "2022-03-25";

     

       
1270
       
-
       
    src = fetchFromGitHub {

     

       
1271
       
-
       
      owner = "whonore";

     

       
1272
       
-
       
      repo = "Coqtail";

     

       
1273
       
-
       
      rev = "7a1cb8fb1cbdf136bba50a22ddcc056e83dc435c";

     

       
1274
       
-
       
      sha256 = "0jj966bansbfzbhbfgyqciis36s7z46n9n8ihy2m7vxynibbf9yp";

     

       
1275
       
-
       
    };

     

       
1276
       
-
       
    meta.homepage = "https://github.com/whonore/Coqtail/";

     

       
1277
       
 
       
  };

     

       
1278
       
 
       


     

       
1279
       
 
       
  cosco-vim = buildVimPluginFrom2Nix {

     
···

       
1772
       
 
       


     

       
1773
       
 
       
  diffview-nvim = buildVimPluginFrom2Nix {

     

       
1774
       
 
       
    pname = "diffview.nvim";

     

       
1775
       
-
       
    version = "2022-02-21";

     

       
1776
       
 
       
    src = fetchFromGitHub {

     

       
1777
       
 
       
      owner = "sindrets";

     

       
1778
       
 
       
      repo = "diffview.nvim";

     

       
1779
       
-
       
      rev = "cf32c3fcdbc2f6855f6bb883302c9f290e9c3d88";

     

       
1780
       
-
       
      sha256 = "0vikawxr40pkprsn8yzpacs33hfakpb98j5lmpf7sjmvyzkb1x8b";

     

       
1781
       
 
       
    };

     

       
1782
       
 
       
    meta.homepage = "https://github.com/sindrets/diffview.nvim/";

     

       
1783
       
 
       
  };

     
···

       
1796
       
 
       


     

       
1797
       
 
       
  doki-theme-vim = buildVimPluginFrom2Nix {

     

       
1798
       
 
       
    pname = "doki-theme-vim";

     

       
1799
       
-
       
    version = "2022-02-16";

     

       
1800
       
 
       
    src = fetchFromGitHub {

     

       
1801
       
 
       
      owner = "doki-theme";

     

       
1802
       
 
       
      repo = "doki-theme-vim";

     

       
1803
       
-
       
      rev = "fe7112ce7db0c8c65420e82aabfe7a98be2b538b";

     

       
1804
       
-
       
      sha256 = "07vy5kf7pqsdqsz5jmqj6lm2aizcncfi4j1vmkpnjw9rpp3c733r";

     

       
1805
       
 
       
    };

     

       
1806
       
 
       
    meta.homepage = "https://github.com/doki-theme/doki-theme-vim/";

     

       
1807
       
 
       
  };

     

       
1808
       
 
       


     

       
1809
       
-
       
  DoxygenToolkit-vim = buildVimPluginFrom2Nix {

     

       
1810
       
-
       
    pname = "DoxygenToolkit.vim";

     

       
1811
       
-
       
    version = "2010-11-06";

     

       
1812
       
-
       
    src = fetchFromGitHub {

     

       
1813
       
-
       
      owner = "vim-scripts";

     

       
1814
       
-
       
      repo = "DoxygenToolkit.vim";

     

       
1815
       
-
       
      rev = "afd8663d36d2ec19d26befdb10e89e912d26bbd3";

     

       
1816
       
-
       
      sha256 = "1za8li02j4nhqjjsyxg4p78638h5af4izim37zc0p1x55zr3i85r";

     

       
1817
       
-
       
    };

     

       
1818
       
-
       
    meta.homepage = "https://github.com/vim-scripts/DoxygenToolkit.vim/";

     

       
1819
       
-
       
  };

     

       
1820
       
-
       


     

       
1821
       
-
       
  dracula-vim = buildVimPluginFrom2Nix {

     

       
1822
       
-
       
    pname = "dracula-vim";

     

       
1823
       
-
       
    version = "2022-03-24";

     

       
1824
       
-
       
    src = fetchFromGitHub {

     

       
1825
       
-
       
      owner = "dracula";

     

       
1826
       
-
       
      repo = "vim";

     

       
1827
       
-
       
      rev = "d7723a842a6cfa2f62cf85530ab66eb418521dc2";

     

       
1828
       
-
       
      sha256 = "1qzil8rwpdzf64gq63ds0cf509ldam77l3fz02g1mia5dry75r02";

     

       
1829
       
-
       
    };

     

       
1830
       
-
       
    meta.homepage = "https://github.com/dracula/vim/";

     

       
1831
       
-
       
  };

     

       
1832
       
-
       


     

       
1833
       
 
       
  dressing-nvim = buildVimPluginFrom2Nix {

     

       
1834
       
 
       
    pname = "dressing.nvim";

     

       
1835
       
-
       
    version = "2022-03-24";

     

       
1836
       
 
       
    src = fetchFromGitHub {

     

       
1837
       
 
       
      owner = "stevearc";

     

       
1838
       
 
       
      repo = "dressing.nvim";

     

       
1839
       
-
       
      rev = "31f12fff6e71a14ddce30bfc7ec9b29a2137ccde";

     

       
1840
       
-
       
      sha256 = "0kjx04q2hnbvw68wh3d9li9p9s5d07j308kfhawpnhnmv6g57nzw";

     

       
1841
       
 
       
    };

     

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

     

       
1843
       
 
       
  };

     
···

       
1913
       
 
       
      sha256 = "133hr3i7zxysf2gnnimhz3gf3nda3fyfxmqq7mhq544v2mki4x9m";

     

       
1914
       
 
       
    };

     

       
1915
       
 
       
    meta.homepage = "https://github.com/dmix/elvish.vim/";

     

       
1916
       
-
       
  };

     

       
1917
       
-
       


     

       
1918
       
-
       
  embark-vim = buildVimPluginFrom2Nix {

     

       
1919
       
-
       
    pname = "embark-vim";

     

       
1920
       
-
       
    version = "2022-03-26";

     

       
1921
       
-
       
    src = fetchFromGitHub {

     

       
1922
       
-
       
      owner = "embark-theme";

     

       
1923
       
-
       
      repo = "vim";

     

       
1924
       
-
       
      rev = "3f7f03aa2ae0d4185792aaf9b960bca0d22c48fd";

     

       
1925
       
-
       
      sha256 = "0gv2ivrwsrhnsr2kh56yj3m1l4ydwq27vllzxa5vkpbb11jydf3d";

     

       
1926
       
-
       
    };

     

       
1927
       
-
       
    meta.homepage = "https://github.com/embark-theme/vim/";

     

       
1928
       
 
       
  };

     

       
1929
       
 
       


     

       
1930
       
 
       
  emmet-vim = buildVimPluginFrom2Nix {

     
···

       
2038
       
 
       


     

       
2039
       
 
       
  fern-vim = buildVimPluginFrom2Nix {

     

       
2040
       
 
       
    pname = "fern.vim";

     

       
2041
       
-
       
    version = "2022-03-24";

     

       
2042
       
 
       
    src = fetchFromGitHub {

     

       
2043
       
 
       
      owner = "lambdalisue";

     

       
2044
       
 
       
      repo = "fern.vim";

     

       
2045
       
-
       
      rev = "45950d39965150a6c6bff1979303e735460379d0";

     

       
2046
       
-
       
      sha256 = "067aild4sr5zd08fn2dna9ndycf5i4w524kkz88yzhyr7h5rc0w4";

     

       
2047
       
 
       
    };

     

       
2048
       
 
       
    meta.homepage = "https://github.com/lambdalisue/fern.vim/";

     

       
2049
       
 
       
  };

     
···

       
2084
       
 
       
    meta.homepage = "https://github.com/bogado/file-line/";

     

       
2085
       
 
       
  };

     

       
2086
       
 
       


     

       
2087
       
-
       
  FixCursorHold-nvim = buildVimPluginFrom2Nix {

     

       
2088
       
-
       
    pname = "FixCursorHold.nvim";

     

       
2089
       
-
       
    version = "2022-02-17";

     

       
2090
       
-
       
    src = fetchFromGitHub {

     

       
2091
       
-
       
      owner = "antoinemadec";

     

       
2092
       
-
       
      repo = "FixCursorHold.nvim";

     

       
2093
       
-
       
      rev = "1bfb32e7ba1344925ad815cb0d7f901dbc0ff7c1";

     

       
2094
       
-
       
      sha256 = "0b1iffk6pa2zwd9fvlgqli72r8qj74b7hqkhlw6awhc7r1qj8m1q";

     

       
2095
       
-
       
    };

     

       
2096
       
-
       
    meta.homepage = "https://github.com/antoinemadec/FixCursorHold.nvim/";

     

       
2097
       
-
       
  };

     

       
2098
       
-
       


     

       
2099
       
 
       
  flake8-vim = buildVimPluginFrom2Nix {

     

       
2100
       
 
       
    pname = "flake8-vim";

     

       
2101
       
 
       
    version = "2020-10-20";

     
···

       
2147
       
 
       


     

       
2148
       
 
       
  formatter-nvim = buildVimPluginFrom2Nix {

     

       
2149
       
 
       
    pname = "formatter.nvim";

     

       
2150
       
-
       
    version = "2022-03-22";

     

       
2151
       
 
       
    src = fetchFromGitHub {

     

       
2152
       
 
       
      owner = "mhartington";

     

       
2153
       
 
       
      repo = "formatter.nvim";

     

       
2154
       
-
       
      rev = "cc42c16a793cba102ac75574ab187a77995ba06b";

     

       
2155
       
-
       
      sha256 = "1qz87l2da378wcbbck6n9p82apl594x2kxldl4sxhy88rbbqi2vb";

     

       
2156
       
 
       
    };

     

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

     

       
2158
       
 
       
  };

     
···

       
2191
       
 
       
      sha256 = "1dmxz283ypz1klcmdf4jk699aifr3dywkh9y8v8v8vyflampqwwp";

     

       
2192
       
 
       
    };

     

       
2193
       
 
       
    meta.homepage = "https://github.com/raghur/fruzzy/";

     

       
2194
       
-
       
  };

     

       
2195
       
-
       


     

       
2196
       
-
       
  FTerm-nvim = buildVimPluginFrom2Nix {

     

       
2197
       
-
       
    pname = "FTerm.nvim";

     

       
2198
       
-
       
    version = "2022-03-13";

     

       
2199
       
-
       
    src = fetchFromGitHub {

     

       
2200
       
-
       
      owner = "numToStr";

     

       
2201
       
-
       
      repo = "FTerm.nvim";

     

       
2202
       
-
       
      rev = "233633a5f6fe8398187a4eba93eba0828ef3d5f3";

     

       
2203
       
-
       
      sha256 = "0sxnii921xia4mrf67qz7ichi9xqr9zf193hb9dx199l7hl6k1p8";

     

       
2204
       
-
       
    };

     

       
2205
       
-
       
    meta.homepage = "https://github.com/numToStr/FTerm.nvim/";

     

       
2206
       
 
       
  };

     

       
2207
       
 
       


     

       
2208
       
 
       
  fugitive-gitlab-vim = buildVimPluginFrom2Nix {

     
···

       
2339
       
 
       


     

       
2340
       
 
       
  gina-vim = buildVimPluginFrom2Nix {

     

       
2341
       
 
       
    pname = "gina.vim";

     

       
2342
       
-
       
    version = "2021-06-12";

     

       
2343
       
 
       
    src = fetchFromGitHub {

     

       
2344
       
 
       
      owner = "lambdalisue";

     

       
2345
       
 
       
      repo = "gina.vim";

     

       
2346
       
-
       
      rev = "abdbe0fe33f3b6fc59e94f7cc3072768f8dfd8ac";

     

       
2347
       
-
       
      sha256 = "1f3shh6jxr5i1an2dbb1vmc0l2xg03fm6ava25ahxg4b5ka59bc5";

     

       
2348
       
 
       
    };

     

       
2349
       
 
       
    meta.homepage = "https://github.com/lambdalisue/gina.vim/";

     

       
2350
       
 
       
  };

     
···

       
2411
       
 
       


     

       
2412
       
 
       
  gitsigns-nvim = buildVimPluginFrom2Nix {

     

       
2413
       
 
       
    pname = "gitsigns.nvim";

     

       
2414
       
-
       
    version = "2022-03-25";

     

       
2415
       
 
       
    src = fetchFromGitHub {

     

       
2416
       
 
       
      owner = "lewis6991";

     

       
2417
       
 
       
      repo = "gitsigns.nvim";

     

       
2418
       
-
       
      rev = "2a107231d92fa37224efdbc475abfba71f94b5ee";

     

       
2419
       
-
       
      sha256 = "0i17r2c48csff7pl0k1vvc5j61xh3qv4xq6v75raz937w0kj6hfg";

     

       
2420
       
 
       
    };

     

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

     

       
2422
       
 
       
  };

     
···

       
2529
       
 
       
    meta.homepage = "https://github.com/morhetz/gruvbox/";

     

       
2530
       
 
       
  };

     

       
2531
       
 
       


     

       
2532
       
-
       
  gruvbox-community = buildVimPluginFrom2Nix {

     

       
2533
       
-
       
    pname = "gruvbox-community";

     

       
2534
       
-
       
    version = "2022-03-06";

     

       
2535
       
-
       
    src = fetchFromGitHub {

     

       
2536
       
-
       
      owner = "gruvbox-community";

     

       
2537
       
-
       
      repo = "gruvbox";

     

       
2538
       
-
       
      rev = "b6f47ae7031f6746a1f1918c17574aa12c474ef0";

     

       
2539
       
-
       
      sha256 = "0m8rrm5v542a2c30sg7hlgm7r6gs4ah1n6nr5dc101l2064kg97g";

     

       
2540
       
-
       
    };

     

       
2541
       
-
       
    meta.homepage = "https://github.com/gruvbox-community/gruvbox/";

     

       
2542
       
-
       
  };

     

       
2543
       
-
       


     

       
2544
       
 
       
  gruvbox-flat-nvim = buildVimPluginFrom2Nix {

     

       
2545
       
 
       
    pname = "gruvbox-flat.nvim";

     

       
2546
       
 
       
    version = "2022-01-19";

     
···

       
2603
       
 
       


     

       
2604
       
 
       
  harpoon = buildVimPluginFrom2Nix {

     

       
2605
       
 
       
    pname = "harpoon";

     

       
2606
       
-
       
    version = "2022-02-16";

     

       
2607
       
 
       
    src = fetchFromGitHub {

     

       
2608
       
 
       
      owner = "ThePrimeagen";

     

       
2609
       
 
       
      repo = "harpoon";

     

       
2610
       
-
       
      rev = "b2bb0d6f2b8a55895afda53f0ad04527998d3411";

     

       
2611
       
-
       
      sha256 = "0izsscglfk6lpisxvarr0qw4m9br8854wi6jhyp2msd8r9gcrzi7";

     

       
2612
       
 
       
    };

     

       
2613
       
 
       
    meta.homepage = "https://github.com/ThePrimeagen/harpoon/";

     

       
2614
       
 
       
  };

     
···

       
2759
       
 
       


     

       
2760
       
 
       
  impatient-nvim = buildVimPluginFrom2Nix {

     

       
2761
       
 
       
    pname = "impatient.nvim";

     

       
2762
       
-
       
    version = "2022-03-22";

     

       
2763
       
 
       
    src = fetchFromGitHub {

     

       
2764
       
 
       
      owner = "lewis6991";

     

       
2765
       
 
       
      repo = "impatient.nvim";

     

       
2766
       
-
       
      rev = "989eefca3539b9958df100e8e3130f55eafe1709";

     

       
2767
       
-
       
      sha256 = "0cypb6nm0jlgf4cbsazwplvniiqrnda32nk2nkaqm0dbprs920sv";

     

       
2768
       
 
       
    };

     

       
2769
       
 
       
    meta.homepage = "https://github.com/lewis6991/impatient.nvim/";

     

       
2770
       
-
       
  };

     

       
2771
       
-
       


     

       
2772
       
-
       
  Improved-AnsiEsc = buildVimPluginFrom2Nix {

     

       
2773
       
-
       
    pname = "Improved-AnsiEsc";

     

       
2774
       
-
       
    version = "2015-08-26";

     

       
2775
       
-
       
    src = fetchFromGitHub {

     

       
2776
       
-
       
      owner = "vim-scripts";

     

       
2777
       
-
       
      repo = "Improved-AnsiEsc";

     

       
2778
       
-
       
      rev = "e1c59a8e9203fab6b9150721f30548916da73351";

     

       
2779
       
-
       
      sha256 = "1smjs4kz2kmzprzp9az4957675nakb43146hshbby39j5xz4jsbz";

     

       
2780
       
-
       
    };

     

       
2781
       
-
       
    meta.homepage = "https://github.com/vim-scripts/Improved-AnsiEsc/";

     

       
2782
       
 
       
  };

     

       
2783
       
 
       


     

       
2784
       
 
       
  increment-activator = buildVimPluginFrom2Nix {

     
···

       
2819
       
 
       


     

       
2820
       
 
       
  indent-blankline-nvim = buildVimPluginFrom2Nix {

     

       
2821
       
 
       
    pname = "indent-blankline.nvim";

     

       
2822
       
-
       
    version = "2022-03-25";

     

       
2823
       
 
       
    src = fetchFromGitHub {

     

       
2824
       
 
       
      owner = "lukas-reineke";

     

       
2825
       
 
       
      repo = "indent-blankline.nvim";

     

       
2826
       
-
       
      rev = "ebedbed53690a53cd15b53c124eb29f9faffc1d2";

     

       
2827
       
-
       
      sha256 = "1wsxvlpq78vyvgz6g0ji07dy1b10bsfr1qk9qdpj2n5592zp8zlk";

     

       
2828
       
 
       
    };

     

       
2829
       
 
       
    meta.homepage = "https://github.com/lukas-reineke/indent-blankline.nvim/";

     

       
2830
       
 
       
  };

     
···

       
2962
       
 
       
    meta.homepage = "https://github.com/nanotech/jellybeans.vim/";

     

       
2963
       
 
       
  };

     

       
2964
       
 
       


     

       
2965
       
-
       
  Jenkinsfile-vim-syntax = buildVimPluginFrom2Nix {

     

       
2966
       
-
       
    pname = "Jenkinsfile-vim-syntax";

     

       
2967
       
-
       
    version = "2021-01-26";

     

       
2968
       
-
       
    src = fetchFromGitHub {

     

       
2969
       
-
       
      owner = "martinda";

     

       
2970
       
-
       
      repo = "Jenkinsfile-vim-syntax";

     

       
2971
       
-
       
      rev = "0d05729168ea44d60862f17cffa80024ab30bcc9";

     

       
2972
       
-
       
      sha256 = "05z30frs4f5z0l4qgxk08r7mb19bzhqs36hi213yin78cz62b9gy";

     

       
2973
       
-
       
    };

     

       
2974
       
-
       
    meta.homepage = "https://github.com/martinda/Jenkinsfile-vim-syntax/";

     

       
2975
       
-
       
  };

     

       
2976
       
-
       


     

       
2977
       
 
       
  jq-vim = buildVimPluginFrom2Nix {

     

       
2978
       
 
       
    pname = "jq.vim";

     

       
2979
       
 
       
    version = "2019-05-21";

     
···

       
3058
       
 
       
    meta.homepage = "https://github.com/qnighy/lalrpop.vim/";

     

       
3059
       
 
       
  };

     

       
3060
       
 
       


     

       
3061
       
-
       
  LanguageClient-neovim = buildVimPluginFrom2Nix {

     

       
3062
       
-
       
    pname = "LanguageClient-neovim";

     

       
3063
       
-
       
    version = "2020-12-10";

     

       
3064
       
-
       
    src = fetchFromGitHub {

     

       
3065
       
-
       
      owner = "autozimu";

     

       
3066
       
-
       
      repo = "LanguageClient-neovim";

     

       
3067
       
-
       
      rev = "a42594c9c320b1283e9b9058b85a8097d8325fed";

     

       
3068
       
-
       
      sha256 = "0lj9na3g2cl0vj56jz8rhz9lm2d3xps5glk8ds491i2ixy4vdm37";

     

       
3069
       
-
       
    };

     

       
3070
       
-
       
    meta.homepage = "https://github.com/autozimu/LanguageClient-neovim/";

     

       
3071
       
-
       
  };

     

       
3072
       
-
       


     

       
3073
       
-
       
  LanguageTool-nvim = buildVimPluginFrom2Nix {

     

       
3074
       
-
       
    pname = "LanguageTool.nvim";

     

       
3075
       
-
       
    version = "2020-10-19";

     

       
3076
       
-
       
    src = fetchFromGitHub {

     

       
3077
       
-
       
      owner = "vigoux";

     

       
3078
       
-
       
      repo = "LanguageTool.nvim";

     

       
3079
       
-
       
      rev = "809e7d77fec834597f495fec737c59292a10025b";

     

       
3080
       
-
       
      sha256 = "1g12dz85xq8qd92dgna0a3w6zgxa74njlvmvly4k20610r63bzrn";

     

       
3081
       
-
       
    };

     

       
3082
       
-
       
    meta.homepage = "https://github.com/vigoux/LanguageTool.nvim/";

     

       
3083
       
-
       
  };

     

       
3084
       
-
       


     

       
3085
       
 
       
  last256 = buildVimPluginFrom2Nix {

     

       
3086
       
 
       
    pname = "last256";

     

       
3087
       
 
       
    version = "2020-12-09";

     
···

       
3116
       
 
       
      sha256 = "1h09yp9kmzbcraw88gdkzlv834p0yi5xacpmx4ksmp4yh4an6h5d";

     

       
3117
       
 
       
    };

     

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

     

       
3119
       
-
       
  };

     

       
3120
       
-
       


     

       
3121
       
-
       
  LeaderF = buildVimPluginFrom2Nix {

     

       
3122
       
-
       
    pname = "LeaderF";

     

       
3123
       
-
       
    version = "2022-03-22";

     

       
3124
       
-
       
    src = fetchFromGitHub {

     

       
3125
       
-
       
      owner = "Yggdroot";

     

       
3126
       
-
       
      repo = "LeaderF";

     

       
3127
       
-
       
      rev = "60e14a5bbd52a22578d6335c606d0539067b9327";

     

       
3128
       
-
       
      sha256 = "05bx5wm8r5rs4y51pkgb2m6bxzddacn7f3bdsgnmbvxz0rxyq8dp";

     

       
3129
       
-
       
    };

     

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

     

       
3131
       
 
       
  };

     

       
3132
       
 
       


     

       
3133
       
 
       
  lean-nvim = buildVimPluginFrom2Nix {

     

       
3134
       
 
       
    pname = "lean.nvim";

     

       
3135
       
-
       
    version = "2022-03-23";

     

       
3136
       
 
       
    src = fetchFromGitHub {

     

       
3137
       
 
       
      owner = "Julian";

     

       
3138
       
 
       
      repo = "lean.nvim";

     

       
3139
       
-
       
      rev = "c22a0a6d288488a05a74aaa53dac4d2d71f7a30d";

     

       
3140
       
-
       
      sha256 = "0rb1gw3ndrjw5k1l2ckm936xp83krrwi3ylr27il8mdf4xllw3y8";

     

       
3141
       
 
       
    };

     

       
3142
       
 
       
    meta.homepage = "https://github.com/Julian/lean.nvim/";

     

       
3143
       
 
       
  };

     
···

       
3192
       
 
       


     

       
3193
       
 
       
  lf-vim = buildVimPluginFrom2Nix {

     

       
3194
       
 
       
    pname = "lf.vim";

     

       
3195
       
-
       
    version = "2021-02-18";

     

       
3196
       
 
       
    src = fetchFromGitHub {

     

       
3197
       
 
       
      owner = "ptzz";

     

       
3198
       
 
       
      repo = "lf.vim";

     

       
3199
       
-
       
      rev = "73fb502c6d1470243b1f4d8afa81e289d9edd94b";

     

       
3200
       
-
       
      sha256 = "1whrzpavv46r64l3b7vax4sj23kjdfjiwmhfpssb6bprhc9c4j97";

     

       
3201
       
 
       
    };

     

       
3202
       
 
       
    meta.homepage = "https://github.com/ptzz/lf.vim/";

     

       
3203
       
 
       
  };

     
···

       
3288
       
 
       


     

       
3289
       
 
       
  lightspeed-nvim = buildVimPluginFrom2Nix {

     

       
3290
       
 
       
    pname = "lightspeed.nvim";

     

       
3291
       
-
       
    version = "2022-03-09";

     

       
3292
       
 
       
    src = fetchFromGitHub {

     

       
3293
       
 
       
      owner = "ggandor";

     

       
3294
       
 
       
      repo = "lightspeed.nvim";

     

       
3295
       
-
       
      rev = "58c9e321b188e040703b01f16922623911f11117";

     

       
3296
       
-
       
      sha256 = "1x9w6nk69a6xzhr9jpcvnw3jby09k49y7gikasxyq5gpq6rp9dfs";

     

       
3297
       
 
       
    };

     

       
3298
       
 
       
    meta.homepage = "https://github.com/ggandor/lightspeed.nvim/";

     

       
3299
       
 
       
  };

     
···

       
3360
       
 
       


     

       
3361
       
 
       
  litee-filetree-nvim = buildVimPluginFrom2Nix {

     

       
3362
       
 
       
    pname = "litee-filetree.nvim";

     

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

     

       
3364
       
 
       
    src = fetchFromGitHub {

     

       
3365
       
 
       
      owner = "ldelossa";

     

       
3366
       
 
       
      repo = "litee-filetree.nvim";

     

       
3367
       
-
       
      rev = "4f54ff9708c59385dd2f08aad1ba7df879e638fc";

     

       
3368
       
-
       
      sha256 = "076wyp90mr43xniv0zc7wh6rfk1wr50cpfw5lvaj6ai7dyys466n";

     

       
3369
       
 
       
    };

     

       
3370
       
 
       
    meta.homepage = "https://github.com/ldelossa/litee-filetree.nvim/";

     

       
3371
       
 
       
  };

     
···

       
3515
       
 
       


     

       
3516
       
 
       
  lualine-nvim = buildVimPluginFrom2Nix {

     

       
3517
       
 
       
    pname = "lualine.nvim";

     

       
3518
       
-
       
    version = "2022-03-27";

     

       
3519
       
 
       
    src = fetchFromGitHub {

     

       
3520
       
 
       
      owner = "nvim-lualine";

     

       
3521
       
 
       
      repo = "lualine.nvim";

     

       
3522
       
-
       
      rev = "f14175e142825c69c5b39e8f1564b9945a97d4aa";

     

       
3523
       
-
       
      sha256 = "0x6f88ixb6xd5nh3d8y5sql8yfyqs5fnpvdkdv9ywp7swzaydgqc";

     

       
3524
       
 
       
    };

     

       
3525
       
 
       
    meta.homepage = "https://github.com/nvim-lualine/lualine.nvim/";

     

       
3526
       
 
       
  };

     

       
3527
       
 
       


     

       
3528
       
 
       
  luasnip = buildVimPluginFrom2Nix {

     

       
3529
       
 
       
    pname = "luasnip";

     

       
3530
       
-
       
    version = "2022-03-27";

     

       
3531
       
 
       
    src = fetchFromGitHub {

     

       
3532
       
 
       
      owner = "l3mon4d3";

     

       
3533
       
 
       
      repo = "luasnip";

     

       
3534
       
-
       
      rev = "d03f0c32b2aa763915401421f6b084315936590f";

     

       
3535
       
-
       
      sha256 = "0qrryj40v70wl1mwn3jc0f50ygslc0848gppki5sxv1aq56a58ps";

     

       
3536
       
 
       
    };

     

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

     

       
3538
       
 
       
  };

     
···

       
3609
       
 
       
    meta.homepage = "https://github.com/vim-scripts/matchit.zip/";

     

       
3610
       
 
       
  };

     

       
3611
       
 
       


     

       
3612
       
-
       
  MatchTagAlways = buildVimPluginFrom2Nix {

     

       
3613
       
-
       
    pname = "MatchTagAlways";

     

       
3614
       
-
       
    version = "2017-05-20";

     

       
3615
       
-
       
    src = fetchFromGitHub {

     

       
3616
       
-
       
      owner = "Valloric";

     

       
3617
       
-
       
      repo = "MatchTagAlways";

     

       
3618
       
-
       
      rev = "352eb479a4ad1608e0880b79ab2357aac2cf4bed";

     

       
3619
       
-
       
      sha256 = "0y8gq4cs0wm2ijagc2frpmm664z355iridxyl5893576v5aqp8z1";

     

       
3620
       
-
       
    };

     

       
3621
       
-
       
    meta.homepage = "https://github.com/Valloric/MatchTagAlways/";

     

       
3622
       
-
       
  };

     

       
3623
       
-
       


     

       
3624
       
 
       
  material-nvim = buildVimPluginFrom2Nix {

     

       
3625
       
 
       
    pname = "material.nvim";

     

       
3626
       
-
       
    version = "2022-03-25";

     

       
3627
       
 
       
    src = fetchFromGitHub {

     

       
3628
       
 
       
      owner = "marko-cerovac";

     

       
3629
       
 
       
      repo = "material.nvim";

     

       
3630
       
-
       
      rev = "82f74e8ec5d21a8ec9ebe1175c330a0b6e490212";

     

       
3631
       
-
       
      sha256 = "0hgcgj84d92js6i6skwzznz0ym8cgzwr4pz5aqi038g8ldpcx0ki";

     

       
3632
       
 
       
    };

     

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

     

       
3634
       
 
       
  };

     

       
3635
       
 
       


     

       
3636
       
-
       
  mattn-calendar-vim = buildVimPluginFrom2Nix {

     

       
3637
       
-
       
    pname = "mattn-calendar-vim";

     

       
3638
       
-
       
    version = "2022-02-10";

     

       
3639
       
-
       
    src = fetchFromGitHub {

     

       
3640
       
-
       
      owner = "mattn";

     

       
3641
       
-
       
      repo = "calendar-vim";

     

       
3642
       
-
       
      rev = "2083a41e2d310f9bbbbf644517f30e901f1fb04d";

     

       
3643
       
-
       
      sha256 = "13wakcprkh93i7afykkpavxqvxssjh573pjjljsgip3y3778ms5q";

     

       
3644
       
-
       
    };

     

       
3645
       
-
       
    meta.homepage = "https://github.com/mattn/calendar-vim/";

     

       
3646
       
-
       
  };

     

       
3647
       
-
       


     

       
3648
       
 
       
  mayansmoke = buildVimPluginFrom2Nix {

     

       
3649
       
 
       
    pname = "mayansmoke";

     

       
3650
       
 
       
    version = "2010-10-18";

     
···

       
3659
       
 
       


     

       
3660
       
 
       
  mini-nvim = buildVimPluginFrom2Nix {

     

       
3661
       
 
       
    pname = "mini.nvim";

     

       
3662
       
-
       
    version = "2022-03-26";

     

       
3663
       
 
       
    src = fetchFromGitHub {

     

       
3664
       
 
       
      owner = "echasnovski";

     

       
3665
       
 
       
      repo = "mini.nvim";

     

       
3666
       
-
       
      rev = "b0763e58ccb8b203f87fcd58fe2fecb095119f96";

     

       
3667
       
-
       
      sha256 = "0qbyvz7l9p9iia7mh41119zdgz2v8xrkp8wcxl6hyxqri18j49yn";

     

       
3668
       
 
       
    };

     

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

     

       
3670
       
 
       
  };

     
···

       
3729
       
 
       
    meta.homepage = "https://github.com/tomasr/molokai/";

     

       
3730
       
 
       
  };

     

       
3731
       
 
       


     

       
3732
       
-
       
  moonlight-nvim = buildVimPluginFrom2Nix {

     

       
3733
       
-
       
    pname = "moonlight.nvim";

     

       
3734
       
-
       
    version = "2021-05-16";

     

       
3735
       
-
       
    src = fetchFromGitHub {

     

       
3736
       
-
       
      owner = "shaunsingh";

     

       
3737
       
-
       
      repo = "moonlight.nvim";

     

       
3738
       
-
       
      rev = "e24e4218ec680b6396532808abf57ca0ada82e66";

     

       
3739
       
-
       
      sha256 = "0m9w3fpypsqxydjd93arbjqb5576nl40iy27i4ijlrqhgdhl49y3";

     

       
3740
       
-
       
    };

     

       
3741
       
-
       
    meta.homepage = "https://github.com/shaunsingh/moonlight.nvim/";

     

       
3742
       
-
       
  };

     

       
3743
       
-
       


     

       
3744
       
 
       
  mru = buildVimPluginFrom2Nix {

     

       
3745
       
 
       
    pname = "mru";

     

       
3746
       
 
       
    version = "2022-03-12";

     
···

       
3751
       
 
       
      sha256 = "06w4rmdn48h21wl9mn5v9mfkaaypd1fxhdjiv7ng5zj7jgi1qnsd";

     

       
3752
       
 
       
    };

     

       
3753
       
 
       
    meta.homepage = "https://github.com/yegappan/mru/";

     

       
3754
       
-
       
  };

     

       
3755
       
-
       


     

       
3756
       
-
       
  Navigator-nvim = buildVimPluginFrom2Nix {

     

       
3757
       
-
       
    pname = "Navigator.nvim";

     

       
3758
       
-
       
    version = "2022-03-25";

     

       
3759
       
-
       
    src = fetchFromGitHub {

     

       
3760
       
-
       
      owner = "numToStr";

     

       
3761
       
-
       
      repo = "Navigator.nvim";

     

       
3762
       
-
       
      rev = "58d07e658c15b61ef7b6e375073b1f06934bc28f";

     

       
3763
       
-
       
      sha256 = "0d40rilwcxi7q36fnk4xpyx1cq3nb4yf22j8k8zq6mwg5h4j648r";

     

       
3764
       
-
       
    };

     

       
3765
       
-
       
    meta.homepage = "https://github.com/numToStr/Navigator.nvim/";

     

       
3766
       
 
       
  };

     

       
3767
       
 
       


     

       
3768
       
 
       
  ncm2 = buildVimPluginFrom2Nix {

     
···

       
4103
       
 
       


     

       
4104
       
 
       
  neorg = buildVimPluginFrom2Nix {

     

       
4105
       
 
       
    pname = "neorg";

     

       
4106
       
-
       
    version = "2022-03-26";

     

       
4107
       
 
       
    src = fetchFromGitHub {

     

       
4108
       
 
       
      owner = "nvim-neorg";

     

       
4109
       
 
       
      repo = "neorg";

     

       
4110
       
-
       
      rev = "8f8c1ae889ffe666423a89271933272ebffec3ef";

     

       
4111
       
-
       
      sha256 = "10fgkrr9wn6jj35qa42c353k4rnys9a2wrckjk0kwrx6kvx7m6l6";

     

       
4112
       
 
       
    };

     

       
4113
       
 
       
    meta.homepage = "https://github.com/nvim-neorg/neorg/";

     

       
4114
       
 
       
  };

     
···

       
4127
       
 
       


     

       
4128
       
 
       
  neosnippet-snippets = buildVimPluginFrom2Nix {

     

       
4129
       
 
       
    pname = "neosnippet-snippets";

     

       
4130
       
-
       
    version = "2021-10-02";

     

       
4131
       
 
       
    src = fetchFromGitHub {

     

       
4132
       
 
       
      owner = "Shougo";

     

       
4133
       
 
       
      repo = "neosnippet-snippets";

     

       
4134
       
-
       
      rev = "8a6655a034eb7c12138dad505ef1004bf383a45d";

     

       
4135
       
-
       
      sha256 = "0mwvcjdrk324azqy5m2lpl3z1gi92jspxvmcjcxqnppfjsv1iyhd";

     

       
4136
       
 
       
    };

     

       
4137
       
 
       
    meta.homepage = "https://github.com/Shougo/neosnippet-snippets/";

     

       
4138
       
 
       
  };

     
···

       
4147
       
 
       
      sha256 = "1mbx2iw4s0ny89siic156y7lwypw55abkvskmzzjjf7y4h8g9rsv";

     

       
4148
       
 
       
    };

     

       
4149
       
 
       
    meta.homepage = "https://github.com/Shougo/neosnippet.vim/";

     

       
4150
       
-
       
  };

     

       
4151
       
-
       


     

       
4152
       
-
       
  NeoSolarized = buildVimPluginFrom2Nix {

     

       
4153
       
-
       
    pname = "NeoSolarized";

     

       
4154
       
-
       
    version = "2020-08-07";

     

       
4155
       
-
       
    src = fetchFromGitHub {

     

       
4156
       
-
       
      owner = "overcache";

     

       
4157
       
-
       
      repo = "NeoSolarized";

     

       
4158
       
-
       
      rev = "b94b1a9ad51e2de015266f10fdc6e142f97bd617";

     

       
4159
       
-
       
      sha256 = "019nz56yirpg1ahg8adfafrxznalw056qwm3xjm9kzg6da8j6v48";

     

       
4160
       
-
       
    };

     

       
4161
       
-
       
    meta.homepage = "https://github.com/overcache/NeoSolarized/";

     

       
4162
       
 
       
  };

     

       
4163
       
 
       


     

       
4164
       
 
       
  neoterm = buildVimPluginFrom2Nix {

     
···

       
4295
       
 
       


     

       
4296
       
 
       
  nightfox-nvim = buildVimPluginFrom2Nix {

     

       
4297
       
 
       
    pname = "nightfox.nvim";

     

       
4298
       
-
       
    version = "2022-03-27";

     

       
4299
       
 
       
    src = fetchFromGitHub {

     

       
4300
       
 
       
      owner = "EdenEast";

     

       
4301
       
 
       
      repo = "nightfox.nvim";

     

       
4302
       
-
       
      rev = "2b19e2ad758f078b607408b15bdaf39f3beafac6";

     

       
4303
       
-
       
      sha256 = "0xn78z74wldjq7p5xzlbv4562b6i5nha3lj0bc2hv6w9n3m7q494";

     

       
4304
       
 
       
    };

     

       
4305
       
 
       
    meta.homepage = "https://github.com/EdenEast/nightfox.nvim/";

     

       
4306
       
 
       
  };

     
···

       
4377
       
 
       
    meta.homepage = "https://github.com/andersevenrud/nordic.nvim/";

     

       
4378
       
 
       
  };

     

       
4379
       
 
       


     

       
4380
       
-
       
  NrrwRgn = buildVimPluginFrom2Nix {

     

       
4381
       
-
       
    pname = "NrrwRgn";

     

       
4382
       
-
       
    version = "2022-02-13";

     

       
4383
       
-
       
    src = fetchFromGitHub {

     

       
4384
       
-
       
      owner = "chrisbra";

     

       
4385
       
-
       
      repo = "NrrwRgn";

     

       
4386
       
-
       
      rev = "e027db9d94f94947153cd7b5ac9abd04371ab2b0";

     

       
4387
       
-
       
      sha256 = "0mcwyqbfc2m865w44s96ra2k0v1mn5kkkxf8i71iqhvc7fvnrfah";

     

       
4388
       
-
       
    };

     

       
4389
       
-
       
    meta.homepage = "https://github.com/chrisbra/NrrwRgn/";

     

       
4390
       
-
       
  };

     

       
4391
       
-
       


     

       
4392
       
 
       
  nterm-nvim = buildVimPluginFrom2Nix {

     

       
4393
       
 
       
    pname = "nterm.nvim";

     

       
4394
       
 
       
    version = "2021-11-10";

     
···

       
4415
       
 
       


     

       
4416
       
 
       
  null-ls-nvim = buildVimPluginFrom2Nix {

     

       
4417
       
 
       
    pname = "null-ls.nvim";

     

       
4418
       
-
       
    version = "2022-03-25";

     

       
4419
       
 
       
    src = fetchFromGitHub {

     

       
4420
       
 
       
      owner = "jose-elias-alvarez";

     

       
4421
       
 
       
      repo = "null-ls.nvim";

     

       
4422
       
-
       
      rev = "7253974f8bd8c805a2a1cf7456b4d47913f4a094";

     

       
4423
       
-
       
      sha256 = "0xy80c1wra3ir8v0ywrrmyswprbzknlwf69q9g33g29zsmgfx9dr";

     

       
4424
       
 
       
    };

     

       
4425
       
 
       
    meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";

     

       
4426
       
 
       
  };

     
···

       
4463
       
 
       


     

       
4464
       
 
       
  nvim-autopairs = buildVimPluginFrom2Nix {

     

       
4465
       
 
       
    pname = "nvim-autopairs";

     

       
4466
       
-
       
    version = "2022-03-25";

     

       
4467
       
 
       
    src = fetchFromGitHub {

     

       
4468
       
 
       
      owner = "windwp";

     

       
4469
       
 
       
      repo = "nvim-autopairs";

     

       
4470
       
-
       
      rev = "f3ebca37d6ef1ff22d1f2c764a9e619d1fe5f3c7";

     

       
4471
       
-
       
      sha256 = "0w5xsj55iz30khiw4y47h43i40z2ly607bm8hvddpvrd50i5vcz1";

     

       
4472
       
 
       
    };

     

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

     

       
4474
       
 
       
  };

     

       
4475
       
 
       


     

       
4476
       
 
       
  nvim-base16 = buildVimPluginFrom2Nix {

     

       
4477
       
 
       
    pname = "nvim-base16";

     

       
4478
       
-
       
    version = "2022-03-13";

     

       
4479
       
 
       
    src = fetchFromGitHub {

     

       
4480
       
 
       
      owner = "RRethy";

     

       
4481
       
 
       
      repo = "nvim-base16";

     

       
4482
       
-
       
      rev = "9893a06a11b448e05c0bd1f44970acbb7712e8ba";

     

       
4483
       
-
       
      sha256 = "0hhlyw9nacyc4pyx2537y145lm9p3s4m4ckh8cwbambp5ypnn8kl";

     

       
4484
       
 
       
    };

     

       
4485
       
 
       
    meta.homepage = "https://github.com/RRethy/nvim-base16/";

     

       
4486
       
 
       
  };

     

       
4487
       
 
       


     

       
4488
       
 
       
  nvim-bqf = buildVimPluginFrom2Nix {

     

       
4489
       
 
       
    pname = "nvim-bqf";

     

       
4490
       
-
       
    version = "2022-03-21";

     

       
4491
       
 
       
    src = fetchFromGitHub {

     

       
4492
       
 
       
      owner = "kevinhwang91";

     

       
4493
       
 
       
      repo = "nvim-bqf";

     

       
4494
       
-
       
      rev = "7d3630f1616c2e5cf9f1c8efc1cf186b9249ce7b";

     

       
4495
       
-
       
      sha256 = "0y9kp05qgs7mmivs52ab26jhiqj1izz4jhj1n4x26zmaqbpw4viw";

     

       
4496
       
 
       
    };

     

       
4497
       
 
       
    meta.homepage = "https://github.com/kevinhwang91/nvim-bqf/";

     

       
4498
       
 
       
  };

     
···

       
4523
       
 
       


     

       
4524
       
 
       
  nvim-cmp = buildVimPluginFrom2Nix {

     

       
4525
       
 
       
    pname = "nvim-cmp";

     

       
4526
       
-
       
    version = "2022-03-22";

     

       
4527
       
 
       
    src = fetchFromGitHub {

     

       
4528
       
 
       
      owner = "hrsh7th";

     

       
4529
       
 
       
      repo = "nvim-cmp";

     

       
4530
       
-
       
      rev = "272cbdca3e327bf43e8df85c6f4f00921656c4e4";

     

       
4531
       
-
       
      sha256 = "1z3nsrkla35sl6d66bjnk0qvqn1a5m8vn670qyb8y9nqs344fy8d";

     

       
4532
       
 
       
    };

     

       
4533
       
 
       
    meta.homepage = "https://github.com/hrsh7th/nvim-cmp/";

     

       
4534
       
 
       
  };

     
···

       
4607
       
 
       


     

       
4608
       
 
       
  nvim-dap = buildVimPluginFrom2Nix {

     

       
4609
       
 
       
    pname = "nvim-dap";

     

       
4610
       
-
       
    version = "2022-03-25";

     

       
4611
       
 
       
    src = fetchFromGitHub {

     

       
4612
       
 
       
      owner = "mfussenegger";

     

       
4613
       
 
       
      repo = "nvim-dap";

     

       
4614
       
-
       
      rev = "e6d7ba5847fbe5f33ba211cf28d3cea72cfa9865";

     

       
4615
       
-
       
      sha256 = "0w57cxj07law5igbxvblfk59pv5c8z714dm80njb168ldgy26kz6";

     

       
4616
       
 
       
    };

     

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

     

       
4618
       
 
       
  };

     

       
4619
       
 
       


     

       
4620
       
 
       
  nvim-dap-ui = buildVimPluginFrom2Nix {

     

       
4621
       
 
       
    pname = "nvim-dap-ui";

     

       
4622
       
-
       
    version = "2022-03-21";

     

       
4623
       
 
       
    src = fetchFromGitHub {

     

       
4624
       
 
       
      owner = "rcarriga";

     

       
4625
       
 
       
      repo = "nvim-dap-ui";

     

       
4626
       
-
       
      rev = "45805d69273f1ca0753a096abd419e89af8e5f8a";

     

       
4627
       
-
       
      sha256 = "03jjhsdl0w5w0s7d9a64fmvwdpm1pkvjvd5gh1hgsavbpf0w71mb";

     

       
4628
       
 
       
    };

     

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

     

       
4630
       
 
       
  };

     
···

       
4667
       
 
       


     

       
4668
       
 
       
  nvim-fzf-commands = buildVimPluginFrom2Nix {

     

       
4669
       
 
       
    pname = "nvim-fzf-commands";

     

       
4670
       
-
       
    version = "2021-05-31";

     

       
4671
       
 
       
    src = fetchFromGitHub {

     

       
4672
       
 
       
      owner = "vijaymarupudi";

     

       
4673
       
 
       
      repo = "nvim-fzf-commands";

     

       
4674
       
-
       
      rev = "c6188c8618ca6b579af37cbc242414e1016bcd45";

     

       
4675
       
-
       
      sha256 = "0nn04gpz3n0jqb9kyxbmipkixzp1lk2f67knxqzzzlxm27m839fy";

     

       
4676
       
 
       
    };

     

       
4677
       
 
       
    meta.homepage = "https://github.com/vijaymarupudi/nvim-fzf-commands/";

     

       
4678
       
 
       
  };

     
···

       
4691
       
 
       


     

       
4692
       
 
       
  nvim-gps = buildVimPluginFrom2Nix {

     

       
4693
       
 
       
    pname = "nvim-gps";

     

       
4694
       
-
       
    version = "2022-03-27";

     

       
4695
       
 
       
    src = fetchFromGitHub {

     

       
4696
       
 
       
      owner = "smiteshp";

     

       
4697
       
 
       
      repo = "nvim-gps";

     

       
4698
       
-
       
      rev = "1ad35eada2972c055b181c73852438a6ea51b484";

     

       
4699
       
-
       
      sha256 = "1kv7p2lcilvkvzl9whdkxgg94vk9fa9d1bikwhahxv2zxzk10qkz";

     

       
4700
       
 
       
    };

     

       
4701
       
 
       
    meta.homepage = "https://github.com/smiteshp/nvim-gps/";

     

       
4702
       
 
       
  };

     
···

       
4715
       
 
       


     

       
4716
       
 
       
  nvim-hlslens = buildVimPluginFrom2Nix {

     

       
4717
       
 
       
    pname = "nvim-hlslens";

     

       
4718
       
-
       
    version = "2022-03-20";

     

       
4719
       
 
       
    src = fetchFromGitHub {

     

       
4720
       
 
       
      owner = "kevinhwang91";

     

       
4721
       
 
       
      repo = "nvim-hlslens";

     

       
4722
       
-
       
      rev = "22f7df73283c6f947a56fef0355f5a3ee2971152";

     

       
4723
       
-
       
      sha256 = "1qjy4n0ly5vmkpfyjanqb76jvh6qa5ldqvhgfgxk91b9l35ca95l";

     

       
4724
       
 
       
    };

     

       
4725
       
 
       
    meta.homepage = "https://github.com/kevinhwang91/nvim-hlslens/";

     

       
4726
       
 
       
  };

     
···

       
4787
       
 
       


     

       
4788
       
 
       
  nvim-lint = buildVimPluginFrom2Nix {

     

       
4789
       
 
       
    pname = "nvim-lint";

     

       
4790
       
-
       
    version = "2022-03-09";

     

       
4791
       
 
       
    src = fetchFromGitHub {

     

       
4792
       
 
       
      owner = "mfussenegger";

     

       
4793
       
 
       
      repo = "nvim-lint";

     

       
4794
       
-
       
      rev = "8cc31931859dc3cc187fd68509f8649599f72cba";

     

       
4795
       
-
       
      sha256 = "006d9l0p86s08vhr5jjm6gi2j27wjbk3c3vfdbq9yi3bz974hgf1";

     

       
4796
       
 
       
    };

     

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

     

       
4798
       
 
       
  };

     
···

       
4811
       
 
       


     

       
4812
       
 
       
  nvim-lspconfig = buildVimPluginFrom2Nix {

     

       
4813
       
 
       
    pname = "nvim-lspconfig";

     

       
4814
       
-
       
    version = "2022-03-23";

     

       
4815
       
 
       
    src = fetchFromGitHub {

     

       
4816
       
 
       
      owner = "neovim";

     

       
4817
       
 
       
      repo = "nvim-lspconfig";

     

       
4818
       
-
       
      rev = "7d5a6dc46dd2ebaeb74b573922f289ae33089fe7";

     

       
4819
       
-
       
      sha256 = "1dz2q6n2ibq9l2js088wfp2y5md6z8lqs6hy02xajglvb0d9g3fg";

     

       
4820
       
 
       
    };

     

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

     

       
4822
       
 
       
  };

     
···

       
4835
       
 
       


     

       
4836
       
 
       
  nvim-metals = buildVimPluginFrom2Nix {

     

       
4837
       
 
       
    pname = "nvim-metals";

     

       
4838
       
-
       
    version = "2022-03-20";

     

       
4839
       
 
       
    src = fetchFromGitHub {

     

       
4840
       
 
       
      owner = "scalameta";

     

       
4841
       
 
       
      repo = "nvim-metals";

     

       
4842
       
-
       
      rev = "3312490ef74ea149121a82fde578a13b1921cef9";

     

       
4843
       
-
       
      sha256 = "0xi13qji716kdbbq579pj7rxbjfkwjrsdp3qvfb937spwzbak2jc";

     

       
4844
       
 
       
    };

     

       
4845
       
 
       
    meta.homepage = "https://github.com/scalameta/nvim-metals/";

     

       
4846
       
 
       
  };

     
···

       
4919
       
 
       


     

       
4920
       
 
       
  nvim-spectre = buildVimPluginFrom2Nix {

     

       
4921
       
 
       
    pname = "nvim-spectre";

     

       
4922
       
-
       
    version = "2022-03-22";

     

       
4923
       
 
       
    src = fetchFromGitHub {

     

       
4924
       
 
       
      owner = "nvim-pack";

     

       
4925
       
 
       
      repo = "nvim-spectre";

     

       
4926
       
-
       
      rev = "3bbf9cb2e36200d67c150d71d49011c133d3bbb8";

     

       
4927
       
-
       
      sha256 = "1jif3knz78mqf6sgckfwin1wx6ad4wppdc2y0hcxlj2kwm17xqzk";

     

       
4928
       
 
       
    };

     

       
4929
       
 
       
    meta.homepage = "https://github.com/nvim-pack/nvim-spectre/";

     

       
4930
       
 
       
  };

     
···

       
4943
       
 
       


     

       
4944
       
 
       
  nvim-tree-lua = buildVimPluginFrom2Nix {

     

       
4945
       
 
       
    pname = "nvim-tree.lua";

     

       
4946
       
-
       
    version = "2022-03-27";

     

       
4947
       
 
       
    src = fetchFromGitHub {

     

       
4948
       
 
       
      owner = "kyazdani42";

     

       
4949
       
 
       
      repo = "nvim-tree.lua";

     

       
4950
       
-
       
      rev = "524758a207f9c5bf3888b446d9f93192a837b8a7";

     

       
4951
       
-
       
      sha256 = "0kz7qhirm7gkklmyysanndm4pimvfm0p0qzz3q96hv01hpm3d17y";

     

       
4952
       
 
       
    };

     

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

     

       
4954
       
 
       
  };

     

       
4955
       
 
       


     

       
4956
       
 
       
  nvim-treesitter = buildVimPluginFrom2Nix {

     

       
4957
       
 
       
    pname = "nvim-treesitter";

     

       
4958
       
-
       
    version = "2022-03-27";

     

       
4959
       
 
       
    src = fetchFromGitHub {

     

       
4960
       
 
       
      owner = "nvim-treesitter";

     

       
4961
       
 
       
      repo = "nvim-treesitter";

     

       
4962
       
-
       
      rev = "b995eebe84df88092a41cbfd591bfc1565f70d8e";

     

       
4963
       
-
       
      sha256 = "1738mssq22n1njrpi004apgfv00fxn7yx00r3175qn57bjw9bks9";

     

       
4964
       
 
       
    };

     

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

     

       
4966
       
 
       
  };

     
···

       
5003
       
 
       


     

       
5004
       
 
       
  nvim-treesitter-textobjects = buildVimPluginFrom2Nix {

     

       
5005
       
 
       
    pname = "nvim-treesitter-textobjects";

     

       
5006
       
-
       
    version = "2022-03-25";

     

       
5007
       
 
       
    src = fetchFromGitHub {

     

       
5008
       
 
       
      owner = "nvim-treesitter";

     

       
5009
       
 
       
      repo = "nvim-treesitter-textobjects";

     

       
5010
       
-
       
      rev = "2885b60e9f9b90b4e2a32b0f8adf8571bf1f390e";

     

       
5011
       
-
       
      sha256 = "0q1dph3pz2ygz1wccjgcdfqyb4faj47rv2v9a4p4ngw2vd00qjgy";

     

       
5012
       
 
       
    };

     

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

     

       
5014
       
 
       
  };

     
···

       
5039
       
 
       


     

       
5040
       
 
       
  nvim-ts-rainbow = buildVimPluginFrom2Nix {

     

       
5041
       
 
       
    pname = "nvim-ts-rainbow";

     

       
5042
       
-
       
    version = "2022-03-20";

     

       
5043
       
 
       
    src = fetchFromGitHub {

     

       
5044
       
 
       
      owner = "p00f";

     

       
5045
       
 
       
      repo = "nvim-ts-rainbow";

     

       
5046
       
-
       
      rev = "af1a18d2577ba0be5b59bc4b32aebd2569ff085e";

     

       
5047
       
-
       
      sha256 = "1z100akjipzp3zyr7d54vbwwf53dj4f8y8qzf7fv32la142a7idq";

     

       
5048
       
 
       
    };

     

       
5049
       
 
       
    meta.homepage = "https://github.com/p00f/nvim-ts-rainbow/";

     

       
5050
       
 
       
  };

     
···

       
5099
       
 
       


     

       
5100
       
 
       
  nvimdev-nvim = buildVimPluginFrom2Nix {

     

       
5101
       
 
       
    pname = "nvimdev.nvim";

     

       
5102
       
-
       
    version = "2022-03-15";

     

       
5103
       
 
       
    src = fetchFromGitHub {

     

       
5104
       
 
       
      owner = "neovim";

     

       
5105
       
 
       
      repo = "nvimdev.nvim";

     

       
5106
       
-
       
      rev = "cb0fcc1cdbe3864554a7b1ecbe706eb4de4ec680";

     

       
5107
       
-
       
      sha256 = "063fyzawn6i67cv3221s282ln5gpms3qw97blrd80l18syykj2b9";

     

       
5108
       
 
       
    };

     

       
5109
       
 
       
    meta.homepage = "https://github.com/neovim/nvimdev.nvim/";

     

       
5110
       
 
       
  };

     
···

       
5135
       
 
       


     

       
5136
       
 
       
  octo-nvim = buildVimPluginFrom2Nix {

     

       
5137
       
 
       
    pname = "octo.nvim";

     

       
5138
       
-
       
    version = "2022-02-28";

     

       
5139
       
 
       
    src = fetchFromGitHub {

     

       
5140
       
 
       
      owner = "pwntester";

     

       
5141
       
 
       
      repo = "octo.nvim";

     

       
5142
       
-
       
      rev = "5e461b944fbf9b6207cf06102ca09fd7778854f7";

     

       
5143
       
-
       
      sha256 = "0s04m3xg98sj74fhhvdmafijmjhpa70hgcylg43yxlgdcscqbd72";

     

       
5144
       
 
       
    };

     

       
5145
       
 
       
    meta.homepage = "https://github.com/pwntester/octo.nvim/";

     

       
5146
       
 
       
  };

     
···

       
5231
       
 
       


     

       
5232
       
 
       
  orgmode = buildVimPluginFrom2Nix {

     

       
5233
       
 
       
    pname = "orgmode";

     

       
5234
       
-
       
    version = "2022-03-10";

     

       
5235
       
 
       
    src = fetchFromGitHub {

     

       
5236
       
 
       
      owner = "nvim-orgmode";

     

       
5237
       
 
       
      repo = "orgmode";

     

       
5238
       
-
       
      rev = "e1f3054987ce054525258d9a3cc5837bf6e75212";

     

       
5239
       
-
       
      sha256 = "0hwsajd7lhc04da7yzx770f3bgn2jsibcg1pjhxyib1prr17mpy0";

     

       
5240
       
 
       
    };

     

       
5241
       
 
       
    meta.homepage = "https://github.com/nvim-orgmode/orgmode/";

     

       
5242
       
 
       
  };

     
···

       
5363
       
 
       


     

       
5364
       
 
       
  playground = buildVimPluginFrom2Nix {

     

       
5365
       
 
       
    pname = "playground";

     

       
5366
       
-
       
    version = "2022-02-16";

     

       
5367
       
 
       
    src = fetchFromGitHub {

     

       
5368
       
 
       
      owner = "nvim-treesitter";

     

       
5369
       
 
       
      repo = "playground";

     

       
5370
       
-
       
      rev = "9df82a27a49e1c14e9d7416b537517a79d675086";

     

       
5371
       
-
       
      sha256 = "1hhrcsrgcy3vqxn9gsm68r77n6z5bw4cr0r47darffan5rxykz21";

     

       
5372
       
 
       
    };

     

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

     

       
5374
       
 
       
  };

     

       
5375
       
 
       


     

       
5376
       
 
       
  plenary-nvim = buildVimPluginFrom2Nix {

     

       
5377
       
 
       
    pname = "plenary.nvim";

     

       
5378
       
-
       
    version = "2022-03-20";

     

       
5379
       
 
       
    src = fetchFromGitHub {

     

       
5380
       
 
       
      owner = "nvim-lua";

     

       
5381
       
 
       
      repo = "plenary.nvim";

     

       
5382
       
-
       
      rev = "0d660152000a40d52158c155625865da2aa7aa1b";

     

       
5383
       
-
       
      sha256 = "0r8amnlaqxg9jpqk6v4rzlfrc8q161jy1bpy35jrk7gva76kp9hm";

     

       
5384
       
 
       
    };

     

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

     

       
5386
       
 
       
  };

     
···

       
5436
       
 
       


     

       
5437
       
 
       
  presenting-vim = buildVimPluginFrom2Nix {

     

       
5438
       
 
       
    pname = "presenting.vim";

     

       
5439
       
-
       
    version = "2021-06-02";

     

       
5440
       
 
       
    src = fetchFromGitHub {

     

       
5441
       
 
       
      owner = "sotte";

     

       
5442
       
 
       
      repo = "presenting.vim";

     

       
5443
       
-
       
      rev = "fd826318582ffccf2f79aff7bef365d68f2ca4fc";

     

       
5444
       
-
       
      sha256 = "1s2c44ngv5vpszwg0nkcghb5flzq9pby1m0l7gr7vwb9p7xl3b83";

     

       
5445
       
 
       
    };

     

       
5446
       
 
       
    meta.homepage = "https://github.com/sotte/presenting.vim/";

     

       
5447
       
 
       
  };

     

       
5448
       
 
       


     

       
5449
       
-
       
  PreserveNoEOL = buildVimPluginFrom2Nix {

     

       
5450
       
-
       
    pname = "PreserveNoEOL";

     

       
5451
       
-
       
    version = "2013-06-14";

     

       
5452
       
-
       
    src = fetchFromGitHub {

     

       
5453
       
-
       
      owner = "vim-scripts";

     

       
5454
       
-
       
      repo = "PreserveNoEOL";

     

       
5455
       
-
       
      rev = "940e3ce90e54d8680bec1135a21dcfbd6c9bfb62";

     

       
5456
       
-
       
      sha256 = "1726jpr2zf6jrb00pp082ikbx4mll3a877pnzs6i18f9fgpaqqgd";

     

       
5457
       
-
       
    };

     

       
5458
       
-
       
    meta.homepage = "https://github.com/vim-scripts/PreserveNoEOL/";

     

       
5459
       
-
       
  };

     

       
5460
       
-
       


     

       
5461
       
 
       
  prev_indent = buildVimPluginFrom2Nix {

     

       
5462
       
 
       
    pname = "prev_indent";

     

       
5463
       
 
       
    version = "2014-03-08";

     
···

       
5539
       
 
       
      repo = "pywal.nvim";

     

       
5540
       
 
       
      rev = "bd58195939d31dd0f15a720fba2956e91598cefe";

     

       
5541
       
 
       
      sha256 = "10fs5assp96rvlcxckd8cwnkfwfckjmf0j8cqq91vb2wx8knxc8g";

     

       
5542
       
-
       
      fetchSubmodules = true;

     

       
5543
       
 
       
    };

     

       
5544
       
 
       
    meta.homepage = "https://github.com/AlphaTechnolog/pywal.nvim/";

     

       
5545
       
-
       
  };

     

       
5546
       
-
       


     

       
5547
       
-
       
  QFEnter = buildVimPluginFrom2Nix {

     

       
5548
       
-
       
    pname = "QFEnter";

     

       
5549
       
-
       
    version = "2020-10-09";

     

       
5550
       
-
       
    src = fetchFromGitHub {

     

       
5551
       
-
       
      owner = "yssl";

     

       
5552
       
-
       
      repo = "QFEnter";

     

       
5553
       
-
       
      rev = "df0a75b287c210f98ae353a12bbfdaf73d858beb";

     

       
5554
       
-
       
      sha256 = "0gdp7nmjlp8ng2rp2v66d8bincnkwrqqpbggb079f0f9szrqlp54";

     

       
5555
       
-
       
    };

     

       
5556
       
-
       
    meta.homepage = "https://github.com/yssl/QFEnter/";

     

       
5557
       
 
       
  };

     

       
5558
       
 
       


     

       
5559
       
 
       
  quick-scope = buildVimPluginFrom2Nix {

     
···

       
5676
       
 
       
    meta.homepage = "https://github.com/ryvnf/readline.vim/";

     

       
5677
       
 
       
  };

     

       
5678
       
 
       


     

       
5679
       
-
       
  Recover-vim = buildVimPluginFrom2Nix {

     

       
5680
       
-
       
    pname = "Recover.vim";

     

       
5681
       
-
       
    version = "2015-08-14";

     

       
5682
       
-
       
    src = fetchFromGitHub {

     

       
5683
       
-
       
      owner = "chrisbra";

     

       
5684
       
-
       
      repo = "Recover.vim";

     

       
5685
       
-
       
      rev = "efa491f6121f65e025f42d79a93081abb8db69d4";

     

       
5686
       
-
       
      sha256 = "17szim82bwnhf9q4n0n4jfmqkmhq6p0lh0j4y77a2x6lkn0pns5s";

     

       
5687
       
-
       
    };

     

       
5688
       
-
       
    meta.homepage = "https://github.com/chrisbra/Recover.vim/";

     

       
5689
       
-
       
  };

     

       
5690
       
-
       


     

       
5691
       
 
       
  refactoring-nvim = buildVimPluginFrom2Nix {

     

       
5692
       
 
       
    pname = "refactoring.nvim";

     

       
5693
       
 
       
    version = "2022-03-23";

     
···

       
5712
       
 
       
    meta.homepage = "https://github.com/tversteeg/registers.nvim/";

     

       
5713
       
 
       
  };

     

       
5714
       
 
       


     

       
5715
       
-
       
  Rename = buildVimPluginFrom2Nix {

     

       
5716
       
-
       
    pname = "Rename";

     

       
5717
       
-
       
    version = "2011-08-31";

     

       
5718
       
-
       
    src = fetchFromGitHub {

     

       
5719
       
-
       
      owner = "vim-scripts";

     

       
5720
       
-
       
      repo = "Rename";

     

       
5721
       
-
       
      rev = "b240f28d2ede65fa77cd99fe045efe79202f7a34";

     

       
5722
       
-
       
      sha256 = "1d1myg4zyc281zcc1ba9idbgcgxndb4a0jwqr4yqxhhzdgszw46r";

     

       
5723
       
-
       
    };

     

       
5724
       
-
       
    meta.homepage = "https://github.com/vim-scripts/Rename/";

     

       
5725
       
-
       
  };

     

       
5726
       
-
       


     

       
5727
       
 
       
  renamer-nvim = buildVimPluginFrom2Nix {

     

       
5728
       
 
       
    pname = "renamer.nvim";

     

       
5729
       
 
       
    version = "2022-01-15";

     
···

       
5734
       
 
       
      sha256 = "00ls708qx4i39gqdjw7l8i5az0k63i4y0ma30m5zsb1cz8gyzrnp";

     

       
5735
       
 
       
    };

     

       
5736
       
 
       
    meta.homepage = "https://github.com/filipdutescu/renamer.nvim/";

     

       
5737
       
-
       
  };

     

       
5738
       
-
       


     

       
5739
       
-
       
  ReplaceWithRegister = buildVimPluginFrom2Nix {

     

       
5740
       
-
       
    pname = "ReplaceWithRegister";

     

       
5741
       
-
       
    version = "2014-10-31";

     

       
5742
       
-
       
    src = fetchFromGitHub {

     

       
5743
       
-
       
      owner = "vim-scripts";

     

       
5744
       
-
       
      repo = "ReplaceWithRegister";

     

       
5745
       
-
       
      rev = "832efc23111d19591d495dc72286de2fb0b09345";

     

       
5746
       
-
       
      sha256 = "0mb0sx85j1k59b1zz95r4vkq4kxlb4krhncq70mq7fxrs5bnhq8g";

     

       
5747
       
-
       
    };

     

       
5748
       
-
       
    meta.homepage = "https://github.com/vim-scripts/ReplaceWithRegister/";

     

       
5749
       
 
       
  };

     

       
5750
       
 
       


     

       
5751
       
 
       
  rest-nvim = buildVimPluginFrom2Nix {

     
···

       
5880
       
 
       
    meta.homepage = "https://github.com/vmware-archive/salt-vim/";

     

       
5881
       
 
       
  };

     

       
5882
       
 
       


     

       
5883
       
-
       
  SchemaStore-nvim = buildVimPluginFrom2Nix {

     

       
5884
       
-
       
    pname = "SchemaStore.nvim";

     

       
5885
       
-
       
    version = "2022-03-25";

     

       
5886
       
-
       
    src = fetchFromGitHub {

     

       
5887
       
-
       
      owner = "b0o";

     

       
5888
       
-
       
      repo = "SchemaStore.nvim";

     

       
5889
       
-
       
      rev = "f665a87f88b7b891aa5e1f91236b5bab29c2faaf";

     

       
5890
       
-
       
      sha256 = "1i90yyrm7ji8wf3if431al9ggcnps37k3lsnga3ixqa5pr7xsrg9";

     

       
5891
       
-
       
    };

     

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

     

       
5893
       
-
       
  };

     

       
5894
       
-
       


     

       
5895
       
 
       
  scrollbar-nvim = buildVimPluginFrom2Nix {

     

       
5896
       
 
       
    pname = "scrollbar.nvim";

     

       
5897
       
 
       
    version = "2021-11-16";

     
···

       
5976
       
 
       
    meta.homepage = "https://github.com/osyo-manga/shabadou.vim/";

     

       
5977
       
 
       
  };

     

       
5978
       
 
       


     

       
5979
       
-
       
  Shade-nvim = buildVimPluginFrom2Nix {

     

       
5980
       
-
       
    pname = "Shade.nvim";

     

       
5981
       
-
       
    version = "2022-02-01";

     

       
5982
       
-
       
    src = fetchFromGitHub {

     

       
5983
       
-
       
      owner = "sunjon";

     

       
5984
       
-
       
      repo = "Shade.nvim";

     

       
5985
       
-
       
      rev = "4286b5abc47d62d0c9ffb22a4f388b7bf2ac2461";

     

       
5986
       
-
       
      sha256 = "0mb0cnf8065qmjq85hlgb4a1mqk1nwl7966l1imb54hpzw828rzl";

     

       
5987
       
-
       
    };

     

       
5988
       
-
       
    meta.homepage = "https://github.com/sunjon/Shade.nvim/";

     

       
5989
       
-
       
  };

     

       
5990
       
-
       


     

       
5991
       
-
       
  ShowMultiBase = buildVimPluginFrom2Nix {

     

       
5992
       
-
       
    pname = "ShowMultiBase";

     

       
5993
       
-
       
    version = "2010-10-18";

     

       
5994
       
-
       
    src = fetchFromGitHub {

     

       
5995
       
-
       
      owner = "vim-scripts";

     

       
5996
       
-
       
      repo = "ShowMultiBase";

     

       
5997
       
-
       
      rev = "85a39fd12668ce973d3d9282263912b2b8f0d338";

     

       
5998
       
-
       
      sha256 = "0hg5352ahzgh2kwqha5v8ai024fld93xag93hb53wjf5b8nzsz8i";

     

       
5999
       
-
       
    };

     

       
6000
       
-
       
    meta.homepage = "https://github.com/vim-scripts/ShowMultiBase/";

     

       
6001
       
-
       
  };

     

       
6002
       
-
       


     

       
6003
       
 
       
  sideways-vim = buildVimPluginFrom2Nix {

     

       
6004
       
 
       
    pname = "sideways.vim";

     

       
6005
       
 
       
    version = "2022-02-12";

     
···

       
6013
       
 
       
    meta.homepage = "https://github.com/AndrewRadev/sideways.vim/";

     

       
6014
       
 
       
  };

     

       
6015
       
 
       


     

       
6016
       
-
       
  SimpylFold = buildVimPluginFrom2Nix {

     

       
6017
       
-
       
    pname = "SimpylFold";

     

       
6018
       
-
       
    version = "2021-11-04";

     

       
6019
       
-
       
    src = fetchFromGitHub {

     

       
6020
       
-
       
      owner = "tmhedberg";

     

       
6021
       
-
       
      repo = "SimpylFold";

     

       
6022
       
-
       
      rev = "b4a87e509c3d873238a39d1c85d0b97d6819f283";

     

       
6023
       
-
       
      sha256 = "0ff5x7ay67wn9c0mi8sb6110i93zrf97c4whg0bd7pr2nmadpvk0";

     

       
6024
       
-
       
    };

     

       
6025
       
-
       
    meta.homepage = "https://github.com/tmhedberg/SimpylFold/";

     

       
6026
       
-
       
  };

     

       
6027
       
-
       


     

       
6028
       
 
       
  skim-vim = buildVimPluginFrom2Nix {

     

       
6029
       
 
       
    pname = "skim.vim";

     

       
6030
       
 
       
    version = "2020-11-11";

     
···

       
6051
       
 
       


     

       
6052
       
 
       
  slimv = buildVimPluginFrom2Nix {

     

       
6053
       
 
       
    pname = "slimv";

     

       
6054
       
-
       
    version = "2022-02-11";

     

       
6055
       
 
       
    src = fetchFromGitHub {

     

       
6056
       
 
       
      owner = "kovisoft";

     

       
6057
       
 
       
      repo = "slimv";

     

       
6058
       
-
       
      rev = "1b88c3a67948b446720883ed8eadb8c2b83a21ef";

     

       
6059
       
-
       
      sha256 = "0m0kkc75ifg7lvk8p3vgq5iy8hr254ywj7hhjgxwzm2zbrwkr04s";

     

       
6060
       
 
       
    };

     

       
6061
       
 
       
    meta.homepage = "https://github.com/kovisoft/slimv/";

     

       
6062
       
 
       
  };

     
···

       
6133
       
 
       
    meta.homepage = "https://github.com/liuchengxu/space-vim/";

     

       
6134
       
 
       
  };

     

       
6135
       
 
       


     

       
6136
       
-
       
  SpaceCamp = buildVimPluginFrom2Nix {

     

       
6137
       
-
       
    pname = "SpaceCamp";

     

       
6138
       
-
       
    version = "2021-04-07";

     

       
6139
       
-
       
    src = fetchFromGitHub {

     

       
6140
       
-
       
      owner = "jaredgorski";

     

       
6141
       
-
       
      repo = "SpaceCamp";

     

       
6142
       
-
       
      rev = "376af5c2204de61726ea86b596acb2dab9795e1f";

     

       
6143
       
-
       
      sha256 = "0h3wxkswd5z9y46d6272sr210i73j5pwf5faw7qhr1plilfgx4gb";

     

       
6144
       
-
       
    };

     

       
6145
       
-
       
    meta.homepage = "https://github.com/jaredgorski/SpaceCamp/";

     

       
6146
       
-
       
  };

     

       
6147
       
-
       


     

       
6148
       
-
       
  Spacegray-vim = buildVimPluginFrom2Nix {

     

       
6149
       
-
       
    pname = "Spacegray.vim";

     

       
6150
       
-
       
    version = "2021-07-06";

     

       
6151
       
-
       
    src = fetchFromGitHub {

     

       
6152
       
-
       
      owner = "ackyshake";

     

       
6153
       
-
       
      repo = "Spacegray.vim";

     

       
6154
       
-
       
      rev = "c699ca10ed421c462bd1c87a158faaa570dc8e28";

     

       
6155
       
-
       
      sha256 = "0ma8w6p5jh6llka49x5j5ql8fmhv0bx5hhsn5b2phak79yqg1k61";

     

       
6156
       
-
       
    };

     

       
6157
       
-
       
    meta.homepage = "https://github.com/ackyshake/Spacegray.vim/";

     

       
6158
       
-
       
  };

     

       
6159
       
-
       


     

       
6160
       
 
       
  spacevim = buildVimPluginFrom2Nix {

     

       
6161
       
 
       
    pname = "spacevim";

     

       
6162
       
 
       
    version = "2018-03-29";

     
···

       
6169
       
 
       
    meta.homepage = "https://github.com/ctjhoa/spacevim/";

     

       
6170
       
 
       
  };

     

       
6171
       
 
       


     

       
6172
       
-
       
  SpaceVim = buildVimPluginFrom2Nix {

     

       
6173
       
-
       
    pname = "SpaceVim";

     

       
6174
       
-
       
    version = "2022-03-27";

     

       
6175
       
-
       
    src = fetchFromGitHub {

     

       
6176
       
-
       
      owner = "SpaceVim";

     

       
6177
       
-
       
      repo = "SpaceVim";

     

       
6178
       
-
       
      rev = "a8d183fdd97de3c1ee54c0e5f0efe9e95a19d866";

     

       
6179
       
-
       
      sha256 = "0rhpasj5jw7jhij6pqjrsb48gwf4hrpadh8ab9d611v6akkkxlvv";

     

       
6180
       
-
       
    };

     

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

     

       
6182
       
-
       
  };

     

       
6183
       
-
       


     

       
6184
       
 
       
  sparkup = buildVimPluginFrom2Nix {

     

       
6185
       
 
       
    pname = "sparkup";

     

       
6186
       
 
       
    version = "2012-06-11";

     
···

       
6231
       
 
       


     

       
6232
       
 
       
  splitjoin-vim = buildVimPluginFrom2Nix {

     

       
6233
       
 
       
    pname = "splitjoin.vim";

     

       
6234
       
-
       
    version = "2022-03-21";

     

       
6235
       
 
       
    src = fetchFromGitHub {

     

       
6236
       
 
       
      owner = "AndrewRadev";

     

       
6237
       
 
       
      repo = "splitjoin.vim";

     

       
6238
       
-
       
      rev = "c32b18751a81715e3c13cff22fea9fb5ce31ef35";

     

       
6239
       
-
       
      sha256 = "12kp185ndag507b7l4qvhr369zyikwgh0wyi9lrjyr2ar5impjqc";

     

       
6240
       
 
       
      fetchSubmodules = true;

     

       
6241
       
 
       
    };

     

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

     
···

       
6326
       
 
       
    meta.homepage = "https://github.com/lambdalisue/suda.vim/";

     

       
6327
       
 
       
  };

     

       
6328
       
 
       


     

       
6329
       
-
       
  SudoEdit-vim = buildVimPluginFrom2Nix {

     

       
6330
       
-
       
    pname = "SudoEdit.vim";

     

       
6331
       
-
       
    version = "2020-02-27";

     

       
6332
       
-
       
    src = fetchFromGitHub {

     

       
6333
       
-
       
      owner = "chrisbra";

     

       
6334
       
-
       
      repo = "SudoEdit.vim";

     

       
6335
       
-
       
      rev = "e203eada5b563e9134ce2aae26b09edae0904fd7";

     

       
6336
       
-
       
      sha256 = "0pf9iix50pw3p430ky51rv11ra1hppdpwa5flzcd5kciybr76n0n";

     

       
6337
       
-
       
    };

     

       
6338
       
-
       
    meta.homepage = "https://github.com/chrisbra/SudoEdit.vim/";

     

       
6339
       
-
       
  };

     

       
6340
       
-
       


     

       
6341
       
 
       
  supertab = buildVimPluginFrom2Nix {

     

       
6342
       
 
       
    pname = "supertab";

     

       
6343
       
 
       
    version = "2021-04-30";

     
···

       
6510
       
 
       


     

       
6511
       
 
       
  tagbar = buildVimPluginFrom2Nix {

     

       
6512
       
 
       
    pname = "tagbar";

     

       
6513
       
-
       
    version = "2022-03-15";

     

       
6514
       
 
       
    src = fetchFromGitHub {

     

       
6515
       
 
       
      owner = "preservim";

     

       
6516
       
 
       
      repo = "tagbar";

     

       
6517
       
-
       
      rev = "69659cfc9d081caf31c8d548dd4c19593839317b";

     

       
6518
       
-
       
      sha256 = "1wdrn0zvqhz7pd0rgl5z3zri3sy4hb947nmw9imvwi62mpdhsh7d";

     

       
6519
       
 
       
    };

     

       
6520
       
 
       
    meta.homepage = "https://github.com/preservim/tagbar/";

     

       
6521
       
 
       
  };

     
···

       
6787
       
 
       


     

       
6788
       
 
       
  telescope-nvim = buildVimPluginFrom2Nix {

     

       
6789
       
 
       
    pname = "telescope.nvim";

     

       
6790
       
-
       
    version = "2022-03-26";

     

       
6791
       
 
       
    src = fetchFromGitHub {

     

       
6792
       
 
       
      owner = "nvim-telescope";

     

       
6793
       
 
       
      repo = "telescope.nvim";

     

       
6794
       
-
       
      rev = "cf2d6d34282afd90f0f5d2aba265a23b068494c2";

     

       
6795
       
-
       
      sha256 = "042w0l8hdcxaj3pmbp0w1mqmivfm48pv3vlcz6d423qiljbkrk9k";

     

       
6796
       
 
       
    };

     

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

     

       
6798
       
 
       
  };

     
···

       
6968
       
 
       


     

       
6969
       
 
       
  toggleterm-nvim = buildVimPluginFrom2Nix {

     

       
6970
       
 
       
    pname = "toggleterm.nvim";

     

       
6971
       
-
       
    version = "2022-03-24";

     

       
6972
       
 
       
    src = fetchFromGitHub {

     

       
6973
       
 
       
      owner = "akinsho";

     

       
6974
       
 
       
      repo = "toggleterm.nvim";

     

       
6975
       
-
       
      rev = "9f969e7f72d19966756318d61f2562f67dbb1f9c";

     

       
6976
       
-
       
      sha256 = "118hwkn9cw2wsqigqvbpvbhbag6ywc325lvn088dfpzbn9k7vfmr";

     

       
6977
       
 
       
    };

     

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

     

       
6979
       
 
       
  };

     
···

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

     

       
7039
       
 
       
  };

     

       
7040
       
 
       


     

       
7041
       
-
       
  TrueZen-nvim = buildVimPluginFrom2Nix {

     

       
7042
       
-
       
    pname = "TrueZen.nvim";

     

       
7043
       
-
       
    version = "2021-10-12";

     

       
7044
       
-
       
    src = fetchFromGitHub {

     

       
7045
       
-
       
      owner = "Pocco81";

     

       
7046
       
-
       
      repo = "TrueZen.nvim";

     

       
7047
       
-
       
      rev = "508b977d71650da5c9243698614a9a1416f116d4";

     

       
7048
       
-
       
      sha256 = "0sr4y1mg83l28l5ias2pv0gxkcgwailfjn2skx35z63f2il3zkbx";

     

       
7049
       
-
       
    };

     

       
7050
       
-
       
    meta.homepage = "https://github.com/Pocco81/TrueZen.nvim/";

     

       
7051
       
-
       
  };

     

       
7052
       
-
       


     

       
7053
       
 
       
  tslime-vim = buildVimPluginFrom2Nix {

     

       
7054
       
 
       
    pname = "tslime.vim";

     

       
7055
       
 
       
    version = "2020-09-09";

     
···

       
7148
       
 
       


     

       
7149
       
 
       
  urlview-nvim = buildVimPluginFrom2Nix {

     

       
7150
       
 
       
    pname = "urlview.nvim";

     

       
7151
       
-
       
    version = "2022-03-29";

     

       
7152
       
 
       
    src = fetchFromGitHub {

     

       
7153
       
 
       
      owner = "axieax";

     

       
7154
       
 
       
      repo = "urlview.nvim";

     

       
7155
       
-
       
      rev = "4ca1b22d914ff3187acd5a9486421769928c9d8f";

     

       
7156
       
-
       
      sha256 = "1vy977y7favs76mpk6v3x18ph40y0d20kmm6bssvnlql1nh3ihbd";

     

       
7157
       
 
       
    };

     

       
7158
       
 
       
    meta.homepage = "https://github.com/axieax/urlview.nvim/";

     

       
7159
       
 
       
  };

     
···

       
7170
       
 
       
    meta.homepage = "https://github.com/vim-scripts/utl.vim/";

     

       
7171
       
 
       
  };

     

       
7172
       
 
       


     

       
7173
       
-
       
  vader-vim = buildVimPluginFrom2Nix {

     

       
7174
       
-
       
    pname = "vader.vim";

     

       
7175
       
-
       
    version = "2020-02-13";

     

       
7176
       
-
       
    src = fetchFromGitHub {

     

       
7177
       
-
       
      owner = "junegunn";

     

       
7178
       
-
       
      repo = "vader.vim";

     

       
7179
       
-
       
      rev = "6fff477431ac3191c69a3a5e5f187925466e275a";

     

       
7180
       
-
       
      sha256 = "153cr1mrf5w5lyr8374brwx1z5yl9h0cnijxnd3xikh3yi3pbmwk";

     

       
7181
       
-
       
    };

     

       
7182
       
-
       
    meta.homepage = "https://github.com/junegunn/vader.vim/";

     

       
7183
       
-
       
  };

     

       
7184
       
-
       


     

       
7185
       
 
       
  vCoolor-vim = buildVimPluginFrom2Nix {

     

       
7186
       
 
       
    pname = "vCoolor.vim";

     

       
7187
       
 
       
    version = "2020-10-14";

     
···

       
7192
       
 
       
      sha256 = "03vaghwqr3k0nls365wk4qwzmvdvdvq41q02c3l5qv2vsdikmz5i";

     

       
7193
       
 
       
    };

     

       
7194
       
 
       
    meta.homepage = "https://github.com/KabbAmine/vCoolor.vim/";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7195
       
 
       
  };

     

       
7196
       
 
       


     

       
7197
       
 
       
  venn-nvim = buildVimPluginFrom2Nix {

     
···

       
7220
       
 
       


     

       
7221
       
 
       
  vifm-vim = buildVimPluginFrom2Nix {

     

       
7222
       
 
       
    pname = "vifm.vim";

     

       
7223
       
-
       
    version = "2022-03-24";

     

       
7224
       
 
       
    src = fetchFromGitHub {

     

       
7225
       
 
       
      owner = "vifm";

     

       
7226
       
 
       
      repo = "vifm.vim";

     

       
7227
       
-
       
      rev = "11d8fb106515a4c4e6016742053356c9f0434fed";

     

       
7228
       
-
       
      sha256 = "1gjaqmkrxg5x6mpb7dnznbbzrv3iadcw7snxjx7bzmr0b24mddcp";

     

       
7229
       
 
       
    };

     

       
7230
       
 
       
    meta.homepage = "https://github.com/vifm/vifm.vim/";

     

       
7231
       
 
       
  };

     

       
7232
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7233
       
 
       
  vim-abolish = buildVimPluginFrom2Nix {

     

       
7234
       
 
       
    pname = "vim-abolish";

     

       
7235
       
 
       
    version = "2021-03-20";

     
···

       
7484
       
 
       


     

       
7485
       
 
       
  vim-airline = buildVimPluginFrom2Nix {

     

       
7486
       
 
       
    pname = "vim-airline";

     

       
7487
       
-
       
    version = "2022-03-23";

     

       
7488
       
 
       
    src = fetchFromGitHub {

     

       
7489
       
 
       
      owner = "vim-airline";

     

       
7490
       
 
       
      repo = "vim-airline";

     

       
7491
       
-
       
      rev = "a306a7abfd8b4450fcfdc0384dadb996148d2c1b";

     

       
7492
       
-
       
      sha256 = "0qvz41rpdbcsszh0n4jhjrw9anyzsh4r1j694a3ryjj58gg9smjy";

     

       
7493
       
 
       
    };

     

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

     

       
7495
       
 
       
  };

     
···

       
8024
       
 
       


     

       
8025
       
 
       
  vim-cool = buildVimPluginFrom2Nix {

     

       
8026
       
 
       
    pname = "vim-cool";

     

       
8027
       
-
       
    version = "2020-04-18";

     

       
8028
       
 
       
    src = fetchFromGitHub {

     

       
8029
       
 
       
      owner = "romainl";

     

       
8030
       
 
       
      repo = "vim-cool";

     

       
8031
       
-
       
      rev = "27ad4ecf7532b750fadca9f36e1c5498fc225af2";

     

       
8032
       
-
       
      sha256 = "1in44gf7hs978nc9328zh1kj3jh04kcinw0m8spcbgj079782sg8";

     

       
8033
       
 
       
    };

     

       
8034
       
 
       
    meta.homepage = "https://github.com/romainl/vim-cool/";

     

       
8035
       
 
       
  };

     
···

       
8082
       
 
       
    meta.homepage = "https://github.com/ap/vim-css-color/";

     

       
8083
       
 
       
  };

     

       
8084
       
 
       


     

       
8085
       
-
       
  vim-CtrlXA = buildVimPluginFrom2Nix {

     

       
8086
       
-
       
    pname = "vim-CtrlXA";

     

       
8087
       
-
       
    version = "2021-08-09";

     

       
8088
       
-
       
    src = fetchFromGitHub {

     

       
8089
       
-
       
      owner = "Konfekt";

     

       
8090
       
-
       
      repo = "vim-CtrlXA";

     

       
8091
       
-
       
      rev = "404ea1e055921db5679b3734108d72850d6faa76";

     

       
8092
       
-
       
      sha256 = "10bgyqnwcqly3sxl27np1b690hnj1snqbcvg8pzh4zgdysfgy9xg";

     

       
8093
       
-
       
    };

     

       
8094
       
-
       
    meta.homepage = "https://github.com/Konfekt/vim-CtrlXA/";

     

       
8095
       
-
       
  };

     

       
8096
       
-
       


     

       
8097
       
 
       
  vim-cue = buildVimPluginFrom2Nix {

     

       
8098
       
 
       
    pname = "vim-cue";

     

       
8099
       
 
       
    version = "2021-06-18";

     
···

       
8176
       
 
       
      sha256 = "0ldkyzsn4b555pb9qdr0k6w6m3w7ziy7v6bcnx0n8ppq4fl68pz2";

     

       
8177
       
 
       
    };

     

       
8178
       
 
       
    meta.homepage = "https://github.com/sunaku/vim-dasht/";

     

       
8179
       
-
       
  };

     

       
8180
       
-
       


     

       
8181
       
-
       
  vim-DetectSpellLang = buildVimPluginFrom2Nix {

     

       
8182
       
-
       
    pname = "vim-DetectSpellLang";

     

       
8183
       
-
       
    version = "2022-03-15";

     

       
8184
       
-
       
    src = fetchFromGitHub {

     

       
8185
       
-
       
      owner = "konfekt";

     

       
8186
       
-
       
      repo = "vim-DetectSpellLang";

     

       
8187
       
-
       
      rev = "d5b55e3307e72e45f8d736818c76884016583538";

     

       
8188
       
-
       
      sha256 = "0l9bdgqaxfpndpf4v5kxn34zx5pnhf62chp4flzyyhhzlz52dqjw";

     

       
8189
       
-
       
    };

     

       
8190
       
-
       
    meta.homepage = "https://github.com/konfekt/vim-DetectSpellLang/";

     

       
8191
       
 
       
  };

     

       
8192
       
 
       


     

       
8193
       
 
       
  vim-deus = buildVimPluginFrom2Nix {

     
···

       
8298
       
 
       
    meta.homepage = "https://github.com/jhradilek/vim-docbk/";

     

       
8299
       
 
       
  };

     

       
8300
       
 
       


     

       
8301
       
-
       
  vim-docbk-snippets = buildVimPluginFrom2Nix {

     

       
8302
       
-
       
    pname = "vim-docbk-snippets";

     

       
8303
       
-
       
    version = "2021-07-30";

     

       
8304
       
-
       
    src = fetchFromGitHub {

     

       
8305
       
-
       
      owner = "jhradilek";

     

       
8306
       
-
       
      repo = "vim-snippets";

     

       
8307
       
-
       
      rev = "81a8dcb66886a0717e9ca73c8857ee90c3989063";

     

       
8308
       
-
       
      sha256 = "0d6532qx66aiawpq2fdji0mnmvnlg5dnbvds5s4pgzafydikpr70";

     

       
8309
       
-
       
    };

     

       
8310
       
-
       
    meta.homepage = "https://github.com/jhradilek/vim-snippets/";

     

       
8311
       
-
       
  };

     

       
8312
       
-
       


     

       
8313
       
 
       
  vim-easy-align = buildVimPluginFrom2Nix {

     

       
8314
       
 
       
    pname = "vim-easy-align";

     

       
8315
       
 
       
    version = "2019-04-29";

     
···

       
8384
       
 
       


     

       
8385
       
 
       
  vim-elixir = buildVimPluginFrom2Nix {

     

       
8386
       
 
       
    pname = "vim-elixir";

     

       
8387
       
-
       
    version = "2022-01-26";

     

       
8388
       
 
       
    src = fetchFromGitHub {

     

       
8389
       
 
       
      owner = "elixir-editors";

     

       
8390
       
 
       
      repo = "vim-elixir";

     

       
8391
       
-
       
      rev = "ff7a1223dfc5386c41bb582039a90a262d488607";

     

       
8392
       
-
       
      sha256 = "0a82c6vmdjfq1cjiakdxd9mz0ivqivrjcrppqpwch9rzp98qspag";

     

       
8393
       
 
       
    };

     

       
8394
       
 
       
    meta.homepage = "https://github.com/elixir-editors/vim-elixir/";

     

       
8395
       
 
       
  };

     
···

       
8420
       
 
       


     

       
8421
       
 
       
  vim-endwise = buildVimPluginFrom2Nix {

     

       
8422
       
 
       
    pname = "vim-endwise";

     

       
8423
       
-
       
    version = "2022-03-24";

     

       
8424
       
 
       
    src = fetchFromGitHub {

     

       
8425
       
 
       
      owner = "tpope";

     

       
8426
       
 
       
      repo = "vim-endwise";

     

       
8427
       
-
       
      rev = "8faf48b69b04af120e162ce113ea21eac322e3b4";

     

       
8428
       
-
       
      sha256 = "0zfgsqs2mal1yh8x4lj1kx2ib80clsh9s9swh44cq5ga5glfkyn8";

     

       
8429
       
 
       
    };

     

       
8430
       
 
       
    meta.homepage = "https://github.com/tpope/vim-endwise/";

     

       
8431
       
 
       
  };

     
···

       
8480
       
 
       


     

       
8481
       
 
       
  vim-eunuch = buildVimPluginFrom2Nix {

     

       
8482
       
 
       
    pname = "vim-eunuch";

     

       
8483
       
-
       
    version = "2022-03-23";

     

       
8484
       
 
       
    src = fetchFromGitHub {

     

       
8485
       
 
       
      owner = "tpope";

     

       
8486
       
 
       
      repo = "vim-eunuch";

     

       
8487
       
-
       
      rev = "01aa41b276b45e2df2cb680ab38e78ea7e5786c1";

     

       
8488
       
-
       
      sha256 = "149hnk9ja9vnw5vr7axliyqh0l2xz6i4l3lngdlzi1xic0xfwxf5";

     

       
8489
       
 
       
    };

     

       
8490
       
 
       
    meta.homepage = "https://github.com/tpope/vim-eunuch/";

     

       
8491
       
 
       
  };

     
···

       
8540
       
 
       


     

       
8541
       
 
       
  vim-fireplace = buildVimPluginFrom2Nix {

     

       
8542
       
 
       
    pname = "vim-fireplace";

     

       
8543
       
-
       
    version = "2022-03-11";

     

       
8544
       
 
       
    src = fetchFromGitHub {

     

       
8545
       
 
       
      owner = "tpope";

     

       
8546
       
 
       
      repo = "vim-fireplace";

     

       
8547
       
-
       
      rev = "49f213283ffd79e1a397a30ce9e11849eaacf8e1";

     

       
8548
       
-
       
      sha256 = "0lk6xxbf111p1d75vagfhf1qydm1mzm4xycmyydfr46acy6a8hbk";

     

       
8549
       
 
       
    };

     

       
8550
       
 
       
    meta.homepage = "https://github.com/tpope/vim-fireplace/";

     

       
8551
       
 
       
  };

     
···

       
8672
       
 
       


     

       
8673
       
 
       
  vim-fugitive = buildVimPluginFrom2Nix {

     

       
8674
       
 
       
    pname = "vim-fugitive";

     

       
8675
       
-
       
    version = "2022-03-26";

     

       
8676
       
 
       
    src = fetchFromGitHub {

     

       
8677
       
 
       
      owner = "tpope";

     

       
8678
       
 
       
      repo = "vim-fugitive";

     

       
8679
       
-
       
      rev = "321328c6c5901a597348155fc0e83b800544dcb0";

     

       
8680
       
-
       
      sha256 = "11sd87c9vw1gs9pkvv0y24yqhkack0yxv5mg50ss6v7mjjdngv66";

     

       
8681
       
 
       
    };

     

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

     

       
8683
       
 
       
  };

     
···

       
8816
       
 
       


     

       
8817
       
 
       
  vim-go = buildVimPluginFrom2Nix {

     

       
8818
       
 
       
    pname = "vim-go";

     

       
8819
       
-
       
    version = "2022-03-19";

     

       
8820
       
 
       
    src = fetchFromGitHub {

     

       
8821
       
 
       
      owner = "fatih";

     

       
8822
       
 
       
      repo = "vim-go";

     

       
8823
       
-
       
      rev = "dcefd64ba251ffc3d497f8758036735c8f6cc824";

     

       
8824
       
-
       
      sha256 = "1j5jrs7kk59ilqsjs0qk5213psv33xnnifsqrjc7h63p28sv3pnw";

     

       
8825
       
 
       
    };

     

       
8826
       
 
       
    meta.homepage = "https://github.com/fatih/vim-go/";

     

       
8827
       
 
       
  };

     
···

       
8922
       
 
       
    meta.homepage = "https://github.com/chkno/vim-haskell-module-name/";

     

       
8923
       
 
       
  };

     

       
8924
       
 
       


     

       
8925
       
-
       
  vim-haskellconceal = buildVimPluginFrom2Nix {

     

       
8926
       
-
       
    pname = "vim-haskellconceal";

     

       
8927
       
-
       
    version = "2017-06-15";

     

       
8928
       
-
       
    src = fetchFromGitHub {

     

       
8929
       
-
       
      owner = "twinside";

     

       
8930
       
-
       
      repo = "vim-haskellconceal";

     

       
8931
       
-
       
      rev = "802f82a5afee56e9e1251e6f756104a3bd114234";

     

       
8932
       
-
       
      sha256 = "1kh6853hi4rgl4z1xs8kz9l1q9w7lh0r42y2m0rabfpr6yh3091r";

     

       
8933
       
-
       
    };

     

       
8934
       
-
       
    meta.homepage = "https://github.com/twinside/vim-haskellconceal/";

     

       
8935
       
-
       
  };

     

       
8936
       
-
       


     

       
8937
       
 
       
  vim-haskellConcealPlus = buildVimPluginFrom2Nix {

     

       
8938
       
 
       
    pname = "vim-haskellConcealPlus";

     

       
8939
       
 
       
    version = "2020-01-21";

     
···

       
8944
       
 
       
      sha256 = "1y2hgcpls21738lhrgimsxnkhxxqczp05nmk68s28xssbn4dqgma";

     

       
8945
       
 
       
    };

     

       
8946
       
 
       
    meta.homepage = "https://github.com/enomsg/vim-haskellConcealPlus/";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8947
       
 
       
  };

     

       
8948
       
 
       


     

       
8949
       
 
       
  vim-hcl = buildVimPluginFrom2Nix {

     
···

       
9117
       
 
       


     

       
9118
       
 
       
  vim-illuminate = buildVimPluginFrom2Nix {

     

       
9119
       
 
       
    pname = "vim-illuminate";

     

       
9120
       
-
       
    version = "2022-03-13";

     

       
9121
       
 
       
    src = fetchFromGitHub {

     

       
9122
       
 
       
      owner = "RRethy";

     

       
9123
       
 
       
      repo = "vim-illuminate";

     

       
9124
       
-
       
      rev = "487563de7ed6195fd46da178cb38dc1ff110c1ce";

     

       
9125
       
-
       
      sha256 = "1k4pzq1gxqpcrx828ywypff1cjrns34rh8q7yz1j8nhlqvgrda9s";

     

       
9126
       
 
       
    };

     

       
9127
       
 
       
    meta.homepage = "https://github.com/RRethy/vim-illuminate/";

     

       
9128
       
 
       
  };

     
···

       
9346
       
 
       


     

       
9347
       
 
       
  vim-kitty-navigator = buildVimPluginFrom2Nix {

     

       
9348
       
 
       
    pname = "vim-kitty-navigator";

     

       
9349
       
-
       
    version = "2022-02-04";

     

       
9350
       
 
       
    src = fetchFromGitHub {

     

       
9351
       
 
       
      owner = "knubie";

     

       
9352
       
 
       
      repo = "vim-kitty-navigator";

     

       
9353
       
-
       
      rev = "8d9af030c8a74cdda6ab9a510d9a13bca80e8f9b";

     

       
9354
       
-
       
      sha256 = "03rf49w3x67aayfn6hl0jhf4gik1scq4khhnvicp1zabdn8cq175";

     

       
9355
       
 
       
    };

     

       
9356
       
 
       
    meta.homepage = "https://github.com/knubie/vim-kitty-navigator/";

     

       
9357
       
 
       
  };

     

       
9358
       
 
       


     

       
9359
       
-
       
  vim-LanguageTool = buildVimPluginFrom2Nix {

     

       
9360
       
-
       
    pname = "vim-LanguageTool";

     

       
9361
       
-
       
    version = "2021-02-08";

     

       
9362
       
-
       
    src = fetchFromGitHub {

     

       
9363
       
-
       
      owner = "dpelle";

     

       
9364
       
-
       
      repo = "vim-LanguageTool";

     

       
9365
       
-
       
      rev = "0372ffae78aa3eac3bfa48ba3bf2f4015a86385a";

     

       
9366
       
-
       
      sha256 = "00476l49lczj1rw5gb6vs7s9r0zi1khw0g1v6bsfwl5r32699l7r";

     

       
9367
       
-
       
    };

     

       
9368
       
-
       
    meta.homepage = "https://github.com/dpelle/vim-LanguageTool/";

     

       
9369
       
-
       
  };

     

       
9370
       
-
       


     

       
9371
       
 
       
  vim-lastplace = buildVimPluginFrom2Nix {

     

       
9372
       
 
       
    pname = "vim-lastplace";

     

       
9373
       
 
       
    version = "2022-02-22";

     
···

       
10295
       
 
       


     

       
10296
       
 
       
  vim-projectionist = buildVimPluginFrom2Nix {

     

       
10297
       
 
       
    pname = "vim-projectionist";

     

       
10298
       
-
       
    version = "2022-03-13";

     

       
10299
       
 
       
    src = fetchFromGitHub {

     

       
10300
       
 
       
      owner = "tpope";

     

       
10301
       
 
       
      repo = "vim-projectionist";

     

       
10302
       
-
       
      rev = "93b2af188fe0937edea414b8e05a362b74f4b31d";

     

       
10303
       
-
       
      sha256 = "13x66y0dp70s2wcz5jkcqyp1r44sn3xdn70khzgl3jlv94ij3s1y";

     

       
10304
       
 
       
    };

     

       
10305
       
 
       
    meta.homepage = "https://github.com/tpope/vim-projectionist/";

     

       
10306
       
 
       
  };

     
···

       
10497
       
 
       
    meta.homepage = "https://github.com/tpope/vim-repeat/";

     

       
10498
       
 
       
  };

     

       
10499
       
 
       


     

       
10500
       
-
       
  vim-ReplaceWithRegister = buildVimPluginFrom2Nix {

     

       
10501
       
-
       
    pname = "vim-ReplaceWithRegister";

     

       
10502
       
-
       
    version = "2021-07-05";

     

       
10503
       
-
       
    src = fetchFromGitHub {

     

       
10504
       
-
       
      owner = "inkarkat";

     

       
10505
       
-
       
      repo = "vim-ReplaceWithRegister";

     

       
10506
       
-
       
      rev = "aad1e8fa31cb4722f20fe40679caa56e25120032";

     

       
10507
       
-
       
      sha256 = "1cfgixq5smwbp55x2baaj1kw736w2mykysppphair44vb4w9rlgm";

     

       
10508
       
-
       
    };

     

       
10509
       
-
       
    meta.homepage = "https://github.com/inkarkat/vim-ReplaceWithRegister/";

     

       
10510
       
-
       
  };

     

       
10511
       
-
       


     

       
10512
       
-
       
  vim-ReplaceWithSameIndentRegister = buildVimPluginFrom2Nix {

     

       
10513
       
-
       
    pname = "vim-ReplaceWithSameIndentRegister";

     

       
10514
       
-
       
    version = "2020-06-17";

     

       
10515
       
-
       
    src = fetchFromGitHub {

     

       
10516
       
-
       
      owner = "inkarkat";

     

       
10517
       
-
       
      repo = "vim-ReplaceWithSameIndentRegister";

     

       
10518
       
-
       
      rev = "0b7f542560bd21822a004e8accdf472eb477c9cf";

     

       
10519
       
-
       
      sha256 = "04zvhqh9rjfiwfk8r0zci608pw09svqb42nvp8pvqb11xp2ydg2y";

     

       
10520
       
-
       
    };

     

       
10521
       
-
       
    meta.homepage = "https://github.com/inkarkat/vim-ReplaceWithSameIndentRegister/";

     

       
10522
       
-
       
  };

     

       
10523
       
-
       


     

       
10524
       
 
       
  vim-rhubarb = buildVimPluginFrom2Nix {

     

       
10525
       
 
       
    pname = "vim-rhubarb";

     

       
10526
       
 
       
    version = "2021-09-13";

     
···

       
10739
       
 
       


     

       
10740
       
 
       
  vim-sleuth = buildVimPluginFrom2Nix {

     

       
10741
       
 
       
    pname = "vim-sleuth";

     

       
10742
       
-
       
    version = "2022-03-26";

     

       
10743
       
 
       
    src = fetchFromGitHub {

     

       
10744
       
 
       
      owner = "tpope";

     

       
10745
       
 
       
      repo = "vim-sleuth";

     

       
10746
       
-
       
      rev = "edffd9ee2cfafa3aba291f105a1d4f9f0e2d5701";

     

       
10747
       
-
       
      sha256 = "1rkn4qawz3p0h1pz0g712k3iz72qvapqd8k1f05kbabxymw6yqd7";

     

       
10748
       
 
       
    };

     

       
10749
       
 
       
    meta.homepage = "https://github.com/tpope/vim-sleuth/";

     

       
10750
       
 
       
  };

     
···

       
10835
       
 
       


     

       
10836
       
 
       
  vim-snippets = buildVimPluginFrom2Nix {

     

       
10837
       
 
       
    pname = "vim-snippets";

     

       
10838
       
-
       
    version = "2022-03-27";

     

       
10839
       
 
       
    src = fetchFromGitHub {

     

       
10840
       
 
       
      owner = "honza";

     

       
10841
       
 
       
      repo = "vim-snippets";

     

       
10842
       
-
       
      rev = "57d23f6f44203374edcbb7d41903a491ec8cbed7";

     

       
10843
       
-
       
      sha256 = "0371pv4pl99icxhbqbqfx7ds1i1kwv1k9p28i5pxayngkyhd7l39";

     

       
10844
       
 
       
    };

     

       
10845
       
 
       
    meta.homepage = "https://github.com/honza/vim-snippets/";

     

       
10846
       
 
       
  };

     
···

       
11013
       
 
       
    meta.homepage = "https://github.com/machakann/vim-swap/";

     

       
11014
       
 
       
  };

     

       
11015
       
 
       


     

       
11016
       
-
       
  vim-SyntaxRange = buildVimPluginFrom2Nix {

     

       
11017
       
-
       
    pname = "vim-SyntaxRange";

     

       
11018
       
-
       
    version = "2021-01-16";

     

       
11019
       
-
       
    src = fetchFromGitHub {

     

       
11020
       
-
       
      owner = "inkarkat";

     

       
11021
       
-
       
      repo = "vim-SyntaxRange";

     

       
11022
       
-
       
      rev = "3a7fd9ff50fabafe61df12522ed2f275c8e2f45e";

     

       
11023
       
-
       
      sha256 = "1b5xyacbn87z8wkacjpnjk82xmxzivlb111427kwb5kxxdh4w7gq";

     

       
11024
       
-
       
    };

     

       
11025
       
-
       
    meta.homepage = "https://github.com/inkarkat/vim-SyntaxRange/";

     

       
11026
       
-
       
  };

     

       
11027
       
-
       


     

       
11028
       
 
       
  vim-table-mode = buildVimPluginFrom2Nix {

     

       
11029
       
 
       
    pname = "vim-table-mode";

     

       
11030
       
 
       
    version = "2022-03-01";

     
···

       
11662
       
 
       
    meta.homepage = "https://github.com/jreybert/vimagit/";

     

       
11663
       
 
       
  };

     

       
11664
       
 
       


     

       
11665
       
-
       
  VimCompletesMe = buildVimPluginFrom2Nix {

     

       
11666
       
-
       
    pname = "VimCompletesMe";

     

       
11667
       
-
       
    version = "2022-02-18";

     

       
11668
       
-
       
    src = fetchFromGitHub {

     

       
11669
       
-
       
      owner = "ackyshake";

     

       
11670
       
-
       
      repo = "VimCompletesMe";

     

       
11671
       
-
       
      rev = "9adf692d7ae6424038458a89d4a411f0a27d1388";

     

       
11672
       
-
       
      sha256 = "1sndgb3291dyifaa8adri2mb8cgbinbar3nw1fnf67k9ahwycaz0";

     

       
11673
       
-
       
    };

     

       
11674
       
-
       
    meta.homepage = "https://github.com/ackyshake/VimCompletesMe/";

     

       
11675
       
-
       
  };

     

       
11676
       
-
       


     

       
11677
       
 
       
  vimelette = buildVimPluginFrom2Nix {

     

       
11678
       
 
       
    pname = "vimelette";

     

       
11679
       
 
       
    version = "2019-05-02";

     
···

       
11696
       
 
       
      sha256 = "028hcmr7xxqmb55m9q2h2x9kr5xq5866ivr0in23jm44s897yr25";

     

       
11697
       
 
       
    };

     

       
11698
       
 
       
    meta.homepage = "https://github.com/Shougo/vimfiler.vim/";

     

       
11699
       
-
       
  };

     

       
11700
       
-
       


     

       
11701
       
-
       
  VimOrganizer = buildVimPluginFrom2Nix {

     

       
11702
       
-
       
    pname = "VimOrganizer";

     

       
11703
       
-
       
    version = "2020-12-15";

     

       
11704
       
-
       
    src = fetchFromGitHub {

     

       
11705
       
-
       
      owner = "hsitz";

     

       
11706
       
-
       
      repo = "VimOrganizer";

     

       
11707
       
-
       
      rev = "09636aed78441a9de2767fcef6d7c567f322cc40";

     

       
11708
       
-
       
      sha256 = "0phpcxmyz562yyp88rbx9pqg46w8r1lyapb700nvxwvqkcd82pfw";

     

       
11709
       
-
       
    };

     

       
11710
       
-
       
    meta.homepage = "https://github.com/hsitz/VimOrganizer/";

     

       
11711
       
 
       
  };

     

       
11712
       
 
       


     

       
11713
       
 
       
  vimoutliner = buildVimPluginFrom2Nix {

     
···

       
11772
       
 
       


     

       
11773
       
 
       
  vimspector = buildVimPluginFrom2Nix {

     

       
11774
       
 
       
    pname = "vimspector";

     

       
11775
       
-
       
    version = "2022-03-23";

     

       
11776
       
 
       
    src = fetchFromGitHub {

     

       
11777
       
 
       
      owner = "puremourning";

     

       
11778
       
 
       
      repo = "vimspector";

     

       
11779
       
-
       
      rev = "99ce7a74699f12e05bf6059125d767b05ceb212b";

     

       
11780
       
-
       
      sha256 = "0hj26vyq8cbw5zsq94i4hay27fs9z5xxyniflz975ddii8189qa9";

     

       
11781
       
 
       
      fetchSubmodules = true;

     

       
11782
       
 
       
    };

     

       
11783
       
 
       
    meta.homepage = "https://github.com/puremourning/vimspector/";

     
···

       
11785
       
 
       


     

       
11786
       
 
       
  vimtex = buildVimPluginFrom2Nix {

     

       
11787
       
 
       
    pname = "vimtex";

     

       
11788
       
-
       
    version = "2022-03-24";

     

       
11789
       
 
       
    src = fetchFromGitHub {

     

       
11790
       
 
       
      owner = "lervag";

     

       
11791
       
 
       
      repo = "vimtex";

     

       
11792
       
-
       
      rev = "4eccec4e9fc46a52ba832ac2f8ab749ea33d6790";

     

       
11793
       
-
       
      sha256 = "07mydwxqhk9l0ciqpczd51x4s58asmqa3f0bznw7cdvp9qa6a6sn";

     

       
11794
       
 
       
    };

     

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

     

       
11796
       
 
       
  };

     
···

       
11855
       
 
       
    meta.homepage = "https://github.com/liuchengxu/vista.vim/";

     

       
11856
       
 
       
  };

     

       
11857
       
 
       


     

       
11858
       
-
       
  Vundle-vim = buildVimPluginFrom2Nix {

     

       
11859
       
-
       
    pname = "Vundle.vim";

     

       
11860
       
-
       
    version = "2019-08-17";

     

       
11861
       
-
       
    src = fetchFromGitHub {

     

       
11862
       
-
       
      owner = "VundleVim";

     

       
11863
       
-
       
      repo = "Vundle.vim";

     

       
11864
       
-
       
      rev = "b255382d6242d7ea3877bf059d2934125e0c4d95";

     

       
11865
       
-
       
      sha256 = "0fkmklcq3fgvd6x6irz9bgyvcdaxafykk3k89gsi9p6b0ikw3rw6";

     

       
11866
       
-
       
    };

     

       
11867
       
-
       
    meta.homepage = "https://github.com/VundleVim/Vundle.vim/";

     

       
11868
       
-
       
  };

     

       
11869
       
-
       


     

       
11870
       
 
       
  wal-vim = buildVimPluginFrom2Nix {

     

       
11871
       
 
       
    pname = "wal.vim";

     

       
11872
       
 
       
    version = "2020-11-08";

     
···

       
11905
       
 
       


     

       
11906
       
 
       
  wilder-nvim = buildVimPluginFrom2Nix {

     

       
11907
       
 
       
    pname = "wilder.nvim";

     

       
11908
       
-
       
    version = "2022-03-13";

     

       
11909
       
 
       
    src = fetchFromGitHub {

     

       
11910
       
 
       
      owner = "gelguy";

     

       
11911
       
 
       
      repo = "wilder.nvim";

     

       
11912
       
-
       
      rev = "b59648ad8588bcba377f4eecdea317796ebd1f9d";

     

       
11913
       
-
       
      sha256 = "0aic96isjssgmlqkr30m9j3895v27f3hgkgsqbl3zwkvjqa218d6";

     

       
11914
       
 
       
    };

     

       
11915
       
 
       
    meta.homepage = "https://github.com/gelguy/wilder.nvim/";

     

       
11916
       
 
       
  };

     
···

       
12011
       
 
       
    meta.homepage = "https://github.com/guns/xterm-color-table.vim/";

     

       
12012
       
 
       
  };

     

       
12013
       
 
       


     

       
12014
       
-
       
  YankRing-vim = buildVimPluginFrom2Nix {

     

       
12015
       
-
       
    pname = "YankRing.vim";

     

       
12016
       
-
       
    version = "2015-07-29";

     

       
12017
       
-
       
    src = fetchFromGitHub {

     

       
12018
       
-
       
      owner = "vim-scripts";

     

       
12019
       
-
       
      repo = "YankRing.vim";

     

       
12020
       
-
       
      rev = "28854abef8fa4ebd3cb219aefcf22566997d8f65";

     

       
12021
       
-
       
      sha256 = "0zdp8pdsqgrh6lfw8ipjhrig6psvmdxkim9ik801y3r373sk2hxw";

     

       
12022
       
-
       
    };

     

       
12023
       
-
       
    meta.homepage = "https://github.com/vim-scripts/YankRing.vim/";

     

       
12024
       
-
       
  };

     

       
12025
       
-
       


     

       
12026
       
 
       
  yats-vim = buildVimPluginFrom2Nix {

     

       
12027
       
 
       
    pname = "yats.vim";

     

       
12028
       
 
       
    version = "2022-01-05";

     
···

       
12036
       
 
       
    meta.homepage = "https://github.com/HerringtonDarkholme/yats.vim/";

     

       
12037
       
 
       
  };

     

       
12038
       
 
       


     

       
12039
       
-
       
  YouCompleteMe = buildVimPluginFrom2Nix {

     

       
12040
       
-
       
    pname = "YouCompleteMe";

     

       
12041
       
-
       
    version = "2022-03-23";

     

       
12042
       
-
       
    src = fetchFromGitHub {

     

       
12043
       
-
       
      owner = "ycm-core";

     

       
12044
       
-
       
      repo = "YouCompleteMe";

     

       
12045
       
-
       
      rev = "89bba25c96866662ca38c2428f73eb64b0351ba3";

     

       
12046
       
-
       
      sha256 = "0yrhvd9c0g6ay02b77sr657hn7ambcifwjfqsjywmnirr4zja45p";

     

       
12047
       
-
       
      fetchSubmodules = true;

     

       
12048
       
-
       
    };

     

       
12049
       
-
       
    meta.homepage = "https://github.com/ycm-core/YouCompleteMe/";

     

       
12050
       
-
       
  };

     

       
12051
       
-
       


     

       
12052
       
-
       
  YUNOcommit-vim = buildVimPluginFrom2Nix {

     

       
12053
       
-
       
    pname = "YUNOcommit.vim";

     

       
12054
       
-
       
    version = "2014-11-26";

     

       
12055
       
-
       
    src = fetchFromGitHub {

     

       
12056
       
-
       
      owner = "esneider";

     

       
12057
       
-
       
      repo = "YUNOcommit.vim";

     

       
12058
       
-
       
      rev = "981082055a73ef076d7e27477874d2303153a448";

     

       
12059
       
-
       
      sha256 = "0mjc7fn405vcx1n7vadl98p5wgm6jxrlbdbkqgjq8f1m1ir81zab";

     

       
12060
       
-
       
    };

     

       
12061
       
-
       
    meta.homepage = "https://github.com/esneider/YUNOcommit.vim/";

     

       
12062
       
-
       
  };

     

       
12063
       
-
       


     

       
12064
       
 
       
  zeavim-vim = buildVimPluginFrom2Nix {

     

       
12065
       
 
       
    pname = "zeavim.vim";

     

       
12066
       
 
       
    version = "2019-06-07";

     
···

       
12143
       
 
       
      sha256 = "0zisr1r1z9ys0jkab1lvwy4klwkay07p0095f03r9qydnig8jgsm";

     

       
12144
       
 
       
    };

     

       
12145
       
 
       
    meta.homepage = "https://github.com/nanotee/zoxide.vim/";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12146
       
 
       
  };

     

       
12147
       
 
       


     

       
12148
       
 
       
}