pygments.rb 2.3.1 → 2.4.0

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

@@ -4,16 +4,14 @@
 
     Lexers for data file format.
 
-    :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 Lexer, RegexLexer, ExtendedRegexLexer, LexerContext, \
-    include, bygroups, inherit
-from pygments.token import Text, Comment, Keyword, Name, String, Number, \
-    Punctuation, Literal, Error
+from pygments.lexer import Lexer, ExtendedRegexLexer, LexerContext, \
+    include, bygroups
+from pygments.token import Comment, Error, Keyword, Literal, Name, Number, \
+    Punctuation, String, Whitespace
 
 __all__ = ['YamlLexer', 'JsonLexer', 'JsonBareObjectLexer', 'JsonLdLexer']
 
@@ -31,13 +29,14 @@ class YamlLexerContext(LexerContext):
 
 class YamlLexer(ExtendedRegexLexer):
     """
-    Lexer for `YAML <http://yaml.org/>`_, a human-friendly data serialization
+    Lexer for YAML, a human-friendly data serialization
     language.
 
     .. versionadded:: 0.11
     """
 
     name = 'YAML'
+    url = 'http://yaml.org/'
     aliases = ['yaml']
     filenames = ['*.yaml', '*.yml']
     mimetypes = ['text/x-yaml']
@@ -170,9 +169,9 @@ class YamlLexer(ExtendedRegexLexer):
         # the root rules
         'root': [
             # ignored whitespaces
-            (r'[ ]+(?=#|$)', Text),
+            (r'[ ]+(?=#|$)', Whitespace),
             # line breaks
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
             # a comment
             (r'#[^\n]*', Comment.Single),
             # the '%YAML' directive
@@ -183,25 +182,25 @@ class YamlLexer(ExtendedRegexLexer):
             (r'^(?:---|\.\.\.)(?=[ ]|$)', reset_indent(Name.Namespace),
              'block-line'),
             # indentation spaces
-            (r'[ ]*(?!\s|$)', save_indent(Text, start=True),
+            (r'[ ]*(?!\s|$)', save_indent(Whitespace, start=True),
              ('block-line', 'indentation')),
         ],
 
         # trailing whitespaces after directives or a block scalar indicator
         'ignored-line': [
             # ignored whitespaces
-            (r'[ ]+(?=#|$)', Text),
+            (r'[ ]+(?=#|$)', Whitespace),
             # a comment
             (r'#[^\n]*', Comment.Single),
             # line break
-            (r'\n', Text, '#pop:2'),
+            (r'\n', Whitespace, '#pop:2'),
         ],
 
         # the %YAML directive
         'yaml-directive': [
             # the version number
             (r'([ ]+)([0-9]+\.[0-9]+)',
-             bygroups(Text, Number), 'ignored-line'),
+             bygroups(Whitespace, Number), 'ignored-line'),
         ],
 
         # the %TAG directive
@@ -209,30 +208,30 @@ class YamlLexer(ExtendedRegexLexer):
             # a tag handle and the corresponding prefix
             (r'([ ]+)(!|![\w-]*!)'
              r'([ ]+)(!|!?[\w;/?:@&=+$,.!~*\'()\[\]%-]+)',
-             bygroups(Text, Keyword.Type, Text, Keyword.Type),
+             bygroups(Whitespace, Keyword.Type, Whitespace, Keyword.Type),
              'ignored-line'),
         ],
 
         # block scalar indicators and indentation spaces
         'indentation': [
             # trailing whitespaces are ignored
-            (r'[ ]*$', something(Text), '#pop:2'),
+            (r'[ ]*$', something(Whitespace), '#pop:2'),
             # whitespaces preceding block collection indicators
-            (r'[ ]+(?=[?:-](?:[ ]|$))', save_indent(Text)),
+            (r'[ ]+(?=[?:-](?:[ ]|$))', save_indent(Whitespace)),
             # block collection indicators
             (r'[?:-](?=[ ]|$)', set_indent(Punctuation.Indicator)),
             # the beginning a block line
-            (r'[ ]*', save_indent(Text), '#pop'),
+            (r'[ ]*', save_indent(Whitespace), '#pop'),
         ],
 
         # an indented line in the block context
         'block-line': [
             # the line end
-            (r'[ ]*(?=#|$)', something(Text), '#pop'),
+            (r'[ ]*(?=#|$)', something(Whitespace), '#pop'),
             # whitespaces separating tokens
-            (r'[ ]+', Text),
+            (r'[ ]+', Whitespace),
             # key with colon
-            (r'''([^#,:?\[\]{}"'\n]+)(:)(?=[ ]|$)''',
+            (r'''([^#,?\[\]{}"'\n]+)(:)(?=[ ]|$)''',
              bygroups(Name.Tag, set_indent(Punctuation, implicit=True))),
             # tags, anchors and aliases,
             include('descriptors'),
@@ -283,9 +282,9 @@ class YamlLexer(ExtendedRegexLexer):
         # the content of a flow collection
         'flow-collection': [
             # whitespaces
-            (r'[ ]+', Text),
+            (r'[ ]+', Whitespace),
             # line breaks
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
             # a comment
             (r'#[^\n]*', Comment.Single),
             # simple indicators
@@ -322,12 +321,12 @@ class YamlLexer(ExtendedRegexLexer):
         # block scalar lines
         'block-scalar-content': [
             # line break
-            (r'\n', Text),
+            (r'\n', Whitespace),
             # empty line
             (r'^[ ]+$',
-             parse_block_scalar_empty_line(Text, Name.Constant)),
+             parse_block_scalar_empty_line(Whitespace, Name.Constant)),
             # indentation spaces (we may leave the state here)
-            (r'^[ ]*', parse_block_scalar_indent(Text)),
+            (r'^[ ]*', parse_block_scalar_indent(Whitespace)),
             # line content
             (r'[\S\t ]+', Name.Constant),
         ],
@@ -347,10 +346,10 @@ class YamlLexer(ExtendedRegexLexer):
         # ignored and regular whitespaces in quoted scalars
         'quoted-scalar-whitespaces': [
             # leading and trailing whitespaces are ignored
-            (r'^[ ]+', Text),
-            (r'[ ]+$', Text),
+            (r'^[ ]+', Whitespace),
+            (r'[ ]+$', Whitespace),
             # line breaks are ignored
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
             # other whitespaces are a part of the value
             (r'[ ]+', Name.Variable),
         ],
@@ -385,25 +384,25 @@ class YamlLexer(ExtendedRegexLexer):
         # the beginning of a new line while scanning a plain scalar
         'plain-scalar-in-block-context-new-line': [
             # empty lines
-            (r'^[ ]+$', Text),
+            (r'^[ ]+$', Whitespace),
             # line breaks
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
             # document start and document end indicators
             (r'^(?=---|\.\.\.)', something(Name.Namespace), '#pop:3'),
             # indentation spaces (we may leave the block line state here)
-            (r'^[ ]*', parse_plain_scalar_indent(Text), '#pop'),
+            (r'^[ ]*', parse_plain_scalar_indent(Whitespace), '#pop'),
         ],
 
         # a plain scalar in the block context
         'plain-scalar-in-block-context': [
             # the scalar ends with the ':' indicator
-            (r'[ ]*(?=:[ ]|:$)', something(Text), '#pop'),
+            (r'[ ]*(?=:[ ]|:$)', something(Whitespace), '#pop'),
             # the scalar ends with whitespaces followed by a comment
-            (r'[ ]+(?=#)', Text, '#pop'),
+            (r'[ ]+(?=#)', Whitespace, '#pop'),
             # trailing whitespaces are ignored
-            (r'[ ]+$', Text),
+            (r'[ ]+$', Whitespace),
             # line breaks are ignored
-            (r'\n+', Text, 'plain-scalar-in-block-context-new-line'),
+            (r'\n+', Whitespace, 'plain-scalar-in-block-context-new-line'),
             # other whitespaces are a part of the value
             (r'[ ]+', Literal.Scalar.Plain),
             # regular non-whitespace characters
@@ -413,14 +412,14 @@ class YamlLexer(ExtendedRegexLexer):
         # a plain scalar is the flow context
         'plain-scalar-in-flow-context': [
             # the scalar ends with an indicator character
-            (r'[ ]*(?=[,:?\[\]{}])', something(Text), '#pop'),
+            (r'[ ]*(?=[,:?\[\]{}])', something(Whitespace), '#pop'),
             # the scalar ends with a comment
-            (r'[ ]+(?=#)', Text, '#pop'),
+            (r'[ ]+(?=#)', Whitespace, '#pop'),
             # leading and trailing whitespaces are ignored
-            (r'^[ ]+', Text),
-            (r'[ ]+$', Text),
+            (r'^[ ]+', Whitespace),
+            (r'[ ]+$', Whitespace),
             # line breaks are ignored
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
             # other whitespaces are a part of the value
             (r'[ ]+', Name.Variable),
             # regular non-whitespace characters
@@ -439,10 +438,17 @@ class JsonLexer(Lexer):
     """
     For JSON data structures.
 
+    Javascript-style comments are supported (like ``/* */`` and ``//``),
+    though comments are not part of the JSON specification.
+    This allows users to highlight JSON as it is used in the wild.
+
+    No validation is performed on the input JSON document.
+
     .. versionadded:: 1.5
     """
 
     name = 'JSON'
+    url = 'https://www.json.org'
     aliases = ['json', 'json-object']
     filenames = ['*.json', 'Pipfile.lock']
     mimetypes = ['application/json', 'application/json-object']
@@ -473,6 +479,10 @@ class JsonLexer(Lexer):
         in_number = False
         in_float = False
         in_punctuation = False
+        in_comment_single = False
+        in_comment_multiline = False
+        expecting_second_comment_opener = False  # // or /*
+        expecting_second_comment_closer = False  # */
 
         start = 0
 
@@ -529,9 +539,9 @@ class JsonLexer(Lexer):
                     continue
 
                 if queue:
-                    queue.append((start, Text, text[start:stop]))
+                    queue.append((start, Whitespace, text[start:stop]))
                 else:
-                    yield start, Text, text[start:stop]
+                    yield start, Whitespace, text[start:stop]
                 in_whitespace = False
                 # Fall through so the new character can be evaluated.
 
@@ -566,6 +576,49 @@ class JsonLexer(Lexer):
                 in_punctuation = False
                 # Fall through so the new character can be evaluated.
 
+            elif in_comment_single:
+                if character != '\n':
+                    continue
+
+                if queue:
+                    queue.append((start, Comment.Single, text[start:stop]))
+                else:
+                    yield start, Comment.Single, text[start:stop]
+
+                in_comment_single = False
+                # Fall through so the new character can be evaluated.
+
+            elif in_comment_multiline:
+                if character == '*':
+                    expecting_second_comment_closer = True
+                elif expecting_second_comment_closer:
+                    expecting_second_comment_closer = False
+                    if character == '/':
+                        if queue:
+                            queue.append((start, Comment.Multiline, text[start:stop + 1]))
+                        else:
+                            yield start, Comment.Multiline, text[start:stop + 1]
+
+                        in_comment_multiline = False
+
+                continue
+
+            elif expecting_second_comment_opener:
+                expecting_second_comment_opener = False
+                if character == '/':
+                    in_comment_single = True
+                    continue
+                elif character == '*':
+                    in_comment_multiline = True
+                    continue
+
+                # Exhaust the queue. Accept the existing token types.
+                yield from queue
+                queue.clear()
+
+                yield start, Error, text[start:stop]
+                # Fall through so the new character can be evaluated.
+
             start = stop
 
             if character == '"':
@@ -591,12 +644,18 @@ class JsonLexer(Lexer):
             elif character == ':':
                 # Yield from the queue. Replace string token types.
                 for _start, _token, _text in queue:
-                    if _token is Text:
-                        yield _start, _token, _text
-                    elif _token is String.Double:
+                    # There can be only three types of tokens before a ':':
+                    # Whitespace, Comment, or a quoted string.
+                    #
+                    # If it's a quoted string we emit Name.Tag.
+                    # Otherwise, we yield the original token.
+                    #
+                    # In all other cases this would be invalid JSON,
+                    # but this is not a validating JSON lexer, so it's OK.
+                    if _token is String.Double:
                         yield _start, Name.Tag, _text
                     else:
-                        yield _start, Error, _text
+                        yield _start, _token, _text
                 queue.clear()
 
                 in_punctuation = True
@@ -608,6 +667,10 @@ class JsonLexer(Lexer):
 
                 in_punctuation = True
 
+            elif character == '/':
+                # This is the beginning of a comment.
+                expecting_second_comment_opener = True
+
             else:
                 # Exhaust the queue. Accept the existing token types.
                 yield from queue
@@ -626,9 +689,15 @@ class JsonLexer(Lexer):
         elif in_constant:
             yield start, Keyword.Constant, text[start:]
         elif in_whitespace:
-            yield start, Text, text[start:]
+            yield start, Whitespace, text[start:]
         elif in_punctuation:
             yield start, Punctuation, text[start:]
+        elif in_comment_single:
+            yield start, Comment.Single, text[start:]
+        elif in_comment_multiline:
+            yield start, Error, text[start:]
+        elif expecting_second_comment_opener:
+            yield start, Error, text[start:]
 
 
 class JsonBareObjectLexer(JsonLexer):
@@ -650,12 +719,13 @@ class JsonBareObjectLexer(JsonLexer):
 
 class JsonLdLexer(JsonLexer):
     """
-    For `JSON-LD <https://json-ld.org/>`_ linked data.
+    For JSON-LD linked data.
 
     .. versionadded:: 2.0
     """
 
     name = 'JSON-LD'
+    url = 'https://json-ld.org/'
     aliases = ['jsonld', 'json-ld']
     filenames = ['*.jsonld']
     mimetypes = ['application/ld+json']

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

@@ -0,0 +1,136 @@
+"""
+    pygments.lexers.dax
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexer for LilyPond.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Comment, Punctuation, Whitespace,\
+    Name, Operator, String, Number, Text
+
+__all__ = ['DaxLexer']
+
+
+class DaxLexer(RegexLexer):
+    """
+    Lexer for Power BI DAX
+    Referenced from: https://github.com/sql-bi/SyntaxHighlighterBrushDax
+
+    .. versionadded:: 2.15
+    """
+    name = 'Dax'
+    aliases = ['dax']
+    filenames = ['*.dax']
+    url = 'https://learn.microsoft.com/en-us/dax/dax-function-reference'
+    mimetypes = []
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r"--.*\n?", Comment.Single),	# Comment: Double dash comment
+            (r"//.*\n?", Comment.Single),	# Comment: Double backslash comment
+            (r'/\*', Comment.Multiline, 'multiline-comments'),
+            (words(('abs', 'accrint', 'accrintm', 'acos', 'acosh', 'acot', 'acoth',
+                    'addcolumns', 'addmissingitems', 'all', 'allcrossfiltered',
+                    'allexcept', 'allnoblankrow', 'allselected', 'amordegrc', 'amorlinc',
+                    'and','approximatedistinctcount', 'asin', 'asinh', 'atan', 'atanh',
+                    'average', 'averagea', 'averagex', 'beta.dist', 'beta.inv',
+                    'bitand', 'bitlshift', 'bitor', 'bitrshift', 'bitxor', 'blank',
+                    'calculate', 'calculatetable', 'calendar', 'calendarauto', 'ceiling',
+                    'chisq.dist', 'chisq.dist.rt', 'chisq.inv', 'chisq.inv.rt',
+                    'closingbalancemonth', 'closingbalancequarter', 'closingbalanceyear',
+                    'coalesce', 'columnstatistics', 'combin', 'combina', 'combinevalues',
+                    'concatenate', 'concatenatex', 'confidence.norm', 'confidence.t',
+                    'contains', 'containsrow', 'containsstring', 'containsstringexact',
+                    'convert', 'cos', 'cosh', 'cot', 'coth', 'count', 'counta', 'countax',
+                    'countblank', 'countrows', 'countx', 'coupdaybs', 'coupdays',
+                    'coupdaysnc', 'coupncd', 'coupnum', 'couppcd', 'crossfilter',
+                    'crossjoin', 'cumipmt', 'cumprinc', 'currency', 'currentgroup',
+                    'customdata', 'datatable', 'date', 'dateadd', 'datediff',
+                    'datesbetween', 'datesinperiod', 'datesmtd', 'datesqtd',
+                    'datesytd', 'datevalue', 'day', 'db', 'ddb', 'degrees', 'detailrows',
+                    'disc', 'distinct', 'distinctcount', 'distinctcountnoblank',
+                    'divide', 'dollarde', 'dollarfr', 'duration', 'earlier', 'earliest',
+                    'edate', 'effect', 'endofmonth', 'endofquarter', 'endofyear',
+                    'eomonth', 'error', 'evaluateandlog', 'even', 'exact', 'except',
+                    'exp', 'expon.dist', 'fact', 'false', 'filter', 'filters', 'find',
+                    'firstdate', 'firstnonblank', 'firstnonblankvalue', 'fixed', 'floor',
+                    'format', 'fv', 'gcd', 'generate', 'generateall', 'generateseries',
+                    'geomean', 'geomeanx', 'groupby', 'hash', 'hasonefilter',
+                    'hasonevalue', 'hour', 'if', 'if.eager', 'iferror', 'ignore', 'index',
+                    'int', 'intersect', 'intrate', 'ipmt', 'isafter', 'isblank',
+                    'iscrossfiltered', 'isempty', 'iserror', 'iseven', 'isfiltered',
+                    'isinscope', 'islogical', 'isnontext', 'isnumber', 'iso.ceiling',
+                    'isodd', 'isonorafter', 'ispmt', 'isselectedmeasure', 'issubtotal',
+                    'istext', 'keepfilters', 'keywordmatch', 'lastdate', 'lastnonblank',
+                    'lastnonblankvalue', 'lcm', 'left', 'len', 'linest', 'linestx', 'ln',
+                    'log', 'log10', 'lookupvalue', 'lower', 'max', 'maxa', 'maxx',
+                    'mduration', 'median', 'medianx', 'mid', 'min', 'mina', 'minute',
+                    'minx', 'mod', 'month', 'mround', 'nameof', 'naturalinnerjoin',
+                    'naturalleftouterjoin', 'networkdays', 'nextday', 'nextmonth',
+                    'nextquarter', 'nextyear', 'nominal', 'nonvisual', 'norm.dist',
+                    'norm.inv', 'norm.s.dist', 'norm.s.inv', 'not', 'now', 'nper', 'odd',
+                    'oddfprice', 'oddfyield', 'oddlprice', 'oddlyield', 'offset',
+                    'openingbalancemonth', 'openingbalancequarter', 'openingbalanceyear',
+                    'or', 'orderby', 'parallelperiod', 'partitionby', 'path',
+                    'pathcontains', 'pathitem', 'pathitemreverse', 'pathlength',
+                    'pduration', 'percentile.exc', 'percentile.inc', 'percentilex.exc',
+                    'percentilex.inc', 'permut', 'pi', 'pmt', 'poisson.dist', 'power',
+                    'ppmt', 'previousday', 'previousmonth', 'previousquarter',
+                    'previousyear', 'price', 'pricedisc', 'pricemat', 'product',
+                    'productx', 'pv', 'quarter', 'quotient', 'radians', 'rand',
+                    'randbetween', 'rank.eq', 'rankx', 'rate', 'received', 'related',
+                    'relatedtable', 'removefilters', 'replace', 'rept', 'right',
+                    'rollup', 'rollupaddissubtotal', 'rollupgroup', 'rollupissubtotal',
+                    'round', 'rounddown', 'roundup', 'row', 'rri', 'sameperiodlastyear',
+                    'sample', 'sampleaxiswithlocalminmax', 'search', 'second',
+                    'selectcolumns', 'selectedmeasure', 'selectedmeasureformatstring',
+                    'selectedmeasurename', 'selectedvalue', 'sign', 'sin', 'sinh', 'sln',
+                    'sqrt', 'sqrtpi', 'startofmonth', 'startofquarter', 'startofyear',
+                    'stdev.p', 'stdev.s', 'stdevx.p', 'stdevx.s', 'substitute',
+                    'substitutewithindex', 'sum', 'summarize', 'summarizecolumns', 'sumx',
+                    'switch', 'syd', 't.dist', 't.dist.2t', 't.dist.rt', 't.inv',
+                    't.inv.2t', 'tan', 'tanh', 'tbilleq', 'tbillprice', 'tbillyield',
+                    'time', 'timevalue', 'tocsv', 'today', 'tojson', 'topn',
+                    'topnperlevel', 'topnskip', 'totalmtd', 'totalqtd', 'totalytd',
+                    'treatas', 'trim', 'true', 'trunc', 'unichar', 'unicode', 'union',
+                    'upper', 'userculture', 'userelationship', 'username', 'userobjectid',
+                    'userprincipalname', 'utcnow', 'utctoday', 'value', 'values', 'var.p',
+                    'var.s', 'varx.p', 'varx.s', 'vdb', 'weekday', 'weeknum', 'window',
+                    'xirr', 'xnpv', 'year', 'yearfrac', 'yield', 'yielddisc', 'yieldmat'),
+                 prefix=r'(?i)', suffix=r'\b'), Name.Function), #Functions
+
+            (words(('at','asc','boolean','both','by','create','currency',
+                'datetime','day','define','desc','double',
+                'evaluate','false','integer','measure',
+                'month','none','order','return','single','start','string',
+                'table','true','var','year'),
+                prefix=r'(?i)', suffix=r'\b'), Name.Builtin), # Keyword
+
+            (r':=|[-+*\/=^]', Operator),
+            (r'\b(IN|NOT)\b', Operator.Word),
+            (r'"', String, 'string'), #StringLiteral
+            (r"'(?:[^']|'')*'(?!')(?:\[[ \w]+\])?|\w+\[[ \w]+\]",
+                Name.Attribute),	# Column reference
+            (r"\[[ \w]+\]", Name.Attribute), #Measure reference
+            (r'(?<!\w)(\d+\.?\d*|\.\d+\b)', Number),# Number
+            (r'[\[\](){}`,.]', Punctuation), #Parenthesis
+            (r'.*\n', Text),
+
+        ],
+        'multiline-comments': [
+            (r'/\*', Comment.Multiline, 'multiline-comments'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[^/*]+', Comment.Multiline),
+            (r'[/*]', Comment.Multiline)
+        ],
+        'string': [
+            (r'""', String.Escape),
+            (r'"', String, '#pop'),
+            (r'[^"]+', String),
+        ]
+    }

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

@@ -4,25 +4,26 @@
 
     Lexers for Devicetree language.
 
-    :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, default, words
 from pygments.token import Comment, Keyword, Name, Number, Operator, \
-    Punctuation, String, Text
+    Punctuation, String, Text, Whitespace
 
 __all__ = ['DevicetreeLexer']
 
 
 class DevicetreeLexer(RegexLexer):
     """
-    Lexer for `Devicetree <https://www.devicetree.org/>`_ files.
+    Lexer for Devicetree files.
 
     .. versionadded:: 2.7
     """
 
     name = 'Devicetree'
+    url = 'https://www.devicetree.org/'
     aliases = ['devicetree', 'dts']
     filenames = ['*.dts', '*.dtsi']
     mimetypes = ['text/x-c']
@@ -46,12 +47,12 @@ class DevicetreeLexer(RegexLexer):
              bygroups(Comment.Preproc, Comment.Multiline, Comment.Preproc, Punctuation)),
         ],
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
             (r'\\\n', Text),  # line continuation
             (r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single),
             (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
-            # Open until EOF, so no ending delimeter
+            # Open until EOF, so no ending delimiter
             (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
         ],
         'statements': [
@@ -73,7 +74,7 @@ class DevicetreeLexer(RegexLexer):
             include('macro'),
 
             # Nodes
-            (r'([^/*@\s&]+|/)(@?)([0-9a-fA-F,]*)(' + _ws + r')(\{)',
+            (r'([^/*@\s&]+|/)(@?)((?:0x)?[0-9a-fA-F,]*)(' + _ws + r')(\{)',
              bygroups(Name.Function, Operator, Number.Integer,
                       Comment.Multiline, Punctuation), 'node'),
 
@@ -88,7 +89,7 @@ class DevicetreeLexer(RegexLexer):
             include('whitespace'),
             include('macro'),
 
-            (r'([^/*@\s&]+|/)(@?)([0-9a-fA-F,]*)(' + _ws + r')(\{)',
+            (r'([^/*@\s&]+|/)(@?)((?:0x)?[0-9a-fA-F,]*)(' + _ws + r')(\{)',
              bygroups(Name.Function, Operator, Number.Integer,
                       Comment.Multiline, Punctuation), '#push'),
 

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

@@ -4,7 +4,7 @@
 
     Lexers for diff/patch 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.
 """
 
@@ -12,7 +12,7 @@ import re
 
 from pygments.lexer import RegexLexer, include, bygroups
 from pygments.token import Text, Comment, Operator, Keyword, Name, Generic, \
-    Literal
+    Literal, Whitespace
 
 __all__ = ['DiffLexer', 'DarcsPatchLexer', 'WDiffLexer']
 
@@ -29,14 +29,17 @@ class DiffLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r' .*\n', Text),
-            (r'\+.*\n', Generic.Inserted),
-            (r'-.*\n', Generic.Deleted),
-            (r'!.*\n', Generic.Strong),
-            (r'@.*\n', Generic.Subheading),
-            (r'([Ii]ndex|diff).*\n', Generic.Heading),
-            (r'=.*\n', Generic.Heading),
-            (r'.*\n', Text),
+            (r'( )(.*)(\n)', bygroups(Whitespace, Text, Whitespace)),
+            (r'(!.*|---)(\n)', bygroups(Generic.Strong, Whitespace)),
+            (r'((?:< |-).*)(\n)', bygroups(Generic.Deleted, Whitespace)),
+            (r'((?:> |\+).*)(\n)', bygroups(Generic.Inserted, Whitespace)),
+            (
+                r'(@.*|\d(?:,\d+)?(?:a|c|d)\d+(?:,\d+)?)(\n)',
+                bygroups(Generic.Subheading, Whitespace),
+            ),
+            (r'((?:[Ii]ndex|diff).*)(\n)', bygroups(Generic.Heading, Whitespace)),
+            (r'(=.*)(\n)', bygroups(Generic.Heading, Whitespace)),
+            (r'(.*)(\n)', bygroups(Text, Whitespace)),
         ]
     }
 
@@ -72,26 +75,26 @@ class DarcsPatchLexer(RegexLexer):
             (r'\{', Operator),
             (r'\}', Operator),
             (r'(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)(\])',
-             bygroups(Operator, Keyword, Name, Text, Name, Operator,
-                      Literal.Date, Text, Operator)),
+             bygroups(Operator, Keyword, Name, Whitespace, Name, Operator,
+                      Literal.Date, Whitespace, Operator)),
             (r'(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)',
-             bygroups(Operator, Keyword, Name, Text, Name, Operator,
-                      Literal.Date, Text), 'comment'),
+             bygroups(Operator, Keyword, Name, Whitespace, Name, Operator,
+                      Literal.Date, Whitespace), 'comment'),
             (r'New patches:', Generic.Heading),
             (r'Context:', Generic.Heading),
             (r'Patch bundle hash:', Generic.Heading),
-            (r'(\s*)(%s)(.*\n)' % '|'.join(DPATCH_KEYWORDS),
-                bygroups(Text, Keyword, Text)),
+            (r'(\s*)(%s)(.*)(\n)' % '|'.join(DPATCH_KEYWORDS),
+                bygroups(Whitespace, Keyword, Text, Whitespace)),
             (r'\+', Generic.Inserted, "insert"),
             (r'-', Generic.Deleted, "delete"),
-            (r'.*\n', Text),
+            (r'(.*)(\n)', bygroups(Text, Whitespace)),
         ],
         'comment': [
             (r'[^\]].*\n', Comment),
             (r'\]', Operator, "#pop"),
         ],
         'specialText': [            # darcs add [_CODE_] special operators for clarity
-            (r'\n', Text, "#pop"),  # line-based
+            (r'\n', Whitespace, "#pop"),  # line-based
             (r'\[_[^_]*_]', Operator),
         ],
         'insert': [
@@ -109,7 +112,7 @@ class DarcsPatchLexer(RegexLexer):
 
 class WDiffLexer(RegexLexer):
     """
-    A `wdiff <https://www.gnu.org/software/wdiff/>`_ lexer.
+    A wdiff lexer.
 
     Note that:
 
@@ -121,6 +124,7 @@ class WDiffLexer(RegexLexer):
     """
 
     name = 'WDiff'
+    url = 'https://www.gnu.org/software/wdiff/'
     aliases = ['wdiff']
     filenames = ['*.wdiff']
     mimetypes = []