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

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

@@ -1,189 +0,0 @@
-"""
-    pygments.lexers.varnish
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Varnish configuration
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, include, bygroups, using, this, \
-    inherit, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Literal, Whitespace
-
-__all__ = ['VCLLexer', 'VCLSnippetLexer']
-
-
-class VCLLexer(RegexLexer):
-    """
-    For Varnish Configuration Language (VCL).
-    """
-    name = 'VCL'
-    aliases = ['vcl']
-    filenames = ['*.vcl']
-    mimetypes = ['text/x-vclsrc']
-    url = 'https://www.varnish-software.com/developers/tutorials/varnish-configuration-language-vcl'
-    version_added = '2.2'
-
-    def analyse_text(text):
-        # If the very first line is 'vcl 4.0;' it's pretty much guaranteed
-        # that this is VCL
-        if text.startswith('vcl 4.0;'):
-            return 1.0
-        # Skip over comments and blank lines
-        # This is accurate enough that returning 0.9 is reasonable.
-        # Almost no VCL files start without some comments.
-        elif '\nvcl 4.0;' in text[:1000]:
-            return 0.9
-
-    tokens = {
-        'probe': [
-            include('whitespace'),
-            include('comments'),
-            (r'(\.\w+)(\s*=\s*)([^;]*)(;)',
-             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
-            (r'\}', Punctuation, '#pop'),
-        ],
-        'acl': [
-            include('whitespace'),
-            include('comments'),
-            (r'[!/]+', Operator),
-            (r';', Punctuation),
-            (r'\d+', Number),
-            (r'\}', Punctuation, '#pop'),
-        ],
-        'backend': [
-            include('whitespace'),
-            (r'(\.probe)(\s*=\s*)(\w+)(;)',
-             bygroups(Name.Attribute, Operator, Name.Variable.Global, Punctuation)),
-            (r'(\.probe)(\s*=\s*)(\{)',
-             bygroups(Name.Attribute, Operator, Punctuation), 'probe'),
-            (r'(\.\w+\b)(\s*=\s*)([^;\s]*)(\s*;)',
-             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
-            (r'\{', Punctuation, '#push'),
-            (r'\}', Punctuation, '#pop'),
-        ],
-        'statements': [
-            (r'(\d\.)?\d+[sdwhmy]', Literal.Date),
-            (r'(\d\.)?\d+ms', Literal.Date),
-            (r'(vcl_pass|vcl_hash|vcl_hit|vcl_init|vcl_backend_fetch|vcl_pipe|'
-             r'vcl_backend_response|vcl_synth|vcl_deliver|vcl_backend_error|'
-             r'vcl_fini|vcl_recv|vcl_purge|vcl_miss)\b', Name.Function),
-            (r'(pipe|retry|hash|synth|deliver|purge|abandon|lookup|pass|fail|ok|'
-             r'miss|fetch|restart)\b', Name.Constant),
-            (r'(beresp|obj|resp|req|req_top|bereq)\.http\.[a-zA-Z_-]+\b', Name.Variable),
-            (words((
-                'obj.status', 'req.hash_always_miss', 'beresp.backend', 'req.esi_level',
-                'req.can_gzip', 'beresp.ttl', 'obj.uncacheable', 'req.ttl', 'obj.hits',
-                'client.identity', 'req.hash_ignore_busy', 'obj.reason', 'req.xid',
-                'req_top.proto', 'beresp.age', 'obj.proto', 'obj.age', 'local.ip',
-                'beresp.uncacheable', 'req.method', 'beresp.backend.ip', 'now',
-                'obj.grace', 'req.restarts', 'beresp.keep', 'req.proto', 'resp.proto',
-                'bereq.xid', 'bereq.between_bytes_timeout', 'req.esi',
-                'bereq.first_byte_timeout', 'bereq.method', 'bereq.connect_timeout',
-                'beresp.do_gzip',  'resp.status', 'beresp.do_gunzip',
-                'beresp.storage_hint', 'resp.is_streaming', 'beresp.do_stream',
-                'req_top.method', 'bereq.backend', 'beresp.backend.name', 'beresp.status',
-                'req.url', 'obj.keep', 'obj.ttl', 'beresp.reason', 'bereq.retries',
-                'resp.reason', 'bereq.url', 'beresp.do_esi', 'beresp.proto', 'client.ip',
-                'bereq.proto', 'server.hostname', 'remote.ip', 'req.backend_hint',
-                'server.identity', 'req_top.url', 'beresp.grace', 'beresp.was_304',
-                'server.ip', 'bereq.uncacheable'), suffix=r'\b'),
-             Name.Variable),
-            (r'[!%&+*\-,/<.}{>=|~]+', Operator),
-            (r'[();]', Punctuation),
-
-            (r'[,]+', Punctuation),
-            (words(('hash_data', 'regsub', 'regsuball', 'if', 'else',
-                    'elsif', 'elif', 'synth', 'synthetic', 'ban',
-                    'return', 'set', 'unset', 'import', 'include', 'new',
-                    'rollback', 'call'), suffix=r'\b'),
-             Keyword),
-            (r'storage\.\w+\.\w+\b', Name.Variable),
-            (words(('true', 'false')), Name.Builtin),
-            (r'\d+\b', Number),
-            (r'(backend)(\s+\w+)(\s*\{)',
-             bygroups(Keyword, Name.Variable.Global, Punctuation), 'backend'),
-            (r'(probe\s)(\s*\w+\s)(\{)',
-             bygroups(Keyword, Name.Variable.Global, Punctuation), 'probe'),
-            (r'(acl\s)(\s*\w+\s)(\{)',
-             bygroups(Keyword, Name.Variable.Global, Punctuation), 'acl'),
-            (r'(vcl )(4.0)(;)$',
-             bygroups(Keyword.Reserved, Name.Constant, Punctuation)),
-            (r'(sub\s+)([a-zA-Z]\w*)(\s*\{)',
-                bygroups(Keyword, Name.Function, Punctuation)),
-            (r'([a-zA-Z_]\w*)'
-             r'(\.)'
-             r'([a-zA-Z_]\w*)'
-             r'(\s*\(.*\))',
-             bygroups(Name.Function, Punctuation, Name.Function, using(this))),
-            (r'[a-zA-Z_]\w*', Name),
-        ],
-        'comment': [
-            (r'[^*/]+', Comment.Multiline),
-            (r'/\*', Comment.Multiline, '#push'),
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline),
-        ],
-        'comments': [
-            (r'#.*$', Comment),
-            (r'/\*', Comment.Multiline, 'comment'),
-            (r'//.*$', Comment),
-        ],
-        'string': [
-            (r'"', String, '#pop'),
-            (r'[^"\n]+', String),  # all other characters
-        ],
-        'multistring': [
-            (r'[^"}]', String),
-            (r'"\}', String, '#pop'),
-            (r'["}]', String),
-        ],
-        'whitespace': [
-            (r'L?"', String, 'string'),
-            (r'\{"', String, 'multistring'),
-            (r'\n', Whitespace),
-            (r'\s+', Whitespace),
-            (r'\\\n', Text),  # line continuation
-        ],
-        'root': [
-            include('whitespace'),
-            include('comments'),
-            include('statements'),
-            (r'\s+', Whitespace),
-        ],
-    }
-
-
-class VCLSnippetLexer(VCLLexer):
-    """
-    For Varnish Configuration Language snippets.
-    """
-    name = 'VCLSnippets'
-    aliases = ['vclsnippets', 'vclsnippet']
-    mimetypes = ['text/x-vclsnippet']
-    filenames = []
-    url = 'https://www.varnish-software.com/developers/tutorials/varnish-configuration-language-vcl'
-    version_added = '2.2'
-
-    def analyse_text(text):
-        # override method inherited from VCLLexer
-        return 0
-
-    tokens = {
-        'snippetspre': [
-            (r'\.\.\.+', Comment),
-            (r'(bereq|req|req_top|resp|beresp|obj|client|server|local|remote|'
-             r'storage)($|\.\*)', Name.Variable),
-        ],
-        'snippetspost': [
-            (r'(backend)\b', Keyword.Reserved),
-        ],
-        'root': [
-            include('snippetspre'),
-            inherit,
-            include('snippetspost'),
-        ],
-    }

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

@@ -1,113 +0,0 @@
-"""
-    pygments.lexers.verification
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for Intermediate Verification Languages (IVLs).
-
-    :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 Comment, Operator, Keyword, Name, Number, \
-    Punctuation, Text, Generic
-
-__all__ = ['BoogieLexer', 'SilverLexer']
-
-
-class BoogieLexer(RegexLexer):
-    """
-    For Boogie source code.
-    """
-    name = 'Boogie'
-    url = 'https://boogie-docs.readthedocs.io/en/latest/'
-    aliases = ['boogie']
-    filenames = ['*.bpl']
-    version_added = '2.1'
-
-    tokens = {
-        'root': [
-            # Whitespace and Comments
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
-            (r'//[/!](.*?)\n', Comment.Doc),
-            (r'//(.*?)\n', Comment.Single),
-            (r'/\*', Comment.Multiline, 'comment'),
-
-            (words((
-                'axiom', 'break', 'call', 'ensures', 'else', 'exists', 'function',
-                'forall', 'if', 'invariant', 'modifies', 'procedure',  'requires',
-                'then', 'var', 'while'),
-             suffix=r'\b'), Keyword),
-            (words(('const',), suffix=r'\b'), Keyword.Reserved),
-
-            (words(('bool', 'int', 'ref'), suffix=r'\b'), Keyword.Type),
-            include('numbers'),
-            (r"(>=|<=|:=|!=|==>|&&|\|\||[+/\-=>*<\[\]])", Operator),
-            (r'\{.*?\}', Generic.Emph), #triggers
-            (r"([{}():;,.])", Punctuation),
-            # Identifier
-            (r'[a-zA-Z_]\w*', Name),
-        ],
-        'comment': [
-            (r'[^*/]+', Comment.Multiline),
-            (r'/\*', Comment.Multiline, '#push'),
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline),
-        ],
-        'numbers': [
-            (r'[0-9]+', Number.Integer),
-        ],
-    }
-
-
-class SilverLexer(RegexLexer):
-    """
-    For Silver source code.
-    """
-    name = 'Silver'
-    aliases = ['silver']
-    filenames = ['*.sil', '*.vpr']
-    url = 'https://github.com/viperproject/silver'
-    version_added = '2.2'
-
-    tokens = {
-        'root': [
-            # Whitespace and Comments
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuation
-            (r'//[/!](.*?)\n', Comment.Doc),
-            (r'//(.*?)\n', Comment.Single),
-            (r'/\*', Comment.Multiline, 'comment'),
-
-            (words((
-                'result', 'true', 'false', 'null', 'method', 'function',
-                'predicate', 'program', 'domain', 'axiom', 'var', 'returns',
-                'field', 'define', 'fold', 'unfold', 'inhale', 'exhale', 'new', 'assert',
-                'assume', 'goto', 'while', 'if', 'elseif', 'else', 'fresh',
-                'constraining', 'Seq', 'Set', 'Multiset', 'union', 'intersection',
-                'setminus', 'subset', 'unfolding', 'in', 'old', 'forall', 'exists',
-                'acc', 'wildcard', 'write', 'none', 'epsilon', 'perm', 'unique',
-                'apply', 'package', 'folding', 'label', 'forperm'),
-             suffix=r'\b'), Keyword),
-            (words(('requires', 'ensures', 'invariant'), suffix=r'\b'), Name.Decorator),
-            (words(('Int', 'Perm', 'Bool', 'Ref', 'Rational'), suffix=r'\b'), Keyword.Type),
-            include('numbers'),
-            (r'[!%&*+=|?:<>/\-\[\]]', Operator),
-            (r'\{.*?\}', Generic.Emph), #triggers
-            (r'([{}():;,.])', Punctuation),
-            # Identifier
-            (r'[\w$]\w*', Name),
-        ],
-        'comment': [
-            (r'[^*/]+', Comment.Multiline),
-            (r'/\*', Comment.Multiline, '#push'),
-            (r'\*/', Comment.Multiline, '#pop'),
-            (r'[*/]', Comment.Multiline),
-        ],
-        'numbers': [
-            (r'[0-9]+', Number.Integer),
-        ],
-    }

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

@@ -1,65 +0,0 @@
-"""
-    pygments.lexers.verifpal
-    ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Verifpal languages.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, words, bygroups, default
-from pygments.token import Comment, Keyword, Name, String, Punctuation, \
-    Whitespace
-
-__all__ = ['VerifpalLexer']
-
-
-class VerifpalLexer(RegexLexer):
-    """
-    For Verifpal code.
-    """
-
-    name = 'Verifpal'
-    aliases = ['verifpal']
-    filenames = ['*.vp']
-    mimetypes = ['text/x-verifpal']
-    url = 'https://verifpal.com'
-    version_added = '2.16'
-
-    tokens = {
-        'root': [
-            (r'//.*$', Comment.Single),
-            (r'(principal)( +)(\w+)( *)(\[)(.*)$', bygroups(Name.Builtin, Whitespace, String, Whitespace, Punctuation, Whitespace)),
-            (r'(attacker)( *)(\[)( *)(passive|active)( *)(\])( *)$', bygroups(Name.Builtin, Whitespace, Punctuation, Whitespace, String, Whitespace, Punctuation, Whitespace)),
-            (r'(knows)( +)(private|public)( +)', bygroups(Name.Builtin, Whitespace, Keyword.Constant, Whitespace), 'shared'),
-            (r'(queries)( +)(\[)', bygroups(Name.Builtin, Whitespace, Punctuation), 'queries'),
-            (r'(\w+)( +)(->|→)( *)(\w+)( *)(\:)', bygroups(String, Whitespace, Punctuation, Whitespace, String, Whitespace, Punctuation), 'shared'),
-            (words(('generates', 'leaks'), suffix=r'\b'), Name.Builtin, 'shared'),
-            (words(( 'phase', 'precondition',), suffix=r'\b'), Name.Builtin),
-            (r'[\[\(\)\]\?:=→^,]', Punctuation),
-            (r'->', Punctuation),
-            (words(('password',), suffix=r'\b'), Keyword.Constant),
-            (words(('AEAD_DEC', 'AEAD_ENC', 'ASSERT', 'BLIND', 'CONCAT',
-                    'DEC', 'ENC', 'G', 'HASH', 'HKDF', 'MAC', 'PKE_DEC',
-                    'PKE_ENC', 'PW_HASH', 'RINGSIGN', 'RINGSIGNVERIF',
-                    'SHAMIR_JOIN', 'SHAMIR_SPLIT', 'SIGN', 'SIGNVERIF',
-                    'SPLIT', 'UNBLIND', '_', 'nil'), suffix=r'\b'),
-             Name.Function),
-            (r'\s+', Whitespace),
-            (r'\w+', Name.Variable),
-        ],
-        'shared': [
-            (r'[\^\[\],]', Punctuation),
-            (r' +', Whitespace),
-            (r'\w+', Name.Variable),
-            default('#pop')
-        ],
-        'queries': [
-            (r'\s+', Name.Variable),
-            (words(('confidentiality?', 'authentication?', 'freshness?',
-                    'unlinkability?', 'equivalence?'), suffix='( )'),
-             bygroups(Keyword.Pseudo, Whitespace), 'shared'),
-            default('#pop')
-        ]
-    }

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

@@ -1,150 +0,0 @@
-"""
-    pygments.lexers.vip
-    ~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Visual Prolog & Grammar files.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import RegexLexer, inherit, words, include
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ['VisualPrologLexer', 'VisualPrologGrammarLexer']
-
-
-class VisualPrologBaseLexer(RegexLexer):
-    minorendkw = ('try', 'foreach', 'if')
-    minorkwexp = ('and', 'catch', 'do', 'else', 'elseif', 'erroneous', 'externally', 'failure', 'finally', 'foreach', 'if', 'or', 'orelse', 'otherwise', 'then',
-                  'try', 'div', 'mod', 'rem', 'quot')
-    dockw = ('short', 'detail', 'end', 'withdomain')
-    tokens = {
-        'root': [
-            (r'\s+', Whitespace),
-            (words(minorendkw, prefix=r'\bend\s+', suffix=r'\b'), Keyword.Minor),
-            (r'end', Keyword),
-            (words(minorkwexp, suffix=r'\b'), Keyword.Minor),
-            (r'0[xo][\da-fA-F_]+', Number),
-            (r'((\d[\d_]*)?\.)?\d[\d_]*([eE][\-+]?\d+)?', Number),
-            (r'_\w*', Name.Variable.Anonymous),
-            (r'[A-Z]\w*', Name.Variable),
-            (r'@\w+', Name.Variable),
-            (r'[a-z]\w*', Name),
-            (r'/\*', Comment, 'comment'),
-            (r'\%', Comment, 'commentline'),
-            (r'"', String.Symbol, 'string'),
-            (r'\'', String.Symbol, 'stringsingle'),
-            (r'@"', String.Symbol, 'atstring'),
-            (r'[\-+*^/!?<>=~:]+', Operator),
-            (r'[$,.[\]|(){}\\]+', Punctuation),
-            (r'.', Text),
-        ],
-        'commentdoc': [
-            (words(dockw, prefix=r'@', suffix=r'\b'), Comment.Preproc),
-            (r'@', Comment),
-        ],
-        'commentline': [
-            include('commentdoc'),
-            (r'[^@\n]+', Comment),
-            (r'$', Comment, '#pop'),
-        ],
-        'comment': [
-            include('commentdoc'),
-            (r'[^@*/]+', Comment),
-            (r'/\*', Comment, '#push'),
-            (r'\*/', Comment, '#pop'),
-            (r'[*/]', Comment),
-        ],
-        'stringescape': [
-            (r'\\u[0-9a-fA-F]{4}', String.Escape),
-            (r'\\[\'"ntr\\]', String.Escape),
-        ],
-        'stringsingle': [
-            include('stringescape'),
-            (r'\'', String.Symbol, '#pop'),
-            (r'[^\'\\\n]+', String),
-            (r'\n', String.Escape.Error, '#pop'),
-        ],
-        'string': [
-            include('stringescape'),
-            (r'"', String.Symbol, '#pop'),
-            (r'[^"\\\n]+', String),
-            (r'\n', String.Escape.Error, '#pop'),
-        ],
-        'atstring': [
-            (r'""', String.Escape),
-            (r'"', String.Symbol, '#pop'),
-            (r'[^"]+', String),
-        ]
-    }
-
-
-class VisualPrologLexer(VisualPrologBaseLexer):
-    """Lexer for VisualProlog
-    """
-    name = 'Visual Prolog'
-    url = 'https://www.visual-prolog.com/'
-    aliases = ['visualprolog']
-    filenames = ['*.pro', '*.cl', '*.i', '*.pack', '*.ph']
-    version_added = '2.17'
-
-    majorkw = ('goal', 'namespace', 'interface', 'class', 'implement', 'where', 'open', 'inherits', 'supports', 'resolve',
-               'delegate', 'monitor', 'constants', 'domains', 'predicates', 'constructors', 'properties', 'clauses', 'facts')
-    minorkw = ('align', 'anyflow', 'as', 'bitsize', 'determ', 'digits', 'erroneous', 'externally', 'failure', 'from',
-               'guard', 'multi', 'nondeterm', 'or', 'orelse', 'otherwise', 'procedure', 'resolve', 'single', 'suspending')
-    directivekw = ('bininclude', 'else', 'elseif', 'endif', 'error', 'export', 'externally', 'from', 'grammargenerate',
-                   'grammarinclude', 'if', 'include', 'message', 'options', 'orrequires', 'requires', 'stringinclude', 'then')
-    tokens = {
-        'root': [
-            (words(minorkw, suffix=r'\b'), Keyword.Minor),
-            (words(majorkw, suffix=r'\b'), Keyword),
-            (words(directivekw, prefix='#', suffix=r'\b'), Keyword.Directive),
-            inherit
-        ]
-    }
-
-    def analyse_text(text):
-        """Competes with IDL and Prolog on *.pro; div. lisps on*.cl and SwigLexer on *.i"""
-        # These are *really* good indicators (and not conflicting with the other languages)
-        # end-scope first on line e.g. 'end implement'
-        # section keyword alone on line e.g. 'clauses'
-        if re.search(r'^\s*(end\s+(interface|class|implement)|(clauses|predicates|domains|facts|constants|properties)\s*$)', text):
-            return 0.98
-        else:
-            return 0
-
-
-class VisualPrologGrammarLexer(VisualPrologBaseLexer):
-    """Lexer for VisualProlog grammar
-    """
-
-    name = 'Visual Prolog Grammar'
-    url = 'https://www.visual-prolog.com/'
-    aliases = ['visualprologgrammar']
-    filenames = ['*.vipgrm']
-    version_added = '2.17'
-
-    majorkw = ('open', 'namespace', 'grammar', 'nonterminals',
-               'startsymbols', 'terminals', 'rules', 'precedence')
-    directivekw = ('bininclude', 'stringinclude')
-    tokens = {
-        'root': [
-            (words(majorkw, suffix=r'\b'), Keyword),
-            (words(directivekw, prefix='#', suffix=r'\b'), Keyword.Directive),
-            inherit
-        ]
-    }
-
-    def analyse_text(text):
-        """No competditors (currently)"""
-        # These are *really* good indicators
-        # end-scope first on line e.g. 'end grammar'
-        # section keyword alone on line e.g. 'rules'
-        if re.search(r'^\s*(end\s+grammar|(nonterminals|startsymbols|terminals|rules|precedence)\s*$)', text):
-            return 0.98
-        else:
-            return 0

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

@@ -1,140 +0,0 @@
-"""
-    pygments.lexers.vyper
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for the Vyper Smart Contract language.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, bygroups, words
-from pygments.token import (Comment, String, Name, Keyword, Number,
-                            Operator, Punctuation, Text, Whitespace)
-
-__all__ = ['VyperLexer']
-
-
-class VyperLexer(RegexLexer):
-    """For the Vyper smart contract language.
-    """
-    name = 'Vyper'
-    aliases = ['vyper']
-    filenames = ['*.vy']
-    url = "https://vyper.readthedocs.io"
-    version_added = '2.17'
-
-    tokens = {
-        'root': [
-            # Whitespace
-            (r'\s+', Whitespace),
-
-            # Line continuations
-            (r'(\\)(\n|\r\n|\r)', bygroups(Text, Whitespace)),
-
-            # Comments - inline and multiline
-            (r'#.*$', Comment.Single),
-            (r'\"\"\"', Comment.Multiline, 'multiline-comment'),
-
-            # Strings - single and double
-            (r"'", String.Single, 'single-string'),
-            (r'"', String.Double, 'double-string'),
-
-            # Functions (working)
-            (r'(def)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)',
-             bygroups(Keyword, Whitespace, Name.Function)),
-
-            # Event and Struct
-            (r'(event|struct|interface|log)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)',
-             bygroups(Keyword, Whitespace, Name.Class)),
-
-            # Imports
-            (r'(from)(\s+)(vyper\.\w+)(\s+)(import)(\s+)(\w+)',
-             bygroups(Keyword, Whitespace, Name.Namespace, Whitespace,
-                      Keyword, Whitespace, Name.Class)),
-
-            # Numeric Literals
-            (r'\b0x[0-9a-fA-F]+\b', Number.Hex),
-            (r'\b(\d{1,3}(?:_\d{3})*|\d+)\b', Number.Integer),
-            (r'\b\d+\.\d*\b', Number.Float),
-
-            # Keywords
-            (words(('def', 'event', 'pass', 'return', 'for', 'while', 'if', 'elif',
-                    'else', 'assert', 'raise', 'import', 'in', 'struct', 'implements',
-                    'interface', 'from', 'indexed', 'log', 'extcall', 'staticcall'),
-                   prefix=r'\b', suffix=r'\b'), Keyword),
-
-            # Visibility and State Mutability
-            (words(('public', 'private', 'view', 'pure', 'constant',
-                    'immutable', 'nonpayable'), prefix=r'\b', suffix=r'\b'),
-             Keyword.Declaration),
-
-            # Built-in Functions
-            (words(('bitwise_and', 'bitwise_not', 'bitwise_or', 'bitwise_xor', 'shift',
-                    'create_minimal_proxy_to', 'create_copy_of', 'create_from_blueprint',
-                    'ecadd', 'ecmul', 'ecrecover', 'keccak256', 'sha256', 'concat', 'convert',
-                    'uint2str', 'extract32', 'slice', 'abs', 'ceil', 'floor', 'max', 'max_value',
-                    'min', 'min_value', 'pow_mod256', 'sqrt', 'isqrt', 'uint256_addmod',
-                    'uint256_mulmod', 'unsafe_add', 'unsafe_sub', 'unsafe_mul', 'unsafe_div',
-                    'as_wei_value', 'blockhash', 'empty', 'len', 'method_id', '_abi_encode',
-                    '_abi_decode', 'print', 'range'), prefix=r'\b', suffix=r'\b'),
-             Name.Builtin),
-
-            # Built-in Variables and Attributes
-            (words(('msg.sender', 'msg.value', 'block.timestamp', 'block.number', 'msg.gas'),
-                   prefix=r'\b', suffix=r'\b'),
-             Name.Builtin.Pseudo),
-
-            (words(('uint', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',
-                    'int', 'int8', 'int16', 'int32', 'int64', 'int128', 'int256', 'bool',
-                    'decimal', 'bytes', 'bytes1', 'bytes2', 'bytes3', 'bytes4', 'bytes5',
-                    'bytes6', 'bytes7', 'bytes8', 'bytes9', 'bytes10', 'bytes11',
-                    'bytes12', 'bytes13', 'bytes14', 'bytes15', 'bytes16', 'bytes17',
-                    'bytes18', 'bytes19', 'bytes20', 'bytes21', 'bytes22', 'bytes23',
-                    'bytes24', 'bytes25', 'bytes26', 'bytes27', 'bytes28', 'bytes29',
-                    'bytes30', 'bytes31', 'bytes32', 'string', 'String', 'address',
-                    'enum', 'struct'), prefix=r'\b', suffix=r'\b'),
-             Keyword.Type),
-
-            # indexed keywords
-            (r'\b(indexed)\b(\s*)(\()(\s*)(\w+)(\s*)(\))',
-             bygroups(Keyword, Whitespace, Punctuation, Whitespace,
-                      Keyword.Type, Punctuation)),
-
-            # Operators and Punctuation
-            (r'(\+|\-|\*|\/|<=?|>=?|==|!=|=|\||&|%)', Operator),
-            (r'[.,:;()\[\]{}]', Punctuation),
-
-            # Other variable names and types
-            (r'@[\w.]+', Name.Decorator),
-            (r'__\w+__', Name.Magic),  # Matches double underscores followed by word characters
-            (r'EMPTY_BYTES32', Name.Constant),
-            (r'\bERC20\b', Name.Class),
-            (r'\bself\b', Name.Attribute),
-
-            (r'Bytes\[\d+\]', Keyword.Type),
-
-            # Generic names and variables
-            (r'\b[a-zA-Z_]\w*\b:', Name.Variable),
-            (r'\b[a-zA-Z_]\w*\b', Name),
-
-        ],
-
-        'multiline-comment': [
-            (r'\"\"\"', Comment.Multiline, '#pop'),
-            (r'[^"]+', Comment.Multiline),
-            (r'\"', Comment.Multiline)
-        ],
-
-        'single-string': [
-            (r"[^\\']+", String.Single),
-            (r"'", String.Single, '#pop'),
-            (r'\\.', String.Escape),
-        ],
-
-        'double-string': [
-            (r'[^\\"]+', String.Double),
-            (r'"', String.Double, '#pop'),
-            (r'\\.', String.Escape),
-        ]
-    }