pygments.rb 2.4.1 → 4.0.0

data/vendor/pygments-main/pygments/lexers/shell.py

@@ -4,7 +4,7 @@
 
     Lexers for various shells.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -25,18 +25,18 @@ __all__ = ['BashLexer', 'BashSessionLexer', 'TcshLexer', 'BatchLexer',
 class BashLexer(RegexLexer):
     """
     Lexer for (ba|k|z|)sh shell scripts.
-
-    .. versionadded:: 0.6
     """
 
     name = 'Bash'
-    aliases = ['bash', 'sh', 'ksh', 'zsh', 'shell']
+    aliases = ['bash', 'sh', 'ksh', 'zsh', 'shell', 'openrc']
     filenames = ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass',
                  '*.exheres-0', '*.exlib', '*.zsh',
                  '.bashrc', 'bashrc', '.bash_*', 'bash_*', 'zshrc', '.zshrc',
                  '.kshrc', 'kshrc',
                  'PKGBUILD']
     mimetypes = ['application/x-sh', 'application/x-shellscript', 'text/x-shellscript']
+    url = 'https://en.wikipedia.org/wiki/Unix_shell'
+    version_added = '0.6'
 
     tokens = {
         'root': [
@@ -129,14 +129,13 @@ class BashLexer(RegexLexer):
 class SlurmBashLexer(BashLexer):
     """
     Lexer for (ba|k|z|)sh Slurm scripts.
-
-    .. versionadded:: 2.4
     """
 
     name = 'Slurm'
     aliases = ['slurm', 'sbatch']
     filenames = ['*.sl']
     mimetypes = []
+    version_added = '2.4'
     EXTRA_KEYWORDS = {'srun'}
 
     def get_tokens_unprocessed(self, text):
@@ -225,14 +224,15 @@ class BashSessionLexer(ShellSessionBaseLexer):
     """
     Lexer for Bash shell sessions, i.e. command lines, including a
     prompt, interspersed with output.
-
-    .. versionadded:: 1.1
     """
 
     name = 'Bash Session'
     aliases = ['console', 'shell-session']
     filenames = ['*.sh-session', '*.shell-session']
     mimetypes = ['application/x-shell-session', 'application/x-sh-session']
+    url = 'https://en.wikipedia.org/wiki/Unix_shell'
+    version_added = '1.1'
+    _example = "console/example.sh-session"
 
     _innerLexerCls = BashLexer
     _ps1rgx = re.compile(
@@ -244,13 +244,13 @@ class BashSessionLexer(ShellSessionBaseLexer):
 class BatchLexer(RegexLexer):
     """
     Lexer for the DOS/Windows Batch file format.
-
-    .. versionadded:: 0.7
     """
     name = 'Batchfile'
     aliases = ['batch', 'bat', 'dosbatch', 'winbatch']
     filenames = ['*.bat', '*.cmd']
     mimetypes = ['application/x-dos-batch']
+    url = 'https://en.wikipedia.org/wiki/Batch_file'
+    version_added = '0.7'
 
     flags = re.MULTILINE | re.IGNORECASE
 
@@ -258,28 +258,25 @@ class BatchLexer(RegexLexer):
     _punct = r'&<>|'
     _ws = r'\t\v\f\r ,;=\xa0'
     _nlws = r'\s\x1a\xa0,;='
-    _space = r'(?:(?:(?:\^[%s])?[%s])+)' % (_nl, _ws)
-    _keyword_terminator = (r'(?=(?:\^[%s]?)?[%s+./:[\\\]]|[%s%s(])' %
-                           (_nl, _ws, _nl, _punct))
-    _token_terminator = r'(?=\^?[%s]|[%s%s])' % (_ws, _punct, _nl)
-    _start_label = r'((?:(?<=^[^:])|^[^:]?)[%s]*)(:)' % _ws
-    _label = r'(?:(?:[^%s%s+:^]|\^[%s]?[\w\W])*)' % (_nlws, _punct, _nl)
-    _label_compound = r'(?:(?:[^%s%s+:^)]|\^[%s]?[^)])*)' % (_nlws, _punct, _nl)
-    _number = r'(?:-?(?:0[0-7]+|0x[\da-f]+|\d+)%s)' % _token_terminator
+    _space = rf'(?:(?:(?:\^[{_nl}])?[{_ws}])+)'
+    _keyword_terminator = (rf'(?=(?:\^[{_nl}]?)?[{_ws}+./:[\\\]]|[{_nl}{_punct}(])')
+    _token_terminator = rf'(?=\^?[{_ws}]|[{_punct}{_nl}])'
+    _start_label = rf'((?:(?<=^[^:])|^[^:]?)[{_ws}]*)(:)'
+    _label = rf'(?:(?:[^{_nlws}{_punct}+:^]|\^[{_nl}]?[\w\W])*)'
+    _label_compound = rf'(?:(?:[^{_nlws}{_punct}+:^)]|\^[{_nl}]?[^)])*)'
+    _number = rf'(?:-?(?:0[0-7]+|0x[\da-f]+|\d+){_token_terminator})'
     _opword = r'(?:equ|geq|gtr|leq|lss|neq)'
-    _string = r'(?:"[^%s"]*(?:"|(?=[%s])))' % (_nl, _nl)
-    _variable = (r'(?:(?:%%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|'
-                 r'[^%%:%s]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%%%s^]|'
-                 r'\^[^%%%s])[^=%s]*=(?:[^%%%s^]|\^[^%%%s])*)?)?%%))|'
-                 r'(?:\^?![^!:%s]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:'
-                 r'[^!%s^]|\^[^!%s])[^=%s]*=(?:[^!%s^]|\^[^!%s])*)?)?\^?!))' %
-                 (_nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl, _nl))
-    _core_token = r'(?:(?:(?:\^[%s]?)?[^"%s%s])+)' % (_nl, _nlws, _punct)
-    _core_token_compound = r'(?:(?:(?:\^[%s]?)?[^"%s%s)])+)' % (_nl, _nlws, _punct)
-    _token = r'(?:[%s]+|%s)' % (_punct, _core_token)
-    _token_compound = r'(?:[%s]+|%s)' % (_punct, _core_token_compound)
-    _stoken = (r'(?:[%s]+|(?:%s|%s|%s)+)' %
-               (_punct, _string, _variable, _core_token))
+    _string = rf'(?:"[^{_nl}"]*(?:"|(?=[{_nl}])))'
+    _variable = (r'(?:(?:%(?:\*|(?:~[a-z]*(?:\$[^:]+:)?)?\d|'
+                 rf'[^%:{_nl}]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:[^%{_nl}^]|'
+                 rf'\^[^%{_nl}])[^={_nl}]*=(?:[^%{_nl}^]|\^[^%{_nl}])*)?)?%))|'
+                 rf'(?:\^?![^!:{_nl}]+(?::(?:~(?:-?\d+)?(?:,(?:-?\d+)?)?|(?:'
+                 rf'[^!{_nl}^]|\^[^!{_nl}])[^={_nl}]*=(?:[^!{_nl}^]|\^[^!{_nl}])*)?)?\^?!))')
+    _core_token = rf'(?:(?:(?:\^[{_nl}]?)?[^"{_nlws}{_punct}])+)'
+    _core_token_compound = rf'(?:(?:(?:\^[{_nl}]?)?[^"{_nlws}{_punct})])+)'
+    _token = rf'(?:[{_punct}]+|{_core_token})'
+    _token_compound = rf'(?:[{_punct}]+|{_core_token_compound})'
+    _stoken = (rf'(?:[{_punct}]+|(?:{_string}|{_variable}|{_core_token})+)')
 
     def _make_begin_state(compound, _core_token=_core_token,
                           _core_token_compound=_core_token_compound,
@@ -288,81 +285,71 @@ class BatchLexer(RegexLexer):
                           _space=_space, _start_label=_start_label,
                           _stoken=_stoken, _token_terminator=_token_terminator,
                           _variable=_variable, _ws=_ws):
-        rest = '(?:%s|%s|[^"%%%s%s%s])*' % (_string, _variable, _nl, _punct,
+        rest = '(?:{}|{}|[^"%{}{}{}])*'.format(_string, _variable, _nl, _punct,
                                             ')' if compound else '')
-        rest_of_line = r'(?:(?:[^%s^]|\^[%s]?[\w\W])*)' % (_nl, _nl)
-        rest_of_line_compound = r'(?:(?:[^%s^)]|\^[%s]?[^)])*)' % (_nl, _nl)
-        set_space = r'((?:(?:\^[%s]?)?[^\S\n])*)' % _nl
+        rest_of_line = rf'(?:(?:[^{_nl}^]|\^[{_nl}]?[\w\W])*)'
+        rest_of_line_compound = rf'(?:(?:[^{_nl}^)]|\^[{_nl}]?[^)])*)'
+        set_space = rf'((?:(?:\^[{_nl}]?)?[^\S\n])*)'
         suffix = ''
         if compound:
-            _keyword_terminator = r'(?:(?=\))|%s)' % _keyword_terminator
-            _token_terminator = r'(?:(?=\))|%s)' % _token_terminator
+            _keyword_terminator = rf'(?:(?=\))|{_keyword_terminator})'
+            _token_terminator = rf'(?:(?=\))|{_token_terminator})'
             suffix = '/compound'
         return [
             ((r'\)', Punctuation, '#pop') if compound else
-             (r'\)((?=\()|%s)%s' % (_token_terminator, rest_of_line),
+             (rf'\)((?=\()|{_token_terminator}){rest_of_line}',
               Comment.Single)),
-            (r'(?=%s)' % _start_label, Text, 'follow%s' % suffix),
+            (rf'(?={_start_label})', Text, f'follow{suffix}'),
             (_space, using(this, state='text')),
-            include('redirect%s' % suffix),
-            (r'[%s]+' % _nl, Text),
+            include(f'redirect{suffix}'),
+            (rf'[{_nl}]+', Text),
             (r'\(', Punctuation, 'root/compound'),
             (r'@+', Punctuation),
-            (r'((?:for|if|rem)(?:(?=(?:\^[%s]?)?/)|(?:(?!\^)|'
-             r'(?<=m))(?:(?=\()|%s)))(%s?%s?(?:\^[%s]?)?/(?:\^[%s]?)?\?)' %
-             (_nl, _token_terminator, _space,
-              _core_token_compound if compound else _core_token, _nl, _nl),
+            (rf'((?:for|if|rem)(?:(?=(?:\^[{_nl}]?)?/)|(?:(?!\^)|'
+             rf'(?<=m))(?:(?=\()|{_token_terminator})))({_space}?{_core_token_compound if compound else _core_token}?(?:\^[{_nl}]?)?/(?:\^[{_nl}]?)?\?)',
              bygroups(Keyword, using(this, state='text')),
-             'follow%s' % suffix),
-            (r'(goto%s)(%s(?:\^[%s]?)?/(?:\^[%s]?)?\?%s)' %
-             (_keyword_terminator, rest, _nl, _nl, rest),
+             f'follow{suffix}'),
+            (rf'(goto{_keyword_terminator})({rest}(?:\^[{_nl}]?)?/(?:\^[{_nl}]?)?\?{rest})',
              bygroups(Keyword, using(this, state='text')),
-             'follow%s' % suffix),
+             f'follow{suffix}'),
             (words(('assoc', 'break', 'cd', 'chdir', 'cls', 'color', 'copy',
                     'date', 'del', 'dir', 'dpath', 'echo', 'endlocal', 'erase',
                     'exit', 'ftype', 'keys', 'md', 'mkdir', 'mklink', 'move',
                     'path', 'pause', 'popd', 'prompt', 'pushd', 'rd', 'ren',
                     'rename', 'rmdir', 'setlocal', 'shift', 'start', 'time',
                     'title', 'type', 'ver', 'verify', 'vol'),
-                   suffix=_keyword_terminator), Keyword, 'follow%s' % suffix),
-            (r'(call)(%s?)(:)' % _space,
+                   suffix=_keyword_terminator), Keyword, f'follow{suffix}'),
+            (rf'(call)({_space}?)(:)',
              bygroups(Keyword, using(this, state='text'), Punctuation),
-             'call%s' % suffix),
-            (r'call%s' % _keyword_terminator, Keyword),
-            (r'(for%s(?!\^))(%s)(/f%s)' %
-             (_token_terminator, _space, _token_terminator),
+             f'call{suffix}'),
+            (rf'call{_keyword_terminator}', Keyword),
+            (rf'(for{_token_terminator}(?!\^))({_space})(/f{_token_terminator})',
              bygroups(Keyword, using(this, state='text'), Keyword),
              ('for/f', 'for')),
-            (r'(for%s(?!\^))(%s)(/l%s)' %
-             (_token_terminator, _space, _token_terminator),
+            (rf'(for{_token_terminator}(?!\^))({_space})(/l{_token_terminator})',
              bygroups(Keyword, using(this, state='text'), Keyword),
              ('for/l', 'for')),
-            (r'for%s(?!\^)' % _token_terminator, Keyword, ('for2', 'for')),
-            (r'(goto%s)(%s?)(:?)' % (_keyword_terminator, _space),
+            (rf'for{_token_terminator}(?!\^)', Keyword, ('for2', 'for')),
+            (rf'(goto{_keyword_terminator})({_space}?)(:?)',
              bygroups(Keyword, using(this, state='text'), Punctuation),
-             'label%s' % suffix),
-            (r'(if(?:(?=\()|%s)(?!\^))(%s?)((?:/i%s)?)(%s?)((?:not%s)?)(%s?)' %
-             (_token_terminator, _space, _token_terminator, _space,
-              _token_terminator, _space),
+             f'label{suffix}'),
+            (rf'(if(?:(?=\()|{_token_terminator})(?!\^))({_space}?)((?:/i{_token_terminator})?)({_space}?)((?:not{_token_terminator})?)({_space}?)',
              bygroups(Keyword, using(this, state='text'), Keyword,
                       using(this, state='text'), Keyword,
                       using(this, state='text')), ('(?', 'if')),
-            (r'rem(((?=\()|%s)%s?%s?.*|%s%s)' %
-             (_token_terminator, _space, _stoken, _keyword_terminator,
-              rest_of_line_compound if compound else rest_of_line),
-             Comment.Single, 'follow%s' % suffix),
-            (r'(set%s)%s(/a)' % (_keyword_terminator, set_space),
+            (rf'rem(((?=\()|{_token_terminator}){_space}?{_stoken}?.*|{_keyword_terminator}{rest_of_line_compound if compound else rest_of_line})',
+             Comment.Single, f'follow{suffix}'),
+            (rf'(set{_keyword_terminator}){set_space}(/a)',
              bygroups(Keyword, using(this, state='text'), Keyword),
-             'arithmetic%s' % suffix),
-            (r'(set%s)%s((?:/p)?)%s((?:(?:(?:\^[%s]?)?[^"%s%s^=%s]|'
-             r'\^[%s]?[^"=])+)?)((?:(?:\^[%s]?)?=)?)' %
-             (_keyword_terminator, set_space, set_space, _nl, _nl, _punct,
+             f'arithmetic{suffix}'),
+            (r'(set{}){}((?:/p)?){}((?:(?:(?:\^[{}]?)?[^"{}{}^={}]|'
+             r'\^[{}]?[^"=])+)?)((?:(?:\^[{}]?)?=)?)'.format(_keyword_terminator, set_space, set_space, _nl, _nl, _punct,
               ')' if compound else '', _nl, _nl),
              bygroups(Keyword, using(this, state='text'), Keyword,
                       using(this, state='text'), using(this, state='variable'),
                       Punctuation),
-             'follow%s' % suffix),
-            default('follow%s' % suffix)
+             f'follow{suffix}'),
+            default(f'follow{suffix}')
         ]
 
     def _make_follow_state(compound, _label=_label,
@@ -375,11 +362,10 @@ class BatchLexer(RegexLexer):
         if compound:
             state.append((r'(?=\))', Text, '#pop'))
         state += [
-            (r'%s([%s]*)(%s)(.*)' %
-             (_start_label, _ws, _label_compound if compound else _label),
+            (rf'{_start_label}([{_ws}]*)({_label_compound if compound else _label})(.*)',
              bygroups(Text, Punctuation, Text, Name.Label, Comment.Single)),
-            include('redirect%s' % suffix),
-            (r'(?=[%s])' % _nl, Text, '#pop'),
+            include(f'redirect{suffix}'),
+            (rf'(?=[{_nl}])', Text, '#pop'),
             (r'\|\|?|&&?', Punctuation, '#pop'),
             include('text')
         ]
@@ -397,9 +383,8 @@ class BatchLexer(RegexLexer):
             (r'0x[\da-f]+', Number.Hex),
             (r'\d+', Number.Integer),
             (r'[(),]+', Punctuation),
-            (r'([%s]|%%|\^\^)+' % op, Operator),
-            (r'(%s|%s|(\^[%s]?)?[^()%s%%\^"%s%s]|\^[%s]?%s)+' %
-             (_string, _variable, _nl, op, _nlws, _punct, _nlws,
+            (rf'([{op}]|%|\^\^)+', Operator),
+            (r'({}|{}|(\^[{}]?)?[^(){}%\^"{}{}]|\^[{}]?{})+'.format(_string, _variable, _nl, op, _nlws, _punct, _nlws,
               r'[^)]' if compound else r'[\w\W]'),
              using(this, state='variable')),
             (r'(?=[\x00|&])', Text, '#pop'),
@@ -422,8 +407,7 @@ class BatchLexer(RegexLexer):
         state = []
         if compound:
             state.append((r'(?=\))', Text, '#pop'))
-        state.append((r'(%s?)((?:%s|%s|\^[%s]?%s|[^"%%^%s%s%s])*)' %
-                      (_label_compound if compound else _label, _string,
+        state.append((r'({}?)((?:{}|{}|\^[{}]?{}|[^"%^{}{}{}])*)'.format(_label_compound if compound else _label, _string,
                        _variable, _nl, r'[^)]' if compound else r'[\w\W]', _nl,
                        _punct, r')' if compound else ''),
                       bygroups(Name.Label, Comment.Single), '#pop'))
@@ -434,14 +418,11 @@ class BatchLexer(RegexLexer):
                              _nl=_nl, _punct=_punct, _stoken=_stoken,
                              _string=_string, _space=_space,
                              _variable=_variable, _nlws=_nlws):
-        stoken_compound = (r'(?:[%s]+|(?:%s|%s|%s)+)' %
-                           (_punct, _string, _variable, _core_token_compound))
+        stoken_compound = (rf'(?:[{_punct}]+|(?:{_string}|{_variable}|{_core_token_compound})+)')
         return [
-            (r'((?:(?<=[%s])\d)?)(>>?&|<&)([%s]*)(\d)' %
-             (_nlws, _nlws),
+            (rf'((?:(?<=[{_nlws}])\d)?)(>>?&|<&)([{_nlws}]*)(\d)',
              bygroups(Number.Integer, Punctuation, Text, Number.Integer)),
-            (r'((?:(?<=[%s])(?<!\^[%s])\d)?)(>>?|<)(%s?%s)' %
-             (_nlws, _nl, _space, stoken_compound if compound else _stoken),
+            (rf'((?:(?<=[{_nlws}])(?<!\^[{_nl}])\d)?)(>>?|<)({_space}?{stoken_compound if compound else _stoken})',
              bygroups(Number.Integer, Punctuation, using(this, state='text')))
         ]
 
@@ -460,13 +441,13 @@ class BatchLexer(RegexLexer):
         'redirect/compound': _make_redirect_state(True),
         'variable-or-escape': [
             (_variable, Name.Variable),
-            (r'%%%%|\^[%s]?(\^!|[\w\W])' % _nl, String.Escape)
+            (rf'%%|\^[{_nl}]?(\^!|[\w\W])', String.Escape)
         ],
         'string': [
             (r'"', String.Double, '#pop'),
             (_variable, Name.Variable),
             (r'\^!|%%', String.Escape),
-            (r'[^"%%^%s]+|[%%^]' % _nl, String.Double),
+            (rf'[^"%^{_nl}]+|[%^]', String.Double),
             default('#pop')
         ],
         'sqstring': [
@@ -480,34 +461,34 @@ class BatchLexer(RegexLexer):
         'text': [
             (r'"', String.Double, 'string'),
             include('variable-or-escape'),
-            (r'[^"%%^%s%s\d)]+|.' % (_nlws, _punct), Text)
+            (rf'[^"%^{_nlws}{_punct}\d)]+|.', Text)
         ],
         'variable': [
             (r'"', String.Double, 'string'),
             include('variable-or-escape'),
-            (r'[^"%%^%s]+|.' % _nl, Name.Variable)
+            (rf'[^"%^{_nl}]+|.', Name.Variable)
         ],
         'for': [
-            (r'(%s)(in)(%s)(\()' % (_space, _space),
+            (rf'({_space})(in)({_space})(\()',
              bygroups(using(this, state='text'), Keyword,
                       using(this, state='text'), Punctuation), '#pop'),
             include('follow')
         ],
         'for2': [
             (r'\)', Punctuation),
-            (r'(%s)(do%s)' % (_space, _token_terminator),
+            (rf'({_space})(do{_token_terminator})',
              bygroups(using(this, state='text'), Keyword), '#pop'),
-            (r'[%s]+' % _nl, Text),
+            (rf'[{_nl}]+', Text),
             include('follow')
         ],
         'for/f': [
-            (r'(")((?:%s|[^"])*?")([%s]*)(\))' % (_variable, _nlws),
+            (rf'(")((?:{_variable}|[^"])*?")([{_nlws}]*)(\))',
              bygroups(String.Double, using(this, state='string'), Text,
                       Punctuation)),
             (r'"', String.Double, ('#pop', 'for2', 'string')),
-            (r"('(?:%%%%|%s|[\w\W])*?')([%s]*)(\))" % (_variable, _nlws),
+            (rf"('(?:%%|{_variable}|[\w\W])*?')([{_nlws}]*)(\))",
              bygroups(using(this, state='sqstring'), Text, Punctuation)),
-            (r'(`(?:%%%%|%s|[\w\W])*?`)([%s]*)(\))' % (_variable, _nlws),
+            (rf'(`(?:%%|{_variable}|[\w\W])*?`)([{_nlws}]*)(\))',
              bygroups(using(this, state='bqstring'), Text, Punctuation)),
             include('for2')
         ],
@@ -516,25 +497,24 @@ class BatchLexer(RegexLexer):
             include('for2')
         ],
         'if': [
-            (r'((?:cmdextversion|errorlevel)%s)(%s)(\d+)' %
-             (_token_terminator, _space),
+            (rf'((?:cmdextversion|errorlevel){_token_terminator})({_space})(\d+)',
              bygroups(Keyword, using(this, state='text'),
                       Number.Integer), '#pop'),
-            (r'(defined%s)(%s)(%s)' % (_token_terminator, _space, _stoken),
+            (rf'(defined{_token_terminator})({_space})({_stoken})',
              bygroups(Keyword, using(this, state='text'),
                       using(this, state='variable')), '#pop'),
-            (r'(exist%s)(%s%s)' % (_token_terminator, _space, _stoken),
+            (rf'(exist{_token_terminator})({_space}{_stoken})',
              bygroups(Keyword, using(this, state='text')), '#pop'),
-            (r'(%s%s)(%s)(%s%s)' % (_number, _space, _opword, _space, _number),
+            (rf'({_number}{_space})({_opword})({_space}{_number})',
              bygroups(using(this, state='arithmetic'), Operator.Word,
                       using(this, state='arithmetic')), '#pop'),
             (_stoken, using(this, state='text'), ('#pop', 'if2')),
         ],
         'if2': [
-            (r'(%s?)(==)(%s?%s)' % (_space, _space, _stoken),
+            (rf'({_space}?)(==)({_space}?{_stoken})',
              bygroups(using(this, state='text'), Operator,
                       using(this, state='text')), '#pop'),
-            (r'(%s)(%s)(%s%s)' % (_space, _opword, _space, _stoken),
+            (rf'({_space})({_opword})({_space}{_stoken})',
              bygroups(using(this, state='text'), Operator.Word,
                       using(this, state='text')), '#pop')
         ],
@@ -545,7 +525,7 @@ class BatchLexer(RegexLexer):
         ],
         'else?': [
             (_space, using(this, state='text')),
-            (r'else%s' % _token_terminator, Keyword, '#pop'),
+            (rf'else{_token_terminator}', Keyword, '#pop'),
             default('#pop')
         ]
     }
@@ -555,14 +535,15 @@ class MSDOSSessionLexer(ShellSessionBaseLexer):
     """
     Lexer for MS DOS shell sessions, i.e. command lines, including a
     prompt, interspersed with output.
-
-    .. versionadded:: 2.1
     """
 
     name = 'MSDOS Session'
     aliases = ['doscon']
     filenames = []
     mimetypes = []
+    url = 'https://en.wikipedia.org/wiki/MS-DOS'
+    version_added = '2.1'
+    _example = "doscon/session"
 
     _innerLexerCls = BatchLexer
     _ps1rgx = re.compile(r'^([^>]*>)(.*\n?)')
@@ -572,14 +553,14 @@ class MSDOSSessionLexer(ShellSessionBaseLexer):
 class TcshLexer(RegexLexer):
     """
     Lexer for tcsh scripts.
-
-    .. versionadded:: 0.10
     """
 
     name = 'Tcsh'
     aliases = ['tcsh', 'csh']
     filenames = ['*.tcsh', '*.csh']
     mimetypes = ['application/x-csh']
+    url = 'https://www.tcsh.org'
+    version_added = '0.10'
 
     tokens = {
         'root': [
@@ -641,14 +622,15 @@ class TcshSessionLexer(ShellSessionBaseLexer):
     """
     Lexer for Tcsh sessions, i.e. command lines, including a
     prompt, interspersed with output.
-
-    .. versionadded:: 2.1
     """
 
     name = 'Tcsh Session'
     aliases = ['tcshcon']
     filenames = []
     mimetypes = []
+    url = 'https://www.tcsh.org'
+    version_added = '2.1'
+    _example = "tcshcon/session"
 
     _innerLexerCls = TcshLexer
     _ps1rgx = re.compile(r'^([^>]+>)(.*\n?)')
@@ -658,13 +640,13 @@ class TcshSessionLexer(ShellSessionBaseLexer):
 class PowerShellLexer(RegexLexer):
     """
     For Windows PowerShell code.
-
-    .. versionadded:: 1.5
     """
     name = 'PowerShell'
     aliases = ['powershell', 'pwsh', 'posh', 'ps1', 'psm1']
     filenames = ['*.ps1', '*.psm1']
     mimetypes = ['text/x-powershell']
+    url = 'https://learn.microsoft.com/en-us/powershell'
+    version_added = '1.5'
 
     flags = re.DOTALL | re.IGNORECASE | re.MULTILINE
 
@@ -721,7 +703,7 @@ class PowerShellLexer(RegexLexer):
             # of '$(...)' blocks in strings
             (r'\(', Punctuation, 'child'),
             (r'\s+', Text),
-            (r'^(\s*#[#\s]*)(\.(?:%s))([^\n]*$)' % '|'.join(commenthelp),
+            (r'^(\s*#[#\s]*)(\.(?:{}))([^\n]*$)'.format('|'.join(commenthelp)),
              bygroups(Comment, String.Doc, Comment)),
             (r'#[^\n]*?$', Comment),
             (r'(&lt;|<)#', Comment.Multiline, 'multline'),
@@ -733,10 +715,10 @@ class PowerShellLexer(RegexLexer):
             (r"'([^']|'')*'", String.Single),
             (r'(\$|@@|@)((global|script|private|env):)?\w+',
              Name.Variable),
-            (r'(%s)\b' % '|'.join(keywords), Keyword),
-            (r'-(%s)\b' % '|'.join(operators), Operator),
-            (r'(%s)-[a-z_]\w*\b' % '|'.join(verbs), Name.Builtin),
-            (r'(%s)\s' % '|'.join(aliases_), Name.Builtin),
+            (r'({})\b'.format('|'.join(keywords)), Keyword),
+            (r'-({})\b'.format('|'.join(operators)), Operator),
+            (r'({})-[a-z_]\w*\b'.format('|'.join(verbs)), Name.Builtin),
+            (r'({})\s'.format('|'.join(aliases_)), Name.Builtin),
             (r'\[[a-z_\[][\w. `,\[\]]*\]', Name.Constant),  # .net [type]s
             (r'-[a-z_]\w*', Name),
             (r'\w+', Name),
@@ -749,7 +731,7 @@ class PowerShellLexer(RegexLexer):
         'multline': [
             (r'[^#&.]+', Comment.Multiline),
             (r'#(>|&gt;)', Comment.Multiline, '#pop'),
-            (r'\.(%s)' % '|'.join(commenthelp), String.Doc),
+            (r'\.({})'.format('|'.join(commenthelp)), String.Doc),
             (r'[#&.]', Comment.Multiline),
         ],
         'string': [
@@ -773,14 +755,15 @@ class PowerShellSessionLexer(ShellSessionBaseLexer):
     """
     Lexer for PowerShell sessions, i.e. command lines, including a
     prompt, interspersed with output.
-
-    .. versionadded:: 2.1
     """
 
     name = 'PowerShell Session'
     aliases = ['pwsh-session', 'ps1con']
     filenames = []
     mimetypes = []
+    url = 'https://learn.microsoft.com/en-us/powershell'
+    version_added = '2.1'
+    _example = "pwsh-session/session"
 
     _innerLexerCls = PowerShellLexer
     _bare_continuation = True
@@ -791,14 +774,14 @@ class PowerShellSessionLexer(ShellSessionBaseLexer):
 class FishShellLexer(RegexLexer):
     """
     Lexer for Fish shell scripts.
-
-    .. versionadded:: 2.1
     """
 
     name = 'Fish'
     aliases = ['fish', 'fishshell']
     filenames = ['*.fish', '*.load']
     mimetypes = ['application/x-fish']
+    url = 'https://fishshell.com'
+    version_added = '2.1'
 
     tokens = {
         'root': [
@@ -862,15 +845,14 @@ class FishShellLexer(RegexLexer):
 
 class ExeclineLexer(RegexLexer):
     """
-    Lexer for Laurent Bercot's execline language
-    (https://skarnet.org/software/execline).
-
-    .. versionadded:: 2.7
+    Lexer for Laurent Bercot's execline language.
     """
 
     name = 'execline'
     aliases = ['execline']
     filenames = ['*.exec']
+    url = 'https://skarnet.org/software/execline'
+    version_added = '2.7'
 
     tokens = {
         'root': [

data/vendor/pygments-main/pygments/lexers/sieve.py

@@ -13,7 +13,7 @@
     https://tools.ietf.org/html/rfc5429
     https://tools.ietf.org/html/rfc8580
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -27,12 +27,12 @@ __all__ = ["SieveLexer"]
 class SieveLexer(RegexLexer):
     """
     Lexer for sieve format.
-
-    .. versionadded:: 2.6
     """
     name = 'Sieve'
     filenames = ['*.siv', '*.sieve']
     aliases = ['sieve']
+    url = 'https://en.wikipedia.org/wiki/Sieve_(mail_filtering_language)'
+    version_added = '2.6'
 
     tokens = {
         'root': [

data/vendor/pygments-main/pygments/lexers/slash.py

@@ -2,10 +2,9 @@
     pygments.lexers.slash
     ~~~~~~~~~~~~~~~~~~~~~
 
-    Lexer for the `Slash <https://github.com/arturadib/Slash-A>`_ programming
-    language.
+    Lexer for the Slash programming language.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -171,13 +170,13 @@ class SlashLanguageLexer(ExtendedRegexLexer):
 class SlashLexer(DelegatingLexer):
     """
     Lexer for the Slash programming language.
-
-    .. versionadded:: 2.4
     """
 
     name = 'Slash'
     aliases = ['slash']
     filenames = ['*.sla']
+    url = 'https://github.com/arturadib/Slash-A'
+    version_added = '2.4'
 
     def __init__(self, **options):
         from pygments.lexers.web import HtmlLexer

data/vendor/pygments-main/pygments/lexers/smalltalk.py

@@ -4,7 +4,7 @@
 
     Lexers for Smalltalk and related languages.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,14 +20,13 @@ class SmalltalkLexer(RegexLexer):
     For Smalltalk syntax.
     Contributed by Stefan Matthias Aust.
     Rewritten by Nils Winter.
-
-    .. versionadded:: 0.10
     """
     name = 'Smalltalk'
     url = 'http://www.smalltalk.org/'
     filenames = ['*.st']
     aliases = ['smalltalk', 'squeak', 'st']
     mimetypes = ['text/x-smalltalk']
+    version_added = '0.10'
 
     tokens = {
         'root': [
@@ -140,14 +139,13 @@ class SmalltalkLexer(RegexLexer):
 class NewspeakLexer(RegexLexer):
     """
     For Newspeak syntax.
-
-    .. versionadded:: 1.1
     """
     name = 'Newspeak'
     url = 'http://newspeaklanguage.org/'
     filenames = ['*.ns2']
     aliases = ['newspeak', ]
     mimetypes = ['text/x-newspeak']
+    version_added = '1.1'
 
     tokens = {
         'root': [