pygments.rb 2.4.1 → 4.0.0

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

@@ -4,7 +4,7 @@
 
     Lexers for BASIC like languages (other than VB.net).
 
-    :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.
 """
 
@@ -23,8 +23,6 @@ __all__ = ['BlitzBasicLexer', 'BlitzMaxLexer', 'MonkeyLexer', 'CbmBasicV2Lexer',
 class BlitzMaxLexer(RegexLexer):
     """
     For BlitzMax source code.
-
-    .. versionadded:: 1.4
     """
 
     name = 'BlitzMax'
@@ -32,14 +30,14 @@ class BlitzMaxLexer(RegexLexer):
     aliases = ['blitzmax', 'bmax']
     filenames = ['*.bmx']
     mimetypes = ['text/x-bmx']
+    version_added = '1.4'
 
     bmax_vopwords = r'\b(Shl|Shr|Sar|Mod)\b'
     bmax_sktypes = r'@{1,2}|[!#$%]'
     bmax_lktypes = r'\b(Int|Byte|Short|Float|Double|Long)\b'
     bmax_name = r'[a-z_]\w*'
-    bmax_var = (r'(%s)(?:(?:([ \t]*)(%s)|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)'
-                r'|([ \t]*)(:)([ \t]*)(?:%s|(%s)))(?:([ \t]*)(Ptr))?)') % \
-        (bmax_name, bmax_sktypes, bmax_lktypes, bmax_name)
+    bmax_var = (rf'({bmax_name})(?:(?:([ \t]*)({bmax_sktypes})|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)'
+                rf'|([ \t]*)(:)([ \t]*)(?:{bmax_lktypes}|({bmax_name})))(?:([ \t]*)(Ptr))?)')
     bmax_func = bmax_var + r'?((?:[ \t]|\.\.\n)*)([(])'
 
     flags = re.MULTILINE | re.IGNORECASE
@@ -60,16 +58,14 @@ class BlitzMaxLexer(RegexLexer):
             (r'\$[0-9a-f]+', Number.Hex),
             (r'\%[10]+', Number.Bin),
             # Other
-            (r'(?:(?:(:)?([ \t]*)(:?%s|([+\-*/&|~]))|Or|And|Not|[=<>^]))' %
-             (bmax_vopwords), Operator),
+            (rf'(?:(?:(:)?([ \t]*)(:?{bmax_vopwords}|([+\-*/&|~]))|Or|And|Not|[=<>^]))', Operator),
             (r'[(),.:\[\]]', Punctuation),
             (r'(?:#[\w \t]*)', Name.Label),
             (r'(?:\?[\w \t]*)', Comment.Preproc),
             # Identifiers
-            (r'\b(New)\b([ \t]?)([(]?)(%s)' % (bmax_name),
+            (rf'\b(New)\b([ \t]?)([(]?)({bmax_name})',
              bygroups(Keyword.Reserved, Whitespace, Punctuation, Name.Class)),
-            (r'\b(Import|Framework|Module)([ \t]+)(%s\.%s)' %
-             (bmax_name, bmax_name),
+            (rf'\b(Import|Framework|Module)([ \t]+)({bmax_name}\.{bmax_name})',
              bygroups(Keyword.Reserved, Whitespace, Keyword.Namespace)),
             (bmax_func, bygroups(Name.Function, Whitespace, Keyword.Type,
                                  Operator, Whitespace, Punctuation, Whitespace,
@@ -78,7 +74,7 @@ class BlitzMaxLexer(RegexLexer):
             (bmax_var, bygroups(Name.Variable, Whitespace, Keyword.Type, Operator,
                                 Whitespace, Punctuation, Whitespace, Keyword.Type,
                                 Name.Class, Whitespace, Keyword.Type)),
-            (r'\b(Type|Extends)([ \t]+)(%s)' % (bmax_name),
+            (rf'\b(Type|Extends)([ \t]+)({bmax_name})',
              bygroups(Keyword.Reserved, Whitespace, Name.Class)),
             # Keywords
             (r'\b(Ptr)\b', Keyword.Type),
@@ -102,7 +98,7 @@ class BlitzMaxLexer(RegexLexer):
                 'RestoreData'), prefix=r'\b', suffix=r'\b'),
              Keyword.Reserved),
             # Final resolve (for variable names and such)
-            (r'(%s)' % (bmax_name), Name.Variable),
+            (rf'({bmax_name})', Name.Variable),
         ],
         'string': [
             (r'""', String.Double),
@@ -115,8 +111,6 @@ class BlitzMaxLexer(RegexLexer):
 class BlitzBasicLexer(RegexLexer):
     """
     For BlitzBasic source code.
-
-    .. versionadded:: 2.0
     """
 
     name = 'BlitzBasic'
@@ -124,11 +118,11 @@ class BlitzBasicLexer(RegexLexer):
     aliases = ['blitzbasic', 'b3d', 'bplus']
     filenames = ['*.bb', '*.decls']
     mimetypes = ['text/x-bb']
+    version_added = '2.0'
 
     bb_sktypes = r'@{1,2}|[#$%]'
     bb_name = r'[a-z]\w*'
-    bb_var = (r'(%s)(?:([ \t]*)(%s)|([ \t]*)([.])([ \t]*)(?:(%s)))?') % \
-             (bb_name, bb_sktypes, bb_name)
+    bb_var = (rf'({bb_name})(?:([ \t]*)({bb_sktypes})|([ \t]*)([.])([ \t]*)(?:({bb_name})))?')
 
     flags = re.MULTILINE | re.IGNORECASE
     tokens = {
@@ -153,21 +147,21 @@ class BlitzBasicLexer(RegexLexer):
              Operator),
             (r'([+\-*/~=<>^])', Operator),
             (r'[(),:\[\]\\]', Punctuation),
-            (r'\.([ \t]*)(%s)' % bb_name, Name.Label),
+            (rf'\.([ \t]*)({bb_name})', Name.Label),
             # Identifiers
-            (r'\b(New)\b([ \t]+)(%s)' % (bb_name),
+            (rf'\b(New)\b([ \t]+)({bb_name})',
              bygroups(Keyword.Reserved, Whitespace, Name.Class)),
-            (r'\b(Gosub|Goto)\b([ \t]+)(%s)' % (bb_name),
+            (rf'\b(Gosub|Goto)\b([ \t]+)({bb_name})',
              bygroups(Keyword.Reserved, Whitespace, Name.Label)),
-            (r'\b(Object)\b([ \t]*)([.])([ \t]*)(%s)\b' % (bb_name),
+            (rf'\b(Object)\b([ \t]*)([.])([ \t]*)({bb_name})\b',
              bygroups(Operator, Whitespace, Punctuation, Whitespace, Name.Class)),
-            (r'\b%s\b([ \t]*)(\()' % bb_var,
+            (rf'\b{bb_var}\b([ \t]*)(\()',
              bygroups(Name.Function, Whitespace, Keyword.Type, Whitespace, Punctuation,
                       Whitespace, Name.Class, Whitespace, Punctuation)),
-            (r'\b(Function)\b([ \t]+)%s' % bb_var,
+            (rf'\b(Function)\b([ \t]+){bb_var}',
              bygroups(Keyword.Reserved, Whitespace, Name.Function, Whitespace, Keyword.Type,
                       Whitespace, Punctuation, Whitespace, Name.Class)),
-            (r'\b(Type)([ \t]+)(%s)' % (bb_name),
+            (rf'\b(Type)([ \t]+)({bb_name})',
              bygroups(Keyword.Reserved, Whitespace, Name.Class)),
             # Keywords
             (r'\b(Pi|True|False|Null)\b', Keyword.Constant),
@@ -194,17 +188,15 @@ class BlitzBasicLexer(RegexLexer):
 
 class MonkeyLexer(RegexLexer):
     """
-    For
-    `Monkey <https://en.wikipedia.org/wiki/Monkey_(programming_language)>`_
-    source code.
-
-    .. versionadded:: 1.6
+    For Monkey source code.
     """
 
     name = 'Monkey'
     aliases = ['monkey']
     filenames = ['*.monkey']
     mimetypes = ['text/x-monkey']
+    url = 'https://blitzresearch.itch.io/monkeyx'
+    version_added = '1.6'
 
     name_variable = r'[a-z_]\w*'
     name_function = r'[A-Z]\w*'
@@ -238,7 +230,7 @@ class MonkeyLexer(RegexLexer):
             (r'\$[0-9a-fA-Z]+', Number.Hex),
             (r'\%[10]+', Number.Bin),
             # Native data types
-            (r'\b%s\b' % keyword_type, Keyword.Type),
+            (rf'\b{keyword_type}\b', Keyword.Type),
             # Exception handling
             (r'(?i)\b(?:Try|Catch|Throw)\b', Keyword.Reserved),
             (r'Throwable', Name.Exception),
@@ -274,21 +266,21 @@ class MonkeyLexer(RegexLexer):
             (r'(?i)(?:Not|Mod|Shl|Shr|And|Or)', Operator.Word),
             (r'[(){}!#,.:]', Punctuation),
             # catch the rest
-            (r'%s\b' % name_constant, Name.Constant),
-            (r'%s\b' % name_function, Name.Function),
-            (r'%s\b' % name_variable, Name.Variable),
+            (rf'{name_constant}\b', Name.Constant),
+            (rf'{name_function}\b', Name.Function),
+            (rf'{name_variable}\b', Name.Variable),
         ],
         'funcname': [
-            (r'(?i)%s\b' % name_function, Name.Function),
+            (rf'(?i){name_function}\b', Name.Function),
             (r':', Punctuation, 'classname'),
             (r'\s+', Whitespace),
             (r'\(', Punctuation, 'variables'),
             (r'\)', Punctuation, '#pop')
         ],
         'classname': [
-            (r'%s\.' % name_module, Name.Namespace),
-            (r'%s\b' % keyword_type, Keyword.Type),
-            (r'%s\b' % name_class, Name.Class),
+            (rf'{name_module}\.', Name.Namespace),
+            (rf'{keyword_type}\b', Keyword.Type),
+            (rf'{name_class}\b', Name.Class),
             # array (of given size)
             (r'(\[)(\s*)(\d*)(\s*)(\])',
              bygroups(Punctuation, Whitespace, Number.Integer, Whitespace, Punctuation)),
@@ -300,9 +292,9 @@ class MonkeyLexer(RegexLexer):
             default('#pop')
         ],
         'variables': [
-            (r'%s\b' % name_constant, Name.Constant),
-            (r'%s\b' % name_variable, Name.Variable),
-            (r'%s' % keyword_type_special, Keyword.Type),
+            (rf'{name_constant}\b', Name.Constant),
+            (rf'{name_variable}\b', Name.Variable),
+            (rf'{keyword_type_special}', Keyword.Type),
             (r'\s+', Whitespace),
             (r':', Punctuation, 'classname'),
             (r',', Punctuation, '#push'),
@@ -325,12 +317,12 @@ class MonkeyLexer(RegexLexer):
 class CbmBasicV2Lexer(RegexLexer):
     """
     For CBM BASIC V2 sources.
-
-    .. versionadded:: 1.6
     """
     name = 'CBM BASIC V2'
     aliases = ['cbmbas']
     filenames = ['*.bas']
+    url = 'https://en.wikipedia.org/wiki/Commodore_BASIC'
+    version_added = '1.6'
 
     flags = re.IGNORECASE
 
@@ -362,17 +354,15 @@ class CbmBasicV2Lexer(RegexLexer):
 
 class QBasicLexer(RegexLexer):
     """
-    For
-    `QBasic <http://en.wikipedia.org/wiki/QBasic>`_
-    source code.
-
-    .. versionadded:: 2.0
+    For QBasic source code.
     """
 
     name = 'QBasic'
     aliases = ['qbasic', 'basic']
     filenames = ['*.BAS', '*.bas']
     mimetypes = ['text/basic']
+    url = 'https://en.wikipedia.org/wiki/QBasic'
+    version_added = '2.0'
 
     declarations = ('DATA', 'LET')
 
@@ -475,26 +465,26 @@ class QBasicLexer(RegexLexer):
         # can't use regular \b because of X$()
         # XXX: use words() here
         'declarations': [
-            (r'\b(%s)(?=\(|\b)' % '|'.join(map(re.escape, declarations)),
+            (r'\b({})(?=\(|\b)'.format('|'.join(map(re.escape, declarations))),
              Keyword.Declaration),
         ],
         'functions': [
-            (r'\b(%s)(?=\(|\b)' % '|'.join(map(re.escape, functions)),
+            (r'\b({})(?=\(|\b)'.format('|'.join(map(re.escape, functions))),
              Keyword.Reserved),
         ],
         'metacommands': [
-            (r'\b(%s)(?=\(|\b)' % '|'.join(map(re.escape, metacommands)),
+            (r'\b({})(?=\(|\b)'.format('|'.join(map(re.escape, metacommands))),
              Keyword.Constant),
         ],
         'operators': [
-            (r'\b(%s)(?=\(|\b)' % '|'.join(map(re.escape, operators)), Operator.Word),
+            (r'\b({})(?=\(|\b)'.format('|'.join(map(re.escape, operators))), Operator.Word),
         ],
         'statements': [
-            (r'\b(%s)\b' % '|'.join(map(re.escape, statements)),
+            (r'\b({})\b'.format('|'.join(map(re.escape, statements))),
              Keyword.Reserved),
         ],
         'keywords': [
-            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
+            (r'\b({})\b'.format('|'.join(keywords)), Keyword),
         ],
     }
 
@@ -506,12 +496,13 @@ class QBasicLexer(RegexLexer):
 class VBScriptLexer(RegexLexer):
     """
     VBScript is scripting language that is modeled on Visual Basic.
-
-    .. versionadded:: 2.4
     """
     name = 'VBScript'
     aliases = ['vbscript']
     filenames = ['*.vbs', '*.VBS']
+    url = 'https://learn.microsoft.com/en-us/previous-versions/t0aew7h6(v=vs.85)'
+    version_added = '2.4'
+
     flags = re.IGNORECASE
 
     tokens = {
@@ -573,8 +564,6 @@ class BBCBasicLexer(RegexLexer):
     """
     BBC Basic was supplied on the BBC Micro, and later Acorn RISC OS.
     It is also used by BBC Basic For Windows.
-
-    .. versionadded:: 2.4
     """
     base_keywords = ['OTHERWISE', 'AND', 'DIV', 'EOR', 'MOD', 'OR', 'ERROR',
                      'LINE', 'OFF', 'STEP', 'SPC', 'TAB', 'ELSE', 'THEN',
@@ -607,6 +596,8 @@ class BBCBasicLexer(RegexLexer):
     name = 'BBC Basic'
     aliases = ['bbcbasic']
     filenames = ['*.bbc']
+    url = 'https://www.bbcbasic.co.uk/bbcbasic.html'
+    version_added = '2.4'
 
     tokens = {
         'root': [

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

@@ -3,9 +3,8 @@
     ~~~~~~~~~~~~~~~~~~~
 
     Lexer for BDD(Behavior-driven development).
-    More information: https://en.wikipedia.org/wiki/Behavior-driven_development
 
-    :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 +18,14 @@ class BddLexer(RegexLexer):
     """
     Lexer for BDD(Behavior-driven development), which highlights not only
     keywords, but also comments, punctuations, strings, numbers, and variables.
-
-    .. versionadded:: 2.11
     """
 
     name = 'Bdd'
     aliases = ['bdd']
     filenames = ['*.feature']
     mimetypes = ['text/x-bdd']
+    url = 'https://en.wikipedia.org/wiki/Behavior-driven_development'
+    version_added = '2.11'
 
     step_keywords = (r'Given|When|Then|Add|And|Feature|Scenario Outline|'
                      r'Scenario|Background|Examples|But')

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

@@ -4,7 +4,7 @@
 
     Lexer for Berry.
 
-    :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.
 """
 
@@ -17,14 +17,14 @@ __all__ = ['BerryLexer']
 
 class BerryLexer(RegexLexer):
     """
-    For `berry <http://github.com/berry-lang/berry>`_ source code.
-
-    .. versionadded:: 2.12.0
+    For Berry source code.
     """
     name = 'Berry'
     aliases = ['berry', 'be']
     filenames = ['*.be']
     mimetypes = ['text/x-berry', 'application/x-berry']
+    url = 'https://berry-lang.github.io'
+    version_added = '2.12'
 
     _name = r'\b[^\W\d]\w*'
 

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

@@ -4,7 +4,7 @@
 
     Lexers for BibTeX bibliography data and styles
 
-    :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,15 +21,15 @@ __all__ = ['BibTeXLexer', 'BSTLexer']
 class BibTeXLexer(ExtendedRegexLexer):
     """
     A lexer for BibTeX bibliography data format.
-
-    .. versionadded:: 2.2
     """
 
     name = 'BibTeX'
     aliases = ['bibtex', 'bib']
     filenames = ['*.bib']
     mimetypes = ["text/x-bibtex"]
+    version_added = '2.2'
     flags = re.IGNORECASE
+    url = 'https://texfaq.org/FAQ-BibTeXing'
 
     ALLOWED_CHARS = r'@!$&*+\-./:;<>?\[\\\]^`|~'
     IDENTIFIER = '[{}][{}]*'.format('a-z_' + ALLOWED_CHARS, r'\w' + ALLOWED_CHARS)
@@ -116,14 +116,14 @@ class BibTeXLexer(ExtendedRegexLexer):
 class BSTLexer(RegexLexer):
     """
     A lexer for BibTeX bibliography styles.
-
-    .. versionadded:: 2.2
     """
 
     name = 'BST'
     aliases = ['bst', 'bst-pybtex']
     filenames = ['*.bst']
+    version_added = '2.2'
     flags = re.IGNORECASE | re.MULTILINE
+    url = 'https://texfaq.org/FAQ-BibTeXing'
 
     tokens = {
         'root': [

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

@@ -0,0 +1,173 @@
+"""
+    pygments.lexers.blueprint
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the Blueprint UI markup language.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, words
+from pygments.token import (
+    Comment,
+    Operator,
+    Keyword,
+    Name,
+    String,
+    Number,
+    Punctuation,
+    Whitespace,
+)
+
+__all__ = ["BlueprintLexer"]
+
+
+class BlueprintLexer(RegexLexer):
+    """
+    For Blueprint UI markup.
+    """
+
+    name = "Blueprint"
+    aliases = ["blueprint"]
+    filenames = ["*.blp"]
+    mimetypes = ["text/x-blueprint"]
+    url = "https://gitlab.gnome.org/jwestman/blueprint-compiler"
+    version_added = '2.16'
+
+    flags = re.IGNORECASE
+    tokens = {
+        "root": [
+            include("block-content"),
+        ],
+        "type": [
+            (r"\$\s*[a-z_][a-z0-9_\-]*", Name.Class),
+            (r"(?:([a-z_][a-z0-9_\-]*)(\s*)(\.)(\s*))?([a-z_][a-z0-9_\-]*)",
+             bygroups(Name.Namespace, Whitespace, Punctuation, Whitespace, Name.Class)),
+        ],
+        "whitespace": [
+            (r"\s+", Whitespace),
+            (r"//.*?\n", Comment.Single),
+            (r"/\*", Comment.Multiline, "comment-multiline"),
+        ],
+        "comment-multiline": [
+            (r"\*/", Comment.Multiline, "#pop"),
+            (r"[^*]+", Comment.Multiline),
+            (r"\*", Comment.Multiline),
+        ],
+        "value": [
+            (r"(typeof)(\s*)(<)", bygroups(Keyword, Whitespace, Punctuation), "typeof"),
+            (words(("true", "false", "null")), Keyword.Constant),
+            (r"[a-z_][a-z0-9_\-]*", Name.Variable),
+            (r"\|", Operator),
+            (r'".*?"', String.Double),
+            (r"\'.*?\'", String.Single),
+            (r"0x[\d_]*", Number.Hex),
+            (r"[0-9_]+", Number.Integer),
+            (r"\d[\d\.a-z_]*", Number),
+        ],
+        "typeof": [
+            include("whitespace"),
+            include("type"),
+            (r">", Punctuation, "#pop"),
+        ],
+        "content": [
+            include("whitespace"),
+            # Keywords
+            (words(("after", "bidirectional", "bind-property", "bind", "default",
+                    "destructive", "disabled", "inverted", "no-sync-create",
+                    "suggested", "swapped", "sync-create", "template")),
+             Keyword),
+            # Translated strings
+            (r"(C?_)(\s*)(\()",
+             bygroups(Name.Function.Builtin, Whitespace, Punctuation),
+             "paren-content"),
+            # Cast expressions
+            (r"(as)(\s*)(<)", bygroups(Keyword, Whitespace, Punctuation), "typeof"),
+            # Closures
+            (r"(\$?[a-z_][a-z0-9_\-]*)(\s*)(\()",
+             bygroups(Name.Function, Whitespace, Punctuation),
+             "paren-content"),
+            # Objects
+            (r"(?:(\$\s*[a-z_][a-z0-9_\-]+)|(?:([a-z_][a-z0-9_\-]*)(\s*)(\.)(\s*))?([a-z_][a-z0-9_\-]*))(?:(\s+)([a-z_][a-z0-9_\-]*))?(\s*)(\{)",
+             bygroups(Name.Class, Name.Namespace, Whitespace, Punctuation, Whitespace,
+                      Name.Class, Whitespace, Name.Variable, Whitespace, Punctuation),
+             "brace-block"),
+            # Misc
+            include("value"),
+            (r",|\.", Punctuation),
+        ],
+        "block-content": [
+            # Import statements
+            (r"(using)(\s+)([a-z_][a-z0-9_\-]*)(\s+)(\d[\d\.]*)(;)",
+             bygroups(Keyword, Whitespace, Name.Namespace, Whitespace,
+                      Name.Namespace, Punctuation)),
+            # Menus
+            (r"(menu|section|submenu)(?:(\s+)([a-z_][a-z0-9_\-]*))?(\s*)(\{)",
+             bygroups(Keyword, Whitespace, Name.Variable, Whitespace, Punctuation),
+             "brace-block"),
+            (r"(item)(\s*)(\{)",
+             bygroups(Keyword, Whitespace, Punctuation),
+             "brace-block"),
+            (r"(item)(\s*)(\()",
+             bygroups(Keyword, Whitespace, Punctuation),
+             "paren-block"),
+            # Templates
+            (r"template", Keyword.Declaration, "template"),
+            # Nested blocks. When extensions are added, this is where they go.
+            (r"(responses|items|mime-types|patterns|suffixes|marks|widgets|strings|styles)(\s*)(\[)",
+             bygroups(Keyword, Whitespace, Punctuation),
+             "bracket-block"),
+            (r"(accessibility|setters|layout|item)(\s*)(\{)",
+             bygroups(Keyword, Whitespace, Punctuation),
+             "brace-block"),
+            (r"(condition|mark|item)(\s*)(\()",
+             bygroups(Keyword, Whitespace, Punctuation),
+             "paren-content"),
+            (r"\[", Punctuation, "child-type"),
+            # Properties and signals
+            (r"([a-z_][a-z0-9_\-]*(?:::[a-z0-9_]+)?)(\s*)(:|=>)",
+             bygroups(Name.Property, Whitespace, Punctuation),
+             "statement"),
+            include("content"),
+        ],
+        "paren-block": [
+            include("block-content"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        "paren-content": [
+            include("content"),
+            (r"\)", Punctuation, "#pop"),
+        ],
+        "bracket-block": [
+            include("block-content"),
+            (r"\]", Punctuation, "#pop"),
+        ],
+        "brace-block": [
+            include("block-content"),
+            (r"\}", Punctuation, "#pop"),
+        ],
+        "statement": [
+            include("content"),
+            (r";", Punctuation, "#pop"),
+        ],
+        "child-type": [
+            include("whitespace"),
+            (r"(action)(\s+)(response)(\s*)(=)(\s*)",
+             bygroups(Keyword, Whitespace, Name.Attribute, Whitespace,
+                      Punctuation, Whitespace)),
+            (words(("default", "internal-child", "response")), Keyword),
+            (r"[a-z_][a-z0-9_\-]*", Name.Decorator),
+            include("value"),
+            (r"=", Punctuation),
+            (r"\]", Punctuation, "#pop"),
+        ],
+        "template": [
+            include("whitespace"),
+            include("type"),
+            (r":", Punctuation),
+            (r"\{", Punctuation, ("#pop", "brace-block")),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexers for the Boa 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.
 """
 
@@ -17,13 +17,13 @@ __all__ = ['BoaLexer']
 
 class BoaLexer(RegexLexer):
     """
-    Lexer for the `Boa <http://boa.cs.iastate.edu/docs/>`_ language.
-
-    .. versionadded:: 2.4
+    Lexer for the Boa language.
     """
     name = 'Boa'
     aliases = ['boa']
     filenames = ['*.boa']
+    url = 'https://boa.cs.iastate.edu/docs'
+    version_added = '2.4'
 
     reserved = words(
         ('input', 'output', 'of', 'weight', 'before', 'after', 'stop',