pygments.rb 0.6.3 → 1.0.0

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

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.stata
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for Stata
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Comment, Keyword, Name, Number, \
+    String, Text, Operator
+
+from pygments.lexers._stata_builtins import builtins_base, builtins_functions
+
+__all__ = ['StataLexer']
+
+class StataLexer(RegexLexer):
+    """
+    For `Stata <http://www.stata.com/>`_ do files.
+
+    .. versionadded:: 2.2
+    """
+    # Syntax based on
+    # - http://fmwww.bc.edu/RePEc/bocode/s/synlightlist.ado
+    # - http://github.com/isagalaev/highlight.js/blob/master/src/languages/stata.js
+    # - http://github.com/jpitblado/vim-stata/blob/master/syntax/stata.vim
+
+    name      = 'Stata'
+    aliases   = ['stata', 'do']
+    filenames = ['*.do', '*.ado']
+    mimetypes = ['text/x-stata', 'text/stata', 'application/x-stata']
+
+    tokens = {
+        'root': [
+            include('comments'),
+            include('vars-strings'),
+            include('numbers'),
+            include('keywords'),
+            (r'.', Text),
+        ],
+        # Global and local macros; regular and special strings
+        'vars-strings': [
+            (r'\$[a-zA-Z_0-9\{]', Name.Variable.Global, 'var_validglobal'),
+            (r'`[a-zA-Z_0-9]{0,31}\'', Name.Variable),
+            (r'"', String, 'string_dquote'),
+            (r'`"', String, 'string_mquote'),
+        ],
+        # For either string type, highlight macros as macros
+        'string_dquote': [
+            (r'"', String, '#pop'),
+            (r'\\\\|\\"|\\\n', String.Escape),
+            (r'\$', Name.Variable.Global, 'var_validglobal'),
+            (r'`', Name.Variable, 'var_validlocal'),
+            (r'[^$\$`"\\]+', String),
+            (r'[$"\\]', String),
+        ],
+        'string_mquote': [
+            (r'"\'', String, '#pop'),
+            (r'\\\\|\\"|\\\n', String.Escape),
+            (r'\$', Name.Variable.Global, 'var_validglobal'),
+            (r'`', Name.Variable, 'var_validlocal'),
+            (r'[^$\$`"\\]+', String),
+            (r'[$"\\]', String),
+        ],
+        'var_validglobal': [
+            (r'\{?[a-zA-Z0-9_]{0,32}\}?', Name.Variable.Global, '#pop'),
+        ],
+        'var_validlocal': [
+            (r'[a-zA-Z0-9_]{0,31}\'', Name.Variable, '#pop'),
+        ],
+        # * only OK at line start, // OK anywhere
+        'comments': [
+            (r'^\s*\*.*$', Comment),
+            (r'//.*', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
+        ],
+        # Built in functions and statements
+        'keywords': [
+            (words(builtins_functions, prefix = r'\b', suffix = r'\('),
+             Name.Function),
+            (words(builtins_base, prefix = r'(^\s*|\s)', suffix = r'\b'),
+             Keyword),
+        ],
+        # http://www.stata.com/help.cgi?operators
+        'operators': [
+            (r'-|==|<=|>=|<|>|&|!=', Operator),
+            (r'\*|\+|\^|/|!|~|==|~=', Operator)
+        ],
+        # Stata numbers
+        'numbers': [
+            # decimal number
+            (r'\b[+-]?([0-9]+(\.[0-9]+)?|\.[0-9]+|\.)([eE][+-]?[0-9]+)?[i]?\b',
+             Number),
+        ],
+        # Stata formats
+        'format': [
+            (r'%-?\d{1,2}(\.\d{1,2})?[gfe]c?', Name.Variable),
+            (r'%(21x|16H|16L|8H|8L)', Name.Variable),
+            (r'%-?(tc|tC|td|tw|tm|tq|th|ty|tg).{0,32}', Name.Variable),
+            (r'%[-~]?\d{1,4}s', Name.Variable),
+        ]
+    }

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

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.supercollider
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for SuperCollider
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, words, default
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation
+
+__all__ = ['SuperColliderLexer']
+
+
+class SuperColliderLexer(RegexLexer):
+    """
+    For `SuperCollider <http://supercollider.github.io/>`_ source code.
+
+    .. versionadded:: 2.1
+    """
+
+    name = 'SuperCollider'
+    aliases = ['sc', 'supercollider']
+    filenames = ['*.sc', '*.scd']
+    mimetypes = ['application/supercollider', 'text/supercollider', ]
+
+    flags = re.DOTALL | re.MULTILINE
+    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),
+            (words((
+                'for', 'in', 'while', 'do', 'break', 'return', 'continue',
+                'switch', 'case', 'default', 'if', 'else', 'throw', 'try',
+                'catch', 'finally', 'new', 'delete', 'typeof', 'instanceof',
+                'void'), suffix=r'\b'),
+             Keyword, 'slashstartsregex'),
+            (words(('var', 'let', 'with', 'function', 'arg'), suffix=r'\b'),
+             Keyword.Declaration, 'slashstartsregex'),
+            (words((
+                '(abstract', 'boolean', 'byte', 'char', 'class', 'const',
+                'debugger', 'double', 'enum', 'export', 'extends', 'final',
+                'float', 'goto', 'implements', 'import', 'int', 'interface',
+                'long', 'native', 'package', 'private', 'protected', 'public',
+                'short', 'static', 'super', 'synchronized', 'throws',
+                'transient', 'volatile'), suffix=r'\b'),
+             Keyword.Reserved),
+            (words(('true', 'false', 'nil', 'inf'), suffix=r'\b'), Keyword.Constant),
+            (words((
+                'Array', 'Boolean', 'Date', 'Error', 'Function', 'Number',
+                'Object', 'Packages', 'RegExp', 'String',
+                'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'super',
+                'thisFunctionDef', 'thisFunction', 'thisMethod', 'thisProcess',
+                'thisThread', 'this'), suffix=r'\b'),
+             Name.Builtin),
+            (r'[$a-zA-Z_]\w*', Name.Other),
+            (r'\\?[$a-zA-Z_]\w*', String.Symbol),
+            (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),
+        ]
+    }

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

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.tcl
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Tcl and related languages.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number
+from pygments.util import shebang_matches
+
+__all__ = ['TclLexer']
+
+
+class TclLexer(RegexLexer):
+    """
+    For Tcl source code.
+
+    .. versionadded:: 0.10
+    """
+
+    keyword_cmds_re = words((
+        'after', 'apply', 'array', 'break', 'catch', 'continue', 'elseif', 'else', 'error',
+        'eval', 'expr', 'for', 'foreach', 'global', 'if', 'namespace', 'proc', 'rename', 'return',
+        'set', 'switch', 'then', 'trace', 'unset', 'update', 'uplevel', 'upvar', 'variable',
+        'vwait', 'while'), prefix=r'\b', suffix=r'\b')
+
+    builtin_cmds_re = words((
+        'append', 'bgerror', 'binary', 'cd', 'chan', 'clock', 'close', 'concat', 'dde', 'dict',
+        'encoding', 'eof', 'exec', 'exit', 'fblocked', 'fconfigure', 'fcopy', 'file',
+        'fileevent', 'flush', 'format', 'gets', 'glob', 'history', 'http', 'incr', 'info', 'interp',
+        'join', 'lappend', 'lassign', 'lindex', 'linsert', 'list', 'llength', 'load', 'loadTk',
+        'lrange', 'lrepeat', 'lreplace', 'lreverse', 'lsearch', 'lset', 'lsort', 'mathfunc',
+        'mathop', 'memory', 'msgcat', 'open', 'package', 'pid', 'pkg::create', 'pkg_mkIndex',
+        'platform', 'platform::shell', 'puts', 'pwd', 're_syntax', 'read', 'refchan',
+        'regexp', 'registry', 'regsub', 'scan', 'seek', 'socket', 'source', 'split', 'string',
+        'subst', 'tell', 'time', 'tm', 'unknown', 'unload'), prefix=r'\b', suffix=r'\b')
+
+    name = 'Tcl'
+    aliases = ['tcl']
+    filenames = ['*.tcl', '*.rvt']
+    mimetypes = ['text/x-tcl', 'text/x-script.tcl', 'application/x-tcl']
+
+    def _gen_command_rules(keyword_cmds_re, builtin_cmds_re, context=""):
+        return [
+            (keyword_cmds_re, Keyword, 'params' + context),
+            (builtin_cmds_re, Name.Builtin, 'params' + context),
+            (r'([\w.-]+)', Name.Variable, 'params' + context),
+            (r'#', Comment, 'comment'),
+        ]
+
+    tokens = {
+        'root': [
+            include('command'),
+            include('basic'),
+            include('data'),
+            (r'\}', Keyword),  # HACK: somehow we miscounted our braces
+        ],
+        'command': _gen_command_rules(keyword_cmds_re, builtin_cmds_re),
+        'command-in-brace': _gen_command_rules(keyword_cmds_re,
+                                               builtin_cmds_re,
+                                               "-in-brace"),
+        'command-in-bracket': _gen_command_rules(keyword_cmds_re,
+                                                 builtin_cmds_re,
+                                                 "-in-bracket"),
+        'command-in-paren': _gen_command_rules(keyword_cmds_re,
+                                               builtin_cmds_re,
+                                               "-in-paren"),
+        'basic': [
+            (r'\(', Keyword, 'paren'),
+            (r'\[', Keyword, 'bracket'),
+            (r'\{', Keyword, 'brace'),
+            (r'"', String.Double, 'string'),
+            (r'(eq|ne|in|ni)\b', Operator.Word),
+            (r'!=|==|<<|>>|<=|>=|&&|\|\||\*\*|[-+~!*/%<>&^|?:]', Operator),
+        ],
+        'data': [
+            (r'\s+', Text),
+            (r'0x[a-fA-F0-9]+', Number.Hex),
+            (r'0[0-7]+', Number.Oct),
+            (r'\d+\.\d+', Number.Float),
+            (r'\d+', Number.Integer),
+            (r'\$([\w.:-]+)', Name.Variable),
+            (r'([\w.:-]+)', Text),
+        ],
+        'params': [
+            (r';', Keyword, '#pop'),
+            (r'\n', Text, '#pop'),
+            (r'(else|elseif|then)\b', Keyword),
+            include('basic'),
+            include('data'),
+        ],
+        'params-in-brace': [
+            (r'\}', Keyword, ('#pop', '#pop')),
+            include('params')
+        ],
+        'params-in-paren': [
+            (r'\)', Keyword, ('#pop', '#pop')),
+            include('params')
+        ],
+        'params-in-bracket': [
+            (r'\]', Keyword, ('#pop', '#pop')),
+            include('params')
+        ],
+        'string': [
+            (r'\[', String.Double, 'string-square'),
+            (r'(?s)(\\\\|\\[0-7]+|\\.|[^"\\])', String.Double),
+            (r'"', String.Double, '#pop')
+        ],
+        'string-square': [
+            (r'\[', String.Double, 'string-square'),
+            (r'(?s)(\\\\|\\[0-7]+|\\.|\\\n|[^\]\\])', String.Double),
+            (r'\]', String.Double, '#pop')
+        ],
+        'brace': [
+            (r'\}', Keyword, '#pop'),
+            include('command-in-brace'),
+            include('basic'),
+            include('data'),
+        ],
+        'paren': [
+            (r'\)', Keyword, '#pop'),
+            include('command-in-paren'),
+            include('basic'),
+            include('data'),
+        ],
+        'bracket': [
+            (r'\]', Keyword, '#pop'),
+            include('command-in-bracket'),
+            include('basic'),
+            include('data'),
+        ],
+        'comment': [
+            (r'.*[^\\]\n', Comment, '#pop'),
+            (r'.*\\\n', Comment),
+        ],
+    }
+
+    def analyse_text(text):
+        return shebang_matches(text, r'(tcl)')

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

@@ -5,23 +5,24 @@
 
     Lexers for various template engines' markup.
 
-    :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.
 """
 
 import re
 
-from pygments.lexers.web import \
-     PhpLexer, HtmlLexer, XmlLexer, JavascriptLexer, CssLexer, LassoLexer
-from pygments.lexers.agile import PythonLexer, PerlLexer
-from pygments.lexers.compiled import JavaLexer
-from pygments.lexers.jvm import TeaLangLexer
-from pygments.lexers.text import YamlLexer
+from pygments.lexers.html import HtmlLexer, XmlLexer
+from pygments.lexers.javascript import JavascriptLexer, LassoLexer
+from pygments.lexers.css import CssLexer
+from pygments.lexers.php import PhpLexer
+from pygments.lexers.python import PythonLexer
+from pygments.lexers.perl import PerlLexer
+from pygments.lexers.jvm import JavaLexer, TeaLangLexer
+from pygments.lexers.data import YamlLexer
 from pygments.lexer import Lexer, DelegatingLexer, RegexLexer, bygroups, \
-     include, using, this, default, combined
-from pygments.token import Error, Punctuation, \
-     Text, Comment, Operator, Keyword, Name, String, Number, Other, Token, \
-     Whitespace
+    include, using, this, default, combined
+from pygments.token import Error, Punctuation, Whitespace, \
+    Text, Comment, Operator, Keyword, Name, String, Number, Other, Token
 from pygments.util import html_doctype_matches, looks_like_xml
 
 __all__ = ['HtmlPhpLexer', 'XmlPhpLexer', 'CssPhpLexer',
@@ -42,7 +43,8 @@ __all__ = ['HtmlPhpLexer', 'XmlPhpLexer', 'CssPhpLexer',
            'VelocityHtmlLexer', 'VelocityXmlLexer', 'SspLexer',
            'TeaTemplateLexer', 'LassoHtmlLexer', 'LassoXmlLexer',
            'LassoCssLexer', 'LassoJavascriptLexer', 'HandlebarsLexer',
-           'HandlebarsHtmlLexer', 'YamlJinjaLexer', 'LiquidLexer']
+           'HandlebarsHtmlLexer', 'YamlJinjaLexer', 'LiquidLexer',
+           'TwigLexer', 'TwigHtmlLexer', 'Angular2Lexer', 'Angular2HtmlLexer']
 
 
 class ErbLexer(Lexer):
@@ -63,7 +65,7 @@ class ErbLexer(Lexer):
     _block_re = re.compile(r'(<%%|%%>|<%=|<%#|<%-|<%|-%>|%>|^%[^%].*?$)', re.M)
 
     def __init__(self, **options):
-        from pygments.lexers.agile import RubyLexer
+        from pygments.lexers.ruby import RubyLexer
         self.ruby_lexer = RubyLexer(**options)
         Lexer.__init__(self, **options)
 
@@ -106,7 +108,7 @@ class ErbLexer(Lexer):
                         data = tokens.pop()
                         r_idx = 0
                         for r_idx, r_token, r_value in \
-                            self.ruby_lexer.get_tokens_unprocessed(data):
+                                self.ruby_lexer.get_tokens_unprocessed(data):
                             yield r_idx + idx, r_token, r_value
                         idx += len(data)
                         state = 2
@@ -119,7 +121,7 @@ class ErbLexer(Lexer):
                         yield idx, Comment.Preproc, tag[0]
                         r_idx = 0
                         for r_idx, r_token, r_value in \
-                            self.ruby_lexer.get_tokens_unprocessed(tag[1:]):
+                                self.ruby_lexer.get_tokens_unprocessed(tag[1:]):
                             yield idx + 1 + r_idx, r_token, r_value
                         idx += len(tag)
                         state = 0
@@ -169,10 +171,11 @@ class SmartyLexer(RegexLexer):
         ],
         'smarty': [
             (r'\s+', Text),
+            (r'\{', Comment.Preproc, '#push'),
             (r'\}', Comment.Preproc, '#pop'),
             (r'#[a-zA-Z_]\w*#', Name.Variable),
             (r'\$[a-zA-Z_]\w*(\.\w+)*', Name.Variable),
-            (r'[~!%^&*()+=|\[\]:;,.<>/?{}@-]', Operator),
+            (r'[~!%^&*()+=|\[\]:;,.<>/?@-]', Operator),
             (r'(true|false|null)\b', Keyword.Constant),
             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
@@ -205,7 +208,7 @@ class VelocityLexer(RegexLexer):
 
     name = 'Velocity'
     aliases = ['velocity']
-    filenames = ['*.vm','*.fhtml']
+    filenames = ['*.vm', '*.fhtml']
 
     flags = re.MULTILINE | re.DOTALL
 
@@ -234,7 +237,7 @@ class VelocityLexer(RegexLexer):
             default('#pop')
         ],
         'directiveparams': [
-            (r'(&&|\|\||==?|!=?|[-<>+*%&\|\^/])|\b(eq|ne|gt|lt|ge|le|not|in)\b',
+            (r'(&&|\|\||==?|!=?|[-<>+*%&|^/])|\b(eq|ne|gt|lt|ge|le|not|in)\b',
              Operator),
             (r'\[', Operator, 'rangeoperator'),
             (r'\b' + identifier + r'\b', Name.Function),
@@ -248,7 +251,7 @@ class VelocityLexer(RegexLexer):
         'funcparams': [
             (r'\$\{?', Punctuation, 'variable'),
             (r'\s+', Text),
-            (r',', Punctuation),
+            (r'[,:]', Punctuation),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single),
             (r"0[xX][0-9a-fA-F]+[Ll]?", Number),
@@ -256,6 +259,8 @@ class VelocityLexer(RegexLexer):
             (r'(true|false|null)\b', Keyword.Constant),
             (r'\(', Punctuation, '#push'),
             (r'\)', Punctuation, '#pop'),
+            (r'\{', Punctuation, '#push'),
+            (r'\}', Punctuation, '#pop'),
             (r'\[', Punctuation, '#push'),
             (r'\]', Punctuation, '#pop'),
         ]
@@ -277,31 +282,31 @@ class VelocityLexer(RegexLexer):
 
 class VelocityHtmlLexer(DelegatingLexer):
     """
-    Subclass of the `VelocityLexer` that highlights unlexer data
+    Subclass of the `VelocityLexer` that highlights unlexed data
     with the `HtmlLexer`.
 
     """
 
     name = 'HTML+Velocity'
     aliases = ['html+velocity']
-    alias_filenames = ['*.html','*.fhtml']
+    alias_filenames = ['*.html', '*.fhtml']
     mimetypes = ['text/html+velocity']
 
     def __init__(self, **options):
         super(VelocityHtmlLexer, self).__init__(HtmlLexer, VelocityLexer,
-                                              **options)
+                                                **options)
 
 
 class VelocityXmlLexer(DelegatingLexer):
     """
-    Subclass of the `VelocityLexer` that highlights unlexer data
+    Subclass of the `VelocityLexer` that highlights unlexed data
     with the `XmlLexer`.
 
     """
 
     name = 'XML+Velocity'
     aliases = ['xml+velocity']
-    alias_filenames = ['*.xml','*.vm']
+    alias_filenames = ['*.xml', '*.vm']
     mimetypes = ['application/xml+velocity']
 
     def __init__(self, **options):
@@ -311,7 +316,7 @@ class VelocityXmlLexer(DelegatingLexer):
     def analyse_text(text):
         rv = VelocityLexer.analyse_text(text) - 0.01
         if looks_like_xml(text):
-            rv += 0.5
+            rv += 0.4
         return rv
 
 
@@ -366,7 +371,7 @@ class DjangoLexer(RegexLexer):
              r'with(?:(?:out)?\s*context)?|scoped|ignore\s+missing)\b',
              Keyword),
             (r'(loop|block|super|forloop)\b', Name.Builtin),
-            (r'[a-zA-Z][\w-]*', Name.Variable),
+            (r'[a-zA-Z_][\w-]*', Name.Variable),
             (r'\.\w+', Name.Variable),
             (r':?"(\\\\|\\"|[^"])*"', String.Double),
             (r":?'(\\\\|\\'|[^'])*'", String.Single),
@@ -448,7 +453,7 @@ class MyghtyLexer(RegexLexer):
 
 class MyghtyHtmlLexer(DelegatingLexer):
     """
-    Subclass of the `MyghtyLexer` that highlights unlexer data
+    Subclass of the `MyghtyLexer` that highlights unlexed data
     with the `HtmlLexer`.
 
     .. versionadded:: 0.6
@@ -465,7 +470,7 @@ class MyghtyHtmlLexer(DelegatingLexer):
 
 class MyghtyXmlLexer(DelegatingLexer):
     """
-    Subclass of the `MyghtyLexer` that highlights unlexer data
+    Subclass of the `MyghtyLexer` that highlights unlexed data
     with the `XmlLexer`.
 
     .. versionadded:: 0.6
@@ -482,7 +487,7 @@ class MyghtyXmlLexer(DelegatingLexer):
 
 class MyghtyJavascriptLexer(DelegatingLexer):
     """
-    Subclass of the `MyghtyLexer` that highlights unlexer data
+    Subclass of the `MyghtyLexer` that highlights unlexed data
     with the `JavascriptLexer`.
 
     .. versionadded:: 0.6
@@ -501,7 +506,7 @@ class MyghtyJavascriptLexer(DelegatingLexer):
 
 class MyghtyCssLexer(DelegatingLexer):
     """
-    Subclass of the `MyghtyLexer` that highlights unlexer data
+    Subclass of the `MyghtyLexer` that highlights unlexed data
     with the `CssLexer`.
 
     .. versionadded:: 0.6
@@ -565,10 +570,12 @@ class MasonLexer(RegexLexer):
     }
 
     def analyse_text(text):
-        rv = 0.0
-        if re.search('<&', text) is not None:
-            rv = 1.0
-        return rv
+        result = 0.0
+        if re.search(r'</%(class|doc|init)%>', text) is not None:
+            result = 1.0
+        elif re.search(r'<&.+&>', text, re.DOTALL) is not None:
+            result = 0.11
+        return result
 
 
 class MakoLexer(RegexLexer):
@@ -595,11 +602,11 @@ class MakoLexer(RegexLexer):
             (r'(\s*)(##[^\n]*)(\n|\Z)',
              bygroups(Text, Comment.Preproc, Other)),
             (r'(?s)<%doc>.*?</%doc>', Comment.Preproc),
-            (r'(<%)([\w\.\:]+)',
+            (r'(<%)([\w.:]+)',
              bygroups(Comment.Preproc, Name.Builtin), 'tag'),
-            (r'(</%)([\w\.\:]+)(>)',
+            (r'(</%)([\w.:]+)(>)',
              bygroups(Comment.Preproc, Name.Builtin, Comment.Preproc)),
-            (r'<%(?=([\w\.\:]+))', Comment.Preproc, 'ondeftags'),
+            (r'<%(?=([\w.:]+))', Comment.Preproc, 'ondeftags'),
             (r'(<%(?:!?))(.*?)(%>)(?s)',
              bygroups(Comment.Preproc, using(PythonLexer), Comment.Preproc)),
             (r'(\$\{)(.*?)(\})',
@@ -653,11 +660,12 @@ class MakoHtmlLexer(DelegatingLexer):
 
     def __init__(self, **options):
         super(MakoHtmlLexer, self).__init__(HtmlLexer, MakoLexer,
-                                              **options)
+                                            **options)
+
 
 class MakoXmlLexer(DelegatingLexer):
     """
-    Subclass of the `MakoLexer` that highlights unlexer data
+    Subclass of the `MakoLexer` that highlights unlexed data
     with the `XmlLexer`.
 
     .. versionadded:: 0.7
@@ -669,11 +677,12 @@ class MakoXmlLexer(DelegatingLexer):
 
     def __init__(self, **options):
         super(MakoXmlLexer, self).__init__(XmlLexer, MakoLexer,
-                                             **options)
+                                           **options)
+
 
 class MakoJavascriptLexer(DelegatingLexer):
     """
-    Subclass of the `MakoLexer` that highlights unlexer data
+    Subclass of the `MakoLexer` that highlights unlexed data
     with the `JavascriptLexer`.
 
     .. versionadded:: 0.7
@@ -687,11 +696,12 @@ class MakoJavascriptLexer(DelegatingLexer):
 
     def __init__(self, **options):
         super(MakoJavascriptLexer, self).__init__(JavascriptLexer,
-                                                    MakoLexer, **options)
+                                                  MakoLexer, **options)
+
 
 class MakoCssLexer(DelegatingLexer):
     """
-    Subclass of the `MakoLexer` that highlights unlexer data
+    Subclass of the `MakoLexer` that highlights unlexed data
     with the `CssLexer`.
 
     .. versionadded:: 0.7
@@ -703,7 +713,7 @@ class MakoCssLexer(DelegatingLexer):
 
     def __init__(self, **options):
         super(MakoCssLexer, self).__init__(CssLexer, MakoLexer,
-                                             **options)
+                                           **options)
 
 
 # Genshi and Cheetah lexers courtesy of Matt Good.
@@ -747,7 +757,7 @@ class CheetahLexer(RegexLexer):
              (bygroups(Comment.Preproc, using(CheetahPythonLexer),
                        Comment.Preproc))),
             # TODO support other Python syntax like $foo['bar']
-            (r'(\$)([a-zA-Z_][\w\.]*\w)',
+            (r'(\$)([a-zA-Z_][\w.]*\w)',
              bygroups(Comment.Preproc, using(CheetahPythonLexer))),
             (r'(\$\{!?)(.*?)(\})(?s)',
              bygroups(Comment.Preproc, using(CheetahPythonLexer),
@@ -767,7 +777,7 @@ class CheetahLexer(RegexLexer):
 
 class CheetahHtmlLexer(DelegatingLexer):
     """
-    Subclass of the `CheetahLexer` that highlights unlexer data
+    Subclass of the `CheetahLexer` that highlights unlexed data
     with the `HtmlLexer`.
     """
 
@@ -782,7 +792,7 @@ class CheetahHtmlLexer(DelegatingLexer):
 
 class CheetahXmlLexer(DelegatingLexer):
     """
-    Subclass of the `CheetahLexer` that highlights unlexer data
+    Subclass of the `CheetahLexer` that highlights unlexed data
     with the `XmlLexer`.
     """
 
@@ -797,7 +807,7 @@ class CheetahXmlLexer(DelegatingLexer):
 
 class CheetahJavascriptLexer(DelegatingLexer):
     """
-    Subclass of the `CheetahLexer` that highlights unlexer data
+    Subclass of the `CheetahLexer` that highlights unlexed data
     with the `JavascriptLexer`.
     """
 
@@ -828,11 +838,11 @@ class GenshiTextLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'[^#\$\s]+', Other),
+            (r'[^#$\s]+', Other),
             (r'^(\s*)(##.*)$', bygroups(Text, Comment)),
             (r'^(\s*)(#)', bygroups(Text, Comment.Preproc), 'directive'),
             include('variable'),
-            (r'[#\$\s]', Other),
+            (r'[#$\s]', Other),
         ],
         'directive': [
             (r'\n', Text, '#pop'),
@@ -845,7 +855,7 @@ class GenshiTextLexer(RegexLexer):
         'variable': [
             (r'(?<!\$)(\$\{)(.+?)(\})',
              bygroups(Comment.Preproc, using(PythonLexer), Comment.Preproc)),
-            (r'(?<!\$)(\$)([a-zA-Z_][\w\.]*)',
+            (r'(?<!\$)(\$)([a-zA-Z_][\w.]*)',
              Name.Variable),
         ]
     }
@@ -861,15 +871,15 @@ class GenshiMarkupLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'[^<\$]+', Other),
+            (r'[^<$]+', Other),
             (r'(<\?python)(.*?)(\?>)',
              bygroups(Comment.Preproc, using(PythonLexer), Comment.Preproc)),
             # yield style and script blocks as Other
             (r'<\s*(script|style)\s*.*?>.*?<\s*/\1\s*>', Other),
             (r'<\s*py:[a-zA-Z0-9]+', Name.Tag, 'pytag'),
-            (r'<\s*[a-zA-Z0-9:]+', Name.Tag, 'tag'),
+            (r'<\s*[a-zA-Z0-9:.]+', Name.Tag, 'tag'),
             include('variable'),
-            (r'[<\$]', Other),
+            (r'[<$]', Other),
         ],
         'pytag': [
             (r'\s+', Text),
@@ -1116,7 +1126,7 @@ class HtmlPhpLexer(DelegatingLexer):
 
 class XmlPhpLexer(DelegatingLexer):
     """
-    Subclass of `PhpLexer` that higlights unhandled data with the `XmlLexer`.
+    Subclass of `PhpLexer` that highlights unhandled data with the `XmlLexer`.
     """
 
     name = 'XML+PHP'
@@ -1174,7 +1184,7 @@ class JavascriptPhpLexer(DelegatingLexer):
 
 class HtmlSmartyLexer(DelegatingLexer):
     """
-    Subclass of the `SmartyLexer` that highighlights unlexed data with the
+    Subclass of the `SmartyLexer` that highlights unlexed data with the
     `HtmlLexer`.
 
     Nested Javascript and CSS is highlighted too.
@@ -1257,7 +1267,7 @@ class JavascriptSmartyLexer(DelegatingLexer):
 
 class HtmlDjangoLexer(DelegatingLexer):
     """
-    Subclass of the `DjangoLexer` that highighlights unlexed data with the
+    Subclass of the `DjangoLexer` that highlights unlexed data with the
     `HtmlLexer`.
 
     Nested Javascript and CSS is highlighted too.
@@ -1416,7 +1426,7 @@ class EvoqueLexer(RegexLexer):
                       String, Punctuation)),
             # directives: evoque, overlay
             # see doc for handling first name arg: /directives/evoque/
-            #+ minor inconsistency: the "name" in e.g. $overlay{name=site_base}
+            # + minor inconsistency: the "name" in e.g. $overlay{name=site_base}
             # should be using(PythonLexer), not passed out as String
             (r'(\$)(evoque|overlay)(\{(%)?)(\s*[#\w\-"\'.]+[^=,%}]+?)?'
              r'(.*?)((?(4)%)\})',
@@ -1442,6 +1452,7 @@ class EvoqueLexer(RegexLexer):
         ],
     }
 
+
 class EvoqueHtmlLexer(DelegatingLexer):
     """
     Subclass of the `EvoqueLexer` that highlights unlexed data with the
@@ -1458,6 +1469,7 @@ class EvoqueHtmlLexer(DelegatingLexer):
         super(EvoqueHtmlLexer, self).__init__(HtmlLexer, EvoqueLexer,
                                               **options)
 
+
 class EvoqueXmlLexer(DelegatingLexer):
     """
     Subclass of the `EvoqueLexer` that highlights unlexed data with the
@@ -1474,6 +1486,7 @@ class EvoqueXmlLexer(DelegatingLexer):
         super(EvoqueXmlLexer, self).__init__(XmlLexer, EvoqueLexer,
                                              **options)
 
+
 class ColdfusionLexer(RegexLexer):
     """
     Coldfusion statements
@@ -1554,7 +1567,7 @@ class ColdfusionMarkupLexer(RegexLexer):
             (r'[^#<]+', Other),
             (r'(#)(.*?)(#)', bygroups(Punctuation, using(ColdfusionLexer),
                                       Punctuation)),
-            #(r'<cfoutput.*?>', Name.Builtin, '#push'),
+            # (r'<cfoutput.*?>', Name.Builtin, '#push'),
             (r'</cfoutput.*?>', Name.Builtin, '#pop'),
             include('tags'),
             (r'(?s)<[^<>]*', Other),
@@ -1585,6 +1598,8 @@ class ColdfusionHtmlLexer(DelegatingLexer):
 class ColdfusionCFCLexer(DelegatingLexer):
     """
     Coldfusion markup/script components
+
+    .. versionadded:: 2.0
     """
     name = 'Coldfusion CFC'
     aliases = ['cfc']
@@ -1593,7 +1608,7 @@ class ColdfusionCFCLexer(DelegatingLexer):
 
     def __init__(self, **options):
         super(ColdfusionCFCLexer, self).__init__(ColdfusionHtmlLexer, ColdfusionLexer,
-                                                  **options)
+                                                 **options)
 
 
 class SspLexer(DelegatingLexer):
@@ -1634,13 +1649,13 @@ class TeaTemplateRootLexer(RegexLexer):
             (r'<%\S?', Keyword, 'sec'),
             (r'[^<]+', Other),
             (r'<', Other),
-            ],
+        ],
         'sec': [
             (r'%>', Keyword, '#pop'),
             # note: '\w\W' != '.' without DOTALL.
             (r'[\w\W]+?(?=%>|\Z)', using(TeaLangLexer)),
-            ],
-        }
+        ],
+    }
 
 
 class TeaTemplateLexer(DelegatingLexer):
@@ -1690,9 +1705,7 @@ class LassoHtmlLexer(DelegatingLexer):
 
     def analyse_text(text):
         rv = LassoLexer.analyse_text(text) - 0.01
-        if re.search(r'<\w+>', text, re.I):
-            rv += 0.2
-        if html_doctype_matches(text):
+        if html_doctype_matches(text):  # same as HTML lexer
             rv += 0.5
         return rv
 
@@ -1769,16 +1782,17 @@ class LassoJavascriptLexer(DelegatingLexer):
 
     def analyse_text(text):
         rv = LassoLexer.analyse_text(text) - 0.05
-        if 'function' in text:
-            rv += 0.2
         return rv
 
+
 class HandlebarsLexer(RegexLexer):
     """
     Generic `handlebars <http://handlebarsjs.com/>` template lexer.
 
     Highlights only the Handlebars template tags (stuff between `{{` and `}}`).
     Everything else is left for a delegating lexer.
+
+    .. versionadded:: 2.0
     """
 
     name = "Handlebars"
@@ -1788,10 +1802,10 @@ class HandlebarsLexer(RegexLexer):
         'root': [
             (r'[^{]+', Other),
 
-            (r'{{!.*}}', Comment),
+            (r'\{\{!.*\}\}', Comment),
 
-            (r'({{{)(\s*)', bygroups(Comment.Special, Text), 'tag'),
-            (r'({{)(\s*)', bygroups(Comment.Preproc, Text), 'tag'),
+            (r'(\{\{\{)(\s*)', bygroups(Comment.Special, Text), 'tag'),
+            (r'(\{\{)(\s*)', bygroups(Comment.Preproc, Text), 'tag'),
         ],
 
         'tag': [
@@ -1800,20 +1814,20 @@ class HandlebarsLexer(RegexLexer):
             (r'\}\}', Comment.Preproc, '#pop'),
 
             # Handlebars
-            (r'([\#/]*)(each|if|unless|else|with|log|in)', bygroups(Keyword,
+            (r'([#/]*)(each|if|unless|else|with|log|in)', bygroups(Keyword,
              Keyword)),
 
             # General {{#block}}
-            (r'([\#/])(\w+)', bygroups(Name.Function, Name.Function)),
+            (r'([#/])([\w-]+)', bygroups(Name.Function, Name.Function)),
 
             # {{opt=something}}
-            (r'(\w+)(=)', bygroups(Name.Attribute, Operator)),
+            (r'([\w-]+)(=)', bygroups(Name.Attribute, Operator)),
 
             # borrowed from DjangoLexer
             (r':?"(\\\\|\\"|[^"])*"', String.Double),
             (r":?'(\\\\|\\'|[^'])*'", String.Single),
             (r'[a-zA-Z][\w-]*', Name.Variable),
-            (r'\.\w+', Name.Variable),
+            (r'\.[\w-]+', Name.Variable),
             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
         ]
@@ -1824,6 +1838,8 @@ class HandlebarsHtmlLexer(DelegatingLexer):
     """
     Subclass of the `HandlebarsLexer` that highlights unlexed data with the
     `HtmlLexer`.
+
+    .. versionadded:: 2.0
     """
 
     name = "HTML+Handlebars"
@@ -1837,7 +1853,7 @@ class HandlebarsHtmlLexer(DelegatingLexer):
 
 class YamlJinjaLexer(DelegatingLexer):
     """
-    Subclass of the `DjangoLexer` that highighlights unlexed data with the
+    Subclass of the `DjangoLexer` that highlights unlexed data with the
     `YamlLexer`.
 
     Commonly used in Saltstack salt states.
@@ -1871,10 +1887,10 @@ class LiquidLexer(RegexLexer):
             # tags and block tags
             (r'(\{%)(\s*)', bygroups(Punctuation, Whitespace), 'tag-or-block'),
             # output tags
-            (r'({{)(\s*)([^\s}]+)',
+            (r'(\{\{)(\s*)([^\s}]+)',
              bygroups(Punctuation, Whitespace, using(this, state = 'generic')),
              'output'),
-            (r'{', Text)
+            (r'\{', Text)
         ],
 
         'tag-or-block': [
@@ -1912,16 +1928,16 @@ class LiquidLexer(RegexLexer):
 
         'output': [
             include('whitespace'),
-            ('\}\}', Punctuation, '#pop'), # end of output
+            ('\}\}', Punctuation, '#pop'),  # end of output
 
             (r'\|', Punctuation, 'filters')
         ],
 
         'filters': [
             include('whitespace'),
-            (r'\}\}', Punctuation, ('#pop', '#pop')), # end of filters and output
+            (r'\}\}', Punctuation, ('#pop', '#pop')),  # end of filters and output
 
-            (r'([^\s\|:]+)(:?)(\s*)',
+            (r'([^\s|:]+)(:?)(\s*)',
              bygroups(Name.Function, Punctuation, Whitespace), 'filter-markup')
         ],
 
@@ -1941,7 +1957,7 @@ class LiquidLexer(RegexLexer):
                       Punctuation)),
             (r'\b!', Operator),
             (r'\bnot\b', Operator.Word),
-            (r'([\w\.\'"]+)(\s+)(contains)(\s+)([\w\.\'"]+)',
+            (r'([\w.\'"]+)(\s+)(contains)(\s+)([\w.\'"]+)',
              bygroups(using(this, state = 'generic'), Whitespace, Operator.Word,
                       Whitespace, using(this, state = 'generic'))),
 
@@ -1980,7 +1996,7 @@ class LiquidLexer(RegexLexer):
             (r'([^\s=:]+)(\s*)(=|:)',
              bygroups(Name.Attribute, Whitespace, Operator)),
             # explicit variables
-            (r'(\{\{)(\s*)([^\s\}])(\s*)(\}\})',
+            (r'(\{\{)(\s*)([^\s}])(\s*)(\}\})',
              bygroups(Punctuation, Whitespace, using(this, state = 'variable'),
                       Whitespace, Punctuation)),
 
@@ -1992,22 +2008,22 @@ class LiquidLexer(RegexLexer):
 
         'default-param-markup': [
             include('param-markup'),
-            (r'.', Text) # fallback for switches / variables / un-quoted strings / ...
+            (r'.', Text)  # fallback for switches / variables / un-quoted strings / ...
         ],
 
         'variable-param-markup': [
             include('param-markup'),
             include('variable'),
-            (r'.', Text) # fallback
+            (r'.', Text)  # fallback
         ],
 
         'tag-markup': [
-            (r'%\}', Punctuation, ('#pop', '#pop')), # end of tag
+            (r'%\}', Punctuation, ('#pop', '#pop')),  # end of tag
             include('default-param-markup')
         ],
 
         'variable-tag-markup': [
-            (r'%\}', Punctuation, ('#pop', '#pop')), # end of tag
+            (r'%\}', Punctuation, ('#pop', '#pop')),  # end of tag
             include('variable-param-markup')
         ],
 
@@ -2031,7 +2047,7 @@ class LiquidLexer(RegexLexer):
             (r'\d+', Number.Integer)
         ],
 
-        'generic': [ # decides for variable, string, keyword or number
+        'generic': [  # decides for variable, string, keyword or number
             include('keyword'),
             include('string'),
             include('number'),
@@ -2051,10 +2067,186 @@ class LiquidLexer(RegexLexer):
         ],
 
         'raw': [
-            (r'[^\{]+', Text),
+            (r'[^{]+', Text),
             (r'(\{%)(\s*)(endraw)(\s*)(%\})',
              bygroups(Punctuation, Whitespace, Name.Tag, Whitespace,
                       Punctuation), '#pop'),
             (r'\{', Text)
-        ]
+        ],
     }
+
+
+class TwigLexer(RegexLexer):
+    """
+    `Twig <http://twig.sensiolabs.org/>`_ template lexer.
+
+    It just highlights Twig code between the preprocessor directives,
+    other data is left untouched by the lexer.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Twig'
+    aliases = ['twig']
+    mimetypes = ['application/x-twig']
+
+    flags = re.M | re.S
+
+    # Note that a backslash is included in the following two patterns
+    # PHP uses a backslash as a namespace separator
+    _ident_char = r'[\\\w-]|[^\x00-\x7f]'
+    _ident_begin = r'(?:[\\_a-z]|[^\x00-\x7f])'
+    _ident_end = r'(?:' + _ident_char + ')*'
+    _ident_inner = _ident_begin + _ident_end
+
+    tokens = {
+        'root': [
+            (r'[^{]+', Other),
+            (r'\{\{', Comment.Preproc, 'var'),
+            # twig comments
+            (r'\{\#.*?\#\}', Comment),
+            # raw twig blocks
+            (r'(\{%)(-?\s*)(raw)(\s*-?)(%\})(.*?)'
+             r'(\{%)(-?\s*)(endraw)(\s*-?)(%\})',
+             bygroups(Comment.Preproc, Text, Keyword, Text, Comment.Preproc,
+                      Other, Comment.Preproc, Text, Keyword, Text,
+                      Comment.Preproc)),
+            (r'(\{%)(-?\s*)(verbatim)(\s*-?)(%\})(.*?)'
+             r'(\{%)(-?\s*)(endverbatim)(\s*-?)(%\})',
+             bygroups(Comment.Preproc, Text, Keyword, Text, Comment.Preproc,
+                      Other, Comment.Preproc, Text, Keyword, Text,
+                      Comment.Preproc)),
+            # filter blocks
+            (r'(\{%%)(-?\s*)(filter)(\s+)(%s)' % _ident_inner,
+             bygroups(Comment.Preproc, Text, Keyword, Text, Name.Function),
+             'tag'),
+            (r'(\{%)(-?\s*)([a-zA-Z_]\w*)',
+             bygroups(Comment.Preproc, Text, Keyword), 'tag'),
+            (r'\{', Other),
+        ],
+        'varnames': [
+            (r'(\|)(\s*)(%s)' % _ident_inner,
+             bygroups(Operator, Text, Name.Function)),
+            (r'(is)(\s+)(not)?(\s*)(%s)' % _ident_inner,
+             bygroups(Keyword, Text, Keyword, Text, Name.Function)),
+            (r'(?i)(true|false|none|null)\b', Keyword.Pseudo),
+            (r'(in|not|and|b-and|or|b-or|b-xor|is'
+             r'if|elseif|else|import'
+             r'constant|defined|divisibleby|empty|even|iterable|odd|sameas'
+             r'matches|starts\s+with|ends\s+with)\b',
+             Keyword),
+            (r'(loop|block|parent)\b', Name.Builtin),
+            (_ident_inner, Name.Variable),
+            (r'\.' + _ident_inner, Name.Variable),
+            (r'\.[0-9]+', Number),
+            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+            (r":?'(\\\\|\\'|[^'])*'", String.Single),
+            (r'([{}()\[\]+\-*/,:~%]|\.\.|\?|:|\*\*|\/\/|!=|[><=]=?)', Operator),
+            (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+             r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+        ],
+        'var': [
+            (r'\s+', Text),
+            (r'(-?)(\}\})', bygroups(Text, Comment.Preproc), '#pop'),
+            include('varnames')
+        ],
+        'tag': [
+            (r'\s+', Text),
+            (r'(-?)(%\})', bygroups(Text, Comment.Preproc), '#pop'),
+            include('varnames'),
+            (r'.', Punctuation),
+        ],
+    }
+
+
+class TwigHtmlLexer(DelegatingLexer):
+    """
+    Subclass of the `TwigLexer` that highlights unlexed data with the
+    `HtmlLexer`.
+
+    .. versionadded:: 2.0
+    """
+
+    name = "HTML+Twig"
+    aliases = ["html+twig"]
+    filenames = ['*.twig']
+    mimetypes = ['text/html+twig']
+
+    def __init__(self, **options):
+        super(TwigHtmlLexer, self).__init__(HtmlLexer, TwigLexer, **options)
+
+        
+class Angular2Lexer(RegexLexer):
+    """
+    Generic `angular2 <http://victorsavkin.com/post/119943127151/angular-2-template-syntax>` template lexer.
+
+    Highlights only the Angular template tags (stuff between `{{` and `}}` and 
+    special attributes: '(event)=', '[property]=', '[(twoWayBinding)]=').
+    Everything else is left for a delegating lexer.
+
+    .. versionadded:: 2.1a0
+    """
+
+    name = "Angular2"
+    aliases = ['ng2']
+
+    tokens = {
+        'root': [
+            (r'[^{([*#]+', Other),
+
+            # {{meal.name}}
+            (r'(\{\{)(\s*)', bygroups(Comment.Preproc, Text), 'ngExpression'),
+            
+            # (click)="deleteOrder()"; [value]="test"; [(twoWayTest)]="foo.bar"
+            (r'([([]+)([\w:.-]+)([\])]+)(\s*)(=)(\s*)',
+             bygroups(Punctuation, Name.Attribute, Punctuation, Text, Operator, Text), 'attr'),
+            (r'([([]+)([\w:.-]+)([\])]+)(\s*)',
+             bygroups(Punctuation, Name.Attribute, Punctuation, Text)),
+             
+            # *ngIf="..."; #f="ngForm"
+            (r'([*#])([\w:.-]+)(\s*)(=)(\s*)',
+             bygroups(Punctuation, Name.Attribute, Punctuation, Operator), 'attr'),
+            (r'([*#])([\w:.-]+)(\s*)',
+             bygroups(Punctuation, Name.Attribute, Punctuation)),
+        ],
+        
+        'ngExpression': [
+            (r'\s+(\|\s+)?', Text),
+            (r'\}\}', Comment.Preproc, '#pop'),
+            
+            # Literals
+            (r':?(true|false)', String.Boolean),
+            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+            (r":?'(\\\\|\\'|[^'])*'", String.Single),
+            (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+             r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+             
+            # Variabletext
+            (r'[a-zA-Z][\w-]*(\(.*\))?', Name.Variable),
+            (r'\.[\w-]+(\(.*\))?', Name.Variable),
+            
+            # inline If
+            (r'(\?)(\s*)([^}\s]+)(\s*)(:)(\s*)([^}\s]+)(\s*)', bygroups(Operator, Text, String, Text, Operator, Text, String, Text)),
+        ],
+        'attr': [
+            ('".*?"', String, '#pop'),
+            ("'.*?'", String, '#pop'),
+            (r'[^\s>]+', String, '#pop'),
+        ],
+    }
+
+
+class Angular2HtmlLexer(DelegatingLexer):
+    """
+    Subclass of the `Angular2Lexer` that highlights unlexed data with the
+    `HtmlLexer`.
+
+    .. versionadded:: 2.0
+    """
+
+    name = "HTML + Angular2"
+    aliases = ["html+ng2"]
+    filenames = ['*.ng2']
+
+    def __init__(self, **options):
+        super(Angular2HtmlLexer, self).__init__(HtmlLexer, Angular2Lexer, **options)