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

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

@@ -1,110 +0,0 @@
-"""
-    pygments.lexers.func
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for FunC.
-
-    :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, Punctuation
-
-__all__ = ['FuncLexer']
-
-
-class FuncLexer(RegexLexer):
-    """
-    For FunC source code.
-    """
-
-    name = 'FunC'
-    aliases = ['func', 'fc']
-    filenames = ['*.fc', '*.func']
-    url = 'https://docs.ton.org/develop/func/overview'
-    version_added = ''
-
-    # 1. Does not start from "
-    # 2. Can start from ` and end with `, containing any character
-    # 3. Starts with underscore or { or } and have more than 1 character after it
-    # 4. Starts with letter, contains letters, numbers and underscores
-    identifier = r'(?!")(`([^`]+)`|((?=_)_|(?=\{)\{|(?=\})\}|(?![_`{}]))([^;,\[\]\(\)\s~.]+))'
-
-    tokens = {
-        'root': [
-            (r'\n', Whitespace),
-            (r'\s+', Whitespace),
-
-            include('keywords'),
-            include('strings'),
-            include('directives'),
-            include('numeric'),
-            include('comments'),
-            include('storage'),
-            include('functions'),
-            include('variables'),
-
-            (r'[.;(),\[\]~{}]', Punctuation)
-        ],
-        'keywords': [
-            (words((
-                '<=>', '>=', '<=', '!=', '==', '^>>', '~>>',
-                '>>', '<<', '/%', '^%', '~%', '^/', '~/', '+=',
-                '-=', '*=', '/=', '~/=', '^/=', '%=', '^%=', '<<=',
-                '>>=', '~>>=', '^>>=', '&=', '|=', '^=', '^', '=',
-                '~', '/', '%', '-', '*', '+','>',
-                '<', '&', '|', ':', '?'), prefix=r'(?<=\s)', suffix=r'(?=\s)'),
-             Operator),
-            (words((
-                'if', 'ifnot',
-                'else', 'elseif', 'elseifnot',
-                'while', 'do', 'until', 'repeat',
-                'return', 'impure', 'method_id',
-                'forall', 'asm', 'inline', 'inline_ref'), prefix=r'\b', suffix=r'\b'),
-             Keyword),
-            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
-        ],
-        'directives': [
-            (r'#include|#pragma', Keyword, 'directive'),
-        ],
-        'directive': [
-            include('strings'),
-            (r'\s+', Whitespace),
-            (r'version|not-version', Keyword),
-            (r'(>=|<=|=|>|<|\^)?([0-9]+)(.[0-9]+)?(.[0-9]+)?', Number), # version
-            (r';', Text, '#pop')
-        ],
-        'strings': [
-            (r'\"([^\n\"]+)\"[Hhcusa]?', String),
-        ],
-        'numeric': [
-            (r'\b(-?(?!_)([\d_]+|0x[\d_a-fA-F]+)|0b[1_0]+)(?<!_)(?=[\s\)\],;])', Number)
-        ],
-        'comments': [
-            (r';;([^\n]*)', Comment.Singleline),
-            (r'\{-', Comment.Multiline, 'comment'),
-        ],
-        'comment': [
-            (r'[^-}{]+', Comment.Multiline),
-            (r'\{-', Comment.Multiline, '#push'),
-            (r'-\}', Comment.Multiline, '#pop'),
-            (r'[-}{]', Comment.Multiline),
-        ],
-        'storage': [
-            (words((
-                'var', 'int', 'slice', 'tuple',
-                'cell', 'builder', 'cont', '_'),
-                prefix=r'\b', suffix=r'(?=[\s\(\),\[\]])'),
-             Keyword.Type),
-            (words(('global', 'const'), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
-        ],
-        'variables': [
-            (identifier, Name.Variable),
-        ],
-        'functions': [
-            # identifier followed by (
-            (identifier + r'(?=[\(])', Name.Function),
-        ]
-    }

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

@@ -1,21 +0,0 @@
-"""
-    pygments.lexers.functional
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Just export lexer classes previously contained in this module.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-# ruff: noqa: F401
-from pygments.lexers.lisp import SchemeLexer, CommonLispLexer, RacketLexer, \
-    NewLispLexer, ShenLexer
-from pygments.lexers.haskell import HaskellLexer, LiterateHaskellLexer, \
-    KokaLexer
-from pygments.lexers.theorem import CoqLexer
-from pygments.lexers.erlang import ErlangLexer, ErlangShellLexer, \
-    ElixirConsoleLexer, ElixirLexer
-from pygments.lexers.ml import SMLLexer, OcamlLexer, OpaLexer
-
-__all__ = []

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

@@ -1,105 +0,0 @@
-"""
-    pygments.lexers.futhark
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for the Futhark language
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, bygroups
-from pygments.token import Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-from pygments import unistring as uni
-
-__all__ = ['FutharkLexer']
-
-
-class FutharkLexer(RegexLexer):
-    """
-    A Futhark lexer
-    """
-    name = 'Futhark'
-    url = 'https://futhark-lang.org/'
-    aliases = ['futhark']
-    filenames = ['*.fut']
-    mimetypes = ['text/x-futhark']
-    version_added = '2.8'
-
-    num_types = ('i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64')
-
-    other_types = ('bool', )
-
-    reserved = ('if', 'then', 'else', 'def', 'let', 'loop', 'in', 'with',
-                'type', 'type~', 'type^',
-                'val', 'entry', 'for', 'while', 'do', 'case', 'match',
-                'include', 'import', 'module', 'open', 'local', 'assert', '_')
-
-    ascii = ('NUL', 'SOH', '[SE]TX', 'EOT', 'ENQ', 'ACK',
-             'BEL', 'BS', 'HT', 'LF', 'VT', 'FF', 'CR', 'S[OI]', 'DLE',
-             'DC[1-4]', 'NAK', 'SYN', 'ETB', 'CAN',
-             'EM', 'SUB', 'ESC', '[FGRU]S', 'SP', 'DEL')
-
-    num_postfix = r'({})?'.format('|'.join(num_types))
-
-    identifier_re = '[a-zA-Z_][a-zA-Z_0-9\']*'
-
-    # opstart_re = '+\-\*/%=\!><\|&\^'
-
-    tokens = {
-        'root': [
-            (r'--(.*?)$', Comment.Single),
-            (r'\s+', Whitespace),
-            (r'\(\)', Punctuation),
-            (r'\b({})(?!\')\b'.format('|'.join(reserved)), Keyword.Reserved),
-            (r'\b({})(?!\')\b'.format('|'.join(num_types + other_types)), Keyword.Type),
-
-            # Identifiers
-            (r'#\[([a-zA-Z_\(\) ]*)\]', Comment.Preproc),
-            (rf'[#!]?({identifier_re}\.)*{identifier_re}', Name),
-
-            (r'\\', Operator),
-            (r'[-+/%=!><|&*^][-+/%=!><|&*^.]*', Operator),
-            (r'[][(),:;`{}?.\'~^]', Punctuation),
-
-            #  Numbers
-            (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*_*[pP][+-]?\d(_*\d)*' + num_postfix,
-             Number.Float),
-            (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*\.[\da-fA-F](_*[\da-fA-F])*'
-             r'(_*[pP][+-]?\d(_*\d)*)?' + num_postfix, Number.Float),
-            (r'\d(_*\d)*_*[eE][+-]?\d(_*\d)*' + num_postfix, Number.Float),
-            (r'\d(_*\d)*\.\d(_*\d)*(_*[eE][+-]?\d(_*\d)*)?' + num_postfix, Number.Float),
-            (r'0[bB]_*[01](_*[01])*' + num_postfix, Number.Bin),
-            (r'0[xX]_*[\da-fA-F](_*[\da-fA-F])*' + num_postfix, Number.Hex),
-            (r'\d(_*\d)*' + num_postfix, Number.Integer),
-
-            #  Character/String Literals
-            (r"'", String.Char, 'character'),
-            (r'"', String, 'string'),
-            #  Special
-            (r'\[[a-zA-Z_\d]*\]', Keyword.Type),
-            (r'\(\)', Name.Builtin),
-        ],
-        'character': [
-            # Allows multi-chars, incorrectly.
-            (r"[^\\']'", String.Char, '#pop'),
-            (r"\\", String.Escape, 'escape'),
-            ("'", String.Char, '#pop'),
-        ],
-        'string': [
-            (r'[^\\"]+', String),
-            (r"\\", String.Escape, 'escape'),
-            ('"', String, '#pop'),
-        ],
-
-        'escape': [
-            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
-            (r'\^[][' + uni.Lu + r'@^_]', String.Escape, '#pop'),
-            ('|'.join(ascii), String.Escape, '#pop'),
-            (r'o[0-7]+', String.Escape, '#pop'),
-            (r'x[\da-fA-F]+', String.Escape, '#pop'),
-            (r'\d+', String.Escape, '#pop'),
-            (r'(\s+)(\\)', bygroups(Whitespace, String.Escape), '#pop'),
-        ],
-    }

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

@@ -1,35 +0,0 @@
-"""
-    pygments.lexers.gcodelexer
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for the G Code Language.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, bygroups
-from pygments.token import Comment, Name, Text, Keyword, Number
-
-__all__ = ['GcodeLexer']
-
-
-class GcodeLexer(RegexLexer):
-    """
-    For gcode source code.
-    """
-    name = 'g-code'
-    aliases = ['gcode']
-    filenames = ['*.gcode']
-    url = 'https://en.wikipedia.org/wiki/G-code'
-    version_added = '2.9'
-
-    tokens = {
-        'root': [
-            (r';.*\n', Comment),
-            (r'^[gmGM]\d{1,4}\s', Name.Builtin),  # M or G commands
-            (r'([^gGmM])([+-]?\d*[.]?\d+)', bygroups(Keyword, Number)),
-            (r'\s', Text.Whitespace),
-            (r'.*\n', Text),
-        ]
-    }

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

@@ -1,189 +0,0 @@
-"""
-    pygments.lexers.gdscript
-    ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for GDScript.
-
-    Modified by Daniel J. Ramirez <djrmuv@gmail.com> based on the original
-    python.py.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import RegexLexer, include, bygroups, default, words, \
-    combined
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ["GDScriptLexer"]
-
-
-class GDScriptLexer(RegexLexer):
-    """
-    For GDScript source code.
-    """
-
-    name = "GDScript"
-    url = 'https://www.godotengine.org'
-    aliases = ["gdscript", "gd"]
-    filenames = ["*.gd"]
-    mimetypes = ["text/x-gdscript", "application/x-gdscript"]
-    version_added = ''
-
-    def innerstring_rules(ttype):
-        return [
-            # the old style '%s' % (...) string formatting
-            (r"%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?"
-             "[hlL]?[E-GXc-giorsux%]",
-             String.Interpol),
-            # backslashes, quotes and formatting signs must be parsed one at a time
-            (r'[^\\\'"%\n]+', ttype),
-            (r'[\'"\\]', ttype),
-            # unhandled string formatting sign
-            (r"%", ttype),
-            # newlines are an error (use "nl" state)
-        ]
-
-    tokens = {
-        "root": [
-            (r"\n", Whitespace),
-            (r'^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")',
-             bygroups(Whitespace, String.Affix, String.Doc)),
-            (r"^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')",
-             bygroups(Whitespace, String.Affix, String.Doc)),
-            (r"[^\S\n]+", Whitespace),
-            (r"#.*$", Comment.Single),
-            (r"[]{}:(),;[]", Punctuation),
-            (r"(\\)(\n)", bygroups(Text, Whitespace)),
-            (r"\\", Text),
-            (r"(in|and|or|not)\b", Operator.Word),
-            (r"!=|==|<<|>>|&&|\+=|-=|\*=|/=|%=|&=|\|=|\|\||[-~+/*%=<>&^.!|$]",
-             Operator),
-            include("keywords"),
-            (r"(func)(\s+)", bygroups(Keyword, Whitespace), "funcname"),
-            (r"(class)(\s+)", bygroups(Keyword, Whitespace), "classname"),
-            include("builtins"),
-            ('([rR]|[uUbB][rR]|[rR][uUbB])(""")',
-             bygroups(String.Affix, String.Double),
-             "tdqs"),
-            ("([rR]|[uUbB][rR]|[rR][uUbB])(''')",
-             bygroups(String.Affix, String.Single),
-             "tsqs"),
-            ('([rR]|[uUbB][rR]|[rR][uUbB])(")',
-             bygroups(String.Affix, String.Double),
-             "dqs"),
-            ("([rR]|[uUbB][rR]|[rR][uUbB])(')",
-             bygroups(String.Affix, String.Single),
-             "sqs"),
-            ('([uUbB]?)(""")',
-             bygroups(String.Affix, String.Double),
-             combined("stringescape", "tdqs")),
-            ("([uUbB]?)(''')",
-             bygroups(String.Affix, String.Single),
-             combined("stringescape", "tsqs")),
-            ('([uUbB]?)(")',
-             bygroups(String.Affix, String.Double),
-             combined("stringescape", "dqs")),
-            ("([uUbB]?)(')",
-             bygroups(String.Affix, String.Single),
-             combined("stringescape", "sqs")),
-            include("name"),
-            include("numbers"),
-        ],
-        "keywords": [
-            (words(("and", "in", "not", "or", "as", "breakpoint", "class",
-                    "class_name", "extends", "is", "func", "setget", "signal",
-                    "tool", "const", "enum", "export", "onready", "static",
-                    "var", "break", "continue", "if", "elif", "else", "for",
-                    "pass", "return", "match", "while", "remote", "master",
-                    "puppet", "remotesync", "mastersync", "puppetsync"),
-                   suffix=r"\b"), Keyword),
-        ],
-        "builtins": [
-            (words(("Color8", "ColorN", "abs", "acos", "asin", "assert", "atan",
-                    "atan2", "bytes2var", "ceil", "char", "clamp", "convert",
-                    "cos", "cosh", "db2linear", "decimals", "dectime", "deg2rad",
-                    "dict2inst", "ease", "exp", "floor", "fmod", "fposmod",
-                    "funcref", "hash", "inst2dict", "instance_from_id", "is_inf",
-                    "is_nan", "lerp", "linear2db", "load", "log", "max", "min",
-                    "nearest_po2", "pow", "preload", "print", "print_stack",
-                    "printerr", "printraw", "prints", "printt", "rad2deg",
-                    "rand_range", "rand_seed", "randf", "randi", "randomize",
-                    "range", "round", "seed", "sign", "sin", "sinh", "sqrt",
-                    "stepify", "str", "str2var", "tan", "tan", "tanh",
-                    "type_exist", "typeof", "var2bytes", "var2str", "weakref",
-                    "yield"), prefix=r"(?<!\.)", suffix=r"\b"),
-             Name.Builtin),
-            (r"((?<!\.)(self|false|true)|(PI|TAU|NAN|INF)" r")\b",
-             Name.Builtin.Pseudo),
-            (words(("bool", "int", "float", "String", "NodePath", "Vector2",
-                    "Rect2", "Transform2D", "Vector3", "Rect3", "Plane", "Quat",
-                    "Basis", "Transform", "Color", "RID", "Object", "NodePath",
-                    "Dictionary", "Array", "PackedByteArray", "PackedInt32Array",
-                    "PackedInt64Array", "PackedFloat32Array", "PackedFloat64Array",
-                    "PackedStringArray", "PackedVector2Array", "PackedVector3Array",
-                    "PackedColorArray", "null", "void"),
-                   prefix=r"(?<!\.)", suffix=r"\b"),
-             Name.Builtin.Type),
-        ],
-        "numbers": [
-            (r"(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?", Number.Float),
-            (r"\d+[eE][+-]?[0-9]+j?", Number.Float),
-            (r"0[xX][a-fA-F0-9]+", Number.Hex),
-            (r"\d+j?", Number.Integer),
-        ],
-        "name": [(r"[a-zA-Z_]\w*", Name)],
-        "funcname": [(r"[a-zA-Z_]\w*", Name.Function, "#pop"), default("#pop")],
-        "classname": [(r"[a-zA-Z_]\w*", Name.Class, "#pop")],
-        "stringescape": [
-            (
-                r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
-                r"U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})",
-                String.Escape,
-            )
-        ],
-        "strings-single": innerstring_rules(String.Single),
-        "strings-double": innerstring_rules(String.Double),
-        "dqs": [
-            (r'"', String.Double, "#pop"),
-            (r'\\\\|\\"|\\\n', String.Escape),  # included here for raw strings
-            include("strings-double"),
-        ],
-        "sqs": [
-            (r"'", String.Single, "#pop"),
-            (r"\\\\|\\'|\\\n", String.Escape),  # included here for raw strings
-            include("strings-single"),
-        ],
-        "tdqs": [
-            (r'"""', String.Double, "#pop"),
-            include("strings-double"),
-            (r"\n", Whitespace),
-        ],
-        "tsqs": [
-            (r"'''", String.Single, "#pop"),
-            include("strings-single"),
-            (r"\n", Whitespace),
-        ],
-    }
-
-    def analyse_text(text):
-        score = 0.0
-
-        if re.search(
-            r"func (_ready|_init|_input|_process|_unhandled_input)", text
-        ):
-            score += 0.8
-
-        if re.search(
-            r"(extends |class_name |onready |preload|load|setget|func [^_])",
-            text
-        ):
-            score += 0.4
-
-        if re.search(r"(var|const|enum|export|signal|tool)", text):
-            score += 0.2
-
-        return min(score, 1.0)

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

@@ -1,74 +0,0 @@
-"""
-    pygments.lexers.gleam
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for the Gleam programming language.
-
-    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, words, bygroups
-from pygments.token import Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ['GleamLexer']
-
-
-class GleamLexer(RegexLexer):
-    """
-    Lexer for the Gleam programming language (version 1.0.0).
-    """
-
-    name = 'Gleam'
-    url = 'https://gleam.run/'
-    filenames = ['*.gleam']
-    aliases = ['gleam']
-    mimetypes = ['text/x-gleam']
-    version_added = '2.19'
-
-    keywords = words((
-        'as', 'assert', 'auto', 'case', 'const', 'delegate', 'derive', 'echo',
-        'else', 'fn', 'if', 'implement', 'import', 'let', 'macro', 'opaque',
-        'panic', 'pub', 'test', 'todo', 'type', 'use',
-    ), suffix=r'\b')
-
-    tokens = {
-        'root': [
-            # Comments
-            (r'(///.*?)(\n)', bygroups(String.Doc, Whitespace)),
-            (r'(//.*?)(\n)', bygroups(Comment.Single, Whitespace)),
-
-            # Keywords
-            (keywords, Keyword),
-            (r'([a-zA-Z_]+)(\.)', bygroups(Keyword, Punctuation)),
-
-            # Punctuation
-            (r'[()\[\]{}:;,@]+', Punctuation),
-            (r'(#|!=|!|==|\|>|\|\||\||\->|<\-|&&|<<|>>|\.\.|\.|=)', Punctuation),
-
-            # Operators
-            (r'(<>|\+\.?|\-\.?|\*\.?|/\.?|%\.?|<=\.?|>=\.?|<\.?|>\.?|=)', Operator),
-
-            # Strings
-            (r'"(\\"|[^"])*"', String),
-
-            # Identifiers
-            (r'\b(let)(\s+)(\w+)', bygroups(Keyword, Whitespace, Name.Variable)),
-            (r'\b(fn)(\s+)(\w+)', bygroups(Keyword, Whitespace, Name.Function)),
-            (r'[a-zA-Z_/]\w*', Name),
-
-            # numbers
-            (r'(\d+(_\d+)*\.(?!\.)(\d+(_\d+)*)?|\.\d+(_\d+)*)([eEf][+-]?[0-9]+)?', Number.Float),
-            (r'\d+(_\d+)*[eEf][+-]?[0-9]+', Number.Float),
-            (r'0[xX][a-fA-F0-9]+(_[a-fA-F0-9]+)*(\.([a-fA-F0-9]+(_[a-fA-F0-9]+)*)?)?p[+-]?\d+', Number.Float),
-            (r'0[bB][01]+(_[01]+)*', Number.Bin),
-            (r'0[oO][0-7]+(_[0-7]+)*', Number.Oct),
-            (r'0[xX][a-fA-F0-9]+(_[a-fA-F0-9]+)*', Number.Hex),
-            (r'\d+(_\d+)*', Number.Integer),
-
-            # Whitespace
-            (r'\s+', Whitespace),
-
-        ],
-    }

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

@@ -1,97 +0,0 @@
-"""
-    pygments.lexers.go
-    ~~~~~~~~~~~~~~~~~~
-
-    Lexers for the Google Go 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 Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Whitespace
-
-__all__ = ['GoLexer']
-
-
-class GoLexer(RegexLexer):
-    """
-    For Go source.
-    """
-    name = 'Go'
-    url = 'https://go.dev/'
-    filenames = ['*.go']
-    aliases = ['go', 'golang']
-    mimetypes = ['text/x-gosrc']
-    version_added = '1.2'
-
-    tokens = {
-        'root': [
-            (r'\n', Whitespace),
-            (r'\s+', Whitespace),
-            (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuations
-            (r'//(.*?)$', Comment.Single),
-            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
-            (r'(import|package)\b', Keyword.Namespace),
-            (r'(var|func|struct|map|chan|type|interface|const)\b',
-             Keyword.Declaration),
-            (words((
-                'break', 'default', 'select', 'case', 'defer', 'go',
-                'else', 'goto', 'switch', 'fallthrough', 'if', 'range',
-                'continue', 'for', 'return'), suffix=r'\b'),
-             Keyword),
-            (r'(true|false|iota|nil)\b', Keyword.Constant),
-            # It seems the builtin types aren't actually keywords, but
-            # can be used as functions. So we need two declarations.
-            (words((
-                'uint', 'uint8', 'uint16', 'uint32', 'uint64',
-                'int', 'int8', 'int16', 'int32', 'int64',
-                'float', 'float32', 'float64',
-                'complex64', 'complex128', 'byte', 'rune',
-                'string', 'bool', 'error', 'uintptr', 'any', 'comparable',
-                'print', 'println', 'panic', 'recover', 'close', 'complex',
-                'real', 'imag', 'len', 'cap', 'append', 'copy', 'delete',
-                'new', 'make', 'min', 'max', 'clear'), suffix=r'\b(\()'),
-             bygroups(Name.Builtin, Punctuation)),
-            (words((
-                'uint', 'uint8', 'uint16', 'uint32', 'uint64',
-                'int', 'int8', 'int16', 'int32', 'int64',
-                'float', 'float32', 'float64',
-                'complex64', 'complex128', 'byte', 'rune',
-                'string', 'bool', 'error', 'uintptr', 'any', 'comparable'), suffix=r'\b'),
-             Keyword.Type),
-            # imaginary_lit
-            (r'\d+i', Number),
-            (r'\d+\.\d*([Ee][-+]\d+)?i', Number),
-            (r'\.\d+([Ee][-+]\d+)?i', Number),
-            (r'\d+[Ee][-+]\d+i', Number),
-            # float_lit
-            (r'\d+(\.\d+[eE][+\-]?\d+|'
-             r'\.\d*|[eE][+\-]?\d+)', Number.Float),
-            (r'\.\d+([eE][+\-]?\d+)?', Number.Float),
-            # int_lit
-            # -- octal_lit
-            (r'0[0-7]+', Number.Oct),
-            # -- hex_lit
-            (r'0[xX][0-9a-fA-F]+', Number.Hex),
-            # -- decimal_lit
-            (r'(0|[1-9][0-9]*)', Number.Integer),
-            # char_lit
-            (r"""'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}"""
-             r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'""",
-             String.Char),
-            # StringLiteral
-            # -- raw_string_lit
-            (r'`[^`]*`', String),
-            # -- interpreted_string_lit
-            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
-            # Tokens
-            (r'(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\|'
-             r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&]'
-             r'|~|\|)', Operator),
-            (r'[|^<>=!()\[\]{}.,;:]', Punctuation),
-            # identifier
-            (r'[^\W\d]\w*', Name.Other),
-        ]
-    }