pygments.rb 2.4.1 → 4.0.0

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

@@ -4,7 +4,7 @@
 
     Lexer for the Monte 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.
 """
 
@@ -78,13 +78,12 @@ _safeScope = [
 class MonteLexer(RegexLexer):
     """
     Lexer for the Monte programming language.
-
-    .. versionadded:: 2.2
     """
     name = 'Monte'
     url = 'https://monte.readthedocs.io/'
     aliases = ['monte']
     filenames = ['*.mt']
+    version_added = '2.2'
 
     tokens = {
         'root': [

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

@@ -5,7 +5,7 @@
     Lexers for the mosel language.
     http://www.fico.com/en/products/fico-xpress-optimization
 
-    :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.
 """
 
@@ -391,12 +391,12 @@ FUNCTIONS = (
 class MoselLexer(RegexLexer):
     """
     For the Mosel optimization language.
-
-    .. versionadded:: 2.6
     """
     name = 'Mosel'
     aliases = ['mosel']
     filenames = ['*.mos']
+    url = 'https://www.fico.com/fico-xpress-optimization/docs/latest/mosel/mosel_lang/dhtml/moselreflang.html'
+    version_added = '2.6'
 
     tokens = {
         'root': [

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

@@ -4,7 +4,7 @@
 
     Lexers for NCAR Command 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.
 """
 
@@ -20,13 +20,14 @@ __all__ = ['NCLLexer']
 class NCLLexer(RegexLexer):
     """
     Lexer for NCL code.
-
-    .. versionadded:: 2.2
     """
     name = 'NCL'
     aliases = ['ncl']
     filenames = ['*.ncl']
     mimetypes = ['text/ncl']
+    url = 'https://www.ncl.ucar.edu'
+    version_added = '2.2'
+
     flags = re.MULTILINE
 
     tokens = {

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

@@ -4,7 +4,7 @@
 
     Lexer for the Nim language (formerly known as Nimrod).
 
-    :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,8 +20,6 @@ __all__ = ['NimrodLexer']
 class NimrodLexer(RegexLexer):
     """
     For Nim source code.
-
-    .. versionadded:: 1.5
     """
 
     name = 'Nimrod'
@@ -29,6 +27,7 @@ class NimrodLexer(RegexLexer):
     aliases = ['nimrod', 'nim']
     filenames = ['*.nim', '*.nimrod']
     mimetypes = ['text/x-nim']
+    version_added = '1.5'
 
     flags = re.MULTILINE | re.IGNORECASE
 
@@ -97,15 +96,15 @@ class NimrodLexer(RegexLexer):
             ("'", String.Char, 'chars'),
 
             # Keywords
-            (r'(%s)\b' % underscorize(opWords), Operator.Word),
+            (rf'({underscorize(opWords)})\b', Operator.Word),
             (r'(proc|func|method|macro|template)(\s)(?![(\[\]])',
              bygroups(Keyword, Text.Whitespace), 'funcname'),
-            (r'(%s)\b' % underscorize(keywords), Keyword),
-            (r'(%s)\b' % underscorize(['from', 'import', 'include', 'export']),
+            (rf'({underscorize(keywords)})\b', Keyword),
+            (r'({})\b'.format(underscorize(['from', 'import', 'include', 'export'])),
              Keyword.Namespace),
             (r'(v_?a_?r)\b', Keyword.Declaration),
-            (r'(%s)\b' % underscorize(types), Name.Builtin),
-            (r'(%s)\b' % underscorize(keywordsPseudo), Keyword.Pseudo),
+            (rf'({underscorize(types)})\b', Name.Builtin),
+            (rf'({underscorize(keywordsPseudo)})\b', Keyword.Pseudo),
 
             # Identifiers
             (r'\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*', Name),

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

@@ -4,7 +4,7 @@
 
     Lexer for the Nit 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.
 """
 
@@ -18,14 +18,13 @@ __all__ = ['NitLexer']
 class NitLexer(RegexLexer):
     """
     For nit source.
-
-    .. versionadded:: 2.0
     """
 
     name = 'Nit'
     url = 'http://nitlanguage.org'
     aliases = ['nit']
     filenames = ['*.nit']
+    version_added = '2.0'
     tokens = {
         'root': [
             (r'#.*?$', Comment.Single),

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

@@ -4,7 +4,7 @@
 
     Lexers for the NixOS Nix 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.
 """
 
@@ -20,8 +20,6 @@ __all__ = ['NixLexer']
 class NixLexer(RegexLexer):
     """
     For the Nix language.
-
-    .. versionadded:: 2.0
     """
 
     name = 'Nix'
@@ -29,13 +27,14 @@ class NixLexer(RegexLexer):
     aliases = ['nixos', 'nix']
     filenames = ['*.nix']
     mimetypes = ['text/x-nix']
+    version_added = '2.0'
 
     keywords = ['rec', 'with', 'let', 'in', 'inherit', 'assert', 'if',
                 'else', 'then', '...']
     builtins = ['import', 'abort', 'baseNameOf', 'dirOf', 'isNull', 'builtins',
                 'map', 'removeAttrs', 'throw', 'toString', 'derivation']
-    operators = ['++', '+', '?', '.', '!', '//', '==',
-                 '!=', '&&', '||', '->', '=']
+    operators = ['++', '+', '?', '.', '!', '//', '==', '/',
+                 '!=', '&&', '||', '->', '=', '<', '>', '*', '-']
 
     punctuations = ["(", ")", "[", "]", ";", "{", "}", ":", ",", "@"]
 
@@ -51,42 +50,49 @@ class NixLexer(RegexLexer):
             (r'\s+', Text),
 
             # keywords
-            ('(%s)' % '|'.join(re.escape(entry) + '\\b' for entry in keywords), Keyword),
+            ('({})'.format('|'.join(re.escape(entry) + '\\b' for entry in keywords)), Keyword),
 
             # highlight the builtins
-            ('(%s)' % '|'.join(re.escape(entry) + '\\b' for entry in builtins),
+            ('({})'.format('|'.join(re.escape(entry) + '\\b' for entry in builtins)),
              Name.Builtin),
 
             (r'\b(true|false|null)\b', Name.Constant),
 
+            # floats
+            (r'-?(\d+\.\d*|\.\d+)([eE][-+]?\d+)?', Number.Float),
+
+            # integers
+            (r'-?[0-9]+', Number.Integer),
+
+            # paths
+            (r'[\w.+-]*(\/[\w.+-]+)+', Literal),
+            (r'~(\/[\w.+-]+)+', Literal),
+            (r'\<[\w.+-]+(\/[\w.+-]+)*\>', Literal),
+
             # operators
-            ('(%s)' % '|'.join(re.escape(entry) for entry in operators),
+            ('({})'.format('|'.join(re.escape(entry) for entry in operators)),
              Operator),
 
             # word operators
             (r'\b(or|and)\b', Operator.Word),
 
-            # punctuations
-            ('(%s)' % '|'.join(re.escape(entry) for entry in punctuations), Punctuation),
+            (r'\{', Punctuation, 'block'),
 
-            # integers
-            (r'[0-9]+', Number.Integer),
+            # punctuations
+            ('({})'.format('|'.join(re.escape(entry) for entry in punctuations)), Punctuation),
 
             # strings
             (r'"', String.Double, 'doublequote'),
-            (r"''", String.Single, 'singlequote'),
-
-            # paths
-            (r'[\w.+-]*(\/[\w.+-]+)+', Literal),
-            (r'\<[\w.+-]+(\/[\w.+-]+)*\>', Literal),
+            (r"''", String.Multiline, 'multiline'),
 
             # urls
             (r'[a-zA-Z][a-zA-Z0-9\+\-\.]*\:[\w%/?:@&=+$,\\.!~*\'-]+', Literal),
 
             # names of variables
-            (r'[\w-]+\s*=', String.Symbol),
+            (r'[\w-]+(?=\s*=)', String.Symbol),
             (r'[a-zA-Z_][\w\'-]*', Text),
 
+            (r"\$\{", String.Interpol, 'antiquote'),
         ],
         'comment': [
             (r'[^/*]+', Comment.Multiline),
@@ -94,24 +100,23 @@ class NixLexer(RegexLexer):
             (r'\*/', Comment.Multiline, '#pop'),
             (r'[*/]', Comment.Multiline),
         ],
-        'singlequote': [
-            (r"'''", String.Escape),
-            (r"''\$\{", String.Escape),
-            (r"''\n", String.Escape),
-            (r"''\r", String.Escape),
-            (r"''\t", String.Escape),
-            (r"''", String.Single, '#pop'),
+        'multiline': [
+            (r"''(\$|'|\\n|\\r|\\t|\\)", String.Escape),
+            (r"''", String.Multiline, '#pop'),
             (r'\$\{', String.Interpol, 'antiquote'),
-            (r"['$]", String.Single),
-            (r"[^'$]+", String.Single),
+            (r"[^'\$]+", String.Multiline),
+            (r"\$[^\{']", String.Multiline),
+            (r"'[^']", String.Multiline),
+            (r"\$(?=')", String.Multiline),
         ],
         'doublequote': [
-            (r'\\', String.Escape),
-            (r'\\"', String.Escape),
-            (r'\\$\{', String.Escape),
+            (r'\\(\\|"|\$|n)', String.Escape),
             (r'"', String.Double, '#pop'),
             (r'\$\{', String.Interpol, 'antiquote'),
-            (r'[^"]', String.Double),
+            (r'[^"\\\$]+', String.Double),
+            (r'\$[^\{"]', String.Double),
+            (r'\$(?=")', String.Double),
+            (r'\\', String.Double),
         ],
         'antiquote': [
             (r"\}", String.Interpol, '#pop'),
@@ -119,6 +124,10 @@ class NixLexer(RegexLexer):
             (r"\$\{", String.Interpol, '#push'),
             include('root'),
         ],
+        'block': [
+            (r"\}", Punctuation, '#pop'),
+            include('root'),
+        ],
     }
 
     def analyse_text(text):

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

@@ -0,0 +1,63 @@
+"""
+    pygments.lexers.numbair
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for other Numba Intermediate Representation.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, bygroups, words
+from pygments.token import Whitespace, Name, String,  Punctuation, Keyword, \
+    Operator, Number
+
+__all__ = ["NumbaIRLexer"]
+
+class NumbaIRLexer(RegexLexer):
+    """
+    Lexer for Numba IR
+    """
+    name = 'Numba_IR'
+    url = "https://numba.readthedocs.io/en/stable/developer/architecture.html#stage-2-generate-the-numba-ir"
+    aliases = ['numba_ir', 'numbair']
+    filenames = ['*.numba_ir']
+    mimetypes = ['text/x-numba_ir', 'text/x-numbair']
+    version_added = '2.19'
+
+    identifier = r'\$[a-zA-Z0-9._]+'
+    fun_or_var = r'([a-zA-Z_]+[a-zA-Z0-9]*)'
+
+    tokens = {
+        'root' : [
+            (r'(label)(\ [0-9]+)(:)$',
+                bygroups(Keyword, Name.Label, Punctuation)),
+
+            (r'=', Operator),
+            include('whitespace'),
+            include('keyword'),
+
+            (identifier, Name.Variable),
+            (fun_or_var + r'(\()',
+                bygroups(Name.Function, Punctuation)),
+            (fun_or_var + r'(\=)',
+                bygroups(Name.Attribute, Punctuation)),
+            (fun_or_var, Name.Constant),
+            (r'[0-9]+', Number),
+
+            # <built-in function some>
+            (r'<[^>\n]*>', String),
+
+            (r'[=<>{}\[\]()*.,!\':]|x\b', Punctuation)
+        ],
+
+        'keyword':[
+            (words((
+                'del', 'jump', 'call', 'branch',
+            ), suffix=' '), Keyword),
+        ],
+
+        'whitespace': [
+            (r'(\n|\s)+', Whitespace),
+        ],
+    }

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

@@ -4,7 +4,7 @@
 
     Lexers for Oberon family 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__ = ['ComponentPascalLexer']
 class ComponentPascalLexer(RegexLexer):
     """
     For Component Pascal source code.
-
-    .. versionadded:: 2.1
     """
     name = 'Component Pascal'
     aliases = ['componentpascal', 'cp']
     filenames = ['*.cp', '*.cps']
     mimetypes = ['text/x-component-pascal']
+    url = 'https://blackboxframework.org'
+    version_added = '2.1'
 
     flags = re.MULTILINE | re.DOTALL
 

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

@@ -4,7 +4,7 @@
 
     Lexers for Objective-C family 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.
 """
 
@@ -13,7 +13,7 @@ import re
 from pygments.lexer import RegexLexer, include, bygroups, using, this, words, \
     inherit, default
 from pygments.token import Text, Keyword, Name, String, Operator, \
-    Number, Punctuation, Literal, Comment
+    Number, Punctuation, Literal, Comment, Whitespace
 
 from pygments.lexers.c_cpp import CLexer, CppLexer
 
@@ -201,6 +201,7 @@ class ObjectiveCLexer(objective(CLexer)):
     aliases = ['objective-c', 'objectivec', 'obj-c', 'objc']
     filenames = ['*.m', '*.h']
     mimetypes = ['text/x-objective-c']
+    version_added = ''
     priority = 0.05    # Lower than C
 
 
@@ -213,20 +214,20 @@ class ObjectiveCppLexer(objective(CppLexer)):
     aliases = ['objective-c++', 'objectivec++', 'obj-c++', 'objc++']
     filenames = ['*.mm', '*.hh']
     mimetypes = ['text/x-objective-c++']
+    version_added = ''
     priority = 0.05    # Lower than C++
 
 
 class LogosLexer(ObjectiveCppLexer):
     """
     For Logos + Objective-C source code with preprocessor directives.
-
-    .. versionadded:: 1.6
     """
 
     name = 'Logos'
     aliases = ['logos']
     filenames = ['*.x', '*.xi', '*.xm', '*.xmi']
     mimetypes = ['text/x-logos']
+    version_added = '1.6'
     priority = 0.25
 
     tokens = {
@@ -283,20 +284,19 @@ class LogosLexer(ObjectiveCppLexer):
 class SwiftLexer(RegexLexer):
     """
     For Swift source.
-
-    .. versionadded:: 2.0
     """
     name = 'Swift'
     url = 'https://www.swift.org/'
     filenames = ['*.swift']
     aliases = ['swift']
     mimetypes = ['text/x-swift']
+    version_added = '2.0'
 
     tokens = {
         'root': [
             # Whitespace and Comments
             (r'\n', Text),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'//', Comment.Single, 'comment-single'),
             (r'/\*', Comment.Multiline, 'comment-multi'),
             (r'#(if|elseif|else|endif|available)\b', Comment.Preproc, 'preproc'),
@@ -403,6 +403,7 @@ class SwiftLexer(RegexLexer):
              r'\.[0-9_]*|[eE][+\-]?[0-9_]+)', Number.Float),
             (r'[0-9][0-9_]*', Number.Integer),
             # String Literal
+            (r'"""', String, 'string-multi'),
             (r'"', String, 'string'),
 
             # Operators and Punctuation
@@ -436,11 +437,11 @@ class SwiftLexer(RegexLexer):
              r'|#(?:file|line|column|function))\b', Keyword.Constant),
             (r'import\b', Keyword.Declaration, 'module'),
             (r'(class|enum|extension|struct|protocol)(\s+)([a-zA-Z_]\w*)',
-             bygroups(Keyword.Declaration, Text, Name.Class)),
+             bygroups(Keyword.Declaration, Whitespace, Name.Class)),
             (r'(func)(\s+)([a-zA-Z_]\w*)',
-             bygroups(Keyword.Declaration, Text, Name.Function)),
+             bygroups(Keyword.Declaration, Whitespace, Name.Function)),
             (r'(var|let)(\s+)([a-zA-Z_]\w*)', bygroups(Keyword.Declaration,
-             Text, Name.Variable)),
+             Whitespace, Name.Variable)),
             (words((
                 'actor', 'associatedtype', 'class', 'deinit', 'enum', 'extension', 'func', 'import',
                 'init', 'internal', 'let', 'operator', 'private', 'protocol', 'public',
@@ -454,31 +455,38 @@ class SwiftLexer(RegexLexer):
 
         # Nested
         'comment-single': [
-            (r'\n', Text, '#pop'),
+            (r'\n', Whitespace, '#pop'),
             include('comment'),
-            (r'[^\n]', Comment.Single)
+            (r'[^\n]+', Comment.Single)
         ],
         'comment-multi': [
             include('comment'),
-            (r'[^*/]', Comment.Multiline),
+            (r'[^*/]+', Comment.Multiline),
             (r'/\*', Comment.Multiline, '#push'),
             (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline)
+            (r'[*/]+', Comment.Multiline)
         ],
         'module': [
-            (r'\n', Text, '#pop'),
+            (r'\n', Whitespace, '#pop'),
             (r'[a-zA-Z_]\w*', Name.Class),
             include('root')
         ],
         'preproc': [
-            (r'\n', Text, '#pop'),
+            (r'\n', Whitespace, '#pop'),
             include('keywords'),
             (r'[A-Za-z]\w*', Comment.Preproc),
             include('root')
         ],
         'string': [
-            (r'\\\(', String.Interpol, 'string-intp'),
             (r'"', String, '#pop'),
+            include("string-common"),
+        ],
+        'string-multi': [
+            (r'"""', String, '#pop'),
+            include("string-common"),
+        ],
+        'string-common': [
+            (r'\\\(', String.Interpol, 'string-intp'),
             (r"""\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}"""
              r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}""", String.Escape),
             (r'[^\\"]+', String),

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

@@ -4,7 +4,7 @@
 
     Lexers for the Ooc 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.
 """
 
@@ -18,14 +18,13 @@ __all__ = ['OocLexer']
 class OocLexer(RegexLexer):
     """
     For Ooc source code
-
-    .. versionadded:: 1.2
     """
     name = 'Ooc'
-    url = 'http://ooc-lang.org/'
+    url = 'https://ooc-lang.github.io/'
     aliases = ['ooc']
     filenames = ['*.ooc']
     mimetypes = ['text/x-ooc']
+    version_added = '1.2'
 
     tokens = {
         'root': [
@@ -43,7 +42,7 @@ class OocLexer(RegexLexer):
             (r'(func)((?:[ \t]|\\\n)+)(~[a-z_]\w*)',
              bygroups(Keyword, Text, Name.Function)),
             (r'\bfunc\b', Keyword),
-            # Note: %= and ^= not listed on http://ooc-lang.org/syntax
+            # Note: %= not listed on https://ooc-lang.github.io/docs/lang/operators/
             (r'//.*', Comment),
             (r'(?s)/\*.*?\*/', Comment.Multiline),
             (r'(==?|\+=?|-[=>]?|\*=?|/=?|:=|!=?|%=?|\?|>{1,3}=?|<{1,3}=?|\.\.|'

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

@@ -0,0 +1,96 @@
+"""
+    pygments.lexers.openscad
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the OpenSCAD languages.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, words, include
+from pygments.token import Text, Comment, Punctuation, Operator, Keyword, Name, Number, Whitespace, Literal, String
+
+__all__ = ['OpenScadLexer']
+
+
+class OpenScadLexer(RegexLexer):
+    """For openSCAD code.
+    """
+    name = "OpenSCAD"
+    url = "https://openscad.org/"
+    aliases = ["openscad"]
+    filenames = ["*.scad"]
+    mimetypes = ["application/x-openscad"]
+    version_added = '2.16'
+
+    tokens = {
+        "root": [
+            (r"[^\S\n]+", Whitespace),
+            (r'//', Comment.Single, 'comment-single'),
+            (r'/\*', Comment.Multiline, 'comment-multi'),
+            (r"[{}\[\]\(\),;:]", Punctuation),
+            (r"[*!#%\-+=?/]", Operator),
+            (r"<=|<|==|!=|>=|>|&&|\|\|", Operator),
+            (r"\$(f[asn]|t|vp[rtd]|children)", Operator),
+            (r"(undef|PI)\b", Keyword.Constant),
+            (
+                r"(use|include)((?:\s|\\\\s)+)",
+                bygroups(Keyword.Namespace, Text),
+                "includes",
+            ),
+            (r"(module)(\s*)([^\s\(]+)",
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace)),
+            (r"(function)(\s*)([^\s\(]+)",
+             bygroups(Keyword.Declaration, Whitespace, Name.Function)),
+            (words(("true", "false"), prefix=r"\b", suffix=r"\b"), Literal),
+            (words((
+                "function", "module", "include", "use", "for",
+                "intersection_for", "if", "else", "return"
+                ), prefix=r"\b", suffix=r"\b"), Keyword
+            ),
+            (words((
+                "circle", "square", "polygon", "text", "sphere", "cube",
+                "cylinder", "polyhedron", "translate", "rotate", "scale",
+                "resize", "mirror", "multmatrix", "color", "offset", "hull",
+                "minkowski", "union", "difference", "intersection", "abs",
+                "sign", "sin", "cos", "tan", "acos", "asin", "atan", "atan2",
+                "floor", "round", "ceil", "ln", "log", "pow", "sqrt", "exp",
+                "rands", "min", "max", "concat", "lookup", "str", "chr",
+                "search", "version", "version_num", "norm", "cross",
+                "parent_module", "echo", "import", "import_dxf",
+                "dxf_linear_extrude", "linear_extrude", "rotate_extrude",
+                "surface", "projection", "render", "dxf_cross",
+                "dxf_dim", "let", "assign", "len"
+                ), prefix=r"\b", suffix=r"\b"),
+                Name.Builtin
+            ),
+            (r"\bchildren\b", Name.Builtin.Pseudo),
+            (r'""".*?"""', String.Double),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"-?\d+(\.\d+)?(e[+-]?\d+)?", Number),
+            (r"\w+", Name),
+        ],
+        "includes": [
+            (
+                r"(<)([^>]*)(>)",
+                bygroups(Punctuation, Comment.PreprocFile, Punctuation),
+            ),
+        ],
+        'comment': [
+            (r':param: [a-zA-Z_]\w*|:returns?:|(FIXME|MARK|TODO):',
+             Comment.Special)
+        ],
+        'comment-single': [
+            (r'\n', Text, '#pop'),
+            include('comment'),
+            (r'[^\n]+', Comment.Single)
+        ],
+        'comment-multi': [
+            include('comment'),
+            (r'[^*/]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline)
+        ],
+    }

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

@@ -4,10 +4,11 @@
 
     Just export lexer classes previously contained in this module.
 
-    :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.
 """
 
+# ruff: noqa: F401
 from pygments.lexers.sql import SqlLexer, MySqlLexer, SqliteConsoleLexer
 from pygments.lexers.shell import BashLexer, BashSessionLexer, BatchLexer, \
     TcshLexer