pygments.rb 2.2.0 → 2.3.1

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

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.kuin
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Kuin language.
+"""
+
+from pygments.lexer import RegexLexer, include, using, inherit, this, bygroups, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, Number, Punctuation
+
+__all__ = ['KuinLexer']
+
+class KuinLexer(RegexLexer):
+    """
+    For `Kuin <https://github.com/kuina/Kuin>`_ source code
+
+    .. versionadded:: 2.9
+    """
+    name = 'Kuin'
+    aliases = ['kuin']
+    filenames = ['*.kn']
+
+    tokens = {
+        'root': [
+            include('statement'),
+        ],
+        'statement': [
+            # Whitespace / Comment
+            include('whitespace'),
+
+            # Block-statement
+            (r'(\+?[ \t]*\*?[ \t]*\bfunc)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)', bygroups(Keyword, using(this), Name.Function), 'func_'),
+            (r'\b(class)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)', bygroups(Keyword, using(this), Name.Class), 'class_'),
+            (r'\b(enum)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)', bygroups(Keyword, using(this), Name.Constant), 'enum_'),
+            (r'\b(block)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'block_'),
+            (r'\b(ifdef)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'ifdef_'),
+            (r'\b(if)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'if_'),
+            (r'\b(switch)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'switch_'),
+            (r'\b(while)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'while_'),
+            (r'\b(for)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'for_'),
+            (r'\b(foreach)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'foreach_'),
+            (r'\b(try)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?', bygroups(Keyword, using(this), Name.Other), 'try_'),
+
+            # Line-statement
+            (r'\b(do)\b', Keyword, 'do'),
+            (r'(\+?[ \t]*\bvar)\b', Keyword, 'var'),
+            (r'\b(const)\b', Keyword, 'const'),
+            (r'\b(ret)\b', Keyword, 'ret'),
+            (r'\b(throw)\b', Keyword, 'throw'),
+            (r'\b(alias)\b', Keyword, 'alias'),
+            (r'\b(assert)\b', Keyword, 'assert'),
+            (r'\|', Text, 'continued_line'),
+            (r'[ \t]*\n', Text),
+        ],
+
+        # Whitespace / Comment
+        'whitespace': [
+            (r'^[ \t]*;.*', Comment.Single),
+            (r'[ \t]+(?![; \t])', Text),
+            (r'\{', Comment.Multiline, 'multiline_comment'),
+        ],
+        'multiline_comment': [
+            (r'\{', Comment.Multiline, 'multiline_comment'),
+            (r'(?:\s*;.*|[^{}\n]+)', Comment.Multiline),
+            (r'\n', Comment.Multiline),
+            (r'\}', Comment.Multiline, '#pop'),
+        ],
+
+        # Block-statement
+        'func_': [
+            include('expr'),
+            (r'\n', Text, 'func'),
+        ],
+        'func': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(func)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+        ],
+        'class_': [
+            include('expr'),
+            (r'\n', Text, 'class'),
+        ],
+        'class': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(class)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+        ],
+        'enum_': [
+            include('expr'),
+            (r'\n', Text, 'enum'),
+        ],
+        'enum': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(enum)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('expr'),
+            (r'\n', Text),
+        ],
+        'block_': [
+            include('expr'),
+            (r'\n', Text, 'block'),
+        ],
+        'block': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(block)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'ifdef_': [
+            include('expr'),
+            (r'\n', Text, 'ifdef'),
+        ],
+        'ifdef': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(ifdef)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('rls', 'dbg'), prefix=r'\b', suffix=r'\b'), Keyword.Constant, 'ifdef_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'ifdef_sp': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'if_': [
+            include('expr'),
+            (r'\n', Text, 'if'),
+        ],
+        'if': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(if)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('elif', 'else'), prefix=r'\b', suffix=r'\b'), Keyword, 'if_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'if_sp': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'switch_': [
+            include('expr'),
+            (r'\n', Text, 'switch'),
+        ],
+        'switch': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(switch)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('case', 'default', 'to'), prefix=r'\b', suffix=r'\b'), Keyword, 'switch_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'switch_sp': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'while_': [
+            include('expr'),
+            (r'\n', Text, 'while'),
+        ],
+        'while': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(while)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'for_': [
+            include('expr'),
+            (r'\n', Text, 'for'),
+        ],
+        'for': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(for)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'foreach_': [
+            include('expr'),
+            (r'\n', Text, 'foreach'),
+        ],
+        'foreach': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(foreach)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'try_': [
+            include('expr'),
+            (r'\n', Text, 'try'),
+        ],
+        'try': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(try)\b', bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('catch', 'finally', 'to'), prefix=r'\b', suffix=r'\b'), Keyword, 'try_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'try_sp': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+
+        # Line-statement
+        'break': [
+            (r'\b(break)\b([ \t]+)([a-zA-Z_][0-9a-zA-Z_]*)', bygroups(Keyword, using(this), Name.Other)),
+        ],
+        'skip': [
+            (r'\b(skip)\b([ \t]+)([a-zA-Z_][0-9a-zA-Z_]*)', bygroups(Keyword, using(this), Name.Other)),
+        ],
+        'alias': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'assert': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'const': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'do': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'ret': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'throw': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'var': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+        'continued_line': [
+            include('expr'),
+            (r'\n', Text, '#pop'),
+        ],
+
+        'expr': [
+            # Whitespace / Comment
+            include('whitespace'),
+
+            # Punctuation
+            (r'\(', Punctuation,),
+            (r'\)', Punctuation,),
+            (r'\[', Punctuation,),
+            (r'\]', Punctuation,),
+            (r',', Punctuation),
+
+            # Keyword
+            (words((
+                'true', 'false', 'null', 'inf'
+                ), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
+            (words((
+                'me'
+                ), prefix=r'\b', suffix=r'\b'), Keyword),
+            (words((
+                'bit16', 'bit32', 'bit64', 'bit8', 'bool',
+                'char', 'class', 'dict', 'enum', 'float', 'func',
+                'int', 'list', 'queue', 'stack'
+                ), prefix=r'\b', suffix=r'\b'), Keyword.Type),
+
+            # Number
+            (r'\b[0-9]\.[0-9]+(?!\.)(:?e[\+-][0-9]+)?\b', Number.Float),
+            (r'\b2#[01]+(?:b(?:8|16|32|64))?\b', Number.Bin),
+            (r'\b8#[0-7]+(?:b(?:8|16|32|64))?\b', Number.Oct),
+            (r'\b16#[0-9A-F]+(?:b(?:8|16|32|64))?\b', Number.Hex),
+            (r'\b[0-9]+(?:b(?:8|16|32|64))?\b', Number.Decimal),
+
+            # String / Char
+            (r'"', String.Double, 'string'),
+            (r"'(?:\\.|.)+?'", String.Char),
+
+            # Operator
+            (r'(?:\.|\$(?:>|<)?)', Operator),
+            (r'(?:\^)', Operator),
+            (r'(?:\+|-|!|##?)', Operator),
+            (r'(?:\*|/|%)', Operator),
+            (r'(?:~)', Operator),
+            (r'(?:(?:=|<>)(?:&|\$)?|<=?|>=?)', Operator),
+            (r'(?:&)', Operator),
+            (r'(?:\|)', Operator),
+            (r'(?:\?)', Operator),
+            (r'(?::(?::|\+|-|\*|/|%|\^|~)?)', Operator),
+
+            # Identifier
+            (r"\b([a-zA-Z_][0-9a-zA-Z_]*)(?=@)\b", Name),
+            (r"(@)?\b([a-zA-Z_][0-9a-zA-Z_]*)\b", bygroups(Name.Other, Name.Variable)),
+        ],
+
+        # String
+        'string': [
+            (r'(?:\\[^{\n]|[^"\\])+', String.Double),
+            (r'\\\{', String.Double, 'toStrInString'),
+            (r'"', String.Double, '#pop'),
+        ],
+        'toStrInString': [
+            include('expr'),
+            (r'\}', String.Double, '#pop'),
+        ],
+    }

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

@@ -1536,7 +1536,7 @@ class EmacsLispLexer(RegexLexer):
     .. versionadded:: 2.1
     """
     name = 'EmacsLisp'
-    aliases = ['emacs', 'elisp', 'emacs-lisp']
+    aliases = ['emacs-lisp', 'elisp', 'emacs']
     filenames = ['*.el']
     mimetypes = ['text/x-elisp', 'application/x-elisp']
 
@@ -2631,23 +2631,22 @@ class FennelLexer(RegexLexer):
     aliases = ['fennel', 'fnl']
     filenames = ['*.fnl']
 
-    # these two lists are taken from fennel-mode.el:
-    # https://gitlab.com/technomancy/fennel-mode
-    # this list is current as of Fennel version 0.6.0.
+    # this list is current as of Fennel version 0.10.0.
     special_forms = (
-        'require-macros', 'eval-compiler', 'doc', 'lua', 'hashfn',
-        'macro', 'macros', 'import-macros', 'pick-args', 'pick-values',
-        'macroexpand', 'macrodebug', 'do', 'values', 'if', 'when',
-        'each', 'for', 'fn', 'lambda', 'λ', 'partial', 'while',
-        'set', 'global', 'var', 'local', 'let', 'tset', 'set-forcibly!',
-        'doto', 'match', 'or', 'and', 'true', 'false', 'nil', 'not',
-        'not=', '.', '+', '..', '^', '-', '*', '%', '/', '>',
-        '<', '>=', '<=', '=', '...', ':', '->', '->>', '-?>',
-        '-?>>', 'rshift', 'lshift', 'bor', 'band', 'bnot', 'bxor',
-        'with-open', 'length'
+        '#', '%', '*', '+', '-', '->', '->>', '-?>', '-?>>', '.', '..',
+        '/', '//', ':', '<', '<=', '=', '>', '>=', '?.', '^', 'accumulate',
+        'and', 'band', 'bnot', 'bor', 'bxor', 'collect', 'comment', 'do', 'doc',
+        'doto', 'each', 'eval-compiler', 'for', 'hashfn', 'icollect', 'if',
+        'import-macros', 'include', 'length', 'let', 'lshift', 'lua',
+        'macrodebug', 'match', 'not', 'not=', 'or', 'partial', 'pick-args',
+        'pick-values', 'quote', 'require-macros', 'rshift', 'set',
+        'set-forcibly!', 'tset', 'values', 'when', 'while', 'with-open', '~='
+    )
+
+    declarations = (
+        'fn', 'global', 'lambda', 'local', 'macro', 'macros', 'var', 'λ'
     )
 
-    # Might be nicer to use the list from _lua_builtins.py but it's unclear how?
     builtins = (
         '_G', '_VERSION', 'arg', 'assert', 'bit32', 'collectgarbage',
         'coroutine', 'debug', 'dofile', 'error', 'getfenv',
@@ -2673,6 +2672,8 @@ class FennelLexer(RegexLexer):
 
             (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
 
+            (r'(true|false|nil)', Name.Constant),
+
             # these are technically strings, but it's worth visually
             # distinguishing them because their intent is different
             # from regular strings.
@@ -2680,6 +2681,8 @@ class FennelLexer(RegexLexer):
 
             # special forms are keywords
             (words(special_forms, suffix=' '), Keyword),
+            # these are ... even more special!
+            (words(declarations, suffix=' '), Keyword.Declaration),
             # lua standard library are builtins
             (words(builtins, suffix=' '), Name.Builtin),
             # special-case the vararg symbol

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

@@ -121,7 +121,7 @@ class RstLexer(RegexLexer):
         .. versionadded:: 0.8
     """
     name = 'reStructuredText'
-    aliases = ['rst', 'rest', 'restructuredtext']
+    aliases = ['restructuredtext', 'rst', 'rest']
     filenames = ['*.rst', '*.rest']
     mimetypes = ["text/x-rst", "text/prs.fallenstein.rst"]
     flags = re.MULTILINE
@@ -501,8 +501,8 @@ class MarkdownLexer(RegexLexer):
 
     .. versionadded:: 2.2
     """
-    name = 'markdown'
-    aliases = ['md', 'markdown']
+    name = 'Markdown'
+    aliases = ['markdown', 'md']
     filenames = ['*.md', '*.markdown']
     mimetypes = ["text/x-markdown"]
     flags = re.MULTILINE

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

@@ -20,7 +20,6 @@ from pygments.lexers import _scilab_builtins
 __all__ = ['MatlabLexer', 'MatlabSessionLexer', 'OctaveLexer', 'ScilabLexer']
 
 
-
 class MatlabLexer(RegexLexer):
     """
     For Matlab source code.
@@ -2783,8 +2782,8 @@ class MatlabSessionLexer(Lexer):
                 # Set leading spaces with the length of the prompt to be a generic prompt
                 # This keeps code aligned when prompts are removed, say with some Javascript
                 if line.startswith(' '*line_start):
-                    insertions.append((len(curcode),
-                                    [(0, Generic.Prompt, line[:line_start])]))
+                    insertions.append(
+                        (len(curcode), [(0, Generic.Prompt, line[:line_start])]))
                     curcode += line[line_start:]
                 else:
                     curcode += line
@@ -3146,18 +3145,21 @@ class OctaveLexer(RegexLexer):
 
     tokens = {
         'root': [
-            # We should look into multiline comments
+            (r'%\{\s*\n', Comment.Multiline, 'percentblockcomment'),
+            (r'#\{\s*\n', Comment.Multiline, 'hashblockcomment'),
             (r'[%#].*$', Comment),
             (r'^\s*function\b', Keyword, 'deffunc'),
 
             # from 'iskeyword' on hg changeset 8cc154f45e37
             (words((
-                '__FILE__', '__LINE__', 'break', 'case', 'catch', 'classdef', 'continue', 'do', 'else',
-                'elseif', 'end', 'end_try_catch', 'end_unwind_protect', 'endclassdef',
-                'endevents', 'endfor', 'endfunction', 'endif', 'endmethods', 'endproperties',
-                'endswitch', 'endwhile', 'events', 'for', 'function', 'get', 'global', 'if', 'methods',
-                'otherwise', 'persistent', 'properties', 'return', 'set', 'static', 'switch', 'try',
-                'until', 'unwind_protect', 'unwind_protect_cleanup', 'while'), suffix=r'\b'),
+                '__FILE__', '__LINE__', 'break', 'case', 'catch', 'classdef',
+                'continue', 'do', 'else', 'elseif', 'end', 'end_try_catch',
+                'end_unwind_protect', 'endclassdef', 'endevents', 'endfor',
+                'endfunction', 'endif', 'endmethods', 'endproperties', 'endswitch',
+                'endwhile', 'events', 'for', 'function', 'get', 'global', 'if',
+                'methods', 'otherwise', 'persistent', 'properties', 'return',
+                'set', 'static', 'switch', 'try', 'until', 'unwind_protect',
+                'unwind_protect_cleanup', 'while'), suffix=r'\b'),
              Keyword),
 
             (words(builtin_kw + command_kw + function_kw + loadable_kw + mapping_kw,
@@ -3191,8 +3193,19 @@ class OctaveLexer(RegexLexer):
             (r'(?<![\w)\].])\'', String, 'string'),
 
             (r'[a-zA-Z_]\w*', Name),
+            (r'\s+', Text),
             (r'.', Text),
         ],
+        'percentblockcomment': [
+            (r'^\s*%\}', Comment.Multiline, '#pop'),
+            (r'^.*\n', Comment.Multiline),
+            (r'.', Comment.Multiline),
+        ],
+        'hashblockcomment': [
+            (r'^\s*#\}', Comment.Multiline, '#pop'),
+            (r'^.*\n', Comment.Multiline),
+            (r'.', Comment.Multiline),
+        ],
         'string': [
             (r"[^']*'", String, '#pop'),
         ],

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

@@ -0,0 +1,155 @@
+"""
+    pygments.lexers.meson
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Pygments lexer for the Meson build system
+
+    :copyright: Copyright 2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import (
+    RegexLexer,
+    words,
+    include,
+)
+from pygments.token import (
+    Comment,
+    Name,
+    Number,
+    Punctuation,
+    Operator,
+    Keyword,
+    String,
+    Whitespace,
+)
+
+__all__ = ['MesonLexer']
+
+
+class MesonLexer(RegexLexer):
+    """
+    `meson <https://mesonbuild.com/>`_ language lexer.
+    The grammar definition use to transcribe the syntax was retrieved from
+    https://mesonbuild.com/Syntax.html#grammar for version 0.58
+    Some of those definitions are improperly transcribed so the Meson++
+    implementation was also checked: https://github.com/dcbaker/meson-plus-plus
+
+    .. versionadded:: 2.10
+    """
+
+    # TODO String interpolation @VARNAME@ inner matches
+    # TODO keyword_arg: value inner matches
+
+    name = 'Meson'
+    aliases = ['meson', 'meson.build']
+    filenames = ['meson.build', 'meson_options.txt']
+    mimetypes = ['text/x-meson']
+
+    flags = re.MULTILINE | re.UNICODE
+
+    tokens = {
+        'root': [
+            (r'#.*?$', Comment),
+            (r"'''.*'''", String.Single),
+            (r'[1-9][0-9]*', Number.Integer),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[a-fA-F0-9]+', Number.Hex),
+            include('string'),
+            include('keywords'),
+            include('expr'),
+            (r'[a-zA-Z_][a-zA-Z_0-9]*', Name),
+            (r'\s+', Whitespace),
+        ],
+        'string': [
+            (r"[']{3}([']{0,2}([^\\']|\\(.|\n)))*[']{3}", String),
+            (r"'.*?(?<!\\)(\\\\)*?'", String),
+        ],
+        'keywords': [
+            (words((
+                'if',
+                'elif',
+                'else',
+                'endif',
+                'foreach',
+                'endforeach',
+                'break',
+                'continue',
+            ),
+                   suffix=r'\b'), Keyword),
+        ],
+        'expr': [
+            (r'(in|and|or|not)\b', Operator.Word),
+            (r'(\*=|/=|%=|\+]=|-=|==|!=|\+|-|=)', Operator),
+            (r'[\[\]{}:().,?]', Punctuation),
+            (words(('true', 'false'), suffix=r'\b'), Keyword.Constant),
+            include('builtins'),
+            (words((
+                'meson',
+                'build_machine',
+                'host_machine',
+                'target_machine',
+            ),
+                   suffix=r'\b'), Name.Variable.Magic),
+        ],
+        'builtins': [
+            # This list was extracted from the v0.58 reference manual
+            (words((
+                'add_global_arguments',
+                'add_global_link_arguments',
+                'add_languages',
+                'add_project_arguments',
+                'add_project_link_arguments',
+                'add_test_setup',
+                'assert',
+                'benchmark',
+                'both_libraries',
+                'build_target',
+                'configuration_data',
+                'configure_file',
+                'custom_target',
+                'declare_dependency',
+                'dependency',
+                'disabler',
+                'environment',
+                'error',
+                'executable',
+                'files',
+                'find_library',
+                'find_program',
+                'generator',
+                'get_option',
+                'get_variable',
+                'include_directories',
+                'install_data',
+                'install_headers',
+                'install_man',
+                'install_subdir',
+                'is_disabler',
+                'is_variable',
+                'jar',
+                'join_paths',
+                'library',
+                'message',
+                'project',
+                'range',
+                'run_command',
+                'set_variable',
+                'shared_library',
+                'shared_module',
+                'static_library',
+                'subdir',
+                'subdir_done',
+                'subproject',
+                'summary',
+                'test',
+                'vcs_tag',
+                'warning',
+            ),
+                   prefix=r'(?<!\.)',
+                   suffix=r'\b'), Name.Builtin),
+            (r'(?<!\.)import\b', Name.Namespace),
+        ],
+    }

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

@@ -21,20 +21,20 @@ __all__ = ["MIMELexer"]
 class MIMELexer(RegexLexer):
     """
     Lexer for Multipurpose Internet Mail Extensions (MIME) data. This lexer is
-    designed to process the nested mulitpart data.
+    designed to process nested multipart data.
 
     It assumes that the given data contains both header and body (and is
-    splitted by empty line). If no valid header is found, then the entire data
-    would be treated as body.
+    split at an empty line). If no valid header is found, then the entire data
+    will be treated as body.
 
     Additional options accepted:
 
     `MIME-max-level`
-        Max recurssion level for nested MIME structure. Any negative number
+        Max recursion level for nested MIME structure. Any negative number
         would treated as unlimited. (default: -1)
 
     `Content-Type`
-        Treat the data as specific content type. Useful when header is
+        Treat the data as a specific content type. Useful when header is
         missing, or this lexer would try to parse from header. (default:
         `text/plain`)
 
@@ -44,7 +44,7 @@ class MIMELexer(RegexLexer):
         would try to parse from header by default. (default: None)
 
     `Content-Transfer-Encoding`
-        Treat the data as specific encoding. Or this lexer would try to parse
+        Treat the data as a specific encoding. Or this lexer would try to parse
         from header by default. (default: None)
 
     .. versionadded:: 2.5
@@ -63,21 +63,6 @@ class MIMELexer(RegexLexer):
         self.content_type = options.get("Content_Type", "text/plain")
         self.max_nested_level = get_int_opt(options, "MIME-max-level", -1)
 
-    def analyse_text(text):
-        try:
-            header, body = text.strip().split("\n\n", 1)
-            if not body.strip():
-                return 0.1
-
-            invalid_headers = MIMELexer.tokens["header"].sub("", header)
-            if invalid_headers.strip():
-                return 0.1
-            else:
-                return 1
-
-        except ValueError:
-            return 0
-
     def get_header_tokens(self, match):
         field = match.group(1)
 

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

@@ -775,7 +775,7 @@ class ReasonLexer(RegexLexer):
     """
 
     name = 'ReasonML'
-    aliases = ['reason', "reasonml"]
+    aliases = ['reasonml', 'reason']
     filenames = ['*.re', '*.rei']
     mimetypes = ['text/x-reasonml']