eric: comparison ThirdParty/Pygments/pygments/lexers/javascript.py

-:f0d08bdeacf4
+:6762afd9f963
 pygments.lexers.javascript
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 Lexers for JavaScript and related languages.
-:copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 from pygments.util import get_bool_opt, iteritems
 import pygments.unistring as uni
 __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
 'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
-'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer']
+'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer', 'JuttleLexer']
 JS_IDENT_START = ('(?:[$_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') +
 ']|\\\\u[a-fA-F0-9]{4})')
 JS_IDENT_PART = ('(?:[$' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
 'Mn', 'Mc', 'Nd', 'Pc') +
 (r'/\*.*?\*/', Comment.Multiline)
 ],
 'slashstartsregex': [
 include('commentsandwhitespace'),
 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-r'([gim]+\b|\B)', String.Regex, '#pop'),
+r'([gimuy]+\b|\B)', String.Regex, '#pop'),
 (r'(?=/)', Text, ('#pop', 'badregex')),
 default('#pop')
 ],
 'badregex': [
 (r'\n', Text, '#pop')
 ],
 'root': [
 (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'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-r'(<<|>>>?|=>|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'),
+r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?', Operator, 'slashstartsregex'),
-(r'\.\.\.', Punctuation),
 (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|yield|'
 r'this|of)\b', Keyword, 'slashstartsregex'),
 r'Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|'
 r'decodeURIComponent|encodeURI|encodeURIComponent|'
 r'Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|'
 r'document|this|window)\b', Name.Builtin),
 (JS_IDENT, Name.Other),
-(r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
-(r'0b[01]+', Number.Bin),
-(r'0o[0-7]+', Number.Oct),
-(r'0x[0-9a-fA-F]+', Number.Hex),
-(r'[0-9]+', Number.Integer),
 (r'"(\\\\|\\"|[^"])*"', String.Double),
 (r"'(\\\\|\\'|[^'])*'", String.Single),
 (r'`', String.Backtick, 'interp'),
 ],
 'interp': [
 (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),
 }
 (r'\b(class)\b(\s+)',
 bygroups(Keyword.Declaration, Text), 'class'),
 (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|const|extends|factory|final|get|implements|'
+(r'\b(abstract|async|await|const|extends|factory|final|get|'
-r'native|operator|set|static|typedef|var)\b', Keyword.Declaration),
+r'implements|native|operator|set|static|sync|typedef|var|with|'
-(r'\b(bool|double|Dynamic|int|num|Object|String|void)\b', Keyword.Type),
+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.Label),
 (r'[a-zA-Z_$]\w*', Name),
 (r'[(){}\[\],.;]', Punctuation),
 .. versionadded:: 1.6
 """
 name = 'TypeScript'
 aliases = ['ts', 'typescript']
-filenames = ['*.ts']
+filenames = ['*.ts', '*.tsx']
 mimetypes = ['text/x-typescript']
 flags = re.DOTALL | re.MULTILINE
 tokens = {
 (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),
 (r'"(\\\\|\\"|[^"])*"', String.Double),
 (r"'(\\\\|\\'|[^'])*'", String.Single),
+(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'),
+],
 }
+def analyse_text(text):
+if re.search('^(import.+(from\s+)?["\']|'
+'(export\s*)?(interface|class|function)\s+)',
+text, re.MULTILINE):
+return 1.0
 class LassoLexer(RegexLexer):
 """
 For `Lasso <http://www.lassosoft.com/>`_ source code, covering both Lasso 9
 flags = re.IGNORECASE | re.DOTALL | re.MULTILINE
 tokens = {
 'root': [
 (r'^#![ \S]+lasso9\b', Comment.Preproc, 'lasso'),
-(r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'),
+(r'(?=\[|<)', Other, 'delimiters'),
-(r'\[noprocess\]', Comment.Preproc, ('delimiters', 'noprocess')),
-(r'\[', Comment.Preproc, ('delimiters', 'squarebrackets')),
-(r'<\?(LassoScript|lasso|=)', Comment.Preproc,
-('delimiters', 'anglebrackets')),
-(r'<(!--.*?-->)?', Other, 'delimiters'),
 (r'\s+', Other),
 default(('delimiters', 'lassofile')),
 ],
 'delimiters': [
 (r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'),
 (r'\[noprocess\]', Comment.Preproc, 'noprocess'),
 (r'\[', Comment.Preproc, 'squarebrackets'),
-(r'<\?(LassoScript|lasso|=)', Comment.Preproc, 'anglebrackets'),
+(r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'),
 (r'<(!--.*?-->)?', Other),
 (r'[^[<]+', Other),
 ],
 'nosquarebrackets': [
 (r'\[noprocess\]', Comment.Preproc, 'noprocess'),
 (r'\[', Other),
-(r'<\?(LassoScript|lasso|=)', Comment.Preproc, 'anglebrackets'),
+(r'<\?(lasso(script)?|=)', Comment.Preproc, 'anglebrackets'),
 (r'<(!--.*?-->)?', Other),
 (r'[^[<]+', Other),
 ],
 'noprocess': [
 (r'\[/noprocess\]', Comment.Preproc, '#pop'),
 (r'"', String.Double, 'doublestring'),
 (r'`[^`]*`', String.Backtick),
 # names
 (r'\$[a-z_][\w.]*', Name.Variable),
-(r'#([a-z_][\w.]*|\d+)', 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.]*')",
 bygroups(Name.Builtin.Pseudo, Operator, Name.Variable.Class)),
 (r'(\.\.?\s*)([a-z_][\w.]*(=(?!=))?)',
 (r'(/?)(Namespace_Using)\b', bygroups(Punctuation, Keyword.Namespace)),
 (r'(/?)(Cache|Database_Names|Database_SchemaNames|'
 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|'
+r'Link_CurrentRecord|Link_Detail|Link_FirstGroup|Link_FirstRecord|'
-r'Link_FirstRecord|Link_LastGroup|Link_LastRecord|Link_NextGroup|'
+r'Link_LastGroup|Link_LastRecord|Link_NextGroup|Link_NextRecord|'
-r'Link_NextRecord|Link_PrevGroup|Link_PrevRecord|Log|Loop|'
+r'Link_PrevGroup|Link_PrevRecord|Log|Loop|Output_None|Portal|'
-r'NoProcess|Output_None|Portal|Private|Protect|Records|Referer|'
+r'Private|Protect|Records|Referer|Referrer|Repeating|ResultSet|'
-r'Referrer|Repeating|ResultSet|Rows|Search_Args|Search_Arguments|'
+r'Rows|Search_Args|Search_Arguments|Select|Sort_Args|'
-r'Select|Sort_Args|Sort_Arguments|Thread_Atomic|Value_List|While|'
+r'Sort_Arguments|Thread_Atomic|Value_List|While|Abort|Case|Else|'
-r'Abort|Case|Else|If_Empty|If_False|If_Null|If_True|Loop_Abort|'
+r'Fail_If|Fail_IfNot|Fail|If_Empty|If_False|If_Null|If_True|'
-r'Loop_Continue|Loop_Count|Params|Params_Up|Return|Return_Value|'
+r'Loop_Abort|Loop_Continue|Loop_Count|Params|Params_Up|Return|'
-r'Run_Children|SOAP_DefineTag|SOAP_LastRequest|SOAP_LastResponse|'
+r'Return_Value|Run_Children|SOAP_DefineTag|SOAP_LastRequest|'
-r'Tag_Name|ascending|average|by|define|descending|do|equals|'
+r'SOAP_LastResponse|Tag_Name|ascending|average|by|define|'
-r'frozen|group|handle_failure|import|in|into|join|let|match|max|'
+r'descending|do|equals|frozen|group|handle_failure|import|in|into|'
-r'min|on|order|parent|protected|provide|public|require|returnhome|'
+r'join|let|match|max|min|on|order|parent|protected|provide|public|'
-r'skip|split_thread|sum|take|thread|to|trait|type|where|with|'
+r'require|returnhome|skip|split_thread|sum|take|thread|to|trait|'
-r'yield|yieldhome)\b',
+r'type|where|with|yield|yieldhome)\b',
 bygroups(Punctuation, Keyword)),
 # other
 (r',', Punctuation, 'commamember'),
 (r'(and|or|not)\b', Operator.Word),
 name = 'CoffeeScript'
 aliases = ['coffee-script', 'coffeescript', 'coffee']
 filenames = ['*.coffee']
 mimetypes = ['text/coffeescript']
+_operator_re = (
+r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|'
+r'\|\||\\(?=\n)|'
+r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?')
 flags = re.DOTALL
 tokens = {
 'commentsandwhitespace': [
 (r'\s+', Text),
 (r'###[^#].*?###', Comment.Multiline),
 'slashstartsregex': [
 include('commentsandwhitespace'),
 (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),
 default('#pop'),
 ],
 'root': [
-# this next expr leads to infinite loops root -> slashstartsregex
-# (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
 include('commentsandwhitespace'),
-(r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|'
+(r'^(?=\s|/)', Text, 'slashstartsregex'),
-r'\|\||\\(?=\n)|'
+(_operator_re, Operator, 'slashstartsregex'),
-r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&|^/])=?',
+(r'(?:\([^()]*\))?\s*[=-]>', Name.Function, 'slashstartsregex'),
-Operator, 'slashstartsregex'),
-(r'(?:\([^()]*\))?\s*[=-]>', Name.Function),
 (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
 (r'[})\].]', Punctuation),
 (r'(?<![.$])(for|own|in|of|while|until|'
 r'loop|break|return|continue|'
 r'switch|when|then|if|unless|else|'
 (r'[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable,
 'slashstartsregex'),
 (r'@[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable.Instance,
 'slashstartsregex'),
 (r'@', Name.Other, 'slashstartsregex'),
-(r'@?[$a-zA-Z_][\w$]*', Name.Other, 'slashstartsregex'),
+(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),
 ('"""', String, 'tdqs'),
 ("'''", String, 'tsqs'),
 'root': [
 (r'\n', Text),
 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$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)|
+(?:()([a-zA-Z$_](?:[\w$\-]*[\w$])?)|
-(?<=[\s\{\[\(])(\.)([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?))
+(?<=[\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$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)'
+(r'(?<=[\s\[{(,;])\.([a-zA-Z$_](?:[\w$\-]*[\w$])?)'
-r'(?=[\s\]\}\),;])', String.Symbol),
+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')),
 (r'"""', String, combined('stringescape', 'tdqs')),
 include('tuple'),
 include('import_paths'),
 include('name'),
 include('numbers'),
 ],
 'dbs': [
-(r'(\.)([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)(?=[\[\.\s])',
+(r'(\.)([a-zA-Z$_](?:[\w$\-]*[\w$])?)(?=[.\[\s])',
 bygroups(Punctuation, Name.Class.DBS)),
-(r'(\[)([\^#][a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)(\])',
+(r'(\[)([\^#][a-zA-Z$_](?:[\w$\-]*[\w$])?)(\])',
 bygroups(Punctuation, Name.Entity.DBS, Punctuation)),
 (r'\s+', Text),
 (r'%', Operator.DBS, '#pop'),
 ],
 'import_paths': [
 (r'(?<=[\s:;,])(\.{1,3}(?:[\w\-]*/)*)(\w(?:[\w\-]*\w)*)(?=[\s;,])',
 bygroups(Text.Whitespace, Text)),
 ],
 'assignment': [
-(r'(\.)?([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)'
+(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\$])
+(?<![\w$])
-E\.[\w\$](?:[\w\$\-]*[\w\$])?
+E\.[\w$](?:[\w$\-]*[\w$])?
-(?:\.[\w\$](?:[\w\$\-]*[\w\$])?)*
+(?:\.[\w$](?:[\w$\-]*[\w$])?)*
-(?=[\(\{\[\?\!\s])''',
+(?=[({\[?!\s])''',
 Name.Exception),
 ],
 'control': [
 (r'''(?x)
-([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+([a-zA-Z$_](?:[\w$-]*[\w$])?)
 (?!\n)\s+
 (?!and|as|each\*|each|in|is|mod|of|or|when|where|with)
-(?=(?:[+\-*/~^<>%&|?!@#.])?[a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)''',
+(?=(?:[+\-*/~^<>%&|?!@#.])?[a-zA-Z$_](?:[\w$-]*[\w$])?)''',
 Keyword.Control),
-(r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?!\n)\s+(?=[\'"\d\{\[\(])',
+(r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(?!\n)\s+(?=[\'"\d{\[(])',
 Keyword.Control),
 (r'''(?x)
 (?:
 (?<=[%=])|
 (?<=[=\-]>)|
 (?<=with|each|with)|
 (?<=each\*|where)
 )(\s+)
-([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)(:)''',
+([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''',
 bygroups(Text, Keyword.Control, Punctuation)),
 (r'''(?x)
 (?<![+\-*/~^<>%&|?!@#.])(\s+)
-([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(:)''',
+([a-zA-Z$_](?:[\w$-]*[\w$])?)(:)''',
 bygroups(Text, Keyword.Control, Punctuation)),
 ],
 'nested': [
 (r'''(?x)
-(?<=[a-zA-Z$0-9_\]\}\)])(\.)
+(?<=[\w$\]})])(\.)
-([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+([a-zA-Z$_](?:[\w$-]*[\w$])?)
 (?=\s+with(?:\s|\n))''',
 bygroups(Punctuation, Name.Function)),
 (r'''(?x)
 (?<!\s)(\.)
-([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+([a-zA-Z$_](?:[\w$-]*[\w$])?)
-(?=[\}\]\)\.,;:\s])''',
+(?=[}\]).,;:\s])''',
 bygroups(Punctuation, Name.Field)),
 (r'''(?x)
-(?<=[a-zA-Z$0-9_\]\}\)])(\.)
+(?<=[\w$\]})])(\.)
-([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+([a-zA-Z$_](?:[\w$-]*[\w$])?)
-(?=[\[\{\(:])''',
+(?=[\[{(:])''',
 bygroups(Punctuation, Name.Function)),
 ],
 'keywords': [
 (words((
 'each', 'each*', 'mod', 'await', 'break', 'chain',
 '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': [
 (words((
 'send', 'object', 'keys', 'items', 'enumerate', 'zip',
 'product', 'neighbours', 'predicate', 'equal',
 'nequal', 'contains', 'repr', 'clone', 'range',
 '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$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Variable.Instance),
+(r'@([a-zA-Z$_](?:[\w$-]*[\w$])?)', Name.Variable.Instance),
-(r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(\+\+|\-\-)?',
+(r'([a-zA-Z$_](?:[\w$-]*[\w$])?)(\+\+|\-\-)?',
 bygroups(Name.Symbol, Operator.Word))
 ],
 'tuple': [
-(r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(,;\n])', Name.Namespace)
+(r'#[a-zA-Z_][\w\-]*(?=[\s{(,;])', Name.Namespace)
 ],
 'interpoling_string': [
 (r'\}', String.Interpol, '#pop'),
 include('root')
 ],
 ],
 'tbt': [
 (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),
 (r'\d+[eE][+-]?[0-9]+', Number.Float),
 (r'8r[0-7]+', Number.Oct),
 (r'2r[01]+', Number.Bin),
 (r'16r[a-fA-F0-9]+', Number.Hex),
-(r'([3-79]|[1-2][0-9]|3[0-6])r[a-zA-Z\d]+(\.[a-zA-Z\d]+)?', Number.Radix),
+(r'([3-79]|[12][0-9]|3[0-6])r[a-zA-Z\d]+(\.[a-zA-Z\d]+)?', Number.Radix),
 (r'\d+', Number.Integer)
 ],
 }
+class JuttleLexer(RegexLexer):
+"""
+For `Juttle`_ source code.
+.. _Juttle: https://github.com/juttle/juttle
+"""
+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|(\d+(\.\d*)?|\.\d+)(ms|[smhdwMy])?):', String.Moment),
+(r':\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d*)?)?(Z|[+-]\d{2}:\d{2}|[+-]\d{4})?:', String.Moment),
+(r':((\d+(\.\d*)?|\.\d+)[ ]+)?(millisecond|second|minute|hour|day|week|month|year)[s]?'
+r'(([ ]+and[ ]+(\d+[ ]+)?(millisecond|second|minute|hour|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'(var|const|function|reducer|sub|input)\b', Keyword.Declaration, 'slashstartsregex'),
+(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'(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)
+]
+}

Mercurial Repositories > eric / file comparison

comparison: ThirdParty/Pygments/pygments/lexers/javascript.py

ThirdParty/Pygments/pygments/lexers/javascript.py