pygments.rb 2.3.1 → 2.4.0

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

@@ -4,13 +4,13 @@
 
     Lexers for graph query 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.
 """
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, using, this
+from pygments.lexer import RegexLexer, include, bygroups, using, this, words
 from pygments.token import Keyword, Punctuation, Comment, Operator, Name,\
     String, Number, Whitespace
 
@@ -20,14 +20,14 @@ __all__ = ['CypherLexer']
 
 class CypherLexer(RegexLexer):
     """
-    For `Cypher Query Language
-    <https://neo4j.com/docs/developer-manual/3.3/cypher/>`_
+    For Cypher Query Language
 
     For the Cypher version in Neo4j 3.3
 
     .. versionadded:: 2.0
     """
     name = 'Cypher'
+    url = 'https://neo4j.com/docs/developer-manual/3.3/cypher/'
     aliases = ['cypher']
     filenames = ['*.cyp', '*.cypher']
 
@@ -36,15 +36,15 @@ class CypherLexer(RegexLexer):
     tokens = {
         'root': [
             include('comment'),
-            include('keywords'),
             include('clauses'),
+            include('keywords'),
             include('relations'),
             include('strings'),
             include('whitespace'),
             include('barewords'),
         ],
         'comment': [
-            (r'^.*//.*\n', Comment.Single),
+            (r'^.*//.*$', Comment.Single),
         ],
         'keywords': [
             (r'(create|order|match|limit|set|skip|start|return|with|where|'
@@ -52,15 +52,36 @@ class CypherLexer(RegexLexer):
         ],
         'clauses': [
             # based on https://neo4j.com/docs/cypher-refcard/3.3/
-            (r'(all|any|as|asc|ascending|assert|call|case|create|'
-             r'create\s+index|create\s+unique|delete|desc|descending|'
-             r'distinct|drop\s+constraint\s+on|drop\s+index\s+on|end|'
-             r'ends\s+with|fieldterminator|foreach|in|is\s+node\s+key|'
-             r'is\s+null|is\s+unique|limit|load\s+csv\s+from|match|merge|none|'
-             r'not|null|on\s+match|on\s+create|optional\s+match|order\s+by|'
-             r'remove|return|set|skip|single|start|starts\s+with|then|union|'
-             r'union\s+all|unwind|using\s+periodic\s+commit|yield|where|when|'
-             r'with)\b', Keyword),
+            (r'(create)(\s+)(index|unique)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(drop)(\s+)(contraint|index)(\s+)(on)\b',
+                bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword)),
+            (r'(ends)(\s+)(with)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(is)(\s+)(node)(\s+)(key)\b',
+                bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword)),
+            (r'(is)(\s+)(null|unique)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(load)(\s+)(csv)(\s+)(from)\b',
+                bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword)),
+            (r'(on)(\s+)(match|create)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(optional)(\s+)(match)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(order)(\s+)(by)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(starts)(\s+)(with)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(union)(\s+)(all)\b',
+                bygroups(Keyword, Whitespace, Keyword)),
+            (r'(using)(\s+)(periodic)(\s+)(commit)\b',
+                bygroups(Keyword, Whitespace, Keyword, Whitespace, Keyword)),
+            (words((
+                'all', 'any', 'as', 'asc', 'ascending', 'assert', 'call', 'case', 'create',
+                'delete', 'desc', 'descending', 'distinct', 'end', 'fieldterminator',
+                'foreach', 'in', 'limit', 'match', 'merge', 'none', 'not', 'null',
+                'remove', 'return', 'set', 'skip', 'single', 'start', 'then', 'union',
+                'unwind', 'yield', 'where', 'when', 'with'), suffix=r'\b'), Keyword),
         ],
         'relations': [
             (r'(-\[)(.*?)(\]->)', bygroups(Operator, using(this), Operator)),

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

@@ -4,14 +4,14 @@
 
     Lexers for computer graphics and plotting related 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.
 """
 
 from pygments.lexer import RegexLexer, words, include, bygroups, using, \
     this, default
 from pygments.token import Text, Comment, Operator, Keyword, Name, \
-    Number, Punctuation, String
+    Number, Punctuation, String, Whitespace
 
 __all__ = ['GLShaderLexer', 'PostScriptLexer', 'AsymptoteLexer', 'GnuplotLexer',
            'PovrayLexer', 'HLSLShaderLexer']
@@ -30,8 +30,8 @@ class GLShaderLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'^#.*', Comment.Preproc),
-            (r'//.*', Comment.Single),
+            (r'#(?:.*\\\n)*.*$', Comment.Preproc),
+            (r'//.*$', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?',
              Operator),
@@ -143,7 +143,7 @@ class GLShaderLexer(RegexLexer):
             (r'gl_\w*', Name.Builtin),
             (r'[a-zA-Z_]\w*', Name),
             (r'\.', Punctuation),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
     }
 
@@ -161,8 +161,8 @@ class HLSLShaderLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'^#.*', Comment.Preproc),
-            (r'//.*', Comment.Single),
+            (r'#(?:.*\\\n)*.*$', Comment.Preproc),
+            (r'//.*$', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?',
              Operator),
@@ -289,7 +289,7 @@ class HLSLShaderLexer(RegexLexer):
              Name.Decorator),   # attributes
             (r'[a-zA-Z_]\w*', Name),
             (r'\\$', Comment.Preproc),  # backslash at end of line -- usually macro continuation
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
         'string': [
             (r'"', String, '#pop'),
@@ -306,13 +306,10 @@ class PostScriptLexer(RegexLexer):
     """
     Lexer for PostScript files.
 
-    The PostScript Language Reference published by Adobe at
-    <http://partners.adobe.com/public/developer/en/ps/PLRM.pdf>
-    is the authority for this.
-
     .. versionadded:: 1.4
     """
     name = 'PostScript'
+    url = 'https://en.wikipedia.org/wiki/PostScript'
     aliases = ['postscript', 'postscr']
     filenames = ['*.ps', '*.eps']
     mimetypes = ['application/postscript']
@@ -326,10 +323,10 @@ class PostScriptLexer(RegexLexer):
     tokens = {
         'root': [
             # All comment types
-            (r'^%!.+\n', Comment.Preproc),
-            (r'%%.*\n', Comment.Special),
+            (r'^%!.+$', Comment.Preproc),
+            (r'%%.*$', Comment.Special),
             (r'(^%.*\n){2,}', Comment.Multiline),
-            (r'%.*\n', Comment.Single),
+            (r'%.*$', Comment.Single),
 
             # String literals are awkward; enter separate state.
             (r'\(', String, 'stringliteral'),
@@ -383,7 +380,7 @@ class PostScriptLexer(RegexLexer):
                 'undefinedfilename', 'undefinedresult'), suffix=delimiter_end),
              Name.Builtin),
 
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
 
         'stringliteral': [
@@ -402,11 +399,12 @@ class PostScriptLexer(RegexLexer):
 
 class AsymptoteLexer(RegexLexer):
     """
-    For `Asymptote <http://asymptote.sf.net/>`_ source code.
+    For Asymptote source code.
 
     .. versionadded:: 1.2
     """
     name = 'Asymptote'
+    url = 'http://asymptote.sf.net/'
     aliases = ['asymptote', 'asy']
     filenames = ['*.asy']
     mimetypes = ['text/x-asymptote']
@@ -416,9 +414,9 @@ class AsymptoteLexer(RegexLexer):
 
     tokens = {
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuation
             (r'//(\n|(.|\n)*?[^\\]\n)', Comment),
             (r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment),
         ],
@@ -529,12 +527,13 @@ def _shortened_many(*words):
 
 class GnuplotLexer(RegexLexer):
     """
-    For `Gnuplot <http://gnuplot.info/>`_ plotting scripts.
+    For Gnuplot plotting scripts.
 
     .. versionadded:: 0.11
     """
 
     name = 'Gnuplot'
+    url = 'http://gnuplot.info/'
     aliases = ['gnuplot']
     filenames = ['*.plot', '*.plt']
     mimetypes = ['text/x-gnuplot']
@@ -562,14 +561,15 @@ class GnuplotLexer(RegexLexer):
                              'she$ll', 'test$'),
              Keyword, 'noargs'),
             (r'([a-zA-Z_]\w*)(\s*)(=)',
-             bygroups(Name.Variable, Text, Operator), 'genericargs'),
-            (r'([a-zA-Z_]\w*)(\s*\(.*?\)\s*)(=)',
-             bygroups(Name.Function, Text, Operator), 'genericargs'),
+             bygroups(Name.Variable, Whitespace, Operator), 'genericargs'),
+            (r'([a-zA-Z_]\w*)(\s*)(\()(.*?)(\))(\s*)(=)',
+             bygroups(Name.Function, Whitespace, Punctuation,
+                      Text, Punctuation, Whitespace, Operator), 'genericargs'),
             (r'@[a-zA-Z_]\w*', Name.Constant),  # macros
             (r';', Keyword),
         ],
         'comment': [
-            (r'[^\\\n]', Comment),
+            (r'[^\\\n]+', Comment),
             (r'\\\n', Comment),
             (r'\\', Comment),
             # don't add the newline to the Comment token
@@ -577,13 +577,13 @@ class GnuplotLexer(RegexLexer):
         ],
         'whitespace': [
             ('#', Comment, 'comment'),
-            (r'[ \t\v\f]+', Text),
+            (r'[ \t\v\f]+', Whitespace),
         ],
         'noargs': [
             include('whitespace'),
             # semicolon and newline end the argument list
             (r';', Punctuation, '#pop'),
-            (r'\n', Text, '#pop'),
+            (r'\n', Whitespace, '#pop'),
         ],
         'dqstring': [
             (r'"', String, '#pop'),
@@ -591,7 +591,7 @@ class GnuplotLexer(RegexLexer):
             (r'[^\\"\n]+', String),   # all other characters
             (r'\\\n', String),        # line continuation
             (r'\\', String),          # stray backslash
-            (r'\n', String, '#pop'),  # newline ends the string too
+            (r'\n', Whitespace, '#pop'),  # newline ends the string too
         ],
         'sqstring': [
             (r"''", String),          # escaped single quote
@@ -599,7 +599,7 @@ class GnuplotLexer(RegexLexer):
             (r"[^\\'\n]+", String),   # all other characters
             (r'\\\n', String),        # line continuation
             (r'\\', String),          # normal backslash
-            (r'\n', String, '#pop'),  # newline ends the string too
+            (r'\n', Whitespace, '#pop'),  # newline ends the string too
         ],
         'genericargs': [
             include('noargs'),
@@ -615,7 +615,7 @@ class GnuplotLexer(RegexLexer):
              bygroups(Name.Function, Text, Punctuation)),
             (r'[a-zA-Z_]\w*', Name),
             (r'@[a-zA-Z_]\w*', Name.Constant),  # macros
-            (r'\\\n', Text),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),
         ],
         'optionarg': [
             include('whitespace'),
@@ -688,11 +688,12 @@ class GnuplotLexer(RegexLexer):
 
 class PovrayLexer(RegexLexer):
     """
-    For `Persistence of Vision Raytracer <http://www.povray.org/>`_ files.
+    For Persistence of Vision Raytracer files.
 
     .. versionadded:: 0.11
     """
     name = 'POVRay'
+    url = 'http://www.povray.org/'
     aliases = ['pov']
     filenames = ['*.pov', '*.inc']
     mimetypes = ['text/x-povray']
@@ -700,7 +701,7 @@ class PovrayLexer(RegexLexer):
     tokens = {
         'root': [
             (r'/\*[\w\W]*?\*/', Comment.Multiline),
-            (r'//.*\n', Comment.Single),
+            (r'//.*$', Comment.Single),
             (r'(?s)"(?:\\.|[^"\\])+"', String.Double),
             (words((
                 'break', 'case', 'debug', 'declare', 'default', 'define', 'else',
@@ -766,16 +767,14 @@ class PovrayLexer(RegexLexer):
                 'quadric', 'quartic', 'smooth_triangle', 'sor', 'sphere', 'superellipsoid',
                 'text', 'torus', 'triangle', 'union'), suffix=r'\b'),
              Name.Builtin),
-            # TODO: <=, etc
-            (r'[\[\](){}<>;,]', Punctuation),
-            (r'[-+*/=]', Operator),
             (r'\b(x|y|z|u|v)\b', Name.Builtin.Pseudo),
             (r'[a-zA-Z_]\w*', Name),
-            (r'[0-9]+\.[0-9]*', Number.Float),
-            (r'\.[0-9]+', Number.Float),
+            (r'[0-9]*\.[0-9]+', Number.Float),
             (r'[0-9]+', Number.Integer),
+            (r'[\[\](){}<>;,]', Punctuation),
+            (r'[-+*/=.|&]|<=|>=|!=', Operator),
             (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ]
     }
 

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

@@ -4,7 +4,7 @@
 
     Lexer for the DOT language (graphviz).
 
-    :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.
 """
 
@@ -23,6 +23,7 @@ class GraphvizLexer(RegexLexer):
     .. versionadded:: 2.8
     """
     name = 'Graphviz'
+    url = 'https://www.graphviz.org/doc/info/lang.html'
     aliases = ['graphviz', 'dot']
     filenames = ['*.gv', '*.dot']
     mimetypes = ['text/x-graphviz', 'text/vnd.graphviz']

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

@@ -4,27 +4,29 @@
 
     Lexers for TigerGraph GSQL graph query 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, using, this, words
-from pygments.token import Keyword, Punctuation, Comment, Operator, Name,\
-    String, Number, Whitespace, Token
-
+from pygments.token import Keyword, Punctuation, Comment, Operator, Name, \
+    String, Number, Whitespace
 
 __all__ = ["GSQLLexer"]
 
+
 class GSQLLexer(RegexLexer):
 
     """
-    For `GSQL <https://docs.tigergraph.com/dev/gsql-ref>`_ queries (version 3.x).
+    For GSQL queries (version 3.x).
+
     .. versionadded:: 2.10
     """
 
     name = 'GSQL'
+    url = 'https://docs.tigergraph.com/dev/gsql-ref'
     aliases = ['gsql']
     filenames = ['*.gsql']
 
@@ -43,40 +45,49 @@ class GSQLLexer(RegexLexer):
             include('operators'),
         ],
         'comment': [
-            (r'.*\#.*\n', Comment.Single),
-            (r'.*\/\*\s*.*\s*\*\/', Comment.Multiline),
+            (r'\#.*', Comment.Single),
+            (r'/\*(.|\n)*?\*/', Comment.Multiline),
         ],
         'keywords': [
             (words((
-             'ACCUM', 'AND', 'ANY', 'API', 'AS', 'ASC', 'AVG', 'BAG', 'BATCH', 'BETWEEN', 'BOOL', 'BOTH', 
-             'BREAK', 'BY', 'CASE', 'CATCH', 'COALESCE', 'COMPRESS', 'CONTINUE', 'COUNT', 
-             'CREATE', 'DATETIME', 'DATETIME_ADD', 'DATETIME_SUB', 'DELETE', 'DESC', 'DISTRIBUTED', 'DO', 
-             'DOUBLE', 'EDGE', 'ELSE', 'END', 'ESCAPE', 'EXCEPTION', 'FALSE', 'FILE', 'FILTER', 'FLOAT', 'FOREACH', 'FOR', 
-             'FROM', 'GRAPH', 'GROUP', 'GSQL_INT_MAX', 'GSQL_INT_MIN', 'GSQL_UINT_MAX', 'HAVING', 'IF', 
-             'IN', 'INSERT', 'INT', 'INTERPRET', 'INTERSECT', 'INTERVAL', 'INTO', 'IS', 'ISEMPTY', 'JSONARRAY', 'JSONOBJECT', 'LASTHOP', 
-             'LEADING', 'LIKE', 'LIMIT', 'LIST', 'LOAD_ACCUM', 'LOG', 'MAP', 'MATCH', 'MAX', 'MIN', 'MINUS', 'NOT', 
-             'NOW', 'NULL', 'OFFSET', 'OR', 'ORDER', 'PATH', 'PER', 'PINNED', 'POST_ACCUM', 'POST-ACCUM', 'PRIMARY_ID', 'PRINT', 
-             'QUERY', 'RAISE', 'RANGE', 'REPLACE', 'RESET_COLLECTION_ACCUM', 'RETURN', 'RETURNS', 'RUN', 'SAMPLE', 'SELECT', 'SELECT_VERTEX', 
-             'SET', 'SRC', 'STATIC', 'STRING', 'SUM', 'SYNTAX', 'TARGET', 'TAGSTGT', 'THEN', 'TO', 'TO_CSV', 'TO_DATETIME', 'TRAILING', 'TRIM', 'TRUE', 
-             'TRY', 'TUPLE', 'TYPEDEF', 'UINT', 'UNION', 'UPDATE', 'VALUES', 'VERTEX', 'WHEN', 'WHERE', 'WHILE', 'WITH'), prefix=r'(?<!\.)', suffix=r'\b'), Token.Keyword)
+                'ACCUM', 'AND', 'ANY', 'API', 'AS', 'ASC', 'AVG', 'BAG', 'BATCH',
+                'BETWEEN', 'BOOL', 'BOTH', 'BREAK', 'BY', 'CASE', 'CATCH', 'COALESCE',
+                'COMPRESS', 'CONTINUE', 'COUNT', 'CREATE', 'DATETIME', 'DATETIME_ADD',
+                'DATETIME_SUB', 'DELETE', 'DESC', 'DISTRIBUTED', 'DO', 'DOUBLE',
+                'EDGE', 'ELSE', 'END', 'ESCAPE', 'EXCEPTION', 'FALSE', 'FILE',
+                'FILTER', 'FLOAT', 'FOREACH', 'FOR', 'FROM', 'GRAPH', 'GROUP',
+                'GSQL_INT_MAX', 'GSQL_INT_MIN', 'GSQL_UINT_MAX', 'HAVING', 'IF',
+                'IN', 'INSERT', 'INT', 'INTERPRET', 'INTERSECT', 'INTERVAL', 'INTO',
+                'IS', 'ISEMPTY', 'JSONARRAY', 'JSONOBJECT', 'LASTHOP', 'LEADING',
+                'LIKE', 'LIMIT', 'LIST', 'LOAD_ACCUM', 'LOG', 'MAP', 'MATCH', 'MAX',
+                'MIN', 'MINUS', 'NOT', 'NOW', 'NULL', 'OFFSET', 'OR', 'ORDER', 'PATH',
+                'PER', 'PINNED', 'POST_ACCUM', 'POST-ACCUM', 'PRIMARY_ID', 'PRINT',
+                'QUERY', 'RAISE', 'RANGE', 'REPLACE', 'RESET_COLLECTION_ACCUM',
+                'RETURN', 'RETURNS', 'RUN', 'SAMPLE', 'SELECT', 'SELECT_VERTEX',
+                'SET', 'SRC', 'STATIC', 'STRING', 'SUM', 'SYNTAX', 'TARGET',
+                'TAGSTGT', 'THEN', 'TO', 'TO_CSV', 'TO_DATETIME', 'TRAILING',
+                'TRIM', 'TRUE', 'TRY', 'TUPLE', 'TYPEDEF', 'UINT', 'UNION', 'UPDATE',
+                'VALUES', 'VERTEX', 'WHEN', 'WHERE', 'WHILE', 'WITH'),
+                   prefix=r'(?<!\.)', suffix=r'\b'), Keyword),
         ],
         'clauses': [
-            (words(('accum', 'having', 'limit', 'order', 'postAccum', 'sample', 'where')), Name.Builtin)
+            (words(('accum', 'having', 'limit', 'order', 'postAccum', 'sample', 'where')),
+             Name.Builtin),
         ],
         'accums': [
-            (words(('andaccum', 'arrayaccum', 'avgaccum', 'bagaccum', 'bitwiseandaccum', 
-             'bitwiseoraccum', 'groupbyaccum', 'heapaccum', 'listaccum', 'MapAccum', 
-             'maxaccum', 'minaccum', 'oraccum', 'setaccum', 'sumaccum')), Name.Builtin),
+            (words(('andaccum', 'arrayaccum', 'avgaccum', 'bagaccum', 'bitwiseandaccum',
+                    'bitwiseoraccum', 'groupbyaccum', 'heapaccum', 'listaccum',
+                    'MapAccum', 'maxaccum', 'minaccum', 'oraccum', 'setaccum',
+                    'sumaccum')), Name.Builtin),
         ],
         'relations': [
             (r'(-\s?)(\(.*\:\w?\))(\s?-)', bygroups(Operator, using(this), Operator)),
             (r'->|<-', Operator),
-            (r'[.*{}]', Punctuation),
+            (r'[.*{}\[\]\<\>\_]', Punctuation),
         ],
         'strings': [
-            (r'"(?:\\[tbnrf\'"\\]|[^\\"])*"', String),
+            (r'"([^"\\]|\\.)*"', String),
             (r'@{1,2}\w+', Name.Variable),
-            (r'(\<\w+)?\<(\w+\>?\,?\s?)+\>+', Name.Constant),
         ],
         'whitespace': [
             (r'\s+', Whitespace),
@@ -86,7 +97,8 @@ class GSQLLexer(RegexLexer):
             (r'(\d+\.\d+|\d+)', Number),
         ],
         'operators': [
-            (r'[^0-9|\/|\-](\-\=|\+\=|\*\=|\\\=|\=|\=\=|\=\=\=|\+|\-|\*|\\|\+\=|\>|\<)[^\>|\/]', Operator),
-            (r'(\(|\)|\,|\;|\=|\-|\+|\*|\/|\>|\<|\:)', Operator),
+            (r'\$|[^0-9|\/|\-](\-\=|\+\=|\*\=|\\\=|\=|\=\=|\=\=\=|'
+             r'\+|\-|\*|\\|\+\=|\>|\<)[^\>|\/]', Operator),
+            (r'(\||\(|\)|\,|\;|\=|\-|\+|\*|\/|\>|\<|\:)', Operator),
         ],
     }