pygments.rb 2.2.0 → 2.3.0

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

@@ -26,6 +26,38 @@ class ChapelLexer(RegexLexer):
     aliases = ['chapel', 'chpl']
     # mimetypes = ['text/x-chapel']
 
+    known_types = ('bool', 'bytes', 'complex', 'imag', 'int', 'locale',
+                   'nothing', 'opaque', 'range', 'real', 'string', 'uint',
+                   'void')
+
+    type_modifiers_par = ('atomic', 'single', 'sync')
+    type_modifiers_mem = ('borrowed', 'owned', 'shared', 'unmanaged')
+    type_modifiers = (*type_modifiers_par, *type_modifiers_mem)
+
+    declarations = ('config', 'const', 'in', 'inout', 'out', 'param', 'ref',
+                    'type', 'var')
+
+    constants = ('false', 'nil', 'none', 'true')
+
+    other_keywords = ('align', 'as',
+                      'begin', 'break', 'by',
+                      'catch', 'cobegin', 'coforall', 'continue',
+                      'defer', 'delete', 'dmapped', 'do', 'domain',
+                      'else', 'enum', 'except', 'export', 'extern',
+                      'for', 'forall', 'foreach', 'forwarding',
+                      'if', 'implements', 'import', 'index', 'init', 'inline',
+                      'label', 'lambda', 'let', 'lifetime', 'local',
+                      'new', 'noinit',
+                      'on', 'only', 'otherwise', 'override',
+                      'pragma', 'primitive', 'private', 'prototype', 'public',
+                      'reduce', 'require', 'return',
+                      'scan', 'select', 'serial', 'sparse', 'subdomain',
+                      'then', 'this', 'throw', 'throws', 'try',
+                      'use',
+                      'when', 'where', 'while', 'with',
+                      'yield',
+                      'zip')
+
     tokens = {
         'root': [
             (r'\n', Text),
@@ -35,34 +67,15 @@ class ChapelLexer(RegexLexer):
             (r'//(.*?)\n', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
 
-            (r'(config|const|in|inout|out|param|ref|type|var)\b',
-             Keyword.Declaration),
-            (r'(false|nil|none|true)\b', Keyword.Constant),
-            (r'(bool|bytes|complex|imag|int|nothing|opaque|range|real|string|uint|void)\b',
-             Keyword.Type),
-            (words((
-                'align', 'as', 'atomic',
-                'begin', 'borrowed', 'break', 'by',
-                'catch', 'cobegin', 'coforall', 'continue',
-                'defer', 'delete', 'dmapped', 'do', 'domain',
-                'else', 'enum', 'except', 'export', 'extern',
-                'for', 'forall', 'forwarding',
-                'if', 'import', 'index', 'init', 'inline',
-                'label', 'lambda', 'let', 'lifetime', 'local', 'locale'
-                'new', 'noinit',
-                'on', 'only', 'otherwise', 'override', 'owned',
-                'pragma', 'private', 'prototype', 'public',
-                'reduce', 'require', 'return',
-                'scan', 'select', 'serial', 'shared', 'single', 'sparse', 'subdomain', 'sync',
-                'then', 'this', 'throw', 'throws', 'try',
-                'unmanaged', 'use',
-                'when', 'where', 'while', 'with',
-                'yield',
-                'zip'), suffix=r'\b'),
-             Keyword),
+            (words(declarations, suffix=r'\b'), Keyword.Declaration),
+            (words(constants, suffix=r'\b'), Keyword.Constant),
+            (words(known_types, suffix=r'\b'), Keyword.Type),
+            (words((*type_modifiers, *other_keywords), suffix=r'\b'), Keyword),
+
             (r'(iter)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
             (r'(proc)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
-            (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text),
+            (r'(operator)((?:\s)+)', bygroups(Keyword, Text), 'procname'),
+            (r'(class|interface|module|record|union)(\s+)', bygroups(Keyword, Text),
              'classname'),
 
             # imaginary integers
@@ -87,8 +100,8 @@ class ChapelLexer(RegexLexer):
             (r'[0-9]+', Number.Integer),
 
             # strings
-            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
-            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+            (r'"(\\\\|\\"|[^"])*"', String),
+            (r"'(\\\\|\\'|[^'])*'", String),
 
             # tokens
             (r'(=|\+=|-=|\*=|/=|\*\*=|%=|&=|\|=|\^=|&&=|\|\|=|<<=|>>=|'
@@ -105,7 +118,18 @@ class ChapelLexer(RegexLexer):
             (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'),
         ],
         'procname': [
-            (r'([a-zA-Z_][.\w$]*|\~[a-zA-Z_][.\w$]*|[+*/!~%<>=&^|\-]{1,2})',
+            (r'([a-zA-Z_][.\w$]*|'  # regular function name, including secondary
+             r'\~[a-zA-Z_][.\w$]*|'  # support for legacy destructors
+             r'[+*/!~%<>=&^|\-:]{1,2})',  # operators
              Name.Function, '#pop'),
+
+            # allow `proc (atomic T).foo`
+            (r'\(', Punctuation, "receivertype"),
+            (r'\)+\.', Punctuation),
+        ],
+        'receivertype': [
+            (words(type_modifiers, suffix=r'\b'), Keyword),
+            (words(known_types, suffix=r'\b'), Keyword.Type),
+            (r'[^()]*', Name.Other, '#pop'),
         ],
     }

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

@@ -59,15 +59,15 @@ class CleanLexer(ExtendedRegexLexer):
         ],
         'comments': [
             (r'//.*\n', Comment.Single),
-            (r'/\*', Comment.Multi, 'comments.in'),
+            (r'/\*', Comment.Multiline, 'comments.in'),
             (r'/\*\*', Comment.Special, 'comments.in'),
         ],
         'comments.in': [
-            (r'\*\/', Comment.Multi, '#pop'),
-            (r'/\*', Comment.Multi, '#push'),
-            (r'[^*/]+', Comment.Multi),
-            (r'\*(?!/)', Comment.Multi),
-            (r'/', Comment.Multi),
+            (r'\*\/', Comment.Multiline, '#pop'),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'[^*/]+', Comment.Multiline),
+            (r'\*(?!/)', Comment.Multiline),
+            (r'/', Comment.Multiline),
         ],
         'keywords': [
             (words(keywords, prefix=r'\b', suffix=r'\b'), Keyword),

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

@@ -21,7 +21,7 @@ __all__ = ['IniLexer', 'RegeditLexer', 'PropertiesLexer', 'KconfigLexer',
            'NginxConfLexer', 'LighttpdConfLexer', 'DockerLexer',
            'TerraformLexer', 'TermcapLexer', 'TerminfoLexer',
            'PkgConfigLexer', 'PacmanConfLexer', 'AugeasLexer', 'TOMLLexer',
-           'SingularityLexer']
+           'NestedTextLexer', 'SingularityLexer']
 
 
 class IniLexer(RegexLexer):
@@ -31,7 +31,13 @@ class IniLexer(RegexLexer):
 
     name = 'INI'
     aliases = ['ini', 'cfg', 'dosini']
-    filenames = ['*.ini', '*.cfg', '*.inf']
+    filenames = [
+        '*.ini', '*.cfg', '*.inf',
+        # systemd unit files
+        # https://www.freedesktop.org/software/systemd/man/systemd.unit.html
+        '*.service', '*.socket', '*.device', '*.mount', '*.automount',
+        '*.swap', '*.target', '*.path', '*.timer', '*.slice', '*.scope',
+    ]
     mimetypes = ['text/x-ini', 'text/inf']
 
     tokens = {
@@ -349,7 +355,7 @@ class SquidConfLexer(RegexLexer):
         "cache_effective_user", "cache_host", "cache_host_acl",
         "cache_host_domain", "cache_log", "cache_mem", "cache_mem_high",
         "cache_mem_low", "cache_mgr", "cachemgr_passwd", "cache_peer",
-        "cache_peer_access", "cahce_replacement_policy", "cache_stoplist",
+        "cache_peer_access", "cache_replacement_policy", "cache_stoplist",
         "cache_stoplist_pattern", "cache_store_log", "cache_swap",
         "cache_swap_high", "cache_swap_log", "cache_swap_low", "client_db",
         "client_lifetime", "client_netmask", "connect_timeout", "coredump_dir",
@@ -509,8 +515,8 @@ class LighttpdConfLexer(RegexLexer):
     .. versionadded:: 0.11
     """
     name = 'Lighttpd configuration file'
-    aliases = ['lighty', 'lighttpd']
-    filenames = []
+    aliases = ['lighttpd', 'lighty']
+    filenames = ['lighttpd.conf']
     mimetypes = ['text/x-lighttpd-conf']
 
     tokens = {
@@ -577,56 +583,113 @@ class TerraformLexer(RegexLexer):
     filenames = ['*.tf']
     mimetypes = ['application/x-tf', 'application/x-terraform']
 
-    embedded_keywords = ('ingress', 'egress', 'listener', 'default',
-                         'connection', 'alias', 'terraform', 'tags', 'vars',
-                         'config', 'lifecycle', 'timeouts')
+    classes = ('backend', 'data', 'module', 'output', 'provider',
+             'provisioner', 'resource', 'variable')
+    classes_re = "({})".format(('|').join(classes))
+
+    types = ('string', 'number', 'bool', 'list', 'tuple', 'map', 'object', 'null')
+
+    numeric_functions = ('abs', 'ceil', 'floor', 'log', 'max',
+                         'mix', 'parseint', 'pow', 'signum')
+
+    string_functions = ('chomp', 'format', 'formatlist', 'indent',
+                        'join', 'lower', 'regex', 'regexall', 'replace',
+                        'split', 'strrev', 'substr', 'title', 'trim',
+                        'trimprefix', 'trimsuffix', 'trimspace', 'upper'
+                        )
+
+    collection_functions = ('alltrue', 'anytrue', 'chunklist', 'coalesce',
+                            'coalescelist', 'compact', 'concat', 'contains',
+                            'distinct', 'element', 'flatten', 'index', 'keys',
+                            'length', 'list', 'lookup', 'map', 'matchkeys',
+                            'merge', 'range', 'reverse', 'setintersection',
+                            'setproduct', 'setsubtract', 'setunion', 'slice',
+                            'sort', 'sum', 'transpose', 'values', 'zipmap'
+                            )
+
+    encoding_functions = ('base64decode', 'base64encode', 'base64gzip',
+                          'csvdecode', 'jsondecode', 'jsonencode', 'textdecodebase64',
+                          'textencodebase64', 'urlencode', 'yamldecode', 'yamlencode')
+
+
+    filesystem_functions = ('abspath', 'dirname', 'pathexpand', 'basename',
+                            'file', 'fileexists', 'fileset', 'filebase64', 'templatefile')
+
+    date_time_functions = ('formatdate', 'timeadd', 'timestamp')
+
+    hash_crypto_functions = ('base64sha256', 'base64sha512', 'bcrypt', 'filebase64sha256',
+                             'filebase64sha512', 'filemd5', 'filesha1', 'filesha256', 'filesha512',
+                             'md5', 'rsadecrypt', 'sha1', 'sha256', 'sha512', 'uuid', 'uuidv5')
+
+    ip_network_functions = ('cidrhost', 'cidrnetmask', 'cidrsubnet', 'cidrsubnets')
+
+    type_conversion_functions = ('can', 'defaults', 'tobool', 'tolist', 'tomap',
+                                 'tonumber', 'toset', 'tostring', 'try')
+
+    builtins = numeric_functions + string_functions + collection_functions + encoding_functions +\
+        filesystem_functions + date_time_functions + hash_crypto_functions + ip_network_functions +\
+        type_conversion_functions
+    builtins_re = "({})".format(('|').join(builtins))
 
     tokens = {
         'root': [
-            include('string'),
-            include('punctuation'),
-            include('curly'),
             include('basic'),
             include('whitespace'),
+
+            # Strings
+            (r'(".*")', bygroups(String.Double)),
+
+            # Constants
+            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Name.Constant),
+
+            # Types
+            (words(types, prefix=r'\b', suffix=r'\b'), Keyword.Type),
+
+            include('identifier'),
+            include('punctuation'),
             (r'[0-9]+', Number),
         ],
         'basic': [
-            (words(('true', 'false'), prefix=r'\b', suffix=r'\b'), Keyword.Type),
             (r'\s*/\*', Comment.Multiline, 'comment'),
             (r'\s*#.*\n', Comment.Single),
-            (r'(.*?)(\s*)(=)', bygroups(Name.Attribute, Text, Operator)),
-            (words(('variable', 'resource', 'provider', 'provisioner', 'module',
-                    'backend', 'data', 'output'), prefix=r'\b', suffix=r'\b'),
-             Keyword.Reserved, 'function'),
-            (words(embedded_keywords, prefix=r'\b', suffix=r'\b'),
-             Keyword.Declaration),
-            (r'\$\{', String.Interpol, 'var_builtin'),
-        ],
-        'function': [
-            (r'(\s+)(".*")(\s+)', bygroups(Text, String, Text)),
-            include('punctuation'),
-            include('curly'),
+            include('whitespace'),
+
+            # e.g. terraform {
+            # e.g. egress {
+            (r'(\s*)([0-9a-zA-Z-_]+)(\s*)(=?)(\s*)(\{)',
+             bygroups(Text, Name.Builtin, Text, Operator, Text, Punctuation)),
+
+            # Assignment with attributes, e.g. something = ...
+            (r'(\s*)([0-9a-zA-Z-_]+)(\s*)(=)(\s*)',
+             bygroups(Text, Name.Attribute, Text, Operator, Text)),
+
+            # Assignment with environment variables and similar, e.g. "something" = ...
+            # or key value assignment, e.g. "SlotName" : ...
+            (r'(\s*)("\S+")(\s*)([=:])(\s*)',
+             bygroups(Text, Literal.String.Double, Text, Operator, Text)),
+
+            # Functions, e.g. jsonencode(element("value"))
+            (builtins_re + r'(\()', bygroups(Name.Function, Punctuation)),
+
+            # List of attributes, e.g. ignore_changes = [last_modified, filename]
+            (r'(\[)([a-z_,\s]+)(\])', bygroups(Punctuation, Name.Builtin, Punctuation)),
+
+            # e.g. resource "aws_security_group" "allow_tls" {
+            # e.g. backend "consul" {
+            (classes_re + r'(\s+)', bygroups(Keyword.Reserved, Text), 'blockname'),
         ],
-        'var_builtin': [
-            (r'\$\{', String.Interpol, '#push'),
-            (words(('concat', 'file', 'join', 'lookup', 'element'),
-                   prefix=r'\b', suffix=r'\b'), Name.Builtin),
-            include('string'),
-            include('punctuation'),
-            (r'\s+', Text),
-            (r'\}', String.Interpol, '#pop'),
+        'blockname': [
+            # e.g. resource "aws_security_group" "allow_tls" {
+            # e.g. backend "consul" {
+            (r'(\s*)("[0-9a-zA-Z-_]+")?(\s*)("[0-9a-zA-Z-_]+")(\s+)(\{)',
+             bygroups(Text, Name.Class, Text, Name.Variable, Text, Punctuation)),
         ],
-        'string': [
-            (r'(".*")', bygroups(String.Double)),
+        'identifier': [
+            (r'\b(var\.[0-9a-zA-Z-_\.\[\]]+)\b', bygroups(Name.Variable)),
+            (r'\b([0-9a-zA-Z-_\[\]]+\.[0-9a-zA-Z-_\.\[\]]+)\b', bygroups(Name.Variable)),
         ],
         'punctuation': [
-            (r'[\[\](),.]', Punctuation),
-        ],
-        # Keep this seperate from punctuation - we sometimes want to use different
-        # Tokens for { }
-        'curly': [
-            (r'\{', Text.Punctuation),
-            (r'\}', Text.Punctuation),
+            (r'[\[\]()\{\},.?:!=]', Punctuation),
         ],
         'comment': [
             (r'[^*/]', Comment.Multiline),
@@ -905,9 +968,12 @@ class TOMLLexer(RegexLexer):
 
     tokens = {
         'root': [
+            # Table
+            (r'^(\s*)(\[.*?\])$', bygroups(Text, Keyword)),
 
             # Basics, comments, strings
-            (r'\s+', Text),
+            (r'[ \t]+', Text),
+            (r'\n', Text),
             (r'#.*?$', Comment.Single),
             # Basic string
             (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
@@ -917,7 +983,6 @@ class TOMLLexer(RegexLexer):
             (r'(true|false)$', Keyword.Constant),
             (r'[a-zA-Z_][\w\-]*', Name),
 
-            (r'\[.*?\]$', Keyword),
             # Datetime
             # TODO this needs to be expanded, as TOML is rather flexible:
             # https://github.com/toml-lang/toml#offset-date-time
@@ -940,6 +1005,31 @@ class TOMLLexer(RegexLexer):
         ]
     }
 
+class NestedTextLexer(RegexLexer):
+    """
+    Lexer for `NextedText <https://nestedtext.org>`_, a human-friendly data 
+    format.
+    
+    .. versionadded:: 2.9
+    """
+
+    name = 'NestedText'
+    aliases = ['nestedtext', 'nt']
+    filenames = ['*.nt']
+
+    _quoted_dict_item = r'^(\s*)({0})(.*?)({0}: ?)(.*?)(\s*)$'
+
+    tokens = {
+        'root': [
+            (r'^(\s*)(#.*?)$', bygroups(Text, Comment)),
+            (r'^(\s*)(> ?)(.*?)(\s*)$', bygroups(Text, Punctuation, String, Whitespace)),
+            (r'^(\s*)(- ?)(.*?)(\s*)$', bygroups(Text, Punctuation, String, Whitespace)),
+            (_quoted_dict_item.format("'"), bygroups(Text, Punctuation, Name, Punctuation, String, Whitespace)),
+            (_quoted_dict_item.format('"'), bygroups(Text, Punctuation, Name, Punctuation, String, Whitespace)),
+            (r'^(\s*)(.*?)(: ?)(.*?)(\s*)$', bygroups(Text, Name, Punctuation, String, Whitespace)),
+        ],
+    }
+        
 
 class SingularityLexer(RegexLexer):
     """

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

@@ -13,7 +13,7 @@ import re
 from pygments.lexer import RegexLexer, bygroups, default, include, using, words
 from pygments.token import Comment, Error, Keyword, Name, Number, Operator, Punctuation, \
     String, Text, Whitespace
-from pygments.lexers._csound_builtins import OPCODES, DEPRECATED_OPCODES
+from pygments.lexers._csound_builtins import OPCODES, DEPRECATED_OPCODES, REMOVED_OPCODES
 from pygments.lexers.html import HtmlLexer
 from pygments.lexers.python import PythonLexer
 from pygments.lexers.scripting import LuaLexer
@@ -219,7 +219,7 @@ class CsoundOrchestraLexer(CsoundLexer):
         type_annotation_token = Keyword.Type
 
         name = match.group(1)
-        if name in OPCODES or name in DEPRECATED_OPCODES:
+        if name in OPCODES or name in DEPRECATED_OPCODES or name in REMOVED_OPCODES:
             yield match.start(), Name.Builtin, name
         elif name in lexer.user_defined_opcodes:
             yield match.start(), Name.Function, name

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

@@ -58,7 +58,7 @@ class DevicetreeLexer(RegexLexer):
             (r'(L?)(")', bygroups(String.Affix, String), 'string'),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'\d+', Number.Integer),
-            (r'([^\s{}/*]*)(\s*)(:)', bygroups(Name.Label, Text, Punctuation)),
+            (r'([^\s{}/*]*)(\s*)(:)', bygroups(Name.Label, Text, Punctuation), '#pop'),
             (words(('compatible', 'model', 'phandle', 'status', '#address-cells',
                     '#size-cells', 'reg', 'virtual-reg', 'ranges', 'dma-ranges',
                     'device_type', 'name'), suffix=r'\b'), Keyword.Reserved),

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

@@ -87,7 +87,7 @@ class CSharpLexer(RegexLexer):
                 (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
                 (r'[{}]', Punctuation),
                 (r'@"(""|[^"])*"', String),
-                (r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+                (r'\$?"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
                 (r"'\\.'|'[^\\]'", String.Char),
                 (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?"
                  r"[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?", Number),

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

@@ -230,7 +230,7 @@ class ElixirLexer(RegexLexer):
 
     name = 'Elixir'
     aliases = ['elixir', 'ex', 'exs']
-    filenames = ['*.ex', '*.eex', '*.exs']
+    filenames = ['*.ex', '*.eex', '*.exs', '*.leex']
     mimetypes = ['text/x-elixir']
 
     KEYWORD = ('fn', 'do', 'end', 'after', 'else', 'rescue', 'catch')

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

@@ -59,7 +59,7 @@ class FloScriptLexer(RegexLexer):
 
             include('name'),
             include('numbers'),
-            (r'#.+$', Comment.Singleline),
+            (r'#.+$', Comment.Single),
         ],
         'string': [
             ('[^"]+', String),

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

@@ -10,9 +10,9 @@
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, default, words
+from pygments.lexer import RegexLexer
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error
+    Number, Punctuation
 from pygments import unistring as uni
 
 __all__ = ['FutharkLexer']
@@ -25,7 +25,7 @@ class FutharkLexer(RegexLexer):
     """
     A Futhark lexer
 
-    .. versionadded:: 2.8.0
+    .. versionadded:: 2.8
     """
     name = 'Futhark'
     aliases = ['futhark']
@@ -70,7 +70,8 @@ class FutharkLexer(RegexLexer):
             (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])*_*[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),

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

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.gcodelexer
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the G Code Language.
+
+    :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 Comment, Name, Text, Keyword, Number
+
+__all__ = ['GcodeLexer']
+
+
+class GcodeLexer(RegexLexer):
+    """
+    For gcode source code.
+
+    .. versionadded:: 2.9
+    """
+    name = 'g-code'
+    aliases = ['gcode']
+    filenames = ['*.gcode']
+
+    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),
+        ]
+    }

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

@@ -25,7 +25,7 @@ class GoLexer(RegexLexer):
     """
     name = 'Go'
     filenames = ['*.go']
-    aliases = ['go']
+    aliases = ['go', 'golang']
     mimetypes = ['text/x-gosrc']
 
     flags = re.MULTILINE | re.UNICODE

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

@@ -407,7 +407,7 @@ class AsymptoteLexer(RegexLexer):
     .. versionadded:: 1.2
     """
     name = 'Asymptote'
-    aliases = ['asy', 'asymptote']
+    aliases = ['asymptote', 'asy']
     filenames = ['*.asy']
     mimetypes = ['text/x-asymptote']
 

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

@@ -9,7 +9,8 @@
 """
 
 from pygments.lexer import RegexLexer, bygroups
-from pygments.token import Comment, Keyword, Operator, Name, String, Number, Punctuation, Whitespace
+from pygments.token import Comment, Keyword, Operator, Name, String, Number, \
+    Punctuation, Whitespace
 
 
 __all__ = ['GraphvizLexer']
@@ -37,9 +38,9 @@ class GraphvizLexer(RegexLexer):
                 bygroups(Name.Attribute, Whitespace, Punctuation, Whitespace),
                 'attr_id'),
             (r'\b(n|ne|e|se|s|sw|w|nw|c|_)\b', Name.Builtin),
-            (r'\b\D\w*', Name.Tag), # node
+            (r'\b\D\w*', Name.Tag),  # node
             (r'[-]?((\.[0-9]+)|([0-9]+(\.[0-9]*)?))', Number),
-            (r'"(\\"|[^"])*?"', Name.Tag), # quoted node
+            (r'"(\\"|[^"])*?"', Name.Tag),  # quoted node
             (r'<', Punctuation, 'xml'),
         ],
         'attr_id': [
@@ -54,4 +55,4 @@ class GraphvizLexer(RegexLexer):
             (r'\s+', Whitespace),
             (r'[^<>\s]', Name.Tag),
         ]
-    }
+    }

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

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