ó
    ÖÁ“i”s  ã                   ó(  • S SK JrJr  S SKrS SKrS SKrS SKrS SKrS SKrS SK	r	S SK
JrJrJrJrJrJrJrJrJrJrJrJrJrJrJr  \(       a  SSKJr  SSKJr  SSKJr  S SK
J r   SS	K!J"r"  SS
K#J$r$J%r%J&r&  SSK'J(r(J)r)J*r*J+r+J,r,J-r-  SSK.J.r.J/r/J0r0J1r1J2r2J3r3  SSKJ4r4  SSK5J6r6J7r7J8r8J9r9  SSK:J;r;J<r<J=r=J>r>J?r?  SSK@JArA  SSK!JBrBJCrCJDrDJErE  SSKFJGrG   S SKHrHSrI " S S\5      rK " S S\(5      rL1 SkrMSrNSrO\" SSS9rP " S S\(5      rQg! \J a    SrI N;f = f) é    )ÚABCÚabstractmethodN)ÚTypeVarÚTypeÚListÚDictÚIteratorÚCallableÚUnionÚOptionalÚSequenceÚTupleÚIterableÚIOÚAnyÚTYPE_CHECKINGÚ
Collectioné   )ÚInteractiveParser)Ú	ParseTree)ÚTransformer)ÚLiteral)ÚParsingFrontend)ÚConfigurationErrorÚassert_configÚUnexpectedInput)Ú	SerializeÚSerializeMemoizerÚFSÚloggerÚTextOrSliceÚ	LarkInput)Úload_grammarÚFromPackageLoaderÚGrammarÚverify_used_filesÚPackageResourceÚsha256_digest)ÚTree)Ú	LexerConfÚ
ParserConfÚ_ParserArgTypeÚ_LexerArgType)ÚLexerÚ
BasicLexerÚTerminalDefÚLexerThreadÚToken)ÚParseTreeBuilder)Ú_validate_frontend_argsÚ_get_lexer_callbacksÚ_deserialize_parsing_frontendÚ_construct_parsing_frontend)ÚRuleTFc                   óR   • \ rS rSr% \S\\   S\\   4S j5       rSr\	\
   \S'   Srg)ÚPostLexé(   ÚstreamÚreturnc                 ó   • U$ ©N© )Úselfr<   s     ÚF/home/mande/repo/quber/.venv/lib/python3.13/site-packages/lark/lark.pyÚprocessÚPostLex.process)   s   € àˆó    r@   Úalways_acceptN)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r   r	   r2   rC   rF   r   ÚstrÚ__annotations__Ú__static_attributes__r@   rE   rB   r:   r:   (   s:   ‡ Øð˜h u™oð °(¸5±/ó ó ðð $&€M�8˜C‘=Ö%rE   r:   c            	       ó®  • \ rS rSr% Sr\\   \S'   \\S'   \\S'   S\S'   \	\\4   \S'   \\S	'   \	\\4   \S
'   \\S'   \\S'   \
\S'   \\S'   \\\\/\4      \S'   \\S'   \\S'   S\S'   \\   \S'   S\S'   \\\\/\4   4   \S'   \\S'   \\S'   \\\/\4      \S'   S\S'   \\   \S'   Sr\(       a  \\-  r0 SS_SS_SS_SS _S
S_SS_SS _SS!_SS"_SS _SS_SS"_SS"_SS_SS_S0 _S	S#_S S$SS#/ S 0 S%.Er\\\4   \S&'   S'\\\4   S(S 4S) jrS*\S(\4S+ jrS*\S,\S(S 4S- jrS3S(\\\4   4S. jjr\S/\\\4   S0\\
\	\\4   4   S(S 4S1 j5       rS2rg )4ÚLarkOptionsé/   z$Specifies the options for Lark

    ÚstartÚdebugÚstrictzOptional[Transformer]ÚtransformerÚpropagate_positionsÚmaybe_placeholdersÚcacheÚcache_grammarÚregexÚg_regex_flagsÚkeep_all_tokensÚ
tree_classÚparserÚlexerz0Literal["auto", "resolve", "explicit", "forest"]Ú	ambiguityÚpostlexz-Optional[Literal["auto", "normal", "invert"]]ÚpriorityÚlexer_callbacksÚ	use_bytesÚordered_setsÚedit_terminalszUList[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]Úimport_pathsÚsource_patha?  
    **===  General Options  ===**

    start
            The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start")
    debug
            Display debug information and extra warnings. Use only when debugging (Default: ``False``)
            When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed.
    strict
            Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions.
    transformer
            Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster)
    propagate_positions
            Propagates positional attributes into the 'meta' attribute of all tree branches.
            Sets attributes: (line, column, end_line, end_column, start_pos, end_pos,
                              container_line, container_column, container_end_line, container_end_column)
            Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating.
    maybe_placeholders
            When ``True``, the ``[]`` operator returns ``None`` when not matched.
            When ``False``,  ``[]`` behaves like the ``?`` operator, and returns no value at all.
            (default= ``True``)
    cache
            Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now.

            - When ``False``, does nothing (default)
            - When ``True``, caches to a temporary file in the local directory
            - When given a string, caches to the path pointed by the string
    cache_grammar
            For use with ``cache`` option. When ``True``, the unanalyzed grammar is also included in the cache.
            Useful for classes that require the ``Lark.grammar`` to be present (e.g. Reconstructor).
            (default= ``False``)
    regex
            When True, uses the ``regex`` module instead of the stdlib ``re``.
    g_regex_flags
            Flags that are applied to all terminals (both regex and strings)
    keep_all_tokens
            Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``)
    tree_class
            Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``.

    **=== Algorithm Options ===**

    parser
            Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley").
            (there is also a "cyk" option for legacy)
    lexer
            Decides whether or not to use a lexer stage

            - "auto" (default): Choose for me based on the parser
            - "basic": Use a basic lexer
            - "contextual": Stronger lexer (only works with parser="lalr")
            - "dynamic": Flexible and powerful (only with parser="earley")
            - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible.
    ambiguity
            Decides how to handle ambiguity in the parse. Only relevant if parser="earley"

            - "resolve": The parser will automatically choose the simplest derivation
              (it chooses consistently: greedy for tokens, non-greedy for rules)
            - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest).
            - "forest": The parser will return the root of the shared packed parse forest.

    **=== Misc. / Domain Specific Options ===**

    postlex
            Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers.
    priority
            How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto")
    lexer_callbacks
            Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution.
    use_bytes
            Accept an input of type ``bytes`` instead of ``str``.
    ordered_sets
            Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True)
    edit_terminals
            A callback for editing the terminals before parse.
    import_paths
            A List of either paths or loader functions to specify from where grammars are imported
    source_path
            Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading
    **=== End of Options ===**
    FNÚearleyÚautoTr   )re   rZ   rc   rd   rf   rg   Ú_pluginsÚ	_defaultsÚoptions_dictr=   c                 ól  • [        U5      n0 nU R                  R                  5        HH  u  pEXB;   a8  UR                  U5      n[	        U[
        5      (       a  US;  a  [        U5      nOUnXcU'   MJ     [	        US   [        5      (       a	  US   /US'   X0R                  S'   [        U R                  S5        U R                  S:X  a  U R                  (       a  [        S5      eU R                  (       a  U R                  (       d  [        S5      eU(       a  [        SUR                  5       -  5      eg )	N)rW   rc   rU   rQ   Úoptions)rh   ÚlalrÚcykNrh   z©Cannot specify an embedded transformer when using the Earley algorithm. Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)z2cache_grammar cannot be set when cache is disabledzUnknown options: %s)Údictrk   ÚitemsÚpopÚ
isinstanceÚboolrK   Ú__dict__r   r]   rT   r   rX   rW   Úkeys)rA   rl   Úorn   ÚnameÚdefaultÚvalues          rB   Ú__init__ÚLarkOptions.__init__Â   s  € Ü�ÓˆàˆØ!Ÿ^™^×1Ñ1Ö3‰MˆDØ‹yØŸ™˜d›�Ü˜g¤t×,Ñ,°Ð=jÓ1jÜ  ›K�Eøà�à!�D‹Mñ 4ô �g˜gÑ&¬×,Ñ,Ø '¨Ñ 0Ð1ˆG�GÑà#*�‰�iÑ ô 	�d—k‘kÐ#BÔCà�;‰;˜(Ó" t×'7×'7Ü$ð &Aó Bð Bð ×× d§j§jÜ$Ð%YÓZÐZæÜ$Ð%:¸Q¿V¹V»XÑ%EÓFÐFð rE   ry   c                 ób   •  U R                   S   U   $ ! [         a  n[        U5      eS nAff = f)Nrn   )rv   ÚKeyErrorÚAttributeError)rA   ry   Úes      rB   Ú__getattr__ÚLarkOptions.__getattr__â   s6   € ð	$Ø—=‘= Ñ+¨DÑ1Ð1øÜó 	$Ü  Ó#Ð#ûð	$ús   ‚ ”
.ž)©.r{   c                 óh   • [        XR                  R                  5       S5        X R                  U'   g )Nz,%r isn't a valid option. Expected one of: %s)r   rn   rw   )rA   ry   r{   s      rB   Ú__setattr__ÚLarkOptions.__setattr__è   s&   € Ü�dŸL™L×-Ñ-Ó/Ð1_Ô`Ø"�‰�TÒrE   c                 ó   • U R                   $ r?   ©rn   )rA   Úmemos     rB   Ú	serializeÚLarkOptions.serializeì   s   € Ø�|‰|ÐrE   Údatar‰   c                 ó   • U " U5      $ r?   r@   )ÚclsrŒ   r‰   s      rB   ÚdeserializeÚLarkOptions.deserializeï   s   € á�4‹yÐrE   r@   r?   )rG   rH   rI   rJ   Ú__doc__r   rK   rL   ru   r   Úintr   r
   r   r,   r-   r:   r   r2   r0   ÚOPTIONS_DOCrk   r|   r‚   r…   rŠ   Úclassmethodr8   r�   rM   r@   rE   rB   rO   rO   /   s   ‡ ñð �‰9ÓØƒKØƒLØ(Ó(Ø˜t S˜yÑ)Ó)ØÓØ��s�ÑÓØÓØƒKØÓØÓØ˜ 3¨ +¨sÐ"2Ñ3Ñ4Ó4ØÓØÓØAÓAØ�gÑÓØ=Ó=Ø˜#˜x¨¨°¨Ñ7Ð7Ñ8Ó8ØƒOØÓØ˜X { m°[Ð&@ÑAÑBÓBØiÓiØ˜#‘ÓðP€Köb Ø�;Ñˆð!Ø�ð!à�%ð!ð 	˜5ð!ð 	�dð	!ð
 	�ð!ð 	˜ð!ð 	�4ð!ð 	�(ð!ð 	�ð!ð 	�tð!ð 	�ð!ð 	�Fð!ð 	�Vð!ð 	�ð!ð 	˜uð!ð  	˜2ð!!ð" 	˜dð#!ð$ ØØØØØØò1!€Iˆt�C˜�H‰~ó ð6G T¨#¨s¨(¡^ð G¸ô Gð@$ ð $¨ô $ð# ð #¨Cð #°Dô #ñ¨¨S°#¨X©õ ð ð˜t C¨ H™~ð °T¸#¸uÀ[ÐRVÐEVÑ?WÐ:WÑ5Xð Ð]jó ó órE   rO   >
   rR   rY   r`   rj   rc   r\   rT   rZ   rb   rU   )ri   ÚnormalÚinvertN)ri   ÚresolveÚexplicitÚforestÚ_TÚLark)Úboundc                   ó\  • \ rS rSr% Sr\\S'   \\S'   S\S'   \\S'   \\S'   S	\S
'   \	\
   \S'   / SQrS6S jr\(       a  \S\R                  -   -  rS7S\S\4S jjrS8S jrS9S jrS:S\	\   SS4S jjr\S\\   S\4S j5       rS\\\4   S\\\\
\4   4   S\S\4S jrS\S\S\4S jr\S 5       r \S;S\\   S \S!\!\   S\4S" jj5       r"\S#/4S\\   S$\S%\S&S'S\4
S( jj5       r#S) r$S7S*\%S\S\&\'   4S+ jjr(S,\S\
4S- jr)S<S*\!\*   S.\!\   SS/4S0 jjr+S<S*\*S.\!\   S1S2SS34S4 jjr,S5r-g)=r›   éþ   a]  Main interface for the library.

It's mostly a thin wrapper for the many different parsers, and for the tree constructor.

Parameters:
    grammar: a string or file-object containing the grammar spec (using Lark's ebnf syntax)
    options: a dictionary controlling various aspects of Lark.

Example:
    >>> Lark(r'''start: "foo" ''')
    Lark(...)
rg   Úsource_grammarr%   Úgrammarrn   r^   r   r]   Ú	terminals)r]   Úrulesrn   r=   Nc                 ó¸  ^• [        U5      U l        U R                  R                  (       a  U R                  S/-   U l        U R                  R                  nU(       a  [
        (       a  [        nO[        S5      e[        nU R                  R                  c   UR                  U l        OU R                  R                  U l         UR                  nU" 5       nS nS n[        U[        5      (       GaÝ  Xl        U R                  R                  (       a   UR!                  5       (       d  [#        S5      eU R                  R$                  (       Ga8  U R                  R&                  S:w  a  [#        S5      eSmSR)                  U4S	 jUR+                  5        5       5      nS
SKJn	  X-   U	-   [        [0        R2                  S S 5      -   n
[5        U
5      n[        U R                  R$                  [        5      (       a  U R                  R$                  nOˆU R                  R$                  SLa  [#        S5      e [6        R8                  " 5       n[<        R>                  " 5       SU R                  R                  (       a  SOSX·/[0        R2                  S S Q7-  -   nU R                  n [@        RB                  " US5       n[D        RF                  " SU5        [I        U5      [J        -
   H  nX.	 M     URM                  5       RO                  S5      n[P        RR                  " U5      nX÷RU                  S5      :X  aC  [W        U5      (       a3  [P        RR                  " U5      nU RX                  " U40 UD6   S S S 5        g S S S 5        [_        XR                  U R                  R`                  U R                  Rb                  5      u  U l2        nO[        U[f        5      (       d   eXl2        U R                  Rh                  S:X  aÞ  U R                  R&                  S:X  a  SU R                  l4        O²U R                  R&                  S:X  aQ  U R                  Rj                  b(  [D        Rl                  " S5        SU R                  l4        OYSU R                  l4        OGU R                  R&                  S:X  a  SU R                  l4        O U R                  R&                  5       eU R                  Rh                  n[        U[n        5      (       a  [q        U[r        5      (       d   eO4[u        US5        U R                  Rj                  b  SU;   a  [#        S 5      eU R                  Rv                  S:X  a,  U R                  R&                  S:X  a  S!U R                  l;        O![u        U R                  R&                  S"S#5        U R                  Rx                  S:X  a  S$U R                  l<        U R                  Rx                  [z        ;  a+  [#        S%U R                  Rx                  < S&[z        < 35      eU R                  Rv                  [|        ;  a+  [#        S'U R                  Rv                  < S&[|        < 35      eU R                  R&                  c  S(nOKU R                  Rj                  b*  [I        U R                  Rj                  R~                  5      nO
[I        5       nU Rd                  R�                  U R                  R‚                  U5      u  U lB        U lC        U lD        U R                  RŠ                  (       a.  U R„                   H  nU R                  R‹                  U5        M      U R„                   Vs0 s H  nUR                  U_M     snU lF        U R                  Rx                  S):X  ax  U R†                   HB  nUR                  Rx                  c  M  UR                  Rx                  * UR                  l<        MD     U R„                   H  nURx                  * Ul<        M     OnU R                  Rx                  cW  U R†                   H-  nUR                  Rx                  c  M  S UR                  l<        M/     U R„                   H
  nS*Ul<        M     [�        U R„                  X@Rˆ                  U R                  Rj                  U R                  R�                  U R                  R’                  U R                  R                  U R                  R”                  S+9U lK        U R                  R&                  (       a  U R™                  5       U l        OU(       a  U R›                  5       U l4        U(       aŽ  [D        RF                  " S,U5         [@        RB                  " US-5       nUc   eUR�                  URU                  S5      S-   5        [P        Rž                  " WU5        U R¡                  U[J        5        S S S 5        g g ! [         a    SU l         G	N\f = f! [         a     G	NYf = f! [:         a    Sn GNöf = f! , (       d  f       GNÐ= f! [Z         a     GNà[:         a!    [D        R\                  " SU5        XÀl         GN	f = fs  snf ! , (       d  f       g = f! [¢         a"  n[D        R\                  " S.UU5         S nAg S nAff = f)/Nr    z?`regex` module must be installed if calling `Lark(regex=True)`.z<string>z/Grammar must be ascii only, when use_bytes=Truero   z+cache only works with parser='lalr' for now)rT   r`   rb   re   rj   Ú c              3   óT   >#   • U  H  u  pUT;  d  M  U[        U5      -   v •  M     g 7fr?   )rK   )Ú.0ÚkÚvÚ
unhashables      €rB   Ú	<genexpr>Ú Lark.__init__.<locals>.<genexpr>F  s%   øé € Ð%bº?±4°1ÈaÐWaÑNa£h a¬¨A«¦hº?ùs   ƒ(“(r   )Ú__version__é   Tz"cache argument must be bool or strÚunknownz/.lark_%s_%s_%s_%s_%s.tmprX   rW   ÚrbzLoading grammar from cache: %só   
Úutf8z<Failed to load Lark from cache: %r. We will try to carry on.ri   Ú
contextualrh   z~postlex can't be used with the dynamic lexer, so we use 'basic' instead. Consider using lalr with contextual instead of earleyÚbasicÚdynamicrp   )r³   r²   r´   Údynamic_completezGCan't use postlex with a dynamic lexer. Use basic or contextual insteadr—   )rh   rp   zG%r doesn't support disambiguation. Use one of these parsers instead: %sr•   zinvalid priority option: z. Must be one of zinvalid ambiguity option: Ú*r–   r   )rc   rS   zSaving grammar to cache: %sÚwbz!Failed to save Lark to cache: %r.)RrO   rn   rX   Ú__serialize_fields__rY   Ú
_has_regexÚImportErrorÚrerg   ry   r€   Úreadrt   rK   rŸ   rc   Úisasciir   rW   r]   Újoinrr   r¤   r¬   ÚsysÚversion_infor(   ÚgetpassÚgetuserÚ	ExceptionÚtempfileÚ
gettempdirr   Úopenr    rR   ÚsetÚ_LOAD_ALLOWED_OPTIONSÚreadlineÚrstripÚpickleÚloadÚencoder&   Ú_loadÚFileNotFoundErrorÚ	exceptionr#   rf   r[   r    r%   r^   r`   ÚinfoÚtypeÚ
issubclassr.   r   r_   ra   Ú_VALID_PRIORITY_OPTIONSÚ_VALID_AMBIGUITY_OPTIONSrF   ÚcompilerQ   r¡   r¢   Úignore_tokensre   Ú_terminals_dictr*   rb   rZ   rS   Ú
lexer_confÚ_build_parserÚ_build_lexerÚwriteÚdumpÚsaveÚIOError)rA   r    rn   Ú	use_regexÚ	re_moduler¼   Úcache_fnÚcache_sha256Úoptions_strr¬   ÚsÚusernameÚold_optionsÚfry   Úfile_sha256Úcached_used_filesÚcached_parser_dataÚ
used_filesr^   Úterminals_to_keepÚtÚruleÚtermr�   r©   s                            @rB   r|   ÚLark.__init__  sƒ  ø€ Ü" 7Ó+ˆŒð �<‰<×%×%Ø(,×(AÑ(AÀYÀKÑ(OˆDÔ%ð —L‘L×&Ñ&ˆ	ÞßŠzÜ!‘	ä!Ð"cÓdÐdäˆIð �<‰<×#Ñ#Ñ+ð.Ø#*§<¡<�Õ ð  $Ÿ|™|×7Ñ7ˆDÔð	Ø—<‘<ˆDñ “fˆGàˆØˆÜ�gœs×#Ò#Ø")ÔØ�|‰|×%×%Ø—‘×(Ñ(Ü,Ð-^Ó_Ð_à�|‰|×!×!Ð!Ø—<‘<×&Ñ&¨&Ó0Ü,Ð-ZÓ[Ð[àh�
Ø Ÿg™gÔ%b¸7¿=¹=¼?Ó%bÓb�Ý)ØÑ)¨KÑ7¼#¼c×>NÑ>NÈrÐPQÐ>RÓ:SÑS�Ü,¨QÓ/�ä˜dŸl™l×0Ñ0´#×6Ñ6Ø#Ÿ|™|×1Ñ1‘Hà—|‘|×)Ñ)°Ò5Ü0Ð1UÓVÐVð-Ü#*§?¢?Ó#4˜ô  (×2Ò2Ó4Ð7RØ+/¯<©<×+E×+E™È7ÐT\ðVCÜmp×m}Ñm}ð  Að  @Að  nBñVCñ 8Cñ  C�Hð #Ÿl™l�ð/ÜŸš ¨4Ô0°AÜŸšÐ%EÀxÔPä%(¨£\Ô4IÔ%I˜DØ '¢ñ &Jà&'§j¡j£l×&9Ñ&9¸%Ó&@˜Ü,2¯KªK¸«NÐ)Ø&×*=Ñ*=¸fÓ*EÓEÔJ[Ð\m×JnÑJnÜ17·²¸Q³Ð.Ø ŸJšJÐ'9ÑE¸WÒEØ"÷ 1×0Ð0ô. (4°G×=MÑ=MÈtÏ|É|×OhÑOhÐjn×jvÑjv÷  kGñ  kGó  (HÑ$ˆDŒL™*ä˜g¤w×/Ñ/Ð/Ð/Ø"ŒLð �<‰<×Ñ Ó'Ø�|‰|×"Ñ" fÓ,Ø%1�—‘Õ"Ø—‘×$Ñ$¨Ó0Ø—<‘<×'Ñ'Ñ3Ü—K’Kð !Xô Yà)0�D—L‘LÕ&à)2�D—L‘LÕ&Ø—‘×$Ñ$¨Ó-Ø%,�—‘Õ"à1˜dŸl™l×1Ñ1Ó1�uØ—‘×"Ñ"ˆÜ�eœT×"Ñ"Ü˜e¤U×+Ñ+Ð+Ñ+ä˜%Ð!WÔXØ�|‰|×#Ñ#Ñ/°IÀÓ4FÜ(Ð)rÓsÐsà�<‰<×!Ñ! VÓ+Ø�|‰|×"Ñ" hÓ.Ø)2�—‘Ô&øä˜$Ÿ,™,×-Ñ-Ð/@ð  CLô  Mà�<‰<× Ñ  FÓ*Ø$,ˆD�L‰LÔ!à�<‰<× Ñ Ô(?Ó?Ý$ÐY]×YeÑYe×YnÔYnö  qHð  &Ió  Jð  JØ�<‰<×!Ñ!Ô)AÓAÝ$ÐZ^×ZfÑZf×ZpÔZpö  sKð  &Ló  Mð  Mà�<‰<×ÑÑ&Ø #ÑØ�\‰\×!Ñ!Ñ-Ü # D§L¡L×$8Ñ$8×$FÑ$FÓ GÑä #£Ðð :>¿¹×9MÑ9MÈdÏlÉl×N`ÑN`ÐbsÓ9tÑ6ˆŒ˜œ
 DÔ$6à�<‰<×&×&Ø—^”^�Ø—‘×+Ñ+¨AÖ.ñ $ð 48·>²>ÓB²>¨a §¡¨¢	±>ÑBˆÔð �<‰<× Ñ  HÓ,ØŸ
œ
�Ø—<‘<×(Ñ(Ó4Ø-1¯\©\×-BÑ-BÐ,B�D—L‘LÖ)ñ #ð Ÿœ�Ø!%§¡ �–ò 'ð
 �\‰\×"Ñ"Ñ*ØŸ
œ
�Ø—<‘<×(Ñ(Ó4Ø,0�D—L‘LÖ)ñ #ð Ÿœ�Ø !�–ñ 'ô $Ø—‘ 	×+=Ñ+=¸t¿|¹|×?SÑ?SØ—‘×,Ñ,¨d¯l©l×.HÑ.HÐTX×T`ÑT`×TjÑTjÐsw×sÑs÷  tGñ  tGñˆŒð
 �<‰<××Ø×,Ñ,Ó.ˆD�KÞØ×*Ñ*Ó,ˆDŒJæÜ�LŠLÐ6¸ÔAðSÜ—W’W˜X tÔ,°Ø'Ñ3Ð3Ð3Ø—G‘G˜L×/Ñ/°Ó7¸%Ñ?Ô@Ü—K’K 
¨AÔ.Ø—I‘I˜aÔ!6Ô7÷	 -Ð,ð øôA "ó .Ø#-�× ð.ûô ó 	Úð	ûô> %ó -ð $-›ð	-ú÷ 1Ö0ûô )ó âÜ ó /Ü×$Ò$Ð%cÐemÔnð $/—Lð/üòB  C÷B -Õ,ûô
 ó SÜ× Ò Ð!DÀhÐPQ×RÑRûðSús°   Âh Ãh' È<h8 Ê,i ËB6iÍ9i Îi Þjæj- æ/Ajèj- èh$è#h$è'
h5è4h5è8iéié
iéi éi é
jé*&jêjê
j*ê&j- ê*j- ê-
kê7këkz

Údont_ignorec                 óh   • U R                   nU(       a  SSKJn  U" U5      nSUl        [        U5      $ )Nr   )Úcopyr@   )rÙ   rô   Úignorer/   )rA   rò   rÙ   rô   s       rB   rÛ   ÚLark._build_lexerÚ  s.   € Ø—_‘_ˆ
ÞÝ!Ù˜jÓ)ˆJØ "ˆJÔÜ˜*Ó%Ð%rE   c                 óp  • 0 U l         U R                  R                  S:w  aÒ  [        U R                  U R                  R
                  =(       d    [        U R                  R                  U R                  R                  S:g  =(       a    U R                  R                  S:H  U R                  R                  5      U l
        U R                  R                  U R                  R                  5      U l         U R                   R                  [        U R                  R                  U R                  5      5        g )Nr™   ro   r˜   )Ú
_callbacksrn   r_   r3   r¢   r\   r)   rU   r]   rV   Ú_parse_tree_builderÚcreate_callbackrT   Úupdater5   r¡   ©rA   s    rB   Ú_prepare_callbacksÚLark._prepare_callbacksâ  sÎ   € ØˆŒà�<‰<×!Ñ! XÓ-Ü'7Ø—J‘JØ—L‘L×+Ñ+×3¬tØ—L‘L×4Ñ4Ø—L‘L×'Ñ'¨6Ñ1×Z°d·l±l×6LÑ6LÐPZÑ6ZØ—L‘L×3Ñ3ó(ˆDÔ$ð #×6Ñ6×FÑFÀtÇ|Á|×G_ÑG_Ó`ˆDŒOØ�‰×ÑÔ3°D·L±L×4LÑ4LÈdÏnÉnÓ]Õ^rE   c                 ó†  • U R                  5         [        U R                  R                  U R                  R                  5        [        U R                  U R                  U R                  R                  5      n[        U R                  R                  U R                  R                  U R                  UU R                  S9$ )Nrˆ   )rý   r4   rn   r]   r^   r+   r¢   rø   rQ   r7   rÙ   )rA   Úparser_confs     rB   rÚ   ÚLark._build_parserð  s„   € Ø×ÑÔ!Ü §¡× 3Ñ 3°T·\±\×5GÑ5GÔHÜ  §¡¨T¯_©_¸d¿l¹l×>PÑ>PÓQˆÜ*Ø�L‰L×ÑØ�L‰L×ÑØ�O‰OØØ—L‘Lñ
ð 	
rE   Úexclude_optionsc                 óR  • U R                   R                  S:w  a  [        S5      eU R                  [        [
        /5      u  p4U(       a2  US   R                  5        VVs0 s H  u  pVXR;  d  M  XV_M     snnUS'   [        R                  " X4S.U[        R                  S9  gs  snnf )zWSaves the instance into the given file object

Useful for caching and multiprocessing.
ro   z7Lark.save() is only implemented for the LALR(1) parser.rn   ©rŒ   r‰   )ÚprotocolN)
rn   r]   ÚNotImplementedErrorÚmemo_serializer0   r8   rr   rË   rÝ   ÚHIGHEST_PROTOCOL)rA   rè   r  rŒ   ÚmÚnr¨   s          rB   rÞ   Ú	Lark.saveü  s�   € ð
 �<‰<×Ñ &Ó(Ü%Ð&_Ó`Ð`Ø×%Ñ%¤{´DÐ&9Ó:‰ˆÞØ04°Y±×0EÑ0EÔ0GÔdÒ0G©¨È1ÑKc›t˜qštÑ0GÒdˆD�‰OÜ�Š˜TÑ-¨q¼6×;RÑ;RÓSùó es   Á B#Á/B#rŽ   c                 óF   • U R                  U 5      nUR                  U5      $ )zVLoads an instance from the given file object

Useful for caching and multiprocessing.
©Ú__new__rÎ   )rŽ   rè   Úinsts      rB   rÌ   Ú	Lark.load  s    € ð �{‰{˜3ÓˆØ�z‰z˜!‹}ÐrE   rŒ   r‰   c                 ó&  • [         R                  " US   U5      nUR                  =(       d    0 Ul        UR                  (       a  [        O[
        Ul        UR                  Ul        UR                  Ul        SUl	        UR                  Ul
        U$ )NrÙ   T)r*   r�   rb   Ú	callbacksrY   r»   rá   rc   rZ   Úskip_validationr`   )rA   rŒ   r‰   rn   rÙ   s        rB   Ú_deserialize_lexer_confÚLark._deserialize_lexer_conf  sr   € Ü×*Ò*¨4°Ñ+=¸tÓDˆ
Ø&×6Ñ6×<¸"ˆ
ÔØ(/¯¯�u¼2ˆ
ÔØ&×0Ñ0ˆ
ÔØ#*×#8Ñ#8ˆ
Ô Ø%)ˆ
Ô"Ø$Ÿ_™_ˆ
ÔØÐrE   rA   rè   c                 óˆ  • [        U[        5      (       a  UnO[        R                  " U5      nUS   nUS   nU(       d   e[        R
                  " U[        [        S.0 5      nSU;   a  [        R
                  " US   U5      U l	        [        US   5      n[        U5      [        -
  [        [        R                  5      -  (       a*  [        SR                  [        U5      [        -
  5      5      eUR!                  U5        [        R                  Xv5      U l        US    Vs/ s H  n[        R
                  " X†5      PM     snU l        SU l        [)        U R"                  R*                  U R"                  R,                  5        U R/                  US	   X`R"                  5      U l        U R0                  R2                  U l        U R5                  5         U R2                   V	s0 s H  o™R6                  U	_M     sn	U l        [;        US	   UU R0                  U R<                  U R"                  5      U l        U $ s  snf s  sn	f )
Nr‰   rŒ   )r8   r0   r    rn   z6Some options are not allowed when loading a Parser: {}r¢   z<deserialized>r]   )rt   rq   rË   rÌ   r   r�   r8   r0   r%   r    rÇ   rÈ   rO   rk   r   Úformatrû   rn   r¢   rg   r4   r]   r^   r  rÙ   r¡   rý   ry   rØ   r6   rø   )
rA   rè   ÚkwargsÚdÚ	memo_jsonrŒ   r‰   rn   Úrrî   s
             rB   rÎ   Ú
Lark._load  sÈ  € Ü�aœ×ÑØ‰Aä—’˜A“ˆAØ�f‘Iˆ	Ø�‰yˆæÐˆyÜ ×,Ò,¨YÄÔVaÑ8bÐdfÓgˆØ˜ÓÜ"×.Ò.¨t°I©ÀÓEˆDŒLÜ�t˜I‘Ó'ˆÜ�‹KÔ/Ñ/´3´{×7LÑ7LÓ3M×MÜ$Ð%]ß$™f¤S¨£[Ô3HÑ%HÓIóKð Kà�‰�vÔÜ"×.Ñ.¨wÓ=ˆŒØ9=¸gºÓGº°A”d×&Ò& qÖ/¹ÑGˆŒ
Ø+ˆÔÜ §¡× 3Ñ 3°T·\±\×5GÑ5GÔHØ×6Ñ6°t¸H±~ÀtÏ\É\ÓZˆŒØŸ™×2Ñ2ˆŒØ×ÑÔ!Ø37·>²>ÓB²>¨a§¡¨¢	±>ÑBˆÔÜ3Ø�‰NØØ�O‰OØ�O‰OØ�L‰Ló
ˆŒð ˆùò Hùò  Cs   Ä% H:Ç%H?c                 óN   • U R                  U 5      nUR                  " XS.40 UD6$ )Nr  r  )rŽ   rŒ   r‰   r  r  s        rB   Ú_load_from_dictÚLark._load_from_dict=  s'   € à�{‰{˜3ÓˆØ�zŠz 4Ñ6ÑA¸&ÑAÐArE   Úgrammar_filenameÚrel_toc                 óè   • U(       a>  [         R                  R                  U5      n[         R                  R                  XA5      n[	        USS9 nU " U40 UD6sSSS5        $ ! , (       d  f       g= f)zþCreate an instance of Lark with the grammar given by its filename

If ``rel_to`` is provided, the function will find the grammar filename in relation to it.

Example:

    >>> Lark.open("grammar_file.lark", rel_to=__file__, parser="lalr")
    Lark(...)

r±   )ÚencodingN)ÚosÚpathÚdirnamer¾   rÆ   )rŽ   r   r!  rn   Úbasepathrè   s         rB   rÆ   Ú	Lark.openB  sR   € ö Ü—w‘w—‘ vÓ.ˆHÜ!Ÿw™wŸ|™|¨HÓGÐÜÐ"¨VÒ4¸Ù�qÑ$˜GÑ$÷ 5×4×4ús   Á	A#Á#
A1r¤   ÚpackageÚgrammar_pathÚsearch_pathszSequence[str]c                 ó°   • [        X5      nU" SU5      u  pgUR                  SU5        UR                  S/ 5        US   R                  U5        U " U40 UD6$ )aC  Create an instance of Lark with the grammar loaded from within the package `package`.
This allows grammar loading from zipapps.

Imports in the grammar will use the `package` and `search_paths` provided, through `FromPackageLoader`

Example:

    Lark.open_from_package(__name__, "example.lark", ("grammars",), parser=...)
Nrg   rf   )r$   Ú
setdefaultÚappend)rŽ   r)  r*  r+  rn   Úpackage_loaderÚ	full_pathÚtexts           rB   Úopen_from_packageÚLark.open_from_packageT  s_   € ô +¨7ÓAˆÙ(¨¨|Ó<‰ˆ	Ø×Ñ˜=¨)Ô4Ø×Ñ˜>¨2Ô.Ø�Ñ×&Ñ& ~Ô6Ù�4Ñ#˜7Ñ#Ð#rE   c                 ó„   • SU R                   < SU R                  R                  < SU R                  R                  < S3$ )Nz
Lark(open(z
), parser=z, lexer=z, ...))rg   rn   r]   r^   rü   s    rB   Ú__repr__ÚLark.__repr__f  s,   � Ø=A×=MÔ=MÈtÏ|É|×ObÔObÐdh×dpÑdp×dvÔdvÐwÐwrE   r1  c                 ó@  • [        U S5      (       a  U(       a  U R                  U5      nOU R                  n[        R                  " X15      nUR                  S5      nU R                  R                  (       a%  U R                  R                  R                  U5      $ U$ )zþOnly lex (and postlex) the text, without parsing it. Only relevant when lexer='basic'

When dont_ignore=True, the lexer will return all tokens, even those marked for %ignore.

:raises UnexpectedCharacters: In case the lexer cannot find a suitable match.
r^   N)	ÚhasattrrÛ   r^   r1   Ú	from_textÚlexrn   r`   rC   )rA   r1  rò   r^   Úlexer_threadr<   s         rB   r:  ÚLark.lexj  sy   € ô �t˜W×%Ñ%®Ø×%Ñ% kÓ2‰Eà—J‘JˆEÜ"×,Ò,¨UÓ9ˆØ×!Ñ! $Ó'ˆØ�<‰<××Ø—<‘<×'Ñ'×/Ñ/°Ó7Ð7ØˆrE   ry   c                 ó    • U R                   U   $ )z Get information about a terminal)rØ   )rA   ry   s     rB   Úget_terminalÚLark.get_terminal|  s   € à×#Ñ# DÑ)Ð)rE   rQ   r   c                 ó4   • U R                   R                  XS9$ )a  Start an interactive parsing session. Only works when parser='lalr'.

Parameters:
    text (LarkInput, optional): Text to be parsed. Required for ``resume_parse()``.
    start (str, optional): Start symbol

Returns:
    A new InteractiveParser instance.

See Also: ``Lark.parse()``
)rQ   )r]   Úparse_interactive)rA   r1  rQ   s      rB   rA  ÚLark.parse_interactive€  s   € ð �{‰{×,Ñ,¨TÐ,Ð?Ð?rE   Úon_errorz+Optional[Callable[[UnexpectedInput], bool]]r   c                 ó†   • Ub%  U R                   R                  S:w  a  [        S5      eU R                  R                  XUS9$ )a_  Parse the given text, according to the options provided.

Parameters:
    text (LarkInput): Text to be parsed, as `str` or `bytes`.
        TextSlice may also be used, but only when lexer='basic' or 'contextual'.
        If Lark was created with a custom lexer, this may be an object of any type.
    start (str, optional): Required if Lark was given multiple possible start symbols (using the start option).
    on_error (function, optional): if provided, will be called on UnexpectedInput error,
        with the exception as its argument. Return true to resume parsing, or false to raise the exception.
        LALR only. See examples/advanced/error_handling.py for an example of how to use on_error.

Returns:
    If a transformer is supplied to ``__init__``, returns whatever is the
    result of the transformation. Otherwise, returns a Tree instance.

:raises UnexpectedInput: On a parse error, one of these sub-exceptions will rise:
        ``UnexpectedCharacters``, ``UnexpectedToken``, or ``UnexpectedEOF``.
        For convenience, these sub-exceptions also inherit from ``ParserError`` and ``LexerError``.

ro   z?The on_error option is only implemented for the LALR(1) parser.)rQ   rC  )rn   r]   r  Úparse)rA   r1  rQ   rC  s       rB   rE  Ú
Lark.parseŽ  sA   € ð* Ñ D§L¡L×$7Ñ$7¸6Ó$AÜ%Ð&gÓhÐhØ�{‰{× Ñ  ¸XÐ ÐFÐFrE   )r¸   rø   rù   rØ   r    r×   r^   rÙ   rn   r]   r¢   rŸ   rg   r¡   )r    zUnion[Grammar, str, IO[str]]r=   N)F)r=   N)r=   r   )r@   r?   )NN).rG   rH   rI   rJ   r‘   rK   rL   rO   r.   r   r0   r¸   r|   r“   ru   r/   rÛ   rý   rÚ   rÞ   r”   r   rš   rÌ   r   r   r’   r   r8   r*   r  rÎ   r  r   rÆ   r2  r5  r!   r	   r2   r:  r>  r"   rA  rE  rM   r@   rE   rB   r›   r›   þ   sE  ‡ ñð ÓØÓØÓØÓØƒLØÓØ˜+Ñ&Ó&â9ÐôSöB Ø�6˜K×3Ñ3Ñ3Ñ3ˆñ&¨ð &°zõ &ô_ô

ñ
T z°#¡ð 
TÀõ 
Tð ð�$�r‘(ð  "ó ó ðð¨D°°c°©Nð À$ÀsÈEÐR]Ð_cÐRcÑLdÐGdÑBeð Ðp{ð ð  AJô ð �Bð  ˜3ð  ¨Rô  ðD ñBó ðBð ñ%�$�r‘(ð %¨cð %¸8ÀC¹=ð %Ð]_ô %ó ð%ð" ØikÐhlñ $˜t B™xð $°#ð $ÀSð $ÐXgð $Ð|~ô $ó ð$ò"xñ˜ð °$ð ÀÈ%Áõ ð$* ð *¨ô *ñ@ h¨yÑ&9ð @ÀxÐPSÁ}ð @Ð^qõ @ñG˜)ð G¨H°S©Mð GÐJwð Gð  BM÷ Gð GrE   )RÚabcr   r   rÁ   r¿   r$  rË   rÄ   Útypesr»   Útypingr   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   Úparsers.lalr_interactive_parserr   Útreer   Úvisitorsr   r   Úparser_frontendsr   Ú
exceptionsr   r   r   Úutilsr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   Úcommonr*   r+   r,   r-   r^   r.   r/   r0   r1   r2   Úparse_tree_builderr3   r4   r5   r6   r7   r    r8   rY   r¹   rº   r:   rO   rÈ   rÔ   rÕ   rš   r›   r@   rE   rB   Ú<module>rR     sì   ðß #Û ß Ó Û Û Û 	÷÷ ÷ ÷ ñ ö ÝBÝÝ%ÝÝ1ç JÑ Jß S× Sß u× uÝ ß HÓ Hç EÕ EÝ 0÷ Hó  HÝ ðÛØ€Jô&ˆcô &ôB�)ô BòN gÐ à<Ð ØDÐ ñ ˆT˜Ñ €ôgGˆ9õ gGøð{ ó Ø‚Jðús   ÃD ÄDÄD