pygments.rb 2.2.0 → 2.3.0

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

@@ -267,11 +267,11 @@ class VelocityLexer(RegexLexer):
 
     def analyse_text(text):
         rv = 0.0
-        if re.search(r'#\{?macro\}?\(.*?\).*?#\{?end\}?', text):
+        if re.search(r'#\{?macro\}?\(.*?\).*?#\{?end\}?', text, re.DOTALL):
             rv += 0.25
-        if re.search(r'#\{?if\}?\(.+?\).*?#\{?end\}?', text):
+        if re.search(r'#\{?if\}?\(.+?\).*?#\{?end\}?', text, re.DOTALL):
             rv += 0.15
-        if re.search(r'#\{?foreach\}?\(.+?\).*?#\{?end\}?', text):
+        if re.search(r'#\{?foreach\}?\(.+?\).*?#\{?end\}?', text, re.DOTALL):
             rv += 0.15
         if re.search(r'\$!?\{?[a-zA-Z_]\w*(\([^)]*\))?'
                      r'(\.\w+(\([^)]*\))?)*\}?', text):
@@ -489,7 +489,7 @@ class MyghtyJavascriptLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Myghty'
-    aliases = ['js+myghty', 'javascript+myghty']
+    aliases = ['javascript+myghty', 'js+myghty']
     mimetypes = ['application/x-javascript+myghty',
                  'text/x-javascript+myghty',
                  'text/javascript+mygthy']
@@ -588,12 +588,12 @@ class MakoLexer(RegexLexer):
     tokens = {
         'root': [
             (r'(\s*)(%)(\s*end(?:\w+))(\n|\Z)',
-             bygroups(Text, Comment.Preproc, Keyword, Other)),
+             bygroups(Text.Whitespace, Comment.Preproc, Keyword, Other)),
             (r'(\s*)(%)([^\n]*)(\n|\Z)',
-             bygroups(Text, Comment.Preproc, using(PythonLexer), Other)),
+             bygroups(Text.Whitespace, Comment.Preproc, using(PythonLexer), Other)),
             (r'(\s*)(##[^\n]*)(\n|\Z)',
-             bygroups(Text, Comment.Preproc, Other)),
-            (r'(?s)<%doc>.*?</%doc>', Comment.Preproc),
+             bygroups(Text.Whitespace, Comment.Single, Text.Whitespace)),
+            (r'(?s)<%doc>.*?</%doc>', Comment.Multiline),
             (r'(<%)([\w.:]+)',
              bygroups(Comment.Preproc, Name.Builtin), 'tag'),
             (r'(</%)([\w.:]+)(>)',
@@ -679,7 +679,7 @@ class MakoJavascriptLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Mako'
-    aliases = ['js+mako', 'javascript+mako']
+    aliases = ['javascript+mako', 'js+mako']
     mimetypes = ['application/x-javascript+mako',
                  'text/x-javascript+mako',
                  'text/javascript+mako']
@@ -798,8 +798,8 @@ class CheetahJavascriptLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Cheetah'
-    aliases = ['js+cheetah', 'javascript+cheetah',
-               'js+spitfire', 'javascript+spitfire']
+    aliases = ['javascript+cheetah', 'js+cheetah',
+               'javascript+spitfire', 'js+spitfire']
     mimetypes = ['application/x-javascript+cheetah',
                  'text/x-javascript+cheetah',
                  'text/javascript+cheetah',
@@ -1026,7 +1026,7 @@ class XmlErbLexer(DelegatingLexer):
     """
 
     name = 'XML+Ruby'
-    aliases = ['xml+erb', 'xml+ruby']
+    aliases = ['xml+ruby', 'xml+erb']
     alias_filenames = ['*.xml']
     mimetypes = ['application/xml+ruby']
 
@@ -1046,7 +1046,7 @@ class CssErbLexer(DelegatingLexer):
     """
 
     name = 'CSS+Ruby'
-    aliases = ['css+erb', 'css+ruby']
+    aliases = ['css+ruby', 'css+erb']
     alias_filenames = ['*.css']
     mimetypes = ['text/css+ruby']
 
@@ -1064,7 +1064,7 @@ class JavascriptErbLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Ruby'
-    aliases = ['js+erb', 'javascript+erb', 'js+ruby', 'javascript+ruby']
+    aliases = ['javascript+ruby', 'js+ruby', 'javascript+erb', 'js+erb']
     alias_filenames = ['*.js']
     mimetypes = ['application/x-javascript+ruby',
                  'text/x-javascript+ruby',
@@ -1147,7 +1147,7 @@ class JavascriptPhpLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+PHP'
-    aliases = ['js+php', 'javascript+php']
+    aliases = ['javascript+php', 'js+php']
     alias_filenames = ['*.js']
     mimetypes = ['application/x-javascript+php',
                  'text/x-javascript+php',
@@ -1229,7 +1229,7 @@ class JavascriptSmartyLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Smarty'
-    aliases = ['js+smarty', 'javascript+smarty']
+    aliases = ['javascript+smarty', 'js+smarty']
     alias_filenames = ['*.js', '*.tpl']
     mimetypes = ['application/x-javascript+smarty',
                  'text/x-javascript+smarty',
@@ -1311,8 +1311,8 @@ class JavascriptDjangoLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Django/Jinja'
-    aliases = ['js+django', 'javascript+django',
-               'js+jinja', 'javascript+jinja']
+    aliases = ['javascript+django', 'js+django',
+               'javascript+jinja', 'js+jinja']
     alias_filenames = ['*.js']
     mimetypes = ['application/x-javascript+django',
                  'application/x-javascript+jinja',
@@ -1750,7 +1750,7 @@ class LassoJavascriptLexer(DelegatingLexer):
     """
 
     name = 'JavaScript+Lasso'
-    aliases = ['js+lasso', 'javascript+lasso']
+    aliases = ['javascript+lasso', 'js+lasso']
     alias_filenames = ['*.js']
     mimetypes = ['application/x-javascript+lasso',
                  'text/x-javascript+lasso',

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

@@ -24,7 +24,7 @@ class TeraTermLexer(RegexLexer):
     .. versionadded:: 2.4
     """
     name = 'Tera Term macro'
-    aliases = ['ttl', 'teraterm', 'teratermmacro']
+    aliases = ['teratermmacro', 'teraterm', 'ttl']
     filenames = ['*.ttl']
     mimetypes = ['text/x-teratermmacro']
 

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

@@ -21,7 +21,7 @@ class GherkinLexer(RegexLexer):
     .. versionadded:: 1.2
     """
     name = 'Gherkin'
-    aliases = ['cucumber', 'gherkin']
+    aliases = ['gherkin', 'cucumber']
     filenames = ['*.feature']
     mimetypes = ['text/x-gherkin']
 

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

@@ -43,6 +43,7 @@ class CoqLexer(RegexLexer):
         'Canonical', 'Coercion', 'Theorem', 'Lemma', 'Corollary',
         'Proposition', 'Fact', 'Remark', 'Example', 'Proof', 'Goal', 'Save',
         'Qed', 'Defined', 'Hint', 'Resolve', 'Rewrite', 'View', 'Search',
+        'Abort', 'Admitted',
         'Show', 'Print', 'Printing', 'All', 'Graph', 'Projections', 'inside',
         'outside', 'Check', 'Global', 'Instance', 'Class', 'Existing',
         'Universe', 'Polymorphic', 'Monomorphic', 'Context'
@@ -55,7 +56,7 @@ class CoqLexer(RegexLexer):
     )
     keywords3 = (
         # Sorts
-        'Type', 'Prop',
+        'Type', 'Prop', 'SProp',
     )
     keywords4 = (
         # Tactics
@@ -94,7 +95,8 @@ class CoqLexer(RegexLexer):
         '<->', '=', '>', '>]', r'>\}', r'\?', r'\?\?', r'\[', r'\[<', r'\[>',
         r'\[\|', ']', '_', '`', r'\{', r'\{<', r'\|', r'\|]', r'\}', '~', '=>',
         r'/\\', r'\\/', r'\{\|', r'\|\}',
-        'Π', 'λ',
+        # 'Π', 'Σ', # Not defined in the standard library
+        'λ', '¬', '∧', '∨', '∀', '∃', '→', '↔', '≠', '≤', '≥',
     )
     operators = r'[!$%&*+\./:<=>?@^|~-]'
     prefix_syms = r'[!?~]'

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

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.thingsdb
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the ThingsDB language.
+
+    :copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+from pygments.lexer import RegexLexer, include, bygroups
+from pygments.token import Comment, Keyword, Name, Number, String, Text, \
+    Operator, Punctuation, Whitespace
+
+__all__ = ['ThingsDBLexer']
+
+
+class ThingsDBLexer(RegexLexer):
+    """
+    Lexer for the ThingsDB programming language.
+
+    .. versionadded:: 2.9
+    """
+    name = 'ThingsDB'
+    aliases = ['ti', 'thingsdb']
+    filenames = ['*.ti']
+
+    tokens = {
+        'root': [
+            include('expression'),
+        ],
+        'expression': [
+            include('comments'),
+            include('whitespace'),
+
+            # numbers
+            (r'[-+]?0b[01]+', Number.Bin),
+            (r'[-+]?0o[0-8]+', Number.Oct),
+            (r'([-+]?0x[0-9a-fA-F]+)', Number.Hex),
+            (r'[-+]?[0-9]+', Number.Integer),
+            (r'[-+]?((inf|nan)([^0-9A-Za-z_]|$)|[0-9]*\.[0-9]+(e[+-][0-9]+)?)',
+            Number.Float),
+
+            # strings
+            (r'(?:"(?:[^"]*)")+', String.Double),
+            (r"(?:'(?:[^']*)')+", String.Single),
+
+            # literals
+            (r'(true|false|nil)\b', Keyword.Constant),
+
+            # regular expressions
+            (r'(/[^/\\]*(?:\\.[^/\\]*)*/i?)', String.Regex),
+
+            # thing id's
+            (r'#[0-9]+', Comment.Preproc),
+
+            # name, assignments and functions
+            include('names'),
+
+            (r'[(){}\[\],;]', Punctuation),
+            (r'[+\-*/%&|<>^!~@=:?]', Operator),
+        ],
+        'names': [
+            (r'(\.)'
+             r'(add|call|contains|del|endswith|extend|filter|find|findindex|'
+             r'get|has|id|indexof|keys|len|lower|map|pop|push|remove|set|sort|'
+             r'splice|startswith|test|unwrap|upper|values|wrap)'
+             r'(\()',
+             bygroups(Name.Function, Name.Function, Punctuation), 'arguments'),
+            (r'(array|assert|assert_err|auth_err|backup_info|backups_info|'
+             r'bad_data_err|bool|closure|collection_info|collections_info|'
+             r'counters|deep|del_backup|del_collection|del_expired|del_node|'
+             r'del_procedure|del_token|del_type|del_user|err|float|'
+             r'forbidden_err|grant|int|isarray|isascii|isbool|isbytes|iserr|'
+             r'isfloat|isinf|isint|islist|isnan|isnil|israw|isset|isstr|'
+             r'isthing|istuple|isutf8|lookup_err|max_quota_err|mod_type|new|'
+             r'new_backup|new_collection|new_node|new_procedure|new_token|'
+             r'new_type|new_user|node_err|node_info|nodes_info|now|'
+             r'num_arguments_err|operation_err|overflow_err|procedure_doc|'
+             r'procedure_info|procedures_info|raise|refs|rename_collection|'
+             r'rename_user|reset_counters|return|revoke|run|set_log_level|set|'
+             r'set_quota|set_type|shutdown|str|syntax_err|thing|try|type|'
+             r'type_err|type_count|type_info|types_info|user_info|users_info|'
+             r'value_err|wse|zero_div_err)'
+             r'(\()',
+             bygroups(Name.Function, Punctuation),
+             'arguments'),
+            (r'(\.[A-Za-z_][0-9A-Za-z_]*)'
+             r'(\s*)(=)',
+             bygroups(Name.Attribute, Text, Operator)),
+            (r'\.[A-Za-z_][0-9A-Za-z_]*', Name.Attribute),
+            (r'([A-Za-z_][0-9A-Za-z_]*)(\s*)(=)',
+            bygroups(Name.Variable, Text, Operator)),
+            (r'[A-Za-z_][0-9A-Za-z_]*', Name.Variable),
+        ],
+        'whitespace': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+        ],
+        'comments': [
+            (r'//(.*?)\n', Comment.Single),
+            (r'/\*', Comment.Multiline, 'comment'),
+        ],
+        'comment': [
+            (r'[^*/]+', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline),
+        ],
+        'arguments': [
+            include('expression'),
+            (',', Punctuation),
+            (r'\(', Punctuation, '#push'),
+            (r'\)', Punctuation, '#pop'),
+        ],
+    }

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

@@ -12,7 +12,7 @@ import re
 
 from pygments.lexer import Lexer
 from pygments.token import Text, Comment, Operator, Keyword, Name, Number, \
-     Punctuation, Error
+    Punctuation, Error
 
 __all__ = ['TNTLexer']
 
@@ -66,15 +66,16 @@ class TNTLexer(Lexer):
                 end += 1
         except IndexError:
             end = len(text)
-        if required:
-            assert end != start
+        if required and end == start:
+            raise AssertionError
         if end != start:
             self.cur.append((start, Text, text[start:end]))
         return end
 
     def variable(self, start, text):
         """Tokenize a variable."""
-        assert text[start] in self.VARIABLES
+        if text[start] not in self.VARIABLES:
+            raise AssertionError
         end = start+1
         while text[end] in self.PRIMES:
             end += 1
@@ -97,10 +98,12 @@ class TNTLexer(Lexer):
         if text[start] == '(':  # (...+...)
             self.cur.append((start, Punctuation, text[start]))
             start = self.term(start+1, text)
-            assert text[start] in self.OPERATORS
+            if text[start] not in self.OPERATORS:
+                raise AssertionError
             self.cur.append((start, Operator, text[start]))
             start = self.term(start+1, text)
-            assert text[start] == ')'
+            if text[start] != ')':
+                raise AssertionError
             self.cur.append((start, Punctuation, text[start]))
             return start+1
         raise AssertionError  # no matches
@@ -116,21 +119,25 @@ class TNTLexer(Lexer):
         if text[start] in self.QUANTIFIERS:  # Aa:<...>
             self.cur.append((start, Keyword.Declaration, text[start]))
             start = self.variable(start+1, text)
-            assert text[start] == ':'
+            if text[start] != ':':
+                raise AssertionError
             self.cur.append((start, Punctuation, text[start]))
             return self.formula(start+1, text)
         if text[start] == '<':  # <...&...>
             self.cur.append((start, Punctuation, text[start]))
             start = self.formula(start+1, text)
-            assert text[start] in self.LOGIC
+            if text[start] not in self.LOGIC:
+                raise AssertionError
             self.cur.append((start, Operator, text[start]))
             start = self.formula(start+1, text)
-            assert text[start] == '>'
+            if text[start] != '>':
+                raise AssertionError
             self.cur.append((start, Punctuation, text[start]))
             return start+1
         # ...=...
         start = self.term(start, text)
-        assert text[start] == '='
+        if text[start] != '=':
+            raise AssertionError
         self.cur.append((start, Operator, text[start]))
         start = self.term(start+1, text)
         return start
@@ -138,7 +145,8 @@ class TNTLexer(Lexer):
     def rule(self, start, text):
         """Tokenize a rule."""
         match = self.RULES.match(text, start)
-        assert match is not None
+        if match is None:
+            raise AssertionError
         groups = sorted(match.regs[1:])  # exclude whole match
         for group in groups:
             if group[0] >= 0:  # this group matched
@@ -162,8 +170,10 @@ class TNTLexer(Lexer):
         self.cur.append((start+1, Text, text[start+1:end]))
         start = end
         match = self.LINENOS.match(text, start)
-        assert match is not None
-        assert text[match.end()] == ')'
+        if match is None:
+            raise AssertionError
+        if text[match.end()] != ')':
+            raise AssertionError
         self.cur.append((match.start(), Number.Integer, match.group(0)))
         self.cur.append((match.end(), Punctuation, text[match.end()]))
         return match.end() + 1
@@ -219,7 +229,7 @@ class TNTLexer(Lexer):
                     orig = len(self.cur)
                     try:
                         start = end = self.formula(start, text)
-                    except AssertionError:  # not well-formed
+                    except (AssertionError, RecursionError):  # not well-formed
                         del self.cur[orig:]
                         while text[end] not in self.WHITESPACE:
                             end += 1
@@ -257,6 +267,6 @@ class TNTLexer(Lexer):
                 try:
                     del self.cur[orig:]
                 except NameError:
-                    pass # if orig was never defined, fine
+                    pass  # if orig was never defined, fine
                 self.error_till_line_end(start, text)
         return self.cur

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

@@ -23,7 +23,7 @@ class RtsLexer(RegexLexer):
     .. versionadded:: 2.1
     """
     name = 'TrafficScript'
-    aliases = ['rts','trafficscript']
+    aliases = ['trafficscript', 'rts']
     filenames = ['*.rts']
 
     tokens = {

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

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.webassembly
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the WebAssembly text format.
+
+    The grammar can be found at https://github.com/WebAssembly/spec/blob/master/interpreter/README.md
+    and https://webassembly.github.io/spec/core/text/.
+
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words, bygroups, default
+from pygments.token import Text, Comment, Operator, Keyword, String, Number, Punctuation, Literal, Error, Name
+
+__all__ = ['WatLexer']
+
+keywords = (
+    'module', 'import', 'func', 'funcref', 'start', 'param', 'local', 'type',
+    'result', 'export', 'memory', 'global', 'mut', 'data', 'table', 'elem',
+    'if', 'then', 'else', 'end', 'block', 'loop'
+)
+
+builtins = (
+    'unreachable', 'nop', 'block', 'loop', 'if', 'else', 'end', 'br', 'br_if',
+    'br_table', 'return', 'call', 'call_indirect', 'drop', 'select',
+    'local.get', 'local.set', 'local.tee', 'global.get', 'global.set',
+    'i32.load', 'i64.load', 'f32.load', 'f64.load', 'i32.load8_s',
+    'i32.load8_u', 'i32.load16_s', 'i32.load16_u', 'i64.load8_s',
+    'i64.load8_u', 'i64.load16_s', 'i64.load16_u', 'i64.load32_s',
+    'i64.load32_u', 'i32.store', 'i64.store', 'f32.store', 'f64.store',
+    'i32.store8', 'i32.store16', 'i64.store8', 'i64.store16', 'i64.store32',
+    'memory.size', 'memory.grow', 'i32.const', 'i64.const', 'f32.const',
+    'f64.const', 'i32.eqz', 'i32.eq', 'i32.ne', 'i32.lt_s', 'i32.lt_u',
+    'i32.gt_s', 'i32.gt_u', 'i32.le_s', 'i32.le_u', 'i32.ge_s', 'i32.ge_u',
+    'i64.eqz', 'i64.eq', 'i64.ne', 'i64.lt_s', 'i64.lt_u', 'i64.gt_s',
+    'i64.gt_u', 'i64.le_s', 'i64.le_u', 'i64.ge_s', 'i64.ge_u', 'f32.eq',
+    'f32.ne', 'f32.lt', 'f32.gt', 'f32.le', 'f32.ge', 'f64.eq', 'f64.ne',
+    'f64.lt', 'f64.gt', 'f64.le', 'f64.ge', 'i32.clz', 'i32.ctz', 'i32.popcnt',
+    'i32.add', 'i32.sub', 'i32.mul', 'i32.div_s', 'i32.div_u', 'i32.rem_s',
+    'i32.rem_u', 'i32.and', 'i32.or', 'i32.xor', 'i32.shl', 'i32.shr_s',
+    'i32.shr_u', 'i32.rotl', 'i32.rotr', 'i64.clz', 'i64.ctz', 'i64.popcnt',
+    'i64.add', 'i64.sub', 'i64.mul', 'i64.div_s', 'i64.div_u', 'i64.rem_s',
+    'i64.rem_u', 'i64.and', 'i64.or', 'i64.xor', 'i64.shl', 'i64.shr_s',
+    'i64.shr_u', 'i64.rotl', 'i64.rotr', 'f32.abs', 'f32.neg', 'f32.ceil',
+    'f32.floor', 'f32.trunc', 'f32.nearest', 'f32.sqrt', 'f32.add', 'f32.sub',
+    'f32.mul', 'f32.div', 'f32.min', 'f32.max', 'f32.copysign', 'f64.abs',
+    'f64.neg', 'f64.ceil', 'f64.floor', 'f64.trunc', 'f64.nearest', 'f64.sqrt',
+    'f64.add', 'f64.sub', 'f64.mul', 'f64.div', 'f64.min', 'f64.max',
+    'f64.copysign', 'i32.wrap_i64', 'i32.trunc_f32_s', 'i32.trunc_f32_u',
+    'i32.trunc_f64_s', 'i32.trunc_f64_u', 'i64.extend_i32_s',
+    'i64.extend_i32_u', 'i64.trunc_f32_s', 'i64.trunc_f32_u',
+    'i64.trunc_f64_s', 'i64.trunc_f64_u', 'f32.convert_i32_s',
+    'f32.convert_i32_u', 'f32.convert_i64_s', 'f32.convert_i64_u',
+    'f32.demote_f64', 'f64.convert_i32_s', 'f64.convert_i32_u',
+    'f64.convert_i64_s', 'f64.convert_i64_u', 'f64.promote_f32',
+    'i32.reinterpret_f32', 'i64.reinterpret_f64', 'f32.reinterpret_i32',
+    'f64.reinterpret_i64',
+)
+
+
+class WatLexer(RegexLexer):
+    """Lexer for the `WebAssembly text format <https://webassembly.org/>`_.
+
+    .. versionadded:: 2.9
+    """
+
+    name = 'WebAssembly'
+    aliases = ['wast', 'wat']
+    filenames = ['*.wat', '*.wast']
+
+    tokens = {
+        'root': [
+            (words(keywords, suffix=r'(?=[^a-z_\.])'), Keyword),
+            (words(builtins), Name.Builtin, 'arguments'),
+            (words(['i32', 'i64', 'f32', 'f64']), Keyword.Type),
+            (r'\$[A-Za-z0-9!#$%&\'*+./:<=>?@\\^_`|~-]+', Name.Variable), # yes, all of the are valid in identifiers
+            (r';;.*?$', Comment.Single),
+            (r'\(;', Comment.Multiline, 'nesting_comment'),
+            (r'[+-]?0x[\dA-Fa-f](_?[\dA-Fa-f])*(.([\dA-Fa-f](_?[\dA-Fa-f])*)?)?([pP][+-]?[\dA-Fa-f](_?[\dA-Fa-f])*)?', Number.Float),
+            (r'[+-]?\d.\d(_?\d)*[eE][+-]?\d(_?\d)*', Number.Float),
+            (r'[+-]?\d.\d(_?\d)*', Number.Float),
+            (r'[+-]?\d.[eE][+-]?\d(_?\d)*', Number.Float),
+            (r'[+-]?(inf|nan:0x[\dA-Fa-f](_?[\dA-Fa-f])*|nan)', Number.Float),
+            (r'[+-]?0x[\dA-Fa-f](_?[\dA-Fa-f])*', Number.Hex),
+            (r'[+-]?\d(_?\d)*', Number.Integer),
+            (r'[\(\)]', Punctuation),
+            (r'"', String.Double, 'string'),
+            (r'\s+', Text),
+        ],
+        'nesting_comment': [
+            (r'\(;', Comment.Multiline, '#push'),
+            (r';\)', Comment.Multiline, '#pop'),
+            (r'[^;(]+', Comment.Multiline),
+            (r'[;(]', Comment.Multiline),
+        ],
+        'string': [
+            (r'\\[\dA-Fa-f][\dA-Fa-f]', String.Escape), # must have exactly two hex digits
+            (r'\\t', String.Escape),
+            (r'\\n', String.Escape),
+            (r'\\r', String.Escape),
+            (r'\\"', String.Escape),
+            (r"\\'", String.Escape),
+            (r'\\u\{[\dA-Fa-f](_?[\dA-Fa-f])*\}', String.Escape),
+            (r'\\\\', String.Escape),
+            (r'"', String.Double, '#pop'),
+            (r'[^"\\]+', String.Double),
+        ],
+        'arguments': [
+            (r'\s+', Text),
+            (r'(offset)(=)(0x[\dA-Fa-f](_?[\dA-Fa-f])*)', bygroups(Keyword, Operator, Number.Hex)),
+            (r'(offset)(=)(\d(_?\d)*)', bygroups(Keyword, Operator, Number.Integer)),
+            (r'(align)(=)(0x[\dA-Fa-f](_?[\dA-Fa-f])*)', bygroups(Keyword, Operator, Number.Hex)),
+            (r'(align)(=)(\d(_?\d)*)', bygroups(Keyword, Operator, Number.Integer)),
+            default('#pop'),
+        ]
+    }

data/vendor/pygments-main/pygments/regexopt.py

@@ -15,7 +15,7 @@ from os.path import commonprefix
 from itertools import groupby
 from operator import itemgetter
 
-CS_ESCAPE = re.compile(r'[\^\\\-\]]')
+CS_ESCAPE = re.compile(r'[\[\^\\\-\]]')
 FIRST_ELEMENT = itemgetter(0)
 
 

data/vendor/pygments-main/pygments/style.py

@@ -134,7 +134,7 @@ class StyleMeta(type):
             color = _ansimap[color]
         bgcolor = t[4]
         if bgcolor in _deprecated_ansicolors:
-            bgcolor = _deprecated_ansicolors[color]
+            bgcolor = _deprecated_ansicolors[bgcolor]
         if bgcolor in ansicolors:
             bgansicolor = bgcolor
             bgcolor = _ansimap[bgcolor]

data/vendor/pygments-main/pygments/styles/__init__.py

@@ -52,6 +52,8 @@ STYLE_MAP = {
     'stata-dark':  'stata_dark::StataDarkStyle',
     'inkpot':      'inkpot::InkPotStyle',
     'zenburn': 'zenburn::ZenburnStyle',
+    'gruvbox-dark': 'gruvbox::GruvboxDarkStyle',
+    'gruvbox-light': 'gruvbox::GruvboxLightStyle',
 }
 
 

data/vendor/pygments-main/pygments/styles/friendly.py

@@ -20,6 +20,7 @@ class FriendlyStyle(Style):
 
     background_color = "#f0f0f0"
     default_style = ""
+    line_number_color = "#666666"
 
     styles = {
         Whitespace:                "#bbbbbb",