Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 167 insertions, 167 deletions

diff --git a/contrib/python/Pygments/py2/pygments/lexers/javascript.py b/contrib/python/Pygments/py2/pygments/lexers/javascript.py
index e9cf672278..55c14745ac 100644
--- a/contrib/python/Pygments/py2/pygments/lexers/javascript.py
+++ b/contrib/python/Pygments/py2/pygments/lexers/javascript.py
@@ -5,7 +5,7 @@
 
     Lexers for JavaScript and related languages.
 
-    :copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS. 
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,7 +20,7 @@ import pygments.unistring as uni
 
 __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
            'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
-           'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer', 'JuttleLexer']
+           'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer', 'JuttleLexer'] 
 
 JS_IDENT_START = ('(?:[$_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') +
                   ']|\\\\u[a-fA-F0-9]{4})')
@@ -53,7 +53,7 @@ class JavascriptLexer(RegexLexer):
         'slashstartsregex': [
             include('commentsandwhitespace'),
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gimuy]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuy]+\b|\B)', String.Regex, '#pop'), 
             (r'(?=/)', Text, ('#pop', 'badregex')),
             default('#pop')
         ],
@@ -64,14 +64,14 @@ class JavascriptLexer(RegexLexer):
             (r'\A#! ?/.*?\n', Comment.Hashbang),  # recognized by node.js
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
-            (r'(\.\d+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?', Number.Float),
-            (r'0[bB][01]+', Number.Bin),
-            (r'0[oO][0-7]+', Number.Oct),
-            (r'0[xX][0-9a-fA-F]+', Number.Hex),
-            (r'[0-9]+', Number.Integer),
-            (r'\.\.\.|=>', Punctuation),
+            (r'(\.\d+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?', Number.Float), 
+            (r'0[bB][01]+', Number.Bin), 
+            (r'0[oO][0-7]+', Number.Oct), 
+            (r'0[xX][0-9a-fA-F]+', Number.Hex), 
+            (r'[0-9]+', Number.Integer), 
+            (r'\.\.\.|=>', Punctuation), 
             (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-             r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'),
+             r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'), 
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
             (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|'
@@ -97,13 +97,13 @@ class JavascriptLexer(RegexLexer):
             (r'`', String.Backtick, '#pop'),
             (r'\\\\', String.Backtick),
             (r'\\`', String.Backtick),
-            (r'\$\{', String.Interpol, 'interp-inside'),
+            (r'\$\{', String.Interpol, 'interp-inside'), 
             (r'\$', String.Backtick),
             (r'[^`\\$]+', String.Backtick),
         ],
         'interp-inside': [
             # TODO: should this include single-line comments and allow nesting strings?
-            (r'\}', String.Interpol, '#pop'),
+            (r'\}', String.Interpol, '#pop'), 
             include('root'),
         ],
         # (\\\\|\\`|[^`])*`', String.Backtick),
@@ -366,10 +366,10 @@ class DartLexer(RegexLexer):
             (r'\b(assert|break|case|catch|continue|default|do|else|finally|for|'
              r'if|in|is|new|return|super|switch|this|throw|try|while)\b',
              Keyword),
-            (r'\b(abstract|async|await|const|extends|factory|final|get|'
-             r'implements|native|operator|set|static|sync|typedef|var|with|'
-             r'yield)\b', Keyword.Declaration),
-            (r'\b(bool|double|dynamic|int|num|Object|String|void)\b', Keyword.Type),
+            (r'\b(abstract|async|await|const|extends|factory|final|get|' 
+             r'implements|native|operator|set|static|sync|typedef|var|with|' 
+             r'yield)\b', Keyword.Declaration), 
+            (r'\b(bool|double|dynamic|int|num|Object|String|void)\b', Keyword.Type), 
             (r'\b(false|null|true)\b', Keyword.Constant),
             (r'[~!%^&*+=|?:<>/-]|as\b', Operator),
             (r'@[a-zA-Z_$]\w*', Name.Decorator),
@@ -449,15 +449,15 @@ class TypeScriptLexer(RegexLexer):
 
     name = 'TypeScript'
     aliases = ['ts', 'typescript']
-    filenames = ['*.ts', '*.tsx']
+    filenames = ['*.ts', '*.tsx'] 
     mimetypes = ['text/x-typescript']
 
     flags = re.DOTALL | re.MULTILINE
 
-    # Higher priority than the TypoScriptLexer, as TypeScript is far more
-    # common these days
-    priority = 0.5
-
+    # Higher priority than the TypoScriptLexer, as TypeScript is far more 
+    # common these days 
+    priority = 0.5 
+ 
     tokens = {
         'commentsandwhitespace': [
             (r'\s+', Text),
@@ -483,7 +483,7 @@ class TypeScriptLexer(RegexLexer):
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
             (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|'
-             r'throw|try|catch|finally|new|delete|typeof|instanceof|void|of|'
+             r'throw|try|catch|finally|new|delete|typeof|instanceof|void|of|' 
              r'this)\b', Keyword, 'slashstartsregex'),
             (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
             (r'(abstract|boolean|byte|char|class|const|debugger|double|enum|export|'
@@ -517,26 +517,26 @@ class TypeScriptLexer(RegexLexer):
             (r'[0-9]+', Number.Integer),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single),
-            (r'`', String.Backtick, 'interp'),
+            (r'`', String.Backtick, 'interp'), 
             # Match stuff like: Decorators
             (r'@\w+', Keyword.Declaration),
-        ],
-
-        # The 'interp*' rules match those in JavascriptLexer. Changes made
-        # there should be reflected here as well.
-        'interp': [
-            (r'`', String.Backtick, '#pop'),
-            (r'\\\\', String.Backtick),
-            (r'\\`', String.Backtick),
-            (r'\$\{', String.Interpol, 'interp-inside'),
-            (r'\$', String.Backtick),
-            (r'[^`\\$]+', String.Backtick),
-        ],
-        'interp-inside': [
-            # TODO: should this include single-line comments and allow nesting strings?
-            (r'\}', String.Interpol, '#pop'),
-            include('root'),
-        ],
+        ], 
+ 
+        # The 'interp*' rules match those in JavascriptLexer. Changes made 
+        # there should be reflected here as well. 
+        'interp': [ 
+            (r'`', String.Backtick, '#pop'), 
+            (r'\\\\', String.Backtick), 
+            (r'\\`', String.Backtick), 
+            (r'\$\{', String.Interpol, 'interp-inside'), 
+            (r'\$', String.Backtick), 
+            (r'[^`\\$]+', String.Backtick), 
+        ], 
+        'interp-inside': [ 
+            # TODO: should this include single-line comments and allow nesting strings? 
+            (r'\}', String.Interpol, '#pop'), 
+            include('root'), 
+        ], 
     }
 
 
@@ -568,7 +568,7 @@ class LassoLexer(RegexLexer):
     tokens = {
         'root': [
             (r'^#![ \S]+lasso9\b', Comment.Preproc, 'lasso'),
-            (r'(?=\[|<)', Other, 'delimiters'),
+            (r'(?=\[|<)', Other, 'delimiters'), 
             (r'\s+', Other),
             default(('delimiters', 'lassofile')),
         ],
@@ -576,14 +576,14 @@ class LassoLexer(RegexLexer):
             (r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'),
             (r'\[noprocess\]', Comment.Preproc, 'noprocess'),
             (r'\[', Comment.Preproc, 'squarebrackets'),
-            (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'),
+            (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'), 
             (r'<(!--.*?-->)?', Other),
             (r'[^[<]+', Other),
         ],
         'nosquarebrackets': [
             (r'\[noprocess\]', Comment.Preproc, 'noprocess'),
             (r'\[', Other),
-            (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'),
+            (r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'), 
             (r'<(!--.*?-->)?', Other),
             (r'[^[<]+', Other),
         ],
@@ -625,7 +625,7 @@ class LassoLexer(RegexLexer):
 
             # names
             (r'\$[a-z_][\w.]*', Name.Variable),
-            (r'#([a-z_][\w.]*|\d+\b)', Name.Variable.Instance),
+            (r'#([a-z_][\w.]*|\d+\b)', Name.Variable.Instance), 
             (r"(\.\s*)('[a-z_][\w.]*')",
                 bygroups(Name.Builtin.Pseudo, Name.Variable.Class)),
             (r"(self)(\s*->\s*)('[a-z_][\w.]*')",
@@ -676,20 +676,20 @@ class LassoLexer(RegexLexer):
              r'Database_TableNames|Define_Tag|Define_Type|Email_Batch|'
              r'Encode_Set|HTML_Comment|Handle|Handle_Error|Header|If|Inline|'
              r'Iterate|LJAX_Target|Link|Link_CurrentAction|Link_CurrentGroup|'
-             r'Link_CurrentRecord|Link_Detail|Link_FirstGroup|Link_FirstRecord|'
-             r'Link_LastGroup|Link_LastRecord|Link_NextGroup|Link_NextRecord|'
-             r'Link_PrevGroup|Link_PrevRecord|Log|Loop|Output_None|Portal|'
-             r'Private|Protect|Records|Referer|Referrer|Repeating|ResultSet|'
-             r'Rows|Search_Args|Search_Arguments|Select|Sort_Args|'
-             r'Sort_Arguments|Thread_Atomic|Value_List|While|Abort|Case|Else|'
-             r'Fail_If|Fail_IfNot|Fail|If_Empty|If_False|If_Null|If_True|'
-             r'Loop_Abort|Loop_Continue|Loop_Count|Params|Params_Up|Return|'
-             r'Return_Value|Run_Children|SOAP_DefineTag|SOAP_LastRequest|'
-             r'SOAP_LastResponse|Tag_Name|ascending|average|by|define|'
-             r'descending|do|equals|frozen|group|handle_failure|import|in|into|'
-             r'join|let|match|max|min|on|order|parent|protected|provide|public|'
-             r'require|returnhome|skip|split_thread|sum|take|thread|to|trait|'
-             r'type|where|with|yield|yieldhome)\b',
+             r'Link_CurrentRecord|Link_Detail|Link_FirstGroup|Link_FirstRecord|' 
+             r'Link_LastGroup|Link_LastRecord|Link_NextGroup|Link_NextRecord|' 
+             r'Link_PrevGroup|Link_PrevRecord|Log|Loop|Output_None|Portal|' 
+             r'Private|Protect|Records|Referer|Referrer|Repeating|ResultSet|' 
+             r'Rows|Search_Args|Search_Arguments|Select|Sort_Args|' 
+             r'Sort_Arguments|Thread_Atomic|Value_List|While|Abort|Case|Else|' 
+             r'Fail_If|Fail_IfNot|Fail|If_Empty|If_False|If_Null|If_True|' 
+             r'Loop_Abort|Loop_Continue|Loop_Count|Params|Params_Up|Return|' 
+             r'Return_Value|Run_Children|SOAP_DefineTag|SOAP_LastRequest|' 
+             r'SOAP_LastResponse|Tag_Name|ascending|average|by|define|' 
+             r'descending|do|equals|frozen|group|handle_failure|import|in|into|' 
+             r'join|let|match|max|min|on|order|parent|protected|provide|public|' 
+             r'require|returnhome|skip|split_thread|sum|take|thread|to|trait|' 
+             r'type|where|with|yield|yieldhome)\b', 
                 bygroups(Punctuation, Keyword)),
 
             # other
@@ -1014,7 +1014,7 @@ class ObjectiveJLexer(RegexLexer):
     }
 
     def analyse_text(text):
-        if re.search(r'^\s*@import\s+[<"]', text, re.MULTILINE):
+        if re.search(r'^\s*@import\s+[<"]', text, re.MULTILINE): 
             # special directive found in most Objective-J files
             return True
         return False
@@ -1034,11 +1034,11 @@ class CoffeeScriptLexer(RegexLexer):
     filenames = ['*.coffee']
     mimetypes = ['text/coffeescript']
 
-    _operator_re = (
-        r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|'
-        r'\|\||\\(?=\n)|'
-        r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?')
-
+    _operator_re = ( 
+        r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|' 
+        r'\|\||\\(?=\n)|' 
+        r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?') 
+ 
     flags = re.DOTALL
     tokens = {
         'commentsandwhitespace': [
@@ -1057,17 +1057,17 @@ class CoffeeScriptLexer(RegexLexer):
             (r'///', String.Regex, ('#pop', 'multilineregex')),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
-            # This isn't really guarding against mishighlighting well-formed
-            # code, just the ability to infinite-loop between root and
-            # slashstartsregex.
-            (r'/', Operator),
+            # This isn't really guarding against mishighlighting well-formed 
+            # code, just the ability to infinite-loop between root and 
+            # slashstartsregex. 
+            (r'/', Operator), 
             default('#pop'),
         ],
         'root': [
             include('commentsandwhitespace'),
-            (r'^(?=\s|/)', Text, 'slashstartsregex'),
-            (_operator_re, Operator, 'slashstartsregex'),
-            (r'(?:\([^()]*\))?\s*[=-]>', Name.Function, 'slashstartsregex'),
+            (r'^(?=\s|/)', Text, 'slashstartsregex'), 
+            (_operator_re, Operator, 'slashstartsregex'), 
+            (r'(?:\([^()]*\))?\s*[=-]>', Name.Function, 'slashstartsregex'), 
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
             (r'(?<![.$])(for|own|in|of|while|until|'
@@ -1088,7 +1088,7 @@ class CoffeeScriptLexer(RegexLexer):
             (r'@[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable.Instance,
              'slashstartsregex'),
             (r'@', Name.Other, 'slashstartsregex'),
-            (r'@?[$a-zA-Z_][\w$]*', Name.Other),
+            (r'@?[$a-zA-Z_][\w$]*', Name.Other), 
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
@@ -1268,32 +1268,32 @@ class EarlGreyLexer(RegexLexer):
             include('control'),
             (r'[^\S\n]+', Text),
             (r';;.*\n', Comment),
-            (r'[\[\]{}:(),;]', Punctuation),
+            (r'[\[\]{}:(),;]', Punctuation), 
             (r'\\\n', Text),
             (r'\\', Text),
             include('errors'),
             (words((
                 'with', 'where', 'when', 'and', 'not', 'or', 'in',
                 'as', 'of', 'is'),
-                prefix=r'(?<=\s|\[)', suffix=r'(?![\w$\-])'),
+                prefix=r'(?<=\s|\[)', suffix=r'(?![\w$\-])'), 
              Operator.Word),
-            (r'[*@]?->', Name.Function),
+            (r'[*@]?->', Name.Function), 
             (r'[+\-*/~^<>%&|?!@#.]*=', Operator.Word),
             (r'\.{2,3}', Operator.Word),  # Range Operator
             (r'([+*/~^<>&|?!]+)|([#\-](?=\s))|@@+(?=\s)|=+', Operator),
-            (r'(?<![\w$\-])(var|let)(?:[^\w$])', Keyword.Declaration),
+            (r'(?<![\w$\-])(var|let)(?:[^\w$])', Keyword.Declaration), 
             include('keywords'),
             include('builtins'),
             include('assignment'),
             (r'''(?x)
-                (?:()([a-zA-Z$_](?:[\w$\-]*[\w$])?)|
-                   (?<=[\s{\[(])(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?))
+                (?:()([a-zA-Z$_](?:[\w$\-]*[\w$])?)| 
+                   (?<=[\s{\[(])(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)) 
                 (?=.*%)''',
              bygroups(Punctuation, Name.Tag, Punctuation, Name.Class.Start), 'dbs'),
             (r'[rR]?`', String.Backtick, 'bt'),
             (r'[rR]?```', String.Backtick, 'tbt'),
-            (r'(?<=[\s\[{(,;])\.([a-zA-Z$_](?:[\w$\-]*[\w$])?)'
-             r'(?=[\s\]}),;])', String.Symbol),
+            (r'(?<=[\s\[{(,;])\.([a-zA-Z$_](?:[\w$\-]*[\w$])?)' 
+             r'(?=[\s\]}),;])', String.Symbol), 
             include('nested'),
             (r'(?:[rR]|[rR]\.[gmi]{1,3})?"', String, combined('stringescape', 'dqs')),
             (r'(?:[rR]|[rR]\.[gmi]{1,3})?\'', String, combined('stringescape', 'sqs')),
@@ -1304,9 +1304,9 @@ class EarlGreyLexer(RegexLexer):
             include('numbers'),
         ],
         'dbs': [
-            (r'(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)(?=[.\[\s])',
+            (r'(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)(?=[.\[\s])', 
              bygroups(Punctuation, Name.Class.DBS)),
-            (r'(\[)([\^#][a-zA-Z$_](?:[\w$\-]*[\w$])?)(\])',
+            (r'(\[)([\^#][a-zA-Z$_](?:[\w$\-]*[\w$])?)(\])', 
              bygroups(Punctuation, Name.Entity.DBS, Punctuation)),
             (r'\s+', Text),
             (r'%', Operator.DBS, '#pop'),
@@ -1316,29 +1316,29 @@ class EarlGreyLexer(RegexLexer):
              bygroups(Text.Whitespace, Text)),
         ],
         'assignment': [
-            (r'(\.)?([a-zA-Z$_](?:[\w$\-]*[\w$])?)'
+            (r'(\.)?([a-zA-Z$_](?:[\w$\-]*[\w$])?)' 
              r'(?=\s+[+\-*/~^<>%&|?!@#.]*\=\s)',
              bygroups(Punctuation, Name.Variable))
         ],
         'errors': [
             (words(('Error', 'TypeError', 'ReferenceError'),
-                   prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'),
+                   prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 
              Name.Exception),
             (r'''(?x)
-                (?<![\w$])
-                E\.[\w$](?:[\w$\-]*[\w$])?
-                (?:\.[\w$](?:[\w$\-]*[\w$])?)*
-                (?=[({\[?!\s])''',
+                (?<![\w$]) 
+                E\.[\w$](?:[\w$\-]*[\w$])? 
+                (?:\.[\w$](?:[\w$\-]*[\w$])?)* 
+                (?=[({\[?!\s])''', 
              Name.Exception),
         ],
         'control': [
             (r'''(?x)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?) 
                 (?!\n)\s+
                 (?!and|as|each\*|each|in|is|mod|of|or|when|where|with)
-                (?=(?:[+\-*/~^<>%&|?!@#.])?[a-zA-Z$_](?:[\w$-]*[\w$])?)''',
+                (?=(?:[+\-*/~^<>%&|?!@#.])?[a-zA-Z$_](?:[\w$-]*[\w$])?)''', 
              Keyword.Control),
-            (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(?!\n)\s+(?=[\'"\d{\[(])',
+            (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(?!\n)\s+(?=[\'"\d{\[(])', 
              Keyword.Control),
             (r'''(?x)
                 (?:
@@ -1347,28 +1347,28 @@ class EarlGreyLexer(RegexLexer):
                     (?<=with|each|with)|
                     (?<=each\*|where)
                 )(\s+)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''',
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''', 
              bygroups(Text, Keyword.Control, Punctuation)),
             (r'''(?x)
                 (?<![+\-*/~^<>%&|?!@#.])(\s+)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''',
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''', 
              bygroups(Text, Keyword.Control, Punctuation)),
         ],
         'nested': [
             (r'''(?x)
-                (?<=[\w$\]})])(\.)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
+                (?<=[\w$\]})])(\.) 
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?) 
                 (?=\s+with(?:\s|\n))''',
              bygroups(Punctuation, Name.Function)),
             (r'''(?x)
                 (?<!\s)(\.)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
-                (?=[}\]).,;:\s])''',
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?) 
+                (?=[}\]).,;:\s])''', 
              bygroups(Punctuation, Name.Field)),
             (r'''(?x)
-                (?<=[\w$\]})])(\.)
-                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
-                (?=[\[{(:])''',
+                (?<=[\w$\]})])(\.) 
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?) 
+                (?=[\[{(:])''', 
              bygroups(Punctuation, Name.Function)),
         ],
         'keywords': [
@@ -1377,15 +1377,15 @@ class EarlGreyLexer(RegexLexer):
                 'continue', 'elif', 'expr-value', 'if', 'match',
                 'return', 'yield', 'pass', 'else', 'require', 'var',
                 'let', 'async', 'method', 'gen'),
-                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'),
+                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 
              Keyword.Pseudo),
             (words(('this', 'self', '@'),
-                   prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'),
+                   prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'), 
              Keyword.Constant),
             (words((
                 'Function', 'Object', 'Array', 'String', 'Number',
                 'Boolean', 'ErrorFactory', 'ENode', 'Promise'),
-                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'),
+                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$])'), 
              Keyword.Type),
         ],
         'builtins': [
@@ -1396,20 +1396,20 @@ class EarlGreyLexer(RegexLexer):
                 'getChecker', 'get-checker', 'getProperty', 'get-property',
                 'getProjector', 'get-projector', 'consume', 'take',
                 'promisify', 'spawn', 'constructor'),
-                prefix=r'(?<![\w\-#.])', suffix=r'(?![\w\-.])'),
+                prefix=r'(?<![\w\-#.])', suffix=r'(?![\w\-.])'), 
              Name.Builtin),
             (words((
                 'true', 'false', 'null', 'undefined'),
-                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'),
+                prefix=r'(?<![\w\-$.])', suffix=r'(?![\w\-$.])'), 
              Name.Constant),
         ],
         'name': [
-            (r'@([a-zA-Z$_](?:[\w$-]*[\w$])?)', Name.Variable.Instance),
-            (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(\+\+|\-\-)?',
+            (r'@([a-zA-Z$_](?:[\w$-]*[\w$])?)', Name.Variable.Instance), 
+            (r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(\+\+|\-\-)?', 
              bygroups(Name.Symbol, Operator.Word))
         ],
         'tuple': [
-            (r'#[a-zA-Z_][\w\-]*(?=[\s{(,;])', Name.Namespace)
+            (r'#[a-zA-Z_][\w\-]*(?=[\s{(,;])', Name.Namespace) 
         ],
         'interpoling_string': [
             (r'\}', String.Interpol, '#pop'),
@@ -1449,7 +1449,7 @@ class EarlGreyLexer(RegexLexer):
             (r'```', String.Backtick, '#pop'),
             (r'\n', String.Backtick),
             (r'\^=?', String.Escape),
-            (r'[^`]+', String.Backtick),
+            (r'[^`]+', String.Backtick), 
         ],
         'numbers': [
             (r'\d+\.(?!\.)\d*([eE][+-]?[0-9]+)?', Number.Float),
@@ -1462,72 +1462,72 @@ class EarlGreyLexer(RegexLexer):
             (r'\d+', Number.Integer)
         ],
     }
-
-
-class JuttleLexer(RegexLexer):
-    """
-    For `Juttle`_ source code.
-
-    .. _Juttle: https://github.com/juttle/juttle
-
+ 
+
+class JuttleLexer(RegexLexer): 
+    """ 
+    For `Juttle`_ source code. 
+ 
+    .. _Juttle: https://github.com/juttle/juttle 
+ 
     .. versionadded:: 2.2
-    """
-
-    name = 'Juttle'
-    aliases = ['juttle', 'juttle']
-    filenames = ['*.juttle']
-    mimetypes = ['application/juttle', 'application/x-juttle',
-                 'text/x-juttle', 'text/juttle']
-
-    flags = re.DOTALL | re.UNICODE | re.MULTILINE
-
-    tokens = {
-        'commentsandwhitespace': [
-            (r'\s+', Text),
-            (r'//.*?\n', Comment.Single),
-            (r'/\*.*?\*/', Comment.Multiline)
-        ],
-        'slashstartsregex': [
-            include('commentsandwhitespace'),
-            (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex, '#pop'),
-            (r'(?=/)', Text, ('#pop', 'badregex')),
-            default('#pop')
-        ],
-        'badregex': [
-            (r'\n', Text, '#pop')
-        ],
-        'root': [
-            (r'^(?=\s|/)', Text, 'slashstartsregex'),
-            include('commentsandwhitespace'),
-            (r':\d{2}:\d{2}:\d{2}(\.\d*)?:', String.Moment),
-            (r':(now|beginning|end|forever|yesterday|today|tomorrow|'
-             r'(\d+(\.\d*)?|\.\d+)(ms|[smhdwMy])?):', String.Moment),
-            (r':\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d*)?)?'
-             r'(Z|[+-]\d{2}:\d{2}|[+-]\d{4})?:', String.Moment),
+    """ 
+ 
+    name = 'Juttle' 
+    aliases = ['juttle', 'juttle'] 
+    filenames = ['*.juttle'] 
+    mimetypes = ['application/juttle', 'application/x-juttle', 
+                 'text/x-juttle', 'text/juttle'] 
+ 
+    flags = re.DOTALL | re.UNICODE | re.MULTILINE 
+ 
+    tokens = { 
+        'commentsandwhitespace': [ 
+            (r'\s+', Text), 
+            (r'//.*?\n', Comment.Single), 
+            (r'/\*.*?\*/', Comment.Multiline) 
+        ], 
+        'slashstartsregex': [ 
+            include('commentsandwhitespace'), 
+            (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' 
+             r'([gim]+\b|\B)', String.Regex, '#pop'), 
+            (r'(?=/)', Text, ('#pop', 'badregex')), 
+            default('#pop') 
+        ], 
+        'badregex': [ 
+            (r'\n', Text, '#pop') 
+        ], 
+        'root': [ 
+            (r'^(?=\s|/)', Text, 'slashstartsregex'), 
+            include('commentsandwhitespace'), 
+            (r':\d{2}:\d{2}:\d{2}(\.\d*)?:', String.Moment), 
+            (r':(now|beginning|end|forever|yesterday|today|tomorrow|' 
+             r'(\d+(\.\d*)?|\.\d+)(ms|[smhdwMy])?):', String.Moment), 
+            (r':\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d*)?)?' 
+             r'(Z|[+-]\d{2}:\d{2}|[+-]\d{4})?:', String.Moment), 
             (r':((\d+(\.\d*)?|\.\d+)[ ]+)?(millisecond|second|minute|hour|'
              r'day|week|month|year)[s]?'
              r'(([ ]+and[ ]+(\d+[ ]+)?(millisecond|second|minute|hour|'
              r'day|week|month|year)[s]?)'
-             r'|[ ]+(ago|from[ ]+now))*:', String.Moment),
-            (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-             r'(==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'),
-            (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
-            (r'[})\].]', Punctuation),
-            (r'(import|return|continue|if|else)\b', Keyword, 'slashstartsregex'),
+             r'|[ ]+(ago|from[ ]+now))*:', String.Moment), 
+            (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|' 
+             r'(==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'), 
+            (r'[{(\[;,]', Punctuation, 'slashstartsregex'), 
+            (r'[})\].]', Punctuation), 
+            (r'(import|return|continue|if|else)\b', Keyword, 'slashstartsregex'), 
             (r'(var|const|function|reducer|sub|input)\b', Keyword.Declaration,
              'slashstartsregex'),
-            (r'(batch|emit|filter|head|join|keep|pace|pass|put|read|reduce|remove|'
+            (r'(batch|emit|filter|head|join|keep|pace|pass|put|read|reduce|remove|' 
              r'sequence|skip|sort|split|tail|unbatch|uniq|view|write)\b',
              Keyword.Reserved),
-            (r'(true|false|null|Infinity)\b', Keyword.Constant),
+            (r'(true|false|null|Infinity)\b', Keyword.Constant), 
             (r'(Array|Date|Juttle|Math|Number|Object|RegExp|String)\b',
              Name.Builtin),
-            (JS_IDENT, Name.Other),
-            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
-            (r'[0-9]+', Number.Integer),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single)
-        ]
-
-    }
+            (JS_IDENT, Name.Other), 
+            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), 
+            (r'[0-9]+', Number.Integer), 
+            (r'"(\\\\|\\"|[^"])*"', String.Double), 
+            (r"'(\\\\|\\'|[^'])*'", String.Single) 
+        ] 
+ 
+    }