pygments.rb 2.3.1 → 2.4.0

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

@@ -4,29 +4,28 @@
 
     Lexers for the ECL 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.
 """
 
 import re
 
 from pygments.lexer import RegexLexer, include, bygroups, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
 
 __all__ = ['ECLLexer']
 
 
 class ECLLexer(RegexLexer):
     """
-    Lexer for the declarative big-data `ECL
-    <https://hpccsystems.com/training/documentation/ecl-language-reference/html>`_
-    language.
+    Lexer for the declarative big-data ECL language.
 
     .. versionadded:: 1.5
     """
 
     name = 'ECL'
+    url = 'https://hpccsystems.com/training/documentation/ecl-language-reference/html'
     aliases = ['ecl']
     filenames = ['*.ecl']
     mimetypes = ['application/x-ecl']
@@ -39,7 +38,7 @@ class ECLLexer(RegexLexer):
             include('statements'),
         ],
         'whitespace': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\/\/.*', Comment.Single),
             (r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment.Multiline),
         ],
@@ -67,7 +66,7 @@ class ECLLexer(RegexLexer):
             (r'((?:ASCII|BIG_ENDIAN|BOOLEAN|DATA|DECIMAL|EBCDIC|INTEGER|PATTERN|'
              r'QSTRING|REAL|RECORD|RULE|SET OF|STRING|TOKEN|UDECIMAL|UNICODE|'
              r'UNSIGNED|VARSTRING|VARUNICODE)\d*)(\s+)',
-             bygroups(Keyword.Type, Text)),
+             bygroups(Keyword.Type, Whitespace)),
         ],
         'keywords': [
             (words((
@@ -80,39 +79,48 @@ class ECLLexer(RegexLexer):
              Keyword.Reserved),
             # These are classed differently, check later
             (words((
-                'ALL', 'AND', 'ANY', 'AS', 'ATMOST', 'BEFORE', 'BEGINC++', 'BEST', 'BETWEEN', 'CASE',
-                'CONST', 'COUNTER', 'CSV', 'DESCEND', 'ENCRYPT', 'ENDC++', 'ENDMACRO', 'EXCEPT',
-                'EXCLUSIVE', 'EXPIRE', 'EXPORT', 'EXTEND', 'FALSE', 'FEW', 'FIRST', 'FLAT', 'FULL',
-                'FUNCTION', 'GROUP', 'HEADER', 'HEADING', 'HOLE', 'IFBLOCK', 'IMPORT', 'IN', 'JOINED',
-                'KEEP', 'KEYED', 'LAST', 'LEFT', 'LIMIT', 'LOAD', 'LOCAL', 'LOCALE', 'LOOKUP', 'MACRO',
-                'MANY', 'MAXCOUNT', 'MAXLENGTH', 'MIN SKEW', 'MODULE', 'INTERFACE', 'NAMED', 'NOCASE',
-                'NOROOT', 'NOSCAN', 'NOSORT', 'NOT', 'OF', 'ONLY', 'OPT', 'OR', 'OUTER', 'OVERWRITE',
-                'PACKED', 'PARTITION', 'PENALTY', 'PHYSICALLENGTH', 'PIPE', 'QUOTE', 'RELATIONSHIP',
-                'REPEAT', 'RETURN', 'RIGHT', 'SCAN', 'SELF', 'SEPARATOR', 'SERVICE', 'SHARED', 'SKEW',
-                'SKIP', 'SQL', 'STORE', 'TERMINATOR', 'THOR', 'THRESHOLD', 'TOKEN', 'TRANSFORM', 'TRIM',
-                'TRUE', 'TYPE', 'UNICODEORDER', 'UNSORTED', 'VALIDATE', 'VIRTUAL', 'WHOLE', 'WILD',
-                'WITHIN', 'XML', 'XPATH', '__COMPRESSED__'), suffix=r'\b'),
+                'ALL', 'AND', 'ANY', 'AS', 'ATMOST', 'BEFORE', 'BEGINC++', 'BEST',
+                'BETWEEN', 'CASE', 'CONST', 'COUNTER', 'CSV', 'DESCEND', 'ENCRYPT',
+                'ENDC++', 'ENDMACRO', 'EXCEPT', 'EXCLUSIVE', 'EXPIRE', 'EXPORT',
+                'EXTEND', 'FALSE', 'FEW', 'FIRST', 'FLAT', 'FULL', 'FUNCTION',
+                'GROUP', 'HEADER', 'HEADING', 'HOLE', 'IFBLOCK', 'IMPORT', 'IN',
+                'JOINED', 'KEEP', 'KEYED', 'LAST', 'LEFT', 'LIMIT', 'LOAD', 'LOCAL',
+                'LOCALE', 'LOOKUP', 'MACRO', 'MANY', 'MAXCOUNT', 'MAXLENGTH',
+                'MIN SKEW', 'MODULE', 'INTERFACE', 'NAMED', 'NOCASE', 'NOROOT',
+                'NOSCAN', 'NOSORT', 'NOT', 'OF', 'ONLY', 'OPT', 'OR', 'OUTER',
+                'OVERWRITE', 'PACKED', 'PARTITION', 'PENALTY', 'PHYSICALLENGTH',
+                'PIPE', 'QUOTE', 'RELATIONSHIP', 'REPEAT', 'RETURN', 'RIGHT',
+                'SCAN', 'SELF', 'SEPARATOR', 'SERVICE', 'SHARED', 'SKEW', 'SKIP',
+                'SQL', 'STORE', 'TERMINATOR', 'THOR', 'THRESHOLD', 'TOKEN',
+                'TRANSFORM', 'TRIM', 'TRUE', 'TYPE', 'UNICODEORDER', 'UNSORTED',
+                'VALIDATE', 'VIRTUAL', 'WHOLE', 'WILD', 'WITHIN', 'XML', 'XPATH',
+                '__COMPRESSED__'), suffix=r'\b'),
              Keyword.Reserved),
         ],
         'functions': [
             (words((
-                'ABS', 'ACOS', 'ALLNODES', 'ASCII', 'ASIN', 'ASSTRING', 'ATAN', 'ATAN2', 'AVE', 'CASE',
-                'CHOOSE', 'CHOOSEN', 'CHOOSESETS', 'CLUSTERSIZE', 'COMBINE', 'CORRELATION', 'COS',
-                'COSH', 'COUNT', 'COVARIANCE', 'CRON', 'DATASET', 'DEDUP', 'DEFINE', 'DENORMALIZE',
-                'DISTRIBUTE', 'DISTRIBUTED', 'DISTRIBUTION', 'EBCDIC', 'ENTH', 'ERROR', 'EVALUATE',
-                'EVENT', 'EVENTEXTRA', 'EVENTNAME', 'EXISTS', 'EXP', 'FAILCODE', 'FAILMESSAGE',
-                'FETCH', 'FROMUNICODE', 'GETISVALID', 'GLOBAL', 'GRAPH', 'GROUP', 'HASH', 'HASH32',
-                'HASH64', 'HASHCRC', 'HASHMD5', 'HAVING', 'IF', 'INDEX', 'INTFORMAT', 'ISVALID',
-                'ITERATE', 'JOIN', 'KEYUNICODE', 'LENGTH', 'LIBRARY', 'LIMIT', 'LN', 'LOCAL', 'LOG', 'LOOP',
-                'MAP', 'MATCHED', 'MATCHLENGTH', 'MATCHPOSITION', 'MATCHTEXT', 'MATCHUNICODE',
-                'MAX', 'MERGE', 'MERGEJOIN', 'MIN', 'NOLOCAL', 'NONEMPTY', 'NORMALIZE', 'PARSE', 'PIPE',
-                'POWER', 'PRELOAD', 'PROCESS', 'PROJECT', 'PULL', 'RANDOM', 'RANGE', 'RANK', 'RANKED',
-                'REALFORMAT', 'RECORDOF', 'REGEXFIND', 'REGEXREPLACE', 'REGROUP', 'REJECTED',
-                'ROLLUP', 'ROUND', 'ROUNDUP', 'ROW', 'ROWDIFF', 'SAMPLE', 'SET', 'SIN', 'SINH', 'SIZEOF',
-                'SOAPCALL', 'SORT', 'SORTED', 'SQRT', 'STEPPED', 'STORED', 'SUM', 'TABLE', 'TAN', 'TANH',
-                'THISNODE', 'TOPN', 'TOUNICODE', 'TRANSFER', 'TRIM', 'TRUNCATE', 'TYPEOF', 'UNGROUP',
-                'UNICODEORDER', 'VARIANCE', 'WHICH', 'WORKUNIT', 'XMLDECODE', 'XMLENCODE',
-                'XMLTEXT', 'XMLUNICODE'), suffix=r'\b'),
+                'ABS', 'ACOS', 'ALLNODES', 'ASCII', 'ASIN', 'ASSTRING', 'ATAN',
+                'ATAN2', 'AVE', 'CASE', 'CHOOSE', 'CHOOSEN', 'CHOOSESETS',
+                'CLUSTERSIZE', 'COMBINE', 'CORRELATION', 'COS', 'COSH', 'COUNT',
+                'COVARIANCE', 'CRON', 'DATASET', 'DEDUP', 'DEFINE', 'DENORMALIZE',
+                'DISTRIBUTE', 'DISTRIBUTED', 'DISTRIBUTION', 'EBCDIC', 'ENTH',
+                'ERROR', 'EVALUATE', 'EVENT', 'EVENTEXTRA', 'EVENTNAME', 'EXISTS',
+                'EXP', 'FAILCODE', 'FAILMESSAGE', 'FETCH', 'FROMUNICODE',
+                'GETISVALID', 'GLOBAL', 'GRAPH', 'GROUP', 'HASH', 'HASH32',
+                'HASH64', 'HASHCRC', 'HASHMD5', 'HAVING', 'IF', 'INDEX',
+                'INTFORMAT', 'ISVALID', 'ITERATE', 'JOIN', 'KEYUNICODE', 'LENGTH',
+                'LIBRARY', 'LIMIT', 'LN', 'LOCAL', 'LOG', 'LOOP', 'MAP', 'MATCHED',
+                'MATCHLENGTH', 'MATCHPOSITION', 'MATCHTEXT', 'MATCHUNICODE', 'MAX',
+                'MERGE', 'MERGEJOIN', 'MIN', 'NOLOCAL', 'NONEMPTY', 'NORMALIZE',
+                'PARSE', 'PIPE', 'POWER', 'PRELOAD', 'PROCESS', 'PROJECT', 'PULL',
+                'RANDOM', 'RANGE', 'RANK', 'RANKED', 'REALFORMAT', 'RECORDOF',
+                'REGEXFIND', 'REGEXREPLACE', 'REGROUP', 'REJECTED', 'ROLLUP',
+                'ROUND', 'ROUNDUP', 'ROW', 'ROWDIFF', 'SAMPLE', 'SET', 'SIN',
+                'SINH', 'SIZEOF', 'SOAPCALL', 'SORT', 'SORTED', 'SQRT', 'STEPPED',
+                'STORED', 'SUM', 'TABLE', 'TAN', 'TANH', 'THISNODE', 'TOPN',
+                'TOUNICODE', 'TRANSFER', 'TRIM', 'TRUNCATE', 'TYPEOF', 'UNGROUP',
+                'UNICODEORDER', 'VARIANCE', 'WHICH', 'WORKUNIT', 'XMLDECODE',
+                'XMLENCODE', 'XMLTEXT', 'XMLUNICODE'), suffix=r'\b'),
              Name.Function),
         ],
         'string': [
@@ -124,7 +132,7 @@ class ECLLexer(RegexLexer):
 
     def analyse_text(text):
         """This is very difficult to guess relative to other business languages.
-        -> in conjuction with BEGIN/END seems relatively rare though."""
+        -> in conjunction with BEGIN/END seems relatively rare though."""
         result = 0
 
         if '->' in text:

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

@@ -4,36 +4,41 @@
 
     Lexer for the Eiffel 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, include, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.lexer import RegexLexer, include, words, bygroups
+from pygments.token import Comment, Operator, Keyword, Name, String, Number, \
+    Punctuation, Whitespace
 
 __all__ = ['EiffelLexer']
 
 
 class EiffelLexer(RegexLexer):
     """
-    For `Eiffel <http://www.eiffel.com>`_ source code.
+    For Eiffel source code.
 
     .. versionadded:: 2.0
     """
     name = 'Eiffel'
+    url = 'http://www.eiffel.com'
     aliases = ['eiffel']
     filenames = ['*.e']
     mimetypes = ['text/x-eiffel']
 
     tokens = {
         'root': [
-            (r'[^\S\n]+', Text),
-            (r'--.*?\n', Comment.Single),
-            (r'[^\S\n]+', Text),
+            (r'[^\S\n]+', Whitespace),
+            (r'--.*?$', Comment.Single),
+            (r'[^\S\n]+', Whitespace),
             # Please note that keyword and operator are case insensitive.
             (r'(?i)(true|false|void|current|result|precursor)\b', Keyword.Constant),
-            (r'(?i)(and(\s+then)?|not|xor|implies|or(\s+else)?)\b', Operator.Word),
+            (r'(?i)(not|xor|implies|or)\b', Operator.Word),
+            (r'(?i)(and)(?:(\s+)(then))?\b',
+             bygroups(Operator.Word, Whitespace, Operator.Word)),
+            (r'(?i)(or)(?:(\s+)(else))?\b',
+             bygroups(Operator.Word, Whitespace, Operator.Word)),
             (words((
                 'across', 'agent', 'alias', 'all', 'as', 'assign', 'attached',
                 'attribute', 'check', 'class', 'convert', 'create', 'debug',
@@ -52,7 +57,7 @@ class EiffelLexer(RegexLexer):
             (r"([{}():;,.])", Punctuation),
             (r'([a-z]\w*)|([A-Z][A-Z0-9_]*[a-z]\w*)', Name),
             (r'([A-Z][A-Z0-9_]*)', Name.Class),
-            (r'\n+', Text),
+            (r'\n+', Whitespace),
         ],
         'numbers': [
             (r'0[xX][a-fA-F0-9]+', Number.Hex),

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

@@ -4,24 +4,26 @@
 
     Lexer for the Elm programming 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, words, include
-from pygments.token import Comment, Keyword, Name, Number, Punctuation, String, Text
+from pygments.lexer import RegexLexer, words, include, bygroups
+from pygments.token import Comment, Keyword, Name, Number, Punctuation, \
+    String, Whitespace
 
 __all__ = ['ElmLexer']
 
 
 class ElmLexer(RegexLexer):
     """
-    For `Elm <http://elm-lang.org/>`_ source code.
+    For Elm source code.
 
     .. versionadded:: 2.1
     """
 
     name = 'Elm'
+    url = 'http://elm-lang.org/'
     aliases = ['elm']
     filenames = ['*.elm']
     mimetypes = ['text/x-elm']
@@ -49,16 +51,18 @@ class ElmLexer(RegexLexer):
             (r'--.*', Comment.Single),
 
             # Whitespace
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
 
             # Strings
             (r'"', String, 'doublequote'),
 
             # Modules
-            (r'^\s*module\s*', Keyword.Namespace, 'imports'),
+            (r'^(\s*)(module)(\s*)', bygroups(Whitespace, Keyword.Namespace,
+                Whitespace), 'imports'),
 
             # Imports
-            (r'^\s*import\s*', Keyword.Namespace, 'imports'),
+            (r'^(\s*)(import)(\s*)', bygroups(Whitespace, Keyword.Namespace,
+                Whitespace), 'imports'),
 
             # Shaders
             (r'\[glsl\|.*', Name.Entity, 'shader'),
@@ -115,6 +119,6 @@ class ElmLexer(RegexLexer):
         'shader': [
             (r'\|(?!\])', Name.Entity),
             (r'\|\]', Name.Entity, '#pop'),
-            (r'.*\n', Name.Entity),
+            (r'(.*)(\n)', bygroups(Name.Entity, Whitespace)),
         ],
     }

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

@@ -0,0 +1,165 @@
+"""
+    pygments.lexers.elpi
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the `Elpi <http://github.com/LPCIC/elpi>`_ programming language.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, include
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number
+
+__all__ = ['ElpiLexer']
+
+
+class ElpiLexer(RegexLexer):
+    """
+    Lexer for the Elpi programming language.
+
+    .. versionadded:: 2.11
+    """
+
+    name = 'Elpi'
+    url = 'http://github.com/LPCIC/elpi'
+    aliases = ['elpi']
+    filenames = ['*.elpi']
+    mimetypes = ['text/x-elpi']
+
+    lcase_re = r"[a-z]"
+    ucase_re = r"[A-Z]"
+    digit_re = r"[0-9]"
+    schar2_re = r"([+*^?/<>`'@#~=&!])"
+    schar_re = r"({}|-|\$|_)".format(schar2_re)
+    idchar_re = r"({}|{}|{}|{})".format(lcase_re,ucase_re,digit_re,schar_re)
+    idcharstarns_re = r"({}*(\.({}|{}){}*)*)".format(idchar_re, lcase_re, ucase_re, idchar_re)
+    symbchar_re = r"({}|{}|{}|{}|:)".format(lcase_re, ucase_re, digit_re, schar_re)
+    constant_re = r"({}{}*|{}{}|{}{}*|_{}+)".format(ucase_re, idchar_re, lcase_re, idcharstarns_re, schar2_re, symbchar_re, idchar_re)
+    symbol_re = r"(,|<=>|->|:-|;|\?-|->|&|=>|\bas\b|\buvar\b|<|=<|=|==|>=|>|\bi<|\bi=<|\bi>=|\bi>|\bis\b|\br<|\br=<|\br>=|\br>|\bs<|\bs=<|\bs>=|\bs>|@|::|\[\]|`->|`:|`:=|\^|-|\+|\bi-|\bi\+|r-|r\+|/|\*|\bdiv\b|\bi\*|\bmod\b|\br\*|~|\bi~|\br~)"
+    escape_re = r"\(({}|{})\)".format(constant_re,symbol_re)
+    const_sym_re = r"({}|{}|{})".format(constant_re,symbol_re,escape_re)
+
+    tokens = {
+        'root': [
+            include('elpi')
+        ],
+
+        'elpi': [
+            include('_elpi-comment'),
+
+            (r"(:before|:after|:if|:name)(\s*)(\")",
+             bygroups(Keyword.Mode, Text.Whitespace, String.Double),
+             'elpi-string'),
+            (r"(:index)(\s*\()", bygroups(Keyword.Mode, Text.Whitespace),
+             'elpi-indexing-expr'),
+            (r"\b(external pred|pred)(\s+)({})".format(const_sym_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Function),
+             'elpi-pred-item'),
+            (r"\b(external type|type)(\s+)(({}(,\s*)?)+)".format(const_sym_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Function),
+             'elpi-type'),
+            (r"\b(kind)(\s+)(({}|,)+)".format(const_sym_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Function),
+             'elpi-type'),
+            (r"\b(typeabbrev)(\s+)({})".format(const_sym_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Function),
+             'elpi-type'),
+            (r"\b(accumulate)(\s+)(\")",
+             bygroups(Keyword.Declaration, Text.Whitespace, String.Double),
+             'elpi-string'),
+            (r"\b(accumulate|namespace|local)(\s+)({})".format(constant_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Text)),
+            (r"\b(shorten)(\s+)({}\.)".format(constant_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Text)),
+            (r"\b(pi|sigma)(\s+)([a-zA-Z][A-Za-z0-9_ ]*)(\\)",
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Variable, Text)),
+            (r"\b(constraint)(\s+)(({}(\s+)?)+)".format(const_sym_re),
+             bygroups(Keyword.Declaration, Text.Whitespace, Name.Function),
+             'elpi-chr-rule-start'),
+
+            (r"(?=[A-Z_]){}".format(constant_re), Name.Variable),
+            (r"(?=[a-z_]){}\\".format(constant_re), Name.Variable),
+            (r"_", Name.Variable),
+            (r"({}|!|=>|;)".format(symbol_re), Keyword.Declaration),
+            (constant_re, Text),
+            (r"\[|\]|\||=>", Keyword.Declaration),
+            (r'"', String.Double, 'elpi-string'),
+            (r'`', String.Double, 'elpi-btick'),
+            (r'\'', String.Double, 'elpi-tick'),
+            (r'\{[^\{]', Text, 'elpi-spill'),
+            (r"\(", Text, 'elpi-in-parens'),
+            (r'\d[\d_]*', Number.Integer),
+            (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
+            (r"[\+\*\-/\^\.]", Operator),
+        ],
+        '_elpi-comment': [
+            (r'%[^\n]*\n', Comment),
+            (r'/\*', Comment, 'elpi-multiline-comment'),
+            (r"\s+", Text.Whitespace),
+        ],
+        'elpi-multiline-comment': [
+            (r'\*/', Comment, '#pop'),
+            (r'.', Comment)
+        ],
+        'elpi-indexing-expr':[
+            (r'[0-9 _]+', Number.Integer),
+            (r'\)', Text, '#pop'),
+        ],
+        'elpi-type': [
+            (r"(ctype\s+)(\")", bygroups(Keyword.Type, String.Double), 'elpi-string'),
+            (r'->', Keyword.Type),
+            (constant_re, Keyword.Type),
+            (r"\(|\)", Keyword.Type),
+            (r"\.", Text, '#pop'),
+            include('_elpi-comment'),
+        ],
+        'elpi-chr-rule-start': [
+            (r"\{", Text, 'elpi-chr-rule'),
+            include('_elpi-comment'),
+        ],
+        'elpi-chr-rule': [
+           (r"\brule\b", Keyword.Declaration),
+           (r"\\", Keyword.Declaration),
+           (r"\}", Text, '#pop:2'),
+           include('elpi'),
+        ],
+        'elpi-pred-item': [
+            (r"[io]:", Keyword.Mode, 'elpi-ctype'),
+            (r"\.", Text, '#pop'),
+            include('_elpi-comment'),
+        ],
+        'elpi-ctype': [
+            (r"(ctype\s+)(\")", bygroups(Keyword.Type, String.Double), 'elpi-string'),
+            (r'->', Keyword.Type),
+            (constant_re, Keyword.Type),
+            (r"\(|\)", Keyword.Type),
+            (r",", Text, '#pop'),
+            (r"\.", Text, '#pop:2'),
+            include('_elpi-comment'),
+        ],
+        'elpi-btick': [
+            (r'[^` ]+', String.Double),
+            (r'`', String.Double, '#pop'),
+        ],
+        'elpi-tick': [
+            (r'[^\' ]+', String.Double),
+            (r'\'', String.Double, '#pop'),
+        ],
+        'elpi-string': [
+            (r'[^\"]+', String.Double),
+            (r'"', String.Double, '#pop'),
+        ],
+        'elpi-spill': [
+            (r'\{[^\{]', Text, '#push'),
+            (r'\}[^\}]', Text, '#pop'),
+            include('elpi'),
+        ],
+        'elpi-in-parens': [
+            (r"\(", Operator, '#push'),
+            (r"\)", Operator, '#pop'),
+            include('elpi'),
+        ],
+
+    }

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

@@ -4,7 +4,7 @@
 
     Lexer for the raw E-mail.
 
-    :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.
 """
 
@@ -63,11 +63,9 @@ class EmailHeaderLexer(RegexLexer):
             (r"\b(\w[\w\.-]*\.[\w\.-]*\w[a-zA-Z]+)\b", Name.Function),
 
             # IPv4
-            (
-                r"(?<=\b)(?:(?:25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.){3}(?:25[0"
-                r"-5]|2[0-4][0-9]|1?[0-9][0-9]?)(?=\b)",
-                Number.Integer,
-            ),
+            (r"(?<=\b)(?:(?:25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.){3}(?:25[0"
+             r"-5]|2[0-4][0-9]|1?[0-9][0-9]?)(?=\b)",
+             Number.Integer),
 
             # IPv6
             (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,7}:(?!\b)", Number.Hex),
@@ -83,43 +81,27 @@ class EmailHeaderLexer(RegexLexer):
              Number.Hex),
             (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}(?=\b)",
              Number.Hex),
-            (
-                r"(?<=\b)::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}"
-                r"[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}"
-                r"[0-9])(?=\b)",
-                Number.Hex,
-            ),
-            (
-                r"(?<=\b)([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-"
-                r"9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-"
-                r"9])(?=\b)",
-                Number.Hex,
-            ),
+            (r"(?<=\b)::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}"
+             r"[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}"
+             r"[0-9])(?=\b)",
+             Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9])"
+             r"{0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])(?=\b)",
+             Number.Hex),
 
             # Date time
-            (
-                r"(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(0[1-9]|[1-2]?[0-9]|3["
-                r"01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+("
-                r"19[0-9]{2}|[2-9][0-9]{3})\s+(2[0-3]|[0-1][0-9]):([0-5][0-9])"
-                r"(?::(60|[0-5][0-9]))?(?:\.\d{1,5})?\s+([-\+][0-9]{2}[0-5][0-"
-                r"9]|\(?(?:UTC?|GMT|(?:E|C|M|P)(?:ST|ET|DT)|[A-IK-Z])\)?)",
-                Name.Decorator,
-            ),
+            (r"(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(0[1-9]|[1-2]?[0-9]|3["
+             r"01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+("
+             r"19[0-9]{2}|[2-9][0-9]{3})\s+(2[0-3]|[0-1][0-9]):([0-5][0-9])"
+             r"(?::(60|[0-5][0-9]))?(?:\.\d{1,5})?\s+([-\+][0-9]{2}[0-5][0-"
+             r"9]|\(?(?:UTC?|GMT|(?:E|C|M|P)(?:ST|ET|DT)|[A-IK-Z])\)?)",
+             Name.Decorator),
 
             # RFC-2047 encoded string
-            (
-                r"(=\?)([\w-]+)(\?)([BbQq])(\?)([\[\w!\"#$%&\'()*+,-./:;<=>@[\\"
-                r"\]^_`{|}~]+)(\?=)",
-                bygroups(
-                    String.Affix,
-                    Name.Constant,
-                    String.Affix,
-                    Keyword.Constant,
-                    String.Affix,
-                    Number.Hex,
-                    String.Affix
-                )
-            ),
+            (r"(=\?)([\w-]+)(\?)([BbQq])(\?)([\[\w!\"#$%&\'()*+,-./:;<=>@[\\"
+             r"\]^_`{|}~]+)(\?=)",
+             bygroups(String.Affix, Name.Constant, String.Affix, Keyword.Constant,
+                      String.Affix, Number.Hex, String.Affix)),
 
             # others
             (r'[\s]+', Text.Whitespace),