pygments.rb 2.4.1 → 4.0.0

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

@@ -0,0 +1,176 @@
+"""
+    pygments.lexers.graphql
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for GraphQL, an open-source data query and manipulation
+    language for APIs.
+
+    More information:
+    https://graphql.org/
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words, include, bygroups, default
+from pygments.token import (Comment, Keyword, Name, Number, Punctuation, String,
+                            Whitespace)
+
+
+__all__ = ["GraphQLLexer"]
+
+OPERATION_TYPES = ("query", "mutation", "subscription")
+BUILTIN_TYPES = ("Int", "Float", "String", "Boolean", "ID")
+BOOLEAN_VALUES = ("true", "false", "null")
+KEYWORDS = (
+    "type",
+    "schema",
+    "extend",
+    "enum",
+    "scalar",
+    "implements",
+    "interface",
+    "union",
+    "input",
+    "directive",
+    "QUERY",
+    "MUTATION",
+    "SUBSCRIPTION",
+    "FIELD",
+    "FRAGMENT_DEFINITION",
+    "FRAGMENT_SPREAD",
+    "INLINE_FRAGMENT",
+    "SCHEMA",
+    "SCALAR",
+    "OBJECT",
+    "FIELD_DEFINITION",
+    "ARGUMENT_DEFINITION",
+    "INTERFACE",
+    "UNION",
+    "ENUM",
+    "ENUM_VALUE",
+    "INPUT_OBJECT",
+    "INPUT_FIELD_DEFINITION",
+)
+
+
+class GraphQLLexer(RegexLexer):
+    """
+    Lexer for GraphQL syntax
+    """
+    name = "GraphQL"
+    aliases = ["graphql"]
+    filenames = ["*.graphql"]
+    url = "https://graphql.org"
+    version_added = '2.16'
+
+    tokens = {
+        "ignored_tokens": [
+            (r"\s+", Whitespace),  # Whitespaces
+            (r"#.*$", Comment),
+            (",", Punctuation),  # Insignificant commas
+        ],
+        "value": [
+            include("ignored_tokens"),
+            (r"-?\d+(?![.eE])", Number.Integer, "#pop"),
+            (
+                r"-?\d+(\.\d+)?([eE][+-]?\d+)?",
+                Number.Float,
+                "#pop",
+            ),
+            (r'"', String, ("#pop", "string")),
+            (words(BOOLEAN_VALUES, suffix=r"\b"), Name.Builtin, "#pop"),
+            (r"\$[a-zA-Z_]\w*", Name.Variable, "#pop"),
+            (r"[a-zA-Z_]\w*", Name.Constant, "#pop"),
+            (r"\[", Punctuation, ("#pop", "list_value")),
+            (r"\{", Punctuation, ("#pop", "object_value")),
+        ],
+        "list_value": [
+            include("ignored_tokens"),
+            ("]", Punctuation, "#pop"),
+            default("value"),
+        ],
+        "object_value": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name),
+            (r":", Punctuation, "value"),
+            (r"\}", Punctuation, "#pop"),
+        ],
+        "string": [
+            (r'\\(["\\/bfnrt]|u[a-fA-F0-9]{4})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'"', String, "#pop"),
+        ],
+        "root": [
+            include("ignored_tokens"),
+            (words(OPERATION_TYPES, suffix=r"\b"), Keyword, "operation"),
+            (words(KEYWORDS, suffix=r"\b"), Keyword),
+            (r"\{", Punctuation, "selection_set"),
+            (r"fragment\b", Keyword, "fragment_definition"),
+        ],
+        "operation": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name.Function),
+            (r"\(", Punctuation, "variable_definition"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+        "variable_definition": [
+            include("ignored_tokens"),
+            (r"\$[a-zA-Z_]\w*", Name.Variable),
+            (r"[\]!]", Punctuation),
+            (r":", Punctuation, "type"),
+            (r"=", Punctuation, "value"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        "type": [
+            include("ignored_tokens"),
+            (r"\[", Punctuation),
+            (words(BUILTIN_TYPES, suffix=r"\b"), Name.Builtin, "#pop"),
+            (r"[a-zA-Z_]\w*", Name.Class, "#pop"),
+        ],
+        "selection_set": [
+            include("ignored_tokens"),
+            (r"([a-zA-Z_]\w*)(\s*)(:)", bygroups(Name.Label, Whitespace, Punctuation)),
+            (r"[a-zA-Z_]\w*", Name),  # Field
+            (
+                r"(\.\.\.)(\s+)(on)\b",
+                bygroups(Punctuation, Whitespace, Keyword),
+                "inline_fragment",
+            ),
+            (r"\.\.\.", Punctuation, "fragment_spread"),
+            (r"\(", Punctuation, "arguments"),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, "selection_set"),
+            (r"\}", Punctuation, "#pop"),
+        ],
+        "directive": [
+            include("ignored_tokens"),
+            (r"\(", Punctuation, ("#pop", "arguments")),
+        ],
+        "arguments": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name),
+            (r":", Punctuation, "value"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        # Fragments
+        "fragment_definition": [
+            include("ignored_tokens"),
+            (r"[\]!]", Punctuation),  # For NamedType
+            (r"on\b", Keyword, "type"),
+            (r"[a-zA-Z_]\w*", Name.Function),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+        "fragment_spread": [
+            include("ignored_tokens"),
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"[a-zA-Z_]\w*", Name, "#pop"),  # Fragment name
+        ],
+        "inline_fragment": [
+            include("ignored_tokens"),
+            (r"[a-zA-Z_]\w*", Name.Class),  # Type condition
+            (r"@[a-zA-Z_]\w*", Name.Decorator, "directive"),
+            (r"\{", Punctuation, ("#pop", "selection_set")),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexer for the DOT language (graphviz).
 
-    :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.
 """
 
@@ -19,14 +19,13 @@ __all__ = ['GraphvizLexer']
 class GraphvizLexer(RegexLexer):
     """
     For graphviz DOT graph description language.
-
-    .. versionadded:: 2.8
     """
     name = 'Graphviz'
     url = 'https://www.graphviz.org/doc/info/lang.html'
     aliases = ['graphviz', 'dot']
     filenames = ['*.gv', '*.dot']
     mimetypes = ['text/x-graphviz', 'text/vnd.graphviz']
+    version_added = '2.8'
     tokens = {
         'root': [
             (r'\s+', Whitespace),

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

@@ -4,7 +4,7 @@
 
     Lexers for TigerGraph GSQL graph query 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.
 """
 
@@ -21,14 +21,13 @@ class GSQLLexer(RegexLexer):
 
     """
     For GSQL queries (version 3.x).
-
-    .. versionadded:: 2.10
     """
 
     name = 'GSQL'
     url = 'https://docs.tigergraph.com/dev/gsql-ref'
     aliases = ['gsql']
     filenames = ['*.gsql']
+    version_added = '2.10'
 
     flags = re.MULTILINE | re.IGNORECASE
 

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

@@ -0,0 +1,73 @@
+"""
+    pygments.lexers.hare
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Hare language.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['HareLexer']
+
+class HareLexer(RegexLexer):
+    """
+    Lexer for the Hare programming language.
+    """
+    name = 'Hare'
+    url = 'https://harelang.org/'
+    aliases = ['hare']
+    filenames = ['*.ha']
+    mimetypes = ['text/x-hare']
+    version_added = '2.19'
+
+    _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
+    _ws1 = r'\s*(?:/[*].*?[*]/\s*)?'
+
+    tokens = {
+        'whitespace': [
+            (r'^use.*;', Comment.Preproc),
+            (r'@[a-z]+', Comment.Preproc),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'//.*?$', Comment.Single),
+        ],
+        'statements': [
+            (r'"', String, 'string'),
+            (r'`[^`]*`', String),
+            (r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
+            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
+            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
+            (r'0o[0-7]+[LlUu]*', Number.Oct),
+            (r'\d+[zui]?(\d+)?', Number.Integer),
+            (r'[~!%^&*+=|?:<>/-]', Operator),
+            (words(('as', 'is', '=>', '..', '...')), Operator),
+            (r'[()\[\],.{};]+', Punctuation),
+            (words(('abort', 'align', 'alloc', 'append', 'assert', 'case',
+                'const', 'def', 'defer', 'delete', 'else', 'enum', 'export',
+                'fn', 'for', 'free', 'if', 'let', 'len', 'match', 'offset',
+                'return', 'static', 'struct', 'switch', 'type', 'union',
+                'yield', 'vastart', 'vaarg', 'vaend'),
+                suffix=r'\b'), Keyword),
+            (r'(bool|int|uint|uintptr|u8|u16|u32|u64|i8|i16|i32|i64|f32|f64|null|done|never|void|nullable|rune|size|valist)\b',
+             Keyword.Type),
+            (r'(true|false|null)\b', Name.Builtin),
+            (r'[a-zA-Z_]\w*', Name),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|'
+             r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\', String),  # stray backslash
+        ],
+        'root': [
+            include('whitespace'),
+            include('statements'),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexers for Haskell 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.
 """
 
@@ -24,14 +24,13 @@ __all__ = ['HaskellLexer', 'HspecLexer', 'IdrisLexer', 'AgdaLexer', 'CryptolLexe
 class HaskellLexer(RegexLexer):
     """
     A Haskell lexer based on the lexemes defined in the Haskell 98 Report.
-
-    .. versionadded:: 0.8
     """
     name = 'Haskell'
     url = 'https://www.haskell.org/'
     aliases = ['haskell', 'hs']
     filenames = ['*.hs']
     mimetypes = ['text/x-haskell']
+    version_added = '0.8'
 
     reserved = ('case', 'class', 'data', 'default', 'deriving', 'do', 'else',
                 'family', 'if', 'in', 'infix[lr]?', 'instance',
@@ -53,7 +52,7 @@ class HaskellLexer(RegexLexer):
             (r'\bimport\b', Keyword.Reserved, 'import'),
             (r'\bmodule\b', Keyword.Reserved, 'module'),
             (r'\berror\b', Name.Exception),
-            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'\b({})(?!\')\b'.format('|'.join(reserved)), Keyword.Reserved),
             (r"'[^\\]'", String.Char),  # this has to come before the TH quote
             (r'^[_' + uni.Ll + r'][\w\']*', Name.Function),
             (r"'?[_" + uni.Ll + r"][\w']*", Name),
@@ -157,14 +156,13 @@ class HaskellLexer(RegexLexer):
 class HspecLexer(HaskellLexer):
     """
     A Haskell lexer with support for Hspec constructs.
-
-    .. versionadded:: 2.4.0
     """
 
     name = 'Hspec'
     aliases = ['hspec']
     filenames = ['*Spec.hs']
     mimetypes = []
+    version_added = '2.4'
 
     tokens = {
         'root': [
@@ -181,14 +179,13 @@ class IdrisLexer(RegexLexer):
     A lexer for the dependently typed programming language Idris.
 
     Based on the Haskell and Agda Lexer.
-
-    .. versionadded:: 2.0
     """
     name = 'Idris'
     url = 'https://www.idris-lang.org/'
     aliases = ['idris', 'idr']
     filenames = ['*.idr']
     mimetypes = ['text/x-idris']
+    version_added = '2.0'
 
     reserved = ('case', 'class', 'data', 'default', 'using', 'do', 'else',
                 'if', 'in', 'infix[lr]?', 'instance', 'rewrite', 'auto',
@@ -211,7 +208,7 @@ class IdrisLexer(RegexLexer):
     tokens = {
         'root': [
             # Comments
-            (r'^(\s*)(%%(%s))' % '|'.join(directives),
+            (r'^(\s*)(%({}))'.format('|'.join(directives)),
              bygroups(Whitespace, Keyword.Reserved)),
             (r'(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$', bygroups(Whitespace, Comment.Single)),
             (r'(\s*)(\|{3}.*?)$', bygroups(Whitespace, Comment.Single)),
@@ -220,7 +217,7 @@ class IdrisLexer(RegexLexer):
             (r'^(\s*)([^\s(){}]+)(\s*)(:)(\s*)',
              bygroups(Whitespace, Name.Function, Whitespace, Operator.Word, Whitespace)),
             #  Identifiers
-            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'\b({})(?!\')\b'.format('|'.join(reserved)), Keyword.Reserved),
             (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace), 'module'),
             (r"('')?[A-Z][\w\']*", Keyword.Type),
             (r'[a-z][\w\']*', Text),
@@ -292,8 +289,6 @@ class AgdaLexer(RegexLexer):
     """
     For the Agda dependently typed functional programming language and
     proof assistant.
-
-    .. versionadded:: 2.0
     """
 
     name = 'Agda'
@@ -301,14 +296,15 @@ class AgdaLexer(RegexLexer):
     aliases = ['agda']
     filenames = ['*.agda']
     mimetypes = ['text/x-agda']
+    version_added = '2.0'
 
     reserved = (
         'abstract', 'codata', 'coinductive', 'constructor', 'data', 'do',
         'eta-equality', 'field', 'forall', 'hiding', 'in', 'inductive', 'infix',
         'infixl', 'infixr', 'instance', 'interleaved', 'let', 'macro', 'mutual',
-        'no-eta-equality', 'open', 'overlap', 'pattern', 'postulate', 'primitive',
+        'no-eta-equality', 'opaque', 'open', 'overlap', 'pattern', 'postulate', 'primitive',
         'private', 'quote', 'quoteTerm', 'record', 'renaming', 'rewrite',
-        'syntax', 'tactic', 'unquote', 'unquoteDecl', 'unquoteDef', 'using',
+        'syntax', 'tactic', 'unfolding', 'unquote', 'unquoteDecl', 'unquoteDef', 'using',
         'variable', 'where', 'with',
     )
 
@@ -325,7 +321,7 @@ class AgdaLexer(RegexLexer):
             (r'\{!', Comment.Directive, 'hole'),
             # Lexemes:
             #  Identifiers
-            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'\b({})(?!\')\b'.format('|'.join(reserved)), Keyword.Reserved),
             (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Whitespace),
              'module'),
             (r'\b(Set|Prop)[\u2080-\u2089]*\b', Keyword.Type),
@@ -365,13 +361,13 @@ class AgdaLexer(RegexLexer):
 class CryptolLexer(RegexLexer):
     """
     FIXME: A Cryptol2 lexer based on the lexemes defined in the Haskell 98 Report.
-
-    .. versionadded:: 2.0
     """
     name = 'Cryptol'
     aliases = ['cryptol', 'cry']
     filenames = ['*.cry']
     mimetypes = ['text/x-cryptol']
+    url = 'https://www.cryptol.net'
+    version_added = '2.0'
 
     reserved = ('Arith', 'Bit', 'Cmp', 'False', 'Inf', 'True', 'else',
                 'export', 'extern', 'fin', 'if', 'import', 'inf', 'lg2',
@@ -394,7 +390,7 @@ class CryptolLexer(RegexLexer):
             (r'\bimport\b', Keyword.Reserved, 'import'),
             (r'\bmodule\b', Keyword.Reserved, 'module'),
             (r'\berror\b', Name.Exception),
-            (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'\b({})(?!\')\b'.format('|'.join(reserved)), Keyword.Reserved),
             (r'^[_a-z][\w\']*', Name.Function),
             (r"'?[_a-z][\w']*", Name),
             (r"('')?[A-Z][\w\']*", Keyword.Type),
@@ -573,13 +569,13 @@ class LiterateHaskellLexer(LiterateLexer):
         If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
-
-    .. versionadded:: 0.9
     """
     name = 'Literate Haskell'
     aliases = ['literate-haskell', 'lhaskell', 'lhs']
     filenames = ['*.lhs']
     mimetypes = ['text/x-literate-haskell']
+    url = 'https://wiki.haskell.org/Literate_programming'
+    version_added = '0.9'
 
     def __init__(self, **options):
         hslexer = HaskellLexer(**options)
@@ -596,13 +592,13 @@ class LiterateIdrisLexer(LiterateLexer):
         If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
-
-    .. versionadded:: 2.0
     """
     name = 'Literate Idris'
     aliases = ['literate-idris', 'lidris', 'lidr']
     filenames = ['*.lidr']
     mimetypes = ['text/x-literate-idris']
+    url = 'https://idris2.readthedocs.io/en/latest/reference/literate.html'
+    version_added = '2.0'
 
     def __init__(self, **options):
         hslexer = IdrisLexer(**options)
@@ -619,13 +615,13 @@ class LiterateAgdaLexer(LiterateLexer):
         If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
-
-    .. versionadded:: 2.0
     """
     name = 'Literate Agda'
     aliases = ['literate-agda', 'lagda']
     filenames = ['*.lagda']
     mimetypes = ['text/x-literate-agda']
+    url = 'https://agda.readthedocs.io/en/latest/tools/literate-programming.html'
+    version_added = '2.0'
 
     def __init__(self, **options):
         agdalexer = AgdaLexer(**options)
@@ -642,13 +638,13 @@ class LiterateCryptolLexer(LiterateLexer):
         If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
         is autodetected: if the first non-whitespace character in the source
         is a backslash or percent character, LaTeX is assumed, else Bird.
-
-    .. versionadded:: 2.0
     """
     name = 'Literate Cryptol'
     aliases = ['literate-cryptol', 'lcryptol', 'lcry']
     filenames = ['*.lcry']
     mimetypes = ['text/x-literate-cryptol']
+    url = 'https://www.cryptol.net'
+    version_added = '2.0'
 
     def __init__(self, **options):
         crylexer = CryptolLexer(**options)
@@ -658,8 +654,6 @@ class LiterateCryptolLexer(LiterateLexer):
 class KokaLexer(RegexLexer):
     """
     Lexer for the Koka language.
-
-    .. versionadded:: 1.6
     """
 
     name = 'Koka'
@@ -667,6 +661,7 @@ class KokaLexer(RegexLexer):
     aliases = ['koka']
     filenames = ['*.kk', '*.kki']
     mimetypes = ['text/x-koka']
+    version_added = '1.6'
 
     keywords = [
         'infix', 'infixr', 'infixl',
@@ -726,7 +721,7 @@ class KokaLexer(RegexLexer):
              'alias-type'),
             (r'(struct)(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
              'struct-type'),
-            ((r'(%s)' % '|'.join(typeStartKeywords)) +
+            ((r'({})'.format('|'.join(typeStartKeywords))) +
              r'(\s+)([a-z]\w*)?', bygroups(Keyword, Whitespace, tokenTypeDef),
              'type'),
 
@@ -748,9 +743,9 @@ class KokaLexer(RegexLexer):
              bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword, Whitespace, Name.Function)),
 
             # keywords
-            (r'(%s)' % '|'.join(typekeywords) + boundary, Keyword.Type),
-            (r'(%s)' % '|'.join(keywords) + boundary, Keyword),
-            (r'(%s)' % '|'.join(builtin) + boundary, Keyword.Pseudo),
+            (r'({})'.format('|'.join(typekeywords)) + boundary, Keyword.Type),
+            (r'({})'.format('|'.join(keywords)) + boundary, Keyword),
+            (r'({})'.format('|'.join(builtin)) + boundary, Keyword.Pseudo),
             (r'::?|:=|\->|[=.]' + sboundary, Keyword),
 
             # names
@@ -811,8 +806,8 @@ class KokaLexer(RegexLexer):
             include('whitespace'),
 
             # keywords
-            (r'(%s)' % '|'.join(typekeywords) + boundary, Keyword),
-            (r'(?=((%s)' % '|'.join(keywords) + boundary + '))',
+            (r'({})'.format('|'.join(typekeywords)) + boundary, Keyword),
+            (r'(?=(({})'.format('|'.join(keywords)) + boundary + '))',
              Keyword, '#pop'),  # need to match because names overlap...
 
             # kinds

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

@@ -4,7 +4,7 @@
 
     Lexers for Haxe and related stuff.
 
-    :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.
 """
 
@@ -21,8 +21,6 @@ __all__ = ['HaxeLexer', 'HxmlLexer']
 class HaxeLexer(ExtendedRegexLexer):
     """
     For Haxe source code.
-
-    .. versionadded:: 1.3
     """
 
     name = 'Haxe'
@@ -30,6 +28,7 @@ class HaxeLexer(ExtendedRegexLexer):
     aliases = ['haxe', 'hxsl', 'hx']
     filenames = ['*.hx', '*.hxsl']
     mimetypes = ['text/haxe', 'text/x-haxe', 'text/x-hx']
+    version_added = '1.3'
 
     # keywords extracted from lexer.mll in the haxe compiler source
     keyword = (r'(?:function|class|static|var|if|else|while|do|for|'
@@ -898,13 +897,12 @@ class HaxeLexer(ExtendedRegexLexer):
 class HxmlLexer(RegexLexer):
     """
     Lexer for haXe build files.
-
-    .. versionadded:: 1.6
     """
     name = 'Hxml'
     url = 'https://haxe.org/manual/compiler-usage-hxml.html'
     aliases = ['haxeml', 'hxml']
     filenames = ['*.hxml']
+    version_added = '1.6'
 
     tokens = {
         'root': [

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

@@ -4,7 +4,7 @@
 
     Lexers for hardware descriptor 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,13 +20,13 @@ __all__ = ['VerilogLexer', 'SystemVerilogLexer', 'VhdlLexer']
 class VerilogLexer(RegexLexer):
     """
     For verilog source code with preprocessor directives.
-
-    .. versionadded:: 1.4
     """
     name = 'verilog'
     aliases = ['verilog', 'v']
     filenames = ['*.v']
     mimetypes = ['text/x-verilog']
+    url = 'https://en.wikipedia.org/wiki/Verilog'
+    version_added = '1.4'
 
     #: optional Comment or Whitespace
     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
@@ -147,13 +147,13 @@ class SystemVerilogLexer(RegexLexer):
     """
     Extends verilog lexer to recognise all SystemVerilog keywords from IEEE
     1800-2009 standard.
-
-    .. versionadded:: 1.5
     """
     name = 'systemverilog'
     aliases = ['systemverilog', 'sv']
     filenames = ['*.sv', '*.svh']
     mimetypes = ['text/x-systemverilog']
+    url = 'https://en.wikipedia.org/wiki/SystemVerilog'
+    version_added = '1.5'
 
     #: optional Comment or Whitespace
     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
@@ -373,13 +373,13 @@ class SystemVerilogLexer(RegexLexer):
 class VhdlLexer(RegexLexer):
     """
     For VHDL source code.
-
-    .. versionadded:: 1.5
     """
     name = 'vhdl'
     aliases = ['vhdl']
     filenames = ['*.vhdl', '*.vhd']
     mimetypes = ['text/x-vhdl']
+    url = 'https://en.wikipedia.org/wiki/VHDL'
+    version_added = '1.5'
     flags = re.MULTILINE | re.IGNORECASE
 
     tokens = {
@@ -387,6 +387,7 @@ class VhdlLexer(RegexLexer):
             (r'\s+', Whitespace),
             (r'(\\)(\n)', bygroups(String.Escape, Whitespace)),  # line continuation
             (r'--.*?$', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r"'(U|X|0|1|Z|W|L|H|-)'", String.Char),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r"'[a-z_]\w*", Name.Attribute),

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

@@ -4,7 +4,7 @@
 
     Lexers for hexadecimal dumps.
 
-    :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.
 """
 
@@ -33,11 +33,11 @@ class HexdumpLexer(RegexLexer):
     * ``od -t x1z FILE``
     * ``xxd FILE``
     * ``DEBUG.EXE FILE.COM`` and entering ``d`` to the prompt.
-
-    .. versionadded:: 2.1
     """
     name = 'Hexdump'
     aliases = ['hexdump']
+    url = 'https://en.wikipedia.org/wiki/Hex_dump'
+    version_added = '2.1'
 
     hd = r'[0-9A-Ha-h]'