pygments.rb 1.2.1 → 2.0.0

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

@@ -5,7 +5,7 @@
 
     Lexer for Robot Framework.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -27,7 +27,6 @@ import re
 
 from pygments.lexer import Lexer
 from pygments.token import Token
-from pygments.util import text_type
 
 __all__ = ['RobotFrameworkLexer']
 
@@ -64,7 +63,7 @@ class RobotFrameworkLexer(Lexer):
     """
     name = 'RobotFramework'
     aliases = ['robotframework']
-    filenames = ['*.txt', '*.robot']
+    filenames = ['*.robot']
     mimetypes = ['text/x-robotframework']
 
     def __init__(self, **options):
@@ -80,11 +79,11 @@ class RobotFrameworkLexer(Lexer):
             for value, token in row_tokenizer.tokenize(row):
                 for value, token in var_tokenizer.tokenize(value, token):
                     if value:
-                        yield index, token, text_type(value)
+                        yield index, token, str(value)
                         index += len(value)
 
 
-class VariableTokenizer(object):
+class VariableTokenizer:
 
     def tokenize(self, string, token):
         var = VariableSplitter(string, identifiers='$@%&')
@@ -99,19 +98,16 @@ class VariableTokenizer(object):
         before = string[:var.start]
         yield before, orig_token
         yield var.identifier + '{', SYNTAX
-        for value, token in self.tokenize(var.base, VARIABLE):
-            yield value, token
+        yield from self.tokenize(var.base, VARIABLE)
         yield '}', SYNTAX
         if var.index:
             yield '[', SYNTAX
-            for value, token in self.tokenize(var.index, VARIABLE):
-                yield value, token
+            yield from self.tokenize(var.index, VARIABLE)
             yield ']', SYNTAX
-        for value, token in self.tokenize(string[var.end:], orig_token):
-            yield value, token
+        yield from self.tokenize(string[var.end:], orig_token)
 
 
-class RowTokenizer(object):
+class RowTokenizer:
 
     def __init__(self):
         self._table = UnknownTable()
@@ -124,6 +120,7 @@ class RowTokenizer(object):
                         'metadata': settings,
                         'variables': variables, 'variable': variables,
                         'testcases': testcases, 'testcase': testcases,
+                        'tasks': testcases, 'task': testcases,
                         'keywords': keywords, 'keyword': keywords,
                         'userkeywords': keywords, 'userkeyword': keywords}
 
@@ -138,9 +135,8 @@ class RowTokenizer(object):
             elif index == 0 and value.startswith('*'):
                 self._table = self._start_table(value)
                 heading = True
-            for value, token in self._tokenize(value, index, commented,
-                                               separator, heading):
-                yield value, token
+            yield from self._tokenize(value, index, commented,
+                                      separator, heading)
         self._table.end_row()
 
     def _start_table(self, header):
@@ -155,25 +151,22 @@ class RowTokenizer(object):
         elif heading:
             yield value, HEADING
         else:
-            for value, token in self._table.tokenize(value, index):
-                yield value, token
+            yield from self._table.tokenize(value, index)
 
 
-class RowSplitter(object):
+class RowSplitter:
     _space_splitter = re.compile('( {2,})')
-    _pipe_splitter = re.compile('((?:^| +)\|(?: +|$))')
+    _pipe_splitter = re.compile(r'((?:^| +)\|(?: +|$))')
 
     def split(self, row):
         splitter = (row.startswith('| ') and self._split_from_pipes
                     or self._split_from_spaces)
-        for value in splitter(row):
-            yield value
+        yield from splitter(row)
         yield '\n'
 
     def _split_from_spaces(self, row):
         yield ''  # Start with (pseudo)separator similarly as with pipes
-        for value in self._space_splitter.split(row):
-            yield value
+        yield from self._space_splitter.split(row)
 
     def _split_from_pipes(self, row):
         _, separator, rest = self._pipe_splitter.split(row, 1)
@@ -185,7 +178,7 @@ class RowSplitter(object):
         yield rest
 
 
-class Tokenizer(object):
+class Tokenizer:
     _tokens = None
 
     def __init__(self):
@@ -216,11 +209,11 @@ class Comment(Tokenizer):
 class Setting(Tokenizer):
     _tokens = (SETTING, ARGUMENT)
     _keyword_settings = ('suitesetup', 'suiteprecondition', 'suiteteardown',
-                         'suitepostcondition', 'testsetup', 'testprecondition',
-                         'testteardown', 'testpostcondition', 'testtemplate')
+                         'suitepostcondition', 'testsetup', 'tasksetup', 'testprecondition',
+                         'testteardown','taskteardown', 'testpostcondition', 'testtemplate', 'tasktemplate')
     _import_settings = ('library', 'resource', 'variables')
     _other_settings = ('documentation', 'metadata', 'forcetags', 'defaulttags',
-                       'testtimeout')
+                       'testtimeout','tasktimeout')
     _custom_tokenizer = None
 
     def __init__(self, template_setter=None):
@@ -292,7 +285,7 @@ class KeywordCall(Tokenizer):
         return GherkinTokenizer().tokenize(value, KEYWORD)
 
 
-class GherkinTokenizer(object):
+class GherkinTokenizer:
     _gherkin_prefix = re.compile('^(Given|When|Then|And) ', re.IGNORECASE)
 
     def tokenize(self, value, token):
@@ -320,7 +313,7 @@ class ForLoop(Tokenizer):
         return token
 
 
-class _Table(object):
+class _Table:
     _tokenizer_class = None
 
     def __init__(self, prev_tokenizer=None):
@@ -333,8 +326,7 @@ class _Table(object):
             self._tokenizer = self._prev_tokenizer
             yield value, SYNTAX
         else:
-            for value_and_token in self._tokenize(value, index):
-                yield value_and_token
+            yield from self._tokenize(value, index)
         self._prev_values_on_row.append(value)
 
     def _continues(self, value, index):

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

@@ -5,7 +5,7 @@
 
     Lexers for Ruby and related languages.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -43,23 +43,22 @@ class RubyLexer(ExtendedRegexLexer):
 
     def heredoc_callback(self, match, ctx):
         # okay, this is the hardest part of parsing Ruby...
-        # match: 1 = <<-?, 2 = quote? 3 = name 4 = quote? 5 = rest of line
+        # match: 1 = <<[-~]?, 2 = quote? 3 = name 4 = quote? 5 = rest of line
 
         start = match.start(1)
-        yield start, Operator, match.group(1)        # <<-?
+        yield start, Operator, match.group(1)        # <<[-~]?
         yield match.start(2), String.Heredoc, match.group(2)   # quote ", ', `
         yield match.start(3), String.Delimiter, match.group(3) # heredoc name
         yield match.start(4), String.Heredoc, match.group(4)   # quote again
 
         heredocstack = ctx.__dict__.setdefault('heredocstack', [])
         outermost = not bool(heredocstack)
-        heredocstack.append((match.group(1) == '<<-', match.group(3)))
+        heredocstack.append((match.group(1) in ('<<-', '<<~'), match.group(3)))
 
         ctx.pos = match.start(5)
         ctx.end = match.end(5)
         # this may find other heredocs
-        for i, t, v in self.get_tokens_unprocessed(context=ctx):
-            yield i, t, v
+        yield from self.get_tokens_unprocessed(context=ctx)
         ctx.pos = match.end()
 
         if outermost:
@@ -109,16 +108,17 @@ class RubyLexer(ExtendedRegexLexer):
             (r'\:@{0,2}[a-zA-Z_]\w*[!?]?', String.Symbol),
             (words(RUBY_OPERATORS, prefix=r'\:@{0,2}'), String.Symbol),
             (r":'(\\\\|\\'|[^'])*'", String.Symbol),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
             (r':"', String.Symbol, 'simple-sym'),
             (r'([a-zA-Z_]\w*)(:)(?!:)',
              bygroups(String.Symbol, Punctuation)),  # Since Ruby 1.9
-            (r'"', String.Double, 'simple-string'),
+            (r'"', String.Double, 'simple-string-double'),
+            (r"'", String.Single, 'simple-string-single'),
             (r'(?<!\.)`', String.Backtick, 'simple-backtick'),
         ]
 
-        # double-quoted string and symbol
-        for name, ttype, end in ('string', String.Double, '"'), \
+        # quoted string and symbol
+        for name, ttype, end in ('string-double', String.Double, '"'), \
+                                ('string-single', String.Single, "'"),\
                                 ('sym', String.Symbol, '"'), \
                                 ('backtick', String.Backtick, '`'):
             states['simple-'+name] = [
@@ -247,10 +247,10 @@ class RubyLexer(ExtendedRegexLexer):
              Name.Builtin),
             (r'__(FILE|LINE)__\b', Name.Builtin.Pseudo),
             # normal heredocs
-            (r'(?<!\w)(<<-?)(["`\']?)([a-zA-Z_]\w*)(\2)(.*?\n)',
+            (r'(?<!\w)(<<[-~]?)(["`\']?)([a-zA-Z_]\w*)(\2)(.*?\n)',
              heredoc_callback),
             # empty string heredocs
-            (r'(<<-?)("|\')()(\2)(.*?\n)', heredoc_callback),
+            (r'(<<[-~]?)("|\')()(\2)(.*?\n)', heredoc_callback),
             (r'__END__', Comment.Preproc, 'end-part'),
             # multiline regex (after keywords or assignments)
             (r'(?:^|(?<=[=<>~!:])|'
@@ -403,8 +403,8 @@ class RubyConsoleLexer(Lexer):
     aliases = ['rbcon', 'irb']
     mimetypes = ['text/x-ruby-shellsession']
 
-    _prompt_re = re.compile('irb\([a-zA-Z_]\w*\):\d{3}:\d+[>*"\'] '
-                            '|>> |\?> ')
+    _prompt_re = re.compile(r'irb\([a-zA-Z_]\w*\):\d{3}:\d+[>*"\'] '
+                            r'|>> |\?> ')
 
     def get_tokens_unprocessed(self, text):
         rblexer = RubyLexer(**self.options)
@@ -421,16 +421,14 @@ class RubyConsoleLexer(Lexer):
                 curcode += line[end:]
             else:
                 if curcode:
-                    for item in do_insertions(
-                            insertions, rblexer.get_tokens_unprocessed(curcode)):
-                        yield item
+                    yield from do_insertions(
+                        insertions, rblexer.get_tokens_unprocessed(curcode))
                     curcode = ''
                     insertions = []
                 yield match.start(), Generic.Output, line
         if curcode:
-            for item in do_insertions(
-                    insertions, rblexer.get_tokens_unprocessed(curcode)):
-                yield item
+            yield from do_insertions(
+                insertions, rblexer.get_tokens_unprocessed(curcode))
 
 
 class FancyLexer(RegexLexer):
@@ -498,11 +496,11 @@ class FancyLexer(RegexLexer):
             (r'[a-zA-Z](\w|[-+?!=*/^><%])*:', Name.Function),
             # operators, must be below functions
             (r'[-+*/~,<>=&!?%^\[\].$]+', Operator),
-            ('[A-Z]\w*', Name.Constant),
-            ('@[a-zA-Z_]\w*', Name.Variable.Instance),
-            ('@@[a-zA-Z_]\w*', Name.Variable.Class),
+            (r'[A-Z]\w*', Name.Constant),
+            (r'@[a-zA-Z_]\w*', Name.Variable.Instance),
+            (r'@@[a-zA-Z_]\w*', Name.Variable.Class),
             ('@@?', Operator),
-            ('[a-zA-Z_]\w*', Name),
+            (r'[a-zA-Z_]\w*', Name),
             # numbers - / checks are necessary to avoid mismarking regexes,
             # see comment in RubyLexer
             (r'(0[oO]?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?',

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

@@ -5,7 +5,7 @@
 
     Lexers for the Rust language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -18,48 +18,56 @@ __all__ = ['RustLexer']
 
 class RustLexer(RegexLexer):
     """
-    Lexer for the Rust programming language (version 1.10).
+    Lexer for the Rust programming language (version 1.47).
 
     .. versionadded:: 1.6
     """
     name = 'Rust'
     filenames = ['*.rs', '*.rs.in']
-    aliases = ['rust']
-    mimetypes = ['text/rust']
-
-    keyword_types = (
-        words(('u8', 'u16', 'u32', 'u64', 'i8', 'i16', 'i32', 'i64',
-               'usize', 'isize', 'f32', 'f64', 'str', 'bool'),
-              suffix=r'\b'),
-        Keyword.Type)
-
-    builtin_types = (words((
-        # Reexported core operators
-        'Copy', 'Send', 'Sized', 'Sync',
-        'Drop', 'Fn', 'FnMut', 'FnOnce',
-
-        # Reexported types and traits
-        'Box',
-        'ToOwned',
-        'Clone',
+    aliases = ['rust', 'rs']
+    mimetypes = ['text/rust', 'text/x-rust']
+
+    keyword_types = (words((
+        'u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128',
+        'usize', 'isize', 'f32', 'f64', 'char', 'str', 'bool',
+    ), suffix=r'\b'), Keyword.Type)
+
+    builtin_funcs_types = (words((
+        'Copy', 'Send', 'Sized', 'Sync', 'Unpin',
+        'Drop', 'Fn', 'FnMut', 'FnOnce', 'drop',
+        'Box', 'ToOwned', 'Clone',
         'PartialEq', 'PartialOrd', 'Eq', 'Ord',
-        'AsRef', 'AsMut', 'Into', 'From',
-        'Default',
-        'Iterator', 'Extend', 'IntoIterator',
-        'DoubleEndedIterator', 'ExactSizeIterator',
-        'Option',
-        'Some', 'None',
-        'Result',
-        'Ok', 'Err',
-        'SliceConcatExt',
-        'String', 'ToString',
-        'Vec'), suffix=r'\b'),
-        Name.Builtin)
+        'AsRef', 'AsMut', 'Into', 'From', 'Default',
+        'Iterator', 'Extend', 'IntoIterator', 'DoubleEndedIterator',
+        'ExactSizeIterator',
+        'Option', 'Some', 'None',
+        'Result', 'Ok', 'Err',
+        'String', 'ToString', 'Vec',
+    ), suffix=r'\b'), Name.Builtin)
+
+    builtin_macros = (words((
+        'asm', 'assert', 'assert_eq', 'assert_ne', 'cfg', 'column',
+        'compile_error', 'concat', 'concat_idents', 'dbg', 'debug_assert',
+        'debug_assert_eq', 'debug_assert_ne', 'env', 'eprint', 'eprintln',
+        'file', 'format', 'format_args', 'format_args_nl', 'global_asm',
+        'include', 'include_bytes', 'include_str',
+        'is_aarch64_feature_detected',
+        'is_arm_feature_detected',
+        'is_mips64_feature_detected',
+        'is_mips_feature_detected',
+        'is_powerpc64_feature_detected',
+        'is_powerpc_feature_detected',
+        'is_x86_feature_detected',
+        'line', 'llvm_asm', 'log_syntax', 'macro_rules', 'matches',
+        'module_path', 'option_env', 'panic', 'print', 'println', 'stringify',
+        'thread_local', 'todo', 'trace_macros', 'unimplemented', 'unreachable',
+        'vec', 'write', 'writeln',
+    ), suffix=r'!'), Name.Function.Magic)
 
     tokens = {
         'root': [
             # rust allows a file to start with a shebang, but if the first line
-            # starts with #![ then it’s not a shebang but a crate attribute.
+            # starts with #![ then it's not a shebang but a crate attribute.
             (r'#![^[\r\n].*$', Comment.Preproc),
             default('base'),
         ],
@@ -77,26 +85,26 @@ class RustLexer(RegexLexer):
             # Macro parameters
             (r"""\$([a-zA-Z_]\w*|\(,?|\),?|,?)""", Comment.Preproc),
             # Keywords
-            (words((
-                'as', 'box', 'const', 'crate', 'else', 'extern',
-                'for', 'if', 'impl', 'in', 'loop', 'match', 'move',
-                'mut', 'pub', 'ref', 'return', 'static', 'super',
-                'trait', 'unsafe', 'use', 'where', 'while'), suffix=r'\b'),
-             Keyword),
-            (words(('abstract', 'alignof', 'become', 'do', 'final', 'macro',
-                    'offsetof', 'override', 'priv', 'proc', 'pure', 'sizeof',
-                    'typeof', 'unsized', 'virtual', 'yield'), suffix=r'\b'),
-             Keyword.Reserved),
+            (words(('as', 'async', 'await', 'box', 'const', 'crate', 'dyn',
+                    'else', 'extern', 'for', 'if', 'impl', 'in', 'loop',
+                    'match', 'move', 'mut', 'pub', 'ref', 'return', 'static',
+                    'super', 'trait', 'unsafe', 'use', 'where', 'while'),
+                   suffix=r'\b'), Keyword),
+            (words(('abstract', 'become', 'do', 'final', 'macro', 'override',
+                    'priv', 'typeof', 'try', 'unsized', 'virtual', 'yield'),
+                   suffix=r'\b'), Keyword.Reserved),
             (r'(true|false)\b', Keyword.Constant),
+            (r'self\b', Name.Builtin.Pseudo),
             (r'mod\b', Keyword, 'modname'),
             (r'let\b', Keyword.Declaration),
             (r'fn\b', Keyword, 'funcname'),
             (r'(struct|enum|type|union)\b', Keyword, 'typename'),
             (r'(default)(\s+)(type|fn)\b', bygroups(Keyword, Text, Keyword)),
             keyword_types,
-            (r'self\b', Name.Builtin.Pseudo),
-            # Prelude (taken from Rust’s src/libstd/prelude.rs)
-            builtin_types,
+            (r'[sS]elf\b', Name.Builtin.Pseudo),
+            # Prelude (taken from Rust's src/libstd/prelude.rs)
+            builtin_funcs_types,
+            builtin_macros,
             # Path seperators, so types don't catch them.
             (r'::\b', Text),
             # Types in positions.
@@ -104,49 +112,47 @@ class RustLexer(RegexLexer):
             # Labels
             (r'(break|continue)(\s*)(\'[A-Za-z_]\w*)?',
              bygroups(Keyword, Text.Whitespace, Name.Label)),
-            # Character Literal
+
+            # Character literals
             (r"""'(\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0"""
              r"""|\\u\{[0-9a-fA-F]{1,6}\}|.)'""",
              String.Char),
             (r"""b'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\0"""
              r"""|\\u\{[0-9a-fA-F]{1,6}\}|.)'""",
              String.Char),
-            # Binary Literal
+
+            # Binary literals
             (r'0b[01_]+', Number.Bin, 'number_lit'),
-            # Octal Literal
+            # Octal literals
             (r'0o[0-7_]+', Number.Oct, 'number_lit'),
-            # Hexadecimal Literal
+            # Hexadecimal literals
             (r'0[xX][0-9a-fA-F_]+', Number.Hex, 'number_lit'),
-            # Decimal Literal
+            # Decimal literals
             (r'[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|'
              r'\.[0-9_]*(?!\.)|[eE][+\-]?[0-9_]+)', Number.Float,
              'number_lit'),
             (r'[0-9][0-9_]*', Number.Integer, 'number_lit'),
-            # String Literal
+
+            # String literals
             (r'b"', String, 'bytestring'),
             (r'"', String, 'string'),
             (r'b?r(#*)".*?"\1', String),
 
-            # Lifetime
-            (r"""'static""", Name.Builtin),
-            (r"""'[a-zA-Z_]\w*""", Name.Attribute),
+            # Lifetime names
+            (r"'", Operator, 'lifetime'),
 
             # Operators and Punctuation
+            (r'\.\.=?', Operator),
             (r'[{}()\[\],.;]', Punctuation),
             (r'[+\-*/%&|<>^!~@=:?]', Operator),
 
-            # Identifier
+            # Identifiers
             (r'[a-zA-Z_]\w*', Name),
+            # Raw identifiers
+            (r'r#[a-zA-Z_]\w*', Name),
 
             # Attributes
             (r'#!?\[', Comment.Preproc, 'attribute['),
-            # Macros
-            (r'([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\s*)(\{)',
-             bygroups(Comment.Preproc, Punctuation, Whitespace, Name,
-                      Whitespace, Punctuation), 'macro{'),
-            (r'([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\()',
-             bygroups(Comment.Preproc, Punctuation, Whitespace, Name,
-                      Punctuation), 'macro('),
         ],
         'comment': [
             (r'[^*/]+', Comment.Multiline),
@@ -173,11 +179,17 @@ class RustLexer(RegexLexer):
         'typename': [
             (r'\s+', Text),
             (r'&', Keyword.Pseudo),
-            builtin_types,
+            (r"'", Operator, 'lifetime'),
+            builtin_funcs_types,
             keyword_types,
             (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
             default('#pop'),
         ],
+        'lifetime': [
+            (r"(static|_)", Name.Builtin),
+            (r"[a-zA-Z_]+\w*", Name.Attribute),
+            default('#pop'),
+        ],
         'number_lit': [
             (r'[ui](8|16|32|64|size)', Keyword, '#pop'),
             (r'f(32|64)', Keyword, '#pop'),
@@ -194,14 +206,6 @@ class RustLexer(RegexLexer):
             (r"""\\x[89a-fA-F][0-9a-fA-F]""", String.Escape),
             include('string'),
         ],
-        'macro{': [
-            (r'\{', Operator, '#push'),
-            (r'\}', Operator, '#pop'),
-        ],
-        'macro(': [
-            (r'\(', Operator, '#push'),
-            (r'\)', Operator, '#pop'),
-        ],
         'attribute_common': [
             (r'"', String, 'string'),
             (r'\[', Comment.Preproc, 'attribute['),

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

@@ -5,7 +5,7 @@
 
     Lexer for SAS.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.scdoc
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for scdoc, a simple man page generator.
+
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, \
+    using, this
+from pygments.token import Text, Comment, Keyword, String, \
+    Generic
+
+
+__all__ = ['ScdocLexer']
+
+
+class ScdocLexer(RegexLexer):
+    """
+    `scdoc` is a simple man page generator for POSIX systems written in C99.
+    https://git.sr.ht/~sircmpwn/scdoc
+
+    .. versionadded:: 2.5
+    """
+    name = 'scdoc'
+    aliases = ['scdoc', 'scd']
+    filenames = ['*.scd', '*.scdoc']
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            # comment
+            (r'^(;.+\n)', bygroups(Comment)),
+
+            # heading with pound prefix
+            (r'^(#)([^#].+\n)', bygroups(Generic.Heading, Text)),
+            (r'^(#{2})(.+\n)', bygroups(Generic.Subheading, Text)),
+            # bulleted lists
+            (r'^(\s*)([*-])(\s)(.+\n)',
+            bygroups(Text, Keyword, Text, using(this, state='inline'))),
+            # numbered lists
+            (r'^(\s*)(\.+\.)( .+\n)',
+            bygroups(Text, Keyword, using(this, state='inline'))),
+            # quote
+            (r'^(\s*>\s)(.+\n)', bygroups(Keyword, Generic.Emph)),
+            # text block
+            (r'^(```\n)([\w\W]*?)(^```$)', bygroups(String, Text, String)),
+
+            include('inline'),
+        ],
+        'inline': [
+            # escape
+            (r'\\.', Text),
+            # underlines
+            (r'(\s)(_[^_]+_)(\W|\n)', bygroups(Text, Generic.Emph, Text)),
+            # bold
+            (r'(\s)(\*[^*]+\*)(\W|\n)', bygroups(Text, Generic.Strong, Text)),
+            # inline code
+            (r'`[^`]+`', String.Backtick),
+
+            # general text, must come last!
+            (r'[^\\\s]+', Text),
+            (r'.', Text),
+        ],
+    }
+
+    def analyse_text(text):
+        """This is very similar to markdown, save for the escape characters
+        needed for * and _."""
+        result = 0
+
+        if '\\*' in text:
+            result += 0.01
+
+        if '\\_' in text:
+            result += 0.01
+
+        return result