py2docfx 0.1.11.dev1869610__py3-none-any.whl → 0.1.11.dev1872139__py3-none-any.whl

py2docfx/venv/1/Lib/site-packages/pygments/lexers/kuin.py

@@ -0,0 +1,332 @@
+"""
+    pygments.lexers.kuin
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Kuin language.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, include, using, this, bygroups, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+        Number, Punctuation, Whitespace
+
+__all__ = ['KuinLexer']
+
+
+class KuinLexer(RegexLexer):
+    """
+    For Kuin source code.
+    """
+    name = 'Kuin'
+    url = 'https://github.com/kuina/Kuin'
+    aliases = ['kuin']
+    filenames = ['*.kn']
+    version_added = '2.9'
+
+    tokens = {
+        'root': [
+            include('statement'),
+        ],
+        'statement': [
+            # Whitespace / Comment
+            include('whitespace'),
+
+            # Block-statement
+            (r'(\+?)([ \t]*)(\*?)([ \t]*)(\bfunc)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)',
+             bygroups(Keyword,Whitespace, Keyword, Whitespace,  Keyword,
+                      using(this), Name.Function), 'func_'),
+            (r'\b(class)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)',
+             bygroups(Keyword, using(this), Name.Class), 'class_'),
+            (r'\b(enum)([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*)',
+             bygroups(Keyword, using(this), Name.Constant), 'enum_'),
+            (r'\b(block)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'block_'),
+            (r'\b(ifdef)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'ifdef_'),
+            (r'\b(if)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'if_'),
+            (r'\b(switch)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'switch_'),
+            (r'\b(while)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'while_'),
+            (r'\b(for)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'for_'),
+            (r'\b(foreach)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'foreach_'),
+            (r'\b(try)\b(?:([ \t]+(?:\n\s*\|)*[ \t]*)([a-zA-Z_][0-9a-zA-Z_]*))?',
+             bygroups(Keyword, using(this), Name.Other), 'try_'),
+
+            # Line-statement
+            (r'\b(do)\b', Keyword, 'do'),
+            (r'(\+?[ \t]*\bvar)\b', Keyword, 'var'),
+            (r'\b(const)\b', Keyword, 'const'),
+            (r'\b(ret)\b', Keyword, 'ret'),
+            (r'\b(throw)\b', Keyword, 'throw'),
+            (r'\b(alias)\b', Keyword, 'alias'),
+            (r'\b(assert)\b', Keyword, 'assert'),
+            (r'\|', Text, 'continued_line'),
+            (r'[ \t]*\n', Whitespace),
+        ],
+
+        # Whitespace / Comment
+        'whitespace': [
+            (r'^([ \t]*)(;.*)', bygroups(Comment.Single, Whitespace)),
+            (r'[ \t]+(?![; \t])', Whitespace),
+            (r'\{', Comment.Multiline, 'multiline_comment'),
+        ],
+        'multiline_comment': [
+            (r'\{', Comment.Multiline, 'multiline_comment'),
+            (r'(?:\s*;.*|[^{}\n]+)', Comment.Multiline),
+            (r'\n', Comment.Multiline),
+            (r'\}', Comment.Multiline, '#pop'),
+        ],
+
+        # Block-statement
+        'func_': [
+            include('expr'),
+            (r'\n', Whitespace, 'func'),
+        ],
+        'func': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(func)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+        ],
+        'class_': [
+            include('expr'),
+            (r'\n', Whitespace, 'class'),
+        ],
+        'class': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(class)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+        ],
+        'enum_': [
+            include('expr'),
+            (r'\n', Whitespace, 'enum'),
+        ],
+        'enum': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(enum)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('expr'),
+            (r'\n', Whitespace),
+        ],
+        'block_': [
+            include('expr'),
+            (r'\n', Whitespace, 'block'),
+        ],
+        'block': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(block)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'ifdef_': [
+            include('expr'),
+            (r'\n', Whitespace, 'ifdef'),
+        ],
+        'ifdef': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(ifdef)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('rls', 'dbg'), prefix=r'\b', suffix=r'\b'),
+             Keyword.Constant, 'ifdef_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'ifdef_sp': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'if_': [
+            include('expr'),
+            (r'\n', Whitespace, 'if'),
+        ],
+        'if': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(if)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('elif', 'else'), prefix=r'\b', suffix=r'\b'), Keyword, 'if_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'if_sp': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'switch_': [
+            include('expr'),
+            (r'\n', Whitespace, 'switch'),
+        ],
+        'switch': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(switch)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('case', 'default', 'to'), prefix=r'\b', suffix=r'\b'),
+             Keyword, 'switch_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'switch_sp': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'while_': [
+            include('expr'),
+            (r'\n', Whitespace, 'while'),
+        ],
+        'while': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(while)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'for_': [
+            include('expr'),
+            (r'\n', Whitespace, 'for'),
+        ],
+        'for': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(for)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'foreach_': [
+            include('expr'),
+            (r'\n', Whitespace, 'foreach'),
+        ],
+        'foreach': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(foreach)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'try_': [
+            include('expr'),
+            (r'\n', Whitespace, 'try'),
+        ],
+        'try': [
+            (r'\b(end)([ \t]+(?:\n\s*\|)*[ \t]*)(try)\b',
+             bygroups(Keyword, using(this), Keyword), '#pop:2'),
+            (words(('catch', 'finally', 'to'), prefix=r'\b', suffix=r'\b'),
+             Keyword, 'try_sp'),
+            include('statement'),
+            include('break'),
+            include('skip'),
+        ],
+        'try_sp': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+
+        # Line-statement
+        'break': [
+            (r'\b(break)\b([ \t]+)([a-zA-Z_][0-9a-zA-Z_]*)',
+             bygroups(Keyword, using(this), Name.Other)),
+        ],
+        'skip': [
+            (r'\b(skip)\b([ \t]+)([a-zA-Z_][0-9a-zA-Z_]*)',
+             bygroups(Keyword, using(this), Name.Other)),
+        ],
+        'alias': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'assert': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'const': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'do': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'ret': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'throw': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'var': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+        'continued_line': [
+            include('expr'),
+            (r'\n', Whitespace, '#pop'),
+        ],
+
+        'expr': [
+            # Whitespace / Comment
+            include('whitespace'),
+
+            # Punctuation
+            (r'\(', Punctuation,),
+            (r'\)', Punctuation,),
+            (r'\[', Punctuation,),
+            (r'\]', Punctuation,),
+            (r',', Punctuation),
+
+            # Keyword
+            (words((
+                'true', 'false', 'null', 'inf'
+                ), prefix=r'\b', suffix=r'\b'), Keyword.Constant),
+            (words((
+                'me'
+                ), prefix=r'\b', suffix=r'\b'), Keyword),
+            (words((
+                'bit16', 'bit32', 'bit64', 'bit8', 'bool',
+                'char', 'class', 'dict', 'enum', 'float', 'func',
+                'int', 'list', 'queue', 'stack'
+                ), prefix=r'\b', suffix=r'\b'), Keyword.Type),
+
+            # Number
+            (r'\b[0-9]\.[0-9]+(?!\.)(:?e[\+-][0-9]+)?\b', Number.Float),
+            (r'\b2#[01]+(?:b(?:8|16|32|64))?\b', Number.Bin),
+            (r'\b8#[0-7]+(?:b(?:8|16|32|64))?\b', Number.Oct),
+            (r'\b16#[0-9A-F]+(?:b(?:8|16|32|64))?\b', Number.Hex),
+            (r'\b[0-9]+(?:b(?:8|16|32|64))?\b', Number.Decimal),
+
+            # String / Char
+            (r'"', String.Double, 'string'),
+            (r"'(?:\\.|.)+?'", String.Char),
+
+            # Operator
+            (r'(?:\.|\$(?:>|<)?)', Operator),
+            (r'(?:\^)', Operator),
+            (r'(?:\+|-|!|##?)', Operator),
+            (r'(?:\*|/|%)', Operator),
+            (r'(?:~)', Operator),
+            (r'(?:(?:=|<>)(?:&|\$)?|<=?|>=?)', Operator),
+            (r'(?:&)', Operator),
+            (r'(?:\|)', Operator),
+            (r'(?:\?)', Operator),
+            (r'(?::(?::|\+|-|\*|/|%|\^|~)?)', Operator),
+
+            # Identifier
+            (r"\b([a-zA-Z_][0-9a-zA-Z_]*)(?=@)\b", Name),
+            (r"(@)?\b([a-zA-Z_][0-9a-zA-Z_]*)\b",
+             bygroups(Name.Other, Name.Variable)),
+        ],
+
+        # String
+        'string': [
+            (r'(?:\\[^{\n]|[^"\\])+', String.Double),
+            (r'\\\{', String.Double, 'toStrInString'),
+            (r'"', String.Double, '#pop'),
+        ],
+        'toStrInString': [
+            include('expr'),
+            (r'\}', String.Double, '#pop'),
+        ],
+    }

py2docfx/venv/1/Lib/site-packages/pygments/lexers/kusto.py

@@ -0,0 +1,93 @@
+"""
+    pygments.lexers.kusto
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Kusto Query Language (KQL).
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import (Comment, Keyword, Name, Number, Punctuation,
+                            String, Whitespace)
+
+__all__ = ["KustoLexer"]
+
+# Although these all seem to be keywords
+# https://github.com/microsoft/Kusto-Query-Language/blob/master/src/Kusto.Language/Syntax/SyntaxFacts.cs
+# it appears that only the ones with tags here
+# https://github.com/microsoft/Kusto-Query-Language/blob/master/src/Kusto.Language/Parser/QueryGrammar.cs
+# are highlighted in the Azure portal log query editor.
+KUSTO_KEYWORDS = [
+    'and', 'as', 'between', 'by', 'consume', 'contains', 'containscs', 'count',
+    'distinct', 'evaluate', 'extend', 'facet', 'filter', 'find', 'fork',
+    'getschema', 'has', 'invoke', 'join', 'limit', 'lookup', 'make-series',
+    'matches regex', 'mv-apply', 'mv-expand', 'notcontains', 'notcontainscs',
+    '!contains', '!has', '!startswith', 'on', 'or', 'order', 'parse', 'parse-where',
+    'parse-kv', 'partition', 'print', 'project', 'project-away', 'project-keep',
+    'project-rename', 'project-reorder', 'range', 'reduce', 'regex', 'render',
+    'sample', 'sample-distinct', 'scan', 'search', 'serialize', 'sort', 'startswith',
+    'summarize', 'take', 'top', 'top-hitters', 'top-nested', 'typeof', 'union',
+    'where', 'bool', 'date', 'datetime', 'int', 'long', 'real', 'string', 'time'
+]
+
+# From
+# https://github.com/microsoft/Kusto-Query-Language/blob/master/src/Kusto.Language/Syntax/SyntaxFacts.cs
+KUSTO_PUNCTUATION = [
+    "(", ")", "[", "]", "{", "}", "|", "<|", "+", "-", "*", "/",
+    "%", ".." "!", "<", "<=", ">", ">=", "=", "==", "!=", "<>",
+    ":", ";", ",", "=~", "!~", "?", "=>",
+]
+
+
+class KustoLexer(RegexLexer):
+    """For Kusto Query Language source code.
+    """
+
+    name = "Kusto"
+    aliases = ["kql", "kusto"]
+    filenames = ["*.kql", "*.kusto", ".csl"]
+    url = "https://learn.microsoft.com/en-us/azure/data-explorer/kusto/query"
+    version_added = '2.17'
+
+    tokens = {
+        "root": [
+            (r"\s+", Whitespace),
+            (words(KUSTO_KEYWORDS, suffix=r"\b"), Keyword),
+            (r"//.*", Comment),
+            (words(KUSTO_PUNCTUATION), Punctuation),
+            (r"[^\W\d]\w*", Name),
+            # Numbers can take the form 1, .1, 1., 1.1, 1.1111, etc.
+            (r"\d+[.]\d*|[.]\d+", Number.Float),
+            (r"\d+", Number.Integer),
+            (r"'", String, "single_string"),
+            (r'"', String, "double_string"),
+            (r"@'", String, "single_verbatim"),
+            (r'@"', String, "double_verbatim"),
+            (r"```", String, "multi_string"),
+        ],
+        "single_string": [
+            (r"'", String, "#pop"),
+            (r"\\.", String.Escape),
+            (r"[^'\\]+", String),
+        ],
+        "double_string": [
+            (r'"', String, "#pop"),
+            (r"\\.", String.Escape),
+            (r'[^"\\]+', String),
+        ],
+        "single_verbatim": [
+            (r"'", String, "#pop"),
+            (r"[^']+", String),
+        ],
+        "double_verbatim": [
+            (r'"', String, "#pop"),
+            (r'[^"]+', String),
+        ],
+        "multi_string": [
+            (r"[^`]+", String),
+            (r"```", String, "#pop"),
+            (r"`", String),
+        ],
+    }

py2docfx/venv/1/Lib/site-packages/pygments/lexers/ldap.py

@@ -0,0 +1,155 @@
+"""
+    pygments.lexers.ldap
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Pygments lexers for LDAP.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+
+from pygments.lexer import RegexLexer, bygroups, default
+from pygments.token import Operator, Comment, Keyword, Literal, Name, String, \
+    Number, Punctuation, Whitespace, Escape
+
+__all__ = ['LdifLexer', 'LdaprcLexer']
+
+
+class LdifLexer(RegexLexer):
+
+    """
+    Lexer for LDIF
+    """
+
+    name = 'LDIF'
+    aliases = ['ldif']
+    filenames = ['*.ldif']
+    mimetypes = ["text/x-ldif"]
+    url = "https://datatracker.ietf.org/doc/html/rfc2849"
+    version_added = '2.17'
+
+    tokens = {
+        'root': [
+            (r'\s*\n', Whitespace),
+            (r'(-)(\n)', bygroups(Punctuation, Whitespace)),
+            (r'(#.*)(\n)', bygroups(Comment.Single, Whitespace)),
+            (r'(version)(:)([ \t]*)(.*)([ \t]*\n)', bygroups(Keyword,
+             Punctuation, Whitespace, Number.Integer, Whitespace)),
+            (r'(control)(:)([ \t]*)([\.0-9]+)([ \t]+)((?:true|false)?)([ \t]*)',
+                bygroups(Keyword, Punctuation, Whitespace, Name.Other, Whitespace, Keyword, Whitespace), "after-control"),
+            (r'(deleteoldrdn)(:)([ \n]*)([0-1]+)([ \t]*\n)',
+             bygroups(Keyword, Punctuation, Whitespace, Number, Whitespace)),
+            (r'(add|delete|replace)(::?)(\s*)(.*)([ \t]*\n)', bygroups(
+                Keyword, Punctuation, Whitespace, Name.Attribute, Whitespace)),
+            (r'(changetype)(:)([ \t]*)([a-z]*)([ \t]*\n)',
+             bygroups(Keyword, Punctuation, Whitespace, Keyword, Whitespace)),
+            (r'(dn|newrdn)(::)', bygroups(Keyword, Punctuation), "base64-dn"),
+            (r'(dn|newrdn)(:)', bygroups(Keyword, Punctuation), "dn"),
+            (r'(objectclass)(:)([ \t]*)([^ \t\n]*)([ \t]*\n)', bygroups(
+                Keyword, Punctuation, Whitespace, Name.Class, Whitespace)),
+            (r'([a-zA-Z]*|[0-9][0-9\.]*[0-9])(;)',
+             bygroups(Name.Attribute, Punctuation), "property"),
+            (r'([a-zA-Z]*|[0-9][0-9\.]*[0-9])(:<)',
+             bygroups(Name.Attribute, Punctuation), "url"),
+            (r'([a-zA-Z]*|[0-9][0-9\.]*[0-9])(::?)',
+             bygroups(Name.Attribute, Punctuation), "value"),
+        ],
+        "after-control": [
+            (r":<", Punctuation, ("#pop", "url")),
+            (r"::?", Punctuation, ("#pop", "value")),
+            default("#pop"),
+        ],
+        'property': [
+            (r'([-a-zA-Z0-9]*)(;)', bygroups(Name.Property, Punctuation)),
+            (r'([-a-zA-Z0-9]*)(:<)',
+             bygroups(Name.Property, Punctuation), ("#pop", "url")),
+            (r'([-a-zA-Z0-9]*)(::?)',
+             bygroups(Name.Property, Punctuation), ("#pop", "value")),
+        ],
+        'value': [
+            (r'(\s*)([^\n]+\S)(\n )',
+             bygroups(Whitespace, String, Whitespace)),
+            (r'(\s*)([^\n]+\S)(\n)',
+             bygroups(Whitespace, String, Whitespace), "#pop"),
+        ],
+        'url': [
+            (r'([ \t]*)(\S*)([ \t]*\n )',
+             bygroups(Whitespace, Comment.PreprocFile, Whitespace)),
+            (r'([ \t]*)(\S*)([ \t]*\n)', bygroups(Whitespace,
+             Comment.PreprocFile, Whitespace), "#pop"),
+        ],
+        "dn": [
+            (r'([ \t]*)([-a-zA-Z0-9\.]+)(=)', bygroups(Whitespace,
+             Name.Attribute, Operator), ("#pop", "dn-value")),
+        ],
+        "dn-value": [
+            (r'\\[^\n]', Escape),
+            (r',', Punctuation, ("#pop", "dn")),
+            (r'\+', Operator, ("#pop", "dn")),
+            (r'[^,\+\n]+', String),
+            (r'\n ', Whitespace),
+            (r'\n', Whitespace, "#pop"),
+        ],
+        "base64-dn": [
+            (r'([ \t]*)([^ \t\n][^ \t\n]*[^\n])([ \t]*\n )',
+             bygroups(Whitespace, Name, Whitespace)),
+            (r'([ \t]*)([^ \t\n][^ \t\n]*[^\n])([ \t]*\n)',
+             bygroups(Whitespace, Name, Whitespace), "#pop"),
+        ]
+    }
+
+
+class LdaprcLexer(RegexLexer):
+    """
+    Lexer for OpenLDAP configuration files.
+    """
+
+    name = 'LDAP configuration file'
+    aliases = ['ldapconf', 'ldaprc']
+    filenames = ['.ldaprc', 'ldaprc', 'ldap.conf']
+    mimetypes = ["text/x-ldapconf"]
+    url = 'https://www.openldap.org/software//man.cgi?query=ldap.conf&sektion=5&apropos=0&manpath=OpenLDAP+2.4-Release'
+    version_added = '2.17'
+
+    _sasl_keywords = r'SASL_(?:MECH|REALM|AUTHCID|AUTHZID|CBINDING)'
+    _tls_keywords = r'TLS_(?:CACERT|CACERTDIR|CERT|ECNAME|KEY|CIPHER_SUITE|PROTOCOL_MIN|RANDFILE|CRLFILE)'
+    _literal_keywords = rf'(?:URI|SOCKET_BIND_ADDRESSES|{_sasl_keywords}|{_tls_keywords})'
+    _boolean_keywords = r'GSSAPI_(?:ALLOW_REMOTE_PRINCIPAL|ENCRYPT|SIGN)|REFERRALS|SASL_NOCANON'
+    _integer_keywords = r'KEEPALIVE_(?:IDLE|PROBES|INTERVAL)|NETWORK_TIMEOUT|PORT|SIZELIMIT|TIMELIMIT|TIMEOUT'
+    _secprops = r'none|noanonymous|noplain|noactive|nodict|forwardsec|passcred|(?:minssf|maxssf|maxbufsize)=\d+'
+
+    flags = re.IGNORECASE | re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'#.*', Comment.Single),
+            (r'\s+', Whitespace),
+            (rf'({_boolean_keywords})(\s+)(on|true|yes|off|false|no)$',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            (rf'({_integer_keywords})(\s+)(\d+)',
+             bygroups(Keyword, Whitespace, Number.Integer)),
+            (r'(VERSION)(\s+)(2|3)', bygroups(Keyword, Whitespace, Number.Integer)),
+            # Constants
+            (r'(DEREF)(\s+)(never|searching|finding|always)',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            (rf'(SASL_SECPROPS)(\s+)((?:{_secprops})(?:,{_secprops})*)',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            (r'(SASL_CBINDING)(\s+)(none|tls-unique|tls-endpoint)',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            (r'(TLS_REQ(?:CERT|SAN))(\s+)(allow|demand|hard|never|try)',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            (r'(TLS_CRLCHECK)(\s+)(none|peer|all)',
+             bygroups(Keyword, Whitespace, Keyword.Constant)),
+            # Literals
+            (r'(BASE|BINDDN)(\s+)(\S+)$',
+             bygroups(Keyword, Whitespace, Literal)),
+            # Accepts hostname with or without port.
+            (r'(HOST)(\s+)([a-z0-9]+)((?::(\d+))?)',
+             bygroups(Keyword, Whitespace, Literal, Number.Integer)),
+            (rf'({_literal_keywords})(\s+)(\S+)$',
+             bygroups(Keyword, Whitespace, Literal)),
+        ],
+    }