pygments.rb 0.5.4 → 0.6.0

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

@@ -5,7 +5,7 @@
 
     Lexers for web-related languages and markup.
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -13,11 +13,11 @@ import re
 import copy
 
 from pygments.lexer import RegexLexer, ExtendedRegexLexer, bygroups, using, \
-     include, this
+    include, this, default
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-     Number, Other, Punctuation, Literal
+    Number, Other, Punctuation, Literal
 from pygments.util import get_bool_opt, get_list_opt, looks_like_xml, \
-                          html_doctype_matches, unirange
+    html_doctype_matches, unirange, iteritems
 from pygments.lexers.agile import RubyLexer
 from pygments.lexers.compiled import ScalaLexer
 
@@ -27,7 +27,8 @@ __all__ = ['HtmlLexer', 'XmlLexer', 'JavascriptLexer', 'JsonLexer', 'CssLexer',
            'MxmlLexer', 'HaxeLexer', 'HamlLexer', 'SassLexer', 'ScssLexer',
            'ObjectiveJLexer', 'CoffeeScriptLexer', 'LiveScriptLexer',
            'DuelLexer', 'ScamlLexer', 'JadeLexer', 'XQueryLexer',
-           'DtdLexer', 'DartLexer', 'LassoLexer', 'QmlLexer', 'TypeScriptLexer']
+           'DtdLexer', 'DartLexer', 'LassoLexer', 'QmlLexer', 'TypeScriptLexer',
+           'KalLexer', 'CirruLexer', 'MaskLexer', 'ZephirLexer', 'SlimLexer']
 
 
 class JavascriptLexer(RegexLexer):
@@ -54,7 +55,7 @@ class JavascriptLexer(RegexLexer):
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
-            (r'', Text, '#pop')
+            default('#pop')
         ],
         'badregex': [
             (r'\n', Text, '#pop')
@@ -80,7 +81,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_][a-zA-Z0-9_]*', Name.Other),
+            (r'[$a-zA-Z_]\w*', Name.Other),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
@@ -94,7 +95,7 @@ class JsonLexer(RegexLexer):
     """
     For JSON data structures.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'JSON'
@@ -177,14 +178,14 @@ class ActionScriptLexer(RegexLexer):
     """
     For ActionScript source code.
 
-    *New in Pygments 0.9.*
+    .. versionadded:: 0.9
     """
 
     name = 'ActionScript'
     aliases = ['as', 'actionscript']
     filenames = ['*.as']
-    mimetypes = ['application/x-actionscript3', 'text/x-actionscript3',
-                 'text/actionscript3']
+    mimetypes = ['application/x-actionscript', 'text/x-actionscript',
+                 'text/actionscript']
 
     flags = re.DOTALL
     tokens = {
@@ -247,7 +248,7 @@ class ActionScriptLexer(RegexLexer):
              r'isXMLName|clearInterval|fscommand|getTimer|getURL|getVersion|'
              r'isFinite|parseFloat|parseInt|setInterval|trace|updateAfterEvent|'
              r'unescape)\b',Name.Function),
-            (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name.Other),
+            (r'[$a-zA-Z_]\w*', Name.Other),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-f]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
@@ -261,16 +262,16 @@ class ActionScript3Lexer(RegexLexer):
     """
     For ActionScript 3 source code.
 
-    *New in Pygments 0.11.*
+    .. versionadded:: 0.11
     """
 
     name = 'ActionScript 3'
     aliases = ['as3', 'actionscript3']
     filenames = ['*.as']
-    mimetypes = ['application/x-actionscript', 'text/x-actionscript',
-                 'text/actionscript']
+    mimetypes = ['application/x-actionscript3', 'text/x-actionscript3',
+                 'text/actionscript3']
 
-    identifier = r'[$a-zA-Z_][a-zA-Z0-9_]*'
+    identifier = r'[$a-zA-Z_]\w*'
     typeidentifier = identifier + '(?:\.<\w+>)?'
 
     flags = re.DOTALL | re.MULTILINE
@@ -358,12 +359,12 @@ class CssLexer(RegexLexer):
             (r'\s+', Text),
             (r'/\*(?:.|\n)*?\*/', Comment),
             (r'{', Punctuation, 'content'),
-            (r'\:[a-zA-Z0-9_-]+', Name.Decorator),
-            (r'\.[a-zA-Z0-9_-]+', Name.Class),
-            (r'\#[a-zA-Z0-9_-]+', Name.Function),
-            (r'@[a-zA-Z0-9_-]+', Keyword, 'atrule'),
-            (r'[a-zA-Z0-9_-]+', Name.Tag),
-            (r'[~\^\*!%&\[\]\(\)<>\|+=@:;,./?-]', Operator),
+            (r'\:[\w-]+', Name.Decorator),
+            (r'\.[\w-]+', Name.Class),
+            (r'\#[\w-]+', Name.Function),
+            (r'@[\w-]+', Keyword, 'atrule'),
+            (r'[\w-]+', Name.Tag),
+            (r'[~\^\*!%&$\[\]\(\)<>\|+=@:;,./?-]', Operator),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single)
         ],
@@ -398,19 +399,19 @@ class CssLexer(RegexLexer):
              r'list-style-type|list-style-image|list-style-position|'
              r'list-style|margin-bottom|margin-left|margin-right|'
              r'margin-top|margin|marker-offset|marks|max-height|max-width|'
-             r'min-height|min-width|opacity|orphans|outline|outline-color|'
-             r'outline-style|outline-width|overflow(?:-x|-y)?|padding-bottom|'
+             r'min-height|min-width|opacity|orphans|outline-color|'
+             r'outline-style|outline-width|outline|overflow(?:-x|-y)?|padding-bottom|'
              r'padding-left|padding-right|padding-top|padding|page|'
              r'page-break-after|page-break-before|page-break-inside|'
-             r'pause-after|pause-before|pause|pitch|pitch-range|'
+             r'pause-after|pause-before|pause|pitch-range|pitch|'
              r'play-during|position|quotes|richness|right|size|'
              r'speak-header|speak-numeral|speak-punctuation|speak|'
              r'speech-rate|stress|table-layout|text-align|text-decoration|'
              r'text-indent|text-shadow|text-transform|top|unicode-bidi|'
              r'vertical-align|visibility|voice-family|volume|white-space|'
-             r'widows|width|word-spacing|z-index|bottom|left|'
+             r'widows|width|word-spacing|z-index|bottom|'
              r'above|absolute|always|armenian|aural|auto|avoid|baseline|'
-             r'behind|below|bidi-override|blink|block|bold|bolder|both|'
+             r'behind|below|bidi-override|blink|block|bolder|bold|both|'
              r'capitalize|center-left|center-right|center|circle|'
              r'cjk-ideographic|close-quote|collapse|condensed|continuous|'
              r'crop|crosshair|cross|cursive|dashed|decimal-leading-zero|'
@@ -420,7 +421,7 @@ class CssLexer(RegexLexer):
              r'hidden|hide|higher|high|hiragana-iroha|hiragana|icon|'
              r'inherit|inline-table|inline|inset|inside|invert|italic|'
              r'justify|katakana-iroha|katakana|landscape|larger|large|'
-             r'left-side|leftwards|level|lighter|line-through|list-item|'
+             r'left-side|leftwards|left|level|lighter|line-through|list-item|'
              r'loud|lower-alpha|lower-greek|lower-roman|lowercase|ltr|'
              r'lower|low|medium|message-box|middle|mix|monospace|'
              r'n-resize|narrower|ne-resize|no-close-quote|no-open-quote|'
@@ -429,11 +430,11 @@ class CssLexer(RegexLexer):
              r'relative|repeat-x|repeat-y|repeat|rgb|ridge|right-side|'
              r'rightwards|s-resize|sans-serif|scroll|se-resize|'
              r'semi-condensed|semi-expanded|separate|serif|show|silent|'
-             r'slow|slower|small-caps|small-caption|smaller|soft|solid|'
+             r'slower|slow|small-caps|small-caption|smaller|soft|solid|'
              r'spell-out|square|static|status-bar|super|sw-resize|'
              r'table-caption|table-cell|table-column|table-column-group|'
              r'table-footer-group|table-header-group|table-row|'
-             r'table-row-group|text|text-bottom|text-top|thick|thin|'
+             r'table-row-group|text-bottom|text-top|text|thick|thin|'
              r'transparent|ultra-condensed|ultra-expanded|underline|'
              r'upper-alpha|upper-latin|upper-roman|uppercase|url|'
              r'visible|w-resize|wait|wider|x-fast|x-high|x-large|x-loud|'
@@ -466,13 +467,15 @@ class CssLexer(RegexLexer):
             (r'\!important', Comment.Preproc),
             (r'/\*(?:.|\n)*?\*/', Comment),
             (r'\#[a-zA-Z0-9]{1,6}', Number),
-            (r'[\.-]?[0-9]*[\.]?[0-9]+(em|px|\%|pt|pc|in|mm|cm|ex|s)\b', Number),
+            (r'[\.-]?[0-9]*[\.]?[0-9]+(em|px|pt|pc|in|mm|cm|ex|s)\b', Number),
+            # Separate regex for percentages, as can't do word boundaries with %
+            (r'[\.-]?[0-9]*[\.]?[0-9]+%', Number),
             (r'-?[0-9]+', Number),
             (r'[~\^\*!%&<>\|+=@:,./?-]+', Operator),
             (r'[\[\]();]+', Punctuation),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
             (r"'(\\\\|\\'|[^'])*'", String.Single),
-            (r'[a-zA-Z_][a-zA-Z0-9_]*', Name)
+            (r'[a-zA-Z_]\w*', Name)
         ]
     }
 
@@ -481,7 +484,7 @@ class ObjectiveJLexer(RegexLexer):
     """
     For Objective-J source code with preprocessor directives.
 
-    *New in Pygments 1.3.*
+    .. versionadded:: 1.3
     """
 
     name = 'Objective-J'
@@ -539,7 +542,7 @@ class ObjectiveJLexer(RegexLexer):
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
         'badregex': [
             (r'\n', Text, '#pop'),
@@ -592,26 +595,26 @@ class ObjectiveJLexer(RegexLexer):
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
              r'window)\b', Name.Builtin),
 
-            (r'([$a-zA-Z_][a-zA-Z0-9_]*)(' + _ws + r')(?=\()',
+            (r'([$a-zA-Z_]\w*)(' + _ws + r')(?=\()',
              bygroups(Name.Function, using(this))),
 
-            (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name),
+            (r'[$a-zA-Z_]\w*', Name),
         ],
         'classname' : [
             # interface definition that inherits
-            (r'([a-zA-Z_][a-zA-Z0-9_]*)(' + _ws + r':' + _ws +
-             r')([a-zA-Z_][a-zA-Z0-9_]*)?',
+            (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_][a-zA-Z0-9_]*)(' + _ws + r'\()([a-zA-Z_][a-zA-Z0-9_]*)(\))',
+            (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_][a-zA-Z0-9_]*)', Name.Class, '#pop'),
+            (r'([a-zA-Z_]\w*)', Name.Class, '#pop'),
         ],
         'forward_classname' : [
-            (r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*,\s*)',
+            (r'([a-zA-Z_]\w*)(\s*,\s*)',
              bygroups(Name.Class, Text), '#push'),
-            (r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*;?)',
+            (r'([a-zA-Z_]\w*)(\s*;?)',
              bygroups(Name.Class, Text), '#pop'),
         ],
         'function_signature': [
@@ -619,26 +622,26 @@ class ObjectiveJLexer(RegexLexer):
 
             # start of a selector w/ parameters
             (r'(\(' + _ws + r')'                # open paren
-             r'([a-zA-Z_][a-zA-Z0-9_]+)'        # return type
+             r'([a-zA-Z_]\w+)'                  # return type
              r'(' + _ws + r'\)' + _ws + r')'    # close paren
-             r'([$a-zA-Z_][a-zA-Z0-9_]+' + _ws + r':)', # function name
+             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_][a-zA-Z0-9_]+)'        # return type
+             r'([a-zA-Z_]\w+)'                  # return type
              r'(' + _ws + r'\)' + _ws + r')'    # close paren
-             r'([$a-zA-Z_][a-zA-Z0-9_]+)',      # function name
+             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_][a-zA-Z0-9_]+' + _ws + r':)', # function name
+            (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_][a-zA-Z0-9_]+)',      # function name
+            (r'([$a-zA-Z_]\w+)',                # function name
              bygroups(Name.Function), "#pop"),
 
             ('', Text, '#pop'),
@@ -650,11 +653,11 @@ class ObjectiveJLexer(RegexLexer):
             (r'(\(' + _ws + ')'                 # open paren
              r'([^\)]+)'                        # type
              r'(' + _ws + r'\)' + _ws + r')'    # close paren
-             r'([$a-zA-Z_][a-zA-Z0-9_]+)',      # param name
+             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_][a-zA-Z0-9_]+' + _ws + r':)',     # function name
+            (r'([$a-zA-Z_]\w+' + _ws + r':)',   # function name
              Name.Function),
 
             # smallest possible selector piece
@@ -664,10 +667,10 @@ class ObjectiveJLexer(RegexLexer):
             (r'(,' + _ws + r'\.\.\.)', using(this)),
 
             # param name
-            (r'([$a-zA-Z_][a-zA-Z0-9_]+)', Text),
+            (r'([$a-zA-Z_]\w+)', Text),
         ],
         'expression' : [
-            (r'([$a-zA-Z_][a-zA-Z0-9_]*)(\()', bygroups(Name.Function,
+            (r'([$a-zA-Z_]\w*)(\()', bygroups(Name.Function,
                                                         Punctuation)),
             (r'(\))', Punctuation, "#pop"),
         ],
@@ -734,8 +737,8 @@ class HtmlLexer(RegexLexer):
         ],
         'tag': [
             (r'\s+', Text),
-            (r'[a-zA-Z0-9_:-]+\s*=', Name.Attribute, 'attr'),
-            (r'[a-zA-Z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+\s*=', Name.Attribute, 'attr'),
+            (r'[\w:-]+', Name.Attribute),
             (r'/?\s*>', Name.Tag, '#pop'),
         ],
         'script-content': [
@@ -796,6 +799,13 @@ class PhpLexer(RegexLexer):
     filenames = ['*.php', '*.php[345]', '*.inc']
     mimetypes = ['text/x-php']
 
+    # 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
+
     flags = re.IGNORECASE | re.DOTALL | re.MULTILINE
     tokens = {
         'root': [
@@ -805,7 +815,7 @@ class PhpLexer(RegexLexer):
         ],
         'php': [
             (r'\?>', Comment.Preproc, '#pop'),
-            (r'<<<(\'?)([a-zA-Z_][a-zA-Z0-9_]*)\1\n.*?\n\2\;?\n', String),
+            (r'<<<(\'?)(' + _ident_inner + ')\1\n.*?\n\2\;?\n', String),
             (r'\s+', Text),
             (r'#.*?\n', Comment.Single),
             (r'//.*?\n', Comment.Single),
@@ -814,7 +824,7 @@ class PhpLexer(RegexLexer):
             (r'/\*\*/', Comment.Multiline),
             (r'/\*\*.*?\*/', String.Doc),
             (r'/\*.*?\*/', Comment.Multiline),
-            (r'(->|::)(\s*)([a-zA-Z_][a-zA-Z0-9_]*)',
+            (r'(->|::)(\s*)(' + _ident_inner + ')',
              bygroups(Operator, Text, Name.Attribute)),
             (r'[~!%^&*+=|:.<>/?@-]+', Operator),
             (r'[\[\]{}();,]+', Punctuation),
@@ -822,7 +832,7 @@ class PhpLexer(RegexLexer):
             (r'(function)(\s*)(?=\()', bygroups(Keyword, Text)),
             (r'(function)(\s+)(&?)(\s*)',
               bygroups(Keyword, Text, Operator, Text), 'functionname'),
-            (r'(const)(\s+)([a-zA-Z_][a-zA-Z0-9_]*)',
+            (r'(const)(\s+)(' + _ident_inner + ')',
               bygroups(Keyword, Text, Name.Constant)),
             (r'(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|'
              r'eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|'
@@ -833,31 +843,33 @@ class PhpLexer(RegexLexer):
              r'endif|list|__LINE__|endswitch|new|__sleep|endwhile|not|'
              r'array|__wakeup|E_ALL|NULL|final|php_user_filter|interface|'
              r'implements|public|private|protected|abstract|clone|try|'
-             r'catch|throw|this|use|namespace|trait)\b', Keyword),
+             r'catch|throw|this|use|namespace|trait|yield|'
+             r'finally)\b', Keyword),
             (r'(true|false|null)\b', Keyword.Constant),
-            (r'\$\{\$+[a-zA-Z_][a-zA-Z0-9_]*\}', Name.Variable),
-            (r'\$+[a-zA-Z_][a-zA-Z0-9_]*', Name.Variable),
-            (r'[\\a-zA-Z_][\\a-zA-Z0-9_]*', Name.Other),
+            (r'\$\{\$+' + _ident_inner + '\}', Name.Variable),
+            (r'\$+' + _ident_inner, Name.Variable),
+            (_ident_inner, Name.Other),
             (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
             (r'\d+[eE][+-]?[0-9]+', Number.Float),
             (r'0[0-7]+', Number.Oct),
-            (r'0[xX][a-fA-F0-9]+', Number.Hex),
+            (r'0[xX][a-f0-9]+', Number.Hex),
             (r'\d+', Number.Integer),
+            (r'0b[01]+', Number.Bin),
             (r"'([^'\\]*(?:\\.[^'\\]*)*)'", String.Single),
             (r'`([^`\\]*(?:\\.[^`\\]*)*)`', String.Backtick),
             (r'"', String.Double, 'string'),
         ],
         'classname': [
-            (r'[a-zA-Z_][\\a-zA-Z0-9_]*', Name.Class, '#pop')
+            (_ident_inner, Name.Class, '#pop')
         ],
         'functionname': [
-            (r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Function, '#pop')
+            (_ident_inner, Name.Function, '#pop')
         ],
         'string': [
             (r'"', String.Double, '#pop'),
             (r'[^{$"\\]+', String.Double),
-            (r'\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})', String.Escape),
-            (r'\$[a-zA-Z_][a-zA-Z0-9_]*(\[\S+\]|->[a-zA-Z_][a-zA-Z0-9_]*)?',
+            (r'\\([nrt\"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})', String.Escape),
+            (r'\$' + _ident_inner + '(\[\S+?\]|->' + _ident_inner + ')?',
              String.Interpol),
             (r'(\{\$\{)(.*?)(\}\})',
              bygroups(String.Interpol, using(this, _startinline=True),
@@ -886,7 +898,7 @@ class PhpLexer(RegexLexer):
         self._functions = set()
         if self.funcnamehighlighting:
             from pygments.lexers._phpbuiltins import MODULES
-            for key, value in MODULES.iteritems():
+            for key, value in iteritems(MODULES):
                 if key not in self.disabledmodules:
                     self._functions.update(value)
         RegexLexer.__init__(self, **options)
@@ -916,7 +928,7 @@ class DtdLexer(RegexLexer):
     """
     A lexer for DTDs (Document Type Definitions).
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     flags = re.MULTILINE | re.DOTALL
@@ -1051,7 +1063,7 @@ class XsltLexer(XmlLexer):
     '''
     A lexer for XSLT.
 
-    *New in Pygments 0.10.*
+    .. versionadded:: 0.10
     '''
 
     name = 'XSLT'
@@ -1089,7 +1101,7 @@ class MxmlLexer(RegexLexer):
     For MXML markup.
     Nested AS3 in <script> tags is highlighted by the appropriate lexer.
 
-    *New in Pygments 1.1.*
+    .. versionadded:: 1.1
     """
     flags = re.MULTILINE | re.DOTALL
     name = 'MXML'
@@ -1106,8 +1118,8 @@ class MxmlLexer(RegexLexer):
                 ('<!--', Comment, 'comment'),
                 (r'<\?.*?\?>', Comment.Preproc),
                 ('<![^>]*>', Comment.Preproc),
-                (r'<\s*[a-zA-Z0-9:._-]+', Name.Tag, 'tag'),
-                (r'<\s*/\s*[a-zA-Z0-9:._-]+\s*>', Name.Tag),
+                (r'<\s*[\w:.-]+', Name.Tag, 'tag'),
+                (r'<\s*/\s*[\w:.-]+\s*>', Name.Tag),
             ],
             'comment': [
                 ('[^-]+', Comment),
@@ -1116,7 +1128,7 @@ class MxmlLexer(RegexLexer):
             ],
             'tag': [
                 (r'\s+', Text),
-                (r'[a-zA-Z0-9_.:-]+\s*=', Name.Attribute, 'attr'),
+                (r'[\w.:-]+\s*=', Name.Attribute, 'attr'),
                 (r'/?\s*>', Name.Tag, '#pop'),
             ],
             'attr': [
@@ -1132,11 +1144,11 @@ class HaxeLexer(ExtendedRegexLexer):
     """
     For Haxe source code (http://haxe.org/).
 
-    *New in Pygments 1.3.*
+    .. versionadded:: 1.3
     """
 
     name = 'Haxe'
-    aliases = ['hx', 'Haxe', 'haxe', 'haXe', 'hxsl']
+    aliases = ['hx', 'haxe', 'hxsl']
     filenames = ['*.hx', '*.hxsl']
     mimetypes = ['text/haxe', 'text/x-haxe', 'text/x-hx']
 
@@ -1149,11 +1161,10 @@ class HaxeLexer(ExtendedRegexLexer):
                r'inline|using|null|true|false|abstract)\b')
 
     # idtype in lexer.mll
-    typeid = r'_*[A-Z][_a-zA-Z0-9]*'
+    typeid = r'_*[A-Z]\w*'
 
     # combined ident and dollar and idtype
-    ident = r'(?:_*[a-z][_a-zA-Z0-9]*|_+[0-9][_a-zA-Z0-9]*|' + typeid + \
-        '|_+|\$[_a-zA-Z0-9]+)'
+    ident = r'(?:_*[a-z]\w*|_+[0-9]\w*|' + typeid + '|_+|\$\w+)'
 
     binop = (r'(?:%=|&=|\|=|\^=|\+=|\-=|\*=|/=|<<=|>\s*>\s*=|>\s*>\s*>\s*=|==|'
              r'!=|<=|>\s*=|&&|\|\||<<|>>>|>\s*>|\.\.\.|<|>|%|&|\||\^|\+|\*|'
@@ -1247,7 +1258,7 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             (ident, Name.Namespace),
             (r'\.', Punctuation, 'import-ident'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'import': [
@@ -1256,7 +1267,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'\*', Keyword), # wildcard import
             (r'\.', Punctuation, 'import-ident'),
             (r'in', Keyword.Namespace, 'ident'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'import-ident': [
@@ -1269,14 +1280,14 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             (ident, Name.Namespace),
             (r'\.', Punctuation, 'import-ident'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'preproc-error': [
             (r'\s+', Comment.Preproc),
             (r"'", String.Single, ('#pop', 'string-single')),
             (r'"', String.Double, ('#pop', 'string-double')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'preproc-expr': [
@@ -1285,6 +1296,19 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'\(', Comment.Preproc, ('#pop', 'preproc-parenthesis')),
 
             (ident, Comment.Preproc, '#pop'),
+
+            # Float
+            (r'\.[0-9]+', Number.Float),
+            (r'[0-9]+[eE][\+\-]?[0-9]+', Number.Float),
+            (r'[0-9]+\.[0-9]*[eE][\+\-]?[0-9]+', Number.Float),
+            (r'[0-9]+\.[0-9]+', Number.Float),
+            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float),
+
+            # Int
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # String
             (r"'", String.Single, ('#pop', 'string-single')),
             (r'"', String.Double, ('#pop', 'string-double')),
         ],
@@ -1298,7 +1322,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'preproc-expr-chain': [
             (r'\s+', Comment.Preproc),
             (binop, Comment.Preproc, ('#pop', 'preproc-expr-in-parenthesis')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # same as 'preproc-expr' but able to chain 'preproc-expr-chain'
@@ -1309,6 +1333,19 @@ class HaxeLexer(ExtendedRegexLexer):
              ('#pop', 'preproc-expr-chain', 'preproc-parenthesis')),
 
             (ident, Comment.Preproc, ('#pop', 'preproc-expr-chain')),
+
+            # Float
+            (r'\.[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+[eE][\+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+\.[0-9]*[eE][\+\-]?[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+\.[0-9]+', Number.Float, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+\.(?!' + ident + '|\.\.)', Number.Float, ('#pop', 'preproc-expr-chain')),
+
+            # Int
+            (r'0x[0-9a-fA-F]+', Number.Hex, ('#pop', 'preproc-expr-chain')),
+            (r'[0-9]+', Number.Integer, ('#pop', 'preproc-expr-chain')),
+
+            # String
             (r"'", String.Single,
              ('#pop', 'preproc-expr-chain', 'string-single')),
             (r'"', String.Double,
@@ -1317,7 +1354,7 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'abstract' : [
             include('spaces'),
-            (r'', Text, ('#pop', 'abstract-body', 'abstract-relation',
+            default(('#pop', 'abstract-body', 'abstract-relation',
                     'abstract-opaque', 'type-param-constraint', 'type-name')),
         ],
 
@@ -1329,14 +1366,14 @@ class HaxeLexer(ExtendedRegexLexer):
         'abstract-opaque' : [
             include('spaces'),
             (r'\(', Punctuation, ('#pop', 'parenthesis-close', 'type')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'abstract-relation': [
             include('spaces'),
             (r'(?:to|from)', Keyword.Declaration, 'type'),
             (r',', Punctuation),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'meta': [
@@ -1348,7 +1385,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'meta-colon': [
             include('spaces'),
             (r':', Name.Decorator, '#pop'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # same as 'ident' but set token as Name.Decorator instead of Name
@@ -1360,13 +1397,13 @@ class HaxeLexer(ExtendedRegexLexer):
         'meta-body': [
             include('spaces'),
             (r'\(', Name.Decorator, ('#pop', 'meta-call')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'meta-call': [
             include('spaces'),
             (r'\)', Name.Decorator, '#pop'),
-            (r'', Text, ('#pop', 'meta-call-sep', 'expr')),
+            default(('#pop', 'meta-call-sep', 'expr')),
         ],
 
         'meta-call-sep': [
@@ -1377,7 +1414,7 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'typedef': [
             include('spaces'),
-            (r'', Text, ('#pop', 'typedef-body', 'type-param-constraint',
+            default(('#pop', 'typedef-body', 'type-param-constraint',
                          'type-name')),
         ],
 
@@ -1388,7 +1425,7 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'enum': [
             include('spaces'),
-            (r'', Text, ('#pop', 'enum-body', 'bracket-open',
+            default(('#pop', 'enum-body', 'bracket-open',
                          'type-param-constraint', 'type-name')),
         ],
 
@@ -1403,12 +1440,12 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             (r'\(', Punctuation,
              ('#pop', 'semicolon', 'flag', 'function-param')),
-            (r'', Punctuation, ('#pop', 'semicolon', 'flag')),
+            default(('#pop', 'semicolon', 'flag')),
         ],
 
         'class': [
             include('spaces'),
-            (r'', Text, ('#pop', 'class-body', 'bracket-open', 'extends',
+            default(('#pop', 'class-body', 'bracket-open', 'extends',
                          'type-param-constraint', 'type-name')),
         ],
 
@@ -1417,7 +1454,7 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'(?:extends|implements)\b', Keyword.Declaration, 'type'),
             (r',', Punctuation), # the comma is made optional here, since haxe2
                                  # requires the comma but haxe3 does not allow it
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'bracket-open': [
@@ -1436,13 +1473,13 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'\}', Punctuation, '#pop'),
             (r'(?:static|public|private|override|dynamic|inline|macro)\b',
              Keyword.Declaration),
-            (r'', Text, 'class-member'),
+            default('class-member'),
         ],
 
         'class-member': [
             include('spaces'),
             (r'(var)\b', Keyword.Declaration,
-             ('#pop', 'optional-semicolon', 'prop')),
+             ('#pop', 'optional-semicolon', 'var')),
             (r'(function)\b', Keyword.Declaration,
              ('#pop', 'optional-semicolon', 'class-method')),
         ],
@@ -1451,14 +1488,14 @@ class HaxeLexer(ExtendedRegexLexer):
         'function-local': [
             include('spaces'),
             (r'(' + ident_no_keyword + ')?', Name.Function,
-             ('#pop', 'expr', 'flag', 'function-param',
+             ('#pop', 'optional-expr', 'flag', 'function-param',
               'parenthesis-open', 'type-param-constraint')),
         ],
 
         'optional-expr': [
             include('spaces'),
             include('expr'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'class-method': [
@@ -1483,18 +1520,11 @@ class HaxeLexer(ExtendedRegexLexer):
             (r',', Punctuation, ('#pop', 'function-param')),
         ],
 
-        # class property
-        # eg. var prop(default, null):String;
-        'prop': [
-            include('spaces'),
-            (ident_no_keyword, Name, ('#pop', 'assign', 'flag', 'prop-get-set')),
-        ],
-
         'prop-get-set': [
             include('spaces'),
             (r'\(', Punctuation, ('#pop', 'parenthesis-close',
                                   'prop-get-set-opt', 'comma', 'prop-get-set-opt')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'prop-get-set-opt': [
@@ -1507,7 +1537,7 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             # makes semicolon optional here, just to avoid checking the last
             # one is bracket or not.
-            (r'', Text, ('#pop', 'optional-semicolon', 'expr')),
+            default(('#pop', 'optional-semicolon', 'expr')),
         ],
 
         'expr': [
@@ -1516,7 +1546,8 @@ class HaxeLexer(ExtendedRegexLexer):
                                     'meta-ident', 'meta-colon')),
             (r'(?:\+\+|\-\-|~(?!/)|!|\-)', Operator),
             (r'\(', Punctuation, ('#pop', 'expr-chain', 'parenthesis')),
-            (r'(?:inline)\b', Keyword.Declaration),
+            (r'(?:static|public|private|override|dynamic|inline)\b',
+             Keyword.Declaration),
             (r'(?:function)\b', Keyword.Declaration, ('#pop', 'expr-chain',
                                                       'function-local')),
             (r'\{', Punctuation, ('#pop', 'expr-chain', 'bracket')),
@@ -1569,14 +1600,22 @@ class HaxeLexer(ExtendedRegexLexer):
             (r'(\.)(' + ident_no_keyword + ')', bygroups(Punctuation, Name)),
             (r'\[', Punctuation, 'array-access'),
             (r'\(', Punctuation, 'call'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # macro reification
         'macro': [
             include('spaces'),
+            include('meta'),
             (r':', Punctuation, ('#pop', 'type')),
-            (r'', Text, ('#pop', 'expr')),
+
+            (r'(?:extern|private)\b', Keyword.Declaration),
+            (r'(?:abstract)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'abstract')),
+            (r'(?:class|interface)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'class')),
+            (r'(?:enum)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'enum')),
+            (r'(?:typedef)\b', Keyword.Declaration, ('#pop', 'optional-semicolon', 'typedef')),
+            
+            default(('#pop', 'expr')),
         ],
 
         # cast can be written as "cast expr" or "cast(expr, type)"
@@ -1584,27 +1623,27 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             (r'\(', Punctuation, ('#pop', 'parenthesis-close',
                                   'cast-type', 'expr')),
-            (r'', Text, ('#pop', 'expr')),
+            default(('#pop', 'expr')),
         ],
 
         # optionally give a type as the 2nd argument of cast()
         'cast-type': [
             include('spaces'),
             (r',', Punctuation, ('#pop', 'type')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'catch': [
             include('spaces'),
             (r'(?:catch)\b', Keyword, ('expr', 'function-param',
                                        'parenthesis-open')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # do-while loop
         'do': [
             include('spaces'),
-            (r'', Punctuation, ('#pop', 'do-while', 'expr')),
+            default(('#pop', 'do-while', 'expr')),
         ],
 
         # the while after do
@@ -1633,12 +1672,12 @@ class HaxeLexer(ExtendedRegexLexer):
         'else': [
             include('spaces'),
             (r'(?:else)\b', Keyword, ('#pop', 'expr')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'switch': [
             include('spaces'),
-            (r'', Text, ('#pop', 'switch-body', 'bracket-open', 'expr')),
+            default(('#pop', 'switch-body', 'bracket-open', 'expr')),
         ],
 
         'switch-body': [
@@ -1650,7 +1689,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'case': [
             include('spaces'),
             (r':', Punctuation, '#pop'),
-            (r'', Text, ('#pop', 'case-sep', 'case-guard', 'expr')),
+            default(('#pop', 'case-sep', 'case-guard', 'expr')),
         ],
 
         'case-sep': [
@@ -1662,25 +1701,25 @@ class HaxeLexer(ExtendedRegexLexer):
         'case-guard': [
             include('spaces'),
             (r'(?:if)\b', Keyword, ('#pop', 'parenthesis', 'parenthesis-open')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # optional multiple expr under a case
         'case-block': [
             include('spaces'),
             (r'(?!(?:case|default)\b|\})', Keyword, 'expr-statement'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'new': [
             include('spaces'),
-            (r'', Text, ('#pop', 'call', 'parenthesis-open', 'type')),
+            default(('#pop', 'call', 'parenthesis-open', 'type')),
         ],
 
         'array-decl': [
             include('spaces'),
             (r'\]', Punctuation, '#pop'),
-            (r'', Text, ('#pop', 'array-decl-sep', 'expr')),
+            default(('#pop', 'array-decl-sep', 'expr')),
         ],
 
         'array-decl-sep': [
@@ -1691,7 +1730,7 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'array-access': [
             include('spaces'),
-            (r'', Text, ('#pop', 'array-access-close', 'expr')),
+            default(('#pop', 'array-access-close', 'expr')),
         ],
 
         'array-access-close': [
@@ -1717,7 +1756,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'optional-semicolon': [
             include('spaces'),
             (r';', Punctuation, '#pop'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # identity that CAN be a Haxe keyword
@@ -1728,8 +1767,8 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'dollar': [
             include('spaces'),
-            (r'\{', Keyword, ('#pop', 'bracket-close', 'expr')),
-            (r'', Text, ('#pop', 'expr-chain')),
+            (r'\{', Punctuation, ('#pop', 'expr-chain', 'bracket-close', 'expr')),
+            default(('#pop', 'expr-chain')),
         ],
 
         'type-name': [
@@ -1740,7 +1779,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'type-full-name': [
             include('spaces'),
             (r'\.', Punctuation, 'ident'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'type': [
@@ -1753,14 +1792,14 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'type-parenthesis': [
             include('spaces'),
-            (r'', Text, ('#pop', 'parenthesis-close', 'type')),
+            default(('#pop', 'parenthesis-close', 'type')),
         ],
 
         'type-check': [
             include('spaces'),
             (r'->', Punctuation, ('#pop', 'type')),
             (r'<(?!=)', Punctuation, 'type-param'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'type-struct': [
@@ -1808,7 +1847,7 @@ class HaxeLexer(ExtendedRegexLexer):
         # ie. the <A,B> path in Map<A,B>
         'type-param': [
             include('spaces'),
-            (r'', Text, ('#pop', 'type-param-sep', 'type-param-type')),
+            default(('#pop', 'type-param-sep', 'type-param-type')),
         ],
 
         'type-param-sep': [
@@ -1823,7 +1862,7 @@ class HaxeLexer(ExtendedRegexLexer):
             include('spaces'),
             (r'<(?!=)', Punctuation, ('#pop', 'type-param-constraint-sep',
                                       'type-param-constraint-flag', 'type-name')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'type-param-constraint-sep': [
@@ -1837,14 +1876,14 @@ class HaxeLexer(ExtendedRegexLexer):
         'type-param-constraint-flag': [
             include('spaces'),
             (r':', Punctuation, ('#pop', 'type-param-constraint-flag-type')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         'type-param-constraint-flag-type': [
             include('spaces'),
             (r'\(', Punctuation, ('#pop', 'type-param-constraint-flag-type-sep',
                                   'type')),
-            (r'', Text, ('#pop', 'type')),
+            default(('#pop', 'type')),
         ],
 
         'type-param-constraint-flag-type-sep': [
@@ -1856,7 +1895,7 @@ class HaxeLexer(ExtendedRegexLexer):
         # a parenthesis expr that contain exactly one expr
         'parenthesis': [
             include('spaces'),
-            (r'', Text, ('#pop', 'parenthesis-close', 'expr')),
+            default(('#pop', 'parenthesis-close', 'flag', 'expr')),
         ],
 
         'parenthesis-open': [
@@ -1871,28 +1910,28 @@ class HaxeLexer(ExtendedRegexLexer):
 
         'var': [
             include('spaces'),
-            (ident_no_keyword, Text, ('#pop', 'var-sep', 'assign', 'flag')),
+            (ident_no_keyword, Text, ('#pop', 'var-sep', 'assign', 'flag', 'prop-get-set')),
         ],
 
         # optional more var decl.
         'var-sep': [
             include('spaces'),
             (r',', Punctuation, ('#pop', 'var')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # optional assignment
         'assign': [
             include('spaces'),
             (r'=', Operator, ('#pop', 'expr')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # optional type flag
         'flag': [
             include('spaces'),
             (r':', Punctuation, ('#pop', 'type')),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
 
         # colon as part of a ternary operator (?:)
@@ -1905,7 +1944,7 @@ class HaxeLexer(ExtendedRegexLexer):
         'call': [
             include('spaces'),
             (r'\)', Punctuation, '#pop'),
-            (r'', Text, ('#pop', 'call-sep', 'expr')),
+            default(('#pop', 'call-sep', 'expr')),
         ],
 
         # after a call param
@@ -1922,27 +1961,27 @@ class HaxeLexer(ExtendedRegexLexer):
              ('#pop', 'bracket-check')),
             (r"'", String.Single, ('#pop', 'bracket-check', 'string-single')),
             (r'"', String.Double, ('#pop', 'bracket-check', 'string-double')),
-            (r'', Text, ('#pop', 'block')),
+            default(('#pop', 'block')),
         ],
 
         'bracket-check': [
             include('spaces'),
             (r':', Punctuation, ('#pop', 'object-sep', 'expr')), #is object
-            (r'', Text, ('#pop', 'block', 'optional-semicolon', 'expr-chain')), #is block
+            default(('#pop', 'block', 'optional-semicolon', 'expr-chain')), #is block
         ],
 
         # code block
         'block': [
             include('spaces'),
             (r'\}', Punctuation, '#pop'),
-            (r'', Text, 'expr-statement'),
+            default('expr-statement'),
         ],
 
         # object in key-value pairs
         'object': [
             include('spaces'),
             (r'\}', Punctuation, '#pop'),
-            (r'', Text, ('#pop', 'object-sep', 'expr', 'colon', 'ident-or-string'))
+            default(('#pop', 'object-sep', 'expr', 'colon', 'ident-or-string'))
         ],
 
         # a key of an object
@@ -2002,11 +2041,11 @@ class HamlLexer(ExtendedRegexLexer):
     """
     For Haml markup.
 
-    *New in Pygments 1.3.*
+    .. versionadded:: 1.3
     """
 
     name = 'Haml'
-    aliases = ['haml', 'HAML']
+    aliases = ['haml']
     filenames = ['*.haml']
     mimetypes = ['text/x-haml']
 
@@ -2026,8 +2065,8 @@ class HamlLexer(ExtendedRegexLexer):
         ],
 
         'css': [
-            (r'\.[a-z0-9_:-]+', Name.Class, 'tag'),
-            (r'\#[a-z0-9_:-]+', Name.Function, 'tag'),
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
         ],
 
         'eval-or-plain': [
@@ -2035,12 +2074,12 @@ class HamlLexer(ExtendedRegexLexer):
             (r'([&!]?[=~])(' + _comma_dot + r'*\n)',
              bygroups(Punctuation, using(RubyLexer)),
              'root'),
-            (r'', Text, 'plain'),
+            default('plain'),
         ],
 
         'content': [
             include('css'),
-            (r'%[a-z0-9_:-]+', Name.Tag, 'tag'),
+            (r'%[\w:-]+', Name.Tag, 'tag'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
             (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
@@ -2076,16 +2115,16 @@ class HamlLexer(ExtendedRegexLexer):
 
         'html-attributes': [
             (r'\s+', Text),
-            (r'[a-z0-9_:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
-            (r'[a-z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
+            (r'[\w:-]+', Name.Attribute),
             (r'\)', Text, '#pop'),
         ],
 
         'html-attribute-value': [
             (r'[ \t]+', Text),
-            (r'[a-z0-9_]+', Name.Variable, '#pop'),
-            (r'@[a-z0-9_]+', Name.Variable.Instance, '#pop'),
-            (r'\$[a-z0-9_]+', Name.Variable.Global, '#pop'),
+            (r'\w+', Name.Variable, '#pop'),
+            (r'@\w+', Name.Variable.Instance, '#pop'),
+            (r'\$\w+', Name.Variable.Global, '#pop'),
             (r"'(\\\\|\\'|[^'\n])*'", String, '#pop'),
             (r'"(\\\\|\\"|[^"\n])*"', String, '#pop'),
         ],
@@ -2225,7 +2264,7 @@ common_sass_tokens = {
         (r'\:', Name.Decorator, 'pseudo-class'),
         (r'\.', Name.Class, 'class'),
         (r'\#', Name.Namespace, 'id'),
-        (r'[a-zA-Z0-9_-]+', Name.Tag),
+        (r'[\w-]+', Name.Tag),
         (r'#\{', String.Interpol, 'interpolation'),
         (r'&', Keyword),
         (r'[~\^\*!&\[\]\(\)<>\|+=@:;,./?-]', Operator),
@@ -2254,19 +2293,19 @@ common_sass_tokens = {
     'pseudo-class': [
         (r'[\w-]+', Name.Decorator),
         (r'#\{', String.Interpol, 'interpolation'),
-        (r'', Text, '#pop'),
+        default('#pop'),
     ],
 
     'class': [
         (r'[\w-]+', Name.Class),
         (r'#\{', String.Interpol, 'interpolation'),
-        (r'', Text, '#pop'),
+        default('#pop'),
     ],
 
     'id': [
         (r'[\w-]+', Name.Namespace),
         (r'#\{', String.Interpol, 'interpolation'),
-        (r'', Text, '#pop'),
+        default('#pop'),
     ],
 
     'for': [
@@ -2279,11 +2318,11 @@ class SassLexer(ExtendedRegexLexer):
     """
     For Sass stylesheets.
 
-    *New in Pygments 1.3.*
+    .. versionadded:: 1.3
     """
 
     name = 'Sass'
-    aliases = ['sass', 'SASS']
+    aliases = ['sass']
     filenames = ['*.sass']
     mimetypes = ['text/x-sass']
 
@@ -2305,14 +2344,14 @@ class SassLexer(ExtendedRegexLexer):
             (r'(@mixin)( [\w-]+)', bygroups(Keyword, Name.Function), 'value'),
             (r'(@include)( [\w-]+)', bygroups(Keyword, Name.Decorator), 'value'),
             (r'@extend', Keyword, 'selector'),
-            (r'@[a-z0-9_-]+', Keyword, 'selector'),
+            (r'@[\w-]+', Keyword, 'selector'),
             (r'=[\w-]+', Name.Function, 'value'),
             (r'\+[\w-]+', Name.Decorator, 'value'),
             (r'([!$][\w-]\w*)([ \t]*(?:(?:\|\|)?=|:))',
              bygroups(Name.Variable, Operator), 'value'),
             (r':', Name.Attribute, 'old-style-attr'),
             (r'(?=.+?[=:]([^a-z]|$))', Name.Attribute, 'new-style-attr'),
-            (r'', Text, 'selector'),
+            default('selector'),
         ],
 
         'single-comment': [
@@ -2335,7 +2374,7 @@ class SassLexer(ExtendedRegexLexer):
             (r'[^\s:="\[]+', Name.Attribute),
             (r'#{', String.Interpol, 'interpolation'),
             (r'[ \t]*=', Operator, 'value'),
-            (r'', Text, 'value'),
+            default('value'),
         ],
 
         'new-style-attr': [
@@ -2350,7 +2389,7 @@ class SassLexer(ExtendedRegexLexer):
             (r"\*/", Comment, '#pop'),
         ],
     }
-    for group, common in common_sass_tokens.iteritems():
+    for group, common in iteritems(common_sass_tokens):
         tokens[group] = copy.copy(common)
     tokens['value'].append((r'\n', Text, 'root'))
     tokens['selector'].append((r'\n', Text, 'root'))
@@ -2378,11 +2417,11 @@ class ScssLexer(RegexLexer):
             (r'(@mixin)( [\w-]+)', bygroups(Keyword, Name.Function), 'value'),
             (r'(@include)( [\w-]+)', bygroups(Keyword, Name.Decorator), 'value'),
             (r'@extend', Keyword, 'selector'),
-            (r'@[a-z0-9_-]+', Keyword, 'selector'),
+            (r'@[\w-]+', Keyword, 'selector'),
             (r'(\$[\w-]*\w)([ \t]*:)', bygroups(Name.Variable, Operator), 'value'),
             (r'(?=[^;{}][;}])', Name.Attribute, 'attr'),
             (r'(?=[^;{}:]+:[^a-z])', Name.Attribute, 'attr'),
-            (r'', Text, 'selector'),
+            default('selector'),
         ],
 
         'attr': [
@@ -2397,7 +2436,7 @@ class ScssLexer(RegexLexer):
             (r"\*/", Comment, '#pop'),
         ],
     }
-    for group, common in common_sass_tokens.iteritems():
+    for group, common in iteritems(common_sass_tokens):
         tokens[group] = copy.copy(common)
     tokens['value'].extend([(r'\n', Text), (r'[;{}]', Punctuation, 'root')])
     tokens['selector'].extend([(r'\n', Text), (r'[;{}]', Punctuation, 'root')])
@@ -2409,7 +2448,7 @@ class CoffeeScriptLexer(RegexLexer):
 
     .. _CoffeeScript: http://coffeescript.org
 
-    *New in Pygments 1.3.*
+    .. versionadded:: 1.3
     """
 
     name = 'CoffeeScript'
@@ -2435,17 +2474,17 @@ class CoffeeScriptLexer(RegexLexer):
             (r'///', String.Regex, ('#pop', 'multilineregex')),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
-            (r'', Text, '#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'=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?',
+             r'\|\||\\(?=\n)|'
+             r'(<<|>>>?|==?(?!>)|!=?|=(?!>)|-(?!>)|[<>+*`%&\|\^/])=?',
              Operator, 'slashstartsregex'),
-            (r'(?:\([^()]+\))?\s*[=-]>', Name.Function),
+            (r'(?:\([^()]*\))?\s*[=-]>', Name.Function),
             (r'[{(\[;,]', Punctuation, 'slashstartsregex'),
             (r'[})\].]', Punctuation),
             (r'(?<![\.\$])(for|own|in|of|while|until|'
@@ -2461,12 +2500,12 @@ class CoffeeScriptLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
              Name.Builtin),
-            (r'[$a-zA-Z_][a-zA-Z0-9_\.:\$]*\s*[:=]\s', Name.Variable,
+            (r'[$a-zA-Z_][\w\.:\$]*\s*[:=]\s', Name.Variable,
               'slashstartsregex'),
-            (r'@[$a-zA-Z_][a-zA-Z0-9_\.:\$]*\s*[:=]\s', Name.Variable.Instance,
+            (r'@[$a-zA-Z_][\w\.:\$]*\s*[:=]\s', Name.Variable.Instance,
               'slashstartsregex'),
             (r'@', Name.Other, 'slashstartsregex'),
-            (r'@?[$a-zA-Z_][a-zA-Z0-9_\$]*', 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),
@@ -2484,6 +2523,125 @@ class CoffeeScriptLexer(RegexLexer):
             (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 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
@@ -2541,7 +2699,7 @@ class LiveScriptLexer(RegexLexer):
             (r'//', String.Regex, ('#pop', 'multilineregex')),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
         'root': [
             # this next expr leads to infinite loops root -> slashstartsregex
@@ -2569,20 +2727,20 @@ class LiveScriptLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
               Name.Builtin),
-            (r'[$a-zA-Z_][a-zA-Z0-9_\.\-:\$]*\s*[:=]\s', Name.Variable,
+            (r'[$a-zA-Z_][\w\.\-:\$]*\s*[:=]\s', Name.Variable,
               'slashstartsregex'),
-            (r'@[$a-zA-Z_][a-zA-Z0-9_\.\-:\$]*\s*[:=]\s', Name.Variable.Instance,
+            (r'@[$a-zA-Z_][\w\.\-:\$]*\s*[:=]\s', Name.Variable.Instance,
               'slashstartsregex'),
             (r'@', Name.Other, 'slashstartsregex'),
-            (r'@?[$a-zA-Z_][a-zA-Z0-9_\-]*', 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'\\[\w$-]+', String),
-            (r'<\[.*\]>', String),
+            (r'\\\S+', String),
+            (r'<\[.*?\]>', String),
         ],
         'strings': [
             (r'[^#\\\'"]+', String),
@@ -2626,11 +2784,11 @@ class DuelLexer(RegexLexer):
     See http://duelengine.org/.
     See http://jsonml.org/jbst/.
 
-    *New in Pygments 1.4.*
+    .. versionadded:: 1.4
     """
 
     name = 'Duel'
-    aliases = ['duel', 'Duel Engine', 'Duel View', 'JBST', 'jbst', 'JsonML+BST']
+    aliases = ['duel', 'jbst', 'jsonml+bst']
     filenames = ['*.duel','*.jbst']
     mimetypes = ['text/x-duel','text/x-jbst']
 
@@ -2657,11 +2815,11 @@ class ScamlLexer(ExtendedRegexLexer):
     """
     For `Scaml markup <http://scalate.fusesource.org/>`_.  Scaml is Haml for Scala.
 
-    *New in Pygments 1.4.*
+    .. versionadded:: 1.4
     """
 
     name = 'Scaml'
-    aliases = ['scaml', 'SCAML']
+    aliases = ['scaml']
     filenames = ['*.scaml']
     mimetypes = ['text/x-scaml']
 
@@ -2679,8 +2837,8 @@ class ScamlLexer(ExtendedRegexLexer):
         ],
 
         'css': [
-            (r'\.[a-z0-9_:-]+', Name.Class, 'tag'),
-            (r'\#[a-z0-9_:-]+', Name.Function, 'tag'),
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
         ],
 
         'eval-or-plain': [
@@ -2688,12 +2846,12 @@ class ScamlLexer(ExtendedRegexLexer):
             (r'([&!]?[=~])(' + _dot + r'*\n)',
              bygroups(Punctuation, using(ScalaLexer)),
              'root'),
-            (r'', Text, 'plain'),
+            default('plain'),
         ],
 
         'content': [
             include('css'),
-            (r'%[a-z0-9_:-]+', Name.Tag, 'tag'),
+            (r'%[\w:-]+', Name.Tag, 'tag'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
             (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
@@ -2732,16 +2890,16 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'html-attributes': [
             (r'\s+', Text),
-            (r'[a-z0-9_:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
-            (r'[a-z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
+            (r'[\w:-]+', Name.Attribute),
             (r'\)', Text, '#pop'),
         ],
 
         'html-attribute-value': [
             (r'[ \t]+', Text),
-            (r'[a-z0-9_]+', Name.Variable, '#pop'),
-            (r'@[a-z0-9_]+', Name.Variable.Instance, '#pop'),
-            (r'\$[a-z0-9_]+', Name.Variable.Global, '#pop'),
+            (r'\w+', Name.Variable, '#pop'),
+            (r'@\w+', Name.Variable.Instance, '#pop'),
+            (r'\$\w+', Name.Variable.Global, '#pop'),
             (r"'(\\\\|\\'|[^'\n])*'", String, '#pop'),
             (r'"(\\\\|\\"|[^"\n])*"', String, '#pop'),
         ],
@@ -2771,11 +2929,11 @@ class JadeLexer(ExtendedRegexLexer):
     Jade is a variant of Scaml, see:
     http://scalate.fusesource.org/documentation/scaml-reference.html
 
-    *New in Pygments 1.4.*
+    .. versionadded:: 1.4
     """
 
     name = 'Jade'
-    aliases = ['jade', 'JADE']
+    aliases = ['jade']
     filenames = ['*.jade']
     mimetypes = ['text/x-jade']
 
@@ -2789,15 +2947,15 @@ class JadeLexer(ExtendedRegexLexer):
         ],
 
         'css': [
-            (r'\.[a-z0-9_:-]+', Name.Class, 'tag'),
-            (r'\#[a-z0-9_:-]+', Name.Function, 'tag'),
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
         ],
 
         'eval-or-plain': [
             (r'[&!]?==', Punctuation, 'plain'),
             (r'([&!]?[=~])(' + _dot + r'*\n)',
              bygroups(Punctuation, using(ScalaLexer)),  'root'),
-            (r'', Text, 'plain'),
+            default('plain'),
         ],
 
         'content': [
@@ -2818,7 +2976,7 @@ class JadeLexer(ExtendedRegexLexer):
              '#pop'),
             (r':' + _dot + r'*\n', _starts_block(Name.Decorator, 'filter-block'),
              '#pop'),
-            (r'[a-z0-9_:-]+', Name.Tag, 'tag'),
+            (r'[\w:-]+', Name.Tag, 'tag'),
             (r'\|', Text, 'eval-or-plain'),
         ],
 
@@ -2841,16 +2999,16 @@ class JadeLexer(ExtendedRegexLexer):
 
         'html-attributes': [
             (r'\s+', Text),
-            (r'[a-z0-9_:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
-            (r'[a-z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
+            (r'[\w:-]+', Name.Attribute),
             (r'\)', Text, '#pop'),
         ],
 
         'html-attribute-value': [
             (r'[ \t]+', Text),
-            (r'[a-z0-9_]+', Name.Variable, '#pop'),
-            (r'@[a-z0-9_]+', Name.Variable.Instance, '#pop'),
-            (r'\$[a-z0-9_]+', Name.Variable.Global, '#pop'),
+            (r'\w+', Name.Variable, '#pop'),
+            (r'@\w+', Name.Variable.Instance, '#pop'),
+            (r'\$\w+', Name.Variable.Global, '#pop'),
             (r"'(\\\\|\\'|[^'\n])*'", String, '#pop'),
             (r'"(\\\\|\\"|[^"\n])*"', String, '#pop'),
         ],
@@ -2879,7 +3037,7 @@ class XQueryLexer(ExtendedRegexLexer):
     An XQuery lexer, parsing a stream and outputting the tokens needed to
     highlight xquery code.
 
-    *New in Pygments 1.4.*
+    .. versionadded:: 1.4
     """
     name = 'XQuery'
     aliases = ['xquery', 'xqy', 'xq', 'xql', 'xqm']
@@ -3284,7 +3442,7 @@ class XQueryLexer(ExtendedRegexLexer):
         'xml_comment': [
             (r'(-->)', popstate_xmlcomment_callback),
             (r'[^-]{1,2}', Literal),
-            (ur'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
+            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
              unirange(0x10000, 0x10ffff), Literal),
         ],
         'processing_instruction': [
@@ -3294,12 +3452,12 @@ class XQueryLexer(ExtendedRegexLexer):
         ],
         'processing_instruction_content': [
             (r'\?>', String.Doc, '#pop'),
-            (ur'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
+            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
              unirange(0x10000, 0x10ffff), Literal),
         ],
         'cdata_section': [
             (r']]>', String.Doc, '#pop'),
-            (ur'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
+            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
              unirange(0x10000, 0x10ffff), Literal),
         ],
         'start_tag': [
@@ -3368,7 +3526,7 @@ class XQueryLexer(ExtendedRegexLexer):
         ],
         'pragmacontents': [
             (r'#\)', Punctuation, 'operator'),
-            (ur'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
+            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
              unirange(0x10000, 0x10ffff), Literal),
             (r'(\s+)', Text),
         ],
@@ -3377,7 +3535,7 @@ class XQueryLexer(ExtendedRegexLexer):
             (r'\(:', Comment, 'comment'),
             (r'\*|\?|\+', Operator, 'operator'),
             (r':=', Operator, 'root'),
-            (r'', Text, 'operator'),
+            default('operator'),
         ],
         'option': [
             include('whitespace'),
@@ -3400,9 +3558,9 @@ class XQueryLexer(ExtendedRegexLexer):
 
             # handle operator state
             # order on numbers matters - handle most complex first
-            (r'\d+(\.\d*)?[eE][\+\-]?\d+', Number.Double, 'operator'),
-            (r'(\.\d+)[eE][\+\-]?\d+', Number.Double, 'operator'),
-            (r'(\.\d+|\d+\.\d*)', Number, 'operator'),
+            (r'\d+(\.\d*)?[eE][\+\-]?\d+', Number.Float, 'operator'),
+            (r'(\.\d+)[eE][\+\-]?\d+', Number.Float, 'operator'),
+            (r'(\.\d+|\d+\.\d*)', Number.Float, 'operator'),
             (r'(\d+)', Number.Integer, 'operator'),
             (r'(\.\.|\.|\))', Punctuation, 'operator'),
             (r'(declare)(\s+)(construction)',
@@ -3541,7 +3699,7 @@ class DartLexer(RegexLexer):
     """
     For `Dart <http://dartlang.org/>`_ source code.
 
-    *New in Pygments 1.5.*
+    .. versionadded:: 1.5
     """
 
     name = 'Dart'
@@ -3569,9 +3727,9 @@ class DartLexer(RegexLexer):
              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', Operator),
-            (r'[a-zA-Z_$][a-zA-Z0-9_]*:', Name.Label),
-            (r'[a-zA-Z_$][a-zA-Z0-9_]*', Name),
+            (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?
@@ -3581,13 +3739,13 @@ class DartLexer(RegexLexer):
             # pseudo-keyword negate intentionally left out
         ],
         'class': [
-            (r'[a-zA-Z_$][a-zA-Z0-9_]*', Name.Class, '#pop')
+            (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_$][a-zA-Z0-9_]*', Name),
+            (r'[a-zA-Z_$]\w*', Name),
             (r'\,', Punctuation),
             (r'\;', Punctuation, '#pop')
         ],
@@ -3606,7 +3764,7 @@ class DartLexer(RegexLexer):
         '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_][a-zA-Z0-9_]*)', bygroups(String.Interpol, Name)),
+            (r'(\$)([a-zA-Z_]\w*)', bygroups(String.Interpol, Name)),
             (r'(\$\{)(.*?)(\})',
              bygroups(String.Interpol, using(this), String.Interpol))
         ],
@@ -3639,9 +3797,9 @@ class DartLexer(RegexLexer):
 
 class TypeScriptLexer(RegexLexer):
     """
-    For `TypeScript <http://www.python.org>`_ source code.
+    For `TypeScript <http://typescriptlang.org/>`_ source code.
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     name = 'TypeScript'
@@ -3662,7 +3820,7 @@ class TypeScriptLexer(RegexLexer):
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
-            (r'', Text, '#pop')
+            default('#pop')
         ],
         'badregex': [
             (r'\n', Text, '#pop')
@@ -3689,7 +3847,7 @@ class TypeScriptLexer(RegexLexer):
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
              r'window)\b', Name.Builtin),
             # Match stuff like: module name {...}
-            (r'\b(module)(\s*)(\s*[a-zA-Z0-9_?.$][\w?.$]*)(\s*)',
+            (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),
@@ -3701,9 +3859,9 @@ class TypeScriptLexer(RegexLexer):
             # Match stuff like: function() {...}
             (r'([a-zA-Z_?.$][\w?.$]*)\(\) \{', Name.Other, 'slashstartsregex'),
             # Match stuff like: (function: return type)
-            (r'([a-zA-Z0-9_?.$][\w?.$]*)(\s*:\s*)([a-zA-Z0-9_?.$][\w?.$]*)',
+            (r'([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)',
              bygroups(Name.Other, Text, Keyword.Type)),
-            (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name.Other),
+            (r'[$a-zA-Z_]\w*', Name.Other),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
@@ -3728,7 +3886,7 @@ class LassoLexer(RegexLexer):
         If given and ``True``, only highlight code between delimiters as Lasso
         (default: ``False``).
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     name = 'Lasso'
@@ -3746,16 +3904,16 @@ class LassoLexer(RegexLexer):
             (r'\[', Comment.Preproc, ('delimiters', 'squarebrackets')),
             (r'<\?(LassoScript|lasso|=)', Comment.Preproc,
                 ('delimiters', 'anglebrackets')),
-            (r'<', Other, 'delimiters'),
+            (r'<(!--.*?-->)?', Other, 'delimiters'),
             (r'\s+', Other),
-            (r'', Other, ('delimiters', 'lassofile')),
+            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),
             (r'[^[<]+', Other),
         ],
         'nosquarebrackets': [
@@ -3777,8 +3935,7 @@ class LassoLexer(RegexLexer):
             include('lasso'),
         ],
         'lassofile': [
-            (r'\]', Comment.Preproc, '#pop'),
-            (r'\?>', Comment.Preproc, '#pop'),
+            (r'\]|\?>', Comment.Preproc, '#pop'),
             include('lasso'),
         ],
         'whitespacecomments': [
@@ -3807,13 +3964,13 @@ 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'(\.\.?)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Name.Builtin.Pseudo, Name.Other.Member)),
-            (r'(->\\?\s*|&\s*)([a-z_][\w.]*)',
+            (r'(->\\?\s*|&\s*)([a-z_][\w.]*(=(?!=))?)',
                 bygroups(Operator, Name.Other.Member)),
-            (r'(self|inherited|global|void)\b', Name.Builtin.Pseudo),
+            (r'(self|inherited)\b', Name.Builtin.Pseudo),
             (r'-[a-z_][\w.]*', Name.Attribute),
-            (r'(::\s*)([a-z_][\w.]*)', bygroups(Punctuation, Name.Label)),
+            (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|'
@@ -3827,22 +3984,22 @@ class LassoLexer(RegexLexer):
             # 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.]*=?|[-+*/%<>]|==)',
+            (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),
+            (r'(public|protected|private|provide)(\s+)(([a-z_][\w.]*=?|[-+*/%])'
+             r'(?=\s*\())', bygroups(Keyword, Text, Name.Function),
                 'signature'),
-            (r'(public|protected|private)(\s+)([a-z_][\w.]*)',
+            (r'(public|protected|private|provide)(\s+)([a-z_][\w.]*)',
                 bygroups(Keyword, Text, Name.Function)),
 
             # keywords
-            (r'(true|false|none|minimal|full|all)\b', Keyword.Constant),
-            (r'(local|var|variable|data(?=\s))\b', Keyword.Declaration),
+            (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|list|queue|set|stack|staticarray)\b', Keyword.Type),
+             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'),
@@ -3862,17 +4019,18 @@ class LassoLexer(RegexLexer):
              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|skip|'
-             r'split_thread|sum|take|thread|to|trait|type|where|with|yield)\b',
+             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, Punctuation, Name.Label, Operator)),
+            (r'([a-z_][\w.]*)(\s*::\s*[a-z_][\w.]*)?(\s*=(?!=))',
+                bygroups(Name, Name.Label, Operator)),
             (r'(/?)([\w.]+)', bygroups(Punctuation, Name.Other)),
-            (r'(=)(bw|ew|cn|lte?|gte?|n?eq|ft|n?rx)\b',
+            (r'(=)(n?bw|n?ew|n?cn|lte?|gte?|n?eq|n?rx|ft)\b',
                 bygroups(Operator, Operator.Word)),
             (r':=|[-+*/%=<>&|!?\\]+', Operator),
             (r'[{}():;,@^]', Punctuation),
@@ -3881,13 +4039,13 @@ class LassoLexer(RegexLexer):
             (r"'", String.Single, '#pop'),
             (r"[^'\\]+", String.Single),
             include('escape'),
-            (r"\\+", String.Single),
+            (r"\\", String.Single),
         ],
         'doublestring': [
             (r'"', String.Double, '#pop'),
             (r'[^"\\]+', String.Double),
             include('escape'),
-            (r'\\+', String.Double),
+            (r'\\', String.Double),
         ],
         'escape': [
             (r'\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:]+:|'
@@ -3906,10 +4064,10 @@ class LassoLexer(RegexLexer):
             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.]*)', bygroups(Punctuation, Name.Label)),
+            (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'),
         ],
@@ -3917,17 +4075,17 @@ class LassoLexer(RegexLexer):
             (r'(\)(?=(\s*::\s*[\w.]+)?\s*,))', Punctuation, '#pop'),
             (r'\)', Punctuation, '#pop:2'),
             (r'-?[a-z_][\w.]*', Name.Attribute),
-            (r'(::\s*)([a-z_][\w.]*)', bygroups(Punctuation, Name.Label)),
+            (r'::\s*[a-z_][\w.]*', Name.Label),
             (r'\.\.\.', Name.Builtin.Pseudo),
             (r'[(,]', Punctuation),
             include('whitespacecomments'),
         ],
         'commamember': [
-            (r'(([a-z_][\w.]*=?|[-+*/%<>]|==)'
+            (r'(([a-z_][\w.]*=?|[-+*/%])'
              r'(?=\s*(\(([^()]*\([^()]*\))*[^)]*\)\s*)?(::[\w.\s]+)?=>))',
                 Name.Function, 'signature'),
             include('whitespacecomments'),
-            (r'', Text, '#pop'),
+            default('#pop'),
         ],
     }
 
@@ -3941,9 +4099,9 @@ class LassoLexer(RegexLexer):
         self._members = set()
         if self.builtinshighlighting:
             from pygments.lexers._lassobuiltins import BUILTINS, MEMBERS
-            for key, value in BUILTINS.iteritems():
+            for key, value in iteritems(BUILTINS):
                 self._builtins.update(value)
-            for key, value in MEMBERS.iteritems():
+            for key, value in iteritems(MEMBERS):
                 self._members.update(value)
         RegexLexer.__init__(self, **options)
 
@@ -3954,7 +4112,8 @@ class LassoLexer(RegexLexer):
         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() in self._members):
+                    token is Name.Other.Member and
+                    value.lower().rstrip('=') in self._members):
                 yield index, Name.Builtin, value
                 continue
             yield index, token, value
@@ -3976,14 +4135,14 @@ class QmlLexer(RegexLexer):
     """
     For QML files. See http://doc.qt.digia.com/4.7/qdeclarativeintroduction.html.
 
-    *New in Pygments 1.6.*
+    .. versionadded:: 1.6
     """
 
     # QML is based on javascript, so much of this is taken from the
     # JavascriptLexer above.
 
     name = 'QML'
-    aliases = ['qml', 'Qt Meta Language', 'Qt modeling Language']
+    aliases = ['qml']
     filenames = ['*.qml',]
     mimetypes = [ 'application/x-qml',]
 
@@ -4002,7 +4161,7 @@ class QmlLexer(RegexLexer):
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
              r'([gim]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
-            (r'', Text, '#pop')
+            default('#pop')
         ],
         'badregex': [
             (r'\n', Text, '#pop')
@@ -4035,7 +4194,7 @@ class QmlLexer(RegexLexer):
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
              r'window)\b', Name.Builtin),
-            (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name.Other),
+            (r'[$a-zA-Z_]\w*', Name.Other),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
@@ -4043,3 +4202,309 @@ class QmlLexer(RegexLexer):
             (r"'(\\\\|\\'|[^'])*'", String.Single),
         ]
     }
+
+
+class CirruLexer(RegexLexer):
+    """
+    Syntax rules of Cirru can be found at:
+    http://grammar.cirru.org/
+
+    * using ``()`` to markup blocks, but limited in the same line
+    * using ``""`` to markup strings, allow ``\`` to escape
+    * using ``$`` as a shorthand for ``()`` till indentation end or ``)``
+    * using indentations for create nesting
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Cirru'
+    aliases = ['cirru']
+    filenames = ['*.cirru', '*.cr']
+    mimetypes = ['text/x-cirru']
+    flags = re.MULTILINE
+
+    tokens = {
+        'string': [
+            (r'[^"\\\n]', String),
+            (r'\\', String.Escape, 'escape'),
+            (r'"', String, '#pop'),
+        ],
+        'escape': [
+            (r'.', String.Escape, '#pop'),
+        ],
+        'function': [
+            (r'[\w-][^\s\(\)\"]*', Name.Function, '#pop'),
+            (r'\)', Operator, '#pop'),
+            (r'(?=\n)', Text, '#pop'),
+            (r'\(', Operator, '#push'),
+            (r'"', String, ('#pop', 'string')),
+            (r'\s+', Text.Whitespace),
+            (r'\,', Operator, '#pop'),
+        ],
+        'line': [
+            (r'^\B', Text.Whitespace, 'function'),
+            (r'\$', Operator, 'function'),
+            (r'\(', Operator, 'function'),
+            (r'\)', Operator),
+            (r'(?=\n)', Text, '#pop'),
+            (r'\n', Text, '#pop'),
+            (r'"', String, 'string'),
+            (r'\s+', Text.Whitespace),
+            (r'[\d\.]+', Number),
+            (r'[\w-][^\"\(\)\s]*', Name.Variable),
+            (r'--', Comment.Single)
+        ],
+        'root': [
+            (r'^\s*', Text.Whitespace, ('line', 'function')),
+            (r'^\s+$', Text.Whitespace),
+        ]
+    }
+
+
+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')
+        ],
+    }
+
+
+class ZephirLexer(RegexLexer):
+    """
+    For `Zephir language <http://zephir-lang.com/>`_ source code.
+
+    Zephir is a compiled high level language aimed
+    to the creation of C-extensions for PHP.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Zephir'
+    aliases = ['zephir']
+    filenames = ['*.zep']
+
+    zephir_keywords = [ 'fetch', 'echo', 'isset', 'empty']
+    zephir_type = [ 'bit', 'bits' , 'string' ]
+
+    flags = re.DOTALL | re.MULTILINE
+
+    tokens = {
+        'commentsandwhitespace': [
+            (r'\s+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline)
+        ],
+        'slashstartsregex': [
+            include('commentsandwhitespace'),
+            (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
+             r'([gim]+\b|\B)', String.Regex, '#pop'),
+            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|loop|'
+             r'require|inline|throw|try|catch|finally|new|delete|typeof|instanceof|void|'
+             r'namespace|use|extends|this|fetch|isset|unset|echo|fetch|likely|unlikely|'
+             r'empty)\b', Keyword, 'slashstartsregex'),
+            (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
+            (r'(abstract|boolean|bool|char|class|const|double|enum|export|extends|final|'
+             r'native|goto|implements|import|int|string|interface|long|ulong|char|uchar|'
+             r'float|unsigned|private|protected|public|short|static|self|throws|reverse|'
+             r'transient|volatile)\b', Keyword.Reserved),
+            (r'(true|false|null|undefined)\b', Keyword.Constant),
+            (r'(Array|Boolean|Date|_REQUEST|_COOKIE|_SESSION|'
+             r'_GET|_POST|_SERVER|this|stdClass|range|count|iterator|'
+             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 SlimLexer(ExtendedRegexLexer):
+    """
+    For Slim markup.
+    """
+
+    name = 'Slim'
+    aliases = ['slim']
+    filenames = ['*.slim']
+    mimetypes = ['text/x-slim']
+
+    flags = re.IGNORECASE
+    _dot = r'(?: \|\n(?=.* \|)|.)'
+    tokens = {
+        'root': [
+            (r'[ \t]*\n', Text),
+            (r'[ \t]*', _indentation),
+        ],
+
+        'css': [
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
+        ],
+
+        'eval-or-plain': [
+            (r'([ \t]*==?)(.*\n)',
+             bygroups(Punctuation, using(RubyLexer)),
+             'root'),
+            (r'[ \t]+[\w:-]+(?=[=])', Name.Attribute, 'html-attributes'),
+            (r'', Text, 'plain'),
+        ],
+
+        'content': [
+            include('css'),
+            (r'[\w:-]+:[ \t]*\n', Text, 'plain'),
+            (r'(-)(.*\n)',
+             bygroups(Punctuation, using(RubyLexer)),
+             '#pop'),
+            (r'\|' + _dot + r'*\n', _starts_block(Text, 'plain'), '#pop'),
+            (r'/' + _dot + r'*\n', _starts_block(Comment.Preproc, 'slim-comment-block'), '#pop'),
+            (r'[\w:-]+', Name.Tag, 'tag'),
+            include('eval-or-plain'),
+        ],
+
+        'tag': [
+            include('css'),
+            (r'[<>]{1,2}(?=[ \t=])', Punctuation),
+            (r'[ \t]+\n', Punctuation, '#pop:2'),
+            include('eval-or-plain'),
+        ],
+
+        'plain': [
+            (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text),
+            (r'(#\{)(.*?)(\})',
+             bygroups(String.Interpol, using(RubyLexer), String.Interpol)),
+            (r'\n', Text, 'root'),
+        ],
+
+        'html-attributes': [
+            (r'=', Punctuation),
+            (r'"[^\"]+"', using(RubyLexer), 'tag'),
+            (r'\'[^\']+\'', using(RubyLexer), 'tag'),
+            (r'[\w]+', Text, 'tag'),
+        ],
+
+        'slim-comment-block': [
+            (_dot + '+', Comment.Preproc),
+            (r'\n', Text, 'root'),
+        ],
+    }