EiRFSrSSKrSSKrSSKrSSKJrJr SSKJr SSK J r J r J r J r Jr SSKJrJrJrJrJrJr SSKJr /SQr\R2"S 5r/S Qr\"S 5r"S S \5r"SS\S9r "SS\ 5r!"SS\"5r#"SS5r$\$"5r%"SS\&5r'"SS5r(Sr)"SS5r*\*"5r+Sr,"SS 5r-"S!S"\5r."S#S$\5r/"S%S&\ \/S9r0"S'S(5r1"S)S*\05r2S+r3"S,S-\/5r4"S.S/\0\4S9r5g)0z pygments.lexer ~~~~~~~~~~~~~~ Base lexer classes. :copyright: Copyright 2006-present by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. N) apply_filtersFilter)get_filter_by_name)ErrorTextOther Whitespace _TokenType) get_bool_opt get_int_opt get_list_optmake_analysatorFuture guess_decode) regex_opt) Lexer RegexLexerExtendedRegexLexerDelegatingLexer LexerContextincludeinheritbygroupsusingthisdefaultwordsline_rez.*? ))sutf-8)szutf-32)szutf-32be)szutf-16)szutf-16becg)N)xs K/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pygments/lexer.pyr%"s#c\rSrSrSrSrSrg) LexerMeta%zv This metaclass automagically converts ``analyse_text`` methods into static methods which always return float values. c\SU;a[US5US'[RXX#5$)N analyse_text)rtype__new__)mcsnamebasesds r$r-LexerMeta.__new__+s/ Q  /.0A BAn ||Cu00r&r"N)__name__ __module__ __qualname____firstlineno____doc__r-__static_attributes__r"r&r$r(r(%s  1r&r(cj\rSrSrSrSr/r/r/r/r Sr Sr Sr Sr SrSrSrSrS rS S jrS rS rg)r1an Lexer for a specific language. See also :doc:`lexerdevelopment`, a high-level guide to writing lexers. Lexer classes have attributes used for choosing the most appropriate lexer based on various criteria. .. autoattribute:: name :no-value: .. autoattribute:: aliases :no-value: .. autoattribute:: filenames :no-value: .. autoattribute:: alias_filenames .. autoattribute:: mimetypes :no-value: .. autoattribute:: priority Lexers included in Pygments should have two additional attributes: .. autoattribute:: url :no-value: .. autoattribute:: version_added :no-value: Lexers included in Pygments may have additional attributes: .. autoattribute:: _example :no-value: You can pass options to the constructor. The basic options recognized by all lexers and processed by the base `Lexer` class are: ``stripnl`` Strip leading and trailing newlines from the input (default: True). ``stripall`` Strip all leading and trailing whitespace from the input (default: False). ``ensurenl`` Make sure that the input ends with a newline (default: True). This is required for some lexers that consume input linewise. .. versionadded:: 1.3 ``tabsize`` If given and greater than 0, expand tabs in the input (default: 0). ``encoding`` If given, must be an encoding name. This encoding will be used to convert the input string to Unicode, if it is not already a Unicode string (default: ``'guess'``, which uses a simple UTF-8 / Locale / Latin1 detection. Can also be ``'chardet'`` to use the chardet library, if it is installed. ``inencoding`` Overrides the ``encoding`` if given. Nrc xXl[USS5Ul[USS5Ul[USS5Ul[ USS5UlURSS 5UlURS 5=(d URUl/Ul [US S 5HnURU5 M g )a) This constructor takes arbitrary options as keyword arguments. Every subclass must first process its own options and then call the `Lexer` constructor, since it processes the basic options like `stripnl`. An example looks like this: .. sourcecode:: python def __init__(self, **options): self.compress = options.get('compress', '') Lexer.__init__(self, **options) As these options must all be specifiable as strings (due to the command line usage), there are various utility functions available to help with that, see `Utilities`_. stripnlTstripallFensurenltabsizerencodingguess inencodingfiltersr"N) optionsr r<r=r>r r?getr@rCr add_filter)selfrDfilter_s r$__init__Lexer.__init__s& #GY= $Wj%@ $Wj$? "7Iq9  J8  L1BT]]  #GY;G OOG $)rD __class__r3rGs r$__repr__Lexer.__repr__sI <<&t~~'>'>&?vdllEUUVW W&t~~'>'>&?qA Ar&c |[U[5(d [U40UD6nURR U5 g)z( Add a new stream filter to this lexer. N) isinstancerrrCappend)rGrHrDs r$rFLexer.add_filters2'6**(URUSS5nURURS5=(d S S5nUnOdURUR5nURS 5(aU[S 5SnO$URS 5(aU[S 5SnURS S 5nURS S 5nUR(aUR5nO"UR(aURS 5nUR S:aUR#UR 5nUR$(aUR'S 5(dUS - nU$![ an[ S5UeSnAff=f)zVApply preprocessing such as decoding the input, removing BOM and normalizing newlines.rAchardetrNzkTo enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/replaceir@ruz   )rRstrr@rrY ImportError _encoding_map startswithlendecodedetectrErZr=stripr<r? expandtabsr>endswith) rGrV_rYedecodedbomr@encs r$_preprocess_lexer_inputLexer._preprocess_lexer_inputs$$$}}'&t,a)+T" %2MCs++"&s3xy/"8"89"M&3 ?!..et5C"kk#''**=*H*35G{{4==1??8,,H /Dx((CMN+||FD)||D$' ==::# TRT5H upnX4v M g7fN)get_tokens_unprocessed)rgtvrGrVs r$streamer"Lexer.get_tokens..streamer s&66t<ad =s"%)rlrrC)rGrV unfilteredrtstreams`` r$ get_tokensLexer.get_tokenss=++D1 "64<<>F r&c[e)a# This method should process the text and return an iterable of ``(index, tokentype, value)`` tuples where ``index`` is the starting position of the token within the input text. It must be overridden by subclasses. It is recommended to implement it as a generator to maximize effectiveness. )NotImplementedError)rGrVs r$rqLexer.get_tokens_unprocesseds "!r&)r@r>rCrDr=r<r?)F)r3r4r5r6r7r/aliases filenamesalias_filenames mimetypespriorityurl version_added_examplerIrOrFr+rlrxrqr8r"r&r$rr1sl8v DG IOIH CMH%<B % "-^0 "r&r) metaclassc*\rSrSrSr\4SjrSrSrg)ri!a This lexer takes two lexer as arguments. A root lexer and a language lexer. First everything is scanned using the language lexer, afterwards all ``Other`` tokens are lexed using the root lexer. The lexers from the ``template`` lexer package use this base lexer. c rU"S0UD6UlU"S0UD6UlX0l[R"U40UD6 gNr") root_lexerlanguage_lexerneedlerrI)rG _root_lexer_language_lexer_needlerDs r$rIDelegatingLexer.__init__+s7%00-88  t'w'r&cSn/n/nURRU5HRupVnX`RLa+U(aUR[ U5U45 /nX'- nM?URXVU45 MT U(aUR[ U5U45 [ UUR RU55$)N)rrqrrSra do_insertionsr)rGrVbuffered insertions lng_bufferirrrss r$rq&DelegatingLexer.get_tokens_unprocessed1s  **AA$GGA!KK%%s8}j&AB!#J !!1),H    s8}j9 :Z!__CCHMO Or&)rrrN) r3r4r5r6r7rrIrqr8r"r&r$rr!s>C( Or&rc\rSrSrSrSrg)riHzA Indicates that a state should include rules from another state. r"Nr3r4r5r6r7r8r"r&r$rrHs  r&rc\rSrSrSrSrSrg)_inheritiOz; Indicates the a state should inherit from its superclass. cg)Nrr"rNs r$rO_inherit.__repr__Ssr&r"N)r3r4r5r6r7rOr8r"r&r$rrOs r&rc$\rSrSrSrSrSrSrg)combinediYz2 Indicates a state combined from multiple states. c,[RX5$rp)tupler-)clsargss r$r-combined.__new__^s}}S''r&cgrpr")rGrs r$rIcombined.__init__as r&r"N)r3r4r5r6r7r-rIr8r"r&r$rrYs( r&rcH\rSrSrSrSrS SjrS SjrS SjrSr S r S r g) _PseudoMatchifz2 A pseudo match object constructed from a string. cX lXlgrp)_text_start)rGstartrVs r$rI_PseudoMatch.__init__ks   r&NcUR$rp)rrGargs r$r_PseudoMatch.startos {{r&cFUR[UR5-$rp)rrarrs r$end_PseudoMatch.endrs{{S_,,r&c>U(a [S5eUR$)Nz No such group) IndexErrorrrs r$group_PseudoMatch.groupus _- -zzr&cUR4$rp)rrNs r$groups_PseudoMatch.groupszs }r&c0$rpr"rNs r$ groupdict_PseudoMatch.groupdict}s r&)rrrp) r3r4r5r6r7rIrrrrrr8r"r&r$rrfs%- r&rc^SU4SjjnU$)zD Callback that yields multiple actions for each group in the match. c 3># [T5Hup4UcM [U5[La7URUS-5nU(aUR US-5XE4v MQMSURUS-5nUcMlU(aUR US-5UlU"U[ UR US-5U5U5HnU(dM Uv M M U(aUR5Ulgg7f)N) enumerater,r rrposrr)lexermatchctxractiondataitemrs r$callbackbygroups..callbacks"4IA~f+{{1q5)++a!e,f::{{1q5)#"'++a!e"4 &u'3EKKA4F'Ms!T4"&J!T) iikCG sA4C7;AC7 *C7rpr")rrs` r$rrs"& Or&c\rSrSrSrSrg)_ThisizL Special singleton used for indicating the caller class. Used by ``using``. r"Nrr"r&r$rrsr&rc ^^^0mST;a9TRS5n[U[[45(aUTS'OSU4TS'T[La SUU4SjjnU$SUUU4SjjnU$)a Callback that processes the match with a different lexer. The keyword arguments are forwarded to the lexer, except `state` which is handled separately. `state` specifies the state that the new lexer will start in, and can be an enumerable such as ('root', 'inline', 'string') or a simple string which is assumed to be on top of the root state. Note: For that to work, `_other` must not be an `ExtendedRegexLexer`. statestackrootc3R># T (a9[UR5nURT 5 UR"S0UD6nOUnUR 5nUR "UR 540T D6HupgnXe-Xx4v M U(aUR5Ulgg7fr) dictrDupdaterMrrqrrr) rrrr1lxsrrrrs gt_kwargskwargss r$rusing..callbacks' __)q) A44U[[]PiPaeQk!Q))+sB$B'c3*># [UR5nURT 5 T "S0UD6nUR5nUR"UR 540T D6HupgnXe-Xx4v M U(aUR 5Ulgg7fr)rrDrrrqrrr) rrrr1rrrrrrs_otherrrs r$rrs|U]]#A HHV !B A44U[[]PiPaeQk!Q))+sBBrp)poprRlistrr)rrrrrs`` @r$rrsrI& JJw  a$ ' '!"Ig "(!Ig  ~ & &6 O & & Or&c\rSrSrSrSrSrg)riz Indicates a state or state action (e.g. #pop) to apply. For example default('#pop') is equivalent to ('', Token, '#pop') Note that state tuples may be used as well. .. versionadded:: 2.0 cXlgrpr)rGrs r$rIdefault.__init__s r&rN)r3r4r5r6r7rIr8r"r&r$rrs r&rc(\rSrSrSrSSjrSrSrg)riz Indicates a list of literal words that is transformed into an optimized regex that matches any of the words. .. versionadded:: 2.0 c(XlX lX0lgrp)rprefixsuffix)rGrrrs r$rIwords.__init__s   r&cT[URURURS9$)Nrr)rrrrrNs r$rE words.getsDKK LLr&)rrrN)rr)r3r4r5r6r7rIrEr8r"r&r$rrs  Mr&rcF\rSrSrSrSrSrSrSrS Sjr S r S r S r g) RegexLexerMetaizk Metaclass for RegexLexer, creates the self._tokens attribute from self.tokens on the first instantiation. c[U[5(aUR5n[R"X5R $)zBPreprocess the regular expression component of a token definition.)rRrrErecompiler)rregexrflagsrs r$_process_regexRegexLexerMeta._process_regexs/ eV $ $IIKEzz%(...r&c`[U5[Ld[U5(d SU<35eU$)z5Preprocess the token component of a token definition.z0token type must be simple type or callable, not )r,r callable)rtokens r$_process_tokenRegexLexerMeta._process_tokens4E{j(HUOO I>ui H I; r&c[U[5(a:US:XagX;aU4$US:XaU$USSS:Xa[USS5*$SU<35e[U[5(agSUR-nU=RS - sl/nUH4nXa:wd S U<35eUR UR UX655 M6 XSU'U4$[U[5(a"UHnXb;aM US ;aMSU-5e U$S U<35e) z=Preprocess the state transition action of a token definition.#pop#pushNz#pop:zunknown new state z_tmp_%drzcircular state ref )rrzunknown new state def )rRr]intr_tmpnameextend_process_stater)r new_state unprocessed processed tmp_stateitokensistates r$_process_new_state!RegexLexerMeta._process_new_statesD i % %F")!|#g%  2A')IabM***@ 29-@@u  8 , ,!CLL0I LLA LG#*L.A&,LL*s11+2; EF$$+i <   5 ) )#-"332(6124$  @29-@ @5r&c [U[5(d SU<35eUSS:wd SU<35eX2;aX#$/=oBU'URnXGHRn[U[5(a<Xc:wd SU<35eUR UR X[U555 MU[U[ 5(aMl[U[5(aPURURX5nUR[R"S5RSU45 M[U5[Ld SU<35eUR!USXS5nUR'US 5n [)U5S:XaSnOURUSX5nURXU45 GMU U$!["a#n [%S US<S U<S U<S U 35U eSn A ff=f)z%Preprocess a single state definition.zwrong state name r#zinvalid state name zcircular state reference rNzwrong rule def zuncompilable regex z in state z of z: r)rRr]flagsrrrrrrrrSrrrr,rr Exception ValueErrorrra) rrrrtokensrtdefrrexerrrs r$rRegexLexerMeta._process_state)s%%%D):5)'DD%Qx3?"5eY ??  # #$&&5!&D$((}K(A%&KK} c0014T<=$))$((224::{V  rzz"~33T9EF:& B/$(B B& r((a&@&&tAw/E4yA~ 22473>K  MM3y1 2A'B  r #6tAwkE9TXY\X__abeaf!ghnqq rsF-- G7GGNc0=o0RU'U=(d URUn[U5HnURX#U5 M U$)z-Preprocess a dictionary of token definitions.) _all_tokensrrr)rr/ tokendefsrrs r$process_tokendefRegexLexerMeta.process_tokendefTsJ,.. OOD)1D!1 )_E   yU ;%r&c0n0nURHnURRS05nUR5HrupVURU5nUc XaU'UR [ 5nXU'M9URUS5nUcMPXgXS-&UR [ 5n X-X%'Mt M U$![ a Mf=f![ a Mf=f)a Merge tokens from superclasses in MRO order, returning a single tokendef dictionary. Any state that is not defined by a subclass will be inherited automatically. States that *are* defined by subclasses will, by default, override that state in the superclass. If a subclass wishes to inherit definitions from a superclass, it can use the special value "inherit", which will cause the superclass' state definition to be included at that point in the state. rNr)__mro____dict__rEitemsindexrrr) rr inheritablectoksrrcuritems inherit_ndx new_inh_ndxs r$ get_tokendefsRegexLexerMeta.get_tokendefs\s A::>>(B/D $ !::e,# %*5M!&+kk'&: *5&)ooeT: &7<]3C#(++g"6K*5)BK&9!-B )&! !"s$B<C < C  C  CCcSUR;aV0UlSUl[US5(aUR(aO%UR SUR 55Ul[R"U/UQ70UD6$)z:Instantiate cls after preprocessing its token definitions._tokensrtoken_variantsr) rrrhasattrr(rr$r'r,__call__)rrkwdss r$r*RegexLexerMeta.__call__sk CLL ( COCLs,--#2D2D!222s7H7H7JK }}S040400r&r"rp) r3r4r5r6r7rrrrrr$r*r8r"r&r$rrs. /  !AF)V/b 1r&rc>\rSrSrSr\R r0rSSjr Sr g)riz Base for simple stateful regular expression-based lexers. Simplifies the lexing process so that you need only provide a list of states and regular expressions. c#n# SnURn[U5nXESnUGH>upxn U"X5n U (dMUb7[U5[LaX8U R 54v OU"X 5ShvN U R 5nU b[ U [5(a`U HYn U S:Xa#[U5S:aUR5 M*M,U S:XaURUS5 MHURU 5 M[ O^[ U [5(a#[U 5[U5:aUSS2 O+XYS2 O&U S:XaURUS5 O SU <35eXESn O8 XS:XaS /nUS nU[S4v US- nGMjU[X4v US- nGM~GN/![a gf=f7f) zf Split ``text`` into (tokentype, text) pairs. ``stack`` is the initial stack (default: ``['root']``) rrrNrrwrong state def: r[r)r'rr,r rrrRrrarrSrabsr rr) rGrVrrr statestack statetokensrexmatchrrmrs r$rq!RegexLexer.get_tokens_unprocesseds LL %[ 2/ /:+)T'1)<:5"%qwwy"88'-d66%%'C ,%i77)2#(F?'*:':(2(8(;%*g%5$.$5$5jn$E$.$5$5e$<*3( 377 #9~Z@$.qrN$.z$:&'1&--jn=K,=i]*KK5&/2&? C0;J yD(&,X &/&7 !:t33q udi//1HC_7P"sG8F55F53F"4C5F5* F% F5 F%F5% F2/F51F22F5r"N)r) r3r4r5r6r7r MULTILINEr rrqr8r"r&r$rrs LLE0F;r&rc(\rSrSrSrSSjrSrSrg)riz1 A helper object that holds lexer position data. NcpXlX lU=(d [U5UlU=(d S/Ulg)Nr)rVrrarr)rGrVrrrs r$rILexerContext.__init__s* ##d)&vh r&c\SUR<SUR<SUR<S3$)Nz LexerContext(z, ))rVrrrNs r$rOLexerContext.__repr__s)tyym2dhh\DJJ>KKr&)rrrrVNN)r3r4r5r6r7rIrOr8r"r&r$rrs' Lr&rc"\rSrSrSrSSjrSrg)ri z= A RegexLexer that uses a context object to store its state. Nc## URnU(d[US5nUSnOUnX4RSnURnUGHupgnU"XRUR 5n U (dM-Ubo[ U5[La4URXyR54v U R 5UlO)U"X U5ShvN U(dX4RSnUGbI[U[5(aUHn U S:Xa7[UR5S:aURR5 M>M@U S:Xa*URRURS5 MpURRU 5 M O[U[5(aB[U5[UR5:aURSS2 OJURUS2 O:US:Xa)URRURS5 O SU<35eX4RSn O URUR :agXRS :Xa:S/UlUSnUR[ S 4v U=RS- slGM[UR["XR4v U=RS- slGMGN![$a gf=f7f) zg Split ``text`` into (tokentype, text) pairs. If ``context`` is given, use this lexer context instead. rrrrNrrr/r[)r'rrrVrrr,r rrRrrarrSrr0rrr) rGrVcontextrrr2r3rrr4rs r$rq)ExtendedRegexLexer.get_tokens_unprocessedsg LL tQ'C#F+KC#IIbM2K88D/:+)T77CGG41)<:5"%''6779"<<&'eegCG'-ds';;;#,.7 " .F  ,%i77)2#(F?'*399~'9(+ (:%*g%5$'II$4$4SYYr]$C$'II$4$4U$;*3( 377"9~SYY?$'IIabM$'IIij$9&'1II,,SYYr];K,=i]*KK5&/ " &> G0;J ww#'')GG},%+H &/&7 !ggtT111  ''5$ww-77GGqLGc)r3r4r5r6r7rqr8r"r&r$rr s @r&rc## [U5n[U5up#SnSnUHupgnUcUnSn U(aU[U5-U:anXX&- n U (aXGU 4v U[U 5- nUHupn XLU 4v U[U 5- nM X&- n [U5up#U(aU[U5-U:aMnU [U5:dMXGXS4v U[U5U - - nM U(aCU=(d SnUHupnXGU4v U[U5- nM [U5up#U(aMBgg![a UShvN gf=f![a SnMf=f![a Sngf=f7f)aC Helper for lexers which must combine the results of several sublexers. ``insertions`` is a list of ``(index, itokens)`` pairs. Each ``itokens`` iterable should be inserted at position ``index`` into the token stream given by the ``tokens`` argument. The result is a combined token stream. TODO: clean up the code here. NTrF)iternext StopIterationra)rrrrrealposinsleftrrrrsolditmpvalit_indexit_tokenit_valueps r$rrSsj!Jj) GGa ?G!c!f*-EI&F&((3v;&07,H113x=(189D !%j!1!c!f*- #a&=ah& & s1v} $G+0 ,QGA!a-  s1v G !*-NE 'E 4!    G  s E/ D/A1E/ E E/6 E/AE/ E$E/-E//E>E?EE/EE/ EE/EE/ E,)E/+E,,E/c\rSrSrSrSrSrg)ProfilingRegexLexerMetaiz>Metaclass for ProfilingRegexLexer, collects regex timing info.c^^^^[U[5(a*[URURURS9mOUm[ R "TU5m[R4UUUU4SjjnU$)Nrc>TRSRT T 4SS/5n[R"5nTRXU5n[R"5nUS==S- ss'US==Xd- - ss'U$)Nrrr!r) _prof_data setdefaulttimer) rVrendposinfot0rest1rcompiledrrs r$ match_func:ProfilingRegexLexerMeta._process_regex..match_funcsn>>"%00%3xHDB..F3CB GqLG Grw GJr&) rRrrrrrrsysmaxsize)rrrrr\r[rs` ` @@r$r&ProfilingRegexLexerMeta._process_regexs] eU # #EKK #(<<1CC::c6*),  r&r"N)r3r4r5r6r7rr8r"r&r$rPrPs Hr&rPc*\rSrSrSr/rSrSSjrSrg)ProfilingRegexLexerizFDrop-in replacement for RegexLexer that does profiling of its regexes.c#H^# TRRR05 [R TX5ShvN TRRR 5n[ SUR55U4SjSS9n[SU55n[5 [STRR[U5U4-5 [S5 [SS -5 [S 5 UHn[S U-5 M [S5 gN7f) Nc3# UHGuupup4U[U5RS5RSS5SSUSU-SU-U- 4v MI g7f)zu'z\\\NAi)reprrdrZ).0rrnrrs r$ =ProfilingRegexLexer.get_tokens_unprocessed..s\@/>+FQFQ47==/77EcrJ4!8TAX\3/>sAAc">UTR$rp)_prof_sort_index)r#rGs r$r%.sAd&;&;$ ? i 47IIJ iA /!3 4 i# Hs?D"D CD"r"Nr6) r3r4r5r6r7rSrorqr8r"r&r$rbrbsPJr&rb)6r7rr^rUpygments.filterrrpygments.filtersrpygments.tokenrrrr r pygments.utilr r r rrrpygments.regexoptr__all__rrr_ staticmethod_default_analyser,r(rrr]rrrrrrrrrrrrrrrrrrPrbr"r&r$rsJ 1/EE**' * **W ,  . 1 1m"im"`OeON c  *  u  64  w1h   MF M d1Yd1N^.^B L LEEP=@n,*0Gr&