pygments.rb 2.0.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.inferno
     ~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for Inferno os and all the related stuff.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.installers
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for installer/packager DSLs and formats.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.int_fiction
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for interactive fiction languages.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.iolang
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Io language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -37,7 +36,7 @@ class IoLexer(RegexLexer):
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'/\+', Comment.Multiline, 'nestedcomment'),
             # DoubleQuotedString
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             # Operators
             (r'::=|:=|=|\(|\)|;|,|\*|-|\+|>|<|@|!|/|\||\^|\.|%|&|\[|\]|\{|\}',
              Operator),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.j
     ~~~~~~~~~~~~~~~~~
 
     Lexer for the J programming language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -89,7 +88,7 @@ class JLexer(RegexLexer):
             (r'=[.:]', Operator),
 
             # Builtins
-            (r'[-=+*#$%@!~`^&";:.,<>{}\[\]\\|/]', Operator),
+            (r'[-=+*#$%@!~`^&";:.,<>{}\[\]\\|/?]', Operator),
 
             # Short Keywords
             (r'[abCdDeEfHiIjLMoprtT]\.',  Keyword.Reserved),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.javascript
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for JavaScript and related languages.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -53,7 +52,7 @@ class JavascriptLexer(RegexLexer):
         'slashstartsregex': [
             include('commentsandwhitespace'),
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gimuy]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
             default('#pop')
         ],
@@ -67,7 +66,7 @@ class JavascriptLexer(RegexLexer):
 
             # Numeric literals
             (r'0[bB][01]+n?', Number.Bin),
-            (r'0[oO]?[0-7]+n?', Number.Oct),  # Browsers support "0o7" and "07" notations
+            (r'0[oO]?[0-7]+n?', Number.Oct),  # Browsers support "0o7" and "07" (< ES5) notations
             (r'0[xX][0-9a-fA-F]+n?', Number.Hex),
             (r'[0-9]+n', Number.Integer),  # Javascript BigInt requires an "n" postfix
             # Javascript doesn't have actual integer literals, so every other
@@ -82,27 +81,25 @@ class JavascriptLexer(RegexLexer):
             (r'[})\].]', Punctuation),
             (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|'
              r'throw|try|catch|finally|new|delete|typeof|instanceof|void|yield|await|async|'
-             r'this|of)\b', Keyword, 'slashstartsregex'),
-            (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
-            (r'(abstract|boolean|byte|char|class|const|debugger|double|enum|export|'
-             r'extends|final|float|goto|implements|import|int|interface|long|native|'
-             r'package|private|protected|public|short|static|super|synchronized|throws|'
-             r'transient|volatile)\b', Keyword.Reserved),
+             r'this|of|static|export|import|debugger|extends|super)\b', Keyword, 'slashstartsregex'),
+            (r'(var|let|const|with|function|class)\b', Keyword.Declaration, 'slashstartsregex'),
+            (r'(abstract|boolean|byte|char|double|enum|final|float|goto'
+             r'implements|int|interface|long|native|package|private|protected'
+             r'public|short|synchronized|throws|transient|volatile)\b', Keyword.Reserved),
             (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
-            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|Promise|Proxy|sun|decodeURI|'
+            (r'(Array|Boolean|Date|BigInt|Error|Function|Math|'
+             r'Number|Object|RegExp|String|Promise|Proxy|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'Error|eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|'
-             r'document|this|window)\b', Name.Builtin),
+             r'document|this|window|globalThis|Symbol)\b', Name.Builtin),
             (JS_IDENT, Name.Other),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'`', String.Backtick, 'interp'),
         ],
         'interp': [
             (r'`', String.Backtick, '#pop'),
-            (r'\\\\', String.Backtick),
-            (r'\\`', String.Backtick),
+            (r'\\.', String.Backtick),
             (r'\$\{', String.Interpol, 'interp-inside'),
             (r'\$', String.Backtick),
             (r'[^`\\$]+', String.Backtick),
@@ -112,7 +109,6 @@ class JavascriptLexer(RegexLexer):
             (r'\}', String.Interpol, '#pop'),
             include('root'),
         ],
-        # (\\\\|\\`|[^`])*`', String.Backtick),
     }
 
 
@@ -161,7 +157,7 @@ class KalLexer(RegexLexer):
         'root': [
             include('commentsandwhitespace'),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex),
+             r'([gimuys]+\b|\B)', String.Regex),
             (r'\?|:|_(?=\n)|==?|!=|-(?!>)|[<>+*/-]=?',
              Operator),
             (r'\b(and|or|isnt|is|not|but|bitwise|mod|\^|xor|exists|'
@@ -183,13 +179,11 @@ class KalLexer(RegexLexer):
             (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'(Array|Boolean|Date|Error|Function|Math|'
+             r'Number|Object|RegExp|String|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'eval|isFinite|isNaN|isSafeInteger|parseFloat|parseInt|document|'
-             r'window|'
-             r'print)\b',
-             Name.Builtin),
+             r'window|globalThis|Symbol|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),
@@ -256,7 +250,7 @@ class LiveScriptLexer(RegexLexer):
         ],
         'multilineregex': [
             include('commentsandwhitespace'),
-            (r'//([gim]+\b|\B)', String.Regex, '#pop'),
+            (r'//([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'/', String.Regex),
             (r'[^/#]+', String.Regex)
         ],
@@ -264,7 +258,7 @@ class LiveScriptLexer(RegexLexer):
             include('commentsandwhitespace'),
             (r'//', String.Regex, ('#pop', 'multilineregex')),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'/', Operator, '#pop'),
             default('#pop'),
         ],
@@ -288,11 +282,11 @@ class LiveScriptLexer(RegexLexer):
             (r'(?<![.$])(true|false|yes|no|on|off|'
              r'null|NaN|Infinity|undefined|void)\b',
              Keyword.Constant),
-            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+            (r'(Array|Boolean|Date|Error|Function|Math|'
+             r'Number|Object|RegExp|String|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
-             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
-             Name.Builtin),
+             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|'
+             r'globalThis|Symbol|Symbol|BigInt)\b', Name.Builtin),
             (r'[$a-zA-Z_][\w.\-:$]*\s*[:=]\s', Name.Variable,
              'slashstartsregex'),
             (r'@[$a-zA-Z_][\w.\-:$]*\s*[:=]\s', Name.Variable.Instance,
@@ -475,7 +469,7 @@ class TypeScriptLexer(RegexLexer):
         'slashstartsregex': [
             include('commentsandwhitespace'),
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
             default('#pop')
         ],
@@ -491,18 +485,19 @@ class TypeScriptLexer(RegexLexer):
             (r'[})\].]', Punctuation),
             (r'(for|in|while|do|break|return|continue|switch|case|default|if|else|'
              r'throw|try|catch|finally|new|delete|typeof|instanceof|void|of|'
-             r'this)\b', Keyword, 'slashstartsregex'),
-            (r'(var|let|with|function)\b', Keyword.Declaration, 'slashstartsregex'),
-            (r'(abstract|boolean|byte|char|class|const|debugger|double|enum|export|'
-             r'extends|final|float|goto|implements|import|int|interface|long|native|'
-             r'package|private|protected|public|short|static|super|synchronized|throws|'
-             r'transient|volatile)\b', Keyword.Reserved),
+             r'this|async|await|debugger|yield|abstract|static|import|export|'
+             r'implements|super|extends|private|protected|public|readonly)\b',
+                Keyword, 'slashstartsregex'),
+            (r'(var|let|const|with|function|class|type|enum|interface)\b',
+                Keyword.Declaration, 'slashstartsregex'),
+            (r'(boolean|byte|char|double|final|float|goto|int|long|native|'
+             r'package|short|synchronized|throws|transient|volatile)\b', Keyword.Reserved),
             (r'(true|false|null|NaN|Infinity|undefined)\b', Keyword.Constant),
-            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+            (r'(Array|Boolean|Date|Error|Function|Math|'
+             r'Number|Object|RegExp|String|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
-             r'window)\b', Name.Builtin),
+             r'window|globalThis|Symbol|BigInt)\b', Name.Builtin),
             # Match stuff like: module name {...}
             (r'\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)',
              bygroups(Keyword.Reserved, Text, Name.Other, Text), 'slashstartsregex'),
@@ -514,16 +509,18 @@ class TypeScriptLexer(RegexLexer):
             (r'(super)(\s*)(\([\w,?.$\s]+\s*\))',
              bygroups(Keyword.Reserved, Text), 'slashstartsregex'),
             # Match stuff like: function() {...}
-            (r'([a-zA-Z_?.$][\w?.$]*)\(\) \{', Name.Other, 'slashstartsregex'),
+            (r'([a-zA-Z_?.$][\w?.$]*)(?=\(\) \{)', Name.Other, 'slashstartsregex'),
             # Match stuff like: (function: return type)
             (r'([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)',
              bygroups(Name.Other, Text, Keyword.Type)),
             (r'[$a-zA-Z_]\w*', Name.Other),
-            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
-            (r'0x[0-9a-fA-F]+', Number.Hex),
-            (r'[0-9]+', Number.Integer),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'0[bB][01]+n?', Number.Bin),
+            (r'0[oO]?[0-7]+n?', Number.Oct),  # Browsers support "0o7" and "07" (< ES5) notations
+            (r'0[xX][0-9a-fA-F]+n?', Number.Hex),
+            (r'[0-9]+n', Number.Integer),
+            (r'(\.[0-9]+|[0-9]+\.[0-9]*|[0-9]+)([eE][-+]?[0-9]+)?', Number.Float),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'`', String.Backtick, 'interp'),
             # Match stuff like: Decorators
             (r'@\w+', Keyword.Declaration),
@@ -533,8 +530,7 @@ class TypeScriptLexer(RegexLexer):
         # there should be reflected here as well.
         'interp': [
             (r'`', String.Backtick, '#pop'),
-            (r'\\\\', String.Backtick),
-            (r'\\`', String.Backtick),
+            (r'\\.', String.Backtick),
             (r'\$\{', String.Interpol, 'interp-inside'),
             (r'\$', String.Backtick),
             (r'[^`\\$]+', String.Backtick),
@@ -875,8 +871,8 @@ class ObjectiveJLexer(RegexLexer):
             (r'(L|@)?"', String, 'string'),
             (r"(L|@)?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'",
              String.Char),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
             (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
@@ -913,11 +909,11 @@ class ObjectiveJLexer(RegexLexer):
              r'MIN|MAX|RAND|SQRT|E|LN2|LN10|LOG2E|LOG10E|PI|PI2|PI_2|SQRT1_2|'
              r'SQRT2)\b', Keyword.Constant),
 
-            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+            (r'(Array|Boolean|Date|Error|Function|Math|'
+             r'Number|Object|RegExp|String|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
              r'Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|'
-             r'window)\b', Name.Builtin),
+             r'window|globalThis|Symbol)\b', Name.Builtin),
 
             (r'([$a-zA-Z_]\w*)(' + _ws + r')(?=\()',
              bygroups(Name.Function, using(this))),
@@ -1055,7 +1051,7 @@ class CoffeeScriptLexer(RegexLexer):
         ],
         'multilineregex': [
             (r'[^/#]+', String.Regex),
-            (r'///([gim]+\b|\B)', String.Regex, '#pop'),
+            (r'///([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'#\{', String.Interpol, 'interpoling_string'),
             (r'[/#]', String.Regex),
         ],
@@ -1063,7 +1059,7 @@ class CoffeeScriptLexer(RegexLexer):
             include('commentsandwhitespace'),
             (r'///', String.Regex, ('#pop', 'multilineregex')),
             (r'/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuys]+\b|\B)', String.Regex, '#pop'),
             # This isn't really guarding against mishighlighting well-formed
             # code, just the ability to infinite-loop between root and
             # slashstartsregex.
@@ -1085,10 +1081,10 @@ class CoffeeScriptLexer(RegexLexer):
             (r'(?<![.$])(true|false|yes|no|on|off|null|'
              r'NaN|Infinity|undefined)\b',
              Keyword.Constant),
-            (r'(Array|Boolean|Date|Error|Function|Math|netscape|'
-             r'Number|Object|Packages|RegExp|String|sun|decodeURI|'
+            (r'(Array|Boolean|Date|Error|Function|Math|'
+             r'Number|Object|RegExp|String|decodeURI|'
              r'decodeURIComponent|encodeURI|encodeURIComponent|'
-             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b',
+             r'eval|isFinite|isNaN|parseFloat|parseInt|document|window|globalThis|Symbol)\b',
              Name.Builtin),
             (r'[$a-zA-Z_][\w.:$]*\s*[:=]\s', Name.Variable,
              'slashstartsregex'),
@@ -1497,7 +1493,7 @@ class JuttleLexer(RegexLexer):
         'slashstartsregex': [
             include('commentsandwhitespace'),
             (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/'
-             r'([gim]+\b|\B)', String.Regex, '#pop'),
+             r'([gimuys]+\b|\B)', String.Regex, '#pop'),
             (r'(?=/)', Text, ('#pop', 'badregex')),
             default('#pop')
         ],
@@ -1533,8 +1529,8 @@ class JuttleLexer(RegexLexer):
             (JS_IDENT, Name.Other),
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'[0-9]+', Number.Integer),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single)
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
         ]
 
     }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.julia
     ~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Julia language.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.jvm
     ~~~~~~~~~~~~~~~~~~~
 
     Pygments lexers for JVM languages.
 
-    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -292,12 +291,12 @@ class ScalaLexer(RegexLexer):
             (r'(import|package)(\s+)', bygroups(Keyword, Text), 'import'),
             (r'(type)(\s+)', bygroups(Keyword, Text), 'type'),
             (r'""".*?"""(?!")', String),
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
             (r"'%s" % idrest, Text.Symbol),
             (r'[fs]"""', String, 'interptriplestring'),  # interpolated strings
             (r'[fs]"', String, 'interpstring'),  # interpolated strings
-            (r'raw"(\\\\|\\"|[^"])*"', String),  # raw strings
+            (r'raw"(\\\\|\\[^\\]|[^"\\])*"', String),  # raw strings
             # (r'(\.)(%s|%s|`[^`]+`)' % (idrest, op), bygroups(Operator,
             # Name.Attribute)),
             (idrest, Name),
@@ -522,10 +521,10 @@ class GroovyLexer(RegexLexer):
             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
             (r'""".*?"""', String.Double),
             (r"'''.*?'''", String.Single),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'\$/((?!/\$).)*/\$', String),
-            (r'/(\\\\|\\"|[^/])*/', String),
+            (r'/(\\\\|\\[^\\]|[^/\\])*/', String),
             (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
             (r'(\.)([a-zA-Z_]\w*)', bygroups(Operator, Name.Attribute)),
             (r'[a-zA-Z_]\w*:', Name.Label),
@@ -618,7 +617,7 @@ class IokeLexer(RegexLexer):
             # Symbols
             (r':[\w!:?]+', String.Symbol),
             (r'[\w!:?]+:(?![\w!?])', String.Other),
-            (r':"(\\\\|\\"|[^"])*"', String.Symbol),
+            (r':"(\\\\|\\[^\\]|[^"\\])*"', String.Symbol),
 
             # Documentation
             (r'((?<=fn\()|(?<=fnx\()|(?<=method\()|(?<=macro\()|(?<=lecro\()'
@@ -836,7 +835,7 @@ class ClojureLexer(RegexLexer):
             (r'0x-?[abcdef\d]+', Number.Hex),
 
             # strings, symbols and characters
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r"'" + valid_name, String.Symbol),
             (r"\\(.|[a-z]+)", String.Char),
 
@@ -917,8 +916,8 @@ class TeaLangLexer(RegexLexer):
             (r'(true|false|null)\b', Keyword.Constant),
             (r'(template)(\s+)', bygroups(Keyword.Declaration, Text), 'template'),
             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-            (r'"(\\\\|\\"|[^"])*"', String),
-            (r'\'(\\\\|\\\'|[^\'])*\'', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'(\.)([a-zA-Z_]\w*)', bygroups(Operator, Name.Attribute)),
             (r'[a-zA-Z_]\w*:', Name.Label),
             (r'[a-zA-Z_\$]\w*', Name),
@@ -979,9 +978,8 @@ class CeylonLexer(RegexLexer):
             (r'(class|interface|object|alias)(\s+)',
              bygroups(Keyword.Declaration, Text), 'class'),
             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r"'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'", String.Char),
-            (r'".*``.*``.*"', String.Interpol),
             (r'(\.)([a-z_]\w*)',
              bygroups(Operator, Name.Attribute)),
             (r'[a-zA-Z_]\w*:', Name.Label),
@@ -1038,74 +1036,137 @@ class KotlinLexer(RegexLexer):
 
     kt_space_name = ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
                '[' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc', 'Cf',
-                                 'Mn', 'Mc', 'Zs') + ',-]*')
+                                 'Mn', 'Mc', 'Zs')
+                + r'\'~!%^&*()+=|\[\]:;,.<>/\?-]*')
 
     kt_id = '(' + kt_name + '|`' + kt_space_name + '`)'
 
+    modifiers = (r'actual|abstract|annotation|companion|const|crossinline|'
+                r'data|enum|expect|external|final|infix|inline|inner|'
+                r'internal|lateinit|noinline|open|operator|override|private|'
+                r'protected|public|sealed|suspend|tailrec')
+
     tokens = {
         'root': [
-            (r'^\s*\[.*?\]', Name.Attribute),
+            # Whitespaces
             (r'[^\S\n]+', Text),
             (r'\s+', Text),
             (r'\\\n', Text),  # line continuation
+            (r'\n', Text),
+            # Comments
             (r'//.*?\n', Comment.Single),
             (r'^#!/.+?\n', Comment.Single),  # shebang for kotlin scripts
             (r'/[*].*?[*]/', Comment.Multiline),
-            (r'""".*?"""', String),
-            (r'\n', Text),
+            # Keywords
+            (r'as\?', Keyword),
+            (r'(as|break|by|catch|constructor|continue|do|dynamic|else|finally|'
+             r'get|for|if|init|[!]*in|[!]*is|out|reified|return|set|super|this|'
+             r'throw|try|typealias|typeof|vararg|when|where|while)\b', Keyword),
+            (r'it\b', Name.Builtin),
+            # Built-in types
+            (words(('Boolean?', 'Byte?', 'Char?', 'Double?', 'Float?',
+             'Int?', 'Long?', 'Short?', 'String?', 'Any?', 'Unit?')), Keyword.Type),
+            (words(('Boolean', 'Byte', 'Char', 'Double', 'Float',
+             'Int', 'Long', 'Short', 'String', 'Any', 'Unit'), suffix=r'\b'), Keyword.Type),
+            # Constants
+            (r'(true|false|null)\b', Keyword.Constant),
+            # Imports
+            (r'(package|import)(\s+)(\S+)', bygroups(Keyword, Text, Name.Namespace)),
+            # Dot access
+            (r'(\?\.)((?:[^\W\d]|\$)[\w$]*)', bygroups(Operator, Name.Attribute)),
+            (r'(\.)((?:[^\W\d]|\$)[\w$]*)', bygroups(Punctuation, Name.Attribute)),
+            # Annotations
+            (r'@[^\W\d][\w.]*', Name.Decorator),
+            # Labels
+            (r'[^\W\d][\w.]+@', Name.Decorator),
+            # Object expression
+            (r'(object)(\s+)(:)(\s+)', bygroups(Keyword, Text, Punctuation, Text), 'class'),
+            # Types
+            (r'((?:(?:' + modifiers + r'|fun)\s+)*)(class|interface|object)(\s+)',
+             bygroups(using(this, state='modifiers'), Keyword.Declaration, Text), 'class'),
+            # Variables
+            (r'(var|val)(\s+)(\()', bygroups(Keyword.Declaration, Text, Punctuation),
+             'destructuring_assignment'),
+            (r'((?:(?:' + modifiers + r')\s+)*)(var|val)(\s+)',
+             bygroups(using(this, state='modifiers'), Keyword.Declaration, Text), 'variable'),
+            # Functions
+            (r'((?:(?:' + modifiers + r')\s+)*)(fun)(\s+)',
+             bygroups(using(this, state='modifiers'), Keyword.Declaration, Text), 'function'),
+            # Operators
             (r'::|!!|\?[:.]', Operator),
-            (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
-            (r'[{}]', Punctuation),
-            (r'@"(""|[^"])*"', String),
-            (r'"(\\\\|\\"|[^"\n])*["\n]', String),
+            (r'[~^*!%&\[\]<>|+=/?-]', Operator),
+            # Punctuation
+            (r'[{}();:.,]', Punctuation),
+            # Strings
+            (r'"""', String, 'multiline_string'),
+            (r'"', String, 'string'),
             (r"'\\.'|'[^\\]'", String.Char),
+            # Numbers
             (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFL]?|"
              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
-            (r'(object)(\s+)(:)(\s+)', bygroups(Keyword, Text, Punctuation, Text), 'class'),
-            (r'(companion)(\s+)(object)', bygroups(Keyword, Text, Keyword)),
-            (r'(class|interface|object)(\s+)', bygroups(Keyword, Text), 'class'),
-            (r'(package|import)(\s+)', bygroups(Keyword, Text), 'package'),
-            (r'(val|var)(\s+)([(])', bygroups(Keyword, Text, Punctuation), 'property_dec'),
-            (r'(val|var)(\s+)', bygroups(Keyword, Text), 'property'),
-            (r'(fun)(\s+)', bygroups(Keyword, Text), 'function'),
-            (r'(inline fun)(\s+)', bygroups(Keyword, Text), 'function'),
-            (r'(abstract|annotation|as|break|by|catch|class|companion|const|'
-             r'constructor|continue|crossinline|data|do|dynamic|else|enum|'
-             r'external|false|final|finally|for|fun|get|if|import|in|infix|'
-             r'inline|inner|interface|internal|is|lateinit|noinline|null|'
-             r'object|open|operator|out|override|package|private|protected|'
-             r'public|reified|return|sealed|set|super|tailrec|this|throw|'
-             r'true|try|val|var|vararg|when|where|while)\b', Keyword),
-            (kt_id, Name),
-        ],
-        'package': [
-            (r'\S+', Name.Namespace, '#pop')
+            # Identifiers
+            (r'' + kt_id + r'((\?[^.])?)', Name) # additionally handle nullable types
         ],
         'class': [
             (kt_id, Name.Class, '#pop')
         ],
-        'property': [
-            (kt_id, Name.Property, '#pop')
+        'variable': [
+            (kt_id, Name.Variable, '#pop')
         ],
-        'property_dec': [
-            (r'(,)(\s*)', bygroups(Punctuation, Text)),
-            (r'(:)(\s*)', bygroups(Punctuation, Text)),
-            (r'<', Punctuation, 'generic'),
-            (r'([)])', Punctuation, '#pop'),
-            (kt_id, Name.Property)
+        'destructuring_assignment': [
+            (r',', Punctuation),
+            (r'\s+', Text),
+            (kt_id, Name.Variable),
+            (r'(:)(\s+)(' + kt_id + ')', bygroups(Punctuation, Text, Name)),
+            (r'<', Operator, 'generic'),
+            (r'\)', Punctuation, '#pop')
         ],
         'function': [
-            (r'<', Punctuation, 'generic'),
-            (r''+kt_id+'([.])'+kt_id, bygroups(Name.Class, Punctuation, Name.Function), '#pop'),
+            (r'<', Operator, 'generic'),
+            (r'' + kt_id + r'(\.)' + kt_id, bygroups(Name, Punctuation, Name.Function), '#pop'),
             (kt_id, Name.Function, '#pop')
         ],
         'generic': [
-            (r'(>)(\s*)', bygroups(Punctuation, Text), '#pop'),
-            (r':',Punctuation),
+            (r'(>)(\s*)', bygroups(Operator, Text), '#pop'),
+            (r':', Punctuation),
             (r'(reified|out|in)\b', Keyword),
-            (r',',Text),
-            (r'\s+',Text),
-            (kt_id,Name)
+            (r',', Punctuation),
+            (r'\s+', Text),
+            (kt_id, Name)
+        ],
+        'modifiers': [
+            (r'\w+', Keyword.Declaration),
+            (r'\s+', Text),
+            default('#pop')
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            include('string_common')
+        ],
+        'multiline_string': [
+            (r'"""', String, '#pop'),
+            (r'"', String),
+            include('string_common')
+        ],
+        'string_common': [
+            (r'\\\\', String),  # escaped backslash
+            (r'\\"', String),  # escaped quote
+            (r'\\', String),  # bare backslash 
+            (r'\$\{', String.Interpol, 'interpolation'),
+            (r'(\$)(\w+)', bygroups(String.Interpol, Name)),
+            (r'[^\\"$]+', String)
+        ],
+        'interpolation': [
+            (r'"', String),
+            (r'\$\{', String.Interpol, 'interpolation'),
+            (r'\{', Punctuation, 'scope'),
+            (r'\}', String.Interpol, '#pop'),
+            include('root')
+        ],
+        'scope': [
+            (r'\{', Punctuation, 'scope'),
+            (r'\}', Punctuation, '#pop'),
+            include('root')
         ]
     }
 
@@ -1151,8 +1212,8 @@ class XtendLexer(RegexLexer):
             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
             (r"(''')", String, 'template'),
             (r'(\u00BB)', String, 'template'),
-            (r'"(\\\\|\\"|[^"])*"', String),
-            (r"'(\\\\|\\'|[^'])*'", String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
             (r'[a-zA-Z_]\w*:', Name.Label),
             (r'[a-zA-Z_$]\w*', Name),
             (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
@@ -1620,54 +1681,59 @@ class JasminLexer(RegexLexer):
 
 
 class SarlLexer(RegexLexer):
-	"""
-	For `SARL <http://www.sarl.io>`_ source code.
-	
-	.. versionadded:: 2.4
-	"""
-	
-	name = 'SARL'
-	aliases = ['sarl']
-	filenames = ['*.sarl']
-	mimetypes = ['text/x-sarl']
-	
-	flags = re.MULTILINE | re.DOTALL
-	
-	tokens = {
-		'root': [
-			# method names
-			(r'^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)'  # return arguments
-			 r'([a-zA-Z_$][\w$]*)'                      # method name
-			 r'(\s*)(\()',                             # signature start
-			 bygroups(using(this), Name.Function, Text, Operator)),
-			(r'[^\S\n]+', Text),
-			(r'//.*?\n', Comment.Single),
-			(r'/\*.*?\*/', Comment.Multiline),
-			(r'@[a-zA-Z_][\w.]*', Name.Decorator),
-			(r'(as|break|case|catch|default|do|else|extends|extension|finally|fires|for|if|implements|instanceof|new|on|requires|return|super|switch|throw|throws|try|typeof|uses|while|with)\b',
-			 Keyword),
-			(r'(abstract|def|dispatch|final|native|override|private|protected|public|static|strictfp|synchronized|transient|val|var|volatile)\b', Keyword.Declaration),
-			 (r'(boolean|byte|char|double|float|int|long|short|void)\b',
-			  Keyword.Type),
-			 (r'(package)(\s+)', bygroups(Keyword.Namespace, Text)),
-			 (r'(false|it|null|occurrence|this|true|void)\b', Keyword.Constant),
-			 (r'(agent|annotation|artifact|behavior|capacity|class|enum|event|interface|skill|space)(\s+)', bygroups(Keyword.Declaration, Text),
-			  'class'),
-			 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-			 (r'"(\\\\|\\"|[^"])*"', String),
-			 (r"'(\\\\|\\'|[^'])*'", String),
-			 (r'[a-zA-Z_]\w*:', Name.Label),
-			 (r'[a-zA-Z_$]\w*', Name),
-			 (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
-			 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
-			 (r'0x[0-9a-fA-F]+', Number.Hex),
-			 (r'[0-9]+L?', Number.Integer),
-			 (r'\n', Text)
-		],
-		'class': [
-			(r'[a-zA-Z_]\w*', Name.Class, '#pop')
-		],
-		'import': [
-			(r'[\w.]+\*?', Name.Namespace, '#pop')
-		],
-	}
+    """
+    For `SARL <http://www.sarl.io>`_ source code.
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'SARL'
+    aliases = ['sarl']
+    filenames = ['*.sarl']
+    mimetypes = ['text/x-sarl']
+
+    flags = re.MULTILINE | re.DOTALL
+
+    tokens = {
+        'root': [
+            # method names
+            (r'^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)'  # return arguments
+             r'([a-zA-Z_$][\w$]*)'                      # method name
+             r'(\s*)(\()',                             # signature start
+             bygroups(using(this), Name.Function, Text, Operator)),
+            (r'[^\S\n]+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (r'@[a-zA-Z_][\w.]*', Name.Decorator),
+            (r'(as|break|case|catch|default|do|else|extends|extension|finally|'
+             r'fires|for|if|implements|instanceof|new|on|requires|return|super|'
+             r'switch|throw|throws|try|typeof|uses|while|with)\b',
+             Keyword),
+            (r'(abstract|def|dispatch|final|native|override|private|protected|'
+             r'public|static|strictfp|synchronized|transient|val|var|volatile)\b',
+             Keyword.Declaration),
+            (r'(boolean|byte|char|double|float|int|long|short|void)\b',
+             Keyword.Type),
+            (r'(package)(\s+)', bygroups(Keyword.Namespace, Text)),
+            (r'(false|it|null|occurrence|this|true|void)\b', Keyword.Constant),
+            (r'(agent|annotation|artifact|behavior|capacity|class|enum|event|'
+             r'interface|skill|space)(\s+)', bygroups(Keyword.Declaration, Text),
+             'class'),
+            (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+            (r'[a-zA-Z_]\w*:', Name.Label),
+            (r'[a-zA-Z_$]\w*', Name),
+            (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
+            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+L?', Number.Integer),
+            (r'\n', Text)
+        ],
+        'class': [
+            (r'[a-zA-Z_]\w*', Name.Class, '#pop')
+        ],
+        'import': [
+            (r'[\w.]+\*?', Name.Namespace, '#pop')
+        ],
+    }