From f7a006d85e3553de6c5852e1fbb70fd923510603 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Fri, 19 Sep 2014 23:53:18 +0200
Subject: split up web lexers

---
 pygments/lexers/javascript.py | 1192 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1192 insertions(+)
 create mode 100644 pygments/lexers/javascript.py

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
new file mode 100644
index 00000000..6e4e07e8
--- /dev/null
+++ b/pygments/lexers/javascript.py
@@ -0,0 +1,1192 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.javascript
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for JavaScript and related languages.
+
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, default, \
+    using, this
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Other
+from pygments.util import get_bool_opt, iteritems
+
+__all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
+           'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
+           'CoffeeScriptLexer', 'MaskLexer']
+
+
+class JavascriptLexer(RegexLexer):
+    """
+    For JavaScript source code.
+    """
+
+    name = 'JavaScript'
+    aliases = ['js', 'javascript']
+    filenames = ['*.js', ]
+    mimetypes = ['application/javascript', 'application/x-javascript',
+                 'text/x-javascript', 'text/javascript', ]
+
+    flags = re.DOTALL
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'<!--', Comment),
+            (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'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
+             r'(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?', Operator, 'slashstartsregex'),
+            (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)\b', Keyword, 'slashstartsregex'),
+            (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
+            (r'(abstract|boolean|byte|char|class|const|debugger|double|enum|export|'
+             r'extends|final|float|goto|implements|import|int|interface|long|native|'
+             r'package|private|protected|public|short|static|super|synchronized|throws|'
+             r'transient|volatile)\b', Keyword.Reserved),
+            (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
+             r'window)\b', Name.Builtin),
+            (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),
+            (r'"(\\\\|\\"|[^"])*"', String.Double),
+            (r"'(\\\\|\\'|[^'])*'", String.Single),
+        ]
+    }
+
+
+class KalLexer(RegexLexer):
+    """
+    For `Kal`_ source code.
+
+    .. _Kal: http://rzimmerman.github.io/kal
+
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Kal'
+    aliases = ['kal']
+    filenames = ['*.kal']
+    mimetypes = ['text/kal', 'application/kal']
+
+    flags = re.DOTALL
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'###[^#].*?###', Comment.Multiline),
+            (r'#(?!##[^#]).*?\n', Comment.Single),
+        ],
+        'functiondef': [
+            (r'[$a-zA-Z_][\w\$]*\s*', Name.Function, '#pop'),
+            include('commentsandwhitespace'),
+        ],
+        'classdef': [
+            (r'\binherits\s+from\b', Keyword),
+            (r'[$a-zA-Z_][\w\$]*\s*\n', Name.Class, '#pop'),
+            (r'[$a-zA-Z_][\w\$]*\s*', Name.Class),
+            include('commentsandwhitespace'),
+        ],
+        'listcomprehension': [
+            (r'\]', Punctuation, '#pop'),
+            (r'\b(property|value)\b', Keyword),
+            include('root'),
+        ],
+        'waitfor': [
+            (r'\n', Punctuation, '#pop'),
+            (r'\bfrom\b', Keyword),
+            include('root'),
+        ],
+        'root': [
+            include('commentsandwhitespace'),
+            (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
+             r'([gim]+\b|\B)', String.Regex),
+            (r'\?|:|_(?=\n)|==?|!=|-(?!>)|[<>+*/-]=?',
+             Operator),
+            (r'\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|'
+             r'\bbut\b|\bbitwise\b|\bmod\b|\^|\bxor\b|\bexists\b|\bdoesnt\s+exist\b',
+             Operator.Word),
+            (r'(?:\([^()]+\))?\s*>', Name.Function),
+            (r'[{(]', Punctuation),
+            (r'\[', Punctuation, 'listcomprehension'),
+            (r'[})\]\.\,]', Punctuation),
+            (r'\b(function|method|task)\b', Keyword.Declaration, 'functiondef'),
+            (r'\bclass\b', Keyword.Declaration, 'classdef'),
+            (r'\b(safe\s+)?wait\s+for\b', Keyword, 'waitfor'),
+            (r'\b(me|this)(\.[$a-zA-Z_][\w\.\$]*)?\b', Name.Variable.Instance),
+            (r'(?<![\.\$])(for(\s+(parallel|series))?|in|of|while|until|'
+             r'break|return|continue|'
+             r'when|if|unless|else|otherwise|except\s+when|'
+             r'throw|raise|fail\s+with|try|catch|finally|new|delete|'
+             r'typeof|instanceof|super|run\s+in\s+parallel|'
+             r'inherits\s+from)\b', Keyword),
+            (r'(?<![\.\$])(true|false|yes|no|on|off|null|nothing|none|'
+             r'NaN|Infinity|undefined)\b',
+             Keyword.Constant),
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|'
+             r'print)\b',
+             Name.Builtin),
+            (r'[$a-zA-Z_][\w\.\$]*\s*(:|[\+\-\*\/]?\=)?\b', Name.Variable),
+            (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'),
+            ('"', String, 'dqs'),
+            ("'", String, 'sqs'),
+        ],
+        'strings': [
+            (r'[^#\\\'"]+', String),
+            # note that all kal strings are multi-line.
+            # hashmarks, quotes and backslashes must be parsed one at a time
+        ],
+        'interpoling_string': [
+            (r'}', String.Interpol, "#pop"),
+            include('root')
+        ],
+        'dqs': [
+            (r'"', String, '#pop'),
+            (r'\\.|\'', String),  # double-quoted string don't need ' escapes
+            (r'#{', String.Interpol, "interpoling_string"),
+            include('strings')
+        ],
+        'sqs': [
+            (r"'", String, '#pop'),
+            (r'#|\\.|"', String),  # single quoted strings don't need " escapses
+            include('strings')
+        ],
+        'tdqs': [
+            (r'"""', String, '#pop'),
+            (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
+            (r'#{', String.Interpol, "interpoling_string"),
+            include('strings'),
+        ],
+        'tsqs': [
+            (r"'''", String, '#pop'),
+            (r'#|\\.|\'|"', String),  # no need to escape quotes in triple-strings
+            include('strings')
+        ],
+    }
+
+
+class LiveScriptLexer(RegexLexer):
+    """
+    For `LiveScript`_ source code.
+
+    .. _LiveScript: http://gkz.github.com/LiveScript/
+
+    New in Pygments 1.6.
+    """
+
+    name = 'LiveScript'
+    aliases = ['live-script', 'livescript']
+    filenames = ['*.ls']
+    mimetypes = ['text/livescript']
+
+    flags = re.DOTALL
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (r'#.*?\n', Comment.Single),
+        ],
+        'multilineregex': [
+            include('commentsandwhitespace'),
+            (r'//([gim]+\b|\B)', String.Regex, '#pop'),
+            (r'/', String.Regex),
+            (r'[^/#]+', String.Regex)
+        ],
+        'slashstartsregex': [
+            include('commentsandwhitespace'),
+            (r'//', String.Regex, ('#pop', 'multilineregex')),
+            (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
+             r'([gim]+\b|\B)', String.Regex, '#pop'),
+            default('#pop'),
+        ],
+        'root': [
+            # this next expr leads to infinite loops root -> slashstartsregex
+            # (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
+            include('commentsandwhitespace'),
+            (r'(?:\([^()]+\))?[ ]*[~-]{1,2}>|'
+             r'(?:\(?[^()\n]+\)?)?[ ]*<[~-]{1,2}', Name.Function),
+            (r'\+\+|&&|(?<![\.\$])\b(?:and|x?or|is|isnt|not)\b|\?|:|=|'
+             r'\|\||\\(?=\n)|(<<|>>>?|==?|!=?|'
+             r'~(?!\~?>)|-(?!\-?>)|<(?!\[)|(?<!\])>|'
+             r'[+*`%&\|\^/])=?',
+             Operator, 'slashstartsregex'),
+            (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
+            (r'[})\].]', Punctuation),
+            (r'(?<![\.\$])(for|own|in|of|while|until|loop|break|'
+             r'return|continue|switch|when|then|if|unless|else|'
+             r'throw|try|catch|finally|new|delete|typeof|instanceof|super|'
+             r'extends|this|class|by|const|var|to|til)\b', Keyword,
+             'slashstartsregex'),
+            (r'(?<![\.\$])(true|false|yes|no|on|off|'
+             r'null|NaN|Infinity|undefined|void)\b',
+             Keyword.Constant),
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
+             Name.Builtin),
+            (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'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?(?:[a-zA-Z_]+)?', Number.Float),
+            (r'[0-9]+(~[0-9a-z]+)?(?:[a-zA-Z_]+)?', Number.Integer),
+            ('"""', String, 'tdqs'),
+            ("'''", String, 'tsqs'),
+            ('"', String, 'dqs'),
+            ("'", String, 'sqs'),
+            (r'\\\S+', String),
+            (r'<\[.*?\]>', String),
+        ],
+        'strings': [
+            (r'[^#\\\'"]+', String),
+            # note that all coffee script strings are multi-line.
+            # hashmarks, quotes and backslashes must be parsed one at a time
+        ],
+        'interpoling_string': [
+            (r'}', String.Interpol, "#pop"),
+            include('root')
+        ],
+        'dqs': [
+            (r'"', String, '#pop'),
+            (r'\\.|\'', String),  # double-quoted string don't need ' escapes
+            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#', String),
+            include('strings')
+        ],
+        'sqs': [
+            (r"'", String, '#pop'),
+            (r'#|\\.|"', String),  # single quoted strings don't need " escapses
+            include('strings')
+        ],
+        'tdqs': [
+            (r'"""', String, '#pop'),
+            (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
+            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#', String),
+            include('strings'),
+        ],
+        'tsqs': [
+            (r"'''", String, '#pop'),
+            (r'#|\\.|\'|"', String),  # no need to escape quotes in triple-strings
+            include('strings')
+        ],
+    }
+
+
+class DartLexer(RegexLexer):
+    """
+    For `Dart <http://dartlang.org/>`_ source code.
+
+    .. versionadded:: 1.5
+    """
+
+    name = 'Dart'
+    aliases = ['dart']
+    filenames = ['*.dart']
+    mimetypes = ['text/x-dart']
+
+    flags = re.MULTILINE | re.DOTALL
+
+    tokens = {
+        'root': [
+            include('string_literal'),
+            (r'#!(.*?)$', Comment.Preproc),
+            (r'\b(import|export)\b', Keyword, 'import_decl'),
+            (r'\b(library|source|part of|part)\b', Keyword),
+            (r'[^\S\n]+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (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'native|operator|set|static|typedef|var)\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),
+            (r'0[xX][0-9a-fA-F]+', Number.Hex),
+            # DIGIT+ (‘.’ DIGIT*)? EXPONENT?
+            (r'\d+(\.\d*)?([eE][+-]?\d+)?', Number),
+            (r'\.\d+([eE][+-]?\d+)?', Number),  # ‘.’ DIGIT+ EXPONENT?
+            (r'\n', Text)
+            # pseudo-keyword negate intentionally left out
+        ],
+        'class': [
+            (r'[a-zA-Z_$]\w*', Name.Class, '#pop')
+        ],
+        'import_decl': [
+            include('string_literal'),
+            (r'\s+', Text),
+            (r'\b(as|show|hide)\b', Keyword),
+            (r'[a-zA-Z_$]\w*', Name),
+            (r'\,', Punctuation),
+            (r'\;', Punctuation, '#pop')
+        ],
+        'string_literal': [
+            # Raw strings.
+            (r'r"""([\s|\S]*?)"""', String.Double),
+            (r"r'''([\s|\S]*?)'''", String.Single),
+            (r'r"(.*?)"', String.Double),
+            (r"r'(.*?)'", String.Single),
+            # Normal Strings.
+            (r'"""', String.Double, 'string_double_multiline'),
+            (r"'''", String.Single, 'string_single_multiline'),
+            (r'"', String.Double, 'string_double'),
+            (r"'", String.Single, 'string_single')
+        ],
+        'string_common': [
+            (r"\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z\'\"$\\])",
+             String.Escape),
+            (r'(\$)([a-zA-Z_]\w*)', bygroups(String.Interpol, Name)),
+            (r'(\$\{)(.*?)(\})',
+             bygroups(String.Interpol, using(this), String.Interpol))
+        ],
+        'string_double': [
+            (r'"', String.Double, '#pop'),
+            (r'[^\"$\\\n]+', String.Double),
+            include('string_common'),
+            (r'\$+', String.Double)
+        ],
+        'string_double_multiline': [
+            (r'"""', String.Double, '#pop'),
+            (r'[^\"$\\]+', String.Double),
+            include('string_common'),
+            (r'(\$|\")+', String.Double)
+        ],
+        'string_single': [
+            (r"'", String.Single, '#pop'),
+            (r"[^\'$\\\n]+", String.Single),
+            include('string_common'),
+            (r'\$+', String.Single)
+        ],
+        'string_single_multiline': [
+            (r"'''", String.Single, '#pop'),
+            (r'[^\'$\\]+', String.Single),
+            include('string_common'),
+            (r'(\$|\')+', String.Single)
+        ]
+    }
+
+
+class TypeScriptLexer(RegexLexer):
+    """
+    For `TypeScript <http://typescriptlang.org/>`_ source code.
+
+    .. versionadded:: 1.6
+    """
+
+    name = 'TypeScript'
+    aliases = ['ts']
+    filenames = ['*.ts']
+    mimetypes = ['text/x-typescript']
+
+    flags = re.DOTALL
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'<!--', Comment),
+            (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'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
+             r'(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?', Operator, 'slashstartsregex'),
+            (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|'
+             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|'
+             r'extends|final|float|goto|implements|import|int|interface|long|native|'
+             r'package|private|protected|public|short|static|super|synchronized|throws|'
+             r'transient|volatile)\b', Keyword.Reserved),
+            (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
+             r'window)\b', Name.Builtin),
+            # Match stuff like: module name {...}
+            (r'\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)',
+             bygroups(Keyword.Reserved, Text, Name.Other, Text), 'slashstartsregex'),
+            # Match variable type keywords
+            (r'\b(string|bool|number)\b', Keyword.Type),
+            # Match stuff like: constructor
+            (r'\b(constructor|declare|interface|as|AS)\b', Keyword.Reserved),
+            # Match stuff like: super(argument, list)
+            (r'(super)(\s*)(\([a-zA-Z0-9,_?.$\s]+\s*\))',
+             bygroups(Keyword.Reserved, Text), 'slashstartsregex'),
+            # Match stuff like: function() {...}
+            (r'([a-zA-Z_?.$][\w?.$]*)\(\) \{', Name.Other, 'slashstartsregex'),
+            # Match stuff like: (function: return type)
+            (r'([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)',
+             bygroups(Name.Other, Text, Keyword.Type)),
+            (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),
+            (r'"(\\\\|\\"|[^"])*"', String.Double),
+            (r"'(\\\\|\\'|[^'])*'", String.Single),
+        ]
+    }
+
+
+class LassoLexer(RegexLexer):
+    """
+    For `Lasso <http://www.lassosoft.com/>`_ source code, covering both Lasso 9
+    syntax and LassoScript for Lasso 8.6 and earlier. For Lasso embedded in
+    HTML, use the `LassoHtmlLexer`.
+
+    Additional options accepted:
+
+    `builtinshighlighting`
+        If given and ``True``, highlight builtin types, traits, methods, and
+        members (default: ``True``).
+    `requiredelimiters`
+        If given and ``True``, only highlight code between delimiters as Lasso
+        (default: ``False``).
+
+    .. versionadded:: 1.6
+    """
+
+    name = 'Lasso'
+    aliases = ['lasso', 'lassoscript']
+    filenames = ['*.lasso', '*.lasso[89]']
+    alias_filenames = ['*.incl', '*.inc', '*.las']
+    mimetypes = ['text/x-lasso']
+    flags = re.IGNORECASE | re.DOTALL | re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'^#!.+lasso9\b', Comment.Preproc, 'lasso'),
+            (r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'),
+            (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'<(!--.*?-->)?', Other),
+            (r'[^[<]+', Other),
+        ],
+        'nosquarebrackets': [
+            (r'<\?(LassoScript|lasso|=)', Comment.Preproc, 'anglebrackets'),
+            (r'<', Other),
+            (r'[^<]+', Other),
+        ],
+        'noprocess': [
+            (r'\[/noprocess\]', Comment.Preproc, '#pop'),
+            (r'\[', Other),
+            (r'[^[]', Other),
+        ],
+        'squarebrackets': [
+            (r'\]', Comment.Preproc, '#pop'),
+            include('lasso'),
+        ],
+        'anglebrackets': [
+            (r'\?>', Comment.Preproc, '#pop'),
+            include('lasso'),
+        ],
+        'lassofile': [
+            (r'\]|\?>', Comment.Preproc, '#pop'),
+            include('lasso'),
+        ],
+        'whitespacecomments': [
+            (r'\s+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*\*!.*?\*/', String.Doc),
+            (r'/\*.*?\*/', Comment.Multiline),
+        ],
+        'lasso': [
+            # whitespace/comments
+            include('whitespacecomments'),
+
+            # literals
+            (r'\d*\.\d+(e[+-]?\d+)?', Number.Float),
+            (r'0x[\da-f]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            (r'([+-]?)(infinity|NaN)\b', bygroups(Operator, Number)),
+            (r"'", String.Single, 'singlestring'),
+            (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.]*')",
+                bygroups(Name.Builtin.Pseudo, Name.Variable.Class)),
+            (r"(self)(\s*->\s*)('[a-z_][\w.]*')",
+                bygroups(Name.Builtin.Pseudo, Operator, Name.Variable.Class)),
+            (r'(\.\.?)([a-z_][\w.]*(=(?!=))?)',
+                bygroups(Name.Builtin.Pseudo, Name.Other.Member)),
+            (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
+                bygroups(Operator, Name.Other.Member)),
+            (r'(self|inherited)\b', Name.Builtin.Pseudo),
+            (r'-[a-z_][\w.]*', Name.Attribute),
+            (r'::\s*[a-z_][\w.]*', Name.Label),
+            (r'(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|'
+             r'Error_DatabaseConnectionUnavailable|Error_DatabaseTimeout|'
+             r'Error_DeleteError|Error_FieldRestriction|Error_FileNotFound|'
+             r'Error_InvalidDatabase|Error_InvalidPassword|'
+             r'Error_InvalidUsername|Error_ModuleNotFound|'
+             r'Error_NoError|Error_NoPermission|Error_OutOfMemory|'
+             r'Error_ReqColumnMissing|Error_ReqFieldMissing|'
+             r'Error_RequiredColumnMissing|Error_RequiredFieldMissing|'
+             r'Error_UpdateError)\b', Name.Exception),
+
+            # definitions
+            (r'(define)(\s+)([a-z_][\w.]*)(\s*=>\s*)(type|trait|thread)\b',
+                bygroups(Keyword.Declaration, Text, Name.Class, Operator, Keyword)),
+            (r'(define)(\s+)([a-z_][\w.]*)(\s*->\s*)([a-z_][\w.]*=?|[-+*/%])',
+                bygroups(Keyword.Declaration, Text, Name.Class, Operator,
+                         Name.Function), 'signature'),
+            (r'(define)(\s+)([a-z_][\w.]*)',
+                bygroups(Keyword.Declaration, Text, Name.Function), 'signature'),
+            (r'(public|protected|private|provide)(\s+)(([a-z_][\w.]*=?|[-+*/%])'
+             r'(?=\s*\())', bygroups(Keyword, Text, Name.Function),
+                'signature'),
+            (r'(public|protected|private|provide)(\s+)([a-z_][\w.]*)',
+                bygroups(Keyword, Text, Name.Function)),
+
+            # keywords
+            (r'(true|false|none|minimal|full|all|void)\b', Keyword.Constant),
+            (r'(local|var|variable|global|data(?=\s))\b', Keyword.Declaration),
+            (r'(array|date|decimal|duration|integer|map|pair|string|tag|xml|'
+             r'null|bytes|list|queue|set|stack|staticarray|tie)\b', Keyword.Type),
+            (r'([a-z_][\w.]*)(\s+)(in)\b', bygroups(Name, Text, Keyword)),
+            (r'(let|into)(\s+)([a-z_][\w.]*)', bygroups(Keyword, Text, Name)),
+            (r'require\b', Keyword, 'requiresection'),
+            (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_FirstRecord|Link_LastGroup|Link_LastRecord|Link_NextGroup|'
+             r'Link_NextRecord|Link_PrevGroup|Link_PrevRecord|Log|Loop|'
+             r'NoProcess|Output_None|Portal|Private|Protect|Records|Referer|'
+             r'Referrer|Repeating|ResultSet|Rows|Search_Args|Search_Arguments|'
+             r'Select|Sort_Args|Sort_Arguments|Thread_Atomic|Value_List|While|'
+             r'Abort|Case|Else|If_Empty|If_False|If_Null|If_True|Loop_Abort|'
+             r'Loop_Continue|Loop_Count|Params|Params_Up|Return|Return_Value|'
+             r'Run_Children|SOAP_DefineTag|SOAP_LastRequest|SOAP_LastResponse|'
+             r'Tag_Name|ascending|average|by|define|descending|do|equals|'
+             r'frozen|group|handle_failure|import|in|into|join|let|match|max|'
+             r'min|on|order|parent|protected|provide|public|require|returnhome|'
+             r'skip|split_thread|sum|take|thread|to|trait|type|where|with|'
+             r'yield|yieldhome)\b',
+                bygroups(Punctuation, Keyword)),
+
+            # other
+            (r',', Punctuation, 'commamember'),
+            (r'(and|or|not)\b', Operator.Word),
+            (r'([a-z_][\w.]*)(\s*::\s*[a-z_][\w.]*)?(\s*=(?!=))',
+                bygroups(Name, Name.Label, Operator)),
+            (r'(/?)([\w.]+)', bygroups(Punctuation, Name.Other)),
+            (r'(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b',
+                bygroups(Operator, Operator.Word)),
+            (r':=|[-+*/%=<>&|!?\\]+', Operator),
+            (r'[{}():;,@^]', Punctuation),
+        ],
+        'singlestring': [
+            (r"'", String.Single, '#pop'),
+            (r"[^'\\]+", String.Single),
+            include('escape'),
+            (r"\\", String.Single),
+        ],
+        'doublestring': [
+            (r'"', String.Double, '#pop'),
+            (r'[^"\\]+', String.Double),
+            include('escape'),
+            (r'\\', String.Double),
+        ],
+        'escape': [
+            (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:]+:|'
+             r'[abefnrtv?\"\'\\]|$)', String.Escape),
+        ],
+        'signature': [
+            (r'=>', Operator, '#pop'),
+            (r'\)', Punctuation, '#pop'),
+            (r'[(,]', Punctuation, 'parameter'),
+            include('lasso'),
+        ],
+        'parameter': [
+            (r'\)', Punctuation, '#pop'),
+            (r'-?[a-z_][\w.]*', Name.Attribute, '#pop'),
+            (r'\.\.\.', Name.Builtin.Pseudo),
+            include('lasso'),
+        ],
+        'requiresection': [
+            (r'(([a-z_][\w.]*=?|[-+*/%])(?=\s*\())', Name, 'requiresignature'),
+            (r'(([a-z_][\w.]*=?|[-+*/%])(?=(\s*::\s*[\w.]+)?\s*,))', Name),
+            (r'[a-z_][\w.]*=?|[-+*/%]', Name, '#pop'),
+            (r'::\s*[a-z_][\w.]*', Name.Label),
+            (r',', Punctuation),
+            include('whitespacecomments'),
+        ],
+        'requiresignature': [
+            (r'(\)(?=(\s*::\s*[\w.]+)?\s*,))', Punctuation, '#pop'),
+            (r'\)', Punctuation, '#pop:2'),
+            (r'-?[a-z_][\w.]*', Name.Attribute),
+            (r'::\s*[a-z_][\w.]*', Name.Label),
+            (r'\.\.\.', Name.Builtin.Pseudo),
+            (r'[(,]', Punctuation),
+            include('whitespacecomments'),
+        ],
+        'commamember': [
+            (r'(([a-z_][\w.]*=?|[-+*/%])'
+             r'(?=\s*(\(([^()]*\([^()]*\))*[^)]*\)\s*)?(::[\w.\s]+)?=>))',
+                Name.Function, 'signature'),
+            include('whitespacecomments'),
+            default('#pop'),
+        ],
+    }
+
+    def __init__(self, **options):
+        self.builtinshighlighting = get_bool_opt(
+            options, 'builtinshighlighting', True)
+        self.requiredelimiters = get_bool_opt(
+            options, 'requiredelimiters', False)
+
+        self._builtins = set()
+        self._members = set()
+        if self.builtinshighlighting:
+            from pygments.lexers._lassobuiltins import BUILTINS, MEMBERS
+            for key, value in iteritems(BUILTINS):
+                self._builtins.update(value)
+            for key, value in iteritems(MEMBERS):
+                self._members.update(value)
+        RegexLexer.__init__(self, **options)
+
+    def get_tokens_unprocessed(self, text):
+        stack = ['root']
+        if self.requiredelimiters:
+            stack.append('delimiters')
+        for index, token, value in \
+                RegexLexer.get_tokens_unprocessed(self, text, stack):
+            if (token is Name.Other and value.lower() in self._builtins or
+                    token is Name.Other.Member and
+                    value.lower().rstrip('=') in self._members):
+                yield index, Name.Builtin, value
+                continue
+            yield index, token, value
+
+    def analyse_text(text):
+        rv = 0.0
+        if 'bin/lasso9' in text:
+            rv += 0.8
+        if re.search(r'<\?(=|lasso)|\A\[', text, re.I):
+            rv += 0.4
+        if re.search(r'local\(', text, re.I):
+            rv += 0.4
+        if '?>' in text:
+            rv += 0.1
+        return rv
+
+
+class ObjectiveJLexer(RegexLexer):
+    """
+    For Objective-J source code with preprocessor directives.
+
+    .. versionadded:: 1.3
+    """
+
+    name = 'Objective-J'
+    aliases = ['objective-j', 'objectivej', 'obj-j', 'objj']
+    filenames = ['*.j']
+    mimetypes = ['text/x-objective-j']
+
+    #: optional Comment or Whitespace
+    _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)*'
+
+    flags = re.DOTALL | re.MULTILINE
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+
+            # function definition
+            (r'^(' + _ws + r'[\+-]' + _ws + r')([\(a-zA-Z_].*?[^\(])(' + _ws + '{)',
+             bygroups(using(this), using(this, state='function_signature'),
+                      using(this))),
+
+            # class definition
+            (r'(@interface|@implementation)(\s+)', bygroups(Keyword, Text),
+             'classname'),
+            (r'(@class|@protocol)(\s*)', bygroups(Keyword, Text),
+             'forward_classname'),
+            (r'(\s*)(@end)(\s*)', bygroups(Text, Keyword, Text)),
+
+            include('statements'),
+            ('[{\(\)}]', Punctuation),
+            (';', Punctuation),
+        ],
+        'whitespace': [
+            (r'(@import)(\s+)("(?:\\\\|\\"|[^"])*")',
+             bygroups(Comment.Preproc, Text, String.Double)),
+            (r'(@import)(\s+)(<(?:\\\\|\\>|[^>])*>)',
+             bygroups(Comment.Preproc, Text, String.Double)),
+            (r'(#(?:include|import))(\s+)("(?:\\\\|\\"|[^"])*")',
+             bygroups(Comment.Preproc, Text, String.Double)),
+            (r'(#(?:include|import))(\s+)(<(?:\\\\|\\>|[^>])*>)',
+             bygroups(Comment.Preproc, Text, String.Double)),
+
+            (r'#if\s+0', Comment.Preproc, 'if0'),
+            (r'#', Comment.Preproc, 'macro'),
+
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),  # line continuation
+            (r'//(\n|(.|\n)*?[^\\]\n)', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+            (r'<!--', Comment),
+        ],
+        'slashstartsregex': [
+            include('whitespace'),
+            (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
+             r'([gim]+\b|\B)', String.Regex, '#pop'),
+            (r'(?=/)', Text, ('#pop', 'badregex')),
+            default('#pop'),
+        ],
+        'badregex': [
+            (r'\n', Text, '#pop'),
+        ],
+        'statements': [
+            (r'(L|@)?"', String, 'string'),
+            (r"(L|@)?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'",
+             String.Char),
+            (r'"(\\\\|\\"|[^"])*"', String.Double),
+            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
+            (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
+            (r'0[0-7]+[Ll]?', Number.Oct),
+            (r'\d+[Ll]?', Number.Integer),
+
+            (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
+
+            (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
+             r'(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?',
+             Operator, 'slashstartsregex'),
+            (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
+            (r'[})\].]', Punctuation),
+
+            (r'(for|in|while|do|break|return|continue|switch|case|default|if|'
+             r'else|throw|try|catch|finally|new|delete|typeof|instanceof|void|'
+             r'prototype|__proto__)\b', Keyword, 'slashstartsregex'),
+
+            (r'(var|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
+
+            (r'(@selector|@private|@protected|@public|@encode|'
+             r'@synchronized|@try|@throw|@catch|@finally|@end|@property|'
+             r'@synthesize|@dynamic|@for|@accessors|new)\b', Keyword),
+
+            (r'(int|long|float|short|double|char|unsigned|signed|void|'
+             r'id|BOOL|bool|boolean|IBOutlet|IBAction|SEL|@outlet|@action)\b',
+             Keyword.Type),
+
+            (r'(self|super)\b', Name.Builtin),
+
+            (r'(TRUE|YES|FALSE|NO|Nil|nil|NULL)\b', Keyword.Constant),
+            (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
+            (r'(ABS|ASIN|ACOS|ATAN|ATAN2|SIN|COS|TAN|EXP|POW|CEIL|FLOOR|ROUND|'
+             r'MIN|MAX|RAND|SQRT|E|LN2|LN10|LOG2E|LOG10E|PI|PI2|PI_2|SQRT1_2|'
+             r'SQRT2)\b', Keyword.Constant),
+
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
+             r'window)\b', Name.Builtin),
+
+            (r'([$a-zA-Z_]\w*)(' + _ws + r')(?=\()',
+             bygroups(Name.Function, using(this))),
+
+            (r'[$a-zA-Z_]\w*', Name),
+        ],
+        'classname': [
+            # interface definition that inherits
+            (r'([a-zA-Z_]\w*)(' + _ws + r':' + _ws +
+             r')([a-zA-Z_]\w*)?',
+             bygroups(Name.Class, using(this), Name.Class), '#pop'),
+            # interface definition for a category
+            (r'([a-zA-Z_]\w*)(' + _ws + r'\()([a-zA-Z_]\w*)(\))',
+             bygroups(Name.Class, using(this), Name.Label, Text), '#pop'),
+            # simple interface / implementation
+            (r'([a-zA-Z_]\w*)', Name.Class, '#pop'),
+        ],
+        'forward_classname': [
+            (r'([a-zA-Z_]\w*)(\s*,\s*)',
+             bygroups(Name.Class, Text), '#push'),
+            (r'([a-zA-Z_]\w*)(\s*;?)',
+             bygroups(Name.Class, Text), '#pop'),
+        ],
+        'function_signature': [
+            include('whitespace'),
+
+            # start of a selector w/ parameters
+            (r'(\(' + _ws + r')'                # open paren
+             r'([a-zA-Z_]\w+)'                  # return type
+             r'(' + _ws + r'\)' + _ws + r')'    # close paren
+             r'([$a-zA-Z_]\w+' + _ws + r':)',   # function name
+             bygroups(using(this), Keyword.Type, using(this),
+                      Name.Function), 'function_parameters'),
+
+            # no-param function
+            (r'(\(' + _ws + r')'                # open paren
+             r'([a-zA-Z_]\w+)'                  # return type
+             r'(' + _ws + r'\)' + _ws + r')'    # close paren
+             r'([$a-zA-Z_]\w+)',                # function name
+             bygroups(using(this), Keyword.Type, using(this),
+                      Name.Function), "#pop"),
+
+            # no return type given, start of a selector w/ parameters
+            (r'([$a-zA-Z_]\w+' + _ws + r':)',   # function name
+             bygroups(Name.Function), 'function_parameters'),
+
+            # no return type given, no-param function
+            (r'([$a-zA-Z_]\w+)',                # function name
+             bygroups(Name.Function), "#pop"),
+
+            ('', Text, '#pop'),
+        ],
+        'function_parameters': [
+            include('whitespace'),
+
+            # parameters
+            (r'(\(' + _ws + ')'                 # open paren
+             r'([^\)]+)'                        # type
+             r'(' + _ws + r'\)' + _ws + r')'    # close paren
+             r'([$a-zA-Z_]\w+)',      # param name
+             bygroups(using(this), Keyword.Type, using(this), Text)),
+
+            # one piece of a selector name
+            (r'([$a-zA-Z_]\w+' + _ws + r':)',   # function name
+             Name.Function),
+
+            # smallest possible selector piece
+            (r'(:)', Name.Function),
+
+            # var args
+            (r'(,' + _ws + r'\.\.\.)', using(this)),
+
+            # param name
+            (r'([$a-zA-Z_]\w+)', Text),
+        ],
+        'expression': [
+            (r'([$a-zA-Z_]\w*)(\()', bygroups(Name.Function,
+                                              Punctuation)),
+            (r'(\))', Punctuation, "#pop"),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\\n', String),  # line continuation
+            (r'\\', String),  # stray backslash
+        ],
+        'macro': [
+            (r'[^/\n]+', Comment.Preproc),
+            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
+            (r'//.*?\n', Comment.Single, '#pop'),
+            (r'/', Comment.Preproc),
+            (r'(?<=\\)\n', Comment.Preproc),
+            (r'\n', Comment.Preproc, '#pop'),
+        ],
+        'if0': [
+            (r'^\s*#if.*?(?<!\\)\n', Comment.Preproc, '#push'),
+            (r'^\s*#endif.*?(?<!\\)\n', Comment.Preproc, '#pop'),
+            (r'.*?\n', Comment),
+        ]
+    }
+
+    def analyse_text(text):
+        if re.search('^\s*@import\s+[<"]', text, re.MULTILINE):
+            # special directive found in most Objective-J files
+            return True
+        return False
+
+
+class CoffeeScriptLexer(RegexLexer):
+    """
+    For `CoffeeScript`_ source code.
+
+    .. _CoffeeScript: http://coffeescript.org
+
+    .. versionadded:: 1.3
+    """
+
+    name = 'CoffeeScript'
+    aliases = ['coffee-script', 'coffeescript', 'coffee']
+    filenames = ['*.coffee']
+    mimetypes = ['text/coffeescript']
+
+    flags = re.DOTALL
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'###[^#].*?###', Comment.Multiline),
+            (r'#(?!##[^#]).*?\n', Comment.Single),
+        ],
+        'multilineregex': [
+            (r'[^/#]+', String.Regex),
+            (r'///([gim]+\b|\B)', String.Regex, '#pop'),
+            (r'#{', String.Interpol, 'interpoling_string'),
+            (r'[/#]', String.Regex),
+        ],
+        'slashstartsregex': [
+            include('commentsandwhitespace'),
+            (r'///', String.Regex, ('#pop', 'multilineregex')),
+            (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
+             r'([gim]+\b|\B)', String.Regex, '#pop'),
+            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'\|\||\\(?=\n)|'
+             r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?',
+             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'throw|try|catch|finally|new|delete|typeof|instanceof|super|'
+             r'extends|this|class|by)\b', Keyword, 'slashstartsregex'),
+            (r'(?<![\.\$])(true|false|yes|no|on|off|null|'
+             r'NaN|Infinity|undefined)\b',
+             Keyword.Constant),
+            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
+             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'decodeURIComponent|encodeURI|encodeURIComponent|'
+             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
+             Name.Builtin),
+            (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'[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'),
+            ('"', String, 'dqs'),
+            ("'", String, 'sqs'),
+        ],
+        'strings': [
+            (r'[^#\\\'"]+', String),
+            # note that all coffee script strings are multi-line.
+            # hashmarks, quotes and backslashes must be parsed one at a time
+        ],
+        'interpoling_string': [
+            (r'}', String.Interpol, "#pop"),
+            include('root')
+        ],
+        'dqs': [
+            (r'"', String, '#pop'),
+            (r'\\.|\'', String),  # double-quoted string don't need ' escapes
+            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#', String),
+            include('strings')
+        ],
+        'sqs': [
+            (r"'", String, '#pop'),
+            (r'#|\\.|"', String),  # single quoted strings don't need " escapses
+            include('strings')
+        ],
+        'tdqs': [
+            (r'"""', String, '#pop'),
+            (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
+            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#', String),
+            include('strings'),
+        ],
+        'tsqs': [
+            (r"'''", String, '#pop'),
+            (r'#|\\.|\'|"', String),  # no need to escape quotes in triple-strings
+            include('strings')
+        ],
+    }
+
+
+class MaskLexer(RegexLexer):
+    """
+    For `Mask <http://github.com/atmajs/MaskJS>`__ markup.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Mask'
+    aliases = ['mask']
+    filenames = ['*.mask']
+    mimetypes = ['text/x-mask']
+
+    flags = re.MULTILINE | re.IGNORECASE | re.DOTALL
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (r'[\{\};>]', Punctuation),
+            (r"'''", String, 'string-trpl-single'),
+            (r'"""', String, 'string-trpl-double'),
+            (r"'", String, 'string-single'),
+            (r'"', String, 'string-double'),
+            (r'([\w-]+)', Name.Tag, 'node'),
+            (r'([^\.#;{>\s]+)', Name.Class, 'node'),
+            (r'(#[\w-]+)', Name.Function, 'node'),
+            (r'(\.[\w-]+)', Name.Variable.Class, 'node')
+        ],
+        'string-base': [
+            (r'\\.', String.Escape),
+            (r'~\[', String.Interpol, 'interpolation'),
+            (r'.', String.Single),
+        ],
+        'string-single': [
+            (r"'", String.Single, '#pop'),
+            include('string-base')
+        ],
+        'string-double': [
+            (r'"', String.Single, '#pop'),
+            include('string-base')
+        ],
+        'string-trpl-single': [
+            (r"'''", String.Single, '#pop'),
+            include('string-base')
+        ],
+        'string-trpl-double': [
+            (r'"""', String.Single, '#pop'),
+            include('string-base')
+        ],
+        'interpolation': [
+            (r'\]', String.Interpol, '#pop'),
+            (r'\s*:', String.Interpol, 'expression'),
+            (r'\s*\w+:', Name.Other),
+            (r'[^\]]+', String.Interpol)
+        ],
+        'expression': [
+            (r'[^\]]+', using(JavascriptLexer), '#pop')
+        ],
+        'node': [
+            (r'\s+', Text),
+            (r'\.', Name.Variable.Class, 'node-class'),
+            (r'\#', Name.Function, 'node-id'),
+            (r'style[ \t]*=', Name.Attribute, 'node-attr-style-value'),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'node-attr-value'),
+            (r'[\w:-]+', Name.Attribute),
+            (r'[>{;]', Punctuation, '#pop')
+        ],
+        'node-class': [
+            (r'[\w-]+', Name.Variable.Class),
+            (r'~\[', String.Interpol, 'interpolation'),
+            default('#pop')
+        ],
+        'node-id': [
+            (r'[\w-]+', Name.Function),
+            (r'~\[', String.Interpol, 'interpolation'),
+            default('#pop')
+        ],
+        'node-attr-value': [
+            (r'\s+', Text),
+            (r'\w+', Name.Variable, '#pop'),
+            (r"'", String, 'string-single-pop2'),
+            (r'"', String, 'string-double-pop2'),
+            default('#pop')
+        ],
+        'node-attr-style-value': [
+            (r'\s+', Text),
+            (r"'", String.Single, 'css-single-end'),
+            (r'"', String.Single, 'css-double-end'),
+            include('node-attr-value')
+        ],
+        'css-base': [
+            (r'\s+', Text),
+            (r";", Punctuation),
+            (r"[\w\-]+\s*:", Name.Builtin)
+        ],
+        'css-single-end': [
+            include('css-base'),
+            (r"'", String.Single, '#pop:2'),
+            (r"[^;']+", Name.Entity)
+        ],
+        'css-double-end': [
+            include('css-base'),
+            (r'"', String.Single, '#pop:2'),
+            (r"[^;\"]+", Name.Entity)
+        ],
+        'string-single-pop2': [
+            (r"'", String.Single, '#pop:2'),
+            include('string-base')
+        ],
+        'string-double-pop2': [
+            (r'"', String.Single, '#pop:2'),
+            include('string-base')
+        ],
+    }
-- 
cgit v1.2.1


From 64fcd7618c5bbae197f66dbe3a1257f062e6b459 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 4 Oct 2014 22:35:59 +0200
Subject: move module names from _XXXbuiltins to _XXX_builtins to be consistent

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 6e4e07e8..968436ed 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -713,7 +713,7 @@ class LassoLexer(RegexLexer):
         self._builtins = set()
         self._members = set()
         if self.builtinshighlighting:
-            from pygments.lexers._lassobuiltins import BUILTINS, MEMBERS
+            from pygments.lexers._lasso_builtins import BUILTINS, MEMBERS
             for key, value in iteritems(BUILTINS):
                 self._builtins.update(value)
             for key, value in iteritems(MEMBERS):
-- 
cgit v1.2.1


From edbf2d93378796fc9838ad5db54e5943f021c03e Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Tue, 7 Oct 2014 13:29:08 -0700
Subject: JavascriptLexer: Support unicode identifiers per standard.

Fixes #999
---
 pygments/lexers/javascript.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 968436ed..8b5f9c76 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -16,11 +16,18 @@ from pygments.lexer import RegexLexer, include, bygroups, default, \
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Other
 from pygments.util import get_bool_opt, iteritems
+import pygments.unistring as uni
 
 __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
            'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
            'CoffeeScriptLexer', 'MaskLexer']
 
+JS_IDENT_START = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
+                  + ']|\\\\u[a-fA-F0-9]{4})')
+JS_IDENT_PART = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
+                 + uni.Mn + uni.Mc + uni.Nd + uni.Pc
+                 + u'\u200c\u200d]|\\\\u[a-fA-F0-9]{4})')
+JS_IDENT = JS_IDENT_START + '(?:' + JS_IDENT_PART + ')*'
 
 class JavascriptLexer(RegexLexer):
     """
@@ -72,7 +79,7 @@ class JavascriptLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
              r'window)\b', Name.Builtin),
-            (r'[$a-zA-Z_]\w*', Name.Other),
+            (JS_IDENT, 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),
-- 
cgit v1.2.1


From 5e0079de2c9979c52e9149458260c6d582c0f9e2 Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Wed, 15 Oct 2014 08:00:06 -0700
Subject: Use unistring.combine for slight speedup.

---
 pygments/lexers/javascript.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 8b5f9c76..95286fdf 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -22,11 +22,11 @@ __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
            'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
            'CoffeeScriptLexer', 'MaskLexer']
 
-JS_IDENT_START = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
-                  + ']|\\\\u[a-fA-F0-9]{4})')
-JS_IDENT_PART = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
-                 + uni.Mn + uni.Mc + uni.Nd + uni.Pc
-                 + u'\u200c\u200d]|\\\\u[a-fA-F0-9]{4})')
+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') +
+                 u'\u200c\u200d]|\\\\u[a-fA-F0-9]{4})')
 JS_IDENT = JS_IDENT_START + '(?:' + JS_IDENT_PART + ')*'
 
 class JavascriptLexer(RegexLexer):
-- 
cgit v1.2.1


From 178c96e1e86f34997c78e6b3504542e7e151a3a9 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Wed, 15 Oct 2014 21:32:31 +0200
Subject: all lexers: fix unescaped { and } so that the "regex" module can
 compile our regexes

---
 pygments/lexers/javascript.py | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 8b5f9c76..481243ef 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -22,6 +22,7 @@ __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
            'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
            'CoffeeScriptLexer', 'MaskLexer']
 
+
 JS_IDENT_START = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
                   + ']|\\\\u[a-fA-F0-9]{4})')
 JS_IDENT_PART = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
@@ -29,6 +30,7 @@ JS_IDENT_PART = ('(?:[$_' + uni.Lu + uni.Ll + uni.Lt + uni.Lm + uni.Lo + uni.Nl
                  + u'\u200c\u200d]|\\\\u[a-fA-F0-9]{4})')
 JS_IDENT = JS_IDENT_START + '(?:' + JS_IDENT_PART + ')*'
 
+
 class JavascriptLexer(RegexLexer):
     """
     For JavaScript source code.
@@ -178,13 +180,13 @@ class KalLexer(RegexLexer):
             # hashmarks, quotes and backslashes must be parsed one at a time
         ],
         'interpoling_string': [
-            (r'}', String.Interpol, "#pop"),
+            (r'\}', String.Interpol, "#pop"),
             include('root')
         ],
         'dqs': [
             (r'"', String, '#pop'),
             (r'\\.|\'', String),  # double-quoted string don't need ' escapes
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             include('strings')
         ],
         'sqs': [
@@ -195,7 +197,7 @@ class KalLexer(RegexLexer):
         'tdqs': [
             (r'"""', String, '#pop'),
             (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             include('strings'),
         ],
         'tsqs': [
@@ -287,13 +289,13 @@ class LiveScriptLexer(RegexLexer):
             # hashmarks, quotes and backslashes must be parsed one at a time
         ],
         'interpoling_string': [
-            (r'}', String.Interpol, "#pop"),
+            (r'\}', String.Interpol, "#pop"),
             include('root')
         ],
         'dqs': [
             (r'"', String, '#pop'),
             (r'\\.|\'', String),  # double-quoted string don't need ' escapes
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             (r'#', String),
             include('strings')
         ],
@@ -305,7 +307,7 @@ class LiveScriptLexer(RegexLexer):
         'tdqs': [
             (r'"""', String, '#pop'),
             (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             (r'#', String),
             include('strings'),
         ],
@@ -1000,7 +1002,7 @@ class CoffeeScriptLexer(RegexLexer):
         'multilineregex': [
             (r'[^/#]+', String.Regex),
             (r'///([gim]+\b|\B)', String.Regex, '#pop'),
-            (r'#{', String.Interpol, 'interpoling_string'),
+            (r'#\{', String.Interpol, 'interpoling_string'),
             (r'[/#]', String.Regex),
         ],
         'slashstartsregex': [
@@ -1054,13 +1056,13 @@ class CoffeeScriptLexer(RegexLexer):
             # hashmarks, quotes and backslashes must be parsed one at a time
         ],
         'interpoling_string': [
-            (r'}', String.Interpol, "#pop"),
+            (r'\}', String.Interpol, "#pop"),
             include('root')
         ],
         'dqs': [
             (r'"', String, '#pop'),
             (r'\\.|\'', String),  # double-quoted string don't need ' escapes
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             (r'#', String),
             include('strings')
         ],
@@ -1072,7 +1074,7 @@ class CoffeeScriptLexer(RegexLexer):
         'tdqs': [
             (r'"""', String, '#pop'),
             (r'\\.|\'|"', String),  # no need to escape quotes in triple-string
-            (r'#{', String.Interpol, "interpoling_string"),
+            (r'#\{', String.Interpol, "interpoling_string"),
             (r'#', String),
             include('strings'),
         ],
-- 
cgit v1.2.1


From f5a697027576977970c0e1524965771f2d04fa76 Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Wed, 15 Oct 2014 22:46:09 -0700
Subject: Curly brace escaping, round 2.

These were all pointed out by regexlint but required manual effort to track down
(indicator.py was confused by most of them being produced by expressions).

Also comment out some iffy comment patterns.
---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 57870009..4148c6b0 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -776,7 +776,7 @@ class ObjectiveJLexer(RegexLexer):
             include('whitespace'),
 
             # function definition
-            (r'^(' + _ws + r'[\+-]' + _ws + r')([\(a-zA-Z_].*?[^\(])(' + _ws + '{)',
+            (r'^(' + _ws + r'[\+-]' + _ws + r')([\(a-zA-Z_].*?[^\(])(' + _ws + r'\{)',
              bygroups(using(this), using(this, state='function_signature'),
                       using(this))),
 
-- 
cgit v1.2.1


From d7c323f61dc380b045a7297a76c06b52b6481669 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Thu, 16 Oct 2014 09:33:43 +0200
Subject: Fix "matches empty string" complaints from regexlint.

---
 pygments/lexers/javascript.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 4148c6b0..f058ec6d 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -11,8 +11,7 @@
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, default, \
-    using, this
+from pygments.lexer import RegexLexer, include, bygroups, default, using, this
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Other
 from pygments.util import get_bool_opt, iteritems
@@ -918,7 +917,7 @@ class ObjectiveJLexer(RegexLexer):
             (r'([$a-zA-Z_]\w+)',                # function name
              bygroups(Name.Function), "#pop"),
 
-            ('', Text, '#pop'),
+            default('#pop'),
         ],
         'function_parameters': [
             include('whitespace'),
-- 
cgit v1.2.1


From ec7883029c219cfbca7037526dcab76b093b4462 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Thu, 16 Oct 2014 10:01:17 +0200
Subject: More fixes thanks to regexlint.

---
 pygments/lexers/javascript.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index f058ec6d..f7e4e478 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -137,9 +137,8 @@ class KalLexer(RegexLexer):
              r'([gim]+\b|\B)', String.Regex),
             (r'\?|:|_(?=\n)|==?|!=|-(?!>)|[<>+*/-]=?',
              Operator),
-            (r'\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|'
-             r'\bbut\b|\bbitwise\b|\bmod\b|\^|\bxor\b|\bexists\b|\bdoesnt\s+exist\b',
-             Operator.Word),
+            (r'\b(and|or|isnt|is|not|but|bitwise|mod|\^|xor|exists|'
+             r'doesnt\s+exist)\b', Operator.Word),
             (r'(?:\([^()]+\))?\s*>', Name.Function),
             (r'[{(]', Punctuation),
             (r'\[', Punctuation, 'listcomprehension'),
@@ -373,8 +372,8 @@ class DartLexer(RegexLexer):
         ],
         'string_literal': [
             # Raw strings.
-            (r'r"""([\s|\S]*?)"""', String.Double),
-            (r"r'''([\s|\S]*?)'''", String.Single),
+            (r'r"""([\w\W]*?)"""', String.Double),
+            (r"r'''([\w\W]*?)'''", String.Single),
             (r'r"(.*?)"', String.Double),
             (r"r'(.*?)'", String.Single),
             # Normal Strings.
-- 
cgit v1.2.1


From d3c45c2caf8bfb56e5ec2cd71cadcf35721bcd75 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Fri, 17 Oct 2014 17:40:46 +0200
Subject: Javascript: allow shebangs

---
 pygments/lexers/javascript.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index f7e4e478..99361aaf 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -59,6 +59,7 @@ class JavascriptLexer(RegexLexer):
             (r'\n', Text, '#pop')
         ],
         'root': [
+            (r'^#! ?/.*?\n', Comment),  # shebang lines are recognized by node.js
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
             (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-- 
cgit v1.2.1


From d419adf633b59dea19d584a646881802193e913a Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 4 Nov 2014 11:37:12 +0100
Subject: Closes #1052: recognize unicode whitespace in JS lexer.

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 99361aaf..0c22aa6e 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -40,7 +40,7 @@ class JavascriptLexer(RegexLexer):
     mimetypes = ['application/javascript', 'application/x-javascript',
                  'text/x-javascript', 'text/javascript', ]
 
-    flags = re.DOTALL
+    flags = re.DOTALL | re.UNICODE
     tokens = {
         'commentsandwhitespace': [
             (r'\s+', Text),
-- 
cgit v1.2.1


From 93fbc24cac6081c4e5e75b9cb2b33d4492fe0494 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Thu, 6 Nov 2014 12:45:29 +0100
Subject: Fix flags for JS.

---
 pygments/lexers/javascript.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 0c22aa6e..2957d86c 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -40,7 +40,8 @@ class JavascriptLexer(RegexLexer):
     mimetypes = ['application/javascript', 'application/x-javascript',
                  'text/x-javascript', 'text/javascript', ]
 
-    flags = re.DOTALL | re.UNICODE
+    flags = re.DOTALL | re.UNICODE | re.MULTILINE
+
     tokens = {
         'commentsandwhitespace': [
             (r'\s+', Text),
@@ -59,11 +60,11 @@ class JavascriptLexer(RegexLexer):
             (r'\n', Text, '#pop')
         ],
         'root': [
-            (r'^#! ?/.*?\n', Comment),  # shebang lines are recognized by node.js
+            (r'\A#! ?/.*?\n', Comment),  # shebang lines are recognized by node.js
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
             (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|'
-- 
cgit v1.2.1


From 0e1d32ecd9de7b352c83bc2af031d7af97042b24 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Thu, 6 Nov 2014 13:02:16 +0100
Subject: Simplify charclasses in a few more modules

---
 pygments/lexers/javascript.py | 77 ++++++++++++++++++++++---------------------
 1 file changed, 39 insertions(+), 38 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 2957d86c..76cd2276 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -23,8 +23,8 @@ __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
 
 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') +
+JS_IDENT_PART = ('(?:[$' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl',
+                                       'Mn', 'Mc', 'Nd', 'Pc') +
                  u'\u200c\u200d]|\\\\u[a-fA-F0-9]{4})')
 JS_IDENT = JS_IDENT_START + '(?:' + JS_IDENT_PART + ')*'
 
@@ -114,13 +114,13 @@ class KalLexer(RegexLexer):
             (r'#(?!##[^#]).*?\n', Comment.Single),
         ],
         'functiondef': [
-            (r'[$a-zA-Z_][\w\$]*\s*', Name.Function, '#pop'),
+            (r'[$a-zA-Z_][\w$]*\s*', Name.Function, '#pop'),
             include('commentsandwhitespace'),
         ],
         'classdef': [
             (r'\binherits\s+from\b', Keyword),
-            (r'[$a-zA-Z_][\w\$]*\s*\n', Name.Class, '#pop'),
-            (r'[$a-zA-Z_][\w\$]*\s*', Name.Class),
+            (r'[$a-zA-Z_][\w$]*\s*\n', Name.Class, '#pop'),
+            (r'[$a-zA-Z_][\w$]*\s*', Name.Class),
             include('commentsandwhitespace'),
         ],
         'listcomprehension': [
@@ -144,18 +144,18 @@ class KalLexer(RegexLexer):
             (r'(?:\([^()]+\))?\s*>', Name.Function),
             (r'[{(]', Punctuation),
             (r'\[', Punctuation, 'listcomprehension'),
-            (r'[})\]\.\,]', Punctuation),
+            (r'[})\].,]', Punctuation),
             (r'\b(function|method|task)\b', Keyword.Declaration, 'functiondef'),
             (r'\bclass\b', Keyword.Declaration, 'classdef'),
             (r'\b(safe\s+)?wait\s+for\b', Keyword, 'waitfor'),
-            (r'\b(me|this)(\.[$a-zA-Z_][\w\.\$]*)?\b', Name.Variable.Instance),
-            (r'(?<![\.\$])(for(\s+(parallel|series))?|in|of|while|until|'
+            (r'\b(me|this)(\.[$a-zA-Z_][\w.$]*)?\b', Name.Variable.Instance),
+            (r'(?<![.$])(for(\s+(parallel|series))?|in|of|while|until|'
              r'break|return|continue|'
              r'when|if|unless|else|otherwise|except\s+when|'
              r'throw|raise|fail\s+with|try|catch|finally|new|delete|'
              r'typeof|instanceof|super|run\s+in\s+parallel|'
              r'inherits\s+from)\b', Keyword),
-            (r'(?<![\.\$])(true|false|yes|no|on|off|null|nothing|none|'
+            (r'(?<![.$])(true|false|yes|no|on|off|null|nothing|none|'
              r'NaN|Infinity|undefined)\b',
              Keyword.Constant),
             (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
@@ -164,7 +164,7 @@ class KalLexer(RegexLexer):
              r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|'
              r'print)\b',
              Name.Builtin),
-            (r'[$a-zA-Z_][\w\.\$]*\s*(:|[\+\-\*\/]?\=)?\b', Name.Variable),
+            (r'[$a-zA-Z_][\w.$]*\s*(:|[+\-*/]?\=)?\b', Name.Variable),
             (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),
@@ -247,19 +247,19 @@ class LiveScriptLexer(RegexLexer):
             include('commentsandwhitespace'),
             (r'(?:\([^()]+\))?[ ]*[~-]{1,2}>|'
              r'(?:\(?[^()\n]+\)?)?[ ]*<[~-]{1,2}', Name.Function),
-            (r'\+\+|&&|(?<![\.\$])\b(?:and|x?or|is|isnt|not)\b|\?|:|=|'
+            (r'\+\+|&&|(?<![.$])\b(?:and|x?or|is|isnt|not)\b|\?|:|=|'
              r'\|\||\\(?=\n)|(<<|>>>?|==?|!=?|'
              r'~(?!\~?>)|-(?!\-?>)|<(?!\[)|(?<!\])>|'
-             r'[+*`%&\|\^/])=?',
+             r'[+*`%&|^/])=?',
              Operator, 'slashstartsregex'),
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
-            (r'(?<![\.\$])(for|own|in|of|while|until|loop|break|'
+            (r'(?<![.$])(for|own|in|of|while|until|loop|break|'
              r'return|continue|switch|when|then|if|unless|else|'
              r'throw|try|catch|finally|new|delete|typeof|instanceof|super|'
              r'extends|this|class|by|const|var|to|til)\b', Keyword,
              'slashstartsregex'),
-            (r'(?<![\.\$])(true|false|yes|no|on|off|'
+            (r'(?<![.$])(true|false|yes|no|on|off|'
              r'null|NaN|Infinity|undefined|void)\b',
              Keyword.Constant),
             (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
@@ -267,12 +267,12 @@ class LiveScriptLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
              Name.Builtin),
-            (r'[$a-zA-Z_][\w\.\-:\$]*\s*[:=]\s', Name.Variable,
+            (r'[$a-zA-Z_][\w.\-:$]*\s*[:=]\s', Name.Variable,
              'slashstartsregex'),
-            (r'@[$a-zA-Z_][\w\.\-:\$]*\s*[:=]\s', Name.Variable.Instance,
+            (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, 'slashstartsregex'),
             (r'[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?(?:[a-zA-Z_]+)?', Number.Float),
             (r'[0-9]+(~[0-9a-z]+)?(?:[a-zA-Z_]+)?', Number.Integer),
             ('"""', String, 'tdqs'),
@@ -385,7 +385,7 @@ class DartLexer(RegexLexer):
             (r"'", String.Single, 'string_single')
         ],
         'string_common': [
-            (r"\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z\'\"$\\])",
+            (r"\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z'\"$\\])",
              String.Escape),
             (r'(\$)([a-zA-Z_]\w*)', bygroups(String.Interpol, Name)),
             (r'(\$\{)(.*?)(\})',
@@ -393,19 +393,19 @@ class DartLexer(RegexLexer):
         ],
         'string_double': [
             (r'"', String.Double, '#pop'),
-            (r'[^\"$\\\n]+', String.Double),
+            (r'[^"$\\\n]+', String.Double),
             include('string_common'),
             (r'\$+', String.Double)
         ],
         'string_double_multiline': [
             (r'"""', String.Double, '#pop'),
-            (r'[^\"$\\]+', String.Double),
+            (r'[^"$\\]+', String.Double),
             include('string_common'),
             (r'(\$|\")+', String.Double)
         ],
         'string_single': [
             (r"'", String.Single, '#pop'),
-            (r"[^\'$\\\n]+", String.Single),
+            (r"[^'$\\\n]+", String.Single),
             include('string_common'),
             (r'\$+', String.Single)
         ],
@@ -430,7 +430,8 @@ class TypeScriptLexer(RegexLexer):
     filenames = ['*.ts']
     mimetypes = ['text/x-typescript']
 
-    flags = re.DOTALL
+    flags = re.DOTALL | re.MULTILINE
+
     tokens = {
         'commentsandwhitespace': [
             (r'\s+', Text),
@@ -452,7 +453,7 @@ class TypeScriptLexer(RegexLexer):
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
             (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|'
@@ -477,7 +478,7 @@ class TypeScriptLexer(RegexLexer):
             # Match stuff like: constructor
             (r'\b(constructor|declare|interface|as|AS)\b', Keyword.Reserved),
             # Match stuff like: super(argument, list)
-            (r'(super)(\s*)(\([a-zA-Z0-9,_?.$\s]+\s*\))',
+            (r'(super)(\s*)(\([\w,?.$\s]+\s*\))',
              bygroups(Keyword.Reserved, Text), 'slashstartsregex'),
             # Match stuff like: function() {...}
             (r'([a-zA-Z_?.$][\w?.$]*)\(\) \{', Name.Other, 'slashstartsregex'),
@@ -672,7 +673,7 @@ class LassoLexer(RegexLexer):
         ],
         'escape': [
             (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:]+:|'
-             r'[abefnrtv?\"\'\\]|$)', String.Escape),
+             r'[abefnrtv?"\'\\]|$)', String.Escape),
         ],
         'signature': [
             (r'=>', Operator, '#pop'),
@@ -776,7 +777,7 @@ class ObjectiveJLexer(RegexLexer):
             include('whitespace'),
 
             # function definition
-            (r'^(' + _ws + r'[\+-]' + _ws + r')([\(a-zA-Z_].*?[^\(])(' + _ws + r'\{)',
+            (r'^(' + _ws + r'[+-]' + _ws + r')([(a-zA-Z_].*?[^(])(' + _ws + r'\{)',
              bygroups(using(this), using(this, state='function_signature'),
                       using(this))),
 
@@ -788,7 +789,7 @@ class ObjectiveJLexer(RegexLexer):
             (r'(\s*)(@end)(\s*)', bygroups(Text, Keyword, Text)),
 
             include('statements'),
-            ('[{\(\)}]', Punctuation),
+            ('[{()}]', Punctuation),
             (';', Punctuation),
         ],
         'whitespace': [
@@ -836,7 +837,7 @@ class ObjectiveJLexer(RegexLexer):
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
 
             (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-             r'(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?',
+             r'(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?',
              Operator, 'slashstartsregex'),
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
@@ -925,7 +926,7 @@ class ObjectiveJLexer(RegexLexer):
 
             # parameters
             (r'(\(' + _ws + ')'                 # open paren
-             r'([^\)]+)'                        # type
+             r'([^)]+)'                        # type
              r'(' + _ws + r'\)' + _ws + r')'    # close paren
              r'([$a-zA-Z_]\w+)',      # param name
              bygroups(using(this), Keyword.Type, using(this), Text)),
@@ -1017,17 +1018,17 @@ class CoffeeScriptLexer(RegexLexer):
             include('commentsandwhitespace'),
             (r'\+\+|~|&&|\band\b|\bor\b|\bis\b|\bisnt\b|\bnot\b|\?|:|'
              r'\|\||\\(?=\n)|'
-             r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?',
+             r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&|^/])=?',
              Operator, 'slashstartsregex'),
             (r'(?:\([^()]*\))?\s*[=-]>', Name.Function),
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
-            (r'(?<![\.\$])(for|own|in|of|while|until|'
+            (r'(?<![.$])(for|own|in|of|while|until|'
              r'loop|break|return|continue|'
              r'switch|when|then|if|unless|else|'
              r'throw|try|catch|finally|new|delete|typeof|instanceof|super|'
              r'extends|this|class|by)\b', Keyword, 'slashstartsregex'),
-            (r'(?<![\.\$])(true|false|yes|no|on|off|null|'
+            (r'(?<![.$])(true|false|yes|no|on|off|null|'
              r'NaN|Infinity|undefined)\b',
              Keyword.Constant),
             (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
@@ -1035,12 +1036,12 @@ class CoffeeScriptLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
              Name.Builtin),
-            (r'[$a-zA-Z_][\w\.:\$]*\s*[:=]\s', Name.Variable,
+            (r'[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable,
              'slashstartsregex'),
-            (r'@[$a-zA-Z_][\w\.:\$]*\s*[:=]\s', Name.Variable.Instance,
+            (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, 'slashstartsregex'),
             (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),
@@ -1102,13 +1103,13 @@ class MaskLexer(RegexLexer):
             (r'\s+', Text),
             (r'//.*?\n', Comment.Single),
             (r'/\*.*?\*/', Comment.Multiline),
-            (r'[\{\};>]', Punctuation),
+            (r'[{};>]', Punctuation),
             (r"'''", String, 'string-trpl-single'),
             (r'"""', String, 'string-trpl-double'),
             (r"'", String, 'string-single'),
             (r'"', String, 'string-double'),
             (r'([\w-]+)', Name.Tag, 'node'),
-            (r'([^\.#;{>\s]+)', Name.Class, 'node'),
+            (r'([^.#;{>\s]+)', Name.Class, 'node'),
             (r'(#[\w-]+)', Name.Function, 'node'),
             (r'(\.[\w-]+)', Name.Variable.Class, 'node')
         ],
@@ -1187,7 +1188,7 @@ class MaskLexer(RegexLexer):
         'css-double-end': [
             include('css-base'),
             (r'"', String.Single, '#pop:2'),
-            (r"[^;\"]+", Name.Entity)
+            (r'[^;"]+', Name.Entity)
         ],
         'string-single-pop2': [
             (r"'", String.Single, '#pop:2'),
-- 
cgit v1.2.1


From 07e4d4ad4cd6353c0bfc63407696b86ea1ebeba7 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 8 Nov 2014 15:15:51 +0100
Subject: Closes #1055: fixup guessing routines for HTML/XML related markup

* remove too broad recognition for Lasso lexer
* recognize XML declaration (<?xml ...?>) as XML
* make HTML doctype recognition more general (HTML5 only requires <!DOCTYPE html>)
* fix PHP not to recognize XML declarations
---
 pygments/lexers/javascript.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 76cd2276..404bcf96 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -746,12 +746,10 @@ class LassoLexer(RegexLexer):
         rv = 0.0
         if 'bin/lasso9' in text:
             rv += 0.8
-        if re.search(r'<\?(=|lasso)|\A\[', text, re.I):
+        if re.search(r'<\?lasso', text, re.I):
             rv += 0.4
         if re.search(r'local\(', text, re.I):
             rv += 0.4
-        if '?>' in text:
-            rv += 0.1
         return rv
 
 
-- 
cgit v1.2.1


From cd528c797fac1910a1bb228bfc76376ee5dfda14 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 09:51:30 -0500
Subject: spelling/grammar/syntax fixes for docs

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 404bcf96..8e258f9a 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -213,7 +213,7 @@ class LiveScriptLexer(RegexLexer):
 
     .. _LiveScript: http://gkz.github.com/LiveScript/
 
-    New in Pygments 1.6.
+    .. versionadded:: 1.6
     """
 
     name = 'LiveScript'
-- 
cgit v1.2.1


From 1a695813347064d9bbb37800897a96c51c21dc34 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 09:51:30 -0500
Subject: spelling/grammar/syntax fixes for docs

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 404bcf96..8e258f9a 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -213,7 +213,7 @@ class LiveScriptLexer(RegexLexer):
 
     .. _LiveScript: http://gkz.github.com/LiveScript/
 
-    New in Pygments 1.6.
+    .. versionadded:: 1.6
     """
 
     name = 'LiveScript'
-- 
cgit v1.2.1


From 6523303273beaa7b7d99c27687437e085b3eb0fc Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:00:07 -0500
Subject: don't allow line breaks in hashbang or escapes

---
 pygments/lexers/javascript.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 8e258f9a..3d976904 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -522,7 +522,7 @@ class LassoLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'^#!.+lasso9\b', Comment.Preproc, 'lasso'),
+            (r'^#![ \S]+lasso9\b', Comment.Preproc, 'lasso'),
             (r'\[no_square_brackets\]', Comment.Preproc, 'nosquarebrackets'),
             (r'\[noprocess\]', Comment.Preproc, ('delimiters', 'noprocess')),
             (r'\[', Comment.Preproc, ('delimiters', 'squarebrackets')),
@@ -672,7 +672,7 @@ class LassoLexer(RegexLexer):
             (r'\\', String.Double),
         ],
         'escape': [
-            (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:]+:|'
+            (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:\n\r]+:|'
              r'[abefnrtv?"\'\\]|$)', String.Escape),
         ],
         'signature': [
-- 
cgit v1.2.1


From 928af09ad3a142f332a293af478348129d5c54fa Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:06:36 -0500
Subject: allow space after dot operators

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3d976904..c899f08c 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -588,7 +588,7 @@ class LassoLexer(RegexLexer):
                 bygroups(Name.Builtin.Pseudo, Name.Variable.Class)),
             (r"(self)(\s*->\s*)('[a-z_][\w.]*')",
                 bygroups(Name.Builtin.Pseudo, Operator, Name.Variable.Class)),
-            (r'(\.\.?)([a-z_][\w.]*(=(?!=))?)',
+            (r'(\.\.?\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Name.Builtin.Pseudo, Name.Other.Member)),
             (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Operator, Name.Other.Member)),
-- 
cgit v1.2.1


From ceda004c96092681f548836b2c1112931349c933 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:08:08 -0500
Subject: -infinity is valid, -nan is not

---
 pygments/lexers/javascript.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index c899f08c..b08f66d4 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -576,7 +576,7 @@ class LassoLexer(RegexLexer):
             (r'\d*\.\d+(e[+-]?\d+)?', Number.Float),
             (r'0x[\da-f]+', Number.Hex),
             (r'\d+', Number.Integer),
-            (r'([+-]?)(infinity|NaN)\b', bygroups(Operator, Number)),
+            (r'(infinity|NaN)\b', Number),
             (r"'", String.Single, 'singlestring'),
             (r'"', String.Double, 'doublestring'),
             (r'`[^`]*`', String.Backtick),
@@ -593,7 +593,7 @@ class LassoLexer(RegexLexer):
             (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Operator, Name.Other.Member)),
             (r'(self|inherited)\b', Name.Builtin.Pseudo),
-            (r'-[a-z_][\w.]*', Name.Attribute),
+            (r'-(?!infinity)[a-z_][\w.]*', Name.Attribute),
             (r'::\s*[a-z_][\w.]*', Name.Label),
             (r'(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|'
              r'Error_DatabaseConnectionUnavailable|Error_DatabaseTimeout|'
-- 
cgit v1.2.1


From 31a4e991001ed34c0596313efc603a55aac9da2a Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:10:40 -0500
Subject: [noprocess] should still work after [no_square_brackets]

---
 pygments/lexers/javascript.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index b08f66d4..0cd68d24 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -541,9 +541,11 @@ class LassoLexer(RegexLexer):
             (r'[^[<]+', Other),
         ],
         'nosquarebrackets': [
+            (r'\[noprocess\]', Comment.Preproc, 'noprocess'),
+            (r'\[', Other),
             (r'<\?(LassoScript|lasso|=)', Comment.Preproc, 'anglebrackets'),
-            (r'<', Other),
-            (r'[^<]+', Other),
+            (r'<(!--.*?-->)?', Other),
+            (r'[^[<]+', Other),
         ],
         'noprocess': [
             (r'\[/noprocess\]', Comment.Preproc, '#pop'),
-- 
cgit v1.2.1


From 6d93c83ae39162b4289b1e3bc449610fc5813c36 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:11:58 -0500
Subject: allow space in data member accessor

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 0cd68d24..3e47821a 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -586,7 +586,7 @@ class LassoLexer(RegexLexer):
             # names
             (r'\$[a-z_][\w.]*', Name.Variable),
             (r'#([a-z_][\w.]*|\d+)', Name.Variable.Instance),
-            (r"(\.)('[a-z_][\w.]*')",
+            (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)),
-- 
cgit v1.2.1


From 63c009b4c1712660de4823ad7546ed46c46d493c Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 10:21:22 -0500
Subject: improved list of built-in Lasso types

---
 pygments/lexers/javascript.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3e47821a..178d63de 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -625,7 +625,8 @@ class LassoLexer(RegexLexer):
             (r'(true|false|none|minimal|full|all|void)\b', Keyword.Constant),
             (r'(local|var|variable|global|data(?=\s))\b', Keyword.Declaration),
             (r'(array|date|decimal|duration|integer|map|pair|string|tag|xml|'
-             r'null|bytes|list|queue|set|stack|staticarray|tie)\b', Keyword.Type),
+             r'null|boolean|bytes|keyword|list|locale|queue|set|stack|'
+             r'staticarray)\b', Keyword.Type),
             (r'([a-z_][\w.]*)(\s+)(in)\b', bygroups(Name, Text, Keyword)),
             (r'(let|into)(\s+)([a-z_][\w.]*)', bygroups(Keyword, Text, Name)),
             (r'require\b', Keyword, 'requiresection'),
-- 
cgit v1.2.1


From 971c89f5f04b1737446e67589adcabb348411868 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Mon, 24 Nov 2014 12:15:46 -0500
Subject: add currentcapture & givenblock to list of special Lasso builtins

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 178d63de..eb6297c0 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -594,7 +594,7 @@ class LassoLexer(RegexLexer):
                 bygroups(Name.Builtin.Pseudo, Name.Other.Member)),
             (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Operator, Name.Other.Member)),
-            (r'(self|inherited)\b', Name.Builtin.Pseudo),
+            (r'(self|inherited|currentcapture|givenblock)\b', Name.Builtin.Pseudo),
             (r'-(?!infinity)[a-z_][\w.]*', Name.Attribute),
             (r'::\s*[a-z_][\w.]*', Name.Label),
             (r'(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|'
-- 
cgit v1.2.1


From 8f30b8acaab6f616a934d4749c37e6dd1e54c849 Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Mon, 24 Nov 2014 13:36:46 -0500
Subject: account for when self and givenblock appear as member methods

---
 pygments/lexers/javascript.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index eb6297c0..30ec0600 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -594,7 +594,8 @@ class LassoLexer(RegexLexer):
                 bygroups(Name.Builtin.Pseudo, Name.Other.Member)),
             (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Operator, Name.Other.Member)),
-            (r'(self|inherited|currentcapture|givenblock)\b', Name.Builtin.Pseudo),
+            (r'(?<!->)(self|inherited|currentcapture|givenblock)\b',
+                Name.Builtin.Pseudo),
             (r'-(?!infinity)[a-z_][\w.]*', Name.Attribute),
             (r'::\s*[a-z_][\w.]*', Name.Label),
             (r'(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|'
-- 
cgit v1.2.1


From 89240ed7d7807346291eb20625a17441f6900157 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Wed, 21 Jan 2015 08:33:25 +0100
Subject: Copyright year update.

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 8e258f9a..fa7dca41 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -5,7 +5,7 @@
 
     Lexers for JavaScript and related languages.
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-- 
cgit v1.2.1


From 9a4cce44cc5b89ea414e8d8c769155d57617bd99 Mon Sep 17 00:00:00 2001
From: Miikka Salminen <miikka.salminen@gmail.com>
Date: Sat, 7 Mar 2015 22:30:17 +0200
Subject: Added a new token type Comment.Hashbang with its documentation, and a
 support for it in Javascript, Perl, Python, Ruby and Bash lexers.

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index fa7dca41..aed8438e 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -60,7 +60,7 @@ class JavascriptLexer(RegexLexer):
             (r'\n', Text, '#pop')
         ],
         'root': [
-            (r'\A#! ?/.*?\n', Comment),  # shebang lines are recognized by node.js
+            (r'\A#! ?/.*?\n', Comment.Hashbang),  # recognized by node.js
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
             (r'\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|'
-- 
cgit v1.2.1


From fcf8bd3417d7256994c85764bb3286edcb31ba03 Mon Sep 17 00:00:00 2001
From: Gregory Szorc <gps@mozilla.com>
Date: Fri, 24 Apr 2015 12:15:59 -0700
Subject: Detect .jsm files as JavaScript

The .jsm extension for JavaScript files is used by a few projects,
notably Mozilla projects like Firefox. .jsm files should be treated as
equivalent to .js files.
---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index aed8438e..7dcfbb4b 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -36,7 +36,7 @@ class JavascriptLexer(RegexLexer):
 
     name = 'JavaScript'
     aliases = ['js', 'javascript']
-    filenames = ['*.js', ]
+    filenames = ['*.js', '*.jsm', ]
     mimetypes = ['application/javascript', 'application/x-javascript',
                  'text/x-javascript', 'text/javascript', ]
 
-- 
cgit v1.2.1


From a2aa5a7161280b230ef247e8dcbc97166d9061c5 Mon Sep 17 00:00:00 2001
From: "Marcus R. Brown" <mrossbrown@gmail.com>
Date: Mon, 21 Sep 2015 01:50:18 -0700
Subject: Add basic support for template strings to the Javascript lexer.

---
 pygments/lexers/javascript.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 7dcfbb4b..3992d072 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -87,6 +87,7 @@ class JavascriptLexer(RegexLexer):
             (r'[0-9]+', Number.Integer),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'`(\\\\|\\`|[^`])*`', String.Backtick),
         ]
     }
 
-- 
cgit v1.2.1


From 8c6b247688e267c9d67a92b6e5a4ba1b3ad3e8a6 Mon Sep 17 00:00:00 2001
From: MadcapJake <madcap.russo@gmail.com>
Date: Thu, 24 Sep 2015 16:57:53 -0500
Subject: Add earl-grey lexer

---
 pygments/lexers/javascript.py | 188 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 186 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 7dcfbb4b..993ea1d6 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -11,7 +11,7 @@
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, default, using, this
+from pygments.lexer import RegexLexer, include, bygroups, default, using, this, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Other
 from pygments.util import get_bool_opt, iteritems
@@ -19,7 +19,7 @@ import pygments.unistring as uni
 
 __all__ = ['JavascriptLexer', 'KalLexer', 'LiveScriptLexer', 'DartLexer',
            'TypeScriptLexer', 'LassoLexer', 'ObjectiveJLexer',
-           'CoffeeScriptLexer', 'MaskLexer']
+           'CoffeeScriptLexer', 'MaskLexer', 'EarlGreyLexer']
 
 JS_IDENT_START = ('(?:[$_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl') +
                   ']|\\\\u[a-fA-F0-9]{4})')
@@ -1197,3 +1197,187 @@ class MaskLexer(RegexLexer):
             include('string-base')
         ],
     }
+
+class EarlGreyLexer(RegexLexer):
+    """
+    For `Earl-Grey`_ source code.
+
+    .. _Earl-Grey: https://breuleux.github.io/earl-grey/
+
+    .. versionadded: 2.1
+    """
+
+    name = 'Earl Grey'
+    aliases = ['Earl-Grey', 'earl-grey', 'earlgrey', 'eg']
+    filenames = ['*.eg']
+    mimetypes = ['text/x-earl-grey']
+
+    # flags = re.DOTALL
+    tokens = {
+        'root': [
+            (r'\n', Text),
+            (r'[^\S\n]+', Text),
+            (r';;.*\n', Comment),
+            (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\$\-])'),
+             Operator.Word),
+            (r'[\*@]?->', Name.Function),
+            (r'([+*/~^<>%&|?!]+)|([\.#\-](?=\s))|@@+(?=\s)|=+', Operator),
+            (r'(?<![\w\$\-])(var|let)(?:[^\w\$])', Keyword.Declaration),
+            include('keywords'),
+            include('builtins'),
+            include('assignment'),
+            include('nested'),
+            (r'(?<=[\s\[\{\(,;])\.([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', String.Symbol),
+            (r'"', String, 'dqs'),
+            (r'\'', String, 'sqs'),
+            (r'"""', String, 'tdqs'),
+            include('control'),
+            include('name'),
+            include('tuple'),
+            include('numbers'),
+            include('import_paths'),
+        ],
+        '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_])?)(?=\s+\=\s)',
+             bygroups(Punctuation, Name.Variable))
+        ],
+        'errors': [
+            (words(('Error', 'TypeError', 'ReferenceError'),
+                prefix=r'(?<![\w\$\-\.])', suffix=r'(?![\w\$\-\.])'),
+             Name.Exception),
+            (r'''(?x)
+                (?<![\w\$])
+                E\.[\w\$](?:[\w\$\-]*[\w\$])?
+                (?:\.[\w\$](?:[\w\$\-]*[\w\$])?)*
+                (?=[\(\{\[\?\!\s])''',
+             Name.Exception),
+        ],
+        'control': [
+            (r'''(?x)
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (?!\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_])?)''',
+             Keyword.Control),
+            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?!\n)\s+(?=[\'"\d\{\[\(])', Keyword.Control),
+            (r'''(?x)
+                (?:
+                    ^(?:\s+)?|
+                    \s(?:=|=>|->|%|with|where|each|each\*|where|with)\s+|
+                    \S+(?<![+\-*/~^<>%&|?!@#.])\s+
+                )
+                (?!(?:and|as|each\*|each|in|is|mod|not|of|or|when|where|with)\\s)
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (\:\s+)
+                (?:
+                    (?=$\n?)|
+                    (?=[+\-*/~^<>=%&|?!#][a-zA-Z$0-9_])|
+                    (?!(?:and|as|each\*|each|in|is|mod|of|or|when|where|with):?\\s)
+                    (?=@?[a-zA-Z$0-9_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)|
+                    (?=\..*?(?=[\s;,]))|
+                    (?=(?:\\"{3}|[\"\\\']).*(?:\"{3}|[\"\\\']))|
+                    (?=\d(?:[\.\w]*\d)?)
+                )''',
+             bygroups(Keyword.Control, Punctuation))
+        ],
+        'nested': [
+            (r'''(?x)
+                (?<!\s)\.
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (?![\[{(:])''',
+             Text),
+            (r'''(?x)
+                (?<!\s)\.
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (?=[\[{(:])''',
+             Name.Attribute),
+            (r'''(?x)
+                (?<!\s)\.
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                \s(?=with)''',
+             Name.Attribute),
+        ],
+        '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\$\-\.])'),
+             Keyword.Pseudo),
+            (words(('this', 'self', '@'),
+                prefix=r'(?<![\w\$\-\.])', suffix=r'(?![\w\$\-])'),
+             Keyword.Constant),
+            (words((
+                'Function', 'Object', 'Array', 'String', 'Number',
+                'Boolean', 'ErrorFactory', 'ENode', 'Promise'),
+                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\-\.])'),
+             Name.Builtin),
+            (words((
+                'true', 'false', 'null', 'undefined'),
+                prefix=r'(?<![\w\$\-\.])', suffix=r'(?![\w\$\-\.])'),
+             Name.Constant),
+        ],
+        'name': [
+            (r'@[a-zA-Z_][a-zA-Z_\-0-9]*', Name.Variable.Instance),
+            (r'[a-zA-Z_][a-zA-Z_\-0-9]*', Name)
+        ],
+        'tuple': [
+            (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(])', Name.Namespace)
+        ],
+        'interpoling_string': [
+            (r'\}', String.Interpol, '#pop'),
+            include('root')
+        ],
+        'strings': [
+            (r'[^\\\'"]', String),
+            (r'[\'"\\]', String),
+            (r'\n', String) # All strings are multiline in EG
+        ],
+        'dqs': [
+            (r'"', String, '#pop'),
+            (r'\\\\|\\"|\\\n', String.Escape),
+            include('strings')
+        ],
+        'sqs': [
+            (r"'", String, '#pop'),
+            (r"\\\\|\\'|\\\n", String.Escape),
+            (r'\{', String.Interpol, 'interpoling_string'),
+            include('strings')
+        ],
+        'tdqs': [
+            (r'"""', String, '#pop'),
+            include('strings')
+        ],
+        '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'\d+', Number.Integer)
+        ],
+    }
-- 
cgit v1.2.1


From d2af6de38ed7d413f9f753e86a731ea41c599401 Mon Sep 17 00:00:00 2001
From: MadcapJake <madcap.russo@gmail.com>
Date: Thu, 24 Sep 2015 17:26:29 -0500
Subject: Fix fields and methods

---
 pygments/lexers/javascript.py | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 993ea1d6..b89c3549 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -1234,15 +1234,16 @@ class EarlGreyLexer(RegexLexer):
             include('builtins'),
             include('assignment'),
             include('nested'),
-            (r'(?<=[\s\[\{\(,;])\.([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', String.Symbol),
+            (r'(?<=[\s\[\{\(,;])\.([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?=[\s\]\}\),;])',
+             String.Symbol),
             (r'"', String, 'dqs'),
             (r'\'', String, 'sqs'),
             (r'"""', String, 'tdqs'),
             include('control'),
-            include('name'),
             include('tuple'),
-            include('numbers'),
             include('import_paths'),
+            include('name'),
+            include('numbers'),
         ],
         'import_paths': [
             (r'(?<=[\s:;,])(\.{1,3}(?:[\w\-]*/)*)(\w(?:[\w\-]*\w)*)(?=[\s;,])',
@@ -1293,20 +1294,20 @@ class EarlGreyLexer(RegexLexer):
         ],
         'nested': [
             (r'''(?x)
-                (?<!\s)\.
+                (?<!\s)(\.)
                 ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                (?![\[{(:])''',
-             Text),
+                (?=[\}\]\)\.,;:\s])''',
+             bygroups(Punctuation, Name.Field)),
             (r'''(?x)
-                (?<!\s)\.
+                (?<=[a-zA-Z$0-9_\]\}\)])(\.)
                 ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                (?=[\[{(:])''',
-             Name.Attribute),
+                (?=[\[\{\(:])''',
+             bygroups(Punctuation, Name.Function)),
             (r'''(?x)
-                (?<!\s)\.
+                (?<=[a-zA-Z$0-9_\]\}\)])(\.)
                 ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                \s(?=with)''',
-             Name.Attribute),
+                \s+(?=with)''',
+             bygroups(Punctuation, Name.Function)),
         ],
         'keywords': [
             (words((
@@ -1341,8 +1342,8 @@ class EarlGreyLexer(RegexLexer):
              Name.Constant),
         ],
         'name': [
-            (r'@[a-zA-Z_][a-zA-Z_\-0-9]*', Name.Variable.Instance),
-            (r'[a-zA-Z_][a-zA-Z_\-0-9]*', Name)
+            (r'@([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Variable.Instance),
+            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Symbol)
         ],
         'tuple': [
             (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(])', Name.Namespace)
-- 
cgit v1.2.1


From 3bff06afe59a552fa3c8bf29a8c46d9050991cd8 Mon Sep 17 00:00:00 2001
From: MadcapJake <madcap.russo@gmail.com>
Date: Fri, 25 Sep 2015 10:33:14 -0500
Subject: Fix dot-strings, add backticks, add dbs

---
 pygments/lexers/javascript.py | 89 +++++++++++++++++++++++++++----------------
 1 file changed, 57 insertions(+), 32 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index b89c3549..941b8d91 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -11,7 +11,8 @@
 
 import re
 
-from pygments.lexer import RegexLexer, include, bygroups, default, using, this, words
+from pygments.lexer import RegexLexer, include, bygroups, default, using, \
+    this, words, combined
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Other
 from pygments.util import get_bool_opt, iteritems
@@ -1212,10 +1213,10 @@ class EarlGreyLexer(RegexLexer):
     filenames = ['*.eg']
     mimetypes = ['text/x-earl-grey']
 
-    # flags = re.DOTALL
     tokens = {
         'root': [
             (r'\n', Text),
+            include('control'),
             (r'[^\S\n]+', Text),
             (r';;.*\n', Comment),
             (r'[\[\]\{\}\:\(\)\,\;]', Punctuation),
@@ -1228,23 +1229,37 @@ class EarlGreyLexer(RegexLexer):
                 prefix=r'(?<=\s|\[)', suffix=r'(?![\w\$\-])'),
              Operator.Word),
             (r'[\*@]?->', Name.Function),
-            (r'([+*/~^<>%&|?!]+)|([\.#\-](?=\s))|@@+(?=\s)|=+', Operator),
+            (r'([+*/~^<>&|?!]+)|([#\-](?=\s))|@@+(?=\s)|=+', Operator),
             (r'(?<![\w\$\-])(var|let)(?:[^\w\$])', Keyword.Declaration),
             include('keywords'),
             include('builtins'),
             include('assignment'),
-            include('nested'),
+            (r'''(?x)
+                (?:()([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)|
+                   (?<=[\s\{\[\(])(\.)([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?))
+                (?=.*%)''',
+             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_])?)(?=[\s\]\}\),;])',
              String.Symbol),
-            (r'"', String, 'dqs'),
-            (r'\'', String, 'sqs'),
-            (r'"""', String, 'tdqs'),
-            include('control'),
+            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])',
+             bygroups(Punctuation, Name.Class.DBS)),
+            (r'(\[)([\^#][a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)(\])',
+             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)),
@@ -1274,25 +1289,24 @@ class EarlGreyLexer(RegexLexer):
             (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?!\n)\s+(?=[\'"\d\{\[\(])', Keyword.Control),
             (r'''(?x)
                 (?:
-                    ^(?:\s+)?|
-                    \s(?:=|=>|->|%|with|where|each|each\*|where|with)\s+|
-                    \S+(?<![+\-*/~^<>%&|?!@#.])\s+
-                )
-                (?!(?:and|as|each\*|each|in|is|mod|not|of|or|when|where|with)\\s)
-                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                (\:\s+)
-                (?:
-                    (?=$\n?)|
-                    (?=[+\-*/~^<>=%&|?!#][a-zA-Z$0-9_])|
-                    (?!(?:and|as|each\*|each|in|is|mod|of|or|when|where|with):?\\s)
-                    (?=@?[a-zA-Z$0-9_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)|
-                    (?=\..*?(?=[\s;,]))|
-                    (?=(?:\\"{3}|[\"\\\']).*(?:\"{3}|[\"\\\']))|
-                    (?=\d(?:[\.\w]*\d)?)
-                )''',
-             bygroups(Keyword.Control, Punctuation))
+                    (?<=[%=])|
+                    (?<=[=\-]>)|
+                    (?<=with|each|with)|
+                    (?<=each\*|where)
+                )(\s+)
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)(:)''',
+             bygroups(Text, Keyword.Control, Punctuation)),
+            (r'''(?x)
+                (?<![+\-*/~^<>%&|?!@#.])(\s+)
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(:)''',
+             bygroups(Text, Keyword.Control, Punctuation)),
         ],
         'nested': [
+            (r'''(?x)
+                (?<=[a-zA-Z$0-9_\]\}\)])(\.)
+                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (?=\s+with(?:\s|\n))''',
+             bygroups(Punctuation, Name.Function)),
             (r'''(?x)
                 (?<!\s)(\.)
                 ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
@@ -1303,11 +1317,6 @@ class EarlGreyLexer(RegexLexer):
                 ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
                 (?=[\[\{\(:])''',
              bygroups(Punctuation, Name.Function)),
-            (r'''(?x)
-                (?<=[a-zA-Z$0-9_\]\}\)])(\.)
-                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                \s+(?=with)''',
-             bygroups(Punctuation, Name.Function)),
         ],
         'keywords': [
             (words((
@@ -1346,12 +1355,16 @@ class EarlGreyLexer(RegexLexer):
             (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Symbol)
         ],
         'tuple': [
-            (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(])', Name.Namespace)
+            (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(,;\n])', Name.Namespace)
         ],
         'interpoling_string': [
             (r'\}', String.Interpol, '#pop'),
             include('root')
         ],
+        'stringescape': [
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
+             r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
+        ],
         'strings': [
             (r'[^\\\'"]', String),
             (r'[\'"\\]', String),
@@ -1370,7 +1383,19 @@ class EarlGreyLexer(RegexLexer):
         ],
         'tdqs': [
             (r'"""', String, '#pop'),
-            include('strings')
+            include('strings'),
+        ],
+        'bt': [
+            (r'`', String.Backtick, '#pop'),
+            (r'(?<!`)\n', String.Backtick),
+            (r'\^|\^=', String.Escape),
+            (r'.+', String.Backtick),
+        ],
+        'tbt': [
+            (r'```', String.Backtick, '#pop'),
+            (r'\n', String.Backtick),
+            (r'\^|\^=', String.Escape),
+            (r'[^\`]+', String.Backtick),
         ],
         'numbers': [
             (r'\d+\.\d*([eE][+-]?[0-9]+)?', Number.Float),
-- 
cgit v1.2.1


From cfd47a725769d774500a8e530f80a48976600135 Mon Sep 17 00:00:00 2001
From: MadcapJake <madcap.russo@gmail.com>
Date: Sun, 27 Sep 2015 03:08:17 -0500
Subject: Fix decrement op, op-assignment, and range op

---
 pygments/lexers/javascript.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 941b8d91..a800ae02 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -1229,6 +1229,8 @@ class EarlGreyLexer(RegexLexer):
                 prefix=r'(?<=\s|\[)', suffix=r'(?![\w\$\-])'),
              Operator.Word),
             (r'[\*@]?->', Name.Function),
+            (r'[+\-*/~^<>%&|?!@#.]*=', Operator.Word),
+            (r'\.{2,3}', Operator.Word), # Range Operator
             (r'([+*/~^<>&|?!]+)|([#\-](?=\s))|@@+(?=\s)|=+', Operator),
             (r'(?<![\w\$\-])(var|let)(?:[^\w\$])', Keyword.Declaration),
             include('keywords'),
@@ -1265,7 +1267,7 @@ class EarlGreyLexer(RegexLexer):
              bygroups(Text.Whitespace, Text)),
         ],
         'assignment': [
-            (r'(\.)?([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?=\s+\=\s)',
+            (r'(\.)?([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?=\s+[+\-*/~^<>%&|?!@#.]*\=\s)',
              bygroups(Punctuation, Name.Variable))
         ],
         'errors': [
@@ -1352,7 +1354,7 @@ class EarlGreyLexer(RegexLexer):
         ],
         'name': [
             (r'@([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Variable.Instance),
-            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Symbol)
+            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(\+\+|\-\-)?', bygroups(Name.Symbol, Operator.Word))
         ],
         'tuple': [
             (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(,;\n])', Name.Namespace)
@@ -1398,7 +1400,7 @@ class EarlGreyLexer(RegexLexer):
             (r'[^\`]+', String.Backtick),
         ],
         'numbers': [
-            (r'\d+\.\d*([eE][+-]?[0-9]+)?', Number.Float),
+            (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),
-- 
cgit v1.2.1


From a746a7fa6a88dcd056358abf33d8b8f4cea54f81 Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Tue, 13 Oct 2015 13:52:55 -0700
Subject: Fixes #1100.  Add support for ECMAScript6 syntax, with example file.

---
 pygments/lexers/javascript.py | 34 ++++++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 8 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3992d072..d13fcbca 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -64,12 +64,13 @@ class JavascriptLexer(RegexLexer):
             (r'^(?=\s|/|<!--)', Text, 'slashstartsregex'),
             include('commentsandwhitespace'),
             (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)\b', Keyword, 'slashstartsregex'),
+             r'this|of)\b', Keyword, 'slashstartsregex'),
             (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
             (r'(abstract|boolean|byte|char|class|const|debugger|double|enum|export|'
              r'extends|final|float|goto|implements|import|int|interface|long|native|'
@@ -77,18 +78,34 @@ class JavascriptLexer(RegexLexer):
              r'transient|volatile)\b', Keyword.Reserved),
             (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
             (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+             r'Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
-             r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
-             r'window)\b', Name.Builtin),
+             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),
-        ]
+            (r'`', String.Backtick, 'interp'),
+        ],
+        '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'),
+        ],
+            #(\\\\|\\`|[^`])*`', String.Backtick),
     }
 
 
@@ -162,7 +179,8 @@ class KalLexer(RegexLexer):
             (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
              r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
-             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|'
+             r'eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|'
+             r'window|'
              r'print)\b',
              Name.Builtin),
             (r'[$a-zA-Z_][\w.$]*\s*(:|[+\-*/]?\=)?\b', Name.Variable),
-- 
cgit v1.2.1


From c6cfc1da86412450f5dc48c8025ab42d04c907f6 Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Wed, 14 Oct 2015 11:54:55 -0700
Subject: Cleanups in preparation for 2.1 release.

---
 pygments/lexers/javascript.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index d13fcbca..d2bcab72 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -36,9 +36,9 @@ class JavascriptLexer(RegexLexer):
 
     name = 'JavaScript'
     aliases = ['js', 'javascript']
-    filenames = ['*.js', '*.jsm', ]
+    filenames = ['*.js', '*.jsm']
     mimetypes = ['application/javascript', 'application/x-javascript',
-                 'text/x-javascript', 'text/javascript', ]
+                 'text/x-javascript', 'text/javascript']
 
     flags = re.DOTALL | re.UNICODE | re.MULTILINE
 
-- 
cgit v1.2.1


From 21f71c28d8d2cbde5b4cfd020b497016f7c1bb0a Mon Sep 17 00:00:00 2001
From: Tim Hatch <tim@timhatch.com>
Date: Wed, 14 Oct 2015 17:47:11 -0700
Subject: Fix out of order alternation in Earl Grey

---
 pygments/lexers/javascript.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3cc20e01..ef92034d 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -1409,13 +1409,13 @@ class EarlGreyLexer(RegexLexer):
         'bt': [
             (r'`', String.Backtick, '#pop'),
             (r'(?<!`)\n', String.Backtick),
-            (r'\^|\^=', String.Escape),
+            (r'\^=?', String.Escape),
             (r'.+', String.Backtick),
         ],
         'tbt': [
             (r'```', String.Backtick, '#pop'),
             (r'\n', String.Backtick),
-            (r'\^|\^=', String.Escape),
+            (r'\^=?', String.Escape),
             (r'[^\`]+', String.Backtick),
         ],
         'numbers': [
-- 
cgit v1.2.1


From 98e5836efac9df2e2ccd65b81d260003f4275419 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 17 Oct 2015 08:28:15 +0200
Subject: More style and markup fixes.

---
 pygments/lexers/javascript.py | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index c35cd3f6..3982c91e 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -106,7 +106,7 @@ class JavascriptLexer(RegexLexer):
             (r'}', String.Interpol, '#pop'),
             include('root'),
         ],
-            #(\\\\|\\`|[^`])*`', String.Backtick),
+        # (\\\\|\\`|[^`])*`', String.Backtick),
     }
 
 
@@ -1222,6 +1222,7 @@ class MaskLexer(RegexLexer):
         ],
     }
 
+
 class EarlGreyLexer(RegexLexer):
     """
     For `Earl-Grey`_ source code.
@@ -1253,7 +1254,7 @@ class EarlGreyLexer(RegexLexer):
              Operator.Word),
             (r'[\*@]?->', Name.Function),
             (r'[+\-*/~^<>%&|?!@#.]*=', Operator.Word),
-            (r'\.{2,3}', Operator.Word), # Range Operator
+            (r'\.{2,3}', Operator.Word),  # Range Operator
             (r'([+*/~^<>&|?!]+)|([#\-](?=\s))|@@+(?=\s)|=+', Operator),
             (r'(?<![\w\$\-])(var|let)(?:[^\w\$])', Keyword.Declaration),
             include('keywords'),
@@ -1266,8 +1267,8 @@ class EarlGreyLexer(RegexLexer):
              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_])?)(?=[\s\]\}\),;])',
-             String.Symbol),
+            (r'(?<=[\s\[\{\(,;])\.([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)'
+             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')),
@@ -1290,12 +1291,13 @@ class EarlGreyLexer(RegexLexer):
              bygroups(Text.Whitespace, Text)),
         ],
         'assignment': [
-            (r'(\.)?([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?=\s+[+\-*/~^<>%&|?!@#.]*\=\s)',
+            (r'(\.)?([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)'
+             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\$])
@@ -1311,7 +1313,8 @@ class EarlGreyLexer(RegexLexer):
                 (?!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_])?)''',
              Keyword.Control),
-            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?!\n)\s+(?=[\'"\d\{\[\(])', Keyword.Control),
+            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(?!\n)\s+(?=[\'"\d\{\[\(])',
+             Keyword.Control),
             (r'''(?x)
                 (?:
                     (?<=[%=])|
@@ -1352,7 +1355,7 @@ class EarlGreyLexer(RegexLexer):
                 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',
@@ -1377,7 +1380,8 @@ class EarlGreyLexer(RegexLexer):
         ],
         'name': [
             (r'@([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Variable.Instance),
-            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(\+\+|\-\-)?', bygroups(Name.Symbol, Operator.Word))
+            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(\+\+|\-\-)?',
+             bygroups(Name.Symbol, Operator.Word))
         ],
         'tuple': [
             (r'#[a-zA-Z_][a-zA-Z_\-0-9]*(?=[\s\{\(,;\n])', Name.Namespace)
@@ -1393,7 +1397,7 @@ class EarlGreyLexer(RegexLexer):
         'strings': [
             (r'[^\\\'"]', String),
             (r'[\'"\\]', String),
-            (r'\n', String) # All strings are multiline in EG
+            (r'\n', String)  # All strings are multiline in EG
         ],
         'dqs': [
             (r'"', String, '#pop'),
-- 
cgit v1.2.1


From 0f7f66750cc3f6dd3c68c1fc8c4d83029967da84 Mon Sep 17 00:00:00 2001
From: Wolfgang Mayr <s1410307080@students.fh-hagenberg.at>
Date: Mon, 26 Oct 2015 16:31:01 +0100
Subject: Added Decorators to TypeScript lexer

---
 pygments/lexers/javascript.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3982c91e..8e2d9797 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -511,6 +511,8 @@ class TypeScriptLexer(RegexLexer):
             (r'[0-9]+', Number.Integer),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single),
+            # Match stuff like: Decorators
+            (r'@\w+', Keyword.Declaration),
         ]
     }
 
-- 
cgit v1.2.1


From 4680aef24be6951985e46e908e9a00eaf6ff7352 Mon Sep 17 00:00:00 2001
From: Samuel Marks <samuelmarks@gmail.com>
Date: Sat, 9 Jan 2016 17:43:32 +1100
Subject: Added more aliases for TypeScript

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 8e2d9797..d51ab5df 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -446,7 +446,7 @@ class TypeScriptLexer(RegexLexer):
     """
 
     name = 'TypeScript'
-    aliases = ['ts']
+    aliases = ['ts', 'typescript', 'TypeScript']
     filenames = ['*.ts']
     mimetypes = ['text/x-typescript']
 
-- 
cgit v1.2.1


From a6526d7b6ec0fda94802cd1608afe1fee973868d Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 16 Jan 2016 12:18:36 +0100
Subject: Update mapfiles.

---
 pygments/lexers/javascript.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index d51ab5df..2a01cd42 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -446,7 +446,7 @@ class TypeScriptLexer(RegexLexer):
     """
 
     name = 'TypeScript'
-    aliases = ['ts', 'typescript', 'TypeScript']
+    aliases = ['ts', 'typescript']
     filenames = ['*.ts']
     mimetypes = ['text/x-typescript']
 
-- 
cgit v1.2.1


From 1d33398ba257ae4165a4de619d1abf1b0b2feed1 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 2 Feb 2016 15:29:05 +0100
Subject: Add lexer for TypoScript (#closes 1173)

Source: https://github.com/Tuurlijk/Pygments-TypoScript-Lexer
---
 pygments/lexers/javascript.py | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 2a01cd42..3ea0836e 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -516,6 +516,10 @@ class TypeScriptLexer(RegexLexer):
         ]
     }
 
+    def analyse_text(text):
+        if '<INCLUDE_TYPOSCRIPT' not in text:
+            return 0.01  # rank about TypoScript lexer
+
 
 class LassoLexer(RegexLexer):
     """
-- 
cgit v1.2.1


From 47146fa9658fbfaede90c6c8b58639142459a81f Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 2 Feb 2016 15:49:26 +0100
Subject: Remove typescript analyser function again.

---
 pygments/lexers/javascript.py | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 3ea0836e..2a01cd42 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -516,10 +516,6 @@ class TypeScriptLexer(RegexLexer):
         ]
     }
 
-    def analyse_text(text):
-        if '<INCLUDE_TYPOSCRIPT' not in text:
-            return 0.01  # rank about TypoScript lexer
-
 
 class LassoLexer(RegexLexer):
     """
-- 
cgit v1.2.1


From 1715147aed86c9a0ac9f3ee197f13cffea123657 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sun, 14 Feb 2016 17:10:00 +0100
Subject: Fix most complaints from regexlint.

---
 pygments/lexers/javascript.py | 80 +++++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

(limited to 'pygments/lexers/javascript.py')

diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 2a01cd42..5dca6832 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -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),
@@ -1245,32 +1245,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$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?)|
-                   (?<=[\s\{\[\(])(\.)([a-zA-Z$_](?:[a-zA-Z$0-9_\-]*[a-zA-Z$0-9_])?))
+                (?:()([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$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)'
-             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')),
@@ -1281,9 +1281,9 @@ class EarlGreyLexer(RegexLexer):
             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'),
@@ -1293,29 +1293,29 @@ class EarlGreyLexer(RegexLexer):
              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\$])
-                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$_](?:[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)
                 (?:
@@ -1324,28 +1324,28 @@ class EarlGreyLexer(RegexLexer):
                     (?<=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_\]\}\)])(\.)
-                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
+                (?<=[\w$\]})])(\.)
+                ([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_])?)
-                (?=[\}\]\)\.,;:\s])''',
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
+                (?=[}\]).,;:\s])''',
              bygroups(Punctuation, Name.Field)),
             (r'''(?x)
-                (?<=[a-zA-Z$0-9_\]\}\)])(\.)
-                ([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)
-                (?=[\[\{\(:])''',
+                (?<=[\w$\]})])(\.)
+                ([a-zA-Z$_](?:[\w$-]*[\w$])?)
+                (?=[\[{(:])''',
              bygroups(Punctuation, Name.Function)),
         ],
         'keywords': [
@@ -1354,15 +1354,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': [
@@ -1373,20 +1373,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$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)', Name.Variable.Instance),
-            (r'([a-zA-Z$_](?:[a-zA-Z$0-9_-]*[a-zA-Z$0-9_])?)(\+\+|\-\-)?',
+            (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_][a-zA-Z_\-0-9]*(?=[\s\{\(,;\n])', Name.Namespace)
+            (r'#[a-zA-Z_][\w\-]*(?=[\s{(,;])', Name.Namespace)
         ],
         'interpoling_string': [
             (r'\}', String.Interpol, '#pop'),
@@ -1426,7 +1426,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),
@@ -1434,7 +1434,7 @@ class EarlGreyLexer(RegexLexer):
             (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)
         ],
     }
-- 
cgit v1.2.1