o
    �õ±j{  ã                   @  sì  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	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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# 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/m0Z0 ddl1m2Z2 ddl3m4Z4 g d¢Z5dZ6dZ7dZ8dZ9dZ:G dd„ de2ƒZ;G dd„ de;ƒZ<G dd „ d ƒZ=G d!d"„ d"ƒZ>G d#d$„ d$ƒZ?e
d5d*d+„ƒZ@e
d6d,d-„ƒZAG d.d/„ d/ƒZBG d0d1„ d1eBƒZCd7d3d4„ZDdS )8é    )ÚannotationsN)Úabstractmethod)Úget_running_loop)ÚAbstractContextManagerÚcontextmanageré   )ÚSPHINX_AUTODOC_RUNNINGÚwin32)Úwindll)ÚCallableÚIterableÚIterator)ÚArrayÚbyrefÚpointer)ÚDWORDÚHANDLE)Ú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                   @  s,   e Zd ZdZd
dd„Zeeddd„ƒƒZd	S )Ú_Win32InputBasez;
    Base class for `Win32Input` and `Win32PipeInput`.
    ÚreturnÚNonec                 C  s   t ƒ | _d S ©N)Ú_Win32HandlesÚwin32_handles©Úself© r4   ú�/root/aizidognhua/tmp/workspace/projects/ec89d86c-575f-41c9-af57-ac45cbdbf775/venv/lib/python3.10/site-packages/prompt_toolkit/input/win32.pyÚ__init__B   s   z_Win32InputBase.__init__r   c                 C  s   d S r/   r4   r2   r4   r4   r5   ÚhandleE   s   z_Win32InputBase.handleN©r-   r.   ©r-   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r6   Úpropertyr   r7   r4   r4   r4   r5   r,   =   s    
r,   c                      sš   e Zd ZdZd'd(‡ fdd„Zd)dd„Zd*dd„Zd+dd„Zd+dd„Ze	d,dd„ƒZ
d*dd„Zd*dd„Zd-dd„Zd.d d!„Zd/d"d#„Ze	d0d%d&„ƒZ‡  ZS )1r%   z<
    `Input` class that reads from the Windows console.
    NÚstdinúTextIO | Noner-   r.   c                   s4   t ƒ  ¡  tƒ | _|  | jrtƒ | _d S tƒ | _d S r/   )Úsuperr6   Ú_is_win_vt100_input_enabledÚ_use_virtual_terminal_inputÚVt100ConsoleInputReaderÚconsole_input_readerr&   )r3   r?   ©Ú	__class__r4   r5   r6   P   s   
zWin32Input.__init__Úinput_ready_callbackúCallable[[], None]úAbstractContextManager[None]c                 C  s
   t | |ƒS )zj
        Return a context manager that makes this input active in the current
        event loop.
        )r)   )r3   rH   r4   r4   r5   Úattach[   s   
zWin32Input.attachc                 C  s   t | ƒS )z{
        Return a context manager that makes sure that this input is not active
        in the current event loop.
        )r*   r2   r4   r4   r5   Údetachd   s   zWin32Input.detachúlist[KeyPress]c                 C  s   t | j ¡ ƒS r/   )ÚlistrE   Úreadr2   r4   r4   r5   Ú	read_keysk   ó   zWin32Input.read_keysc                 C  s
   | j  ¡ S r/   )rE   Ú
flush_keysr2   r4   r4   r5   rR   n   s   
zWin32Input.flush_keysÚboolc                 C  ó   dS ©NFr4   r2   r4   r4   r5   Úclosedq   ó   zWin32Input.closedc                 C  s   t | jd�S )N)Ú use_win10_virtual_terminal_input)r'   rC   r2   r4   r4   r5   r'   u   s   ÿzWin32Input.raw_modec                 C  s   t ƒ S r/   )r(   r2   r4   r4   r5   r(   z   s   zWin32Input.cooked_modeÚintc                 C  s
   t j ¡ S r/   )Úsysr?   Úfilenor2   r4   r4   r5   r[   }   s   
zWin32Input.filenoÚstrc                 C  rT   )Nzwin32-inputr4   r2   r4   r4   r5   Útypeahead_hash„   s   zWin32Input.typeahead_hashc                 C  s   | j  ¡  d S r/   )rE   Úcloser2   r4   r4   r5   r^   ‡   rQ   zWin32Input.closer   c                 C  s   | j jS r/   )rE   r7   r2   r4   r4   r5   r7   Š   s   zWin32Input.handler/   )r?   r@   r-   r.   )rH   rI   r-   rJ   )r-   rJ   ©r-   rM   ©r-   rS   )r-   rY   )r-   r\   r8   r9   )r:   r;   r<   r=   r6   rK   rL   rP   rR   r>   rV   r'   r(   r[   r]   r^   r7   Ú__classcell__r4   r4   rF   r5   r%   K   s     

	






r%   c                   @  sH  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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%“¥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j0“d-ej1“d.ej2“d/ej3“d0ej4“d1ej5“d2ej6“d3ej7“ej8ej9ej:ej;ej<d4œ¥Z=d5Z>d6Z?d7Z@d8ZAd9ZBdbdcd?d@„ZCdddAdB„ZDdedDdE„ZEdfdGdH„ZFdgdKdL„ZGdhdRdS„ZHeIdidUdV„ƒZJeIdjdXdY„ƒZKdkd\d]„ZLdld_d`„ZMdaS )mr&   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+   TÚrecognize_pasterS   r-   r.   c                 C  s\   d | _ || _|  tj ¡ rttj t	¡ƒ| _
d S t dtjtjB ¡| _ tt | j ¡ƒ| _
d S )NúCONIN$)Ú_fdconr›   rZ   r?   Úisattyr   r
   Úkernel32ÚGetStdHandler   r7   ÚosÚopenÚO_RDWRÚO_BINARYÚmsvcrtÚget_osfhandle)r3   r›   r4   r4   r5   r6   Ý   s   
zConsoleInputReader.__init__c                 C  ó   | j durt | j ¡ dS dS ©zClose fdcon.N©r�   r¡   r^   r2   r4   r4   r5   r^   ê   ó   
ÿzConsoleInputReader.closeúIterable[KeyPress]c           	   	   #  sN  � d}t dƒ}t| }|ƒ }tˆ jgdd�sdS tj ˆ jt|ƒ|t|ƒ¡ tˆ  	||¡ƒ}‡ fdd„|D ƒ}tˆ  
|¡ƒ}ˆ jr ˆ  |¡r t|ƒ}|D ]Q}g }|rŠt|jtƒra|jtjtjhv rŠ| |j¡ zt|ƒ}W n tyx   d}Y nw |rŠt|jtƒra|jtjtjhv sa|r–ttjd |¡ƒV  |dur�|V  qLdS |E dH  dS )úñ
        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   ©ÚtimeoutNc                   s   g | ]}ˆ   |¡‘qS r4   )Ú_insert_key_data)Ú.0Úkeyr2   r4   r5   Ú
<listcomp>  s    z+ConsoleInputReader.read.<locals>.<listcomp>Ú )r   r   r   r7   r
   rŸ   ÚReadConsoleInputWr   rN   Ú	_get_keysÚ_merge_paired_surrogatesr›   Ú	_is_pasteÚiterÚ
isinstancer²   r   ÚControlJÚControlMÚappendÚdataÚnextÚStopIterationr   ÚBracketedPasteÚjoin)	r3   Ú	max_countrO   ÚarrtypeÚinput_recordsÚall_keysÚgenÚkr¾   r4   r2   r5   rO   ï   sL   €ÿ
ÿÿù
ÿ€ïzConsoleInputReader.readrM   c                 C  s   g S r/   r4   r2   r4   r4   r5   rR   -  rW   zConsoleInputReader.flush_keysÚ	key_pressr   c                 C  s6   |j r|S t|jtƒrt |jd¡}nd}t|j|ƒS )z@
        Insert KeyPress data, for vt100 compatibility.
        r´   )r¾   rº   r²   r   r"   Úgetr   )r3   rÉ   r¾   r4   r4   r5   r°   1  s   z#ConsoleInputReader._insert_key_datarO   r   rÅ   úArray[INPUT_RECORD]úIterator[KeyPress]c                 c  sv   � t |jƒD ]2}|| }|jtv r8t|jt|j ƒ}t|tƒr+|jr+|  	|¡E dH  qt|t
ƒr8|  |¡E dH  qdS )úR
        Generator that yields `KeyPress` objects from the input records.
        N)ÚrangeÚvalueÚ	EventTyper    ÚgetattrÚEventrº   r   ÚKeyDownÚ_event_to_key_pressesr   Ú_handle_mouse)r3   rO   rÅ   ÚiÚirÚevr4   r4   r5   r¶   ?  s   €

€ðzConsoleInputReader._get_keysÚkey_pressesc                 c  s´   � d}| D ]K}t |jtƒ }|od|j  kodkn  }|o+d|j  ko)dkn  }|rH|rC|j|j  dd¡ d¡}t||ƒ}n|V  d}|rM|}q|V  q|rX|V  dS dS )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   )rÙ   Úbuffered_high_surrogater²   Úis_textÚis_high_surrogateÚis_low_surrogateÚfullcharr4   r4   r5   r·   W  s*   €
ý
ÿz+ConsoleInputReader._merge_paired_surrogatesÚkeysc                 C  sJ   d}d}| D ]}t |jtƒs|d7 }|jtjkr|d7 }q|dko$|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¼   )râ   Ú
text_countÚnewline_countrÈ   r4   r4   r5   r¸   x  s   €zConsoleInputReader._is_pasterØ   r   c                 C  s´  t |tƒr|js
J ‚d}|j}|jj}| dd¡}|dkr-|j| jv r,t	| j|j dƒ}n|| j
v rE| j
| tjkr<d}t	| j
| |ƒ}nt	||ƒ}|| j@ sT|| j@ rŠ|| j@ rŠ|rŠtjtjtjtjtjtjtjtjtjtjtjtjtjtjtjtjtj tj!i	}| "|j#|j#¡|_#|| j@ s”|| j@ rÉ|rÉtjtj$tjtj%tjtj&tjtj'tjtj(tjtj)tjtj*tj+tj,tjtj-tj tj.i
}| "|j#|j#¡|_#|| j@ �r	|�r	tj/tj0tjtj1tjtj2tjtj3tjtj4tjtj5tjtj6tjtj7tj+tj8tjtj9tj tj:i}| "|j#|j#¡|_#|| j@ �s|| j@ �r$|�r$|j;dk�r$t	tj<dƒ}|| j@ �s0|| j@ �rB|�rB|j#tjk�rBt	tj=dƒ|gS |�rX|| j>@ }|�rUt	tj=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)r3   rØ   ÚresultÚcontrol_key_stateÚu_charÚ
ascii_charÚmappingÚmeta_pressedr4   r4   r5   rÔ   Ž  s°   €
ÿ
þýûú	÷ÿþýöõþýûþýû

z(ConsoleInputReader._event_to_key_pressesr   c                 C  s´   |j }|j}d}tj}|t@ r|dkrtj}ntj}n|tkr#tj	}n|t
kr*tj}|t@ r1tj}|du r@|dkr=tj}ntj}d |j|jt|jjƒt|jjƒg¡}ttj|ƒ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Ï   r\   ÚMousePositionÚXÚYr   r   ÚWindowsMouseEvent)r3   rØ   Úevent_flagsÚbutton_stateÚ
event_typeÚbuttonr¾   r4   r4   r5   rÕ     s4   

üÿz ConsoleInputReader._handle_mouseN)T)r›   rS   r-   r.   r8   ©r-   r«   r_   )rÉ   r   r-   r   )rO   r   rÅ   rË   r-   rÌ   )rÙ   rM   r-   rÌ   )râ   rM   r-   rS   )rØ   r   r-   rM   )rØ   r   r-   rM   )Nr:   r;   r<   r=   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   r^   rO   rR   r°   r¶   Ústaticmethodr·   r¸   rÔ   rÕ   r4   r4   r4   r5   r&   �   s    ÿþýüûúùø	÷
öõôóòñðïîíìëêéèçæåäãâá à!ß%þýüûùø	÷
öõôòñðïîíìç


>

 
 r&   c                   @  sB   e Zd ZdZddd„Zddd„Zdd	d
„Zddd„Zddd„ZdS )rD   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.)
    r-   r.   c                   sn   d ˆ _ g ˆ _t‡ fdd„ƒˆ _ˆ  tj ¡ r!ttj	 
t¡ƒˆ _d S t dtjtjB ¡ˆ _ tt ˆ j ¡ƒˆ _d S )Nc                   s   ˆ j  | ¡S r/   )Ú_bufferr½   )rÉ   r2   r4   r5   Ú<lambda>T  s    z2Vt100ConsoleInputReader.__init__.<locals>.<lambda>rœ   )r�   rf  r$   Ú_vt100_parserrZ   r?   rž   r   r
   rŸ   r    r   r7   r¡   r¢   r£   r¤   r¥   r¦   r2   r4   r2   r5   r6   O  s   
ÿ
z Vt100ConsoleInputReader.__init__c                 C  r§   r¨   r©   r2   r4   r4   r5   r^   `  rª   zVt100ConsoleInputReader.closer«   c                 C  sx   d}t dƒ}t| }|ƒ }t| jgdd�sg S tj | jt|ƒ|t|ƒ¡ |  ||¡D ]}| j	 
|¡ q+| j}g | _|S )r¬   r­   r   r®   )r   r   r   r7   r
   rŸ   rµ   r   r¶   rh  Úfeedrf  )r3   rÃ   rO   rÄ   rÅ   Úkey_datar  r4   r4   r5   rO   e  s   ÿzVt100ConsoleInputReader.readrM   c                 C  s   | j  ¡  | j}g | _|S )zc
        Flush pending keys and return them.
        (Used for flushing the 'escape' key.)
        )rh  Úflushrf  )r3   r  r4   r4   r5   rR   Š  s   
z"Vt100ConsoleInputReader.flush_keysrO   r   rÅ   rË   úIterator[str]c                 c  s`   � t |jƒD ]'}|| }|jtv r-t|jt|j ƒ}t|tƒr-|jr-|j	j
}|dkr-|V  qdS )rÍ   rå   N)rÎ   rÏ   rÐ   r    rÑ   rÒ   rº   r   rÓ   ré   rê   )r3   rO   rÅ   rÖ   r×   rØ   r  r4   r4   r5   r¶   ˜  s   €
€ñz!Vt100ConsoleInputReader._get_keysNr8   r:  r_   )rO   r   rÅ   rË   r-   rl  )	r:   r;   r<   r=   r6   r^   rO   rR   r¶   r4   r4   r4   r5   rD   B  s    



%rD   c                   @  s.   e Zd ZdZddd„Zdd
d„Zddd„ZdS )r0   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`.
    r-   r.   c                 C  s   i | _ i | _d S r/   )Ú_handle_callbacksÚ_remove_eventsr2   r4   r4   r5   r6   À  s   
z_Win32Handles.__init__r7   r   ÚcallbackrI   c                   sv   ˆj }|du rtdƒ‚|  ˆ¡ tƒ ‰ˆ | j|< tƒ ‰ˆ| j|< d
‡ ‡‡fdd„‰d
‡‡‡‡fdd„‰tˆˆd	� dS )z7
        Add a Win32 handle to the event loop.
        NúInvalid handle.r-   r.   c                
     s(   zˆ ƒ  W t ˆˆd� d S t ˆˆd� w )N©Úloopr   r4   )ro  rr  Úwaitr4   r5   ÚreadyÛ  s   z-_Win32Handles.add_win32_handle.<locals>.readyc                    s2   t ˆˆ gƒ} | ˆu rtj ˆ¡ d S ˆ ˆ¡ d S r/   )r   r
   rŸ   ÚCloseHandleÚcall_soon_threadsafe)r  )r7   rr  rt  Úremove_eventr4   r5   rs  å  s
   z,_Win32Handles.add_win32_handle.<locals>.waitrq  r8   )rÏ   Ú
ValueErrorÚremove_win32_handler   rm  r   rn  r   )r3   r7   ro  Úhandle_valuer4   )ro  r7   rr  rt  rw  rs  r5   Úadd_win32_handleÇ  s   



z_Win32Handles.add_win32_handleúCallable[[], None] | Nonec                 C  sf   |j du rdS z	| j |j ¡}W n	 ty   Y nw tj |¡ z| j |j ¡W S  ty2   Y dS w )zt
        Remove a Win32 handle from the event loop.
        Return either the registered handler or `None`.
        N)rÏ   rn  ÚpopÚKeyErrorr
   rŸ   ÚSetEventrm  )r3   r7   Úeventr4   r4   r5   ry  ò  s   
ÿÿz!_Win32Handles.remove_win32_handleNr8   )r7   r   ro  rI   r-   r.   )r7   r   r-   r|  )r:   r;   r<   r=   r6   r{  ry  r4   r4   r4   r5   r0   °  s
    

+r0   Úinputro  rI   r-   úIterator[None]c              
   c  s€   � | j }| j}|jdu rtdƒ‚| |¡}| ||¡ zdV  W | |¡ |r/| ||¡ dS dS | |¡ |r?| ||¡ 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.
    Nrp  ©r1   r7   rÏ   rx  ry  r{  )r�  ro  r1   r7   Úprevious_callbackr4   r4   r5   r)     s"   €



ÿ
þÿr)   c              
   c  s`   � | j }| j}|jd u rtdƒ‚| |¡}zd V  W |r$| ||¡ d S d S |r/| ||¡ w w )Nrp  rƒ  )r�  r1   r7   r„  r4   r4   r5   r*   %  s   €

ÿÿr*   c                   @  s<   e Zd ZdZ	ddd
d„Zddd„Zddd„Zddd„ZdS )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`.
    NFr[   ú
int | NonerX   rS   r-   r.   c                 C  s   t tj t¡ƒ| _|| _d S r/   )r   r
   rŸ   r    r   r7   rX   )r3   r[   rX   r4   r4   r5   r6   A  s   
zraw_mode.__init__c                 C  s,   t ƒ }tj | jt|ƒ¡ || _|  ¡  d S r/   )r   r
   rŸ   ÚGetConsoleModer7   r   Úoriginal_modeÚ_patch)r3   r‡  r4   r4   r5   Ú	__enter__G  s   zraw_mode.__enter__c                 C  sD   d}d}d}| j j||B |B  @ }| jr|tO }tj | j|¡ d S ©Nr+   r   r!   )r‡  rÏ   rX   ÚENABLE_VIRTUAL_TERMINAL_INPUTr
   rŸ   ÚSetConsoleModer7   )r3   ÚENABLE_ECHO_INPUTÚENABLE_LINE_INPUTÚENABLE_PROCESSED_INPUTÚnew_moder4   r4   r5   rˆ  O  s   
ÿzraw_mode._patchÚaÚobjectc                 G  s   t j | j| j¡ d S r/   )r
   rŸ   rŒ  r7   r‡  )r3   r‘  r4   r4   r5   Ú__exit__^  s   zraw_mode.__exit__rU   )r[   r…  rX   rS   r-   r.   r8   )r‘  r’  r-   r.   )r:   r;   r<   r=   r6   r‰  rˆ  r“  r4   r4   r4   r5   r'   6  s    ÿ

r'   c                   @  s   e Zd ZdZddd„ZdS )r(   zx
    ::

        with cooked_mode(stdin):
            ''' The pseudo-terminal stdin is now used in cooked mode. '''
    r-   r.   c                 C  s0   d}d}d}t j | j| jj||B |B B ¡ d S rŠ  )r
   rŸ   rŒ  r7   r‡  rÏ   )r3   r�  rŽ  r�  r4   r4   r5   rˆ  k  s   
ÿþzcooked_mode._patchNr8   )r:   r;   r<   r=   rˆ  r4   r4   r4   r5   r(   c  s    r(   rS   c               
   C  sf   t tj t¡ƒ} tdƒ}tj | t|ƒ¡ ztj | tt	ƒ¡}|dkW tj | |¡ S tj | |¡ 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  r4   r4   r5   rB   x  s   ÿ rB   )r�  r,   ro  rI   r-   r‚  )r�  r,   r-   r‚  r`   )EÚ
__future__r   r¡   rZ   Úabcr   Úasyncior   Ú
contextlibr   r   Úutilsr   Úplatformr¥   Úctypesr
   Úcollections.abcr   r   r   r   r   r   Úctypes.wintypesr   r   Útypingr   Ú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.  r'  r‹  r,   r%   r&   rD   r0   r)   r*   r'   r(   rB   r4   r4   r4   r5   Ú<module>   sZ    D   6nX-