Curly brace escaping, round 1.

These locations were all found by regexlint and done semi-manually, leaving
braces within [] alone (they aren't special in the 'regex' module).

21 files changed, 46 insertions, 46 deletions

diff --git a/pygments/lexers/automation.py b/pygments/lexers/automation.py
index e012aae4..7be1b9a4 100644
--- a/pygments/lexers/automation.py
+++ b/pygments/lexers/automation.py
@@ -347,7 +347,7 @@ class AutoItLexer(RegexLexer):
         ],
         'labels': [
             # sendkeys
-            (r'(^\s*)({\S+?})', bygroups(Text, Name.Label)),
+            (r'(^\s*)(\{\S+?\})', bygroups(Text, Name.Label)),
         ],
         'numbers': [
             (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
diff --git a/pygments/lexers/erlang.py b/pygments/lexers/erlang.py
index ccd94564..89dcf336 100644
--- a/pygments/lexers/erlang.py
+++ b/pygments/lexers/erlang.py
@@ -432,7 +432,7 @@ class ElixirLexer(RegexLexer):
         'map_val': [
             include('root'),
             (r',', Punctuation, '#pop'),
-            (r'(?=})', Punctuation, '#pop'),
+            (r'(?=\})', Punctuation, '#pop'),
         ],
         'tuple': [
             include('root'),
diff --git a/pygments/lexers/factor.py b/pygments/lexers/factor.py
index ab1ca16b..079ff764 100644
--- a/pygments/lexers/factor.py
+++ b/pygments/lexers/factor.py
@@ -322,7 +322,7 @@ class FactorLexer(RegexLexer):
         'slots': [
             (r'\s+', Text),
             (r';\s', Keyword, '#pop'),
-            (r'({\s+)(\S+)(\s+[^}]+\s+}\s)',
+            (r'(\{\s+)(\S+)(\s+[^}]+\s+\}\s)',
              bygroups(Text, Name.Variable, Text)),
             (r'\S+', Name.Variable),
         ],
diff --git a/pygments/lexers/fantom.py b/pygments/lexers/fantom.py
index c05cb8e8..25a9e027 100644
--- a/pygments/lexers/fantom.py
+++ b/pygments/lexers/fantom.py
@@ -79,7 +79,7 @@ class FantomLexer(RegexLexer):
             (r'\\"', String.Escape),                         # Escaped "
             (r'\\`', String.Escape),                         # Escaped `
             (r'\$\w+', String.Interpol),                     # Subst var
-            (r'\${.*?}', String.Interpol),                   # Subst expr
+            (r'\$\{.*?\}', String.Interpol),                 # Subst expr
             (r'"', Punctuation, '#pop'),                     # Closing quot
             (r'.', String)                                   # String content
         ],
@@ -88,7 +88,7 @@ class FantomLexer(RegexLexer):
             (r'\\"', String.Escape),                         # Escaped "
             (r'\\`', String.Escape),                         # Escaped `
             (r'\$\w+', String.Interpol),                     # Subst var
-            (r'\${.*?}', String.Interpol),                   # Subst expr
+            (r'\$\{.*?\}', String.Interpol),                 # Subst expr
             (r'`', Punctuation, '#pop'),                     # Closing tick
             (r'.', String.Backtick)                          # URI content
         ],
diff --git a/pygments/lexers/felix.py b/pygments/lexers/felix.py
index 25232378..21602b91 100644
--- a/pygments/lexers/felix.py
+++ b/pygments/lexers/felix.py
@@ -232,7 +232,7 @@ class FelixLexer(RegexLexer):
             (r'[a-zA-Z_]\w*', Name),
         ],
         'stringescape': [
-            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
              r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
         ],
         'strings': [
diff --git a/pygments/lexers/haskell.py b/pygments/lexers/haskell.py
index 6c71aa97..9bcbc406 100644
--- a/pygments/lexers/haskell.py
+++ b/pygments/lexers/haskell.py
@@ -52,7 +52,7 @@ class HaskellLexer(RegexLexer):
             (r'\s+', Text),
             # (r'--\s*|.*$', Comment.Doc),
             (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
-            (r'{-', Comment.Multiline, 'comment'),
+            (r'\{-', Comment.Multiline, 'comment'),
             # Lexemes:
             #  Identifiers
             (r'\bimport\b', Keyword.Reserved, 'import'),
@@ -112,7 +112,7 @@ class HaskellLexer(RegexLexer):
             (r'[' + uni.Lu + r']\w*', Keyword.Type),
             (r'(_[\w\']+|[' + uni.Ll + r'][\w\']*)', Name.Function),
             (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
-            (r'{-', Comment.Multiline, 'comment'),
+            (r'\{-', Comment.Multiline, 'comment'),
             (r',', Punctuation),
             (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
             # (HACK, but it makes sense to push two instances, believe me)
@@ -124,8 +124,8 @@ class HaskellLexer(RegexLexer):
         'comment': [
             # Multiline Comments
             (r'[^-{}]+', Comment.Multiline),
-            (r'{-', Comment.Multiline, '#push'),
-            (r'-}', Comment.Multiline, '#pop'),
+            (r'\{-', Comment.Multiline, '#push'),
+            (r'-\}', Comment.Multiline, '#pop'),
             (r'[-{}]', Comment.Multiline),
         ],
         'character': [
@@ -188,7 +188,7 @@ class IdrisLexer(RegexLexer):
              bygroups(Text, Keyword.Reserved)),
             (r'(\s*)(--(?![!#$%&*+./<=>?@\^|_~:\\]).*?)$', bygroups(Text, Comment.Single)),
             (r'(\s*)(\|{3}.*?)$', bygroups(Text, Comment.Single)),
-            (r'(\s*)({-)', bygroups(Text, Comment.Multiline), 'comment'),
+            (r'(\s*)(\{-)', bygroups(Text, Comment.Multiline), 'comment'),
             # Declaration
             (r'^(\s*)([^\s\(\)\{\}]+)(\s*)(:)(\s*)',
              bygroups(Text, Name.Function, Text, Operator.Word, Text)),
@@ -222,7 +222,7 @@ class IdrisLexer(RegexLexer):
             (r'[A-Z]\w*', Keyword.Type),
             (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
             (r'--.*$', Comment.Single),
-            (r'{-', Comment.Multiline, 'comment'),
+            (r'\{-', Comment.Multiline, 'comment'),
             (r',', Punctuation),
             (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
             # (HACK, but it makes sense to push two instances, believe me)
@@ -234,8 +234,8 @@ class IdrisLexer(RegexLexer):
         'comment': [
             # Multiline Comments
             (r'[^-{}]+', Comment.Multiline),
-            (r'{-', Comment.Multiline, '#push'),
-            (r'-}', Comment.Multiline, '#pop'),
+            (r'\{-', Comment.Multiline, '#push'),
+            (r'-\}', Comment.Multiline, '#pop'),
             (r'[-{}]', Comment.Multiline),
         ],
         'character': [
@@ -289,9 +289,9 @@ class AgdaLexer(RegexLexer):
              bygroups(Text, Name.Function, Text, Operator.Word, Text)),
             # Comments
             (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
-            (r'{-', Comment.Multiline, 'comment'),
+            (r'\{-', Comment.Multiline, 'comment'),
             # Holes
-            (r'{!', Comment.Directive, 'hole'),
+            (r'\{!', Comment.Directive, 'hole'),
             # Lexemes:
             #  Identifiers
             (r'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
@@ -314,12 +314,12 @@ class AgdaLexer(RegexLexer):
         'hole': [
             # Holes
             (r'[^!{}]+', Comment.Directive),
-            (r'{!', Comment.Directive, '#push'),
-            (r'!}', Comment.Directive, '#pop'),
+            (r'\{!', Comment.Directive, '#push'),
+            (r'!\}', Comment.Directive, '#pop'),
             (r'[!{}]', Comment.Directive),
         ],
         'module': [
-            (r'{-', Comment.Multiline, 'comment'),
+            (r'\{-', Comment.Multiline, 'comment'),
             (r'[a-zA-Z][\w.]*', Name, '#pop'),
             (r'[^a-zA-Z]+', Text)
         ],
diff --git a/pygments/lexers/int_fiction.py b/pygments/lexers/int_fiction.py
index 8c3a934c..b464496b 100644
--- a/pygments/lexers/int_fiction.py
+++ b/pygments/lexers/int_fiction.py
@@ -179,7 +179,7 @@ class Inform6Lexer(RegexLexer):
             (r'[~^]+', String.Escape),
             (r'[^~^\\@({%s]+' % _squote, String.Single),
             (r'[({]', String.Single),
-            (r'@{[0-9a-fA-F]{,4}}', String.Escape),
+            (r'@\{[0-9a-fA-F]{,4}\}', String.Escape),
             (r'@..', String.Escape),
             (r'[%s]' % _squote, String.Single, '#pop')
         ],
diff --git a/pygments/lexers/julia.py b/pygments/lexers/julia.py
index a9836ee2..65cc9259 100644
--- a/pygments/lexers/julia.py
+++ b/pygments/lexers/julia.py
@@ -117,7 +117,7 @@ class JuliaLexer(RegexLexer):
         ],
 
         'stringescape': [
-            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
              r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
         ],
         "blockcomment": [
diff --git a/pygments/lexers/make.py b/pygments/lexers/make.py
index 0ce3ef4b..4ca7c328 100644
--- a/pygments/lexers/make.py
+++ b/pygments/lexers/make.py
@@ -172,7 +172,7 @@ class CMakeLexer(RegexLexer):
         'args': [
             (r'\(', Punctuation, '#push'),
             (r'\)', Punctuation, '#pop'),
-            (r'(\${)(.+?)(})', bygroups(Operator, Name.Variable, Operator)),
+            (r'(\$\{)(.+?)(\})', bygroups(Operator, Name.Variable, Operator)),
             (r'(\$<)(.+?)(>)', bygroups(Operator, Name.Variable, Operator)),
             (r'(?s)".*?"', String.Double),
             (r'\\\S+', String),
diff --git a/pygments/lexers/markup.py b/pygments/lexers/markup.py
index 75236a61..dcc22250 100644
--- a/pygments/lexers/markup.py
+++ b/pygments/lexers/markup.py
@@ -96,7 +96,7 @@ class MoinWikiLexer(RegexLexer):
             (r'.', Text),
         ],
         'codeblock': [
-            (r'}}}', Name.Builtin, '#pop'),
+            (r'\}\}\}', Name.Builtin, '#pop'),
             # these blocks are allowed to be nested in Trac, but not MoinMoin
             (r'\{\{\{', Text, '#push'),
             (r'[^{}]+', Comment.Preproc),  # slurp boring text
diff --git a/pygments/lexers/modeling.py b/pygments/lexers/modeling.py
index 11fd0e14..c2b365b3 100644
--- a/pygments/lexers/modeling.py
+++ b/pygments/lexers/modeling.py
@@ -159,7 +159,7 @@ class BugsLexer(RegexLexer):
             include('comments'),
             include('whitespace'),
             # Block start
-            (r'(model)(\s+)({)',
+            (r'(model)(\s+)(\{)',
              bygroups(Keyword.Namespace, Text, Punctuation)),
             # Reserved Words
             (r'(for|in)(?![0-9a-zA-Z\._])', Keyword.Reserved),
@@ -242,7 +242,7 @@ class JagsLexer(RegexLexer):
             include('comments'),
             include('whitespace'),
             # Block start
-            (r'(model|data)(\s+)({)',
+            (r'(model|data)(\s+)(\{)',
              bygroups(Keyword.Namespace, Text, Punctuation)),
             (r'var(?![0-9a-zA-Z\._])', Keyword.Declaration),
             # Reserved Words
diff --git a/pygments/lexers/nimrod.py b/pygments/lexers/nimrod.py
index 9b056fc4..e687152e 100644
--- a/pygments/lexers/nimrod.py
+++ b/pygments/lexers/nimrod.py
@@ -72,7 +72,7 @@ class NimrodLexer(RegexLexer):
             (r'##.*$', String.Doc),
             (r'#.*$', Comment),
             (r'\*|=|>|<|\+|-|/|@|\$|~|&|%|\!|\?|\||\\|\[|\]', Operator),
-            (r'\.\.|\.|,|\[\.|\.\]|{\.|\.}|\(\.|\.\)|{|}|\(|\)|:|\^|`|;',
+            (r'\.\.|\.|,|\[\.|\.\]|\{\.|\.\}|\(\.|\.\)|\{|\}|\(|\)|:|\^|`|;',
              Punctuation),
 
             # Strings
diff --git a/pygments/lexers/nix.py b/pygments/lexers/nix.py
index 23171fee..6d9f0e7d 100644
--- a/pygments/lexers/nix.py
+++ b/pygments/lexers/nix.py
@@ -115,7 +115,7 @@ class NixLexer(RegexLexer):
             (r'[^"]', String.Double),
         ],
         'antiquote': [
-            (r"}", String.Interpol, '#pop'),
+            (r"\}", String.Interpol, '#pop'),
             # TODO: we should probably escape also here ''${ \${
             (r"\$\{", String.Interpol, '#push'),
             include('root'),
diff --git a/pygments/lexers/objective.py b/pygments/lexers/objective.py
index a2a3c7f5..8cb02170 100644
--- a/pygments/lexers/objective.py
+++ b/pygments/lexers/objective.py
@@ -262,7 +262,7 @@ class LogosLexer(ObjectiveCppLexer):
              bygroups(Keyword, Text, Name.Class)),
             (r'(%config)(\s*\(\s*)(\w+)(\s*=\s*)(.*?)(\s*\)\s*)',
              bygroups(Keyword, Text, Name.Variable, Text, String, Text)),
-            (r'(%ctor)(\s*)({)', bygroups(Keyword, Text, Punctuation),
+            (r'(%ctor)(\s*)(\{)', bygroups(Keyword, Text, Punctuation),
              'function'),
             (r'(%new)(\s*)(\()(\s*.*?\s*)(\))',
              bygroups(Keyword, Text, Keyword, String, Keyword)),
diff --git a/pygments/lexers/perl.py b/pygments/lexers/perl.py
index df48e2be..0536b948 100644
--- a/pygments/lexers/perl.py
+++ b/pygments/lexers/perl.py
@@ -37,7 +37,7 @@ class PerlLexer(RegexLexer):
             (r'/(\\\\|\\[^\\]|[^\\/])*/[egimosx]*', String.Regex, '#pop'),
             (r'!(\\\\|\\[^\\]|[^\\!])*![egimosx]*', String.Regex, '#pop'),
             (r'\\(\\\\|[^\\])*\\[egimosx]*', String.Regex, '#pop'),
-            (r'{(\\\\|\\[^\\]|[^\\}])*}[egimosx]*', String.Regex, '#pop'),
+            (r'\{(\\\\|\\[^\\]|[^\\}])*\}[egimosx]*', String.Regex, '#pop'),
             (r'<(\\\\|\\[^\\]|[^\\>])*>[egimosx]*', String.Regex, '#pop'),
             (r'\[(\\\\|\\[^\\]|[^\\\]])*\][egimosx]*', String.Regex, '#pop'),
             (r'\((\\\\|\\[^\\]|[^\\\)])*\)[egimosx]*', String.Regex, '#pop'),
@@ -67,7 +67,7 @@ class PerlLexer(RegexLexer):
             (r's%(\\\\|\\[^\\]|[^\\%])*%(\\\\|\\[^\\]|[^\\%])*%[egimosx]*',
                 String.Regex),
             # balanced delimiters
-            (r's{(\\\\|\\[^\\]|[^\\}])*}\s*', String.Regex, 'balanced-regex'),
+            (r's\{(\\\\|\\[^\\]|[^\\}])*\}\s*', String.Regex, 'balanced-regex'),
             (r's<(\\\\|\\[^\\]|[^\\>])*>\s*', String.Regex, 'balanced-regex'),
             (r's\[(\\\\|\\[^\\]|[^\\\]])*\]\s*', String.Regex,
                 'balanced-regex'),
diff --git a/pygments/lexers/python.py b/pygments/lexers/python.py
index 411f7bc7..3caf2725 100644
--- a/pygments/lexers/python.py
+++ b/pygments/lexers/python.py
@@ -151,7 +151,7 @@ class PythonLexer(RegexLexer):
             default('#pop'),
         ],
         'stringescape': [
-            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
              r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
         ],
         'strings': [
@@ -602,7 +602,7 @@ class CythonLexer(RegexLexer):
             default('#pop'),
         ],
         'stringescape': [
-            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
              r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
         ],
         'strings': [
@@ -710,7 +710,7 @@ class DgLexer(RegexLexer):
             (r'.', Error),
         ],
         'stringescape': [
-            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+            (r'\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|'
              r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
         ],
         'string': [
diff --git a/pygments/lexers/resource.py b/pygments/lexers/resource.py
index 6a9e702e..681c4c6c 100644
--- a/pygments/lexers/resource.py
+++ b/pygments/lexers/resource.py
@@ -40,7 +40,7 @@ class ResourceLexer(RegexLexer):
         ],
         'string': [
             (r'(\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}|\\U00[0-9a-fA-F]{6}|'
-             r'\\[0-7]{1,3}|\\c.|\\[abtnvfre\'"?\\]|\\{|[^"{\\])+', String),
+             r'\\[0-7]{1,3}|\\c.|\\[abtnvfre\'"?\\]|\\\{|[^"{\\])+', String),
             (r'\{', String.Escape, 'msgname'),
             (r'"', String, '#pop')
         ],
@@ -50,7 +50,7 @@ class ResourceLexer(RegexLexer):
         'message': [
             (r'\{', String.Escape, 'msgname'),
             (r'\}', String.Escape, '#pop'),
-            (r'(,)(\s*)([a-zA-Z]+)(\s*})',
+            (r'(,)(\s*)([a-zA-Z]+)(\s*\})',
              bygroups(Operator, String.Escape, Keyword, String.Escape), '#pop'),
             (r'(,)(\s*)([a-zA-Z]+)(\s*)(,)(\s*)(offset)(\s*)(:)(\s*)(-?\d+)(\s*)',
              bygroups(Operator, String.Escape, Keyword, String.Escape, Operator,
@@ -62,9 +62,9 @@ class ResourceLexer(RegexLexer):
             (r'\s+', String.Escape)
         ],
         'choice': [
-            (r'(=|<|>|<=|>=|!=)(-?\d+)(\s*{)',
+            (r'(=|<|>|<=|>=|!=)(-?\d+)(\s*\{)',
              bygroups(Operator, Number.Integer, String.Escape), 'message'),
-            (r'([a-zA-Z]+)(\s*{)', bygroups(Keyword.Type, String.Escape), 'str'),
+            (r'([a-zA-Z]+)(\s*\{)', bygroups(Keyword.Type, String.Escape), 'str'),
             (r'\}', String.Escape, ('#pop', '#pop')),
             (r'\s+', String.Escape)
         ],
diff --git a/pygments/lexers/ruby.py b/pygments/lexers/ruby.py
index 2becb101..638789d0 100644
--- a/pygments/lexers/ruby.py
+++ b/pygments/lexers/ruby.py
@@ -451,7 +451,7 @@ class FancyLexer(RegexLexer):
             (r'/(\\\\|\\/|[^/])*/[egimosx]*', String.Regex, '#pop'),
             (r'!(\\\\|\\!|[^!])*![egimosx]*', String.Regex, '#pop'),
             (r'\\(\\\\|[^\\])*\\[egimosx]*', String.Regex, '#pop'),
-            (r'{(\\\\|\\}|[^}])*}[egimosx]*', String.Regex, '#pop'),
+            (r'\{(\\\\|\\\}|[^}])*\}[egimosx]*', String.Regex, '#pop'),
             (r'<(\\\\|\\>|[^>])*>[egimosx]*', String.Regex, '#pop'),
             (r'\[(\\\\|\\\]|[^\]])*\][egimosx]*', String.Regex, '#pop'),
             (r'\((\\\\|\\\)|[^\)])*\)[egimosx]*', String.Regex, '#pop'),
@@ -463,7 +463,7 @@ class FancyLexer(RegexLexer):
             (r'\s+', Text),
 
             # balanced delimiters (copied from PerlLexer):
-            (r's{(\\\\|\\}|[^}])*}\s*', String.Regex, 'balanced-regex'),
+            (r's\{(\\\\|\\\}|[^}])*\}\s*', String.Regex, 'balanced-regex'),
             (r's<(\\\\|\\>|[^>])*>\s*', String.Regex, 'balanced-regex'),
             (r's\[(\\\\|\\\]|[^\]])*\]\s*', String.Regex, 'balanced-regex'),
             (r's\((\\\\|\\\)|[^\)])*\)\s*', String.Regex, 'balanced-regex'),
diff --git a/pygments/lexers/scripting.py b/pygments/lexers/scripting.py
index 602877f4..a8b1ba50 100644
--- a/pygments/lexers/scripting.py
+++ b/pygments/lexers/scripting.py
@@ -267,7 +267,7 @@ class ChaiscriptLexer(RegexLexer):
             (r"'(\\\\|\\'|[^'])*'", String.Single),
         ],
         'dqstring': [
-            (r'\${[^"}]+?}', String.Iterpol),
+            (r'\$\{[^"}]+?\}', String.Iterpol),
             (r'\$', String.Double),
             (r'\\\\', String.Double),
             (r'\\"', String.Double),
diff --git a/pygments/lexers/shell.py b/pygments/lexers/shell.py
index 3973afa5..575e2525 100644
--- a/pygments/lexers/shell.py
+++ b/pygments/lexers/shell.py
@@ -46,7 +46,7 @@ class BashLexer(RegexLexer):
         'interp': [
             (r'\$\(\(', Keyword, 'math'),
             (r'\$\(', Keyword, 'paren'),
-            (r'\${#?', String.Interpol, 'curly'),
+            (r'\$\{#?', String.Interpol, 'curly'),
             (r'\$#?(\w+|.)', Name.Variable),
         ],
         'basic': [
@@ -288,7 +288,7 @@ class TcshLexer(RegexLexer):
         'root': [
             include('basic'),
             (r'\$\(', Keyword, 'paren'),
-            (r'\${#?', Keyword, 'curly'),
+            (r'\$\{#?', Keyword, 'curly'),
             (r'`', String.Backtick, 'backticks'),
             include('data'),
         ],
diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
index e7a2e567..1d0565ad 100644
--- a/pygments/lexers/templates.py
+++ b/pygments/lexers/templates.py
@@ -1802,10 +1802,10 @@ class HandlebarsLexer(RegexLexer):
         'root': [
             (r'[^{]+', Other),
 
-            (r'{{!.*}}', Comment),
+            (r'\{\{!.*\}\}', Comment),
 
-            (r'({{{)(\s*)', bygroups(Comment.Special, Text), 'tag'),
-            (r'({{)(\s*)', bygroups(Comment.Preproc, Text), 'tag'),
+            (r'(\{\{\{)(\s*)', bygroups(Comment.Special, Text), 'tag'),
+            (r'(\{\{)(\s*)', bygroups(Comment.Preproc, Text), 'tag'),
         ],
 
         'tag': [
@@ -1887,7 +1887,7 @@ class LiquidLexer(RegexLexer):
             # tags and block tags
             (r'(\{%)(\s*)', bygroups(Punctuation, Whitespace), 'tag-or-block'),
             # output tags
-            (r'({{)(\s*)([^\s}]+)',
+            (r'(\{\{)(\s*)([^\s}]+)',
              bygroups(Punctuation, Whitespace, using(this, state = 'generic')),
              'output'),
             (r'\{', Text)