
    Xhz                    4   d dl mZ d dlZd dlZd dlmZ d dlmZ d dlm	Z	 ddl
mZ ej                  dk(  sJ es
d dlZd d	lmZ d d
lmZmZmZ d dlmZmZ d dlmZmZmZmZmZ d dlmZ d dlmZm Z  d dl!m"Z" d dl#m$Z$ d dl%m&Z&m'Z' d dl(m)Z)m*Z*m+Z+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 g dZ4dZ5dZ6dZ7dZ8dZ9 G d de1      Z: G d de:      Z; G d d      Z< G d  d!      Z= G d" d#      Z>e		 	 	 	 	 	 d+d$       Z?e	d,d%       Z@ G d& d'      ZA G d( d)eA      ZBd-d*ZCy).    )annotationsN)abstractmethod)get_running_loop)contextmanager   )SPHINX_AUTODOC_RUNNINGwin32)windll)Arraybyrefpointer)DWORDHANDLE)CallableContextManagerIterableIteratorTextIOrun_in_executor_with_context)create_win32_eventwait_for_handles)KeyPress)Keys)MouseButtonMouseEventType)INPUT_RECORDKEY_EVENT_RECORDMOUSE_EVENT_RECORDSTD_INPUT_HANDLE
EventTypes   )REVERSE_ANSI_SEQUENCES)Input)Vt100Parser)
Win32InputConsoleInputReaderraw_modecooked_modeattach_win32_inputdetach_win32_input   i   c                  4    e Zd ZdZddZeedd              Zy)_Win32InputBasez;
    Base class for `Win32Input` and `Win32PipeInput`.
    c                "    t               | _        y N)_Win32Handleswin32_handlesselfs    N/var/www/html/myenv/lib/python3.12/site-packages/prompt_toolkit/input/win32.py__init__z_Win32InputBase.__init__A   s    *_    c                     y r0    r3   s    r5   handlez_Win32InputBase.handleD   s     	r7   NreturnNoner<   r   )__name__
__module____qualname____doc__r6   propertyr   r:   r9   r7   r5   r.   r.   <   s(    -   r7   r.   c                       e Zd ZdZdd fdZddZddZddZddZe	dd       Z
ddZdd	Zdd
ZddZddZe	dd       Z xZS )r&   z<
    `Input` class that reads from the Windows console.
    c                    t         |           t               | _        |  | j                  rt	               | _        y t               | _        y r0   )superr6   _is_win_vt100_input_enabled_use_virtual_terminal_inputVt100ConsoleInputReaderconsole_input_readerr'   )r4   stdin	__class__s     r5   r6   zWin32Input.__init__O   s;    +F+H(++(?(AD%(:(<D%r7   c                    t        | |      S )zj
        Return a context manager that makes this input active in the current
        event loop.
        )r*   )r4   input_ready_callbacks     r5   attachzWin32Input.attachZ   s    
 "$(<==r7   c                    t        |       S )z{
        Return a context manager that makes sure that this input is not active
        in the current event loop.
        )r+   r3   s    r5   detachzWin32Input.detacha   s    
 "$''r7   c                H    t        | j                  j                               S r0   )listrJ   readr3   s    r5   	read_keyszWin32Input.read_keysh   s    D--22455r7   c                6    | j                   j                         S r0   )rJ   
flush_keysr3   s    r5   rW   zWin32Input.flush_keysk   s    ((3355r7   c                     yNFr9   r3   s    r5   closedzWin32Input.closedn   s    r7   c                .    t        | j                        S )N) use_win10_virtual_terminal_input)r(   rH   r3   s    r5   r(   zWin32Input.raw_moder   s    -1-M-M
 	
r7   c                    t               S r0   )r)   r3   s    r5   r)   zWin32Input.cooked_modew   s
    }r7   c                >    t         j                  j                         S r0   )sysrK   filenor3   s    r5   r`   zWin32Input.filenoz   s    
 yy!!r7   c                     y)Nzwin32-inputr9   r3   s    r5   typeahead_hashzWin32Input.typeahead_hash   s    r7   c                8    | j                   j                          y r0   )rJ   closer3   s    r5   rd   zWin32Input.close   s    !!'')r7   c                .    | j                   j                  S r0   )rJ   r:   r3   s    r5   r:   zWin32Input.handle   s    ((///r7   r0   )rK   zTextIO | Noner<   r=   )rN   Callable[[], None]r<   ContextManager[None])r<   rg   r<   list[KeyPress]r<   bool)r<   int)r<   strr;   r>   )r?   r@   rA   rB   r6   rO   rQ   rU   rW   rC   rZ   r(   r)   r`   rb   rd   r:   __classcell__)rL   s   @r5   r&   r&   J   sb    	=>(66  

"* 0 0r7   r&   c                  *   e Zd ZdZi dej
                  dej                  dej                  dej                  dej                  dej                  dej                  d	ej                  d
ej                  dej                  dej                  dej                   dej"                  dej$                  dej&                  dej(                  dej*                  i dej,                  dej.                  dej0                  dej2                  dej4                  dej6                  dej8                  dej:                  dej<                  dej>                  dej@                  dejB                  dejD                  d ejF                  d!ejH                  d"ejJ                  Z&i d#ejN                  d$ejP                  d%ejR                  d&ejT                  d'ejV                  d(ejX                  d)ejZ                  d*ej\                  d+ej^                  d,ej`                  d-ejb                  d.ejd                  d/ejf                  d0ejh                  d1ejj                  d2ejl                  d3ejn                  ejp                  ejr                  ejt                  ejv                  ejx                  d4Z=d5Z>d6Z?d7Z@d8ZAd9ZBdEdFd:ZCdGd;ZDdHd<ZEdId=ZFdJd>ZG	 	 	 	 	 	 dKd?ZHeIdLd@       ZJeIdMdA       ZKdNdBZLdOdCZMyD)Pr'   z|
    :param recognize_paste: When True, try to discover paste actions and turn
        the event into a BracketedPaste.
                                      	   
                                                               !   "   #   $   %   &   '   (   -   .   p   q   r   s   t   u   v   )w   x   y   z   {   r   r"         r,   c                   d | _         || _        |  t        j                  j	                         r2t        t        j                  j                  t                    | _
        y t        j                  dt        j                  t        j                  z        | _         t        t        j                   | j                               | _
        y )NCONIN$)_fdconrecognize_paster_   rK   isattyr   r
   kernel32GetStdHandler    r:   osopenO_RDWRO_BINARYmsvcrtget_osfhandle)r4   r   s     r5   r6   zConsoleInputReader.__init__   s|    . 	99 !=!=>N!OPDK''(BII,CDDK !5!5dkk!BCDKr7   c                \    | j                    t        j                  | j                          yyzClose fdcon.Nr   r   rd   r3   s    r5   rd   zConsoleInputReader.close   !    ;;"HHT[[! #r7   c              #     K   d}t        d      }t        |z  } |       }t        | j                  gd      syt        j
                  j                  | j                  t        |      |t        |             t        | j                  ||            }|D cg c]  }| j                  |       }}t        | j                  |            }| j                  r| j                  |      rt        |      }|D ]  }g }	|rt        |j                   t"              r,|j                   t"        j$                  t"        j&                  hv rq|	j)                  |j*                         	 t-        |      }|rHt        |j                   t"              sD|j                   t"        j$                  t"        j&                  hv rq|	r+t1        t"        j2                  dj5                  |	             ||  y|E d{    yc c}w # t.        $ r d}Y w xY w7 w)
        Return a list of `KeyPress` instances. It won't return anything when
        there was nothing to read.  (This function doesn't block.)

        http://msdn.microsoft.com/en-us/library/windows/desktop/ms684961(v=vs.85).aspx
           r   timeoutN )r   r   r   r:   r
   r   ReadConsoleInputWr   rS   	_get_keys_insert_key_data_merge_paired_surrogatesr   	_is_pasteiter
isinstancekeyr   ControlJControlMappenddatanextStopIterationr   BracketedPastejoin)
r4   	max_countrT   arrtypeinput_recordsall_keysr   genkr   s
             r5   rT   zConsoleInputReader.read   s     	Qx*	  q9 	))KK/GDM	
 t];< ;CC3D))#.CC 55h?@DNN8$<x.C   "155$/uu >>KK'! I "155$/uu >> "4#6#6FF=G#&  9 D( ) ! !  sU   BHG6.B0HG;*H,H4/H$H0H1
H;H	HH		Hc                    g S r0   r9   r3   s    r5   rW   zConsoleInputReader.flush_keys*  s    	r7   c                    |j                   r|S t        |j                  t              r!t	        j
                  |j                  d      }nd}t        |j                  |      S )z@
        Insert KeyPress data, for vt100 compatibility.
        r   )r   r   r   r   r#   getr   )r4   	key_pressr   s      r5   r   z#ConsoleInputReader._insert_key_data.  sK     >>immT*)--immR@DD	t,,r7   c              #    K   t        |j                        D ]  }||   }|j                  t        v st	        |j
                  t        |j                           }t        |t              r&|j                  r| j                  |      E d{    xt        |t              s| j                  |      E d{     y7 27 	w)R
        Generator that yields `KeyPress` objects from the input records.
        N)rangevalue	EventTyper!   getattrEventr   r   KeyDown_event_to_key_pressesr   _handle_mouse)r4   rT   r   iirevs         r5   r   zConsoleInputReader._get_keys<  s      tzz" 	6Aq!B ||z)RXXz",,'?@ b"23

#99"===$67#11"555!	6 > 6s/   0CAC
B=C!C5B?6C?Cc              #    K   d}| D ]  }t        |j                  t               }|xr d|j                  cxk  xr dk  nc }|xr d|j                  cxk  xr dk  nc }|rM|rE|j                  |j                  z   j                  dd      j	                  d      }t        ||      }n| d}|r|}|  |r| yyw)zm
        Combines consecutive KeyPresses with high and low surrogates into
        single characters
        Nu   u   u   u   z	utf-16-lesurrogatepass)r   r   r   encodedecoder   )key_pressesbuffered_high_surrogater   is_textis_high_surrogateis_low_surrogatefullchars          r5   r   z+ConsoleInputReader._merge_paired_surrogatesT  s      #' 	C$SWWd33G ' KH,K8,K&J8sww+J(+J&# 144sww>_=, 
 #8X6C11*.' *-'	+	. #)) #s   CCc                    d}d}| D ]D  }t        |j                  t              s|dz  }|j                  t        j                  k(  s@|dz  }F |dk\  xr |dk\  S )a<  
        Return `True` when we should consider this list of keys as a paste
        event. Pasted text on windows will be turned into a
        `Keys.BracketedPaste` event. (It's not 100% correct, but it is probably
        the best possible way to detect pasting of text and handle that
        correctly.)
        r   r"   )r   r   r   r   )keys
text_countnewline_countr   s       r5   r   zConsoleInputReader._is_pasteu  sd     
 	#AaeeT*a
uu%"		# !5jAo5r7   c                h   t        |t              r|j                  sJ d}|j                  }|j                  j
                  }|j                  dd      }|dk(  r<|j                  | j                  v rzt        | j                  |j                     d      }nV|| j                  v r<| j                  |   t        j                  k(  rd}t        | j                  |   |      }nt        ||      }|| j                  z  s|| j                  z  rN|| j                  z  r>|r;t        j                   t        j"                  t        j$                  t        j&                  t        j(                  t        j*                  t        j,                  t        j.                  t        j0                  t        j2                  t        j4                  t        j6                  t        j8                  t        j:                  t        j<                  t        j>                  t        j@                  t        jB                  i	}|jE                  |jF                  |jF                        |_#        || j                  z  s|| j                  z  r\|rYt        j                   t        jH                  t        j$                  t        jJ                  t        j(                  t        jL                  t        j,                  t        jN                  t        j0                  t        jP                  t        j4                  t        jR                  t        j8                  t        jT                  t        jV                  t        jX                  t        j<                  t        jZ                  t        j@                  t        j\                  i
}|jE                  |jF                  |jF                        |_#        || j                  z  rz|rwt        j^                  t        j`                  t        j                   t        jb                  t        j$                  t        jd                  t        j(                  t        jf                  t        j,                  t        jh                  t        j0                  t        jj                  t        j4                  t        jl                  t        j8                  t        jn                  t        jV                  t        jp                  t        j<                  t        jr                  t        j@                  t        jt                  i}|jE                  |jF                  |jF                        |_#        || j                  z  s|| j                  z  r+|r)|jv                  dk(  rt        t        jx                  d      }|| j                  z  s|| j                  z  r;|r9|jF                  t        j                  k(  rt        t        jz                  d      |gS |r0|| j|                  z  }|rt        t        jz                  d      |gS |gS g S )zU
        For this `KEY_EVENT_RECORD`, return a list of `KeyPress` instances.
        Nzutf-8r    r   
 )?r   r   r   ControlKeyStateuCharUnicodeCharr   VirtualKeyCodekeycodesr   mappingsr   r   LEFT_CTRL_PRESSEDRIGHT_CTRL_PRESSEDSHIFT_PRESSEDLeftControlShiftLeftRightControlShiftRightUpControlShiftUpDownControlShiftDownHomeControlShiftHomeEndControlShiftEndInsertControlShiftInsertPageUpControlShiftPageUpPageDownControlShiftPageDownr   r   ControlLeftControlRight	ControlUpControlDownControlHome
ControlEndControlInsertDeleteControlDeleteControlPageUpControlPageDownTabBackTab	ShiftLeft
ShiftRightShiftUp	ShiftDown	ShiftHomeShiftEndShiftInsertShiftDeleteShiftPageUpShiftPageDownr   ControlSpaceEscapeLEFT_ALT_PRESSED)r4   r   resultcontrol_key_stateu_char
ascii_charmappingmeta_presseds           r5   r   z(ConsoleInputReader._event_to_key_presses  s    "./BJJ>>"&..%%]]7O<
 V  DMM1!$--0A0A"BBGT]]*==,=  "$--
";VD!&&1
 "D$:$::$t'>'>>!D$6$66 		400

D22,,		400		400$..T44T44t88
'G !VZZ<FJ  6 66 4#:#::		4++

D--		4++		4++$//T//T//T//t33G !VZZ<FJ t111f$,,		4>>

DOO		4>>		4>>$--T--T--T--t11G !VZZ<FJ
 "D$:$::$t'>'>>s"d//5F "D$:$::$t'>'>>

dmm+T[["-v66 ,t/D/DDL b16::x Ir7   c                   |j                   }|j                  }d}t        j                  }|t        z  r'|dkD  rt
        j                  }nDt
        j                  }n3|t        k(  rt        j                  }n|t        k(  rt        j                  }|t        z  rt
        j                  }|&|dkD  rt
        j                  }nt
        j                  }dj!                  |j"                  |j"                  t%        |j&                  j(                        t%        |j&                  j*                        g      }t-        t.        j0                  |      gS )zK
        Handle mouse events. Return a list of KeyPress instances.
        Nr   ;)
EventFlagsButtonStater   NONEMOUSE_WHEELEDr   	SCROLL_UPSCROLL_DOWNFROM_LEFT_1ST_BUTTON_PRESSEDLEFTRIGHTMOST_BUTTON_PRESSEDRIGHTMOUSE_MOVED
MOUSE_MOVE
MOUSE_DOWNMOUSE_UPr   r   rm   MousePositionXYr   r   WindowsMouseEvent)r4   r   event_flagsbutton_state
event_typebuttonr   s          r5   r   z ConsoleInputReader._handle_mouse  s    mm~~,0
).. &a+55
+77
 ;;$))!99$** $'22J a+66
 ,44
xx  B$$&&'B$$&&'	
 //677r7   N)T)r   rk   r<   r=   r;   r<   zIterable[KeyPress]rh   )r   r   r<   r   )rT   r   r   Array[INPUT_RECORD]r<   Iterator[KeyPress])r   ri   r<   rN  )r   ri   r<   rk   )r   r   r<   ri   )r   r   r<   ri   )Nr?   r@   rA   rB   r   r,  r+  ControlAControlBControlCControlDControlEControlFControlGControlHControlIr   ControlKControlLr   ControlNControlOControlPControlQControlRControlSControlTControlUControlVControlWControlXControlYControlZControlBackslashControlSquareCloseControlCircumflexControlUnderscore	Backspacer   r  r  r  r
  r  r  r  r  r  r  F1F2F3F4F5F6F7F8F9F10F11F12r   r-  RIGHT_ALT_PRESSEDr  r   r   r6   rd   rT   rW   r   r   staticmethodr   r   r   r   r9   r7   r5   r'   r'      s   """"" 	" 		"
 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	"  	!"" 	#"$ 	%"& 	'"( 	)"* 	+", 	-". 	/"0 	1"2 	3"4 	5"6 	7"8 	9": 	&&;"< 	((="> 	''?"@ 	''A"B 	C"HJ
DKK 	DMM 	DHH	
 	DII 	DII 	DGG 	DJJ 	DII 	DKK 	DKK 	TWW 	TWW  	TWW!" 	TWW#$ 	TWW%& 	TWW'( 	TWW)* WWWWXXXXXX3H8 MD"
< |-66*=6	60 * *@ 6 6*BH-8r7   r'   c                  D    e Zd ZdZddZddZd	dZd
dZ	 	 	 	 	 	 ddZy)rI   a  
    Similar to `ConsoleInputReader`, but for usage when
    `ENABLE_VIRTUAL_TERMINAL_INPUT` is enabled. This assumes that Windows sends
    us the right vt100 escape sequences and we parse those with our vt100
    parser.

    (Using this instead of `ConsoleInputReader` results in the "data" attribute
    from the `KeyPress` instances to be more correct in edge cases, because
    this responds to for instance the terminal being in application cursor keys
    mode.)
    c                    d  _         g  _        t         fd       _          t        j
                  j                         r2t        t        j                  j                  t                     _        y t        j                  dt        j                  t        j                   z         _         t        t#        j$                   j                                _        y )Nc                :    j                   j                  |       S r0   )_bufferr   )r   r4   s    r5   <lambda>z2Vt100ConsoleInputReader.__init__.<locals>.<lambda>Q  s    dll11)< r7   r   )r   r}  r%   _vt100_parserr_   rK   r   r   r
   r   r   r    r:   r   r   r   r   r   r   r3   s   `r5   r6   z Vt100ConsoleInputReader.__init__L  s    ')(<
 	99 !=!=>N!OPDK''(BII,CDDK !5!5dkk!BCDKr7   c                \    | j                    t        j                  | j                          yyr   r   r3   s    r5   rd   zVt100ConsoleInputReader.close]  r   r7   c                z   d}t        d      }t        |z  } |       }t        | j                  gd      sg S t        j
                  j                  | j                  t        |      |t        |             | j                  ||      D ]  }| j                  j                  |        | j                  }g | _        |S )r   r   r   r   )r   r   r   r:   r
   r   r   r   r   r  feedr}  )r4   r   rT   r   r   key_datar.  s          r5   rT   zVt100ConsoleInputReader.readb  s     	Qx*	  q9I 	))KK/GDM	
 t]; 	.H##H-	. r7   c                `    | j                   j                          | j                  }g | _        |S )zc
        Flush pending keys and return them.
        (Used for flushing the 'escape' key.)
        )r  flushr}  )r4   r.  s     r5   rW   z"Vt100ConsoleInputReader.flush_keys  s-     	  " r7   c              #  :  K   t        |j                        D ]  }||   }|j                  t        v st	        |j
                  t        |j                           }t        |t              sS|j                  s`|j                  j                  }|dk7  s||  yw)r   r   N)r   r   r   r!   r   r   r   r   r   r   r   )r4   rT   r   r   r   r   r0  s          r5   r   z!Vt100ConsoleInputReader._get_keys  s      tzz" 	%Aq!B ||z)RXXz",,'?@ b"23

XX11F'$	%s   0B7B+B8BBNr;   rL  rh   )rT   r   r   rM  r<   zIterator[str])	r?   r@   rA   rB   r6   rd   rT   rW   r   r9   r7   r5   rI   rI   ?  s:    
D""
#J%%*=%	%r7   rI   c                  (    e Zd ZdZddZddZddZy)	r1   a  
    Utility to keep track of which handles are connectod to which callbacks.

    `add_win32_handle` starts a tiny event loop in another thread which waits
    for the Win32 handle to become ready. When this happens, the callback will
    be called in the current asyncio event loop using `call_soon_threadsafe`.

    `remove_win32_handle` will stop this tiny event loop.

    NOTE: We use this technique, so that we don't have to use the
          `ProactorEventLoop` on Windows and we can wait for things like stdin
          in a `SelectorEventLoop`. This is important, because our inputhook
          mechanism (used by IPython), only works with the `SelectorEventLoop`.
    c                     i | _         i | _        y r0   )_handle_callbacks_remove_eventsr3   s    r5   r6   z_Win32Handles.__init__  s    @B 24r7   c                   j                   }|t        d      | j                         t               | j                  |<   t               | j                  |<   dfddfdt               y)z7
        Add a Win32 handle to the event loop.
        NInvalid handle.c                 T    	           t               y # t               w xY w)Nloopr   )callbackr  waits   r5   readyz-_Win32Handles.add_win32_handle.<locals>.ready  s#    >
,T=,T=s    'c                     t        g      } | u r t        j                  j                         y j	                         y r0   )r   r
   r   CloseHandlecall_soon_threadsafe)r.  r:   r  r  remove_events    r5   r  z,_Win32Handles.add_win32_handle.<locals>.wait  s?     &|V&<=F%++L9))%0r7   r  r;   )r   
ValueErrorremove_win32_handler   r  r   r  r   )r4   r:   r  handle_valuer  r  r  r  s    `` @@@@r5   add_win32_handlez_Win32Handles.add_win32_handle  s}     ||.// 	  (!/7|, *+,8L)	>		1 		1 	%T5r7   c                .   |j                   y	 | j                  j                  |j                         }t        j                  j                  |       	 | j                  j                  |j                         S # t        $ r Y 1w xY w# t        $ r Y yw xY w)zt
        Remove a Win32 handle from the event loop.
        Return either the registered handler or `None`.
        N)r   r  popr
   r   SetEventKeyErrorr  )r4   r:   events      r5   r  z!_Win32Handles.remove_win32_handle  s    
 <<	,''++FLL9E OO$$U+	))--fll;;  		  		s#   %A9 $B 9	BB	BBNr;   )r:   r   r  rf   r<   r=   )r:   r   r<   zCallable[[], None] | None)r?   r@   rA   rB   r6   r  r  r9   r7   r5   r1   r1     s    4)6Vr7   r1   c              #  \  K   | j                   }| j                  }|j                  t        d      |j	                  |      }|j                  ||       	 d |j	                  |       |r|j                  ||       yy# |j	                  |       |r|j                  ||       w w xY ww)z
    Context manager that makes this input active in the current event loop.

    :param input: :class:`~prompt_toolkit.input.Input` object.
    :param input_ready_callback: Called when the input is ready to read.
    Nr  r2   r:   r   r  r  r  )inputr  r2   r:   previous_callbacks        r5   r*   r*     s      ''M\\F||*++ &99&A""684F))&1**63DE  	))&1**63DE s   AB,B 'B,(B))B,c              #     K   | j                   }| j                  }|j                  t        d      |j	                  |      }	 d  |r|j                  ||       y y # |r|j                  ||       w w xY ww)Nr  r  )r  r2   r:   r  s       r5   r+   r+   "  s}     ''M\\F||*++%99&AF**63DE **63DE s   AA8A A8A55A8c                  >    e Zd ZdZ	 d	 	 	 	 	 ddZd	dZd	dZd
dZy)r(   z
    ::

        with raw_mode(stdin):
            ''' the windows terminal is now in 'raw' mode. '''

    The ``fileno`` attribute is ignored. This is to be compatible with the
    `raw_input` method of `.vt100_input`.
    Nc                t    t        t        j                  j                  t                    | _        || _        y r0   )r   r
   r   r   r    r:   r\   )r4   r`   r\   s      r5   r6   zraw_mode.__init__>  s(     V__99:JKL0P-r7   c                    t               }t        j                  j                  | j                  t        |             || _        | j                          y r0   )r   r
   r   GetConsoleModer:   r   original_mode_patch)r4   r  s     r5   	__enter__zraw_mode.__enter__D  s7    &&t{{GM4JK*r7   c                    d}d}d}| j                   j                  ||z  |z   z  }| j                  r	|t        z  }t        j
                  j                  | j                  |       y Nr,   r   r"   )r  r   r\   ENABLE_VIRTUAL_TERMINAL_INPUTr
   r   SetConsoleModer:   )r4   ENABLE_ECHO_INPUTENABLE_LINE_INPUTENABLE_PROCESSED_INPUTnew_modes        r5   r  zraw_mode._patchL  sl    ""!'%%++ 114JJ/
 
 0055H&&t{{H=r7   c                l    t         j                  j                  | j                  | j                         y r0   )r
   r   r  r:   r  )r4   as     r5   __exit__zraw_mode.__exit__[  s     &&t{{D4F4FGr7   rY   )r`   z
int | Noner\   rk   r<   r=   r;   )r  objectr<   r=   )r?   r@   rA   rB   r6   r  r  r  r9   r7   r5   r(   r(   3  s?     SXQ QKOQ	Q>Hr7   r(   c                      e Zd ZdZddZy)r)   zx
    ::

        with cooked_mode(stdin):
            ''' The pseudo-terminal stdin is now used in cooked mode. '''
    c                    d}d}d}t         j                  j                  | j                  | j                  j
                  ||z  |z  z         y r  )r
   r   r  r:   r  r   )r4   r  r  r  s       r5   r  zcooked_mode._patchh  sQ    ""!'&&KK$$ #447MMO	
r7   Nr;   )r?   r@   rA   rB   r  r9   r7   r5   r)   r)   `  s    

r7   r)   c                    t        t        j                  j                  t                    } t        d      }t        j                  j                  | t        |             	 t        j                  j                  | t        t                    }|dk(  t        j                  j                  | |       S # t        j                  j                  | |       w xY w)z_
    Returns True when we're running Windows and VT100 escape sequences are
    supported.
    r   r"   )
r   r
   r   r   r    r   r  r   r  r  )hconsoler  r.  s      r5   rG   rG   u  s    
 foo223CDEH !HM
OO""8U=-AB@oo44e9:
 {&&x?&&x?s   "1B4 4"C)r  r.   r  rf   r<   Iterator[None])r  r.   r<   r  rj   )D
__future__r   r   r_   abcr   asyncior   
contextlibr   utilsr   platformr   ctypesr
   r   r   r   ctypes.wintypesr   r   typingr   r   r   r   r   prompt_toolkit.eventloopr   prompt_toolkit.eventloop.win32r   r   (prompt_toolkit.key_binding.key_processorr   prompt_toolkit.keysr   prompt_toolkit.mouse_eventsr   r   prompt_toolkit.win32_typesr   r   r   r    r!   ansi_escape_sequencesr#   baser$   vt100_parserr%   __all__r<  r>  r@  r9  r  r.   r&   r'   rI   r1   r*   r+   r(   r)   rG   r9   r7   r5   <module>r     s7   " 	 
  $ % *
||w   ( ( ) G G A O = $ C  :  %  #   !' e ?0 ?0Dp8 p8fk% k%\U Up FF&8FF F8 F F *H *HZ
( 
*@r7   