pygments.rb 2.2.0 → 2.3.0

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

@@ -25,7 +25,7 @@ class NimrodLexer(RegexLexer):
     """
 
     name = 'Nimrod'
-    aliases = ['nim', 'nimrod']
+    aliases = ['nimrod', 'nim']
     filenames = ['*.nim', '*.nimrod']
     mimetypes = ['text/x-nim']
 

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

@@ -412,7 +412,7 @@ class SwiftLexer(RegexLexer):
         ],
         'keywords': [
             (words((
-                'as', 'break', 'case', 'catch', 'continue', 'default', 'defer',
+                'as', 'async', 'await', 'break', 'case', 'catch', 'continue', 'default', 'defer',
                 'do', 'else', 'fallthrough', 'for', 'guard', 'if', 'in', 'is',
                 'repeat', 'return', '#selector', 'switch', 'throw', 'try',
                 'where', 'while'), suffix=r'\b'),
@@ -440,8 +440,8 @@ class SwiftLexer(RegexLexer):
             (r'(var|let)(\s+)([a-zA-Z_]\w*)', bygroups(Keyword.Declaration,
              Text, Name.Variable)),
             (words((
-                'class', 'deinit', 'enum', 'extension', 'func', 'import', 'init',
-                'internal', 'let', 'operator', 'private', 'protocol', 'public',
+                'actor', 'associatedtype', 'class', 'deinit', 'enum', 'extension', 'func', 'import',
+                'init', 'internal', 'let', 'operator', 'private', 'protocol', 'public',
                 'static', 'struct', 'subscript', 'typealias', 'var'), suffix=r'\b'),
              Keyword.Declaration)
         ],

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

@@ -652,7 +652,7 @@ class AntlrActionScriptLexer(DelegatingLexer):
     """
 
     name = 'ANTLR With ActionScript Target'
-    aliases = ['antlr-as', 'antlr-actionscript']
+    aliases = ['antlr-actionscript', 'antlr-as']
     filenames = ['*.G', '*.g']
 
     def __init__(self, **options):

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

@@ -0,0 +1,43 @@
+"""
+    pygments.lexers.procfile
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for Procfile file format.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import Name, Number, String, Text, Punctuation
+
+__all__ = ["ProcfileLexer"]
+
+
+class ProcfileLexer(RegexLexer):
+    """
+    Lexer for Procfile file format.
+
+    The format is used to run processes on Heroku or is used by Foreman or
+    Honcho tools.
+    For more information about the definition of the format, see:
+    https://devcenter.heroku.com/articles/procfile#procfile-format
+
+    .. versionadded:: 2.10
+    """
+    name = 'Procfile'
+    aliases = ['procfile']
+    filenames = ['Procfile']
+
+    tokens = {
+        'root': [
+            (r'^([a-z]+)(:)', bygroups(Name.Label, Punctuation)),
+            (r'\s+', Text.Whitespace),
+            (r'"[^"]*"', String),
+            (r"'[^']*'", String),
+            (r'[0-9]+', Number.Integer),
+            (r'\$[a-zA-Z_][\w]*', Name.Variable),
+            (r'(\w+)(=)(\w+)', bygroups(Name.Variable, Punctuation, String)),
+            (r'([\w\-\./]+)', Text),
+        ],
+    }

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

@@ -166,7 +166,7 @@ class PromQLLexer(RegexLexer):
             (r"\n", Whitespace),
             (r"\s+", Whitespace),
             (r",", Punctuation),
-            (r'([_a-zA-Z][a-zA-Z0-9_]*?)(\s*?)(=~|!=|=|~!)(\s*?)(")(.*?)(")',
+            (r'([_a-zA-Z][a-zA-Z0-9_]*?)(\s*?)(=~|!=|=|!~)(\s*?)("|\')(.*?)("|\')',
              bygroups(Name.Label, Whitespace, Operator, Whitespace,
                       Punctuation, String, Punctuation)),
         ],

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

@@ -160,6 +160,7 @@ class PythonLexer(RegexLexer):
             ("([uUbB]?)(')", bygroups(String.Affix, String.Single),
              combined('stringescape', 'sqs')),
             (r'[^\S\n]+', Text),
+            include('numbers'),
             (r'!=|==|<<|>>|:=|[-~+/*%=<>&^|.]', Operator),
             (r'[]{}:(),;[]', Punctuation),
             (r'(in|is|and|or|not)\b', Operator.Word),
@@ -168,7 +169,6 @@ class PythonLexer(RegexLexer):
             include('magicfuncs'),
             include('magicvars'),
             include('name'),
-            include('numbers'),
         ],
         'expr-inside-fstring': [
             (r'[{([]', Punctuation, 'expr-inside-fstring-inner'),
@@ -727,7 +727,7 @@ class PythonTracebackLexer(RegexLexer):
             (r'^(  File )("[^"]+")(, line )(\d+)(\n)',
              bygroups(Text, Name.Builtin, Text, Number, Text)),
             (r'^(    )(.+)(\n)',
-             bygroups(Text, using(PythonLexer), Text)),
+             bygroups(Text, using(PythonLexer), Text), 'markers'),
             (r'^([ \t]*)(\.\.\.)(\n)',
              bygroups(Text, Comment, Text)),  # for doctests...
             (r'^([^:]+)(: )(.+)(\n)',
@@ -735,6 +735,15 @@ class PythonTracebackLexer(RegexLexer):
             (r'^([a-zA-Z_][\w.]*)(:?\n)',
              bygroups(Generic.Error, Text), '#pop')
         ],
+        'markers': [
+            # Either `PEP 657 <https://www.python.org/dev/peps/pep-0657/>`
+            # error locations in Python 3.11+, or single-caret markers
+            # for syntax errors before that.
+            (r'^( {4,})(\^+)(\n)',
+             bygroups(Text, Punctuation.Marker, Text),
+             '#pop'),
+            default('#pop'),
+        ],
     }
 
 
@@ -773,7 +782,7 @@ class Python2TracebackLexer(RegexLexer):
             (r'^(  File )("[^"]+")(, line )(\d+)(\n)',
              bygroups(Text, Name.Builtin, Text, Number, Text)),
             (r'^(    )(.+)(\n)',
-             bygroups(Text, using(Python2Lexer), Text)),
+             bygroups(Text, using(Python2Lexer), Text), 'marker'),
             (r'^([ \t]*)(\.\.\.)(\n)',
              bygroups(Text, Comment, Text)),  # for doctests...
             (r'^([^:]+)(: )(.+)(\n)',
@@ -781,6 +790,11 @@ class Python2TracebackLexer(RegexLexer):
             (r'^([a-zA-Z_]\w*)(:?\n)',
              bygroups(Generic.Error, Text), '#pop')
         ],
+        'marker': [
+            # For syntax errors.
+            (r'( {4,})(\^)', bygroups(Text, Punctuation.Marker), '#pop'),
+            default('#pop'),
+        ],
     }
 
 
@@ -845,14 +859,14 @@ class CythonLexer(RegexLexer):
         ],
         'builtins': [
             (words((
-                '__import__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin',
+                '__import__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bint',
                 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr',
                 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'delattr',
                 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit',
                 'file', 'filter', 'float', 'frozenset', 'getattr', 'globals',
                 'hasattr', 'hash', 'hex', 'id', 'input', 'int', 'intern', 'isinstance',
                 'issubclass', 'iter', 'len', 'list', 'locals', 'long', 'map', 'max',
-                'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'property',
+                'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'Py_ssize_t',
                 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed',
                 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod',
                 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'unsigned',

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

@@ -24,7 +24,7 @@ class ResourceLexer(RegexLexer):
     .. versionadded:: 2.0
     """
     name = 'ResourceBundle'
-    aliases = ['resource', 'resourcebundle']
+    aliases = ['resourcebundle', 'resource']
     filenames = []
 
     _types = (':table', ':array', ':string', ':bin', ':import', ':intvector',

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

@@ -23,7 +23,7 @@ class RNCCompactLexer(RegexLexer):
     """
 
     name = 'Relax-NG Compact'
-    aliases = ['rnc', 'rng-compact']
+    aliases = ['rng-compact', 'rnc']
     filenames = ['*.rnc']
 
     tokens = {

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

@@ -33,7 +33,7 @@ class RubyLexer(ExtendedRegexLexer):
     """
 
     name = 'Ruby'
-    aliases = ['rb', 'ruby', 'duby']
+    aliases = ['ruby', 'rb', 'duby']
     filenames = ['*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec',
                  '*.rbx', '*.duby', 'Gemfile']
     mimetypes = ['text/x-ruby', 'application/x-ruby']

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

@@ -109,7 +109,7 @@ class RustLexer(RegexLexer):
             # Types in positions.
             (r'(?::|->)', Text, 'typename'),
             # Labels
-            (r'(break|continue)(\s*)(\'[A-Za-z_]\w*)?',
+            (r'(break|continue)(\b\s*)(\'[A-Za-z_]\w*)?',
              bygroups(Keyword, Text.Whitespace, Name.Label)),
 
             # Character literals
@@ -135,7 +135,7 @@ class RustLexer(RegexLexer):
             # String literals
             (r'b"', String, 'bytestring'),
             (r'"', String, 'string'),
-            (r'b?r(#*)".*?"\1', String),
+            (r'(?s)b?r(#*)".*?"\1', String),
 
             # Lifetime names
             (r"'", Operator, 'lifetime'),
@@ -152,6 +152,11 @@ class RustLexer(RegexLexer):
 
             # Attributes
             (r'#!?\[', Comment.Preproc, 'attribute['),
+
+            # Misc
+            # Lone hashes: not used in Rust syntax, but allowed in macro
+            # arguments, most famously for quote::quote!()
+            (r'#', Text),
         ],
         'comment': [
             (r'[^*/]+', Comment.Multiline),
@@ -208,16 +213,10 @@ class RustLexer(RegexLexer):
         'attribute_common': [
             (r'"', String, 'string'),
             (r'\[', Comment.Preproc, 'attribute['),
-            (r'\(', Comment.Preproc, 'attribute('),
         ],
         'attribute[': [
             include('attribute_common'),
-            (r'\];?', Comment.Preproc, '#pop'),
-            (r'[^"\]]+', Comment.Preproc),
-        ],
-        'attribute(': [
-            include('attribute_common'),
-            (r'\);?', Comment.Preproc, '#pop'),
-            (r'[^")]+', Comment.Preproc),
+            (r'\]', Comment.Preproc, '#pop'),
+            (r'[^"\]\[]+', Comment.Preproc),
         ],
     }

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

@@ -168,9 +168,9 @@ class MoonScriptLexer(LuaLexer):
     .. versionadded:: 1.5
     """
 
-    name = "MoonScript"
-    aliases = ["moon", "moonscript"]
-    filenames = ["*.moon"]
+    name = 'MoonScript'
+    aliases = ['moonscript', 'moon']
+    filenames = ['*.moon']
     mimetypes = ['text/x-moonscript', 'application/x-moonscript']
 
     tokens = {
@@ -237,7 +237,7 @@ class ChaiscriptLexer(RegexLexer):
     """
 
     name = 'ChaiScript'
-    aliases = ['chai', 'chaiscript']
+    aliases = ['chaiscript', 'chai']
     filenames = ['*.chai']
     mimetypes = ['text/x-chaiscript', 'application/x-chaiscript']
 
@@ -1236,9 +1236,9 @@ class MiniScriptLexer(RegexLexer):
     .. versionadded:: 2.6
     """
 
-    name = "MiniScript"
-    aliases = ["ms", "miniscript"]
-    filenames = ["*.ms"]
+    name = 'MiniScript'
+    aliases = ['miniscript', 'ms']
+    filenames = ['*.ms']
     mimetypes = ['text/x-minicript', 'application/x-miniscript']
 
     tokens = {

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

@@ -192,10 +192,13 @@ class ShellSessionBaseLexer(Lexer):
                                    [(0, Generic.Prompt, m.group(1))]))
                 curcode += m.group(2)
                 backslash_continuation = curcode.endswith('\\\n')
-            elif line.startswith(self._ps2) and backslash_continuation:
-                insertions.append((len(curcode),
-                                   [(0, Generic.Prompt, line[:len(self._ps2)])]))
-                curcode += line[len(self._ps2):]
+            elif backslash_continuation:
+                if line.startswith(self._ps2):
+                    insertions.append((len(curcode),
+                                    [(0, Generic.Prompt, line[:len(self._ps2)])]))
+                    curcode += line[len(self._ps2):]
+                else:
+                    curcode += line
                 backslash_continuation = curcode.endswith('\\\n')
             else:
                 if insertions:
@@ -238,7 +241,7 @@ class BatchLexer(RegexLexer):
     .. versionadded:: 0.7
     """
     name = 'Batchfile'
-    aliases = ['bat', 'batch', 'dosbatch', 'winbatch']
+    aliases = ['batch', 'bat', 'dosbatch', 'winbatch']
     filenames = ['*.bat', '*.cmd']
     mimetypes = ['application/x-dos-batch']
 
@@ -652,7 +655,7 @@ class PowerShellLexer(RegexLexer):
     .. versionadded:: 1.5
     """
     name = 'PowerShell'
-    aliases = ['powershell', 'posh', 'ps1', 'psm1']
+    aliases = ['powershell', 'pwsh', 'posh', 'ps1', 'psm1']
     filenames = ['*.ps1', '*.psm1']
     mimetypes = ['text/x-powershell']
 
@@ -730,7 +733,7 @@ class PowerShellLexer(RegexLexer):
             (r'\[[a-z_\[][\w. `,\[\]]*\]', Name.Constant),  # .net [type]s
             (r'-[a-z_]\w*', Name),
             (r'\w+', Name),
-            (r'[.,;@{}\[\]$()=+*/\\&%!~?^`|<>-]|::', Punctuation),
+            (r'[.,;:@{}\[\]$()=+*/\\&%!~?^`|<>-]', Punctuation),
         ],
         'child': [
             (r'\)', Punctuation, '#pop'),
@@ -768,7 +771,7 @@ class PowerShellSessionLexer(ShellSessionBaseLexer):
     """
 
     name = 'PowerShell Session'
-    aliases = ['ps1con']
+    aliases = ['pwsh-session', 'ps1con']
     filenames = []
     mimetypes = []
 

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

@@ -0,0 +1,79 @@
+"""
+    pygments.lexers.smithy
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Smithy IDL.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Text, Comment, Keyword, Name, String, \
+    Number, Whitespace, Punctuation
+
+__all__ = ['SmithyLexer']
+
+
+class SmithyLexer(RegexLexer):
+    """
+    For Smithy IDL
+
+    .. versionadded:: 2.10
+    """
+    name = 'Smithy'
+    filenames = ['*.smithy']
+    aliases = ['smithy']
+
+    flags = re.MULTILINE | re.UNICODE
+    unquoted = r'[A-Za-z0-9_\.#$-]+'
+    identifier = r"[A-Za-z0-9_\.#$-]+"
+
+    simple_shapes = (
+        'use', 'byte', 'short', 'integer', 'long', 'float', 'document',
+        'double', 'bigInteger', 'bigDecimal', 'boolean', 'blob', 'string',
+        'timestamp',
+    )
+
+    aggregate_shapes = (
+       'apply', 'list', 'map', 'set', 'structure', 'union', 'resource',
+       'operation', 'service', 'trait'
+    )
+
+    tokens = {
+        'root': [
+            (r'///.*$', Comment.Multiline),
+            (r'//.*$', Comment),
+            (r'@[0-9a-zA-Z\.#-]*', Name.Decorator),
+            (r'(=)', Name.Decorator),
+            (r'^(\$version)(:)(.+)',
+                bygroups(Keyword.Declaration, Name.Decorator, Name.Class)),
+            (r'^(namespace)(\s+' + identifier + r')\b',
+                bygroups(Keyword.Declaration, Name.Class)),
+            (words(simple_shapes,
+                   prefix=r'^', suffix=r'(\s+' + identifier + r')\b'),
+                bygroups(Keyword.Declaration, Name.Class)),
+            (words(aggregate_shapes,
+                   prefix=r'^', suffix=r'(\s+' + identifier + r')'),
+                bygroups(Keyword.Declaration, Name.Class)),
+            (r'^(metadata)(\s+.+)(\s*)(=)',
+                bygroups(Keyword.Declaration, Name.Class, Whitespace, Name.Decorator)),
+            (r"(true|false|null)", Keyword.Constant),
+            (r"(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)", Number),
+            (identifier + ":", Name.Label),
+            (identifier, Name.Variable.Class),
+            (r'\[', Text, "#push"),
+            (r'\]', Text, "#pop"),
+            (r'\(', Text, "#push"),
+            (r'\)', Text, "#pop"),
+            (r'\{', Text, "#push"),
+            (r'\}', Text, "#pop"),
+            (r'"{3}(\\\\|\n|\\")*"{3}', String.Doc),
+            (r'"(\\\\|\n|\\"|[^"])*"', String.Double),
+            (r"'(\\\\|\n|\\'|[^'])*'", String.Single),
+            (r'[:,]+', Punctuation),
+            (r'\s+', Whitespace),
+        ]
+    }

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

@@ -68,7 +68,7 @@ class NuSMVLexer(RegexLexer):
             (r'\-?\d+\b', Number.Integer),
             (r'0[su][bB]\d*_[01_]+', Number.Bin),
             (r'0[su][oO]\d*_[0-7_]+', Number.Oct),
-            (r'0[su][dD]\d*_[\d_]+', Number.Dec),
+            (r'0[su][dD]\d*_[\d_]+', Number.Decimal),
             (r'0[su][hH]\d*_[\da-fA-F_]+', Number.Hex),
 
             # Whitespace, punctuation and the rest

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

@@ -12,11 +12,11 @@ import ast
 import re
 
 from pygments.lexer import Lexer
-from pygments.token import Token, Error, Text
+from pygments.token import Token, Error, Text, Generic
 from pygments.util import get_choice_opt
 
 
-__all__ = ['TextLexer', 'RawTokenLexer']
+__all__ = ['TextLexer', 'OutputLexer', 'RawTokenLexer']
 
 
 class TextLexer(Lexer):
@@ -36,6 +36,19 @@ class TextLexer(Lexer):
         return TextLexer.priority
 
 
+class OutputLexer(Lexer):
+    """
+    Simple lexer that highlights everything as ``Token.Generic.Output``.
+
+    .. versionadded:: 2.10
+    """
+    name = 'Text output'
+    aliases = ['output']
+
+    def get_tokens_unprocessed(self, text):
+        yield 0, Generic.Output, text
+
+
 _ttype_cache = {}
 
 line_re = re.compile('.*?\n')

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

@@ -25,7 +25,7 @@ class SuperColliderLexer(RegexLexer):
     """
 
     name = 'SuperCollider'
-    aliases = ['sc', 'supercollider']
+    aliases = ['supercollider', 'sc']
     filenames = ['*.sc', '*.scd']
     mimetypes = ['application/supercollider', 'text/supercollider', ]
 

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

@@ -10,7 +10,7 @@
 
 from pygments.lexer import RegexLexer, include, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number
+    Number, Whitespace
 from pygments.util import shebang_matches
 
 __all__ = ['TclLexer']
@@ -79,13 +79,13 @@ class TclLexer(RegexLexer):
             (r'!=|==|<<|>>|<=|>=|&&|\|\||\*\*|[-+~!*/%<>&^|?:]', Operator),
         ],
         'data': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'0x[a-fA-F0-9]+', Number.Hex),
             (r'0[0-7]+', Number.Oct),
             (r'\d+\.\d+', Number.Float),
             (r'\d+', Number.Integer),
             (r'\$([\w.:-]+)', Name.Variable),
-            (r'([\w.:-]+)', Text),
+            (r'([\w.,@:-]+)', Text),
         ],
         'params': [
             (r';', Keyword, '#pop'),

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

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.teal
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for TEAL.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, include, words
+from pygments.token import Comment, Name, Number, String, Text, Keyword
+
+__all__ = ['TealLexer']
+
+class TealLexer(RegexLexer):
+    """
+    For the `Transaction Execution Approval Language (TEAL)
+    <https://developer.algorand.org/docs/reference/teal/specification/>`
+
+    For more information about the grammar, see:
+    https://github.com/algorand/go-algorand/blob/master/data/transactions/logic/assembler.go
+
+    .. versionadded:: 2.9
+    """
+    name = 'teal'
+    aliases = ['teal']
+    filenames = ['*.teal']
+
+    keywords = words({
+        'Sender', 'Fee', 'FirstValid', 'FirstValidTime', 'LastValid', 'Note',
+        'Lease', 'Receiver', 'Amount', 'CloseRemainderTo', 'VotePK',
+        'SelectionPK', 'VoteFirst', 'VoteLast', 'VoteKeyDilution', 'Type',
+        'TypeEnum', 'XferAsset', 'AssetAmount', 'AssetSender', 'AssetReceiver',
+        'AssetCloseTo', 'GroupIndex', 'TxID', 'ApplicationID', 'OnCompletion',
+        'ApplicationArgs', 'NumAppArgs', 'Accounts', 'NumAccounts',
+        'ApprovalProgram', 'ClearStateProgram', 'RekeyTo', 'ConfigAsset',
+        'ConfigAssetTotal', 'ConfigAssetDecimals', 'ConfigAssetDefaultFrozen',
+        'ConfigAssetUnitName', 'ConfigAssetName', 'ConfigAssetURL',
+        'ConfigAssetMetadataHash', 'ConfigAssetManager', 'ConfigAssetReserve',
+        'ConfigAssetFreeze', 'ConfigAssetClawback', 'FreezeAsset',
+        'FreezeAssetAccount', 'FreezeAssetFrozen',
+        'NoOp', 'OptIn', 'CloseOut', 'ClearState', 'UpdateApplication',
+        'DeleteApplication',
+        'MinTxnFee', 'MinBalance', 'MaxTxnLife', 'ZeroAddress', 'GroupSize',
+        'LogicSigVersion', 'Round', 'LatestTimestamp', 'CurrentApplicationID',
+        'AssetBalance', 'AssetFrozen',
+        'AssetTotal', 'AssetDecimals', 'AssetDefaultFrozen', 'AssetUnitName',
+        'AssetName', 'AssetURL', 'AssetMetadataHash', 'AssetManager',
+        'AssetReserve', 'AssetFreeze', 'AssetClawback',
+    }, suffix = r'\b')
+
+    identifier = r'[^ \t\n]+(?=\/\/)|[^ \t\n]+'
+    newline = r'\r?\n'
+    tokens = {
+        'root': [
+            include('whitespace'),
+            # pragmas match specifically on the space character
+            (r'^#pragma .*' + newline, Comment.Directive),
+            # labels must be followed by a space,
+            # but anything after that is ignored
+            ('(' + identifier + ':' + ')' + '([ \t].*)',
+                bygroups(Name.Label, Comment.Single)),
+            (identifier, Name.Function, 'function-args'),
+        ],
+        'function-args': [
+            include('whitespace'),
+            (r'"', String, 'string'),
+            (r'(b(?:ase)?(?:32|64) ?)(\(?[a-zA-Z0-9+/=]+\)?)',
+                bygroups(String.Affix, String.Other)),
+            (r'[A-Z2-7]{58}', Number), # address
+            (r'0x[\da-fA-F]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            (keywords, Keyword),
+            (identifier, Name.Attributes),  # branch targets
+            (newline, Text, '#pop'),
+        ],
+        'string': [
+            (r'\\(?:["nrt\\]|x\d\d)', String.Escape),
+            (r'[^\\\"\n]+', String),
+            (r'"', String, '#pop'),
+        ],
+        'whitespace': [
+            (r'[ \t]+', Text),
+            (r'//[^\n]+', Comment.Single),
+        ],
+    }