py2docfx 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1859874__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/pygments/lexers/tnt.py

@@ -1,270 +0,0 @@
-"""
-    pygments.lexers.tnt
-    ~~~~~~~~~~~~~~~~~~~
-
-    Lexer for Typographic Number Theory.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import Lexer
-from pygments.token import Text, Comment, Operator, Keyword, Name, Number, \
-    Punctuation, Error
-
-__all__ = ['TNTLexer']
-
-
-class TNTLexer(Lexer):
-    """
-    Lexer for Typographic Number Theory, as described in the book
-    Gödel, Escher, Bach, by Douglas R. Hofstadter
-    """
-
-    name = 'Typographic Number Theory'
-    url = 'https://github.com/Kenny2github/language-tnt'
-    aliases = ['tnt']
-    filenames = ['*.tnt']
-    version_added = '2.7'
-
-    cur = []
-
-    LOGIC = set('⊃→]&∧^|∨Vv')
-    OPERATORS = set('+.⋅*')
-    VARIABLES = set('abcde')
-    PRIMES = set("'′")
-    NEGATORS = set('~!')
-    QUANTIFIERS = set('AE∀∃')
-    NUMBERS = set('0123456789')
-    WHITESPACE = set('\t \v\n')
-
-    RULES = re.compile('''(?xi)
-        joining | separation | double-tilde | fantasy\\ rule
-        | carry[- ]over(?:\\ of)?(?:\\ line)?\\ ([0-9]+) | detachment
-        | contrapositive | De\\ Morgan | switcheroo
-        | specification | generalization | interchange
-        | existence | symmetry | transitivity
-        | add\\ S | drop\\ S | induction
-        | axiom\\ ([1-5]) | premise | push | pop
-    ''')
-    LINENOS = re.compile(r'(?:[0-9]+)(?:(?:, ?|,? and )(?:[0-9]+))*')
-    COMMENT = re.compile(r'\[[^\n\]]+\]')
-
-    def __init__(self, *args, **kwargs):
-        Lexer.__init__(self, *args, **kwargs)
-        self.cur = []
-
-    def whitespace(self, start, text, required=False):
-        """Tokenize whitespace."""
-        end = start
-        try:
-            while text[end] in self.WHITESPACE:
-                end += 1
-        except IndexError:
-            end = len(text)
-        if required and end == start:
-            raise AssertionError
-        if end != start:
-            self.cur.append((start, Text, text[start:end]))
-        return end
-
-    def variable(self, start, text):
-        """Tokenize a variable."""
-        if text[start] not in self.VARIABLES:
-            raise AssertionError
-        end = start+1
-        while text[end] in self.PRIMES:
-            end += 1
-        self.cur.append((start, Name.Variable, text[start:end]))
-        return end
-
-    def term(self, start, text):
-        """Tokenize a term."""
-        if text[start] == 'S':  # S...S(...) or S...0
-            end = start+1
-            while text[end] == 'S':
-                end += 1
-            self.cur.append((start, Number.Integer, text[start:end]))
-            return self.term(end, text)
-        if text[start] == '0':  # the singleton 0
-            self.cur.append((start, Number.Integer, text[start]))
-            return start+1
-        if text[start] in self.VARIABLES:  # a''...
-            return self.variable(start, text)
-        if text[start] == '(':  # (...+...)
-            self.cur.append((start, Punctuation, text[start]))
-            start = self.term(start+1, text)
-            if text[start] not in self.OPERATORS:
-                raise AssertionError
-            self.cur.append((start, Operator, text[start]))
-            start = self.term(start+1, text)
-            if text[start] != ')':
-                raise AssertionError
-            self.cur.append((start, Punctuation, text[start]))
-            return start+1
-        raise AssertionError  # no matches
-
-    def formula(self, start, text):
-        """Tokenize a formula."""
-        if text[start] in self.NEGATORS:  # ~<...>
-            end = start+1
-            while text[end] in self.NEGATORS:
-                end += 1
-            self.cur.append((start, Operator, text[start:end]))
-            return self.formula(end, text)
-        if text[start] in self.QUANTIFIERS:  # Aa:<...>
-            self.cur.append((start, Keyword.Declaration, text[start]))
-            start = self.variable(start+1, text)
-            if text[start] != ':':
-                raise AssertionError
-            self.cur.append((start, Punctuation, text[start]))
-            return self.formula(start+1, text)
-        if text[start] == '<':  # <...&...>
-            self.cur.append((start, Punctuation, text[start]))
-            start = self.formula(start+1, text)
-            if text[start] not in self.LOGIC:
-                raise AssertionError
-            self.cur.append((start, Operator, text[start]))
-            start = self.formula(start+1, text)
-            if text[start] != '>':
-                raise AssertionError
-            self.cur.append((start, Punctuation, text[start]))
-            return start+1
-        # ...=...
-        start = self.term(start, text)
-        if text[start] != '=':
-            raise AssertionError
-        self.cur.append((start, Operator, text[start]))
-        start = self.term(start+1, text)
-        return start
-
-    def rule(self, start, text):
-        """Tokenize a rule."""
-        match = self.RULES.match(text, start)
-        if match is None:
-            raise AssertionError
-        groups = sorted(match.regs[1:])  # exclude whole match
-        for group in groups:
-            if group[0] >= 0:  # this group matched
-                self.cur.append((start, Keyword, text[start:group[0]]))
-                self.cur.append((group[0], Number.Integer,
-                                 text[group[0]:group[1]]))
-                if group[1] != match.end():
-                    self.cur.append((group[1], Keyword,
-                                     text[group[1]:match.end()]))
-                break
-        else:
-            self.cur.append((start, Keyword, text[start:match.end()]))
-        return match.end()
-
-    def lineno(self, start, text):
-        """Tokenize a line referral."""
-        end = start
-        while text[end] not in self.NUMBERS:
-            end += 1
-        self.cur.append((start, Punctuation, text[start]))
-        self.cur.append((start+1, Text, text[start+1:end]))
-        start = end
-        match = self.LINENOS.match(text, start)
-        if match is None:
-            raise AssertionError
-        if text[match.end()] != ')':
-            raise AssertionError
-        self.cur.append((match.start(), Number.Integer, match.group(0)))
-        self.cur.append((match.end(), Punctuation, text[match.end()]))
-        return match.end() + 1
-
-    def error_till_line_end(self, start, text):
-        """Mark everything from ``start`` to the end of the line as Error."""
-        end = start
-        try:
-            while text[end] != '\n':  # there's whitespace in rules
-                end += 1
-        except IndexError:
-            end = len(text)
-        if end != start:
-            self.cur.append((start, Error, text[start:end]))
-        end = self.whitespace(end, text)
-        return end
-
-    def get_tokens_unprocessed(self, text):
-        """Returns a list of TNT tokens."""
-        self.cur = []
-        start = end = self.whitespace(0, text)
-        while start <= end < len(text):
-            try:
-                # try line number
-                while text[end] in self.NUMBERS:
-                    end += 1
-                if end != start:  # actual number present
-                    self.cur.append((start, Number.Integer, text[start:end]))
-                    # whitespace is required after a line number
-                    orig = len(self.cur)
-                    try:
-                        start = end = self.whitespace(end, text, True)
-                    except AssertionError:
-                        del self.cur[orig:]
-                        start = end = self.error_till_line_end(end, text)
-                        continue
-                # at this point it could be a comment
-                match = self.COMMENT.match(text, start)
-                if match is not None:
-                    self.cur.append((start, Comment, text[start:match.end()]))
-                    start = end = match.end()
-                    # anything after the closing bracket is invalid
-                    start = end = self.error_till_line_end(start, text)
-                    # do not attempt to process the rest
-                    continue
-                del match
-                if text[start] in '[]':  # fantasy push or pop
-                    self.cur.append((start, Keyword, text[start]))
-                    start += 1
-                    end += 1
-                else:
-                    # one formula, possibly containing subformulae
-                    orig = len(self.cur)
-                    try:
-                        start = end = self.formula(start, text)
-                    except (AssertionError, RecursionError):  # not well-formed
-                        del self.cur[orig:]
-                        while text[end] not in self.WHITESPACE:
-                            end += 1
-                        self.cur.append((start, Error, text[start:end]))
-                        start = end
-                # skip whitespace after formula
-                orig = len(self.cur)
-                try:
-                    start = end = self.whitespace(end, text, True)
-                except AssertionError:
-                    del self.cur[orig:]
-                    start = end = self.error_till_line_end(start, text)
-                    continue
-                # rule proving this formula a theorem
-                orig = len(self.cur)
-                try:
-                    start = end = self.rule(start, text)
-                except AssertionError:
-                    del self.cur[orig:]
-                    start = end = self.error_till_line_end(start, text)
-                    continue
-                # skip whitespace after rule
-                start = end = self.whitespace(end, text)
-                # line marker
-                if text[start] == '(':
-                    orig = len(self.cur)
-                    try:
-                        start = end = self.lineno(start, text)
-                    except AssertionError:
-                        del self.cur[orig:]
-                        start = end = self.error_till_line_end(start, text)
-                        continue
-                    start = end = self.whitespace(start, text)
-            except IndexError:
-                try:
-                    del self.cur[orig:]
-                except NameError:
-                    pass  # if orig was never defined, fine
-                self.error_till_line_end(start, text)
-        return self.cur

py2docfx/venv/template/Lib/site-packages/pygments/lexers/trafficscript.py

@@ -1,51 +0,0 @@
-"""
-    pygments.lexers.trafficscript
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexer for RiverBed's TrafficScript (RTS) language.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer
-from pygments.token import String, Number, Name, Keyword, Operator, Text, Comment
-
-__all__ = ['RtsLexer']
-
-
-class RtsLexer(RegexLexer):
-    """
-    For Riverbed Stingray Traffic Manager
-    """
-    name = 'TrafficScript'
-    aliases = ['trafficscript', 'rts']
-    filenames = ['*.rts']
-    url = 'https://riverbed.com'
-    version_added = '2.1'
-
-    tokens = {
-        'root' : [
-            (r"'(\\\\|\\[^\\]|[^'\\])*'", String),
-            (r'"', String, 'escapable-string'),
-            (r'(0x[0-9a-fA-F]+|\d+)', Number),
-            (r'\d+\.\d+', Number.Float),
-            (r'\$[a-zA-Z](\w|_)*', Name.Variable),
-            (r'(if|else|for(each)?|in|while|do|break|sub|return|import)', Keyword),
-            (r'[a-zA-Z][\w.]*', Name.Function),
-            (r'[-+*/%=,;(){}<>^.!~|&\[\]\?\:]', Operator),
-            (r'(>=|<=|==|!=|'
-             r'&&|\|\||'
-             r'\+=|.=|-=|\*=|/=|%=|<<=|>>=|&=|\|=|\^=|'
-             r'>>|<<|'
-             r'\+\+|--|=>)', Operator),
-            (r'[ \t\r]+', Text),
-            (r'#[^\n]*', Comment),
-        ],
-        'escapable-string' : [
-            (r'\\[tsn]', String.Escape),
-            (r'[^"]', String),
-            (r'"', String, '#pop'),
-        ],
-
-    }

py2docfx/venv/template/Lib/site-packages/pygments/lexers/typoscript.py

@@ -1,216 +0,0 @@
-"""
-    pygments.lexers.typoscript
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for TypoScript
-
-    `TypoScriptLexer`
-        A TypoScript lexer.
-
-    `TypoScriptCssDataLexer`
-        Lexer that highlights markers, constants and registers within css.
-
-    `TypoScriptHtmlDataLexer`
-        Lexer that highlights markers, constants and registers within html tags.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-from pygments.lexer import RegexLexer, include, bygroups, using
-from pygments.token import Text, Comment, Name, String, Number, \
-    Operator, Punctuation
-
-__all__ = ['TypoScriptLexer', 'TypoScriptCssDataLexer', 'TypoScriptHtmlDataLexer']
-
-
-class TypoScriptCssDataLexer(RegexLexer):
-    """
-    Lexer that highlights markers, constants and registers within css blocks.
-    """
-
-    name = 'TypoScriptCssData'
-    aliases = ['typoscriptcssdata']
-    url = 'http://docs.typo3.org/typo3cms/TyposcriptReference/'
-    version_added = '2.2'
-
-    tokens = {
-        'root': [
-            # marker: ###MARK###
-            (r'(.*)(###\w+###)(.*)', bygroups(String, Name.Constant, String)),
-            # constant: {$some.constant}
-            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
-             bygroups(String.Symbol, Operator, Name.Constant,
-                      Name.Constant, String.Symbol)),  # constant
-            # constant: {register:somevalue}
-            (r'(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)',
-             bygroups(String, String.Symbol, Name.Constant, Operator,
-                      Name.Constant, String.Symbol, String)),  # constant
-            # whitespace
-            (r'\s+', Text),
-            # comments
-            (r'/\*(?:(?!\*/).)*\*/', Comment),
-            (r'(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)',
-             Comment),
-            # other
-            (r'[<>,:=.*%+|]', String),
-            (r'[\w"\-!/&;(){}]+', String),
-        ]
-    }
-
-
-class TypoScriptHtmlDataLexer(RegexLexer):
-    """
-    Lexer that highlights markers, constants and registers within html tags.
-    """
-
-    name = 'TypoScriptHtmlData'
-    aliases = ['typoscripthtmldata']
-    url = 'http://docs.typo3.org/typo3cms/TyposcriptReference/'
-    version_added = '2.2'
-
-    tokens = {
-        'root': [
-            # INCLUDE_TYPOSCRIPT
-            (r'(INCLUDE_TYPOSCRIPT)', Name.Class),
-            # Language label or extension resource FILE:... or LLL:... or EXT:...
-            (r'(EXT|FILE|LLL):[^}\n"]*', String),
-            # marker: ###MARK###
-            (r'(.*)(###\w+###)(.*)', bygroups(String, Name.Constant, String)),
-            # constant: {$some.constant}
-            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
-             bygroups(String.Symbol, Operator, Name.Constant,
-                      Name.Constant, String.Symbol)),  # constant
-            # constant: {register:somevalue}
-            (r'(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)',
-             bygroups(String, String.Symbol, Name.Constant, Operator,
-                      Name.Constant, String.Symbol, String)),  # constant
-            # whitespace
-            (r'\s+', Text),
-            # other
-            (r'[<>,:=.*%+|]', String),
-            (r'[\w"\-!/&;(){}#]+', String),
-        ]
-    }
-
-
-class TypoScriptLexer(RegexLexer):
-    """
-    Lexer for TypoScript code.
-    """
-
-    name = 'TypoScript'
-    url = 'http://docs.typo3.org/typo3cms/TyposcriptReference/'
-    aliases = ['typoscript']
-    filenames = ['*.typoscript']
-    mimetypes = ['text/x-typoscript']
-    version_added = '2.2'
-
-    flags = re.DOTALL | re.MULTILINE
-
-    tokens = {
-        'root': [
-            include('comment'),
-            include('constant'),
-            include('html'),
-            include('label'),
-            include('whitespace'),
-            include('keywords'),
-            include('punctuation'),
-            include('operator'),
-            include('structure'),
-            include('literal'),
-            include('other'),
-        ],
-        'keywords': [
-            # Conditions
-            (r'(?i)(\[)(browser|compatVersion|dayofmonth|dayofweek|dayofyear|'
-             r'device|ELSE|END|GLOBAL|globalString|globalVar|hostname|hour|IP|'
-             r'language|loginUser|loginuser|minute|month|page|PIDinRootline|'
-             r'PIDupinRootline|system|treeLevel|useragent|userFunc|usergroup|'
-             r'version)([^\]]*)(\])',
-             bygroups(String.Symbol, Name.Constant, Text, String.Symbol)),
-            # Functions
-            (r'(?=[\w\-])(HTMLparser|HTMLparser_tags|addParams|cache|encapsLines|'
-             r'filelink|if|imageLinkWrap|imgResource|makelinks|numRows|numberFormat|'
-             r'parseFunc|replacement|round|select|split|stdWrap|strPad|tableStyle|'
-             r'tags|textStyle|typolink)(?![\w\-])', Name.Function),
-            # Toplevel objects and _*
-            (r'(?:(=?\s*<?\s+|^\s*))(cObj|field|config|content|constants|FEData|'
-             r'file|frameset|includeLibs|lib|page|plugin|register|resources|sitemap|'
-             r'sitetitle|styles|temp|tt_[^:.\s]*|types|xmlnews|INCLUDE_TYPOSCRIPT|'
-             r'_CSS_DEFAULT_STYLE|_DEFAULT_PI_VARS|_LOCAL_LANG)(?![\w\-])',
-             bygroups(Operator, Name.Builtin)),
-            # Content objects
-            (r'(?=[\w\-])(CASE|CLEARGIF|COA|COA_INT|COBJ_ARRAY|COLUMNS|CONTENT|'
-             r'CTABLE|EDITPANEL|FILE|FILES|FLUIDTEMPLATE|FORM|HMENU|HRULER|HTML|'
-             r'IMAGE|IMGTEXT|IMG_RESOURCE|LOAD_REGISTER|MEDIA|MULTIMEDIA|OTABLE|'
-             r'PAGE|QTOBJECT|RECORDS|RESTORE_REGISTER|SEARCHRESULT|SVG|SWFOBJECT|'
-             r'TEMPLATE|TEXT|USER|USER_INT)(?![\w\-])', Name.Class),
-            # Menu states
-            (r'(?=[\w\-])(ACTIFSUBRO|ACTIFSUB|ACTRO|ACT|CURIFSUBRO|CURIFSUB|CURRO|'
-             r'CUR|IFSUBRO|IFSUB|NO|SPC|USERDEF1RO|USERDEF1|USERDEF2RO|USERDEF2|'
-             r'USRRO|USR)', Name.Class),
-            # Menu objects
-            (r'(?=[\w\-])(GMENU_FOLDOUT|GMENU_LAYERS|GMENU|IMGMENUITEM|IMGMENU|'
-             r'JSMENUITEM|JSMENU|TMENUITEM|TMENU_LAYERS|TMENU)', Name.Class),
-            # PHP objects
-            (r'(?=[\w\-])(PHP_SCRIPT(_EXT|_INT)?)', Name.Class),
-            (r'(?=[\w\-])(userFunc)(?![\w\-])', Name.Function),
-        ],
-        'whitespace': [
-            (r'\s+', Text),
-        ],
-        'html': [
-            (r'<\S[^\n>]*>', using(TypoScriptHtmlDataLexer)),
-            (r'&[^;\n]*;', String),
-            (r'(?s)(_CSS_DEFAULT_STYLE)(\s*)(\()(.*(?=\n\)))',
-             bygroups(Name.Class, Text, String.Symbol, using(TypoScriptCssDataLexer))),
-        ],
-        'literal': [
-            (r'0x[0-9A-Fa-f]+t?', Number.Hex),
-            # (r'[0-9]*\.[0-9]+([eE][0-9]+)?[fd]?\s*(?:[^=])', Number.Float),
-            (r'[0-9]+', Number.Integer),
-            (r'(###\w+###)', Name.Constant),
-        ],
-        'label': [
-            # Language label or extension resource FILE:... or LLL:... or EXT:...
-            (r'(EXT|FILE|LLL):[^}\n"]*', String),
-            # Path to a resource
-            (r'(?![^\w\-])([\w\-]+(?:/[\w\-]+)+/?)(\S*\n)',
-             bygroups(String, String)),
-        ],
-        'punctuation': [
-            (r'[,.]', Punctuation),
-        ],
-        'operator': [
-            (r'[<>,:=.*%+|]', Operator),
-        ],
-        'structure': [
-            # Brackets and braces
-            (r'[{}()\[\]\\]', String.Symbol),
-        ],
-        'constant': [
-            # Constant: {$some.constant}
-            (r'(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})',
-                bygroups(String.Symbol, Operator, Name.Constant,
-                         Name.Constant, String.Symbol)),  # constant
-            # Constant: {register:somevalue}
-            (r'(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})',
-                bygroups(String.Symbol, Name.Constant, Operator,
-                         Name.Constant, String.Symbol)),  # constant
-            # Hex color: #ff0077
-            (r'(#[a-fA-F0-9]{6}\b|#[a-fA-F0-9]{3}\b)', String.Char)
-        ],
-        'comment': [
-            (r'(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)',
-             Comment),
-            (r'/\*(?:(?!\*/).)*\*/', Comment),
-            (r'(\s*#\s*\n)', Comment),
-        ],
-        'other': [
-            (r'[\w"\-!/&;]+', Text),
-        ],
-    }

py2docfx/venv/template/Lib/site-packages/pygments/lexers/typst.py

@@ -1,104 +0,0 @@
-"""
-    pygments.lexers.typst
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    Lexers for Typst language.
-
-    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from pygments.lexer import RegexLexer, words, bygroups, include
-from pygments.token import Comment, Keyword, Name, String, Punctuation, \
-    Whitespace, Generic, Operator, Number, Text
-
-__all__ = ['TypstLexer']
-
-
-class TypstLexer(RegexLexer):
-    """
-    For Typst code.
-    """
-
-    name = 'Typst'
-    aliases = ['typst']
-    filenames = ['*.typ']
-    mimetypes = ['text/x-typst']
-    url = 'https://typst.app'
-    version_added = '2.18'
-
-    tokens = {
-        'root': [
-            include('markup'),
-        ],
-        'common': [
-            (r'[ \t]+', Whitespace),
-            (r'((?!=[*_$`\-+0-9/<@\\#\[]|https?://).)+', Text),
-        ],
-        'markup': [
-            include('comment'),
-            (r'^\s*=+.*$', Generic.Heading),
-            (r'[*][^*]*[*]', Generic.Strong),
-            (r'_[^_]*_', Generic.Emph),
-            (r'\$', Punctuation, 'maths'),
-            (r'`[^`]*`', String.Backtick),  # inline code
-            (r'^\s*-', Punctuation),  # unnumbered list
-            (r'^\s*\+', Punctuation),  # numbered list
-            (r'^\s*[0-9.]+', Punctuation),  # numbered list variant
-            (r'^(\s*/\s+)([^:]+)(:)', bygroups(Punctuation, Name.Variable, Punctuation)),  # definitions
-            (r'<[a-zA-Z_][a-zA-Z0-9_-]*>', Name.Label),  # label
-            (r'@[a-zA-Z_][a-zA-Z0-9_-]*', Name.Label),  # reference
-            (r'\\#', Text), # escaped
-            (words(('#let', '#set', '#show'), suffix=r'\b'), Keyword.Declaration, 'inline_code'),
-            (r'(#[a-zA-Z_][a-zA-Z0-9_]*)(\[)', bygroups(Name.Function, Punctuation), 'markup'),
-            (r'(#[a-zA-Z_][a-zA-Z0-9_]*)(\()', bygroups(Name.Function, Punctuation), 'inline_code'),
-            (r'#[a-zA-Z_][a-zA-Z0-9_]*', Name.Variable),
-            (r'```(?:.|\n)*?```', String.Backtick),  # code block
-            (r'https?://[0-9a-zA-Z~/%#&=\',;.+?]*', Generic.Emph),  # links
-            (words((r'---', r'\\', r'~', r'--', r'...'), suffix=r'\b'), Punctuation),  # special chars shorthand
-            (r'\\\[', Punctuation),  # escaped
-            (r'\\\]', Punctuation),  # escaped
-            (r'\[', Punctuation, '#push'),
-            (r'\]', Punctuation, '#pop'),
-            include('common'),
-        ],
-        'maths': [
-            include('comment'),
-            (words(('_', '^', '+', '-', '/', '*', '->', '<-', '!=', '=='),
-                   suffix=r'\b'), Operator),
-            (words((r'\\', '$='), suffix=r'\b'), Operator),  # maths markup operators
-            (r'\\\$', Punctuation),  # escaped
-            (r'\$', Punctuation, '#pop'),  # end of math mode
-            include('code'),
-        ],
-        'comment': [
-            (r'//.*$', Comment.Single),
-            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
-        ],
-        'code': [
-            include('comment'),
-            (r'\[', Punctuation, 'markup'),
-            (r'\(|\{', Punctuation, 'code'),
-            (r'\)|\}', Punctuation, '#pop'),
-            (r'"[^"]*"', String.Double),
-            (r'[=,]', Operator),
-            (words(('and', 'or', 'not'), suffix=r'\b'), Operator.Word),
-            (r'=>|<=|==|!=|>|<|-=|\+=|\*=|/=|\+|-|\\|\*', Operator), # comparisons
-            (r'([a-zA-Z_][a-zA-Z0-9_]*)(:)', bygroups(Name.Variable, Punctuation), '#push'),
-            (r'([a-zA-Z_][a-zA-Z0-9_]*)(\()', bygroups(Name.Function, Punctuation), '#push'),
-            (words(('as', 'break', 'export', 'continue', 'else', 'for', 'if',
-                    'import', 'in', 'include', 'return', 'while'), suffix=r'\b'),
-             Keyword.Reserved),
-            (words(('auto', 'none', 'true', 'false'), suffix=r'\b'), Keyword.Constant),
-            (r'([0-9.]+)(mm|pt|cm|in|em|fr|%)', bygroups(Number, Keyword.Reserved)),
-            (words(('let', 'set', 'show'), suffix=r'\b'), Keyword.Declaration),
-            # FIXME: make this work
-            ## (r'(import|include)( *)(")([^"])(")',
-            ##  bygroups(Keyword.Reserved, Text, Punctuation, String.Double, Punctuation)),
-            include('common'),
-        ],
-        'inline_code': [
-            (r';$', Punctuation, '#pop'),
-            include('code'),
-        ],
-    }