pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers._lasso_builtins
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Built-in Lasso types, traits, methods, and members.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers._lua_builtins
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -9,12 +8,10 @@
 
     Do not edit the MODULES dict by hand.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-from __future__ import print_function
-
 MODULES = {'basic': ('_G',
            '_VERSION',
            'assert',
@@ -288,7 +285,7 @@ if __name__ == '__main__':  # pragma: no cover
             print('>> %s' % full_function_name)
             m = get_function_module(full_function_name)
             modules.setdefault(m, []).append(full_function_name)
-        modules = {k: tuple(v) for k, v in modules.iteritems()}
+        modules = {k: tuple(v) for k, v in modules.items()}
 
         regenerate(__file__, modules)
 

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

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers._mapping
     ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -13,10 +12,9 @@
     :license: BSD, see LICENSE for details.
 """
 
-from __future__ import print_function
-
 LEXERS = {
     'ABAPLexer': ('pygments.lexers.business', 'ABAP', ('abap',), ('*.abap', '*.ABAP'), ('text/x-abap',)),
+    'AMDGPULexer': ('pygments.lexers.amdgpu', 'AMDGPU', ('amdgpu',), ('*.isa',), ()),
     'APLLexer': ('pygments.lexers.apl', 'APL', ('apl',), ('*.apl',), ()),
     'AbnfLexer': ('pygments.lexers.grammar_notation', 'ABNF', ('abnf',), ('*.abnf',), ('text/x-abnf',)),
     'ActionScript3Lexer': ('pygments.lexers.actionscript', 'ActionScript 3', ('as3', 'actionscript3'), ('*.as',), ('application/x-actionscript3', 'text/x-actionscript3', 'text/actionscript3')),
@@ -42,17 +40,20 @@ LEXERS = {
     'ApacheConfLexer': ('pygments.lexers.configs', 'ApacheConf', ('apacheconf', 'aconf', 'apache'), ('.htaccess', 'apache.conf', 'apache2.conf'), ('text/x-apacheconf',)),
     'AppleScriptLexer': ('pygments.lexers.scripting', 'AppleScript', ('applescript',), ('*.applescript',), ()),
     'ArduinoLexer': ('pygments.lexers.c_like', 'Arduino', ('arduino',), ('*.ino',), ('text/x-arduino',)),
+    'ArrowLexer': ('pygments.lexers.arrow', 'Arrow', ('arrow',), ('*.arw',), ()),
     'AspectJLexer': ('pygments.lexers.jvm', 'AspectJ', ('aspectj',), ('*.aj',), ('text/x-aspectj',)),
     'AsymptoteLexer': ('pygments.lexers.graphics', 'Asymptote', ('asy', 'asymptote'), ('*.asy',), ('text/x-asymptote',)),
-    'AugeasLexer': ('pygments.lexers.github', 'Augeas', ('augeas',), ('*.aug',), ()),
+    'AugeasLexer': ('pygments.lexers.configs', 'Augeas', ('augeas',), ('*.aug',), ()),
     'AutoItLexer': ('pygments.lexers.automation', 'AutoIt', ('autoit',), ('*.au3',), ('text/x-autoit',)),
     'AutohotkeyLexer': ('pygments.lexers.automation', 'autohotkey', ('ahk', 'autohotkey'), ('*.ahk', '*.ahkl'), ('text/x-autohotkey',)),
     'AwkLexer': ('pygments.lexers.textedit', 'Awk', ('awk', 'gawk', 'mawk', 'nawk'), ('*.awk',), ('application/x-awk',)),
+    'BBCBasicLexer': ('pygments.lexers.basic', 'BBC Basic', ('bbcbasic',), ('*.bbc',), ()),
     'BBCodeLexer': ('pygments.lexers.markup', 'BBCode', ('bbcode',), (), ('text/x-bbcode',)),
     'BCLexer': ('pygments.lexers.algebra', 'BC', ('bc',), ('*.bc',), ()),
     'BSTLexer': ('pygments.lexers.bibtex', 'BST', ('bst', 'bst-pybtex'), ('*.bst',), ()),
+    'BareLexer': ('pygments.lexers.bare', 'BARE', ('bare',), ('*.bare',), ()),
     'BaseMakefileLexer': ('pygments.lexers.make', 'Base Makefile', ('basemake',), (), ()),
-    'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh', 'zsh', 'shell'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '*.exheres-0', '*.exlib', '*.zsh', '.bashrc', 'bashrc', '.bash_*', 'bash_*', 'zshrc', '.zshrc', 'PKGBUILD'), ('application/x-sh', 'application/x-shellscript')),
+    'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh', 'zsh', 'shell'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '*.exheres-0', '*.exlib', '*.zsh', '.bashrc', 'bashrc', '.bash_*', 'bash_*', 'zshrc', '.zshrc', 'PKGBUILD'), ('application/x-sh', 'application/x-shellscript', 'text/x-shellscript')),
     'BashSessionLexer': ('pygments.lexers.shell', 'Bash Session', ('console', 'shell-session'), ('*.sh-session', '*.shell-session'), ('application/x-shell-session', 'application/x-sh-session')),
     'BatchLexer': ('pygments.lexers.shell', 'Batchfile', ('bat', 'batch', 'dosbatch', 'winbatch'), ('*.bat', '*.cmd'), ('application/x-dos-batch',)),
     'BefungeLexer': ('pygments.lexers.esoteric', 'Befunge', ('befunge',), ('*.befunge',), ('application/x-befunge',)),
@@ -60,10 +61,10 @@ LEXERS = {
     'BlitzBasicLexer': ('pygments.lexers.basic', 'BlitzBasic', ('blitzbasic', 'b3d', 'bplus'), ('*.bb', '*.decls'), ('text/x-bb',)),
     'BlitzMaxLexer': ('pygments.lexers.basic', 'BlitzMax', ('blitzmax', 'bmax'), ('*.bmx',), ('text/x-bmx',)),
     'BnfLexer': ('pygments.lexers.grammar_notation', 'BNF', ('bnf',), ('*.bnf',), ('text/x-bnf',)),
+    'BoaLexer': ('pygments.lexers.boa', 'Boa', ('boa',), ('*.boa',), ()),
     'BooLexer': ('pygments.lexers.dotnet', 'Boo', ('boo',), ('*.boo',), ('text/x-boo',)),
     'BoogieLexer': ('pygments.lexers.verification', 'Boogie', ('boogie',), ('*.bpl',), ()),
     'BrainfuckLexer': ('pygments.lexers.esoteric', 'Brainfuck', ('brainfuck', 'bf'), ('*.bf', '*.b'), ('application/x-brainfuck',)),
-    'BroLexer': ('pygments.lexers.dsls', 'Bro', ('bro',), ('*.bro',), ()),
     'BugsLexer': ('pygments.lexers.modeling', 'BUGS', ('bugs', 'winbugs', 'openbugs'), ('*.bug',), ()),
     'CAmkESLexer': ('pygments.lexers.esoteric', 'CAmkES', ('camkes', 'idl4'), ('*.camkes', '*.idl4'), ()),
     'CLexer': ('pygments.lexers.c_cpp', 'C', ('c',), ('*.c', '*.h', '*.idc'), ('text/x-chdr', 'text/x-csrc')),
@@ -77,10 +78,12 @@ LEXERS = {
     'CapDLLexer': ('pygments.lexers.esoteric', 'CapDL', ('capdl',), ('*.cdl',), ()),
     'CapnProtoLexer': ('pygments.lexers.capnproto', "Cap'n Proto", ('capnp',), ('*.capnp',), ()),
     'CbmBasicV2Lexer': ('pygments.lexers.basic', 'CBM BASIC V2', ('cbmbas',), ('*.bas',), ()),
+    'CddlLexer': ('pygments.lexers.cddl', 'CDDL', ('cddl',), ('*.cddl',), ('text/x-cddl',)),
     'CeylonLexer': ('pygments.lexers.jvm', 'Ceylon', ('ceylon',), ('*.ceylon',), ('text/x-ceylon',)),
     'Cfengine3Lexer': ('pygments.lexers.configs', 'CFEngine3', ('cfengine3', 'cf3'), ('*.cf',), ()),
     'ChaiscriptLexer': ('pygments.lexers.scripting', 'ChaiScript', ('chai', 'chaiscript'), ('*.chai',), ('text/x-chaiscript', 'application/x-chaiscript')),
     'ChapelLexer': ('pygments.lexers.chapel', 'Chapel', ('chapel', 'chpl'), ('*.chpl',), ()),
+    'CharmciLexer': ('pygments.lexers.c_like', 'Charmci', ('charmci',), ('*.ci',), ()),
     'CheetahHtmlLexer': ('pygments.lexers.templates', 'HTML+Cheetah', ('html+cheetah', 'html+spitfire', 'htmlcheetah'), (), ('text/html+cheetah', 'text/html+spitfire')),
     'CheetahJavascriptLexer': ('pygments.lexers.templates', 'JavaScript+Cheetah', ('js+cheetah', 'javascript+cheetah', 'js+spitfire', 'javascript+spitfire'), (), ('application/x-javascript+cheetah', 'text/x-javascript+cheetah', 'text/javascript+cheetah', 'application/x-javascript+spitfire', 'text/x-javascript+spitfire', 'text/javascript+spitfire')),
     'CheetahLexer': ('pygments.lexers.templates', 'Cheetah', ('cheetah', 'spitfire'), ('*.tmpl', '*.spt'), ('application/x-cheetah', 'application/x-spitfire')),
@@ -106,7 +109,7 @@ LEXERS = {
     'CryptolLexer': ('pygments.lexers.haskell', 'Cryptol', ('cryptol', 'cry'), ('*.cry',), ('text/x-cryptol',)),
     'CrystalLexer': ('pygments.lexers.crystal', 'Crystal', ('cr', 'crystal'), ('*.cr',), ('text/x-crystal',)),
     'CsoundDocumentLexer': ('pygments.lexers.csound', 'Csound Document', ('csound-document', 'csound-csd'), ('*.csd',), ()),
-    'CsoundOrchestraLexer': ('pygments.lexers.csound', 'Csound Orchestra', ('csound', 'csound-orc'), ('*.orc',), ()),
+    'CsoundOrchestraLexer': ('pygments.lexers.csound', 'Csound Orchestra', ('csound', 'csound-orc'), ('*.orc', '*.udo'), ()),
     'CsoundScoreLexer': ('pygments.lexers.csound', 'Csound Score', ('csound-score', 'csound-sco'), ('*.sco',), ()),
     'CssDjangoLexer': ('pygments.lexers.templates', 'CSS+Django/Jinja', ('css+django', 'css+jinja'), (), ('text/css+django', 'text/css+jinja')),
     'CssErbLexer': ('pygments.lexers.templates', 'CSS+Ruby', ('css+erb', 'css+ruby'), (), ('text/css+ruby',)),
@@ -121,9 +124,10 @@ LEXERS = {
     'DObjdumpLexer': ('pygments.lexers.asm', 'd-objdump', ('d-objdump',), ('*.d-objdump',), ('text/x-d-objdump',)),
     'DarcsPatchLexer': ('pygments.lexers.diff', 'Darcs Patch', ('dpatch',), ('*.dpatch', '*.darcspatch'), ()),
     'DartLexer': ('pygments.lexers.javascript', 'Dart', ('dart',), ('*.dart',), ('text/x-dart',)),
-    'Dasm16Lexer': ('pygments.lexers.github', 'dasm16', ('DASM16',), ('*.dasm16', '*.dasm'), ('text/x-dasm16',)),
+    'Dasm16Lexer': ('pygments.lexers.asm', 'DASM16', ('dasm16',), ('*.dasm16', '*.dasm'), ('text/x-dasm16',)),
     'DebianControlLexer': ('pygments.lexers.installers', 'Debian Control file', ('control', 'debcontrol'), ('control',), ()),
     'DelphiLexer': ('pygments.lexers.pascal', 'Delphi', ('delphi', 'pas', 'pascal', 'objectpascal'), ('*.pas', '*.dpr'), ('text/x-pascal',)),
+    'DevicetreeLexer': ('pygments.lexers.devicetree', 'Devicetree', ('devicetree', 'dts'), ('*.dts', '*.dtsi'), ('text/x-c',)),
     'DgLexer': ('pygments.lexers.python', 'dg', ('dg',), ('*.dg',), ('text/x-dg',)),
     'DiffLexer': ('pygments.lexers.diff', 'Diff', ('diff', 'udiff'), ('*.diff', '*.patch'), ('text/x-diff', 'text/x-patch')),
     'DjangoLexer': ('pygments.lexers.templates', 'Django/Jinja', ('django', 'jinja'), (), ('application/x-django-templating', 'application/x-jinja')),
@@ -140,28 +144,36 @@ LEXERS = {
     'EbnfLexer': ('pygments.lexers.parsers', 'EBNF', ('ebnf',), ('*.ebnf',), ('text/x-ebnf',)),
     'EiffelLexer': ('pygments.lexers.eiffel', 'Eiffel', ('eiffel',), ('*.e',), ('text/x-eiffel',)),
     'ElixirConsoleLexer': ('pygments.lexers.erlang', 'Elixir iex session', ('iex',), (), ('text/x-elixir-shellsession',)),
-    'ElixirLexer': ('pygments.lexers.erlang', 'Elixir', ('elixir', 'ex', 'exs'), ('*.ex', '*.exs'), ('text/x-elixir',)),
+    'ElixirLexer': ('pygments.lexers.erlang', 'Elixir', ('elixir', 'ex', 'exs'), ('*.ex', '*.eex', '*.exs'), ('text/x-elixir',)),
     'ElmLexer': ('pygments.lexers.elm', 'Elm', ('elm',), ('*.elm',), ('text/x-elm',)),
     'EmacsLispLexer': ('pygments.lexers.lisp', 'EmacsLisp', ('emacs', 'elisp', 'emacs-lisp'), ('*.el',), ('text/x-elisp', 'application/x-elisp')),
+    'EmailLexer': ('pygments.lexers.email', 'E-mail', ('email', 'eml'), ('*.eml',), ('message/rfc822',)),
     'ErbLexer': ('pygments.lexers.templates', 'ERB', ('erb',), (), ('application/x-ruby-templating',)),
     'ErlangLexer': ('pygments.lexers.erlang', 'Erlang', ('erlang',), ('*.erl', '*.hrl', '*.es', '*.escript'), ('text/x-erlang',)),
     'ErlangShellLexer': ('pygments.lexers.erlang', 'Erlang erl session', ('erl',), ('*.erl-sh',), ('text/x-erl-shellsession',)),
     'EvoqueHtmlLexer': ('pygments.lexers.templates', 'HTML+Evoque', ('html+evoque',), ('*.html',), ('text/html+evoque',)),
     'EvoqueLexer': ('pygments.lexers.templates', 'Evoque', ('evoque',), ('*.evoque',), ('application/x-evoque',)),
     'EvoqueXmlLexer': ('pygments.lexers.templates', 'XML+Evoque', ('xml+evoque',), ('*.xml',), ('application/xml+evoque',)),
+    'ExeclineLexer': ('pygments.lexers.shell', 'execline', ('execline',), ('*.exec',), ()),
     'EzhilLexer': ('pygments.lexers.ezhil', 'Ezhil', ('ezhil',), ('*.n',), ('text/x-ezhil',)),
-    'FSharpLexer': ('pygments.lexers.dotnet', 'FSharp', ('fsharp',), ('*.fs', '*.fsi'), ('text/x-fsharp',)),
+    'FSharpLexer': ('pygments.lexers.dotnet', 'F#', ('fsharp', 'f#'), ('*.fs', '*.fsi'), ('text/x-fsharp',)),
+    'FStarLexer': ('pygments.lexers.ml', 'FStar', ('fstar',), ('*.fst', '*.fsti'), ('text/x-fstar',)),
     'FactorLexer': ('pygments.lexers.factor', 'Factor', ('factor',), ('*.factor',), ('text/x-factor',)),
     'FancyLexer': ('pygments.lexers.ruby', 'Fancy', ('fancy', 'fy'), ('*.fy', '*.fancypack'), ('text/x-fancysrc',)),
     'FantomLexer': ('pygments.lexers.fantom', 'Fantom', ('fan',), ('*.fan',), ('application/x-fantom',)),
     'FelixLexer': ('pygments.lexers.felix', 'Felix', ('felix', 'flx'), ('*.flx', '*.flxh'), ('text/x-felix',)),
+    'FennelLexer': ('pygments.lexers.lisp', 'Fennel', ('fennel', 'fnl'), ('*.fnl',), ()),
     'FishShellLexer': ('pygments.lexers.shell', 'Fish', ('fish', 'fishshell'), ('*.fish', '*.load'), ('application/x-fish',)),
     'FlatlineLexer': ('pygments.lexers.dsls', 'Flatline', ('flatline',), (), ('text/x-flatline',)),
+    'FloScriptLexer': ('pygments.lexers.floscript', 'FloScript', ('floscript', 'flo'), ('*.flo',), ()),
     'ForthLexer': ('pygments.lexers.forth', 'Forth', ('forth',), ('*.frt', '*.fs'), ('application/x-forth',)),
     'FortranFixedLexer': ('pygments.lexers.fortran', 'FortranFixed', ('fortranfixed',), ('*.f', '*.F'), ()),
     'FortranLexer': ('pygments.lexers.fortran', 'Fortran', ('fortran',), ('*.f03', '*.f90', '*.F03', '*.F90'), ('text/x-fortran',)),
     'FoxProLexer': ('pygments.lexers.foxpro', 'FoxPro', ('foxpro', 'vfp', 'clipper', 'xbase'), ('*.PRG', '*.prg'), ()),
+    'FreeFemLexer': ('pygments.lexers.freefem', 'Freefem', ('freefem',), ('*.edp',), ('text/x-freefem',)),
+    'FutharkLexer': ('pygments.lexers.futhark', 'Futhark', ('futhark',), ('*.fut',), ('text/x-futhark',)),
     'GAPLexer': ('pygments.lexers.algebra', 'GAP', ('gap',), ('*.g', '*.gd', '*.gi', '*.gap'), ()),
+    'GDScriptLexer': ('pygments.lexers.gdscript', 'GDScript', ('gdscript', 'gd'), ('*.gd',), ('text/x-gdscript', 'application/x-gdscript')),
     'GLShaderLexer': ('pygments.lexers.graphics', 'GLSL', ('glsl',), ('*.vert', '*.frag', '*.geo'), ('text/x-glslsrc',)),
     'GasLexer': ('pygments.lexers.asm', 'GAS', ('gas', 'asm'), ('*.s', '*.S'), ('text/x-gas',)),
     'GenshiLexer': ('pygments.lexers.templates', 'Genshi', ('genshi', 'kid', 'xml+genshi', 'xml+kid'), ('*.kid',), ('application/x-genshi', 'application/x-kid')),
@@ -174,8 +186,10 @@ LEXERS = {
     'GoodDataCLLexer': ('pygments.lexers.business', 'GoodData-CL', ('gooddata-cl',), ('*.gdc',), ('text/x-gooddata-cl',)),
     'GosuLexer': ('pygments.lexers.jvm', 'Gosu', ('gosu',), ('*.gs', '*.gsx', '*.gsp', '*.vark'), ('text/x-gosu',)),
     'GosuTemplateLexer': ('pygments.lexers.jvm', 'Gosu Template', ('gst',), ('*.gst',), ('text/x-gosu-template',)),
+    'GraphvizLexer': ('pygments.lexers.graphviz', 'Graphviz', ('graphviz', 'dot'), ('*.gv', '*.dot'), ('text/x-graphviz', 'text/vnd.graphviz')),
     'GroffLexer': ('pygments.lexers.markup', 'Groff', ('groff', 'nroff', 'man'), ('*.[1234567]', '*.man'), ('application/x-troff', 'text/troff')),
     'GroovyLexer': ('pygments.lexers.jvm', 'Groovy', ('groovy',), ('*.groovy', '*.gradle'), ('text/x-groovy',)),
+    'HLSLShaderLexer': ('pygments.lexers.graphics', 'HLSL', ('hlsl',), ('*.hlsl', '*.hlsli'), ('text/x-hlsl',)),
     'HamlLexer': ('pygments.lexers.html', 'Haml', ('haml',), ('*.haml',), ('text/x-haml',)),
     'HandlebarsHtmlLexer': ('pygments.lexers.templates', 'HTML+Handlebars', ('html+handlebars',), ('*.handlebars', '*.hbs'), ('text/html+handlebars', 'text/x-handlebars-template')),
     'HandlebarsLexer': ('pygments.lexers.templates', 'Handlebars', ('handlebars',), (), ()),
@@ -183,6 +197,7 @@ LEXERS = {
     'HaxeLexer': ('pygments.lexers.haxe', 'Haxe', ('hx', 'haxe', 'hxsl'), ('*.hx', '*.hxsl'), ('text/haxe', 'text/x-haxe', 'text/x-hx')),
     'HexdumpLexer': ('pygments.lexers.hexdump', 'Hexdump', ('hexdump',), (), ()),
     'HsailLexer': ('pygments.lexers.asm', 'HSAIL', ('hsail', 'hsa'), ('*.hsail',), ('text/x-hsail',)),
+    'HspecLexer': ('pygments.lexers.haskell', 'Hspec', ('hspec',), (), ()),
     'HtmlDjangoLexer': ('pygments.lexers.templates', 'HTML+Django/Jinja', ('html+django', 'html+jinja', 'htmldjango'), (), ('text/html+django', 'text/html+jinja')),
     'HtmlGenshiLexer': ('pygments.lexers.templates', 'HTML+Genshi', ('html+genshi', 'html+kid'), (), ('text/html+genshi',)),
     'HtmlLexer': ('pygments.lexers.html', 'HTML', ('html',), ('*.html', '*.htm', '*.xhtml', '*.xslt'), ('text/html', 'application/xhtml+xml')),
@@ -193,6 +208,7 @@ LEXERS = {
     'HyLexer': ('pygments.lexers.lisp', 'Hy', ('hylang',), ('*.hy',), ('text/x-hy', 'application/x-hy')),
     'HybrisLexer': ('pygments.lexers.scripting', 'Hybris', ('hybris', 'hy'), ('*.hy', '*.hyb'), ('text/x-hybris', 'application/x-hybris')),
     'IDLLexer': ('pygments.lexers.idl', 'IDL', ('idl',), ('*.pro',), ('text/idl',)),
+    'IconLexer': ('pygments.lexers.unicon', 'Icon', ('icon',), ('*.icon', '*.ICON'), ()),
     'IdrisLexer': ('pygments.lexers.haskell', 'Idris', ('idris', 'idr'), ('*.idr',), ('text/x-idris',)),
     'IgorLexer': ('pygments.lexers.igor', 'Igor', ('igor', 'igorpro'), ('*.ipf',), ('text/ipf',)),
     'Inform6Lexer': ('pygments.lexers.int_fiction', 'Inform 6', ('inform6', 'i6'), ('*.inf',), ()),
@@ -210,22 +226,23 @@ LEXERS = {
     'JavascriptDjangoLexer': ('pygments.lexers.templates', 'JavaScript+Django/Jinja', ('js+django', 'javascript+django', 'js+jinja', 'javascript+jinja'), (), ('application/x-javascript+django', 'application/x-javascript+jinja', 'text/x-javascript+django', 'text/x-javascript+jinja', 'text/javascript+django', 'text/javascript+jinja')),
     'JavascriptErbLexer': ('pygments.lexers.templates', 'JavaScript+Ruby', ('js+erb', 'javascript+erb', 'js+ruby', 'javascript+ruby'), (), ('application/x-javascript+ruby', 'text/x-javascript+ruby', 'text/javascript+ruby')),
     'JavascriptGenshiLexer': ('pygments.lexers.templates', 'JavaScript+Genshi Text', ('js+genshitext', 'js+genshi', 'javascript+genshitext', 'javascript+genshi'), (), ('application/x-javascript+genshi', 'text/x-javascript+genshi', 'text/javascript+genshi')),
-    'JavascriptLexer': ('pygments.lexers.javascript', 'JavaScript', ('js', 'javascript'), ('*.js', '*.jsm'), ('application/javascript', 'application/x-javascript', 'text/x-javascript', 'text/javascript')),
+    'JavascriptLexer': ('pygments.lexers.javascript', 'JavaScript', ('js', 'javascript'), ('*.js', '*.jsm', '*.mjs'), ('application/javascript', 'application/x-javascript', 'text/x-javascript', 'text/javascript')),
     'JavascriptPhpLexer': ('pygments.lexers.templates', 'JavaScript+PHP', ('js+php', 'javascript+php'), (), ('application/x-javascript+php', 'text/x-javascript+php', 'text/javascript+php')),
     'JavascriptSmartyLexer': ('pygments.lexers.templates', 'JavaScript+Smarty', ('js+smarty', 'javascript+smarty'), (), ('application/x-javascript+smarty', 'text/x-javascript+smarty', 'text/javascript+smarty')),
     'JclLexer': ('pygments.lexers.scripting', 'JCL', ('jcl',), ('*.jcl',), ('text/x-jcl',)),
     'JsgfLexer': ('pygments.lexers.grammar_notation', 'JSGF', ('jsgf',), ('*.jsgf',), ('application/jsgf', 'application/x-jsgf', 'text/jsgf')),
-    'JsonBareObjectLexer': ('pygments.lexers.data', 'JSONBareObject', ('json-object',), (), ('application/json-object',)),
+    'JsonBareObjectLexer': ('pygments.lexers.data', 'JSONBareObject', (), (), ()),
     'JsonLdLexer': ('pygments.lexers.data', 'JSON-LD', ('jsonld', 'json-ld'), ('*.jsonld',), ('application/ld+json',)),
-    'JsonLexer': ('pygments.lexers.data', 'JSON', ('json',), ('*.json',), ('application/json',)),
+    'JsonLexer': ('pygments.lexers.data', 'JSON', ('json', 'json-object'), ('*.json', 'Pipfile.lock'), ('application/json', 'application/json-object')),
     'JspLexer': ('pygments.lexers.templates', 'Java Server Page', ('jsp',), ('*.jsp',), ('application/x-jsp',)),
     'JuliaConsoleLexer': ('pygments.lexers.julia', 'Julia console', ('jlcon',), (), ()),
     'JuliaLexer': ('pygments.lexers.julia', 'Julia', ('julia', 'jl'), ('*.jl',), ('text/x-julia', 'application/x-julia')),
-    'JuttleLexer': ('pygments.lexers.javascript', 'Juttle', ('juttle', 'juttle'), ('*.juttle',), ('application/juttle', 'application/x-juttle', 'text/x-juttle', 'text/juttle')),
+    'JuttleLexer': ('pygments.lexers.javascript', 'Juttle', ('juttle',), ('*.juttle',), ('application/juttle', 'application/x-juttle', 'text/x-juttle', 'text/juttle')),
     'KalLexer': ('pygments.lexers.javascript', 'Kal', ('kal',), ('*.kal',), ('text/kal', 'application/kal')),
-    'KconfigLexer': ('pygments.lexers.configs', 'Kconfig', ('kconfig', 'menuconfig', 'linux-config', 'kernel-config'), ('Kconfig', '*Config.in*', 'external.in*', 'standard-modules.in'), ('text/x-kconfig',)),
+    'KconfigLexer': ('pygments.lexers.configs', 'Kconfig', ('kconfig', 'menuconfig', 'linux-config', 'kernel-config'), ('Kconfig*', '*Config.in*', 'external.in*', 'standard-modules.in'), ('text/x-kconfig',)),
+    'KernelLogLexer': ('pygments.lexers.textfmts', 'Kernel log', ('kmsg', 'dmesg'), ('*.kmsg', '*.dmesg'), ()),
     'KokaLexer': ('pygments.lexers.haskell', 'Koka', ('koka',), ('*.kk', '*.kki'), ('text/x-koka',)),
-    'KotlinLexer': ('pygments.lexers.jvm', 'Kotlin', ('kotlin',), ('*.kt',), ('text/x-kotlin',)),
+    'KotlinLexer': ('pygments.lexers.jvm', 'Kotlin', ('kotlin',), ('*.kt', '*.kts'), ('text/x-kotlin',)),
     'LSLLexer': ('pygments.lexers.scripting', 'LSL', ('lsl',), ('*.lsl',), ('text/x-lsl',)),
     'LassoCssLexer': ('pygments.lexers.templates', 'CSS+Lasso', ('css+lasso',), (), ('text/css+lasso',)),
     'LassoHtmlLexer': ('pygments.lexers.templates', 'HTML+Lasso', ('html+lasso',), (), ('text/html+lasso', 'application/x-httpd-lasso', 'application/x-httpd-lasso[89]')),
@@ -243,9 +260,12 @@ LEXERS = {
     'LiterateIdrisLexer': ('pygments.lexers.haskell', 'Literate Idris', ('lidr', 'literate-idris', 'lidris'), ('*.lidr',), ('text/x-literate-idris',)),
     'LiveScriptLexer': ('pygments.lexers.javascript', 'LiveScript', ('live-script', 'livescript'), ('*.ls',), ('text/livescript',)),
     'LlvmLexer': ('pygments.lexers.asm', 'LLVM', ('llvm',), ('*.ll',), ('text/x-llvm',)),
+    'LlvmMirBodyLexer': ('pygments.lexers.asm', 'LLVM-MIR Body', ('llvm-mir-body',), (), ()),
+    'LlvmMirLexer': ('pygments.lexers.asm', 'LLVM-MIR', ('llvm-mir',), ('*.mir',), ()),
     'LogosLexer': ('pygments.lexers.objective', 'Logos', ('logos',), ('*.x', '*.xi', '*.xm', '*.xmi'), ('text/x-logos',)),
     'LogtalkLexer': ('pygments.lexers.prolog', 'Logtalk', ('logtalk',), ('*.lgt', '*.logtalk'), ('text/x-logtalk',)),
     'LuaLexer': ('pygments.lexers.scripting', 'Lua', ('lua',), ('*.lua', '*.wlua'), ('text/x-lua', 'application/x-lua')),
+    'MIMELexer': ('pygments.lexers.mime', 'MIME', ('mime',), (), ('multipart/mixed', 'multipart/related', 'multipart/alternative')),
     'MOOCodeLexer': ('pygments.lexers.scripting', 'MOOCode', ('moocode', 'moo'), ('*.moo',), ('text/x-moocode',)),
     'MSDOSSessionLexer': ('pygments.lexers.shell', 'MSDOS Session', ('doscon',), (), ()),
     'MakefileLexer': ('pygments.lexers.make', 'Makefile', ('make', 'makefile', 'mf', 'bsdmake'), ('*.mak', '*.mk', 'Makefile', 'makefile', 'Makefile.*', 'GNUmakefile'), ('text/x-makefile',)),
@@ -255,19 +275,21 @@ LEXERS = {
     'MakoLexer': ('pygments.lexers.templates', 'Mako', ('mako',), ('*.mao',), ('application/x-mako',)),
     'MakoXmlLexer': ('pygments.lexers.templates', 'XML+Mako', ('xml+mako',), (), ('application/xml+mako',)),
     'MaqlLexer': ('pygments.lexers.business', 'MAQL', ('maql',), ('*.maql',), ('text/x-gooddata-maql', 'application/x-gooddata-maql')),
-    'MarkdownLexer': ('pygments.lexers.markup', 'markdown', ('md',), ('*.md',), ('text/x-markdown',)),
+    'MarkdownLexer': ('pygments.lexers.markup', 'markdown', ('md', 'markdown'), ('*.md', '*.markdown'), ('text/x-markdown',)),
     'MaskLexer': ('pygments.lexers.javascript', 'Mask', ('mask',), ('*.mask',), ('text/x-mask',)),
     'MasonLexer': ('pygments.lexers.templates', 'Mason', ('mason',), ('*.m', '*.mhtml', '*.mc', '*.mi', 'autohandler', 'dhandler'), ('application/x-mason',)),
     'MathematicaLexer': ('pygments.lexers.algebra', 'Mathematica', ('mathematica', 'mma', 'nb'), ('*.nb', '*.cdf', '*.nbp', '*.ma'), ('application/mathematica', 'application/vnd.wolfram.mathematica', 'application/vnd.wolfram.mathematica.package', 'application/vnd.wolfram.cdf')),
     'MatlabLexer': ('pygments.lexers.matlab', 'Matlab', ('matlab',), ('*.m',), ('text/matlab',)),
     'MatlabSessionLexer': ('pygments.lexers.matlab', 'Matlab session', ('matlabsession',), (), ()),
     'MiniDLexer': ('pygments.lexers.d', 'MiniD', ('minid',), (), ('text/x-minidsrc',)),
+    'MiniScriptLexer': ('pygments.lexers.scripting', 'MiniScript', ('ms', 'miniscript'), ('*.ms',), ('text/x-minicript', 'application/x-miniscript')),
     'ModelicaLexer': ('pygments.lexers.modeling', 'Modelica', ('modelica',), ('*.mo',), ('text/x-modelica',)),
     'Modula2Lexer': ('pygments.lexers.modula2', 'Modula-2', ('modula2', 'm2'), ('*.def', '*.mod'), ('text/x-modula2',)),
     'MoinWikiLexer': ('pygments.lexers.markup', 'MoinMoin/Trac Wiki markup', ('trac-wiki', 'moin'), (), ('text/x-trac-wiki',)),
     'MonkeyLexer': ('pygments.lexers.basic', 'Monkey', ('monkey',), ('*.monkey',), ('text/x-monkey',)),
     'MonteLexer': ('pygments.lexers.monte', 'Monte', ('monte',), ('*.mt',), ()),
     'MoonScriptLexer': ('pygments.lexers.scripting', 'MoonScript', ('moon', 'moonscript'), ('*.moon',), ('text/x-moonscript', 'application/x-moonscript')),
+    'MoselLexer': ('pygments.lexers.mosel', 'Mosel', ('mosel',), ('*.mos',), ()),
     'MozPreprocCssLexer': ('pygments.lexers.markup', 'CSS+mozpreproc', ('css+mozpreproc',), ('*.css.in',), ()),
     'MozPreprocHashLexer': ('pygments.lexers.markup', 'mozhashpreproc', ('mozhashpreproc',), (), ()),
     'MozPreprocJavascriptLexer': ('pygments.lexers.markup', 'Javascript+mozpreproc', ('javascript+mozpreproc',), ('*.js.in',), ()),
@@ -295,6 +317,7 @@ LEXERS = {
     'NimrodLexer': ('pygments.lexers.nimrod', 'Nimrod', ('nim', 'nimrod'), ('*.nim', '*.nimrod'), ('text/x-nim',)),
     'NitLexer': ('pygments.lexers.nit', 'Nit', ('nit',), ('*.nit',), ()),
     'NixLexer': ('pygments.lexers.nix', 'Nix', ('nixos', 'nix'), ('*.nix',), ('text/x-nix',)),
+    'NotmuchLexer': ('pygments.lexers.textfmts', 'Notmuch', ('notmuch',), (), ()),
     'NuSMVLexer': ('pygments.lexers.smv', 'NuSMV', ('nusmv',), ('*.smv',), ()),
     'NumPyLexer': ('pygments.lexers.python', 'NumPy', ('numpy',), (), ()),
     'ObjdumpLexer': ('pygments.lexers.asm', 'objdump', ('objdump',), ('*.objdump',), ('text/x-objdump',)),
@@ -311,13 +334,16 @@ LEXERS = {
     'PanLexer': ('pygments.lexers.dsls', 'Pan', ('pan',), ('*.pan',), ()),
     'ParaSailLexer': ('pygments.lexers.parasail', 'ParaSail', ('parasail',), ('*.psi', '*.psl'), ('text/x-parasail',)),
     'PawnLexer': ('pygments.lexers.pawn', 'Pawn', ('pawn',), ('*.p', '*.pwn', '*.inc'), ('text/x-pawn',)),
-    'Perl6Lexer': ('pygments.lexers.perl', 'Perl6', ('perl6', 'pl6'), ('*.pl', '*.pm', '*.nqp', '*.p6', '*.6pl', '*.p6l', '*.pl6', '*.6pm', '*.p6m', '*.pm6', '*.t'), ('text/x-perl6', 'application/x-perl6')),
-    'PerlLexer': ('pygments.lexers.perl', 'Perl', ('perl', 'pl'), ('*.pl', '*.pm', '*.t'), ('text/x-perl', 'application/x-perl')),
+    'PegLexer': ('pygments.lexers.grammar_notation', 'PEG', ('peg',), ('*.peg',), ('text/x-peg',)),
+    'Perl6Lexer': ('pygments.lexers.perl', 'Perl6', ('perl6', 'pl6', 'raku'), ('*.pl', '*.pm', '*.nqp', '*.p6', '*.6pl', '*.p6l', '*.pl6', '*.6pm', '*.p6m', '*.pm6', '*.t', '*.raku', '*.rakumod', '*.rakutest', '*.rakudoc'), ('text/x-perl6', 'application/x-perl6')),
+    'PerlLexer': ('pygments.lexers.perl', 'Perl', ('perl', 'pl'), ('*.pl', '*.pm', '*.t', '*.perl'), ('text/x-perl', 'application/x-perl')),
     'PhpLexer': ('pygments.lexers.php', 'PHP', ('php', 'php3', 'php4', 'php5'), ('*.php', '*.php[345]', '*.inc'), ('text/x-php',)),
     'PigLexer': ('pygments.lexers.jvm', 'Pig', ('pig',), ('*.pig',), ('text/x-pig',)),
     'PikeLexer': ('pygments.lexers.c_like', 'Pike', ('pike',), ('*.pike', '*.pmod'), ('text/x-pike',)),
     'PkgConfigLexer': ('pygments.lexers.configs', 'PkgConfig', ('pkgconfig',), ('*.pc',), ()),
     'PlPgsqlLexer': ('pygments.lexers.sql', 'PL/pgSQL', ('plpgsql',), (), ('text/x-plpgsql',)),
+    'PointlessLexer': ('pygments.lexers.pointless', 'Pointless', ('pointless',), ('*.ptls',), ()),
+    'PonyLexer': ('pygments.lexers.pony', 'Pony', ('pony',), ('*.pony',), ()),
     'PostScriptLexer': ('pygments.lexers.graphics', 'PostScript', ('postscript', 'postscr'), ('*.ps', '*.eps'), ('application/postscript',)),
     'PostgresConsoleLexer': ('pygments.lexers.sql', 'PostgreSQL console (psql)', ('psql', 'postgresql-console', 'postgres-console'), (), ('text/x-postgresql-psql',)),
     'PostgresLexer': ('pygments.lexers.sql', 'PostgreSQL SQL dialect', ('postgresql', 'postgres'), (), ('text/x-postgresql',)),
@@ -326,17 +352,18 @@ LEXERS = {
     'PowerShellSessionLexer': ('pygments.lexers.shell', 'PowerShell Session', ('ps1con',), (), ()),
     'PraatLexer': ('pygments.lexers.praat', 'Praat', ('praat',), ('*.praat', '*.proc', '*.psc'), ()),
     'PrologLexer': ('pygments.lexers.prolog', 'Prolog', ('prolog',), ('*.ecl', '*.prolog', '*.pro', '*.pl'), ('text/x-prolog',)),
+    'PromQLLexer': ('pygments.lexers.promql', 'PromQL', ('promql',), ('*.promql',), ()),
     'PropertiesLexer': ('pygments.lexers.configs', 'Properties', ('properties', 'jproperties'), ('*.properties',), ('text/x-java-properties',)),
     'ProtoBufLexer': ('pygments.lexers.dsls', 'Protocol Buffer', ('protobuf', 'proto'), ('*.proto',), ()),
+    'PsyshConsoleLexer': ('pygments.lexers.php', 'PsySH console session for PHP', ('psysh',), (), ()),
     'PugLexer': ('pygments.lexers.html', 'Pug', ('pug', 'jade'), ('*.pug', '*.jade'), ('text/x-pug', 'text/x-jade')),
     'PuppetLexer': ('pygments.lexers.dsls', 'Puppet', ('puppet',), ('*.pp',), ()),
-    'PuppetLexer': ('pygments.lexers.github', 'Puppet', ('puppet',), ('*.pp',), ()),
     'PyPyLogLexer': ('pygments.lexers.console', 'PyPy Log', ('pypylog', 'pypy'), ('*.pypylog',), ('application/x-pypylog',)),
-    'Python3Lexer': ('pygments.lexers.python', 'Python 3', ('python3', 'py3'), (), ('text/x-python3', 'application/x-python3')),
-    'Python3TracebackLexer': ('pygments.lexers.python', 'Python 3.0 Traceback', ('py3tb',), ('*.py3tb',), ('text/x-python3-traceback',)),
+    'Python2Lexer': ('pygments.lexers.python', 'Python 2.x', ('python2', 'py2'), (), ('text/x-python2', 'application/x-python2')),
+    'Python2TracebackLexer': ('pygments.lexers.python', 'Python 2.x Traceback', ('py2tb',), ('*.py2tb',), ('text/x-python2-traceback',)),
     'PythonConsoleLexer': ('pygments.lexers.python', 'Python console session', ('pycon',), (), ('text/x-python-doctest',)),
-    'PythonLexer': ('pygments.lexers.python', 'Python', ('python', 'py', 'sage'), ('*.py', '*.pyw', '*.sc', 'SConstruct', 'SConscript', '*.tac', '*.sage'), ('text/x-python', 'application/x-python')),
-    'PythonTracebackLexer': ('pygments.lexers.python', 'Python Traceback', ('pytb',), ('*.pytb',), ('text/x-python-traceback',)),
+    'PythonLexer': ('pygments.lexers.python', 'Python', ('python', 'py', 'sage', 'python3', 'py3'), ('*.py', '*.pyw', '*.jy', '*.sage', '*.sc', 'SConstruct', 'SConscript', '*.bzl', 'BUCK', 'BUILD', 'BUILD.bazel', 'WORKSPACE', '*.tac'), ('text/x-python', 'application/x-python', 'text/x-python3', 'application/x-python3')),
+    'PythonTracebackLexer': ('pygments.lexers.python', 'Python Traceback', ('pytb', 'py3tb'), ('*.pytb', '*.py3tb'), ('text/x-python-traceback', 'text/x-python3-traceback')),
     'QBasicLexer': ('pygments.lexers.basic', 'QBasic', ('qbasic', 'basic'), ('*.BAS', '*.bas'), ('text/basic',)),
     'QVToLexer': ('pygments.lexers.qvt', 'QVTO', ('qvto', 'qvt'), ('*.qvto',), ()),
     'QmlLexer': ('pygments.lexers.webmisc', 'QML', ('qml', 'qbs'), ('*.qml', '*.qbs'), ('application/x-qml', 'application/x-qt.qbs+qml')),
@@ -352,43 +379,53 @@ LEXERS = {
     'RagelLexer': ('pygments.lexers.parsers', 'Ragel', ('ragel',), (), ()),
     'RagelObjectiveCLexer': ('pygments.lexers.parsers', 'Ragel in Objective C Host', ('ragel-objc',), ('*.rl',), ()),
     'RagelRubyLexer': ('pygments.lexers.parsers', 'Ragel in Ruby Host', ('ragel-ruby', 'ragel-rb'), ('*.rl',), ()),
-    'RawTokenLexer': ('pygments.lexers.special', 'Raw token data', ('raw',), (), ('application/x-pygments-tokens',)),
+    'RawTokenLexer': ('pygments.lexers.special', 'Raw token data', (), (), ('application/x-pygments-tokens',)),
     'RdLexer': ('pygments.lexers.r', 'Rd', ('rd',), ('*.Rd',), ('text/x-r-doc',)),
+    'ReasonLexer': ('pygments.lexers.ml', 'ReasonML', ('reason', 'reasonml'), ('*.re', '*.rei'), ('text/x-reasonml',)),
     'RebolLexer': ('pygments.lexers.rebol', 'REBOL', ('rebol',), ('*.r', '*.r3', '*.reb'), ('text/x-rebol',)),
     'RedLexer': ('pygments.lexers.rebol', 'Red', ('red', 'red/system'), ('*.red', '*.reds'), ('text/x-red', 'text/x-red-system')),
     'RedcodeLexer': ('pygments.lexers.esoteric', 'Redcode', ('redcode',), ('*.cw',), ()),
     'RegeditLexer': ('pygments.lexers.configs', 'reg', ('registry',), ('*.reg',), ('text/x-windows-registry',)),
-    'ResourceLexer': ('pygments.lexers.resource', 'ResourceBundle', ('resource', 'resourcebundle'), ('*.txt',), ()),
+    'ResourceLexer': ('pygments.lexers.resource', 'ResourceBundle', ('resource', 'resourcebundle'), (), ()),
     'RexxLexer': ('pygments.lexers.scripting', 'Rexx', ('rexx', 'arexx'), ('*.rexx', '*.rex', '*.rx', '*.arexx'), ('text/x-rexx',)),
     'RhtmlLexer': ('pygments.lexers.templates', 'RHTML', ('rhtml', 'html+erb', 'html+ruby'), ('*.rhtml',), ('text/html+ruby',)),
+    'RideLexer': ('pygments.lexers.ride', 'Ride', ('ride',), ('*.ride',), ('text/x-ride',)),
     'RoboconfGraphLexer': ('pygments.lexers.roboconf', 'Roboconf Graph', ('roboconf-graph',), ('*.graph',), ()),
     'RoboconfInstancesLexer': ('pygments.lexers.roboconf', 'Roboconf Instances', ('roboconf-instances',), ('*.instances',), ()),
-    'RobotFrameworkLexer': ('pygments.lexers.robotframework', 'RobotFramework', ('robotframework',), ('*.txt', '*.robot'), ('text/x-robotframework',)),
+    'RobotFrameworkLexer': ('pygments.lexers.robotframework', 'RobotFramework', ('robotframework',), ('*.robot',), ('text/x-robotframework',)),
     'RqlLexer': ('pygments.lexers.sql', 'RQL', ('rql',), ('*.rql',), ('text/x-rql',)),
     'RslLexer': ('pygments.lexers.dsls', 'RSL', ('rsl',), ('*.rsl',), ('text/rsl',)),
     'RstLexer': ('pygments.lexers.markup', 'reStructuredText', ('rst', 'rest', 'restructuredtext'), ('*.rst', '*.rest'), ('text/x-rst', 'text/prs.fallenstein.rst')),
     'RtsLexer': ('pygments.lexers.trafficscript', 'TrafficScript', ('rts', 'trafficscript'), ('*.rts',), ()),
     'RubyConsoleLexer': ('pygments.lexers.ruby', 'Ruby irb session', ('rbcon', 'irb'), (), ('text/x-ruby-shellsession',)),
     'RubyLexer': ('pygments.lexers.ruby', 'Ruby', ('rb', 'ruby', 'duby'), ('*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec', '*.rbx', '*.duby', 'Gemfile'), ('text/x-ruby', 'application/x-ruby')),
-    'RustLexer': ('pygments.lexers.rust', 'Rust', ('rust',), ('*.rs', '*.rs.in'), ('text/rust',)),
+    'RustLexer': ('pygments.lexers.rust', 'Rust', ('rust', 'rs'), ('*.rs', '*.rs.in'), ('text/rust', 'text/x-rust')),
     'SASLexer': ('pygments.lexers.sas', 'SAS', ('sas',), ('*.SAS', '*.sas'), ('text/x-sas', 'text/sas', 'application/x-sas')),
     'SLexer': ('pygments.lexers.r', 'S', ('splus', 's', 'r'), ('*.S', '*.R', '.Rhistory', '.Rprofile', '.Renviron'), ('text/S-plus', 'text/S', 'text/x-r-source', 'text/x-r', 'text/x-R', 'text/x-r-history', 'text/x-r-profile')),
     'SMLLexer': ('pygments.lexers.ml', 'Standard ML', ('sml',), ('*.sml', '*.sig', '*.fun'), ('text/x-standardml', 'application/x-standardml')),
+    'SarlLexer': ('pygments.lexers.jvm', 'SARL', ('sarl',), ('*.sarl',), ('text/x-sarl',)),
     'SassLexer': ('pygments.lexers.css', 'Sass', ('sass',), ('*.sass',), ('text/x-sass',)),
     'ScalaLexer': ('pygments.lexers.jvm', 'Scala', ('scala',), ('*.scala',), ('text/x-scala',)),
     'ScamlLexer': ('pygments.lexers.html', 'Scaml', ('scaml',), ('*.scaml',), ('text/x-scaml',)),
+    'ScdocLexer': ('pygments.lexers.scdoc', 'scdoc', ('scdoc', 'scd'), ('*.scd', '*.scdoc'), ()),
     'SchemeLexer': ('pygments.lexers.lisp', 'Scheme', ('scheme', 'scm'), ('*.scm', '*.ss'), ('text/x-scheme', 'application/x-scheme')),
     'ScilabLexer': ('pygments.lexers.matlab', 'Scilab', ('scilab',), ('*.sci', '*.sce', '*.tst'), ('text/scilab',)),
     'ScssLexer': ('pygments.lexers.css', 'SCSS', ('scss',), ('*.scss',), ('text/x-scss',)),
+    'ShExCLexer': ('pygments.lexers.rdf', 'ShExC', ('shexc', 'shex'), ('*.shex',), ('text/shex',)),
     'ShenLexer': ('pygments.lexers.lisp', 'Shen', ('shen',), ('*.shen',), ('text/x-shen', 'application/x-shen')),
+    'SieveLexer': ('pygments.lexers.sieve', 'Sieve', ('sieve',), ('*.siv', '*.sieve'), ()),
     'SilverLexer': ('pygments.lexers.verification', 'Silver', ('silver',), ('*.sil', '*.vpr'), ()),
-    'SlashLexer': ('pygments.lexers.github', 'Slash', ('slash',), ('*.sl',), ()),
+    'SingularityLexer': ('pygments.lexers.configs', 'Singularity', ('singularity',), ('*.def', 'Singularity'), ()),
+    'SlashLexer': ('pygments.lexers.slash', 'Slash', ('slash',), ('*.sla',), ()),
     'SlimLexer': ('pygments.lexers.webmisc', 'Slim', ('slim',), ('*.slim',), ('text/x-slim',)),
+    'SlurmBashLexer': ('pygments.lexers.shell', 'Slurm', ('slurm', 'sbatch'), ('*.sl',), ()),
     'SmaliLexer': ('pygments.lexers.dalvik', 'Smali', ('smali',), ('*.smali',), ('text/smali',)),
     'SmalltalkLexer': ('pygments.lexers.smalltalk', 'Smalltalk', ('smalltalk', 'squeak', 'st'), ('*.st',), ('text/x-smalltalk',)),
+    'SmartGameFormatLexer': ('pygments.lexers.sgf', 'SmartGameFormat', ('sgf',), ('*.sgf',), ()),
     'SmartyLexer': ('pygments.lexers.templates', 'Smarty', ('smarty',), ('*.tpl',), ('application/x-smarty',)),
     'SnobolLexer': ('pygments.lexers.snobol', 'Snobol', ('snobol',), ('*.snobol',), ('text/x-snobol',)),
     'SnowballLexer': ('pygments.lexers.dsls', 'Snowball', ('snowball',), ('*.sbl',), ()),
+    'SolidityLexer': ('pygments.lexers.solidity', 'Solidity', ('solidity',), ('*.sol',), ()),
     'SourcePawnLexer': ('pygments.lexers.pawn', 'SourcePawn', ('sp',), ('*.sp',), ('text/x-sourcepawn',)),
     'SourcesListLexer': ('pygments.lexers.installers', 'Debian Sourcelist', ('sourceslist', 'sources.list', 'debsources'), ('sources.list',), ()),
     'SparqlLexer': ('pygments.lexers.rdf', 'SPARQL', ('sparql',), ('*.rq', '*.sparql'), ('application/sparql-query',)),
@@ -403,19 +440,22 @@ LEXERS = {
     'SwigLexer': ('pygments.lexers.c_like', 'SWIG', ('swig',), ('*.swg', '*.i'), ('text/swig',)),
     'SystemVerilogLexer': ('pygments.lexers.hdl', 'systemverilog', ('systemverilog', 'sv'), ('*.sv', '*.svh'), ('text/x-systemverilog',)),
     'TAPLexer': ('pygments.lexers.testing', 'TAP', ('tap',), ('*.tap',), ()),
-    'TOMLLexer': ('pygments.lexers.github', 'TOML', ('toml',), ('*.toml',), ()),
+    'TNTLexer': ('pygments.lexers.tnt', 'Typographic Number Theory', ('tnt',), ('*.tnt',), ()),
+    'TOMLLexer': ('pygments.lexers.configs', 'TOML', ('toml',), ('*.toml', 'Pipfile', 'poetry.lock'), ()),
     'Tads3Lexer': ('pygments.lexers.int_fiction', 'TADS 3', ('tads3',), ('*.t',), ()),
     'TasmLexer': ('pygments.lexers.asm', 'TASM', ('tasm',), ('*.asm', '*.ASM', '*.tasm'), ('text/x-tasm',)),
     'TclLexer': ('pygments.lexers.tcl', 'Tcl', ('tcl',), ('*.tcl', '*.rvt'), ('text/x-tcl', 'text/x-script.tcl', 'application/x-tcl')),
     'TcshLexer': ('pygments.lexers.shell', 'Tcsh', ('tcsh', 'csh'), ('*.tcsh', '*.csh'), ('application/x-csh',)),
     'TcshSessionLexer': ('pygments.lexers.shell', 'Tcsh Session', ('tcshcon',), (), ()),
     'TeaTemplateLexer': ('pygments.lexers.templates', 'Tea', ('tea',), ('*.tea',), ('text/x-tea',)),
+    'TeraTermLexer': ('pygments.lexers.teraterm', 'Tera Term macro', ('ttl', 'teraterm', 'teratermmacro'), ('*.ttl',), ('text/x-teratermmacro',)),
     'TermcapLexer': ('pygments.lexers.configs', 'Termcap', ('termcap',), ('termcap', 'termcap.src'), ()),
     'TerminfoLexer': ('pygments.lexers.configs', 'Terminfo', ('terminfo',), ('terminfo', 'terminfo.src'), ()),
     'TerraformLexer': ('pygments.lexers.configs', 'Terraform', ('terraform', 'tf'), ('*.tf',), ('application/x-tf', 'application/x-terraform')),
     'TexLexer': ('pygments.lexers.markup', 'TeX', ('tex', 'latex'), ('*.tex', '*.aux', '*.toc'), ('text/x-tex', 'text/x-latex')),
     'TextLexer': ('pygments.lexers.special', 'Text only', ('text',), ('*.txt',), ('text/plain',)),
     'ThriftLexer': ('pygments.lexers.dsls', 'Thrift', ('thrift',), ('*.thrift',), ('application/x-thrift',)),
+    'TiddlyWiki5Lexer': ('pygments.lexers.markup', 'tiddler', ('tid',), ('*.tid',), ('text/vnd.tiddlywiki',)),
     'TodotxtLexer': ('pygments.lexers.textfmts', 'Todotxt', ('todotxt',), ('todo.txt', '*.todotxt'), ('text/x-todo',)),
     'TransactSqlLexer': ('pygments.lexers.sql', 'Transact-SQL', ('tsql', 't-sql'), ('*.sql',), ('text/x-tsql',)),
     'TreetopLexer': ('pygments.lexers.parsers', 'Treetop', ('treetop',), ('*.treetop', '*.tt'), ()),
@@ -425,8 +465,12 @@ LEXERS = {
     'TypeScriptLexer': ('pygments.lexers.javascript', 'TypeScript', ('ts', 'typescript'), ('*.ts', '*.tsx'), ('text/x-typescript',)),
     'TypoScriptCssDataLexer': ('pygments.lexers.typoscript', 'TypoScriptCssData', ('typoscriptcssdata',), (), ()),
     'TypoScriptHtmlDataLexer': ('pygments.lexers.typoscript', 'TypoScriptHtmlData', ('typoscripthtmldata',), (), ()),
-    'TypoScriptLexer': ('pygments.lexers.typoscript', 'TypoScript', ('typoscript',), ('*.ts', '*.txt'), ('text/x-typoscript',)),
+    'TypoScriptLexer': ('pygments.lexers.typoscript', 'TypoScript', ('typoscript',), ('*.typoscript',), ('text/x-typoscript',)),
+    'UcodeLexer': ('pygments.lexers.unicon', 'ucode', ('ucode',), ('*.u', '*.u1', '*.u2'), ()),
+    'UniconLexer': ('pygments.lexers.unicon', 'Unicon', ('unicon',), ('*.icn',), ('text/unicon',)),
     'UrbiscriptLexer': ('pygments.lexers.urbi', 'UrbiScript', ('urbiscript',), ('*.u',), ('application/x-urbiscript',)),
+    'UsdLexer': ('pygments.lexers.usd', 'USD', ('usd', 'usda'), ('*.usd', '*.usda'), ()),
+    'VBScriptLexer': ('pygments.lexers.basic', 'VBScript', ('vbscript',), ('*.vbs', '*.VBS'), ()),
     'VCLLexer': ('pygments.lexers.varnish', 'VCL', ('vcl',), ('*.vcl',), ('text/x-vclsrc',)),
     'VCLSnippetLexer': ('pygments.lexers.varnish', 'VCLSnippets', ('vclsnippets', 'vclsnippet'), (), ('text/x-vclsnippet',)),
     'VCTreeStatusLexer': ('pygments.lexers.console', 'VCTreeStatus', ('vctreestatus',), (), ()),
@@ -441,6 +485,7 @@ LEXERS = {
     'VhdlLexer': ('pygments.lexers.hdl', 'vhdl', ('vhdl',), ('*.vhdl', '*.vhd'), ('text/x-vhdl',)),
     'VimLexer': ('pygments.lexers.textedit', 'VimL', ('vim',), ('*.vim', '.vimrc', '.exrc', '.gvimrc', '_vimrc', '_exrc', '_gvimrc', 'vimrc', 'gvimrc'), ('text/x-vim',)),
     'WDiffLexer': ('pygments.lexers.diff', 'WDiff', ('wdiff',), ('*.wdiff',), ()),
+    'WebIDLLexer': ('pygments.lexers.webidl', 'Web IDL', ('webidl',), ('*.webidl',), ()),
     'WhileyLexer': ('pygments.lexers.whiley', 'Whiley', ('whiley',), ('*.whiley',), ('text/x-whiley',)),
     'X10Lexer': ('pygments.lexers.x10', 'X10', ('x10', 'xten'), ('*.x10',), ('text/x-x10',)),
     'XQueryLexer': ('pygments.lexers.webmisc', 'XQuery', ('xquery', 'xqy', 'xq', 'xql', 'xqm'), ('*.xqy', '*.xquery', '*.xq', '*.xql', '*.xqm'), ('text/xquery', 'application/xquery')),
@@ -455,7 +500,10 @@ LEXERS = {
     'XtlangLexer': ('pygments.lexers.lisp', 'xtlang', ('extempore',), ('*.xtm',), ()),
     'YamlJinjaLexer': ('pygments.lexers.templates', 'YAML+Jinja', ('yaml+jinja', 'salt', 'sls'), ('*.sls',), ('text/x-yaml+jinja', 'text/x-sls')),
     'YamlLexer': ('pygments.lexers.data', 'YAML', ('yaml',), ('*.yaml', '*.yml'), ('text/x-yaml',)),
+    'YangLexer': ('pygments.lexers.yang', 'YANG', ('yang',), ('*.yang',), ('application/yang',)),
+    'ZeekLexer': ('pygments.lexers.dsls', 'Zeek', ('zeek', 'bro'), ('*.zeek', '*.bro'), ()),
     'ZephirLexer': ('pygments.lexers.php', 'Zephir', ('zephir',), ('*.zep',), ()),
+    'ZigLexer': ('pygments.lexers.zig', 'Zig', ('zig',), ('*.zig',), ('text/zig',)),
 }
 
 if __name__ == '__main__':  # pragma: no cover

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers._mql_builtins
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Builtins for the MqlLexer.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 types = (
@@ -884,7 +883,7 @@ constants = (
     'PERIOD_W1',
     'POINTER_AUTOMATIC',
     'POINTER_DYNAMIC',
-    'POINTER_INVALID'
+    'POINTER_INVALID',
     'PRICE_CLOSE',
     'PRICE_HIGH',
     'PRICE_LOW',

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

@@ -0,0 +1,1281 @@
+"""
+    pygments.lexers._mysql_builtins
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Self-updating data files for the MySQL lexer.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+
+MYSQL_CONSTANTS = (
+    'false',
+    'null',
+    'true',
+    'unknown',
+)
+
+
+# At this time, no easily-parsed, definitive list of data types
+# has been found in the MySQL source code or documentation. (The
+# `sql/sql_yacc.yy` file is definitive but is difficult to parse.)
+# Therefore these types are currently maintained manually.
+#
+# Some words in this list -- like "long", "national", "precision",
+# and "varying" -- appear to only occur in combination with other
+# data type keywords. Therefore they are included as separate words
+# even though they do not naturally occur in syntax separately.
+#
+# This list is also used to strip data types out of the list of
+# MySQL keywords, which is automatically updated later in the file.
+#
+MYSQL_DATATYPES = (
+    # Numeric data types
+    'bigint',
+    'bit',
+    'bool',
+    'boolean',
+    'dec',
+    'decimal',
+    'double',
+    'fixed',
+    'float',
+    'float4',
+    'float8',
+    'int',
+    'int1',
+    'int2',
+    'int3',
+    'int4',
+    'int8',
+    'integer',
+    'mediumint',
+    'middleint',
+    'numeric',
+    'precision',
+    'real',
+    'serial',
+    'smallint',
+    'tinyint',
+
+    # Date and time data types
+    'date',
+    'datetime',
+    'time',
+    'timestamp',
+    'year',
+
+    # String data types
+    'binary',
+    'blob',
+    'char',
+    'enum',
+    'long',
+    'longblob',
+    'longtext',
+    'mediumblob',
+    'mediumtext',
+    'national',
+    'nchar',
+    'nvarchar',
+    'set',
+    'text',
+    'tinyblob',
+    'tinytext',
+    'varbinary',
+    'varchar',
+    'varcharacter',
+    'varying',
+
+    # Spatial data types
+    'geometry',
+    'geometrycollection',
+    'linestring',
+    'multilinestring',
+    'multipoint',
+    'multipolygon',
+    'point',
+    'polygon',
+
+    # JSON data types
+    'json',
+)
+
+# Everything below this line is auto-generated from the MySQL source code.
+# Run this file in Python and it will update itself.
+# -----------------------------------------------------------------------------
+
+MYSQL_FUNCTIONS = (
+    'abs',
+    'acos',
+    'adddate',
+    'addtime',
+    'aes_decrypt',
+    'aes_encrypt',
+    'any_value',
+    'asin',
+    'atan',
+    'atan2',
+    'benchmark',
+    'bin',
+    'bin_to_uuid',
+    'bit_and',
+    'bit_count',
+    'bit_length',
+    'bit_or',
+    'bit_xor',
+    'can_access_column',
+    'can_access_database',
+    'can_access_event',
+    'can_access_resource_group',
+    'can_access_routine',
+    'can_access_table',
+    'can_access_trigger',
+    'can_access_view',
+    'cast',
+    'ceil',
+    'ceiling',
+    'char_length',
+    'character_length',
+    'coercibility',
+    'compress',
+    'concat',
+    'concat_ws',
+    'connection_id',
+    'conv',
+    'convert_cpu_id_mask',
+    'convert_interval_to_user_interval',
+    'convert_tz',
+    'cos',
+    'cot',
+    'count',
+    'crc32',
+    'curdate',
+    'current_role',
+    'curtime',
+    'date_add',
+    'date_format',
+    'date_sub',
+    'datediff',
+    'dayname',
+    'dayofmonth',
+    'dayofweek',
+    'dayofyear',
+    'degrees',
+    'elt',
+    'exp',
+    'export_set',
+    'extract',
+    'extractvalue',
+    'field',
+    'find_in_set',
+    'floor',
+    'format_bytes',
+    'format_pico_time',
+    'found_rows',
+    'from_base64',
+    'from_days',
+    'from_unixtime',
+    'get_dd_column_privileges',
+    'get_dd_create_options',
+    'get_dd_index_private_data',
+    'get_dd_index_sub_part_length',
+    'get_dd_property_key_value',
+    'get_dd_tablespace_private_data',
+    'get_lock',
+    'greatest',
+    'group_concat',
+    'gtid_subset',
+    'gtid_subtract',
+    'hex',
+    'icu_version',
+    'ifnull',
+    'inet6_aton',
+    'inet6_ntoa',
+    'inet_aton',
+    'inet_ntoa',
+    'instr',
+    'internal_auto_increment',
+    'internal_avg_row_length',
+    'internal_check_time',
+    'internal_checksum',
+    'internal_data_free',
+    'internal_data_length',
+    'internal_dd_char_length',
+    'internal_get_comment_or_error',
+    'internal_get_dd_column_extra',
+    'internal_get_enabled_role_json',
+    'internal_get_hostname',
+    'internal_get_mandatory_roles_json',
+    'internal_get_partition_nodegroup',
+    'internal_get_username',
+    'internal_get_view_warning_or_error',
+    'internal_index_column_cardinality',
+    'internal_index_length',
+    'internal_is_enabled_role',
+    'internal_is_mandatory_role',
+    'internal_keys_disabled',
+    'internal_max_data_length',
+    'internal_table_rows',
+    'internal_tablespace_autoextend_size',
+    'internal_tablespace_data_free',
+    'internal_tablespace_extent_size',
+    'internal_tablespace_extra',
+    'internal_tablespace_free_extents',
+    'internal_tablespace_id',
+    'internal_tablespace_initial_size',
+    'internal_tablespace_logfile_group_name',
+    'internal_tablespace_logfile_group_number',
+    'internal_tablespace_maximum_size',
+    'internal_tablespace_row_format',
+    'internal_tablespace_status',
+    'internal_tablespace_total_extents',
+    'internal_tablespace_type',
+    'internal_tablespace_version',
+    'internal_update_time',
+    'is_free_lock',
+    'is_ipv4',
+    'is_ipv4_compat',
+    'is_ipv4_mapped',
+    'is_ipv6',
+    'is_used_lock',
+    'is_uuid',
+    'is_visible_dd_object',
+    'isnull',
+    'json_array',
+    'json_array_append',
+    'json_array_insert',
+    'json_arrayagg',
+    'json_contains',
+    'json_contains_path',
+    'json_depth',
+    'json_extract',
+    'json_insert',
+    'json_keys',
+    'json_length',
+    'json_merge',
+    'json_merge_patch',
+    'json_merge_preserve',
+    'json_object',
+    'json_objectagg',
+    'json_overlaps',
+    'json_pretty',
+    'json_quote',
+    'json_remove',
+    'json_replace',
+    'json_schema_valid',
+    'json_schema_validation_report',
+    'json_search',
+    'json_set',
+    'json_storage_free',
+    'json_storage_size',
+    'json_type',
+    'json_unquote',
+    'json_valid',
+    'last_day',
+    'last_insert_id',
+    'lcase',
+    'least',
+    'length',
+    'like_range_max',
+    'like_range_min',
+    'ln',
+    'load_file',
+    'locate',
+    'log',
+    'log10',
+    'log2',
+    'lower',
+    'lpad',
+    'ltrim',
+    'make_set',
+    'makedate',
+    'maketime',
+    'master_pos_wait',
+    'max',
+    'mbrcontains',
+    'mbrcoveredby',
+    'mbrcovers',
+    'mbrdisjoint',
+    'mbrequals',
+    'mbrintersects',
+    'mbroverlaps',
+    'mbrtouches',
+    'mbrwithin',
+    'md5',
+    'mid',
+    'min',
+    'monthname',
+    'name_const',
+    'now',
+    'nullif',
+    'oct',
+    'octet_length',
+    'ord',
+    'period_add',
+    'period_diff',
+    'pi',
+    'position',
+    'pow',
+    'power',
+    'ps_current_thread_id',
+    'ps_thread_id',
+    'quote',
+    'radians',
+    'rand',
+    'random_bytes',
+    'regexp_instr',
+    'regexp_like',
+    'regexp_replace',
+    'regexp_substr',
+    'release_all_locks',
+    'release_lock',
+    'remove_dd_property_key',
+    'reverse',
+    'roles_graphml',
+    'round',
+    'rpad',
+    'rtrim',
+    'sec_to_time',
+    'session_user',
+    'sha',
+    'sha1',
+    'sha2',
+    'sign',
+    'sin',
+    'sleep',
+    'soundex',
+    'space',
+    'sqrt',
+    'st_area',
+    'st_asbinary',
+    'st_asgeojson',
+    'st_astext',
+    'st_aswkb',
+    'st_aswkt',
+    'st_buffer',
+    'st_buffer_strategy',
+    'st_centroid',
+    'st_contains',
+    'st_convexhull',
+    'st_crosses',
+    'st_difference',
+    'st_dimension',
+    'st_disjoint',
+    'st_distance',
+    'st_distance_sphere',
+    'st_endpoint',
+    'st_envelope',
+    'st_equals',
+    'st_exteriorring',
+    'st_geohash',
+    'st_geomcollfromtext',
+    'st_geomcollfromtxt',
+    'st_geomcollfromwkb',
+    'st_geometrycollectionfromtext',
+    'st_geometrycollectionfromwkb',
+    'st_geometryfromtext',
+    'st_geometryfromwkb',
+    'st_geometryn',
+    'st_geometrytype',
+    'st_geomfromgeojson',
+    'st_geomfromtext',
+    'st_geomfromwkb',
+    'st_interiorringn',
+    'st_intersection',
+    'st_intersects',
+    'st_isclosed',
+    'st_isempty',
+    'st_issimple',
+    'st_isvalid',
+    'st_latfromgeohash',
+    'st_latitude',
+    'st_length',
+    'st_linefromtext',
+    'st_linefromwkb',
+    'st_linestringfromtext',
+    'st_linestringfromwkb',
+    'st_longfromgeohash',
+    'st_longitude',
+    'st_makeenvelope',
+    'st_mlinefromtext',
+    'st_mlinefromwkb',
+    'st_mpointfromtext',
+    'st_mpointfromwkb',
+    'st_mpolyfromtext',
+    'st_mpolyfromwkb',
+    'st_multilinestringfromtext',
+    'st_multilinestringfromwkb',
+    'st_multipointfromtext',
+    'st_multipointfromwkb',
+    'st_multipolygonfromtext',
+    'st_multipolygonfromwkb',
+    'st_numgeometries',
+    'st_numinteriorring',
+    'st_numinteriorrings',
+    'st_numpoints',
+    'st_overlaps',
+    'st_pointfromgeohash',
+    'st_pointfromtext',
+    'st_pointfromwkb',
+    'st_pointn',
+    'st_polyfromtext',
+    'st_polyfromwkb',
+    'st_polygonfromtext',
+    'st_polygonfromwkb',
+    'st_simplify',
+    'st_srid',
+    'st_startpoint',
+    'st_swapxy',
+    'st_symdifference',
+    'st_touches',
+    'st_transform',
+    'st_union',
+    'st_validate',
+    'st_within',
+    'st_x',
+    'st_y',
+    'statement_digest',
+    'statement_digest_text',
+    'std',
+    'stddev',
+    'stddev_pop',
+    'stddev_samp',
+    'str_to_date',
+    'strcmp',
+    'subdate',
+    'substr',
+    'substring',
+    'substring_index',
+    'subtime',
+    'sum',
+    'sysdate',
+    'system_user',
+    'tan',
+    'time_format',
+    'time_to_sec',
+    'timediff',
+    'to_base64',
+    'to_days',
+    'to_seconds',
+    'trim',
+    'ucase',
+    'uncompress',
+    'uncompressed_length',
+    'unhex',
+    'unix_timestamp',
+    'updatexml',
+    'upper',
+    'uuid',
+    'uuid_short',
+    'uuid_to_bin',
+    'validate_password_strength',
+    'var_pop',
+    'var_samp',
+    'variance',
+    'version',
+    'wait_for_executed_gtid_set',
+    'wait_until_sql_thread_after_gtids',
+    'weekday',
+    'weekofyear',
+    'yearweek',
+)
+
+
+MYSQL_OPTIMIZER_HINTS = (
+    'bka',
+    'bnl',
+    'dupsweedout',
+    'firstmatch',
+    'group_index',
+    'hash_join',
+    'index',
+    'index_merge',
+    'intoexists',
+    'join_fixed_order',
+    'join_index',
+    'join_order',
+    'join_prefix',
+    'join_suffix',
+    'loosescan',
+    'materialization',
+    'max_execution_time',
+    'merge',
+    'mrr',
+    'no_bka',
+    'no_bnl',
+    'no_group_index',
+    'no_hash_join',
+    'no_icp',
+    'no_index',
+    'no_index_merge',
+    'no_join_index',
+    'no_merge',
+    'no_mrr',
+    'no_order_index',
+    'no_range_optimization',
+    'no_semijoin',
+    'no_skip_scan',
+    'order_index',
+    'qb_name',
+    'resource_group',
+    'semijoin',
+    'set_var',
+    'skip_scan',
+    'subquery',
+)
+
+
+MYSQL_KEYWORDS = (
+    'accessible',
+    'account',
+    'action',
+    'active',
+    'add',
+    'admin',
+    'after',
+    'against',
+    'aggregate',
+    'algorithm',
+    'all',
+    'alter',
+    'always',
+    'analyze',
+    'and',
+    'any',
+    'array',
+    'as',
+    'asc',
+    'ascii',
+    'asensitive',
+    'at',
+    'attribute',
+    'auto_increment',
+    'autoextend_size',
+    'avg',
+    'avg_row_length',
+    'backup',
+    'before',
+    'begin',
+    'between',
+    'binlog',
+    'block',
+    'both',
+    'btree',
+    'buckets',
+    'by',
+    'byte',
+    'cache',
+    'call',
+    'cascade',
+    'cascaded',
+    'case',
+    'catalog_name',
+    'chain',
+    'change',
+    'changed',
+    'channel',
+    'character',
+    'charset',
+    'check',
+    'checksum',
+    'cipher',
+    'class_origin',
+    'client',
+    'clone',
+    'close',
+    'coalesce',
+    'code',
+    'collate',
+    'collation',
+    'column',
+    'column_format',
+    'column_name',
+    'columns',
+    'comment',
+    'commit',
+    'committed',
+    'compact',
+    'completion',
+    'component',
+    'compressed',
+    'compression',
+    'concurrent',
+    'condition',
+    'connection',
+    'consistent',
+    'constraint',
+    'constraint_catalog',
+    'constraint_name',
+    'constraint_schema',
+    'contains',
+    'context',
+    'continue',
+    'convert',
+    'cpu',
+    'create',
+    'cross',
+    'cube',
+    'cume_dist',
+    'current',
+    'current_date',
+    'current_time',
+    'current_timestamp',
+    'current_user',
+    'cursor',
+    'cursor_name',
+    'data',
+    'database',
+    'databases',
+    'datafile',
+    'day',
+    'day_hour',
+    'day_microsecond',
+    'day_minute',
+    'day_second',
+    'deallocate',
+    'declare',
+    'default',
+    'default_auth',
+    'definer',
+    'definition',
+    'delay_key_write',
+    'delayed',
+    'delete',
+    'dense_rank',
+    'desc',
+    'describe',
+    'description',
+    'deterministic',
+    'diagnostics',
+    'directory',
+    'disable',
+    'discard',
+    'disk',
+    'distinct',
+    'distinctrow',
+    'div',
+    'do',
+    'drop',
+    'dual',
+    'dumpfile',
+    'duplicate',
+    'dynamic',
+    'each',
+    'else',
+    'elseif',
+    'empty',
+    'enable',
+    'enclosed',
+    'encryption',
+    'end',
+    'ends',
+    'enforced',
+    'engine',
+    'engine_attribute',
+    'engines',
+    'error',
+    'errors',
+    'escape',
+    'escaped',
+    'event',
+    'events',
+    'every',
+    'except',
+    'exchange',
+    'exclude',
+    'execute',
+    'exists',
+    'exit',
+    'expansion',
+    'expire',
+    'explain',
+    'export',
+    'extended',
+    'extent_size',
+    'failed_login_attempts',
+    'false',
+    'fast',
+    'faults',
+    'fetch',
+    'fields',
+    'file',
+    'file_block_size',
+    'filter',
+    'first',
+    'first_value',
+    'flush',
+    'following',
+    'follows',
+    'for',
+    'force',
+    'foreign',
+    'format',
+    'found',
+    'from',
+    'full',
+    'fulltext',
+    'function',
+    'general',
+    'generated',
+    'geomcollection',
+    'get',
+    'get_format',
+    'get_master_public_key',
+    'global',
+    'grant',
+    'grants',
+    'group',
+    'group_replication',
+    'grouping',
+    'groups',
+    'handler',
+    'hash',
+    'having',
+    'help',
+    'high_priority',
+    'histogram',
+    'history',
+    'host',
+    'hosts',
+    'hour',
+    'hour_microsecond',
+    'hour_minute',
+    'hour_second',
+    'identified',
+    'if',
+    'ignore',
+    'ignore_server_ids',
+    'import',
+    'in',
+    'inactive',
+    'index',
+    'indexes',
+    'infile',
+    'initial_size',
+    'inner',
+    'inout',
+    'insensitive',
+    'insert',
+    'insert_method',
+    'install',
+    'instance',
+    'interval',
+    'into',
+    'invisible',
+    'invoker',
+    'io',
+    'io_after_gtids',
+    'io_before_gtids',
+    'io_thread',
+    'ipc',
+    'is',
+    'isolation',
+    'issuer',
+    'iterate',
+    'join',
+    'json_table',
+    'json_value',
+    'key',
+    'key_block_size',
+    'keys',
+    'kill',
+    'lag',
+    'language',
+    'last',
+    'last_value',
+    'lateral',
+    'lead',
+    'leading',
+    'leave',
+    'leaves',
+    'left',
+    'less',
+    'level',
+    'like',
+    'limit',
+    'linear',
+    'lines',
+    'list',
+    'load',
+    'local',
+    'localtime',
+    'localtimestamp',
+    'lock',
+    'locked',
+    'locks',
+    'logfile',
+    'logs',
+    'loop',
+    'low_priority',
+    'master',
+    'master_auto_position',
+    'master_bind',
+    'master_compression_algorithms',
+    'master_connect_retry',
+    'master_delay',
+    'master_heartbeat_period',
+    'master_host',
+    'master_log_file',
+    'master_log_pos',
+    'master_password',
+    'master_port',
+    'master_public_key_path',
+    'master_retry_count',
+    'master_server_id',
+    'master_ssl',
+    'master_ssl_ca',
+    'master_ssl_capath',
+    'master_ssl_cert',
+    'master_ssl_cipher',
+    'master_ssl_crl',
+    'master_ssl_crlpath',
+    'master_ssl_key',
+    'master_ssl_verify_server_cert',
+    'master_tls_ciphersuites',
+    'master_tls_version',
+    'master_user',
+    'master_zstd_compression_level',
+    'match',
+    'max_connections_per_hour',
+    'max_queries_per_hour',
+    'max_rows',
+    'max_size',
+    'max_updates_per_hour',
+    'max_user_connections',
+    'maxvalue',
+    'medium',
+    'member',
+    'memory',
+    'merge',
+    'message_text',
+    'microsecond',
+    'migrate',
+    'min_rows',
+    'minute',
+    'minute_microsecond',
+    'minute_second',
+    'mod',
+    'mode',
+    'modifies',
+    'modify',
+    'month',
+    'mutex',
+    'mysql_errno',
+    'name',
+    'names',
+    'natural',
+    'ndb',
+    'ndbcluster',
+    'nested',
+    'network_namespace',
+    'never',
+    'new',
+    'next',
+    'no',
+    'no_wait',
+    'no_write_to_binlog',
+    'nodegroup',
+    'none',
+    'not',
+    'nowait',
+    'nth_value',
+    'ntile',
+    'null',
+    'nulls',
+    'number',
+    'of',
+    'off',
+    'offset',
+    'oj',
+    'old',
+    'on',
+    'one',
+    'only',
+    'open',
+    'optimize',
+    'optimizer_costs',
+    'option',
+    'optional',
+    'optionally',
+    'options',
+    'or',
+    'order',
+    'ordinality',
+    'organization',
+    'others',
+    'out',
+    'outer',
+    'outfile',
+    'over',
+    'owner',
+    'pack_keys',
+    'page',
+    'parser',
+    'partial',
+    'partition',
+    'partitioning',
+    'partitions',
+    'password',
+    'password_lock_time',
+    'path',
+    'percent_rank',
+    'persist',
+    'persist_only',
+    'phase',
+    'plugin',
+    'plugin_dir',
+    'plugins',
+    'port',
+    'precedes',
+    'preceding',
+    'prepare',
+    'preserve',
+    'prev',
+    'primary',
+    'privilege_checks_user',
+    'privileges',
+    'procedure',
+    'process',
+    'processlist',
+    'profile',
+    'profiles',
+    'proxy',
+    'purge',
+    'quarter',
+    'query',
+    'quick',
+    'random',
+    'range',
+    'rank',
+    'read',
+    'read_only',
+    'read_write',
+    'reads',
+    'rebuild',
+    'recover',
+    'recursive',
+    'redo_buffer_size',
+    'redundant',
+    'reference',
+    'references',
+    'regexp',
+    'relay',
+    'relay_log_file',
+    'relay_log_pos',
+    'relay_thread',
+    'relaylog',
+    'release',
+    'reload',
+    'remove',
+    'rename',
+    'reorganize',
+    'repair',
+    'repeat',
+    'repeatable',
+    'replace',
+    'replicate_do_db',
+    'replicate_do_table',
+    'replicate_ignore_db',
+    'replicate_ignore_table',
+    'replicate_rewrite_db',
+    'replicate_wild_do_table',
+    'replicate_wild_ignore_table',
+    'replication',
+    'require',
+    'require_row_format',
+    'require_table_primary_key_check',
+    'reset',
+    'resignal',
+    'resource',
+    'respect',
+    'restart',
+    'restore',
+    'restrict',
+    'resume',
+    'retain',
+    'return',
+    'returned_sqlstate',
+    'returning',
+    'returns',
+    'reuse',
+    'reverse',
+    'revoke',
+    'right',
+    'rlike',
+    'role',
+    'rollback',
+    'rollup',
+    'rotate',
+    'routine',
+    'row',
+    'row_count',
+    'row_format',
+    'row_number',
+    'rows',
+    'rtree',
+    'savepoint',
+    'schedule',
+    'schema',
+    'schema_name',
+    'schemas',
+    'second',
+    'second_microsecond',
+    'secondary',
+    'secondary_engine',
+    'secondary_engine_attribute',
+    'secondary_load',
+    'secondary_unload',
+    'security',
+    'select',
+    'sensitive',
+    'separator',
+    'serializable',
+    'server',
+    'session',
+    'share',
+    'show',
+    'shutdown',
+    'signal',
+    'signed',
+    'simple',
+    'skip',
+    'slave',
+    'slow',
+    'snapshot',
+    'socket',
+    'some',
+    'soname',
+    'sounds',
+    'source',
+    'spatial',
+    'specific',
+    'sql',
+    'sql_after_gtids',
+    'sql_after_mts_gaps',
+    'sql_before_gtids',
+    'sql_big_result',
+    'sql_buffer_result',
+    'sql_calc_found_rows',
+    'sql_no_cache',
+    'sql_small_result',
+    'sql_thread',
+    'sql_tsi_day',
+    'sql_tsi_hour',
+    'sql_tsi_minute',
+    'sql_tsi_month',
+    'sql_tsi_quarter',
+    'sql_tsi_second',
+    'sql_tsi_week',
+    'sql_tsi_year',
+    'sqlexception',
+    'sqlstate',
+    'sqlwarning',
+    'srid',
+    'ssl',
+    'stacked',
+    'start',
+    'starting',
+    'starts',
+    'stats_auto_recalc',
+    'stats_persistent',
+    'stats_sample_pages',
+    'status',
+    'stop',
+    'storage',
+    'stored',
+    'straight_join',
+    'stream',
+    'string',
+    'subclass_origin',
+    'subject',
+    'subpartition',
+    'subpartitions',
+    'super',
+    'suspend',
+    'swaps',
+    'switches',
+    'system',
+    'table',
+    'table_checksum',
+    'table_name',
+    'tables',
+    'tablespace',
+    'temporary',
+    'temptable',
+    'terminated',
+    'than',
+    'then',
+    'thread_priority',
+    'ties',
+    'timestampadd',
+    'timestampdiff',
+    'tls',
+    'to',
+    'trailing',
+    'transaction',
+    'trigger',
+    'triggers',
+    'true',
+    'truncate',
+    'type',
+    'types',
+    'unbounded',
+    'uncommitted',
+    'undefined',
+    'undo',
+    'undo_buffer_size',
+    'undofile',
+    'unicode',
+    'uninstall',
+    'union',
+    'unique',
+    'unknown',
+    'unlock',
+    'unsigned',
+    'until',
+    'update',
+    'upgrade',
+    'usage',
+    'use',
+    'use_frm',
+    'user',
+    'user_resources',
+    'using',
+    'utc_date',
+    'utc_time',
+    'utc_timestamp',
+    'validation',
+    'value',
+    'values',
+    'variables',
+    'vcpu',
+    'view',
+    'virtual',
+    'visible',
+    'wait',
+    'warnings',
+    'week',
+    'weight_string',
+    'when',
+    'where',
+    'while',
+    'window',
+    'with',
+    'without',
+    'work',
+    'wrapper',
+    'write',
+    'x509',
+    'xa',
+    'xid',
+    'xml',
+    'xor',
+    'year_month',
+    'zerofill',
+)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    import re
+    from urllib.request import urlopen
+
+    from pygments.util import format_lines
+
+    # MySQL source code
+    SOURCE_URL = 'https://github.com/mysql/mysql-server/raw/8.0'
+    LEX_URL = SOURCE_URL + '/sql/lex.h'
+    ITEM_CREATE_URL = SOURCE_URL + '/sql/item_create.cc'
+
+
+    def update_myself():
+        # Pull content from lex.h.
+        lex_file = urlopen(LEX_URL).read().decode('utf8', errors='ignore')
+        keywords = parse_lex_keywords(lex_file)
+        functions = parse_lex_functions(lex_file)
+        optimizer_hints = parse_lex_optimizer_hints(lex_file)
+
+        # Parse content in item_create.cc.
+        item_create_file = urlopen(ITEM_CREATE_URL).read().decode('utf8', errors='ignore')
+        functions.update(parse_item_create_functions(item_create_file))
+
+        # Remove data types from the set of keywords.
+        keywords -= set(MYSQL_DATATYPES)
+
+        update_content('MYSQL_FUNCTIONS', tuple(sorted(functions)))
+        update_content('MYSQL_KEYWORDS', tuple(sorted(keywords)))
+        update_content('MYSQL_OPTIMIZER_HINTS', tuple(sorted(optimizer_hints)))
+
+
+    def parse_lex_keywords(f):
+        """Parse keywords in lex.h."""
+
+        results = set()
+        for m in re.finditer(r'{SYM(?:_HK)?\("(?P<keyword>[a-z0-9_]+)",', f, flags=re.I):
+            results.add(m.group('keyword').lower())
+
+        if not results:
+            raise ValueError('No keywords found')
+
+        return results
+
+
+    def parse_lex_optimizer_hints(f):
+        """Parse optimizer hints in lex.h."""
+
+        results = set()
+        for m in re.finditer(r'{SYM_H\("(?P<keyword>[a-z0-9_]+)",', f, flags=re.I):
+            results.add(m.group('keyword').lower())
+
+        if not results:
+            raise ValueError('No optimizer hints found')
+
+        return results
+
+
+    def parse_lex_functions(f):
+        """Parse MySQL function names from lex.h."""
+
+        results = set()
+        for m in re.finditer(r'{SYM_FN?\("(?P<function>[a-z0-9_]+)",', f, flags=re.I):
+            results.add(m.group('function').lower())
+
+        if not results:
+            raise ValueError('No lex functions found')
+
+        return results
+
+
+    def parse_item_create_functions(f):
+        """Parse MySQL function names from item_create.cc."""
+
+        results = set()
+        for m in re.finditer(r'{"(?P<function>[^"]+?)",\s*SQL_F[^(]+?\(', f, flags=re.I):
+            results.add(m.group('function').lower())
+
+        if not results:
+            raise ValueError('No item_create functions found')
+
+        return results
+
+
+    def update_content(field_name, content):
+        """Overwrite this file with content parsed from MySQL's source code."""
+
+        with open(__file__) as f:
+            data = f.read()
+
+        # Line to start/end inserting
+        re_match = re.compile(r'^%s\s*=\s*\($.*?^\s*\)$' % field_name, re.M | re.S)
+        m = re_match.search(data)
+        if not m:
+            raise ValueError('Could not find an existing definition for %s' % field_name)
+
+        new_block = format_lines(field_name, content)
+        data = data[:m.start()] + new_block + data[m.end():]
+
+        with open(__file__, 'w', newline='\n') as f:
+            f.write(data)
+
+    update_myself()