pygments.rb 2.3.1 → 2.4.0

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

@@ -4,12 +4,12 @@
 
     Lexers for hexadecimal dumps.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 from pygments.lexer import RegexLexer, bygroups, include
-from pygments.token import Text, Name, Number, String, Punctuation
+from pygments.token import Name, Number, String, Punctuation, Whitespace
 
 __all__ = ['HexdumpLexer']
 
@@ -43,22 +43,22 @@ class HexdumpLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('offset'),
             (r'('+hd+r'{2})(\-)('+hd+r'{2})',
              bygroups(Number.Hex, Punctuation, Number.Hex)),
             (hd+r'{2}', Number.Hex),
             (r'(\s{2,3})(\>)(.{16})(\<)$',
-             bygroups(Text, Punctuation, String, Punctuation), 'bracket-strings'),
+             bygroups(Whitespace, Punctuation, String, Punctuation), 'bracket-strings'),
             (r'(\s{2,3})(\|)(.{16})(\|)$',
-             bygroups(Text, Punctuation, String, Punctuation), 'piped-strings'),
+             bygroups(Whitespace, Punctuation, String, Punctuation), 'piped-strings'),
             (r'(\s{2,3})(\>)(.{1,15})(\<)$',
-             bygroups(Text, Punctuation, String, Punctuation)),
+             bygroups(Whitespace, Punctuation, String, Punctuation)),
             (r'(\s{2,3})(\|)(.{1,15})(\|)$',
-             bygroups(Text, Punctuation, String, Punctuation)),
-            (r'(\s{2,3})(.{1,15})$', bygroups(Text, String)),
-            (r'(\s{2,3})(.{16}|.{20})$', bygroups(Text, String), 'nonpiped-strings'),
-            (r'\s', Text),
+             bygroups(Whitespace, Punctuation, String, Punctuation)),
+            (r'(\s{2,3})(.{1,15})$', bygroups(Whitespace, String)),
+            (r'(\s{2,3})(.{16}|.{20})$', bygroups(Whitespace, String), 'nonpiped-strings'),
+            (r'\s', Whitespace),
             (r'^\*', Punctuation),
         ],
         'offset': [
@@ -66,37 +66,37 @@ class HexdumpLexer(RegexLexer):
             (r'^'+hd+'+', Name.Label),
         ],
         'offset-mode': [
-            (r'\s', Text, '#pop'),
+            (r'\s', Whitespace, '#pop'),
             (hd+'+', Name.Label),
             (r':', Punctuation)
         ],
         'piped-strings': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('offset'),
             (hd+r'{2}', Number.Hex),
             (r'(\s{2,3})(\|)(.{1,16})(\|)$',
-             bygroups(Text, Punctuation, String, Punctuation)),
-            (r'\s', Text),
+             bygroups(Whitespace, Punctuation, String, Punctuation)),
+            (r'\s', Whitespace),
             (r'^\*', Punctuation),
         ],
         'bracket-strings': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('offset'),
             (hd+r'{2}', Number.Hex),
             (r'(\s{2,3})(\>)(.{1,16})(\<)$',
-             bygroups(Text, Punctuation, String, Punctuation)),
-            (r'\s', Text),
+             bygroups(Whitespace, Punctuation, String, Punctuation)),
+            (r'\s', Whitespace),
             (r'^\*', Punctuation),
         ],
         'nonpiped-strings': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('offset'),
             (r'('+hd+r'{2})(\-)('+hd+r'{2})',
              bygroups(Number.Hex, Punctuation, Number.Hex)),
             (hd+r'{2}', Number.Hex),
-            (r'(\s{19,})(.{1,20}?)$', bygroups(Text, String)),
-            (r'(\s{2,3})(.{1,20})$', bygroups(Text, String)),
-            (r'\s', Text),
+            (r'(\s{19,})(.{1,20}?)$', bygroups(Whitespace, String)),
+            (r'(\s{2,3})(.{1,20})$', bygroups(Whitespace, String)),
+            (r'\s', Whitespace),
             (r'^\*', Punctuation),
         ],
     }

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

@@ -4,7 +4,7 @@
 
     Lexers for HTML, XML and related markup.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -13,7 +13,7 @@ import re
 from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, bygroups, \
     default, using
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Punctuation
+    Punctuation, Whitespace
 from pygments.util import looks_like_xml, html_doctype_matches
 
 from pygments.lexers.javascript import JavascriptLexer
@@ -32,6 +32,7 @@ class HtmlLexer(RegexLexer):
     """
 
     name = 'HTML'
+    url = 'https://html.spec.whatwg.org/'
     aliases = ['html']
     filenames = ['*.html', '*.htm', '*.xhtml', '*.xslt']
     mimetypes = ['text/html', 'application/xhtml+xml']
@@ -42,7 +43,7 @@ class HtmlLexer(RegexLexer):
             ('[^<&]+', Text),
             (r'&\S*?;', Name.Entity),
             (r'\<\!\[CDATA\[.*?\]\]\>', Comment.Preproc),
-            ('<!--', Comment, 'comment'),
+            (r'<!--.*?-->', Comment.Multiline),
             (r'<\?.*?\?>', Comment.Preproc),
             ('<![^>]*>', Comment.Preproc),
             (r'(<)(\s*)(script)(\s*)',
@@ -59,11 +60,6 @@ class HtmlLexer(RegexLexer):
              bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text,
                       Punctuation)),
         ],
-        'comment': [
-            ('[^-]+', Comment),
-            ('-->', Comment, '#pop'),
-            ('-', Comment),
-        ],
         'tag': [
             (r'\s+', Text),
             (r'([\w:-]+\s*)(=)(\s*)', bygroups(Name.Attribute, Operator, Text),
@@ -200,7 +196,7 @@ class XmlLexer(RegexLexer):
     Generic lexer for XML (eXtensible Markup Language).
     """
 
-    flags = re.MULTILINE | re.DOTALL | re.UNICODE
+    flags = re.MULTILINE | re.DOTALL
 
     name = 'XML'
     aliases = ['xml']
@@ -211,27 +207,23 @@ class XmlLexer(RegexLexer):
 
     tokens = {
         'root': [
-            ('[^<&]+', Text),
+            (r'[^<&\s]+', Text),
+            (r'[^<&\S]+', Whitespace),
             (r'&\S*?;', Name.Entity),
             (r'\<\!\[CDATA\[.*?\]\]\>', Comment.Preproc),
-            ('<!--', Comment, 'comment'),
+            (r'<!--.*?-->', Comment.Multiline),
             (r'<\?.*?\?>', Comment.Preproc),
             ('<![^>]*>', Comment.Preproc),
             (r'<\s*[\w:.-]+', Name.Tag, 'tag'),
             (r'<\s*/\s*[\w:.-]+\s*>', Name.Tag),
         ],
-        'comment': [
-            ('[^-]+', Comment),
-            ('-->', Comment, '#pop'),
-            ('-', Comment),
-        ],
         'tag': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[\w.:-]+\s*=', Name.Attribute, 'attr'),
             (r'/?\s*>', Name.Tag, '#pop'),
         ],
         'attr': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             ('".*?"', String, '#pop'),
             ("'.*?'", String, '#pop'),
             (r'[^\s>]+', String, '#pop'),
@@ -295,7 +287,7 @@ class HamlLexer(ExtendedRegexLexer):
     flags = re.IGNORECASE
     # Haml can include " |\n" anywhere,
     # which is ignored and used to wrap long lines.
-    # To accomodate this, use this custom faux dot instead.
+    # To accommodate this, use this custom faux dot instead.
     _dot = r'(?: \|\n(?=.* \|)|.)'
 
     # In certain places, a comma at the end of the line

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

@@ -4,14 +4,15 @@
 
     Lexers for IDL.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
-from pygments.lexer import RegexLexer, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, Number, String
+from pygments.lexer import RegexLexer, words, bygroups
+from pygments.token import Text, Comment, Operator, Keyword, Name, Number, \
+    String, Whitespace
 
 __all__ = ['IDLLexer']
 
@@ -23,6 +24,7 @@ class IDLLexer(RegexLexer):
     .. versionadded:: 1.6
     """
     name = 'IDL'
+    url = 'https://www.l3harrisgeospatial.com/Software-Technology/IDL'
     aliases = ['idl']
     filenames = ['*.pro']
     mimetypes = ['text/idl']
@@ -248,7 +250,8 @@ class IDLLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'^\s*;.*?\n', Comment.Single),
+            (r'(^\s*)(;.*?)(\n)', bygroups(Whitespace, Comment.Single,
+                Whitespace)),
             (words(_RESERVED, prefix=r'\b', suffix=r'\b'), Keyword),
             (words(_BUILTIN_LIB, prefix=r'\b', suffix=r'\b'), Name.Builtin),
             (r'\+=|-=|\^=|\*=|/=|#=|##=|<=|>=|=', Operator),
@@ -264,6 +267,8 @@ class IDLLexer(RegexLexer):
             (r'\b[+\-]?[0-9]+U?L{1,2}\b', Number.Integer.Long),
             (r'\b[+\-]?[0-9]+U?S?\b', Number.Integer),
             (r'\b[+\-]?[0-9]+B\b', Number),
+            (r'[ \t]+', Whitespace),
+            (r'\n', Whitespace),
             (r'.', Text),
         ]
     }
@@ -277,4 +282,4 @@ class IDLLexer(RegexLexer):
         if 'endswitch' in text:
             result += 0.01
 
-        return result
+        return result

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

@@ -4,14 +4,14 @@
 
     Lexers for Igor Pro.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
 from pygments.lexer import RegexLexer, words
-from pygments.token import Text, Comment, Keyword, Name, String
+from pygments.token import Text, Comment, Keyword, Name, String, Whitespace
 
 __all__ = ['IgorLexer']
 
@@ -413,6 +413,7 @@ class IgorLexer(RegexLexer):
             # Compiler directives.
             (r'^#(include|pragma|define|undef|ifdef|ifndef|if|elif|else|endif)',
              Name.Decorator),
+            (r'\s+', Whitespace),
             (r'[^a-z"/]+$', Text),
             (r'.', Text),
         ],

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

@@ -4,22 +4,22 @@
 
     Lexers for Inferno os and all the related stuff.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
 from pygments.lexer import RegexLexer, include, bygroups, default
-from pygments.token import Punctuation, Text, Comment, Operator, Keyword, \
-    Name, String, Number
+from pygments.token import Punctuation, Comment, Operator, Keyword, \
+    Name, String, Number, Whitespace
 
 __all__ = ['LimboLexer']
 
 
 class LimboLexer(RegexLexer):
     """
-    Lexer for `Limbo programming language <http://www.vitanuova.com/inferno/limbo.html>`_
+    Lexer for Limbo programming language
 
     TODO:
         - maybe implement better var declaration highlighting
@@ -28,16 +28,17 @@ class LimboLexer(RegexLexer):
     .. versionadded:: 2.0
     """
     name = 'Limbo'
+    url = 'http://www.vitanuova.com/inferno/limbo.html'
     aliases = ['limbo']
     filenames = ['*.b']
     mimetypes = ['text/limbo']
 
     tokens = {
         'whitespace': [
-            (r'^(\s*)([a-zA-Z_]\w*:(\s*)\n)',
-             bygroups(Text, Name.Label)),
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'^(\s*)([a-zA-Z_]\w*:)(\s*\n)',
+             bygroups(Whitespace, Name.Label, Whitespace)),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
             (r'#(\n|(.|\n)*?[^\\]\n)', Comment.Single),
         ],
         'string': [

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

@@ -4,7 +4,7 @@
 
     Lexers for installer/packager DSLs and formats.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,11 +20,12 @@ __all__ = ['NSISLexer', 'RPMSpecLexer', 'SourcesListLexer',
 
 class NSISLexer(RegexLexer):
     """
-    For `NSIS <http://nsis.sourceforge.net/>`_ scripts.
+    For NSIS scripts.
 
     .. versionadded:: 1.6
     """
     name = 'NSIS'
+    url = 'http://nsis.sourceforge.net/'
     aliases = ['nsis', 'nsi', 'nsh']
     filenames = ['*.nsi', '*.nsh']
     mimetypes = ['text/x-nsis']
@@ -33,7 +34,7 @@ class NSISLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'[;#].*\n', Comment),
+            (r'([;#].*)(\n)', bygroups(Comment, Whitespace)),
             (r"'.*?'", String.Single),
             (r'"', String.Double, 'str_double'),
             (r'`', String.Backtick, 'str_backtick'),
@@ -42,11 +43,12 @@ class NSISLexer(RegexLexer):
             include('basic'),
             (r'\$\{[a-z_|][\w|]*\}', Keyword.Pseudo),
             (r'/[a-z_]\w*', Name.Attribute),
-            ('.', Text),
+            (r'\s+', Whitespace),
+            (r'[\w.]+', Text),
         ],
         'basic': [
             (r'(\n)(Function)(\s+)([._a-z][.\w]*)\b',
-             bygroups(Text, Keyword, Text, Name.Function)),
+             bygroups(Whitespace, Keyword, Whitespace, Name.Function)),
             (r'\b([_a-z]\w*)(::)([a-z][a-z0-9]*)\b',
              bygroups(Keyword.Namespace, Punctuation, Name.Function)),
             (r'\b([_a-z]\w*)(:)', bygroups(Name.Label, Punctuation)),
@@ -128,16 +130,16 @@ class NSISLexer(RegexLexer):
             (r'\$[a-z_]\w*', Name.Variable),
         ],
         'str_double': [
-            (r'"', String, '#pop'),
+            (r'"', String.Double, '#pop'),
             (r'\$(\\[nrt"]|\$)', String.Escape),
             include('interpol'),
-            (r'.', String.Double),
+            (r'[^"]+', String.Double),
         ],
         'str_backtick': [
-            (r'`', String, '#pop'),
+            (r'`', String.Double, '#pop'),
             (r'\$(\\[nrt"]|\$)', String.Escape),
             include('interpol'),
-            (r'.', String.Double),
+            (r'[^`]+', String.Double),
         ],
     }
 
@@ -159,20 +161,20 @@ class RPMSpecLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'#.*\n', Comment),
+            (r'#.*$', Comment),
             include('basic'),
         ],
         'description': [
             (r'^(%' + _directives + ')(.*)$',
              bygroups(Name.Decorator, Text), '#pop'),
-            (r'\n', Text),
+            (r'\s+', Whitespace),
             (r'.', Text),
         ],
         'changelog': [
-            (r'\*.*\n', Generic.Subheading),
+            (r'\*.*$', Generic.Subheading),
             (r'^(%' + _directives + ')(.*)$',
              bygroups(Name.Decorator, Text), '#pop'),
-            (r'\n', Text),
+            (r'\s+', Whitespace),
             (r'.', Text),
         ],
         'string': [
@@ -197,10 +199,11 @@ class RPMSpecLexer(RegexLexer):
             include('interpol'),
             (r"'.*?'", String.Single),
             (r'"', String.Double, 'string'),
+            (r'\s+', Whitespace),
             (r'.', Text),
         ],
         'macro': [
-            (r'%define.*\n', Comment.Preproc),
+            (r'%define.*$', Comment.Preproc),
             (r'%\{\!\?.*%define.*\}', Comment.Preproc),
             (r'(%(?:if(?:n?arch)?|else(?:if)?|endif))(.*)$',
              bygroups(Comment.Preproc, Text)),
@@ -229,10 +232,10 @@ class SourcesListLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'#.*?$', Comment),
             (r'^(deb(?:-src)?)(\s+)',
-             bygroups(Keyword, Text), 'distribution')
+             bygroups(Keyword, Whitespace), 'distribution')
         ],
         'distribution': [
             (r'#.*?$', Comment, '#pop'),
@@ -240,7 +243,7 @@ class SourcesListLexer(RegexLexer):
             (r'[^\s$[]+', String),
             (r'\[', String.Other, 'escaped-distribution'),
             (r'\$', String),
-            (r'\s+', Text, 'components')
+            (r'\s+', Whitespace, 'components')
         ],
         'escaped-distribution': [
             (r'\]', String.Other, '#pop'),
@@ -251,7 +254,7 @@ class SourcesListLexer(RegexLexer):
         'components': [
             (r'#.*?$', Comment, '#pop:2'),
             (r'$', Text, '#pop:2'),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\S+', Keyword.Pseudo),
         ]
     }
@@ -270,14 +273,19 @@ class DebianControlLexer(RegexLexer):
     .. versionadded:: 0.9
     """
     name = 'Debian Control file'
+    url = 'https://www.debian.org/doc/debian-policy/ch-controlfields.html'
     aliases = ['debcontrol', 'control']
     filenames = ['control']
 
     tokens = {
         'root': [
             (r'^(Description)', Keyword, 'description'),
-            (r'^(Maintainer)(:\s*)', bygroups(Keyword, Text), 'maintainer'),
-            (r'^((Build-)?Depends)', Keyword, 'depends'),
+            (r'^(Maintainer|Uploaders)(:\s*)', bygroups(Keyword, Text),
+             'maintainer'),
+            (r'^((?:Build-|Pre-)?Depends(?:-Indep|-Arch)?)(:\s*)',
+             bygroups(Keyword, Text), 'depends'),
+            (r'^(Recommends|Suggests|Enhances)(:\s*)', bygroups(Keyword, Text),
+             'depends'),
             (r'^((?:Python-)?Version)(:\s*)(\S+)$',
              bygroups(Keyword, Text, Number)),
             (r'^((?:Installed-)?Size)(:\s*)(\S+)$',
@@ -288,10 +296,11 @@ class DebianControlLexer(RegexLexer):
              bygroups(Keyword, Whitespace, String)),
         ],
         'maintainer': [
-            (r'<[^>]+>', Generic.Strong),
             (r'<[^>]+>$', Generic.Strong, '#pop'),
+            (r'<[^>]+>', Generic.Strong),
             (r',\n?', Text),
-            (r'.', Text),
+            (r'[^,<]+$', Text, '#pop'),
+            (r'[^,<]+', Text),
         ],
         'description': [
             (r'(.*)(Homepage)(: )(\S+)',
@@ -301,21 +310,18 @@ class DebianControlLexer(RegexLexer):
             default('#pop'),
         ],
         'depends': [
-            (r':\s*', Text),
-            (r'(\$)(\{)(\w+\s*:\s*\w+)', bygroups(Operator, Text, Name.Entity)),
+            (r'(\$)(\{)(\w+\s*:\s*\w+)(\})',
+             bygroups(Operator, Text, Name.Entity, Text)),
             (r'\(', Text, 'depend_vers'),
-            (r',', Text),
             (r'\|', Operator),
-            (r'[\s]+', Text),
-            (r'[})]\s*$', Text, '#pop'),
-            (r'\}', Text),
-            (r'[^,]$', Name.Function, '#pop'),
-            (r'([+.a-zA-Z0-9-])(\s*)', bygroups(Name.Function, Text)),
+            (r',\n', Text),
+            (r'\n', Text, '#pop'),
+            (r'[,\s]', Text),
+            (r'[+.a-zA-Z0-9-]+', Name.Function),
             (r'\[.*?\]', Name.Entity),
         ],
         'depend_vers': [
-            (r'\),', Text, '#pop'),
-            (r'\)[^,]', Text, '#pop:2'),
-            (r'([><=]+)(\s*)([^)]+)', bygroups(Operator, Text, Number))
+            (r'\)', Text, '#pop'),
+            (r'([><=]+)(\s*)([^)]+)', bygroups(Operator, Text, Number)),
         ]
     }