o

���a�q�@s
dZd
dl
Z
d
dlmZmZmZmZmZmZm	Z	m
Z

d
dlmZm
Z
mZmZmZmZmZmZmZmZmZ
d
dlmZ
d
dlmZ
d
dlmZ
gd�
ZGd	d
�d
e�ZGdd�de�Z Gd
d�de�Z!Gdd�de�Z"Gdd�de�Z#Gdd�de�Z$Gdd�de�Z%Gdd�de�Z&dS)z�
    pygments.lexers.dotnet
    ~~~~~~~~~~~~~~~~~~~~~~

    Lexers for .net languages.

    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
�N)�
RegexLexer�DelegatingLexer�bygroups�include�using�this�default�words)�Punctuation�Text�Comment�Operator�Keyword�Name�String�Number�Literal�Other�
Whitespace)
�get_choice_opt)
�	unistring)
�XmlLexer)�CSharpLexer�NemerleLexer�BooLexer�
VbNetLexer�CSharpAspxLexer�VbNetAspxLexer�FSharpLexerc@seZ
dZd
ZdZgd�
Zdg
Zdg
Zej	ej
BejBZdde
�dd	d
dd�d
de
�dd	d
ddddddd�
dde
�dd	d
ddd�dde
�dd	d
dddddddd�dd�ZiZdZe��D]�\ZZdededeeee�
ejee�fdeeej�fdefd eee�fd!ej fd"ej!fd#efd$efd%efd&e"fd'e"fd(e"j#fd)e$fd*eej%eej%ej%e�fd+ee&ee&�fd,e&fd-ee&e�fd.e&j'fd/ee&e�d0fd1ee&e�d2feefgeej(d3fe)d3�
gd4ed3fd5ed6ej*d3fgd7�ee<qed8d9�Z+d:S);ra�
    For `C# <http://msdn2.microsoft.com/en-us/vcsharp/default.aspx>`_
    source code.

    Additional options accepted:

    `unicodelevel`
      Determines which Unicode characters this lexer allows for identifiers.
      The possible values are:

      * ``none`` -- only the ASCII letters and numbers are allowed. This
        is the fastest selection.
      * ``basic`` -- all Unicode characters from the specification except
        category ``Lo`` are allowed.
      * ``full`` -- all Unicode characters as specified in the C# specs
        are allowed.  Note that this means a considerable slowdown since the
        ``Lo`` category has more than 40,000 characters in it!

      The default value is ``basic``.

      .. versionadded:: 0.8
    zC#)�csharpzc#�csz*.csz
text/x-csharp�@?[_a-zA-Z]\w*�@?[_�Lu�Ll�Lt�Lm�Nl�
]�
[�Nd�Pc�Cf�Mn�Mc�]*�	@?(?:_|[^�Lo�])�[^��none�basic�fullT�
^([ \t]*)((?:�(?:\[\])?\s+)+?)(�
)(\s*)(\()�^(\s*)(\[.*?\])�[^\S\n]+�(\\)(\n)�//.*?\n�/[*].*?[*]/�\n�[~!%^&*()+=|\[\]:;,.<>/?-]�[{}]�
@"(""|[^"])*"z!\$?"(\\\\|\\[^\\]|[^"\\\n])*["\n]�
'\\.'|'[^\\]'zA[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?zb(#)([ \t]*)(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma)\b(.*?)(\n)�\b(extern)(\s+)(alias)\ba(abstract|as|async|await|base|break|by|case|catch|checked|const|continue|default|delegate|do|else|enum|event|explicit|extern|false|finally|fixed|for|foreach|goto|if|implicit|in|interface|internal|is|let|lock|new|null|on|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|true|try|typeof|unchecked|unsafe|virtual|void|while|get|set|new|partial|yield|add|remove|value|alias|ascending|descending|from|group|into|orderby|select|thenby|where|join|equals)\b�(global)(::)zk(bool|byte|char|decimal|double|dynamic|float|int|long|object|sbyte|short|string|uint|ulong|ushort|var)\b\??z(class|struct)(\s+)�class�(namespace|using)(\s+)�	namespace�#pop�(?=\()�
(�|\.)+)�rootrGrIc
K�Pt|
d
t
|j�
d�}||jv
r|j�|�
|_n|j||_tj|f
i|
�
�

dS�N�unicodelevelr6�	r�list�tokens�_all_tokens�	__class__�process_tokendef�_tokensr�__init__��self�options�level�r^�8/usr/lib/python3/dist-packages/pygments/lexers/dotnet.pyrY�s



zCSharpLexer.__init__N),�__name__�
__module__�__qualname__�__doc__�name�aliases�	filenames�	mimetypes�re�	MULTILINE�DOTALL�UNICODE�flags�uni�combine�	allexcept�levelsrT�token_variants�items�	levelname�cs_identrrrrr�Functionr
�	Attributerr�Single�	Multiliner�Charr�Preprocr�Type�Classr�	NamespacerYr^r^r^r_rs�





�

���
�
��

����


�
�
��











�
��
��

�

�
.
�
��8rc!@s0eZ
dZd
ZdZdg
Zdg
Zdg
Zej	ej
BejBZdde
�dd	d
dd�d
de
�dd	d
ddddddd�
dde
�dd	d
ddd�dde
�dd	d
dddddddd�dd�ZiZdZe��D�
](\ZZdededeeee�
ejee�fdeeej�fdefd eee�fd!ej fd"ej!fd#efd$ee"ee"�d%fd&ee"ee"�d'fd(e"d)fd*ed+ee#ee#�fd,e#fd-eefd.eee�d/fd0efd1efd2e"fd3e"fd4e"j$fd5e%fd6e%fd7eej&eej&�d8fd9ee#ee#�fd:e#fd;ee#e�fd<e#j'fd=ed>eeee#j'�fd?ee#e�d@fdAee#e�dBfeefgeej(dCfg
dDej&fdEefd#edCfgdFedCfdGedHej)dCfgdIe"fd-eefd.eee�d/fdJe"fdKe"dCfgdLe"fd-eefd.eee�d/fd(e"dMfdNe"dCfgdOe"fd(e"dMfdNe"dCfgdPe#fdQefeefdRe%fdSedMfdTedCfgdU�ee<qddVdW�Z*dXdY�Z+dZS)[ra�
    For `Nemerle <http://nemerle.org>`_ source code.

    Additional options accepted:

    `unicodelevel`
      Determines which Unicode characters this lexer allows for identifiers.
      The possible values are:

      * ``none`` -- only the ASCII letters and numbers are allowed. This
        is the fastest selection.
      * ``basic`` -- all Unicode characters from the specification except
        category ``Lo`` are allowed.
      * ``full`` -- all Unicode characters as specified in the C# specs
        are allowed.  Note that this means a considerable slowdown since the
        ``Lo`` category has more than 40,000 characters in it!

      The default value is ``basic``.

    .. versionadded:: 1.5
    �Nemerle�nemerlez*.nztext/x-nemerler!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4Tr8r9r:r;r<r=r>r?r@z(\$)(\s*)(")�
splice-stringz
(\$)(\s*)(<#)�splice-string2z<#�recursive-stringz(<\[)(\s*)(z:)?z\]\>z\$z(\$)(\()�splice-string-contentrArBrCz"(\\\\|\\[^\\]|[^"\\\n])*["\n]rDz0[xX][0-9a-fA-F]+[Ll]?z*[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?zY(#)([ \t]*)(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma)\b�preprocrEa�
(abstract|and|as|base|catch|def|delegate|enum|event|extern|false|finally|fun|implements|interface|internal|is|macro|match|matches|module|mutable|new|null|out|override|params|partial|private|protected|public|ref|sealed|static|syntax|this|throw|true|try|type|typeof|virtual|volatile|when|where|with|assert|assert2|async|break|checked|continue|do|else|ensures|for|foreach|if|late|lock|new|nolate|otherwise|regexp|repeat|requires|return|surroundwith|unchecked|unless|using|while|yield)\brFzo(bool|byte|char|decimal|double|float|int|long|object|sbyte|short|string|uint|ulong|ushort|void|array|list)\b\??z(:>?)(\s*)(z\??)z"(class|struct|variant|module)(\s+)rGrHrIrJz\w+z[ \t]+rKrLrMz[^"$]z\\"�
"z[^#<>$]�#pushz#>z[^#<>]zif|matchz[~!%^&*+=|\[\]:;,.<>/?-\\"$ ]�\d+�\(�\))rNrGr�rIr�r�r�r�c
KrOrPrRrZr^r^r_rY(
s

�
zNemerleLexer.__init__c
Csd
}
d|vr
|
d7}
|
S)zUNemerle is quite similar to Python, but @if is relatively uncommon
        elsewhere.r
z@ifg�������?r^��text�resultr^r^r_�analyse_text3
s
zNemerleLexer.analyse_textN),r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprTrqrrrsrtrrrrrrur
rvrrrwrxrrryrrzr{r|r}rYr�r^r^r^r_r�s






�

���
�
��

����


�
�
��






�
�
�



�






�
�
�

�

�

��
@�

�
�




�
�	




�
�	

�




��krc@sR
eZ
dZd
ZdZdg
Zdg
Zdg
Zdefde	j
fde	jd	fd
efde
ee�fdefd
ejfdejfdejfdefdefdefde
ee�dfde
ee�dfde
ee�dfdejfdejfdejfdej
fdefdejfdefd ejfd!ejfd"ejjfd#ejfgde	jd$fd%e	jd&fd'e	jfd(e	jfgdejd&fg
dejd&fg
d)ejd&fg
d*�Z d+S),rz<
    For `Boo <http://boo.codehaus.org/>`_ source code.
    �Boo�booz*.booz
text/x-boo�\s+z	(#|//).*$z/[*]�commentz[]{}:(),.;[]r=z\\z(in|is|and|or|not)\bz/(\\\\|\\[^\\]|[^/\\\s])/z@/(\\\\|\\[^\\]|[^/\\])*/z=~|!=|==|<<|>>|[-+/*%=<>&^|]aO
(as|abstract|callable|constructor|destructor|do|import|enum|event|final|get|interface|internal|of|override|partial|private|protected|public|return|set|static|struct|transient|virtual|yield|super|and|break|cast|continue|elif|else|ensure|except|for|given|goto|if|in|is|isa|not|or|otherwise|pass|raise|ref|try|unless|when|while|from|as)\bzdef(?=\s+\(.*?\))z
(def)(\s+)�funcnamez(class)(\s+)�	classnamez(namespace)(\s+)rIz�(?<!\.)(true|false|null|self|__eval__|__switch__|array|assert|checked|enumerate|filter|getter|len|lock|map|matrix|max|min|normalArrayIndexing|print|property|range|rawArrayIndexing|required|typeof|unchecked|using|yieldAll|zip)\bz"""(\\\\|\\"|.*?)"""z"(\\\\|\\[^\\]|[^"\\])*"z'(\\\\|\\[^\\]|[^'\\])*'z[a-zA-Z_]\w*z%(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?z[0-9][0-9.]*(ms?|d|h|s)z0\d+z0x[a-fA-F0-9]+z\d+Lr�r�z[*]/rJz[^/*]z[*/]z[a-zA-Z_][\w.]*)rNr�r�r�rIN)!r`rarbrcrdrerfrgrrrwrxr
rrr
�Wordr�Regexrr�Builtin�Doubler�Float�Oct�Hex�Integer�Longrur|r}rTr^r^r^r_r>
sb














�



�









�
'



�
�
�
�
�rc@s�
eZ
dZd
ZdZddgZddgZddgZd	e�	d
ddd
�dde�	d
ddd
ddddd�	dZ
ejej
BZdejfdefdefdeee�fdeee�fdejfdefdeejeejeej�feddd d!�efd"ed#fd$ed%fd&eee�d'fd(eee�d)fd*eee�d+fd,ejfd-ejfd.efd/ed0fd1eee�fe
d2efd3ejfd4e j!fd5e j"fd6e j"fd7e j"fgd8efd9ed:fd;efge
ej#d:fe$d:�
ge
ej%d:fg
e
ej&d:fg
e
ej'fd<ej'fe$d:�
gdefd=ed:fe$d:�
gd>�Z(d?d@�Z)dAS)Brzm
    For
    `Visual Basic.NET <http://msdn2.microsoft.com/en-us/vbasic/default.aspx>`_
    source code.
    zVB.netzvb.net�vbnetz*.vbz*.basztext/x-vbnetz
text/x-vbaz[_r$r%r&r'r(r)r*r+r,r-r.r/z	^\s*<.*?>r�r@z(rem\b.*?)(\n)z
('.*?)(\n)z�#If\s.*?\sThen|#ElseIf\s.*?\sThen|#Else|#End\s+If|#Const|#ExternalSource.*?\n|#End\s+ExternalSource|#Region.*?\n|#End\s+Region|#ExternalChecksumz[(){}!#,.:]z?(Option)(\s+)(Strict|Explicit|Compare)(\s+)(On|Off|Binary|Text))l�
AddHandler�Alias�ByRef�ByVal�Call�Case�Catch�CBool�CByte�CChar�CDate�CDec�CDbl�CInt�CLng�CObj�Continue�CSByte�CShort�CSng�CStr�CType�CUInt�CULng�CUShort�Declare�Default�Delegate�
DirectCast�Do�Each�Else�ElseIf�EndIf�Erase�Error�Event�Exit�False�Finally�For�Friend�Get�Global�GoSub�GoTo�Handles�If�
Implements�Inherits�	Interface�Let�Lib�Loop�Me�MustInherit�MustOverride�MyBase�MyClass�	Narrowing�New�Next�Not�Nothing�NotInheritable�NotOverridable�Of�Onr
�Option�Optional�	Overloads�Overridable�	Overrides�
ParamArray�Partial�Private�	Protected�Public�
RaiseEvent�ReadOnly�ReDim�
RemoveHandler�Resume�Return�Select�Set�Shadows�Sharedrw�Static�Step�Stop�SyncLock�Then�Throw�To�True�Try�TryCast�Wend�Using�When�While�Widening�With�
WithEvents�	WriteOnlyz(?<!\.)z\b)�prefix�suffixz(?<!\.)End\b�endz(?<!\.)(Dim|Const)\b�dimz#(?<!\.)(Function|Sub|Property)(\s+)r�z"(?<!\.)(Class|Structure|Enum)(\s+)r�z&(?<!\.)(Module|Namespace|Imports)(\s+)rIz|(?<!\.)(Boolean|Byte|Char|Date|Decimal|Double|Integer|Long|Object|SByte|Short|Single|String|Variant|UInteger|ULong|UShort)\bzU(?<!\.)(AddressOf|And|AndAlso|As|GetType|In|Is|IsNot|Like|Mod|Or|OrElse|TypeOf|Xor)\bzE&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>\[\]]r��stringz(_)(\n)z	[%&@!#$]?z#.*?#z"(\d+\.\d*|\d*\.\d+)(F[+-]?[0-9]+)?z\d+([SILDFR]|US|UI|UL)?z&H[0-9a-f]+([SILDFR]|US|UI|UL)?z&O[0-7]+([SILDFR]|US|UI|UL)?�""z"C?rJ�[^"]+�\.z?(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b)rNr
r
r�r�rIr

c

Cst�
d
|tj�r
dSdS)Nz^\s*(#If|Module|Namespace)g�?)rh�searchri�
r�r^r^r_r��
s

�zVbNetLexer.analyse_textN)*r`rarbrcrdrerfrgrmrn�uni_namerhri�
IGNORECASErlrrvrrrrzr
r�Declarationr	r{r
r�rrr�Daterr�r��Variablerrur|r}rTr�r^r^r^r_r�
s�




�

���




�



����



�

�

��
��







�<

�

�
�
�

�

���Xrc@sfeZ
dZd
ZdZgZgZejZ	dde
eje
ej�fde
ee�
e
ee�
�fdee�
fdee�
fgi
ZdS)	�GenericAspxLexerz"
    Lexer for ASP.NET pages.
    zaspx-genrNz(<%[@=#]?)(.*?)(%>)z(<script.*?>)(.*?)(</script>)z
(.+?)(?=<)z.+N)r`rarbrcrdrfrgrhrjrlrr�TagrrrrTr^r^r^r_r
�
s 







�


��r
c�>eZ
dZd
ZdZdg
Zgd�
ZgZ�f
dd�Zdd�Z	�Z
S)rz9
    Lexer for highlighting C# within ASP.NET pages.
    zaspx-cs�z*.aspxz*.asaxz*.ascxz*.ashxz*.asmxz*.axdc
�t�j
ttfi|
�
�

dS�
N)�superrYrr
�r[r\�
rVr^r_rY�
zCSharpAspxLexer.__init__c

C�4t�
d
|tj�du
rdSt�
d|tj�du
rdSdS)NzPage\s*Language="C#"皙�����?zscript[^>]+language=["\']C#�333333�?�rhr
�
Ir
r^r^r_r��




�zCSharpAspxLexer.analyse_text�r`rarbrcrdrerfrgrYr��
__classcell__r^r^r
r_r�



rcr
)rzG
    Lexer for highlighting Visual Basic.net within ASP.NET pages.
    zaspx-vbr
c
r
r
)r
rYrr
r
r
r^r_rY%r 
zVbNetAspxLexer.__init__c

Cr!
)NzPage\s*Language="Vb"r"
zscript[^>]+language=["\']vbr#
r$
r
r^r^r_r�(r&
zVbNetAspxLexer.analyse_textr'
r^r^r
r_rr)
rc@s�eZ
dZd
ZdZddgZddgZdg
Zgd�
Zegd	�
7Zgd
�
Z	dZ
gd�
Zd
ZdZ
gd�
Zdejfdejfdejfdejfggdef�
dejjf�
dejdf�
def�
deeje�f�
deeje�f�
dedf�
dedf�
ded f�
d!ed"f�
d#eeeej�f�
d$eeeej�f�
d%eeeej�f�
d&eeeeeej�f�
d'd(�e�
ef�
d)ef�
d*d(�e	�
e f�
d+e
ee
fe f�
d'd(�e�
e j!f�
d'd(�e�
ej"f�
d,eej#eej#ej#e�f�
d-ef�
d.e$j%f�
d/e$j&f�
d0e$j'f�
d1e$j(f�
d2e$j)f�
d3ej*f�
d4ej*f�
d5ef�
d6ej+d"f�
d7ejf�
defd8efd9ejfd:ed;fd<ed;fe,d;�
gd=efd>ed?fd@ed;fdedfded fd!ed"fdAefgdBefe-dC�
dDefdEefdFed;fgdGefdEefdHefdFed;fgdGefdEefdIed;fd!efgdJ�Z.dKdL�Z/dMS)Nrz`
    For the `F# language <https://fsharp.org/>`_ (version 3.0).

    .. versionadded:: 1.5
    zF#�fsharpzf#z*.fsz*.fsiz
text/x-fsharp)B�abstract�as�assert�base�beginrGr�delegatezdo!�do�done�downcast�downto�elif�elser

�	exception�extern�false�finally�for�function�fun�global�if�inherit�inline�	interface�internal�in�lazyzlet!�let�match�member�module�mutablerI�new�null�of�open�override�private�public�reczreturn!�return�select�static�struct�then�to�true�try�type�upcastzuse!�use�val�void�when�while�withzyield!�yield)�atomic�break�checked�	component�const�
constraint�constructor�continue�eager�event�external�fixed�functorr�method�mixin�object�parallel�process�	protected�pure�sealed�tailcall�trait�virtual�volatile)+z!=�
#z&&�
&r�r�z\*z\+�
,z-\.z->�
-z\.\.r
z::z:=z:>�
:z;;�
;z<-z<\]�
<z>\]�
>z\?\?z\?z\[<z\[\|z\[z\]�
_�
`z\{z\|\]z\|z\}�
~z<@@z<@�
=z@>z@@>z[!$%&*+\./:<=>?@^|~-])�and�or�notz[!?~]z[=<>@^|&+\*/$%-])�sbyte�byte�char�	nativeint�
unativeint�float32�single�float�double�int8�uint8�int16�uint16�int32�uint32�int64�uint64�decimal�unit�boolr
rS�exn�obj�enumz\\[\\"\'ntbrafv]z
\\[0-9]{3}z\\u[0-9a-fA-F]{4}z\\U[0-9a-fA-F]{8}r�z	\(\)|\[\]z \b(?<!\.)([A-Z][\w\']*)(?=\s*\.)�dottedz\b([A-Z][\w\']*)z(///.*?)(\n)z(//.*?)(\n)z
\(\*(?!\))r�z@"�lstringz"""�tqsr�r
z\b(open|module)(\s+)([\w.]+)z\b(let!?)(\s+)(\w+)z\b(type)(\s+)(\w+)z&\b(member|override)(\s+)(\w+)(\.)(\w+)z\b(%s)\b�
|z``([^`\n\r\t]|`[^`\n\r\t])+``z(%s)z
(%s|%s)?%sz;(#)([ \t]*)(if|endif|else|line|nowarn|light|\d+)\b(.*?)(\n)z
[^\W\d][\w']*z\d[\d_]*[uU]?[yslLnQRZINGmM]?z-0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?z0[oO][0-7][0-7_]*[uU]?[yslLn]?z0[bB][01][01_]*[uU]?[yslLn]?z/-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?z9'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?z'.'�
'z@?"z[~?][a-z][\w\']*:r
z[A-Z][\w\']*(?=\s*\.)z[A-Z][\w\']*rJz
[a-z_][\w\']*z	[^(*)@"]+z\(\*r�z\*\)z[(*)@]z[^\\"]+�escape-sequencez\\\nr@z"B?r
r

z"""B?)r�
rNr�
r�r
r�
r�
c
Cs(d
}
d|vr
|
d7}
d|vr|
d7}
|
S)zSF# doesn't have that many unique features -- |> and <| are weak
        indicators.r
z|>g�������?z<|r^r�r^r^r_r��s



zFSharpLexer.analyse_textN)0r`rarbrcrdrerfrg�keywords�keyopts�	operators�word_operators�prefix_syms�
infix_syms�
primitivesr�Escaperrr��Pseudor}r�Docrrwrr
r|r
ru�joinr
r�r{rzrr�r�r��Binr�ryr�rrrTr�r^r^r^r_r0s











�
�
�
������
���
��
��
��
��������

��� �"�#�$�%�&
��)
��+�,�
.�0�3



�





�



�


�


��ar)'rcrh�pygments.lexerrrrrrrrr	�pygments.tokenr
rrr
rrrrrrr�
pygments.utilr�pygmentsrrm�pygments.lexers.htmlr�__all__rrrrr
rrrr^r^r^r_�<module>
s"	(4
t2Cn