pygments.rb 2.3.1 → 2.4.0

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

@@ -4,7 +4,7 @@
 
     Lexers for BASIC like languages (other than VB.net).
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -22,12 +22,13 @@ __all__ = ['BlitzBasicLexer', 'BlitzMaxLexer', 'MonkeyLexer', 'CbmBasicV2Lexer',
 
 class BlitzMaxLexer(RegexLexer):
     """
-    For `BlitzMax <http://blitzbasic.com>`_ source code.
+    For BlitzMax source code.
 
     .. versionadded:: 1.4
     """
 
     name = 'BlitzMax'
+    url = 'http://blitzbasic.com'
     aliases = ['blitzmax', 'bmax']
     filenames = ['*.bmx']
     mimetypes = ['text/x-bmx']
@@ -45,8 +46,8 @@ class BlitzMaxLexer(RegexLexer):
     tokens = {
         'root': [
             # Text
-            (r'[ \t]+', Text),
-            (r'\.\.\n', Text),  # Line continuation
+            (r'\s+', Whitespace),
+            (r'(\.\.)(\n)', bygroups(Text, Whitespace)),  # Line continuation
             # Comments
             (r"'.*?\n", Comment.Single),
             (r'([ \t]*)\bRem\n(\n|.)*?\s*\bEnd([ \t]*)Rem', Comment.Multiline),
@@ -66,19 +67,19 @@ class BlitzMaxLexer(RegexLexer):
             (r'(?:\?[\w \t]*)', Comment.Preproc),
             # Identifiers
             (r'\b(New)\b([ \t]?)([(]?)(%s)' % (bmax_name),
-             bygroups(Keyword.Reserved, Text, Punctuation, Name.Class)),
+             bygroups(Keyword.Reserved, Whitespace, Punctuation, Name.Class)),
             (r'\b(Import|Framework|Module)([ \t]+)(%s\.%s)' %
              (bmax_name, bmax_name),
-             bygroups(Keyword.Reserved, Text, Keyword.Namespace)),
-            (bmax_func, bygroups(Name.Function, Text, Keyword.Type,
-                                 Operator, Text, Punctuation, Text,
-                                 Keyword.Type, Name.Class, Text,
-                                 Keyword.Type, Text, Punctuation)),
-            (bmax_var, bygroups(Name.Variable, Text, Keyword.Type, Operator,
-                                Text, Punctuation, Text, Keyword.Type,
-                                Name.Class, Text, Keyword.Type)),
+             bygroups(Keyword.Reserved, Whitespace, Keyword.Namespace)),
+            (bmax_func, bygroups(Name.Function, Whitespace, Keyword.Type,
+                                 Operator, Whitespace, Punctuation, Whitespace,
+                                 Keyword.Type, Name.Class, Whitespace,
+                                 Keyword.Type, Whitespace, Punctuation)),
+            (bmax_var, bygroups(Name.Variable, Whitespace, Keyword.Type, Operator,
+                                Whitespace, Punctuation, Whitespace, Keyword.Type,
+                                Name.Class, Whitespace, Keyword.Type)),
             (r'\b(Type|Extends)([ \t]+)(%s)' % (bmax_name),
-             bygroups(Keyword.Reserved, Text, Name.Class)),
+             bygroups(Keyword.Reserved, Whitespace, Name.Class)),
             # Keywords
             (r'\b(Ptr)\b', Keyword.Type),
             (r'\b(Pi|True|False|Null|Self|Super)\b', Keyword.Constant),
@@ -113,12 +114,13 @@ class BlitzMaxLexer(RegexLexer):
 
 class BlitzBasicLexer(RegexLexer):
     """
-    For `BlitzBasic <http://blitzbasic.com>`_ source code.
+    For BlitzBasic source code.
 
     .. versionadded:: 2.0
     """
 
     name = 'BlitzBasic'
+    url = 'http://blitzbasic.com'
     aliases = ['blitzbasic', 'b3d', 'bplus']
     filenames = ['*.bb', '*.decls']
     mimetypes = ['text/x-bb']
@@ -132,7 +134,7 @@ class BlitzBasicLexer(RegexLexer):
     tokens = {
         'root': [
             # Text
-            (r'[ \t]+', Text),
+            (r'\s+', Whitespace),
             # Comments
             (r";.*?\n", Comment.Single),
             # Data types
@@ -154,19 +156,19 @@ class BlitzBasicLexer(RegexLexer):
             (r'\.([ \t]*)(%s)' % bb_name, Name.Label),
             # Identifiers
             (r'\b(New)\b([ \t]+)(%s)' % (bb_name),
-             bygroups(Keyword.Reserved, Text, Name.Class)),
+             bygroups(Keyword.Reserved, Whitespace, Name.Class)),
             (r'\b(Gosub|Goto)\b([ \t]+)(%s)' % (bb_name),
-             bygroups(Keyword.Reserved, Text, Name.Label)),
+             bygroups(Keyword.Reserved, Whitespace, Name.Label)),
             (r'\b(Object)\b([ \t]*)([.])([ \t]*)(%s)\b' % (bb_name),
-             bygroups(Operator, Text, Punctuation, Text, Name.Class)),
+             bygroups(Operator, Whitespace, Punctuation, Whitespace, Name.Class)),
             (r'\b%s\b([ \t]*)(\()' % bb_var,
-             bygroups(Name.Function, Text, Keyword.Type, Text, Punctuation,
-                      Text, Name.Class, Text, Punctuation)),
+             bygroups(Name.Function, Whitespace, Keyword.Type, Whitespace, Punctuation,
+                      Whitespace, Name.Class, Whitespace, Punctuation)),
             (r'\b(Function)\b([ \t]+)%s' % bb_var,
-             bygroups(Keyword.Reserved, Text, Name.Function, Text, Keyword.Type,
-                      Text, Punctuation, Text, Name.Class)),
+             bygroups(Keyword.Reserved, Whitespace, Name.Function, Whitespace, Keyword.Type,
+                      Whitespace, Punctuation, Whitespace, Name.Class)),
             (r'\b(Type)([ \t]+)(%s)' % (bb_name),
-             bygroups(Keyword.Reserved, Text, Name.Class)),
+             bygroups(Keyword.Reserved, Whitespace, Name.Class)),
             # Keywords
             (r'\b(Pi|True|False|Null)\b', Keyword.Constant),
             (r'\b(Local|Global|Const|Field|Dim)\b', Keyword.Declaration),
@@ -179,13 +181,13 @@ class BlitzBasicLexer(RegexLexer):
              Keyword.Reserved),
             # Final resolve (for variable names and such)
             # (r'(%s)' % (bb_name), Name.Variable),
-            (bb_var, bygroups(Name.Variable, Text, Keyword.Type,
-                              Text, Punctuation, Text, Name.Class)),
+            (bb_var, bygroups(Name.Variable, Whitespace, Keyword.Type,
+                              Whitespace, Punctuation, Whitespace, Name.Class)),
         ],
         'string': [
             (r'""', String.Double),
             (r'"C?', String.Double, '#pop'),
-            (r'[^"]+', String.Double),
+            (r'[^"\n]+', String.Double),
         ],
     }
 
@@ -219,7 +221,7 @@ class MonkeyLexer(RegexLexer):
     tokens = {
         'root': [
             # Text
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             # Comments
             (r"'.*", Comment),
             (r'(?i)^#rem\b', Comment.Multiline, 'comment'),
@@ -246,14 +248,14 @@ class MonkeyLexer(RegexLexer):
             (r'\b(?:HOST|LANG|TARGET|CONFIG)\b', Name.Constant),
             # Keywords
             (r'(?i)^(Import)(\s+)(.*)(\n)',
-             bygroups(Keyword.Namespace, Text, Name.Namespace, Text)),
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace, Whitespace)),
             (r'(?i)^Strict\b.*\n', Keyword.Reserved),
             (r'(?i)(Const|Local|Global|Field)(\s+)',
-             bygroups(Keyword.Declaration, Text), 'variables'),
+             bygroups(Keyword.Declaration, Whitespace), 'variables'),
             (r'(?i)(New|Class|Interface|Extends|Implements)(\s+)',
-             bygroups(Keyword.Reserved, Text), 'classname'),
+             bygroups(Keyword.Reserved, Whitespace), 'classname'),
             (r'(?i)(Function|Method)(\s+)',
-             bygroups(Keyword.Reserved, Text), 'funcname'),
+             bygroups(Keyword.Reserved, Whitespace), 'funcname'),
             (r'(?i)(?:End|Return|Public|Private|Extern|Property|'
              r'Final|Abstract)\b', Keyword.Reserved),
             # Flow Control stuff
@@ -262,7 +264,7 @@ class MonkeyLexer(RegexLexer):
              r'While|Wend|'
              r'Repeat|Until|Forever|'
              r'For|To|Until|Step|EachIn|Next|'
-             r'Exit|Continue)\s+', Keyword.Reserved),
+             r'Exit|Continue)(?=\s)', Keyword.Reserved),
             # not used yet
             (r'(?i)\b(?:Module|Inline)\b', Keyword.Reserved),
             # Array
@@ -279,7 +281,7 @@ class MonkeyLexer(RegexLexer):
         'funcname': [
             (r'(?i)%s\b' % name_function, Name.Function),
             (r':', Punctuation, 'classname'),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\(', Punctuation, 'variables'),
             (r'\)', Punctuation, '#pop')
         ],
@@ -289,19 +291,19 @@ class MonkeyLexer(RegexLexer):
             (r'%s\b' % name_class, Name.Class),
             # array (of given size)
             (r'(\[)(\s*)(\d*)(\s*)(\])',
-             bygroups(Punctuation, Text, Number.Integer, Text, Punctuation)),
+             bygroups(Punctuation, Whitespace, Number.Integer, Whitespace, Punctuation)),
             # generics
-            (r'\s+(?!<)', Text, '#pop'),
+            (r'\s+(?!<)', Whitespace, '#pop'),
             (r'<', Punctuation, '#push'),
             (r'>', Punctuation, '#pop'),
-            (r'\n', Text, '#pop'),
+            (r'\n', Whitespace, '#pop'),
             default('#pop')
         ],
         'variables': [
             (r'%s\b' % name_constant, Name.Constant),
             (r'%s\b' % name_variable, Name.Variable),
             (r'%s' % keyword_type_special, Keyword.Type),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r':', Punctuation, 'classname'),
             (r',', Punctuation, '#push'),
             default('#pop')
@@ -335,7 +337,7 @@ class CbmBasicV2Lexer(RegexLexer):
     tokens = {
         'root': [
             (r'rem.*\n', Comment.Single),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'new|run|end|for|to|next|step|go(to|sub)?|on|return|stop|cont'
              r'|if|then|input#?|read|wait|load|save|verify|poke|sys|print#?'
              r'|list|clr|cmd|open|close|get#?', Keyword.Reserved),
@@ -623,7 +625,8 @@ class BBCBasicLexer(RegexLexer):
 
             # Some special cases to make functions come out nicer
             (r'(DEF)(\s*)(FN|PROC)([A-Za-z_@][\w@]*)',
-             bygroups(Keyword.Declaration, Whitespace, Keyword.Declaration, Name.Function)),
+             bygroups(Keyword.Declaration, Whitespace,
+                      Keyword.Declaration, Name.Function)),
             (r'(FN|PROC)([A-Za-z_@][\w@]*)',
              bygroups(Keyword, Name.Function)),
 
@@ -631,7 +634,8 @@ class BBCBasicLexer(RegexLexer):
              bygroups(Keyword, Whitespace, Name.Label)),
 
             (r'(TRUE|FALSE)', Keyword.Constant),
-            (r'(PAGE|LOMEM|HIMEM|TIME|WIDTH|ERL|ERR|REPORT\$|POS|VPOS|VOICES)', Keyword.Pseudo),
+            (r'(PAGE|LOMEM|HIMEM|TIME|WIDTH|ERL|ERR|REPORT\$|POS|VPOS|VOICES)',
+             Keyword.Pseudo),
 
             (words(base_keywords), Keyword),
             (words(basic5_keywords), Keyword),

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

@@ -0,0 +1,58 @@
+"""
+    pygments.lexers.bdd
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexer for BDD(Behavior-driven development).
+    More information: https://en.wikipedia.org/wiki/Behavior-driven_development
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include
+from pygments.token import Comment, Keyword, Name, String, Number, Text, \
+    Punctuation, Whitespace
+
+__all__ = ['BddLexer']
+
+class BddLexer(RegexLexer):
+    """
+    Lexer for BDD(Behavior-driven development), which highlights not only
+    keywords, but also comments, punctuations, strings, numbers, and variables.
+
+    .. versionadded:: 2.11
+    """
+
+    name = 'Bdd'
+    aliases = ['bdd']
+    filenames = ['*.feature']
+    mimetypes = ['text/x-bdd']
+
+    step_keywords = (r'Given|When|Then|Add|And|Feature|Scenario Outline|'
+                     r'Scenario|Background|Examples|But')
+
+    tokens = {
+        'comments': [
+            (r'^\s*#.*$', Comment),
+        ],
+        'miscellaneous': [
+            (r'(<|>|\[|\]|=|\||:|\(|\)|\{|\}|,|\.|;|-|_|\$)', Punctuation),
+            (r'((?<=\<)[^\\>]+(?=\>))', Name.Variable),
+            (r'"([^\"]*)"', String),
+            (r'^@\S+', Name.Label),
+        ],
+        'numbers': [
+            (r'(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number),
+        ],
+        'root': [
+            (r'\n|\s+', Whitespace),
+            (step_keywords, Keyword),
+            include('comments'),
+            include('miscellaneous'),
+            include('numbers'),
+            (r'\S+', Text),
+        ]
+    }
+
+    def analyse_text(self, text):
+        return

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

@@ -0,0 +1,99 @@
+"""
+    pygments.lexers.berry
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for Berry.
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words, include, bygroups
+from pygments.token import Comment, Whitespace, Operator, Keyword, Name, \
+    String, Number, Punctuation
+
+__all__ = ['BerryLexer']
+
+
+class BerryLexer(RegexLexer):
+    """
+    For `berry <http://github.com/berry-lang/berry>`_ source code.
+
+    .. versionadded:: 2.12.0
+    """
+    name = 'Berry'
+    aliases = ['berry', 'be']
+    filenames = ['*.be']
+    mimetypes = ['text/x-berry', 'application/x-berry']
+
+    _name = r'\b[^\W\d]\w*'
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            include('numbers'),
+            include('keywords'),
+            (rf'(def)(\s+)({_name})',
+             bygroups(Keyword.Declaration, Whitespace, Name.Function)),
+            (rf'\b(class)(\s+)({_name})',
+             bygroups(Keyword.Declaration, Whitespace, Name.Class)),
+            (rf'\b(import)(\s+)({_name})',
+             bygroups(Keyword.Namespace, Whitespace, Name.Namespace)),
+            include('expr')
+        ],
+        'expr': [
+            (r'[^\S\n]+', Whitespace),
+            (r'\.\.|[~!%^&*+=|?:<>/-]', Operator),
+            (r'[(){}\[\],.;]', Punctuation),
+            include('controls'),
+            include('builtins'),
+            include('funccall'),
+            include('member'),
+            include('name'),
+            include('strings')
+        ],
+        'whitespace': [
+            (r'\s+', Whitespace),
+            (r'#-(.|\n)*?-#', Comment.Multiline),
+            (r'#.*?$', Comment.Single)
+        ],
+        'keywords': [
+            (words((
+                'as', 'break', 'continue', 'import', 'static', 'self', 'super'),
+                suffix=r'\b'), Keyword.Reserved),
+            (r'(true|false|nil)\b', Keyword.Constant),
+            (r'(var|def)\b', Keyword.Declaration)
+        ],
+        'controls': [
+            (words((
+                'if', 'elif', 'else', 'for', 'while', 'do', 'end', 'break',
+                'continue', 'return', 'try', 'except', 'raise'),
+                suffix=r'\b'), Keyword)
+        ],
+        'builtins': [
+            (words((
+                'assert', 'bool', 'input', 'classname', 'classof', 'number', 'real',
+                'bytes', 'compile', 'map', 'list', 'int', 'isinstance', 'print',
+                'range', 'str', 'super', 'module', 'size', 'issubclass', 'open',
+                'file', 'type', 'call'),
+                suffix=r'\b'), Name.Builtin)
+        ],
+        'numbers': [
+            (r'0[xX][a-fA-F0-9]+', Number.Hex),
+            (r'-?\d+', Number.Integer),
+            (r'(-?\d+\.?|\.\d)\d*([eE][+-]?\d+)?', Number.Float)
+        ],
+        'name': [
+            (_name, Name)
+        ],
+        'funccall': [
+            (rf'{_name}(?=\s*\()', Name.Function, '#pop')
+        ],
+        'member': [
+            (rf'(?<=\.){_name}\b(?!\()', Name.Attribute, '#pop')
+        ],
+        'strings': [
+            (r'"([^\\]|\\.)*?"', String.Double, '#pop'),
+            (r'\'([^\\]|\\.)*?\'', String.Single, '#pop')
+        ]
+    }

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

@@ -4,7 +4,7 @@
 
     Lexers for BibTeX bibliography data and styles
 
-    :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,8 +12,8 @@ import re
 
 from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, default, \
     words
-from pygments.token import Name, Comment, String, Error, Number, Text, \
-    Keyword, Punctuation
+from pygments.token import Name, Comment, String, Error, Number, Keyword, \
+    Punctuation, Whitespace
 
 __all__ = ['BibTeXLexer', 'BSTLexer']
 
@@ -55,7 +55,7 @@ class BibTeXLexer(ExtendedRegexLexer):
     tokens = {
         'root': [
             include('whitespace'),
-            ('@comment', Comment),
+            (r'@comment(?!ary)', Comment),
             ('@preamble', Name.Class, ('closing-brace', 'value', 'opening-brace')),
             ('@string', Name.Class, ('closing-brace', 'field', 'opening-brace')),
             ('@' + IDENTIFIER, Name.Class,
@@ -108,7 +108,7 @@ class BibTeXLexer(ExtendedRegexLexer):
             (r'[^\{\}]+', String),
         ],
         'whitespace': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
     }
 
@@ -153,7 +153,7 @@ class BSTLexer(RegexLexer):
             default('#pop'),
         ],
         'whitespace': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             ('%.*?$', Comment.Single),
         ],
     }

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

@@ -4,20 +4,16 @@
 
     Lexers for the Boa 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, words
-from pygments.token import String, Comment, Keyword, Name, Number, Text, \
-    Operator, Punctuation
+from pygments.token import String, Comment, Keyword, Name, Number, Operator, \
+    Punctuation, Whitespace
 
 __all__ = ['BoaLexer']
 
-line_re = re.compile('.*?\n')
-
 
 class BoaLexer(RegexLexer):
     """
@@ -96,6 +92,6 @@ class BoaLexer(RegexLexer):
             (words(string_sep), String.Delimiter),
             (r'[a-zA-Z_]+', Name.Variable),
             (r'[0-9]+', Number.Integer),
-            (r'\s+?', Text),  # Whitespace
+            (r'\s+', Whitespace),  # Whitespace
         ]
     }

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

@@ -4,7 +4,7 @@
 
     Lexers for "business-oriented" languages.
 
-    :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, words, bygroups
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error
+    Number, Punctuation, Error, Whitespace
 
 from pygments.lexers._openedge_builtins import OPENEDGEKEYWORDS
 
@@ -49,7 +49,7 @@ class CobolLexer(RegexLexer):
             include('nums'),
             (r'[a-z0-9]([\w\-]*[a-z0-9]+)?', Name.Variable),
             # (r'[\s]+', Text),
-            (r'[ \t]+', Text),
+            (r'[ \t]+', Whitespace),
         ],
         'comment': [
             (r'(^.{6}[*/].*\n|^.{6}|\*>.*\n)', Comment),
@@ -129,7 +129,7 @@ class CobolLexer(RegexLexer):
                 'SEQUENCE', 'SEQUENTIAL', 'SHARING', 'SIGN', 'SIGNED', 'SIGNED-INT',
                 'SIGNED-LONG', 'SIGNED-SHORT', 'SIZE', 'SORT-MERGE', 'SOURCE',
                 'SOURCE-COMPUTER', 'SPECIAL-NAMES', 'STANDARD',
-                'STANDARD-1', 'STANDARD-2', 'STATUS', 'SUM',
+                'STANDARD-1', 'STANDARD-2', 'STATUS', 'SUBKEY', 'SUM',
                 'SYMBOLIC', 'SYNC', 'SYNCHRONIZED', 'TALLYING', 'TAPE',
                 'TEST', 'THROUGH', 'THRU', 'TIME', 'TIMES', 'TO', 'TOP', 'TRAILING',
                 'TRANSFORM', 'TYPE', 'UNDERLINE', 'UNIT', 'UNSIGNED',
@@ -252,7 +252,7 @@ class ABAPLexer(RegexLexer):
 
     tokens = {
         'common': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'^\*.*$', Comment.Single),
             (r'\".*?\n', Comment.Single),
             (r'##\w+', Comment.Special),
@@ -270,18 +270,18 @@ class ABAPLexer(RegexLexer):
              r'TRANSACTION|TRANSFORMATION))\b',
              Keyword),
             (r'(FORM|PERFORM)(\s+)(\w+)',
-             bygroups(Keyword, Text, Name.Function)),
+             bygroups(Keyword, Whitespace, Name.Function)),
             (r'(PERFORM)(\s+)(\()(\w+)(\))',
-             bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation)),
+             bygroups(Keyword, Whitespace, Punctuation, Name.Variable, Punctuation)),
             (r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)',
-             bygroups(Keyword, Text, Name.Function, Text, Keyword)),
+             bygroups(Keyword, Whitespace, Name.Function, Whitespace, Keyword)),
 
             # method implementation
             (r'(METHOD)(\s+)([\w~]+)',
-             bygroups(Keyword, Text, Name.Function)),
+             bygroups(Keyword, Whitespace, Name.Function)),
             # method calls
             (r'(\s+)([\w\-]+)([=\-]>)([\w\-~]+)',
-             bygroups(Text, Name.Variable, Operator, Name.Function)),
+             bygroups(Whitespace, Name.Variable, Operator, Name.Function)),
             # call methodnames returning style
             (r'(?<=(=|-)>)([\w\-~]+)(?=\()', Name.Function),
 
@@ -299,7 +299,7 @@ class ABAPLexer(RegexLexer):
              r'CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|'
              r'DELETE-ADJACENT|DIVIDE-CORRESPONDING|'
              r'EDITOR-CALL|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|EXIT-COMMAND|'
-             r'FIELD-GROUPS|FIELD-SYMBOLS|FUNCTION-POOL|'
+             r'FIELD-GROUPS|FIELD-SYMBOLS|FIELD-SYMBOL|FUNCTION-POOL|'
              r'INTERFACE-POOL|INVERTED-DATE|'
              r'LOAD-OF-PROGRAM|LOG-POINT|'
              r'MESSAGE-ID|MOVE-CORRESPONDING|MULTIPLY-CORRESPONDING|'
@@ -373,7 +373,7 @@ class ABAPLexer(RegexLexer):
             (r'(^|(?<=(\s|\.)))(ABBREVIATED|ABSTRACT|ADD|ALIASES|ALIGN|ALPHA|'
              r'ASSERT|AS|ASSIGN(ING)?|AT(\s+FIRST)?|'
              r'BACK|BLOCK|BREAK-POINT|'
-             r'CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|'
+             r'CASE|CAST|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|COND|CONV|'
              r'CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|'
              r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|COUNTRY|CURRENCY|'
              r'DATA|DATE|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|'
@@ -388,15 +388,15 @@ class ABAPLexer(RegexLexer):
              r'LANGUAGE|LEAVE|LENGTH|LINES|LOAD|LOCAL|'
              r'JOIN|'
              r'KEY|'
-             r'NEXT|'
+             r'NEW|NEXT|'
              r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFIER|MODIFY|MOVE|MULTIPLY|'
              r'NODES|NUMBER|'
              r'OBLIGATORY|OBJECT|OF|OFF|ON|OTHERS|OVERLAY|'
              r'PACK|PAD|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|PF\d\d|'
              r'RAISE|RAISING|RANGES?|READ|RECEIVE|REDEFINITION|REFRESH|REJECT|REPORT|RESERVE|'
-             r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|REPLACE|'
+             r'REF|RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|REPLACE|'
              r'SCROLL|SEARCH|SELECT|SHIFT|SIGN|SINGLE|SIZE|SKIP|SORT|SPLIT|STATICS|STOP|'
-             r'STYLE|SUBMATCHES|SUBMIT|SUBTRACT|SUM(?!\()|SUMMARY|SUMMING|SUPPLY|'
+             r'STYLE|SUBMATCHES|SUBMIT|SUBTRACT|SUM(?!\()|SUMMARY|SUMMING|SUPPLY|SWITCH|'
              r'TABLE|TABLES|TIMESTAMP|TIMES?|TIMEZONE|TITLE|\??TO|'
              r'TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|'
              r'ULINE|UNDER|UNPACK|UPDATE|USING|'
@@ -481,7 +481,7 @@ class OpenEdgeLexer(RegexLexer):
             (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'[0-9]+', Number.Integer),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[+*/=-]', Operator),
             (r'[.:()]', Punctuation),
             (r'.', Name.Variable),  # Lazy catch-all
@@ -552,7 +552,7 @@ com/gooddata/processor/COMMANDS.txt>`_
             (r'"', String, 'string-literal'),
             (r'[0-9]+(?:\.[0-9]+)?(?:e[+-]?[0-9]{1,3})?', Number),
             # Space is not significant
-            (r'\s', Text)
+            (r'\s', Whitespace)
         ],
         'string-literal': [
             (r'\\[tnrfbae"\\]', String.Escape),
@@ -616,7 +616,7 @@ class MaqlLexer(RegexLexer):
             # Punctuation
             (r'[,;()]', Punctuation),
             # Space is not significant
-            (r'\s+', Text)
+            (r'\s+', Whitespace)
         ],
         'string-literal': [
             (r'\\[tnrfbae"\\]', String.Escape),