android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/pygments/lexers/tact.py

@@ -1,303 +0,0 @@
-"""
-    pygments.lexers.tact
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Tact.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, include, bygroups, words
-from pygments.token import Comment, Operator, Keyword, Name, String, \
-    Number, Whitespace, Punctuation
-
-__all__ = ['TactLexer']
-
-
-class TactLexer(RegexLexer):
-    """For Tact source code."""
-
-    name = 'Tact'
-    aliases = ['tact']
-    filenames = ['*.tact']
-    url = "https://tact-lang.org"
-    version_added = '2.18'
-
-    tokens = {
-        'root': [
-            (r'\s+', Whitespace),
-            (r'[.;(),\[\]{}]', Punctuation),
-            (r'\?|!!', Operator),
-            include('comments'),
-            include('import-in'),
-            include('struct-in'),
-            include('contract-or-trait-in'),
-            include('annotation-in'),
-            include('fun-declaration-in'),
-            include('const-declaration-in'),
-            include('statements'),
-        ],
-        'import-in': [
-            (r'((?<=\.\.\.)|(?<![.$]))\b(import)\b(\s*)', bygroups(Punctuation, Keyword, Whitespace), 'import'),
-        ],
-        'import': [
-            (r';', Punctuation, '#pop'),
-            include('comments'),
-            include('string-in'),
-            (r'\s+', Whitespace),
-        ],
-        'struct-in': [
-            (r'((?<=\.\.\.)|(?<![.$]))\b(struct|message)\b', bygroups(Punctuation, Keyword), 'struct'),
-        ],
-        'struct': [
-            include('comments'),
-            include('struct-header'),
-            include('struct-body-in'),
-            (r'\s+', Whitespace),
-        ],
-        'struct-header': [
-            include('comments'),
-            (r'\b\w+', Name.Class),
-            (r'(\()((?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b)(\))', bygroups(Punctuation, Number.Hex, Punctuation)),
-            (r'(\()((?:\b[0-9]+\b))(\))', bygroups(Punctuation, Number.Integer, Punctuation)),
-        ],
-        'struct-body-in': [
-            (r'\{', Punctuation, 'struct-body'),
-        ],
-        'struct-body': [
-            (r'\}', Punctuation, '#pop:2'),
-            include('comments'),
-            include('field-declaration-in'),
-        ],
-        'contract-or-trait-in': [
-            (r'((?<=\.\.\.)|(?<![.$]))\b(contract|trait)\b', Keyword, 'contract-or-trait'),
-        ],
-        'contract-or-trait': [
-            include('comments'),
-            (r'with', Keyword),
-            (r'\b\w+', Name.Class),
-            include('contract-or-trait-body-in'),
-            (r'\s+', Whitespace),
-            (r',', Punctuation),
-        ],
-        'contract-or-trait-body-in': [
-            (r'\{', Punctuation, 'contract-or-trait-body'),
-        ],
-        'contract-or-trait-body': [
-            (r'\}', Punctuation, '#pop:2'),
-            include('comments'),
-            include('init-declaration-in'),
-            include('receive-declaration-in'),
-            include('bounce-declaration-in'),
-            include('fun-declaration-in'),
-            include('const-declaration-in'),
-            include('field-declaration-in'),
-            (r'\s+', Whitespace),
-        ],
-        'field-declaration-in': [
-            (r'\b\w+', Name.Property, 'field-declaration'),
-        ],
-        'field-declaration': [
-            (r';', Punctuation, '#pop'),
-            include('comments'),
-            include('type-annotation-in'),
-            include('variable-init-in'),
-        ],
-        'const-declaration-in': [
-            (r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*const\b)', Keyword, 'const-declaration'),
-        ],
-        'const-declaration': [
-            (r'(;)', Punctuation, '#pop'),
-            (r'const', Keyword),
-            (words(('get', 'native', 'extends', 'mutates', 'virtual', 'override', 'inline', 'abstract'), suffix=r'\b'), Keyword),
-            (r'\b\w+\b', Name.Constant),
-            include('comments'),
-            include('type-annotation-in'),
-            include('variable-init-in'),
-            (r'\s+', Whitespace),
-        ],
-        'init-declaration-in': [
-            (r'(init)', Keyword, 'init-declaration')
-        ],
-        'init-declaration': [
-            (r'(?<=\})', Punctuation, '#pop'),
-            include('comments'),
-            include('fun-arguments-in'),
-            include('block-declaration-in'),
-            (r'\s+', Whitespace),
-        ],
-        'receive-declaration-in': [
-            (r'(receive|exernal)', Keyword, 'receive-declaration')
-        ],
-        'receive-declaration': [
-            (r'(?<=\})', Punctuation, '#pop'),
-            include('comments'),
-            include('fun-arguments-in'),
-            include('block-declaration-in'),
-        ],
-        'bounce-declaration-in': [
-            (r'(bounced)', Keyword, 'bounce-declaration')
-        ],
-        'bounce-declaration': [
-            (r'(?<=\})', Punctuation, '#pop'),
-            include('comments'),
-            include('fun-arguments-in'),
-            include('block-declaration-in'),
-        ],
-        'fun-declaration-in': [
-            (r'(?=\b(?:(?:get|native|extends|mutates|virtual|override|inline|abstract)\s*)*fun\b)', Keyword, 'fun-declaration')
-        ],
-        'fun-declaration': [
-            (r'(?<=\}|\;)', Punctuation, '#pop'),
-            (r'fun', Keyword),
-            (r'\b(get|native|extends|mutates|virtual|override|inline|abstract)\b', Keyword),
-            (r'\b[\w]+', Name.Function),
-            include('fun-declaration-body'),
-            (r'[,;]', Punctuation),
-        ],
-        'fun-declaration-body': [
-            include('comments'),
-            include('fun-arguments-in'),
-            include('type-annotation-in'),
-            include('block-declaration-in'),
-            (r'\s+', Whitespace),
-        ],
-        'fun-arguments-in': [
-            (r'\(', Punctuation, 'fun-arguments'),
-        ],
-        'fun-arguments': [
-            (r'\)', Punctuation, '#pop'),
-            include('comments'),
-            include('string-in'),
-            include('type-annotation-in'),
-            (r'(self)|(\b[\w]+\b)', bygroups(Name.Variable.Instance, Name.Variable)),
-            (r',', Punctuation),
-            (r'\s+', Whitespace),
-        ],
-        'block-declaration-in': [
-            (r'\{', Punctuation, 'block-declaration')
-        ],
-        'block-declaration': [
-            (r'\}', Punctuation, '#pop'),
-            include('statements'),
-        ],
-        'statements': [
-            include('comments'),
-            include('block-declaration-in'),
-            include('expressions'),
-        ],
-        'annotation-in': [
-            (r'(@)(\w+)(\()', bygroups(Keyword.Pseudo, Keyword, Punctuation), 'annotation')
-        ],
-        'annotation': [
-            (r'\)', Punctuation, '#pop'),
-            include('annotation-argument'),
-            (r'\s+', Whitespace),
-        ],
-        'annotation-argument': [
-            (r'\w+', Name.Function.Magic),
-        ],
-        'expressions': [
-            include('comments'),
-            include('type-annotation-in'),
-            include('keywords'),
-            include('numeric'),
-            include('string-in'),
-            include('variable'),
-            include('function-call'),
-            include('struct-init-in'),
-        ],
-        'struct-init-in': [
-            (r'(\b\w+)(\s*)(\{)', bygroups(Name.Class, Whitespace, Punctuation), 'struct-init')
-        ],
-        'struct-init': [
-            (r'(\})', Punctuation, '#pop'),
-            include('comments'),
-            include('struct-property-in'),
-            (r'\s+', Whitespace),
-            (r',', Punctuation),
-        ],
-        'struct-property-in': [
-            (r'(\b[\w]+)(\s*)(:)', bygroups(Name.Property, Whitespace, Punctuation), 'struct-property')
-        ],
-        'struct-property': [
-            (r'(?=\}|\,)', Punctuation, '#pop'),
-            include('comments'),
-            include('expressions'),
-            (r'\s+', Whitespace),
-        ],
-        'variable-init-in': [
-            (r'(=)', Operator, 'variable-init')
-        ],
-        'variable-init': [
-            (r'(?=\}|\{|\,|\;)',Punctuation, '#pop'),
-            include('comments'),
-            include('expressions'),
-            (r'\s+', Whitespace),
-        ],
-        'type-annotation-in': [
-            (r'(:)(\s+)', bygroups(Punctuation, Whitespace), 'type-annotation')
-        ],
-        'type-annotation': [
-            (r'(?=\{|\;|\=|\,|\))', Punctuation, '#pop'),
-            include('comments'),
-            include('type-as-in'),
-            include('type-generic-in'),
-            (r'\?', Operator),
-            (r'\b\w+', Keyword.Type),
-            (r'\s+', Whitespace),
-        ],
-        'type-generic-in': [
-            (r'<', Punctuation, 'type-generic'),
-        ],
-        'type-generic': [
-            (r'>', Punctuation, '#pop'),
-            include('comments'),
-            include('type-as-in'),
-            (r'\b\w+', Keyword.Type),
-            (r'\s+', Whitespace),
-            (r',', Punctuation),
-        ],
-        'type-as-in': [
-            (r'\b(as)(\s+)', bygroups(Keyword, Whitespace), 'type-as'),
-        ],
-        'type-as': [
-            (r'(?=\{|\;|\=|\,|\)|\>)', Punctuation, '#pop'),
-            include('comments'),
-            (r'\b\w+', Keyword.Type),
-            (r'\s+', Whitespace),
-        ],
-        'keywords': [
-            (words(('if', 'else', 'while', 'do', 'until', 'repeat', 'return', 'extends', 'mutates', 'virtual', 'override', 'inline', 'native', 'let', 'const', 'fun', 'self', 'is', 'initOf', 'map', 'bounced', 'get', 'as'), prefix=r'\b', suffix=r'\b'), Keyword),
-            (r'(<=>|>=|<=|!=|==|\^>>|~>>|>>|<<|\/%|\^%|~%|\^\/|~\/|\+=|-=|\*=|\/=|~\/=|\^\/=|%=|\^%=|<<=|>>=|~>>=|\^>>=|&=|\|=|\^=|\^|=|~|\/|%|-|\*|\+|>|<|&|\||:|\?)', Operator),
-            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
-        ],
-        'string-in': [
-            (r'"', String, 'string'),
-        ],
-        'string': [
-            (r'"', String, '#pop'),
-            (r'\\.', String.Escape),
-            (r'[^\\"]+', String.Double),
-        ],
-        'numeric': [
-            (r'(?:\b0[xX])[0-9a-fA-F][0-9a-fA-F_]*\b', Number.Hex),
-            (r'(?:\b[0-9]+\b)', Number.Integer),
-        ],
-        'comments': [
-            (r'//.*', Comment.Single),
-            (r'/\*', Comment.Multiline, 'comments-multiline'),
-        ],
-        'comments-multiline': [
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[^*]+', Comment.Multiline),
-            (r'[*]', Comment.Multiline),
-        ],
-        'variable': [
-            (r'\b\w+\b(?!\s*\()(?!\s*\{)', Name.Variable)
-        ],
-        'function-call': [
-            (r'\b\w+\b(?=\s*\()(?!\s*\{)', Name.Function)
-        ],
-    }

venv/Lib/site-packages/pygments/lexers/tal.py

@@ -1,77 +0,0 @@
-"""
-    pygments.lexers.tal
-    ~~~~~~~~~~~~~~~~~~~
-
-    Lexer for Uxntal
-
-    .. versionadded:: 2.12
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, words
-from pygments.token import Comment, Keyword, Name, String, Number, \
-    Punctuation, Whitespace, Literal
-
-__all__ = ['TalLexer']
-
-
-class TalLexer(RegexLexer):
-    """
-    For Uxntal source code.
-    """
-
-    name = 'Tal'
-    aliases = ['tal', 'uxntal']
-    filenames = ['*.tal']
-    mimetypes = ['text/x-uxntal']
-    url = 'https://wiki.xxiivv.com/site/uxntal.html'
-    version_added = '2.12'
-
-    instructions = [
-        'BRK', 'LIT', 'INC', 'POP', 'DUP', 'NIP', 'SWP', 'OVR', 'ROT',
-        'EQU', 'NEQ', 'GTH', 'LTH', 'JMP', 'JCN', 'JSR', 'STH',
-        'LDZ', 'STZ', 'LDR', 'STR', 'LDA', 'STA', 'DEI', 'DEO',
-        'ADD', 'SUB', 'MUL', 'DIV', 'AND', 'ORA', 'EOR', 'SFT'
-    ]
-
-    tokens = {
-        # the comment delimiters must not be adjacent to non-space characters.
-        # this means ( foo ) is a valid comment but (foo) is not. this also
-        # applies to nested comments.
-        'comment': [
-            (r'(?<!\S)\((?!\S)', Comment.Multiline, '#push'), # nested comments
-            (r'(?<!\S)\)(?!\S)', Comment.Multiline, '#pop'), # nested comments
-            (r'[^()]+', Comment.Multiline), # comments
-            (r'[()]+', Comment.Multiline), # comments
-        ],
-        'root': [
-            (r'\s+', Whitespace), # spaces
-            (r'(?<!\S)\((?!\S)', Comment.Multiline, 'comment'), # comments
-            (words(instructions, prefix=r'(?<!\S)', suffix=r'2?k?r?(?!\S)'),
-             Keyword.Reserved), # instructions
-            (r'[][{}](?!\S)', Punctuation), # delimiters
-            (r'#([0-9a-f]{2}){1,2}(?!\S)', Number.Hex), # integer
-            (r'"\S+', String), # raw string
-            (r'([0-9a-f]{2}){1,2}(?!\S)', Literal), # raw integer
-            (r'[|$][0-9a-f]{1,4}(?!\S)', Keyword.Declaration), # abs/rel pad
-            (r'%\S+', Name.Decorator), # macro
-            (r'@\S+', Name.Function), # label
-            (r'&\S+', Name.Label), # sublabel
-            (r'/\S+', Name.Tag), # spacer
-            (r'\.\S+', Name.Variable.Magic), # literal zero page addr
-            (r',\S+', Name.Variable.Instance), # literal rel addr
-            (r';\S+', Name.Variable.Global), # literal abs addr
-            (r'-\S+', Literal), # raw zero page addr
-            (r'_\S+', Literal), # raw relative addr
-            (r'=\S+', Literal), # raw absolute addr
-            (r'!\S+', Name.Function), # immediate jump
-            (r'\?\S+', Name.Function), # conditional immediate jump
-            (r'~\S+', Keyword.Namespace), # include
-            (r'\S+', Name.Function), # macro invocation, immediate subroutine
-        ]
-    }
-
-    def analyse_text(text):
-        return '|0100' in text[:500]

venv/Lib/site-packages/pygments/lexers/tcl.py

@@ -1,148 +0,0 @@
-"""
-    pygments.lexers.tcl
-    ~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Tcl and related languages.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, include, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Whitespace
-from pygments.util import shebang_matches
-
-__all__ = ['TclLexer']
-
-
-class TclLexer(RegexLexer):
-    """
-    For Tcl source code.
-    """
-
-    keyword_cmds_re = words((
-        'after', 'apply', 'array', 'break', 'catch', 'continue', 'elseif',
-        'else', 'error', 'eval', 'expr', 'for', 'foreach', 'global', 'if',
-        'namespace', 'proc', 'rename', 'return', 'set', 'switch', 'then',
-        'trace', 'unset', 'update', 'uplevel', 'upvar', 'variable', 'vwait',
-        'while'), prefix=r'\b', suffix=r'\b')
-
-    builtin_cmds_re = words((
-        'append', 'bgerror', 'binary', 'cd', 'chan', 'clock', 'close',
-        'concat', 'dde', 'dict', 'encoding', 'eof', 'exec', 'exit', 'fblocked',
-        'fconfigure', 'fcopy', 'file', 'fileevent', 'flush', 'format', 'gets',
-        'glob', 'history', 'http', 'incr', 'info', 'interp', 'join', 'lappend',
-        'lassign', 'lindex', 'linsert', 'list', 'llength', 'load', 'loadTk',
-        'lrange', 'lrepeat', 'lreplace', 'lreverse', 'lsearch', 'lset', 'lsort',
-        'mathfunc', 'mathop', 'memory', 'msgcat', 'open', 'package', 'pid',
-        'pkg::create', 'pkg_mkIndex', 'platform', 'platform::shell', 'puts',
-        'pwd', 're_syntax', 'read', 'refchan', 'regexp', 'registry', 'regsub',
-        'scan', 'seek', 'socket', 'source', 'split', 'string', 'subst', 'tell',
-        'time', 'tm', 'unknown', 'unload'), prefix=r'\b', suffix=r'\b')
-
-    name = 'Tcl'
-    url = 'https://www.tcl.tk/about/language.html'
-    aliases = ['tcl']
-    filenames = ['*.tcl', '*.rvt']
-    mimetypes = ['text/x-tcl', 'text/x-script.tcl', 'application/x-tcl']
-    version_added = '0.10'
-
-    def _gen_command_rules(keyword_cmds_re, builtin_cmds_re, context=""):
-        return [
-            (keyword_cmds_re, Keyword, 'params' + context),
-            (builtin_cmds_re, Name.Builtin, 'params' + context),
-            (r'([\w.-]+)', Name.Variable, 'params' + context),
-            (r'#', Comment, 'comment'),
-        ]
-
-    tokens = {
-        'root': [
-            include('command'),
-            include('basic'),
-            include('data'),
-            (r'\}', Keyword),  # HACK: somehow we miscounted our braces
-        ],
-        'command': _gen_command_rules(keyword_cmds_re, builtin_cmds_re),
-        'command-in-brace': _gen_command_rules(keyword_cmds_re,
-                                               builtin_cmds_re,
-                                               "-in-brace"),
-        'command-in-bracket': _gen_command_rules(keyword_cmds_re,
-                                                 builtin_cmds_re,
-                                                 "-in-bracket"),
-        'command-in-paren': _gen_command_rules(keyword_cmds_re,
-                                               builtin_cmds_re,
-                                               "-in-paren"),
-        'basic': [
-            (r'\(', Keyword, 'paren'),
-            (r'\[', Keyword, 'bracket'),
-            (r'\{', Keyword, 'brace'),
-            (r'"', String.Double, 'string'),
-            (r'(eq|ne|in|ni)\b', Operator.Word),
-            (r'!=|==|<<|>>|<=|>=|&&|\|\||\*\*|[-+~!*/%<>&^|?:]', Operator),
-        ],
-        'data': [
-            (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.:-]+\}', Name.Variable),
-            (r'[\w.,@:-]+', Text),
-        ],
-        'params': [
-            (r';', Keyword, '#pop'),
-            (r'\n', Text, '#pop'),
-            (r'(else|elseif|then)\b', Keyword),
-            include('basic'),
-            include('data'),
-        ],
-        'params-in-brace': [
-            (r'\}', Keyword, ('#pop', '#pop')),
-            include('params')
-        ],
-        'params-in-paren': [
-            (r'\)', Keyword, ('#pop', '#pop')),
-            include('params')
-        ],
-        'params-in-bracket': [
-            (r'\]', Keyword, ('#pop', '#pop')),
-            include('params')
-        ],
-        'string': [
-            (r'\[', String.Double, 'string-square'),
-            (r'(?s)(\\\\|\\[0-7]+|\\.|[^"\\])', String.Double),
-            (r'"', String.Double, '#pop')
-        ],
-        'string-square': [
-            (r'\[', String.Double, 'string-square'),
-            (r'(?s)(\\\\|\\[0-7]+|\\.|\\\n|[^\]\\])', String.Double),
-            (r'\]', String.Double, '#pop')
-        ],
-        'brace': [
-            (r'\}', Keyword, '#pop'),
-            include('command-in-brace'),
-            include('basic'),
-            include('data'),
-        ],
-        'paren': [
-            (r'\)', Keyword, '#pop'),
-            include('command-in-paren'),
-            include('basic'),
-            include('data'),
-        ],
-        'bracket': [
-            (r'\]', Keyword, '#pop'),
-            include('command-in-bracket'),
-            include('basic'),
-            include('data'),
-        ],
-        'comment': [
-            (r'.*[^\\]\n', Comment, '#pop'),
-            (r'.*\\\n', Comment),
-        ],
-    }
-
-    def analyse_text(text):
-        return shebang_matches(text, r'(tcl)')

venv/Lib/site-packages/pygments/lexers/teal.py

@@ -1,88 +0,0 @@
-"""
-    pygments.lexers.teal
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for TEAL.
-
-    :copyright: Copyright 2006-2025 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, \
-    Whitespace
-
-__all__ = ['TealLexer']
-
-
-class TealLexer(RegexLexer):
-    """
-    For the Transaction Execution Approval Language (TEAL)
-
-    For more information about the grammar, see:
-    https://github.com/algorand/go-algorand/blob/master/data/transactions/logic/assembler.go
-    """
-    name = 'teal'
-    url = 'https://developer.algorand.org/docs/reference/teal/specification/'
-    aliases = ['teal']
-    filenames = ['*.teal']
-    version_added = '2.9'
-
-    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]+', Whitespace),
-            (r'//[^\n]+', Comment.Single),
-        ],
-    }