pygments.rb 2.3.1 → 2.4.0

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

@@ -4,31 +4,29 @@
 
     Lexers for the Factor 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, bygroups, default, words
-from pygments.token import Text, Comment, Keyword, Name, String, Number
+from pygments.token import Text, Comment, Keyword, Name, String, Number, \
+    Whitespace, Punctuation
 
 __all__ = ['FactorLexer']
 
 
 class FactorLexer(RegexLexer):
     """
-    Lexer for the `Factor <http://factorcode.org>`_ language.
+    Lexer for the Factor language.
 
     .. versionadded:: 1.4
     """
     name = 'Factor'
+    url = 'http://factorcode.org'
     aliases = ['factor']
     filenames = ['*.factor']
     mimetypes = ['text/x-factor']
 
-    flags = re.MULTILINE | re.UNICODE
-
     builtin_kernel = words((
         '-rot', '2bi', '2bi@', '2bi*', '2curry', '2dip', '2drop', '2dup', '2keep', '2nip',
         '2over', '2tri', '2tri@', '2tri*', '3bi', '3curry', '3dip', '3drop', '3dup', '3keep',
@@ -43,7 +41,7 @@ class FactorLexer(RegexLexer):
         'pick', 'prepose', 'retainstack', 'rot', 'same?', 'swap', 'swapd', 'throw',
         'tri', 'tri-curry', 'tri-curry@', 'tri-curry*', 'tri@', 'tri*', 'tuple',
         'tuple?', 'unless', 'unless*', 'until', 'when', 'when*', 'while', 'with',
-        'wrapper', 'wrapper?', 'xor'), suffix=r'\s')
+        'wrapper', 'wrapper?', 'xor'), suffix=r'(\s+)')
 
     builtin_assocs = words((
         '2cache', '<enum>', '>alist', '?at', '?of', 'assoc', 'assoc-all?',
@@ -57,7 +55,7 @@ class FactorLexer(RegexLexer):
         'clear-assoc', 'delete-at', 'delete-at*', 'enum', 'enum?', 'extract-keys',
         'inc-at', 'key?', 'keys', 'map>assoc', 'maybe-set-at', 'new-assoc', 'of',
         'push-at', 'rename-at', 'set-at', 'sift-keys', 'sift-values', 'substitute',
-        'unzip', 'value-at', 'value-at*', 'value?', 'values', 'zip'), suffix=r'\s')
+        'unzip', 'value-at', 'value-at*', 'value?', 'values', 'zip'), suffix=r'(\s+)')
 
     builtin_combinators = words((
         '2cleave', '2cleave>quot', '3cleave', '3cleave>quot', '4cleave',
@@ -65,7 +63,7 @@ class FactorLexer(RegexLexer):
         'case>quot', 'cleave', 'cleave>quot', 'cond', 'cond>quot', 'deep-spread>quot',
         'execute-effect', 'linear-case-quot', 'no-case', 'no-case?', 'no-cond',
         'no-cond?', 'recursive-hashcode', 'shallow-spread>quot', 'spread',
-        'to-fixed-point', 'wrong-values', 'wrong-values?'), suffix=r'\s')
+        'to-fixed-point', 'wrong-values', 'wrong-values?'), suffix=r'(\s+)')
 
     builtin_math = words((
         '-', '/', '/f', '/i', '/mod', '2/', '2^', '<', '<=', '<fp-nan>', '>',
@@ -85,7 +83,7 @@ class FactorLexer(RegexLexer):
         'prev-float', 'ratio', 'ratio?', 'rational', 'rational?', 'real',
         'real-part', 'real?', 'recip', 'rem', 'sgn', 'shift', 'sq', 'times',
         'u<', 'u<=', 'u>', 'u>=', 'unless-zero', 'unordered?', 'when-zero',
-        'zero?'), suffix=r'\s')
+        'zero?'), suffix=r'(\s+)')
 
     builtin_sequences = words((
         '1sequence', '2all?', '2each', '2map', '2map-as', '2map-reduce', '2reduce',
@@ -129,18 +127,18 @@ class FactorLexer(RegexLexer):
         'trim-head', 'trim-head-slice', 'trim-slice', 'trim-tail', 'trim-tail-slice',
         'unclip', 'unclip-last', 'unclip-last-slice', 'unclip-slice', 'unless-empty',
         'virtual-exemplar', 'virtual-sequence', 'virtual-sequence?', 'virtual@',
-        'when-empty'), suffix=r'\s')
+        'when-empty'), suffix=r'(\s+)')
 
     builtin_namespaces = words((
         '+@', 'change', 'change-global', 'counter', 'dec', 'get', 'get-global',
         'global', 'inc', 'init-namespaces', 'initialize', 'is-global', 'make-assoc',
         'namespace', 'namestack', 'off', 'on', 'set', 'set-global', 'set-namestack',
         'toggle', 'with-global', 'with-scope', 'with-variable', 'with-variables'),
-        suffix=r'\s')
+        suffix=r'(\s+)')
 
     builtin_arrays = words((
         '1array', '2array', '3array', '4array', '<array>', '>array', 'array',
-        'array?', 'pair', 'pair?', 'resize-array'), suffix=r'\s')
+        'array?', 'pair', 'pair?', 'resize-array'), suffix=r'(\s+)')
 
     builtin_io = words((
         '(each-stream-block-slice)', '(each-stream-block)',
@@ -170,15 +168,15 @@ class FactorLexer(RegexLexer):
         'with-input-stream*', 'with-output-stream', 'with-output-stream*',
         'with-output>error', 'with-output+error-stream',
         'with-output+error-stream*', 'with-streams', 'with-streams*',
-        'write', 'write1'), suffix=r'\s')
+        'write', 'write1'), suffix=r'(\s+)')
 
     builtin_strings = words((
         '1string', '<string>', '>string', 'resize-string', 'string',
-        'string?'), suffix=r'\s')
+        'string?'), suffix=r'(\s+)')
 
     builtin_vectors = words((
         '1vector', '<vector>', '>vector', '?push', 'vector', 'vector?'),
-        suffix=r'\s')
+        suffix=r'(\s+)')
 
     builtin_continuations = words((
         '<condition>', '<continuation>', '<restart>', 'attempt-all',
@@ -190,7 +188,7 @@ class FactorLexer(RegexLexer):
         'ifcc', 'ignore-errors', 'in-callback?', 'original-error', 'recover',
         'restart', 'restart?', 'restarts', 'rethrow', 'rethrow-restarts',
         'return', 'return-continuation', 'thread-error-hook', 'throw-continue',
-        'throw-restarts', 'with-datastack', 'with-return'), suffix=r'\s')
+        'throw-restarts', 'with-datastack', 'with-return'), suffix=r'(\s+)')
 
     tokens = {
         'root': [
@@ -199,83 +197,105 @@ class FactorLexer(RegexLexer):
             default('base'),
         ],
         'base': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
 
             # defining words
             (r'((?:MACRO|MEMO|TYPED)?:[:]?)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function)),
+             bygroups(Keyword, Whitespace, Name.Function)),
             (r'(M:[:]?)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class, Text, Name.Function)),
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace,
+                 Name.Function)),
             (r'(C:)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function, Text, Name.Class)),
+             bygroups(Keyword, Whitespace, Name.Function, Whitespace,
+                 Name.Class)),
             (r'(GENERIC:)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function)),
+             bygroups(Keyword, Whitespace, Name.Function)),
             (r'(HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function, Text, Name.Function)),
-            (r'\(\s', Name.Function, 'stackeffect'),
-            (r';\s', Keyword),
+             bygroups(Keyword, Whitespace, Name.Function, Whitespace,
+                 Name.Function)),
+            (r'(\()(\s)', bygroups(Name.Function, Whitespace), 'stackeffect'),
+            (r'(;)(\s)', bygroups(Keyword, Whitespace)),
 
             # imports and namespaces
             (r'(USING:)(\s+)',
-             bygroups(Keyword.Namespace, Text), 'vocabs'),
+             bygroups(Keyword.Namespace, Whitespace), 'vocabs'),
             (r'(USE:|UNUSE:|IN:|QUALIFIED:)(\s+)(\S+)',
-             bygroups(Keyword.Namespace, Text, Name.Namespace)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace)),
             (r'(QUALIFIED-WITH:)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword.Namespace, Text, Name.Namespace, Text, Name.Namespace)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace,
+                 Whitespace, Name.Namespace)),
             (r'(FROM:|EXCLUDE:)(\s+)(\S+)(\s+=>\s)',
-             bygroups(Keyword.Namespace, Text, Name.Namespace, Text), 'words'),
-            (r'(RENAME:)(\s+)(\S+)(\s+)(\S+)(\s+=>\s+)(\S+)',
-             bygroups(Keyword.Namespace, Text, Name.Function, Text, Name.Namespace, Text, Name.Function)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace,
+                 Whitespace), 'words'),
+            (r'(RENAME:)(\s+)(\S+)(\s+)(\S+)(\s+)(=>)(\s+)(\S+)',
+             bygroups(Keyword.Namespace, Whitespace, Name.Function, Whitespace,
+                 Name.Namespace, Whitespace, Punctuation, Whitespace,
+                 Name.Function)),
             (r'(ALIAS:|TYPEDEF:)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword.Namespace, Text, Name.Function, Text, Name.Function)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Function, Whitespace,
+                 Name.Function)),
             (r'(DEFER:|FORGET:|POSTPONE:)(\s+)(\S+)',
-             bygroups(Keyword.Namespace, Text, Name.Function)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Function)),
 
             # tuples and classes
-            (r'(TUPLE:|ERROR:)(\s+)(\S+)(\s+<\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class, Text, Name.Class), 'slots'),
+            (r'(TUPLE:|ERROR:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)',
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace, Punctuation,
+                 Whitespace, Name.Class), 'slots'),
             (r'(TUPLE:|ERROR:|BUILTIN:)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class), 'slots'),
+             bygroups(Keyword, Whitespace, Name.Class), 'slots'),
             (r'(MIXIN:|UNION:|INTERSECTION:)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class)),
-            (r'(PREDICATE:)(\s+)(\S+)(\s+<\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class, Text, Name.Class)),
+             bygroups(Keyword, Whitespace, Name.Class)),
+            (r'(PREDICATE:)(\s+)(\S+)(\s+)(<)(\s+)(\S+)',
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace,
+                 Punctuation, Whitespace, Name.Class)),
             (r'(C:)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function, Text, Name.Class)),
+             bygroups(Keyword, Whitespace, Name.Function, Whitespace, Name.Class)),
             (r'(INSTANCE:)(\s+)(\S+)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Class, Text, Name.Class)),
-            (r'(SLOT:)(\s+)(\S+)', bygroups(Keyword, Text, Name.Function)),
-            (r'(SINGLETON:)(\s+)(\S+)', bygroups(Keyword, Text, Name.Class)),
+             bygroups(Keyword, Whitespace, Name.Class, Whitespace, Name.Class)),
+            (r'(SLOT:)(\s+)(\S+)', bygroups(Keyword, Whitespace, Name.Function)),
+            (r'(SINGLETON:)(\s+)(\S+)', bygroups(Keyword, Whitespace, Name.Class)),
             (r'SINGLETONS:', Keyword, 'classes'),
 
             # other syntax
             (r'(CONSTANT:|SYMBOL:|MAIN:|HELP:)(\s+)(\S+)',
-             bygroups(Keyword, Text, Name.Function)),
-            (r'SYMBOLS:\s', Keyword, 'words'),
-            (r'SYNTAX:\s', Keyword),
-            (r'ALIEN:\s', Keyword),
-            (r'(STRUCT:)(\s+)(\S+)', bygroups(Keyword, Text, Name.Class)),
-            (r'(FUNCTION:)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)',
-             bygroups(Keyword.Namespace, Text, Name.Function, Text)),
-            (r'(FUNCTION-ALIAS:)(\s+)(\S+)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)',
-             bygroups(Keyword.Namespace, Text, Name.Function, Text, Name.Function, Text)),
+             bygroups(Keyword, Whitespace, Name.Function)),
+            (r'(SYMBOLS:)(\s+)', bygroups(Keyword, Whitespace), 'words'),
+            (r'(SYNTAX:)(\s+)', bygroups(Keyword, Whitespace)),
+            (r'(ALIEN:)(\s+)', bygroups(Keyword, Whitespace)),
+            (r'(STRUCT:)(\s+)(\S+)', bygroups(Keyword, Whitespace, Name.Class)),
+            (r'(FUNCTION:)(\s+)'
+                r'(\S+)(\s+)(\S+)(\s+)'
+                r'(\()(\s+)([^)]+)(\))(\s)',
+             bygroups(Keyword.Namespace, Whitespace,
+                 Text, Whitespace, Name.Function, Whitespace,
+                 Punctuation, Whitespace, Text, Punctuation, Whitespace)),
+            (r'(FUNCTION-ALIAS:)(\s+)'
+                r'(\S+)(\s+)(\S+)(\s+)'
+                r'(\S+)(\s+)'
+                r'(\()(\s+)([^)]+)(\))(\s)',
+             bygroups(Keyword.Namespace, Whitespace,
+                 Text, Whitespace, Name.Function, Whitespace,
+                 Name.Function, Whitespace,
+                 Punctuation, Whitespace, Text, Punctuation, Whitespace)),
 
             # vocab.private
-            (r'(?:<PRIVATE|PRIVATE>)\s', Keyword.Namespace),
+            (r'(<PRIVATE|PRIVATE>)(\s)', bygroups(Keyword.Namespace, Whitespace)),
 
             # strings
             (r'"""\s(?:.|\n)*?\s"""', String),
             (r'"(?:\\\\|\\"|[^"])*"', String),
-            (r'\S+"\s+(?:\\\\|\\"|[^"])*"', String),
-            (r'CHAR:\s+(?:\\[\\abfnrstv]|[^\\]\S*)\s', String.Char),
+            (r'(\S+")(\s+)((?:\\\\|\\"|[^"])*")',
+                bygroups(String, Whitespace, String)),
+            (r'(CHAR:)(\s+)(\\[\\abfnrstv]|[^\\]\S*)(\s)',
+                bygroups(String.Char, Whitespace, String.Char, Whitespace)),
 
             # comments
             (r'!\s+.*$', Comment),
             (r'#!\s+.*$', Comment),
-            (r'/\*\s+(?:.|\n)*?\s\*/\s', Comment),
+            (r'/\*\s+(?:.|\n)*?\s\*/', Comment),
 
             # boolean constants
-            (r'[tf]\s', Name.Constant),
+            (r'[tf]\b', Name.Constant),
 
             # symbols and literals
             (r'[\\$]\s+\S+', Name.Constant),
@@ -296,48 +316,49 @@ class FactorLexer(RegexLexer):
              Keyword),
 
             # builtins
-            (builtin_kernel, Name.Builtin),
-            (builtin_assocs, Name.Builtin),
-            (builtin_combinators, Name.Builtin),
-            (builtin_math, Name.Builtin),
-            (builtin_sequences, Name.Builtin),
-            (builtin_namespaces, Name.Builtin),
-            (builtin_arrays, Name.Builtin),
-            (builtin_io, Name.Builtin),
-            (builtin_strings, Name.Builtin),
-            (builtin_vectors, Name.Builtin),
-            (builtin_continuations, Name.Builtin),
+            (builtin_kernel, bygroups(Name.Builtin, Whitespace)),
+            (builtin_assocs, bygroups(Name.Builtin, Whitespace)),
+            (builtin_combinators, bygroups(Name.Builtin, Whitespace)),
+            (builtin_math, bygroups(Name.Builtin, Whitespace)),
+            (builtin_sequences, bygroups(Name.Builtin, Whitespace)),
+            (builtin_namespaces, bygroups(Name.Builtin, Whitespace)),
+            (builtin_arrays, bygroups(Name.Builtin, Whitespace)),
+            (builtin_io, bygroups(Name.Builtin, Whitespace)),
+            (builtin_strings, bygroups(Name.Builtin, Whitespace)),
+            (builtin_vectors, bygroups(Name.Builtin, Whitespace)),
+            (builtin_continuations, bygroups(Name.Builtin, Whitespace)),
 
             # everything else is text
             (r'\S+', Text),
         ],
         'stackeffect': [
-            (r'\s+', Text),
-            (r'\(\s+', Name.Function, 'stackeffect'),
-            (r'\)\s', Name.Function, '#pop'),
-            (r'--\s', Name.Function),
+            (r'\s+', Whitespace),
+            (r'(\()(\s+)', bygroups(Name.Function, Whitespace), 'stackeffect'),
+            (r'(\))(\s+)', bygroups(Name.Function, Whitespace), '#pop'),
+            (r'(--)(\s+)', bygroups(Name.Function, Whitespace)),
             (r'\S+', Name.Variable),
         ],
         'slots': [
-            (r'\s+', Text),
-            (r';\s', Keyword, '#pop'),
-            (r'(\{\s+)(\S+)(\s[^}]+\s\}\s)',
-             bygroups(Text, Name.Variable, Text)),
+            (r'\s+', Whitespace),
+            (r'(;)(\s+)', bygroups(Keyword, Whitespace), '#pop'),
+            (r'(\{)(\s+)(\S+)(\s+)([^}]+)(\s+)(\})(\s+)',
+             bygroups(Text, Whitespace, Name.Variable, Whitespace,
+                 Text, Whitespace, Text, Whitespace)),
             (r'\S+', Name.Variable),
         ],
         'vocabs': [
-            (r'\s+', Text),
-            (r';\s', Keyword, '#pop'),
+            (r'\s+', Whitespace),
+            (r'(;)(\s+)', bygroups(Keyword, Whitespace), '#pop'),
             (r'\S+', Name.Namespace),
         ],
         'classes': [
-            (r'\s+', Text),
-            (r';\s', Keyword, '#pop'),
+            (r'\s+', Whitespace),
+            (r'(;)(\s+)', bygroups(Keyword, Whitespace), '#pop'),
             (r'\S+', Name.Class),
         ],
         'words': [
-            (r'\s+', Text),
-            (r';\s', Keyword, '#pop'),
+            (r'\s+', Whitespace),
+            (r'(;)(\s+)', bygroups(Keyword, Whitespace), '#pop'),
             (r'\S+', Name.Function),
         ],
     }

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

@@ -4,7 +4,7 @@
 
     Lexer for the Fantom 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.
 """
 
@@ -13,7 +13,7 @@ from string import Template
 from pygments.lexer import RegexLexer, include, bygroups, using, \
     this, default, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Literal
+    Number, Punctuation, Literal, Whitespace
 
 __all__ = ['FantomLexer']
 
@@ -45,10 +45,10 @@ class FantomLexer(RegexLexer):
     tokens = {
         'comments': [
             (r'(?s)/\*.*?\*/', Comment.Multiline),           # Multiline
-            (r'//.*?\n', Comment.Single),                    # Single line
+            (r'//.*?$', Comment.Single),                    # Single line
             # TODO: highlight references in fandocs
-            (r'\*\*.*?\n', Comment.Special),                 # Fandoc
-            (r'#.*\n', Comment.Single)                       # Shell-style
+            (r'\*\*.*?$', Comment.Special),                 # Fandoc
+            (r'#.*$', Comment.Single)                       # Shell-style
         ],
         'literals': [
             (r'\b-?[\d_]+(ns|ms|sec|min|hr|day)', Number),   # Duration
@@ -133,21 +133,21 @@ class FantomLexer(RegexLexer):
             include('operators'),
             (r'using\b', Keyword.Namespace, 'using'),         # Using stmt
             (r'@\w+', Name.Decorator, 'facet'),               # Symbol
-            (r'(class|mixin)(\s+)(\w+)', bygroups(Keyword, Text, Name.Class),
+            (r'(class|mixin)(\s+)(\w+)', bygroups(Keyword, Whitespace, Name.Class),
              'inheritance'),                                  # Inheritance list
 
             # Type var := val
             (s(r'($type)([ \t]+)($id)(\s*)(:=)'),
-             bygroups(using(this, state='inType'), Text,
-                      Name.Variable, Text, Operator)),
+             bygroups(using(this, state='inType'), Whitespace,
+                      Name.Variable, Whitespace, Operator)),
 
             # var := val
             (s(r'($id)(\s*)(:=)'),
-             bygroups(Name.Variable, Text, Operator)),
+             bygroups(Name.Variable, Whitespace, Operator)),
 
             # .someId( or ->someId( ###
             (s(r'(\.|(?:\->))($id)(\s*)(\()'),
-             bygroups(Operator, Name.Function, Text, Punctuation),
+             bygroups(Operator, Name.Function, Whitespace, Punctuation),
              'insideParen'),
 
             # .someId  or ->someId
@@ -156,42 +156,43 @@ class FantomLexer(RegexLexer):
 
             # new makeXXX (
             (r'(new)(\s+)(make\w*)(\s*)(\()',
-             bygroups(Keyword, Text, Name.Function, Text, Punctuation),
+             bygroups(Keyword, Whitespace, Name.Function, Whitespace, Punctuation),
              'insideMethodDeclArgs'),
 
             # Type name (
             (s(r'($type)([ \t]+)'  # Return type and whitespace
                r'($id)(\s*)(\()'),  # method name + open brace
-             bygroups(using(this, state='inType'), Text,
-                      Name.Function, Text, Punctuation),
+             bygroups(using(this, state='inType'), Whitespace,
+                      Name.Function, Whitespace, Punctuation),
              'insideMethodDeclArgs'),
 
             # ArgType argName,
             (s(r'($type)(\s+)($id)(\s*)(,)'),
-             bygroups(using(this, state='inType'), Text, Name.Variable,
-                      Text, Punctuation)),
+             bygroups(using(this, state='inType'), Whitespace, Name.Variable,
+                      Whitespace, Punctuation)),
 
             # ArgType argName)
             # Covered in 'insideParen' state
 
             # ArgType argName -> ArgType|
             (s(r'($type)(\s+)($id)(\s*)(\->)(\s*)($type)(\|)'),
-             bygroups(using(this, state='inType'), Text, Name.Variable,
-                      Text, Punctuation, Text, using(this, state='inType'),
+             bygroups(using(this, state='inType'), Whitespace, Name.Variable,
+                      Whitespace, Punctuation, Whitespace, using(this, state='inType'),
                       Punctuation)),
 
             # ArgType argName|
             (s(r'($type)(\s+)($id)(\s*)(\|)'),
-             bygroups(using(this, state='inType'), Text, Name.Variable,
-                      Text, Punctuation)),
+             bygroups(using(this, state='inType'), Whitespace, Name.Variable,
+                      Whitespace, Punctuation)),
 
             # Type var
             (s(r'($type)([ \t]+)($id)'),
-             bygroups(using(this, state='inType'), Text,
+             bygroups(using(this, state='inType'), Whitespace,
                       Name.Variable)),
 
             (r'\(', Punctuation, 'insideParen'),
             (r'\{', Punctuation, 'insideBrace'),
+            (r'\s+', Whitespace),
             (r'.', Text)
         ],
         'insideParen': [
@@ -201,8 +202,8 @@ class FantomLexer(RegexLexer):
         'insideMethodDeclArgs': [
             (r'\)', Punctuation, '#pop'),
             (s(r'($type)(\s+)($id)(\s*)(\))'),
-             bygroups(using(this, state='inType'), Text, Name.Variable,
-                      Text, Punctuation), '#pop'),
+             bygroups(using(this, state='inType'), Whitespace, Name.Variable,
+                      Whitespace, Punctuation), '#pop'),
             include('root'),
         ],
         'insideBrace': [
@@ -210,14 +211,14 @@ class FantomLexer(RegexLexer):
             include('root'),
         ],
         'inheritance': [
-            (r'\s+', Text),                                      # Whitespace
+            (r'\s+', Whitespace),                                      # Whitespace
             (r':|,', Punctuation),
             (r'(?:(\w+)(::))?(\w+)',
              bygroups(Name.Namespace, Punctuation, Name.Class)),
             (r'\{', Punctuation, '#pop')
         ],
         'using': [
-            (r'[ \t]+', Text),  # consume whitespaces
+            (r'[ \t]+', Whitespace),  # consume whitespaces
             (r'(\[)(\w+)(\])',
              bygroups(Punctuation, Comment.Special, Punctuation)),  # ffi
             (r'(\")?([\w.]+)(\")?',
@@ -226,14 +227,14 @@ class FantomLexer(RegexLexer):
             default('#pop')
         ],
         'usingClass': [
-            (r'[ \t]+', Text),  # consume whitespaces
+            (r'[ \t]+', Whitespace),  # consume whitespaces
             (r'(as)(\s+)(\w+)',
-             bygroups(Keyword.Declaration, Text, Name.Class), '#pop:2'),
+             bygroups(Keyword.Declaration, Whitespace, Name.Class), '#pop:2'),
             (r'[\w$]+', Name.Class),
             default('#pop:2')  # jump out to root state
         ],
         'facet': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\{', Punctuation, 'facetFields'),
             default('#pop')
         ],
@@ -241,9 +242,10 @@ class FantomLexer(RegexLexer):
             include('comments'),
             include('literals'),
             include('operators'),
-            (r'\s+', Text),
-            (r'(\s*)(\w+)(\s*)(=)', bygroups(Text, Name, Text, Operator)),
+            (r'\s+', Whitespace),
+            (r'(\s*)(\w+)(\s*)(=)', bygroups(Whitespace, Name, Whitespace, Operator)),
             (r'\}', Punctuation, '#pop'),
+            (r'\s+', Whitespace),
             (r'.', Text)
         ],
     }

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

@@ -4,26 +4,27 @@
 
     Lexer for the Felix 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, bygroups, default, words, \
     combined
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['FelixLexer']
 
 
 class FelixLexer(RegexLexer):
     """
-    For `Felix <http://www.felix-lang.org>`_ source code.
+    For Felix source code.
 
     .. versionadded:: 1.2
     """
 
     name = 'Felix'
+    url = 'http://www.felix-lang.org'
     aliases = ['felix', 'flx']
     filenames = ['*.flx', '*.flxh']
     mimetypes = ['text/x-felix']
@@ -157,13 +158,14 @@ class FelixLexer(RegexLexer):
             (r'[a-zA-Z_]\w*', Name),
         ],
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
 
             include('comment'),
 
             # Preprocessor
-            (r'#\s*if\s+0', Comment.Preproc, 'if0'),
+            (r'(#)(\s*)(if)(\s+)(0)',
+                bygroups(Comment.Preproc, Whitespace, Comment.Preproc,
+                    Whitespace, Comment.Preproc), 'if0'),
             (r'#', Comment.Preproc, 'macro'),
         ],
         'operators': [
@@ -171,7 +173,7 @@ class FelixLexer(RegexLexer):
             (r'!=|==|<<|>>|\|\||&&|[-~+/*%=<>&^|.$]', Operator),
         ],
         'comment': [
-            (r'//(.*?)\n', Comment.Single),
+            (r'//(.*?)$', Comment.Single),
             (r'/[*]', Comment.Multiline, 'comment2'),
         ],
         'comment2': [
@@ -181,24 +183,26 @@ class FelixLexer(RegexLexer):
             (r'[/*]', Comment.Multiline),
         ],
         'if0': [
-            (r'^\s*#if.*?(?<!\\)\n', Comment, '#push'),
-            (r'^\s*#endif.*?(?<!\\)\n', Comment, '#pop'),
-            (r'.*?\n', Comment),
+            (r'^(\s*)(#if.*?(?<!\\))(\n)',
+                bygroups(Whitespace, Comment, Whitespace), '#push'),
+            (r'^(\s*)(#endif.*?(?<!\\))(\n)',
+                bygroups(Whitespace, Comment, Whitespace), '#pop'),
+            (r'(.*?)(\n)', bygroups(Comment, Whitespace)),
         ],
         'macro': [
             include('comment'),
             (r'(import|include)(\s+)(<[^>]*?>)',
-             bygroups(Comment.Preproc, Text, String), '#pop'),
+             bygroups(Comment.Preproc, Whitespace, String), '#pop'),
             (r'(import|include)(\s+)("[^"]*?")',
-             bygroups(Comment.Preproc, Text, String), '#pop'),
+             bygroups(Comment.Preproc, Whitespace, String), '#pop'),
             (r"(import|include)(\s+)('[^']*?')",
-             bygroups(Comment.Preproc, Text, String), '#pop'),
+             bygroups(Comment.Preproc, Whitespace, String), '#pop'),
             (r'[^/\n]+', Comment.Preproc),
             # (r'/[*](.|\n)*?[*]/', Comment),
             # (r'//.*?\n', Comment, '#pop'),
             (r'/', Comment.Preproc),
             (r'(?<=\\)\n', Comment.Preproc),
-            (r'\n', Comment.Preproc, '#pop'),
+            (r'\n', Whitespace, '#pop'),
         ],
         'funcname': [
             include('whitespace'),