Ë

����†£éfšÁ��ã�������������������óX��—�d�Z�ddlmZ�ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZ	�ddl
mZ�ddlmZ�dZ�ed¬«������d„�«�������Zd0d	„Zd
„�Zd„�Zd0d„Zd
„�Zd„�Z�ed¬«������d„�«�������Zd0d„Z�ed¬«������d„�«�������Z�ed¬«������d„�«�������Z�ed¬«������d„�«�������Zd„�Zd„�Z d0d„Z!	�d0d„Z"dZ#dZ$e#e$z���Z%dZ&dZ'dZ(dZ)dZ*g�d¢Z+g�d¢Z,g�d ¢Z-g�d!¢Z.d"gZ/�ed¬«������d#„�«�������Z0d$„�Z1d%„�Z2d0d&„Z3d'„�Z4	�d0d(„Z5d0d)„Z6d*„�Z7d1d+„Z8d,„�Z9d-„�Z:d.„�Z;e<d/k(��r�e;«��������yy#�e$�r	�ddlmZ�Y�Œðw�xY�w)2zr yasi

Date: 20th November 2013
Author: nkmathew <kipkoechmathew@gmail.com>

Dialect aware s-expression indenter

é����)Úprint_functionN)Ú	lru_cache)Úpprintz2.1.2)Úmaxsizec������������
������óP��—�t��������j������������������dd¬«������}�|�j������������������ddd¬«�������|�j������������������dd	d
ddd
¬«�������|�j������������������ddddd
d¬«�������|�j������������������dddddd
¬«�������|�j������������������ddddd¬«�������|�j������������������dd d!d"d#d
¬«�������|�j������������������d$d%d&d'd(d
¬«�������|�j������������������d)d*d+d,d
¬«�������|�j������������������d-d.d/d0d1d¬«�������|�j������������������d2d3d4d5d
d6¬«�������|�j������������������d7d8d9t��������d:¬;«�������|�j������������������d<d=d>d?t��������d@¬;«�������|�j������������������dAdBdCt��������d:¬D«�������|�j������������������dEdFdGdHdIt
��������z��¬J«�������|�j������������������dKdLdMdNt��������dO¬;«�������|�j������������������dPdQdRdSdTt��������t
��������j������������������«�������¬D«�������|�j������������������dUdVdWdXt��������dY¬D«�������|�j������������������dZd[d\d]t��������d^¬D«�������|�j������������������d_d`dadbd¬c«�������|�j������������������dddedfdgdhd¬c«�������|�j������������������didjdkd¬c«�������|�S�)lz Return command line parser z#Dialect-aware s-expression indenterÚyasi)ÚdescriptionÚprogÚfileszWList of files to be indented. Will indent from standard input if no files are specifiedÚ*)ÚhelpÚnargsz-ncz--no-compactz--ncÚcompactz$Do not compact the code, just indentÚstore_false)Údestr
���Úactionz-nbz--no-backupz--nbÚbackupz>Do not create a backup file even if --backup-dir is specified )r���r���r
���z-nmz--no-modifyz--nmÚmodifyzDo not modify the filez--diffz-diffÚoutput_diffz3Prints unified diff of the initial and final resultÚ
store_truez-nwz--no-warningz--nwÚwarningzDo not display warningsz-nrz--no-rcz--nrÚread_rcz1Ignore any rc files in the current or home folderz--no-outputz
-no-outputÚoutputz$Suppress output of the indented codez-cz--colorz-colorÚcolour_diffzDisplay diff text in colorz-nez	--no-exitz--neÚexitz;Instructs the program not to exit when a warning is raised.z-oÚoutput_filezPath/name of output fileÚ�)r���r
���ÚtypeÚdefaultz--tabz-tabÚtab_sizezŽIndent with tabs using the specified tabwidth. A tab is assumed         equal to 4 spaces by default when expanding the tabs in the input fileéÿÿÿÿz	--dialectz-dialectzUse Scheme keywords)r
���r���r���z-vz	--versionÚversionzPrints script versionzyasi v%s)r���r
���r"���z-suffixz--suffixÚ
backup_suffixzBackup file suffixz
.yasi.bak~z-bdz--backup-dirz--bdz-backup-dirz4The directory where the backup file is to be writtenz-isz
--indent-sizez--iszThe number of spaces per indent��z-diz--default-indentz--dizsThe indent level to be used in case a function's argument is in the next line. Vim uses 2, the most common being 1.��z-icz--indent-commentsz--icz[If true, comment lines will be indented possibly messing with any deliberate comment layout)r
���r���z-uniz	--uniformz-uniformz--unizdDictates whether the if-clause and else-clause of an if-likeblock should have the same indent level.z	-parallelz
--parallelz#Process the given files in parallel)ÚargparseÚArgumentParserÚadd_argumentÚstrÚintÚ__version__ÚosÚgetcwd)Úparsers��� úM/var/lib/jenkins/workspace/mettalog/venv/lib/python3.12/site-packages/yasi.pyÚcreate_args_parserr0���%���s��€�ô�×
$Ñ
$Ø9ÀôH€Fà
×јð�'Tà!ð�ô�#ð�×ÑØ
ˆ~˜v¨IØ
3¸Mð�ô�Kð�×ÑØ
ˆ}˜f¨8¸MØ
Mð�ô�Oð�×ÑØ
ˆ}˜f¨8Ø
%¨mð�ô�=ð�×Ñؐ' 
Ø
BØð�ô�ð�×ÑØ
ˆ~˜v¨IØ
&¨}ð�ô�>ð�×ÑØ
ˆy˜& yØ
@Øð�ô�ð�×Ñؐ|¨(Ø
3¸Mð�ô�Kð�×ÑØˆi˜¨
Ø
)°,ð�ô�@ð�×ÑØ
ˆ{˜F¨¸
Ø
Jð�ô�Lð�×ÑØ=Ø
'¬c¸2ð�ô�?ð�×Ñؐ˜jðPä
˜"ð	�ô�ð
�×ÑؐZØ
"¬°bð�ô�:ð�×ÑØˆk )Ø
$¨j¼;Ñ.Fð�ô�Hð�×Ñؐ: OÐ:NÜ
˜,ð�ô�(ð�×ÑØ
ˆ~˜v }Ø
CÜ
œ"Ÿ)™)›+ð�ô�'ð�×ÑØ
ˆ Ø
.Ü
˜!ð�ô�ð�×ÑØ
Ð! 6ðXä
˜!ð	�ô�ð
�×ÑØ
Ð" Fð5Ø=Ið�ô�Kð�×Ñؐ˜Z¨ð3àð	�ô�ð
�×Ñؐ\Ø
2Øð�ô�ð�€Mó����c�����������������ó��—�|�€t���������j������������������dd�}�t��������|�t��������«������r|�j	������������������«�������}�t��������|�t
��������j������������������«������r|�S�t��������«�������}|j������������������|�«������}|j������������������j������������������«�������|_	��������|j������������������dvr*|j������������������dj������������������|j������������������«������«�������t��������j������������������j������������������|j ������������������«������|_��������t��������j������������������j#������������������|j ������������������«������s*|j������������������dj������������������|j ������������������«������«�������t%��������|j&������������������«������dkD��r|j(������������������r|j������������������d«�������|j&������������������s-|j*������������������r|j(������������������sd|_��������d|_��������d|_��������|j0������������������rd|_��������|S�)zK Reads command-line arguments

    >>> parse_args('--indent-comments')
    Nr%���)ÚlispÚnewlispÚclojureÚschemeÚallr���z!`{0}' is not a recognized dialectzDirectory `{0}' does not existz;Cannot use the -o flag when more than one file is specifiedF)ÚsysÚargvÚ
isinstancer)���Úsplitr&���Ú	Namespacer0���Ú
parse_argsÚdialectÚlowerÚerrorÚformatr,���ÚpathÚ
expanduserÚ
backup_dirÚexistsÚlenr���r���r���r���r���r���)Ú	argumentsr.���Úargss���   r/���r=���r=���x���sK��€�ð
�ÐÜ—H‘H˜Q˜RLˆ	ܐ)œSÔ!Ø—O‘OÓ%ˆ	ܐ)œX×/Ñ/Ô0ØÐÜ
Ó
!€FØ×јYÓ'€Dà—<‘<×%Ñ%Ó'€D„L؇||ÐNÑN؏‰Ð8×?Ñ?ÀÇÁÓMÔNä—g‘g×(Ñ(¨¯©Ó9€D„OÜ
7‰7>‰>˜$Ÿ/™/Ô*؏‰Ð5×<Ñ<¸T¿_¹_ÓMÔNä
ˆ4:‰:ƒ˜Ò˜t×/Ò/؏‰ÐRÔSà:Š:à;Š;˜t×/Ò/؈DŒK؈ŒØˆŒà×Òð�ˆŒà€Kr1���c�����������������óî���—�t���������j������������������j������������������|�«������sJ�dt��������«�������›d|�›d«�������‚t	��������|�d«������5�}|j������������������«�������j
������������������d«������cddd«�������S�#�1�sw�Y���yxY�w)aT�� read_file(fname : str) -> str

    >>> read_file(r'C:\mine\test.lisp')
    r'(print "No, no, there's \r\nlife in him!. ")\r\n\r\n'

    The file is read in binary mode in order to preserve original line endings.
        Line ending    Binary mode Text mode
            CRLF            CRLF    LF
            CR              CR      LF
    ú
--ú-- Warning: File `ú' does not exist...Úrbzutf-8N)r,���rB���rE���Úcurrent_timeÚopenÚreadÚdecode)ÚfnameÚfps���  r/���Ú	read_filerT��� ���sb���€�ô�7‰7>‰>˜%Ô ñ�"܍>š5ð#"ó�"Ð ä	
ˆeTÓ	ð�)˜b؏w‰w‹y×Ñ Ó(÷)÷�)ò�)ús���ÁA+Á+A4c������������������óR���—�t��������j������������������dt��������j������������������«�������«������S�)zx current_time() -> str

    >>> current_time()
    14:28:04

    Returns the current local time in 24 clock system.
    z%X)ÚtimeÚstrftimeÚ	localtime©�r1���r/���rN���rN���±���s���€�ô�=‰=˜¤§¡Ó 0Ó2Ð2r1���c�����������������ót��—�t��������|«������}|j������������������}t��������j������������������j	������������������|�«������sJ�dt��������«�������›d|�›d«�������‚t��������j������������������j	������������������t��������j������������������j
������������������|«������«������sJ�dt��������«�������›d|�›d«�������‚|t��������j������������������z���t��������j������������������j������������������|�«������d���z���|j������������������z���}	�t��������j������������������|�|«�������y#�t��������$�r4�d}t��������«�������|�|f}t��������j������������������j������������������||z��«�������Y�yw�xY�w)z‹ backup_source_file(fname : str)

    >>> backup_source_file('~/Desktop/lisp/test.lisp')

    Create a backup copy of the source file.
    rJ���rK���rL���z-- Warning: Directory `r%���z^
--%s-- Warning: Couldn't backup the file `%s' in `%s', check if you have enough permissions. N)r=���rD���r,���rB���rE���rN���ÚabspathÚsepr;���r#���ÚshutilÚcopyfileÚIOErrorr8���ÚstderrÚwrite)rR���rH���rD���Úbackup_nameÚmessageÚtpls���      r/���Úbackup_source_filere���¼���sò���€�ô�dÓ€DØ—‘€JÜ
7‰7>‰>˜%Ô ñ�TÜ<H½NÊEÐ	RóTÐ ä
7‰7>‰>œ"Ÿ'™'Ÿ/™/¨*Ó5Ô6ñ�YÜAMÅÒQVÐ	WóYÐ6àœrŸv™vÑ%¬¯©¯
©
°eÓ(<¸QÑ(?Ñ?À$×BTÑBTÑT€Kð(܏‰˜˜{Õ+øÜò�(ØsˆÜ‹~˜u jÐ1ˆÜ
‰
×ј 3™Ö'ð(ús���Ã#C:�Ã::D7Ä6D7c�����������������óH���—�t��������j������������������|�«������j������������������«�������S�)a
�� md5sum(content : str) -> str

    >>> md5sum('Keyboard not found!! Press F1 to continue...')
    'ad98cde09016d2e99a726966a4291acf'

    Returns a checksum to be used to determine whether the file has changed.
    A simple textual comparison can still do the work
    )ÚhashlibÚmd5Ú	hexdigest)Úcontents��� r/���Úmd5sumrk���Ò���s���€�ô�;‰;wÓ×)Ñ)Ó+Ð+r1���c�����������������óF���—�t���������|�v�rt���������S�t��������|�v�rt��������S�t��������S�)z¸ find_line_ending(string : str) -> str

    >>> find_line_ending('Elementary my dear Watson. \r')
    '\r'

    Find the line ending in the file so that we can try to preserve it.
    )ÚCRLFÚCRÚLF©Ústrings��� r/���Úfind_line_endingrr���Þ���s!���€�ô�ˆv~܈Ü	ˆV|܈	Ü
€Ir1���c�����������������óz��—�t��������j������������������dd|�«������}�t��������j������������������dd|�t���������j������������������«������}�t��������j������������������dd|�«������}�t��������j������������������dd|�«������}�t��������j������������������dd	|�«������}�t��������j������������������d
d|�«������}�t��������j������������������dd|�«������}�t��������j������������������dd|�«������}�t��������j������������������d
d|�«������}�t��������j������������������dd|�«������}�t��������j������������������dd|�«������}�t��������j������������������dd|�«������}�t��������j������������������dd|�«������}�|�S�)z‹ trim(string : str) -> str

    Uses every usefull hack to try and reduce extra whitespace without
    messing with character literals
    z[ 	]*$r���z([^\\(\[, {@~`'#^])(\(|\[|{)z\1 \2z(\)|\]|})(\[|\(|{)z[ 	]*(\)|\]|})z\1z[ 	]{2,}ú z(\))[ \t]*(?=(\)))z(\])[ \t]*(?=(\]))z(})[ \t]*(?=(}))z(\()[ \t]*(?=(\())z(\[)[ \t]*(?=(\[))z({)[ \t]*(?=({))ú^[ 	]*z('|`)[ 	]+(\(|\[|{)z\1\2)ÚreÚsubÚXrp���s��� r/���Útrimry���í���s��€�ô�V‰VI˜r 6Ó
*€Fä
V‰VÐ7¸À6Ì2Ï4É4Ó
P€Fä
V‰VÐ)¨8°VÓ
<€Fä
V‰VÐ% u¨fÓ
5€Fä
V‰VK  fÓ
-€Fä
V‰VÐ)¨5°&Ó
9€FÜ
V‰VÐ)¨5°&Ó
9€FÜ
V‰VÐ'¨°Ó
7€Fä
V‰VÐ)¨5°&Ó
9€FÜ
V‰VÐ)¨5°&Ó
9€FÜ
V‰VÐ'¨°Ó
7€Fä
V‰VI˜r 6Ó
*€Fä
V‰VÐ*¨G°VÓ
<€FØ€Mr1���c�����������������ó–��—�t��������|«������}t��������j������������������d|�«������}t��������j������������������d|�«������}|r|j������������������«�������nd}|r|j������������������«�������nd}|dk7��r$t��������j������������������d|�«������j	������������������«�������}|j
������������������dk(��r{t��������j������������������d|�«������}t��������j������������������d|�«������}|r|j������������������«�������nd}|r|j������������������«�������nd}|||g}|D�cg�c]
��}|dk7��sŒ	|‘Œ�}}|rt
��������|«������}|dk7��r|dk7��r	||k��r|}|S�|dk7��r	|dk(��r|}|S�|dk(��rt��������|�«������}|S�c�c}w�)a$�� find_trim_limit(string : str) -> int

    >>> find_trim_limit(r'(list #\; #")')
    14
    >>> find_trim_limit(r'(list ; ")')
    6
    >>> find_trim_limit(r'(list " ;)')
    7

    The function attempts to identify upto which point we are supposed to trim
    so that we don't mess with strings or any aligned comments.

    It does this by comparing the positions of semicolons and double
    quotes. It doesn't consider the multiline comment marker. If your
    code uses multiline comments(#| ... |#), you'll have to use --no-compact mode
    z
([^\\];)|(^;)z
([^\\]")|(^")r!���z[ 	]*;r4���ú{ú\[text\])r=���rv���ÚsearchÚendÚstartr>���ÚminrF���)	rq���rH���Ú
comment_startÚstring_startÚlimitÚbrace_string_startÚtag_string_startÚpos_lstÚxs	���         r/���Úfind_trim_limitrˆ���
��sa��€�ô"�dÓ€Dä—I‘IÐ.°Ó7€Mä—9‘9Ð-¨vÓ6€Lá".ˆL×ÑÔ°B€EÙ+8M×%Ñ%Ô'¸b€MؘÒô�Ÿ	™	 )¨VÓ4×:Ñ:Ó<ˆ
à‡||yÒ äŸY™Y s¨FÓ3ÐÜŸ9™9 Z°Ó8ÐÙ9KÐ/×3Ñ3Ô5ÐQSÐÙ5EÐ+×/Ñ/Ô1È2ÐØÐ,Ð.>Ð?ˆØ%Ö1˜¨¨b«’1Ð1ˆÐ1Ùܘ“LˆEà˜Ò˜u¨š{ؘ5Ò ð�"ˆEð�€Lð�
˜"Ò	 ¨"¢ð�ˆð
�€Lð	�
"Šô�F“ˆØ€Lùò#�2s���Ã5
EÄ�Ec�����������������ó���—�|�sy|dk(��r%t��������j������������������d|�t���������j������������������«������S�|dk(��rt��������j������������������d|�«������S�|dk(��rt��������j������������������d|�«������S�|dk(��rt��������j������������������d	|�«������S�y)
ap�� is_macro_name(func_name : str, dialect : str) -> bool

    >>> is_macro_name('yacc:define-parser')
    True

    Tests if a word is a macro using the language's/dialect's convention,
    e.g macros in Lisp usually start with 'def' and 'with' in Scheme. Saves
    the effort of finding all the macros in Lisp/Scheme/Clojure/newLISP and storing
    them in a list.
    Fr3���z^(macro|def|do|with-)r6���z^(call-|def|with-)r5���z^(def|with)r4���z^(macro|def))rv���r}���ÚI)Ú	func_namer>���s���  r/���Ú
is_macro_namerŒ���F��sy���€�ñ�Øؐ&Ò܏y‰yÐ0°)¼R¿T¹TÓBÐBؐ(Ò܏y‰yÐ-¨yÓ9Ð9ؐ)Ò܏y‰y˜¨	Ó2Ð2ؐ)Ò܏y‰y˜¨Ó3Ð3Ør1���c�����������������óÌ���—�|�j������������������|«������}|d���dk(��r|d=�|D�cg�c]��}||z���‘Œ	�}}|S�|D�cg�c]��}||z���‘Œ	�}}|d���j������������������|«������|d<���|S�c�c}w�c�c}w�)aö�� split_preserve(string : str, sep : str)  -> [str]

    >>> split_preserve('''
    "My dear Holmes, " said I, "this is too much. You would certainly
    have been burned, had you lived a few centuries ago.
                ''', '\n')
    ['\n',
     '    "My dear Holmes, " said I, "this is too much. You would certainly\n',
     '    have been burned, had you lived a few centuries ago.\n',
     '                ']

    Splits the string and sticks the separator back to every string in the list.
    r!���r���)r;���Úrstrip)rq���r\���Ústr_listr‡���s���    r/���Úsplit_preserver���_��s…���€�ð �|‰|˜CÓ €Hؐ|rÒð
�
RˆLØ%-Ö. A˜“GÐ.ˆÐ.ð�€Oð�*2Ö2 A˜˜C›Ð2ˆÐ2Ø ‘|×*Ñ*¨3Ó/ˆ‰Ø€Oùò�/ùò
�3s
���¡AµA!c�����������������ó.���—�t��������j������������������d|�«������S�)zˆ all_whitespace(string : str) -> bool

    >>> all_whitespace('      ')
    True

    Returns True if a string has only whitespace.
    z
^[ 	]*(
|
|$))rv���r}���rp���s��� r/���Úall_whitespacer’���€��s���€�ô�9‰9Ð'¨Ó0Ð0r1���c�����������������óŽ���—�t��������|«������}|j������������������dk��r|�j������������������d«������S�|�j������������������|j������������������«������S�)zP tabify(text : str, args : argparse.Namespace|str) -> str

    Expands tabs
    r%���é���)r=���r ���Ú
expandtabs)ÚtextrH���s���  r/���Údetabifyr—���Œ��s<���€�ô
�dÓ€D؇}}qÒ؏‰˜qÓ!Ð!؏?‰?˜4Ÿ=™=Ó)Ð)r1���c�����������������ó|���—�t��������|«������}|j������������������dk��r|�S�d|j������������������z��}|�j������������������|d«������S�)z½ tabify(text : str, args : argparse.Namespace|str) -> str

    >>> tabify('        (println "hello world")', '--tab=3')
     '		  (println "hello world")'

    Replace spaces with tabs
    r%���rt���ú	)r=���r ���Úreplace)r–���rH���Ú	tab_equivs���   r/���Útabifyrœ���—��s>���€�ô�dÓ€D؇}}qÒ؈ؐd—m‘mÑ#€I؏<‰<˜	 4Ó(Ð(r1���c�����������������ó~��—�t��������|«������}|j������������������rjt��������|�|«������}t��������j������������������d|�t��������j
������������������«������}|r|j������������������r|j������������������«�������}|�d|�}|�|d�}t��������|«������}||z���}�nt��������j������������������dd|�d¬«������}�|}|r|d���d���}d	|z��}	t��������|	|«������}	|	|�z���|fS�)
a&�� pad_leading_whitespace(string : str, current_level : int,
                               zero_level : int) -> str

    >>> pad_leading_whitespace("(print 'Yello)")
    "         (print 'Yello)"

    Takes a string and indents it using the current indentation level
    and the zero level.
    ú^[ 	]*;r���Nz^[ 	]+r���)Úcountr!���Úindent_levelrt���)r=���r���rˆ���rv���r}���ÚMÚindent_commentsr~���ry���rw���rœ���)
rq���Ú
zero_levelÚblistrH���Ú
trim_limitÚcomment_lineÚsubstr1Úsubstr2r ���Úpaddings
���          r/���Úpad_leading_whitespacerª���¦��sÏ���€�ô�dÓ€D؇|‚|ô�% V¨TÓ2ˆ
Ü—y‘y ¨V´R·T±TÓ:ˆÙ˜D×0Ò0Ø%×)Ñ)Ó+ˆJؘ˜:Ð&ˆØ˜˜Ð%ˆÜw“-ˆØ˜7Ñ"‰ô�—‘˜	 2 v°QÔ7ˆà€LÙؘR‘y Ñ0ˆàLÑ €GܐW˜dÓ#€GؐVј\Ð)Ð)r1���c�����������������óv��—�t��������|«������}t��������j������������������d|t��������j������������������«������}|j������������������rd}|j
������������������sA|g�k(��r<|s:t
��������||«������}t��������j������������������d|«������}|r|j������������������«�������dz
��}�nd}�|r|�|dfS�|s!t��������|«������st��������||�||«������\��}	}
|�|	|
fS�|�|dfS�)a�� indent_line(zerolevel : int, bracket_list : list, line : str, in_comment : bool,
                    in_symbol_region : bool, args : string|list)

    Most important function in the indentation process. It uses the bracket
    locations stored in the list to indent the line.
    rž���Fz^[ 	]+[^; )

]r%���r���)
r=���rv���r}���r¡���r¢���r���r—���r~���r’���rª���)Ú	zerolevelÚbracket_listÚlineÚ
in_commentÚin_symbol_regionrH���r¦���Ú_lineÚleading_spacesÚ	curr_lineÚ
current_levels���           r/���Úindent_linerµ���É��sÍ���€�ô�dÓ€DÜ—9‘9˜Z¨¬r¯t©tÓ4€LØ×Òàˆ؏<Š<˜L¨BÒ.±zô�˜˜tÓ$ˆÜŸ™Ð#6¸Ó>ˆÙð�'×*Ñ*Ó,¨qÑ0‰IàˆIáà˜$ Ð!Ð!Ù¤¨tÔ 4ô�$:¸$À	Ø:FÈó$NÑ ˆ	=à˜) ]Ð2Ð2ؐd˜AÐÐr1���ú
ú
r%���r$���é���r”���)+Údefinez
local-odd?ÚwhenÚbeginÚcasezlocal-even?Údoz call-with-bytevector-output-portzcall-with-input-fileúcall-with-portzcall-with-current-continuationzopen-file-input-portr¾���zcall-with-valueszcall-with-output-filezcall-with-string-output-portz
define-syntaxÚifÚletúlet*ÚlibraryÚunlessÚlambdazsyntax-ruleszsyntax-casez
let-syntaxzletrec*Úletrecz
let-valueszlet*-valueszwith-exception-handlerzwith-input-from-filezwith-interrupts-disabledúwith-input-from-stringzwith-output-to-filezwith-input-from-portúwith-output-to-stringzwith-source-pathzwith-syntaxz
with-implicitzwith-error-handlerÚmoduleÚparameterize)%ÚdefnÚfnÚdorunÚdoseqÚlooprº���rÀ���ÚdefmacroÚbindingÚdotoÚnsz:importÚ	defstructÚcondpÚcommentrº���zwhen-letz->z->>zextend-typeÚreifyrÐ���zwhen-notÚproxyÚdotimesÚtryÚfinallyÚforÚletfnÚcatchÚiterateÚwhilezwith-local-varsÚlockingÚdefmultiÚ	defmethodÚextend)3z:implementationz:methodr¼���ÚdefclassÚdefconstantÚ
defgenericÚdefimplementationzdefine-conditionzdefine-implementation-packageÚdefinterfacerÏ���râ���Ú
defpackageÚ
defprojectÚdeftypeÚdefunÚdefvarzdo-external-symbolsÚdolistrØ���ÚecaseÚ	etypecaseÚfletzhandler-bindr¿���rÄ���rÀ���rÁ���zprint-unreadable-objectÚmacroletÚdefparameterú
with-slotsÚtypecaserÎ���rº���Úprog1rÃ���zwith-open-filerÇ���rÆ���Úblockzhandler-caserÓ���z	eval-whenÚtagbodyz
ignore-errorsÚlabelsúmultiple-value-bindÚprognzunwind-protectÚcollect)rß���r¿���r¼���rØ���r¹���rî���rÝ���ÚthrowrÄ���zlambda-macrorº���rÃ���Úletexr»���ÚdostringrÀ���ÚletnÚdoargsúdefine-macroÚuntilzdo-untilzdo-whilezfor-allzfind-allrÛ���r¿���c������������������óØ��—�d}�t���������j������������������j������������������d|�z���«������}t���������j������������������j������������������|�«������r t���������j������������������j	������������������|�«������}n!t���������j������������������j������������������|«������sd}d}|r$t��������|«������5�}|j
������������������«�������}ddd«�������i�}|rt��������j������������������|«������}t��������j������������������t��������|«������S�#�1�sw�Y���Œ<xY�w)z_ Reads the json configuration file(.yasirc.json), parses it and returns the
    dictionary
    z.yasirc.jsonz~/r���N)r,���rB���rC���rE���r[���rO���rP���ÚjsonÚloadsÚcollectionsÚdefaultdictÚdict)rR���rB���rj���ÚfÚrets���     r/���Ú
parse_rc_jsonr��3��s²���€�ð
�
€EÜ
7‰7×јd U™lÓ+€DÜ	‡ww‡~~eÔ܏w‰w‰˜uÓ%‰Ü
W‰W^‰^˜DÔ
!؈؀GÙÜ
$‹Zð�	˜1Ø—f‘f“hˆG÷	à
€CÙ܏j‰j˜Ó!ˆÜ×"Ñ"¤4¨Ó-Ð-÷	ð�	ús���ÂC à C)c�����������������ó���—�|�D�]��}|||<���Œ	�|S�)zB Associate keywords with their respective indentation numbers
    rY���)ÚlstÚinumÚdicÚis���    r/���Úassign_indent_numbersr��H��s���€�ó�ˆØˆˆAŠð�à€Jr1���c�����������������ó��—�|�j�������������������}t��������j������������������t��������«������}g�}t��������}g�}|dk(��rt
��������}|g�d¢z
��}|g�d¢z
��}ne|dk(��rt��������}|g�d¢z
��}|g�z
��}nM|dk(��rt��������}|g�z
��}|dgz
��}n6|dk(��rt��������}|g�z
��}|g�z
��}n |d	k(��rt
��������t��������z���t��������z���t��������z���}t��������|t��������|«������}t��������|t��������|«������}t��������|t��������|«������}|�j������������������rt��������«�������}|j������������������||���«�������|S�)
zà add_keywords(dialect : str) -> [str, str]

    Takes a lisp dialect name and returns a list of keywords that increase
    indentation by two spaces and those that can be one-armed like 'if'
    r3���)rú���zdestructuring-bindr½���údo*)rñ���rò���rù���r6���)rô���r½���r��r5���rÜ���r4���r7���)r>���r��r��r*���ÚIF_LIKEÚ
LISP_KEYWORDSÚSCHEME_KEYWORDSÚCLOJURE_KEYWORDSÚNEWLISP_KEYWORDSr��ÚKEYWORD1ÚKEYWORD2ÚKEYWORD4r���r��Úupdate)rH���r>���ÚkeywordsÚtwo_spacersÚ	two_armedÚ
local_bindersÚrc_keywordss���       r/���Úadd_keywordsr#��P��s!��€�ð�l‰l€GÜ×&Ñ&¤sÓ+€HØ€KÜ€IØ€Mؐ&ÒÜ#ˆØÒOÑOˆ	ØÒ7Ñ7‰
Ø	HÒ	Ü%ˆØÒ0Ñ0ˆ	ؘщ
Ø	IÒ	Ü&ˆØR‰ˆ	ؘ'˜Ñ"‰
Ø	IÒ	Ü&ˆØR‰ˆ	ؘщ
Ø	EÒ	Ü#¤oÑ5Ô8HÑHÜñˆä$ [´(¸HÓE€HÜ$ Y´¸(ÓC€HÜ$ ]´H¸hÓG€H؇|‚|Ü#“oˆØ‰˜ GÑ,Ô-Ø€Or1���c�����������������ó��—�t��������|«������}d}||�dz���d�}t��������j������������������d|«������rd}||gS�|�t��������|«������dz
��k7��rØ||�dz������dk(��rÍt��������j������������������d|«������}|r5|j	������������������«�������|j������������������«�������z
��dz
��}|j	������������������«�������}nd}t��������j������������������d||d�«������}|r|j	������������������«�������|z���dz���}n|dz���}t��������j������������������d||dz
��||dz
��d�j������������������d«������z���d�«������r||j������������������z���}||gS�t��������j������������������d	|«������}|r|j	������������������«�������}nd}t��������j������������������d
||j������������������d«������d�«������r||j������������������z���}||gS�)a™�� find_first_arg_pos(bracket_offset : int, curr_line : str) -> [int, int]

    Arguments:
    bracket_offset - The position of the bracket in the current line e.g
        "    (  list 'timey 'wimey  )" --> 4
        " (  list 'timey 'wimey  )"    --> 1
        "(  list 'timey 'wimey  )"     --> 0

    >>> find_first_arg_pos(0, "(     list 'one-sheep 'two-sheep )")
    [11, 5]

    Returns the position of the first argument to the function relative to the
    position of the opening bracket and the number of spaces between the opening
    bracket and the function name.
    The two values will to be used to align the other arguments in the subsequent line
    r���r%���Nz^[ 	]*($|
)rt���z +[^)\]]| \)z +([^)])|( *(\(|\[))z^[ 	]*(#\||;|$|
)z +([^)}

])|( *(\(|\[|{))z
^[	 ]*(;|$|
))	r=���rv���r}���rF���r~���r���ÚmatchÚfindÚdefault_indent)Úbracket_offsetr³���rH���Úspaces_before_funcÚsublineÚarg_posr%��r~���s���        r/���Úfind_first_arg_posr,��y��s©��€�ô"�dÓ€DØÐؘ¨Ñ*Ð+Ð,€GÜ	‡yy 'Ô*ð�ˆðF�
Ð'Ð(Ð(ðC�œS ›^¨aÑ/Ò/°I¸nÈqÑ>PÑ4QÐUXÒ4Xô�—I‘I˜n¨gÓ6ˆEÙØ%*§Y¡Y£[°5·;±;³=Ñ%@À1Ñ%DÐ"Ø—i‘i“k‘àä—i‘iÐ 6¸ÀÀ¸
ÓFˆGÙØ!Ÿ+™+›-Ð*<Ñ<¸qÑ@‘à,¨qÑ0Üx‰xÐ-Ø  q¡¨7°3¸±7°8Ð+<×+AÑ+AÀ#Ó+FÑ!FÐ HÐIôKð�-¨t×/BÑ/BÑBð�
Ð'Ð(Ð(ô�—I‘IÐ;¸WÓEˆEÙØŸ)™)›+‘àÜx‰xÐ)¨7°7·<±<ÀÓ3DÐ3EÐ+FÔGð�-¨t×/BÑ/BÑBØÐ'Ð(Ð(r1���c�����������������ó���—�|�dk(��rd}n
|�dk(��rd}nd}|g�k7��rG|j������������������«�������}|d���}|d���}	|d���}
||ur"d	}||�||	|
fz��}|||d
œ}|j������������������|«�������|S�d|�z��}|||dz���d
œ}|j������������������|«�������|S�)
a�� _pop_from_list(char : str, lst : [str], line : str,
                        real_pos : int, offset : int)

    The function is called when a closing bracket is encountered. The function
    simply pops the last pushed item and issues a warning if an error is
    encountered.
    ú]ú[ú)ú(r{���Ú	characterÚline_numberÚbracket_posz,Bracket `%s' does not match `%s' at (%d, %d)©Úmsgr®���ÚcolumnzUnmatched closing bracket `%s'r%���)ÚpopÚappend)
Úbracketr��r®���Úreal_posÚoffsetÚ	msg_stackÚcorrect_closerÚpoppedÚpopped_charÚ
popped_posÚ
popped_offsetrc���Úwarning_infos
���             r/���Ú_pop_from_listrD��¶��sÍ���€�ð�#‚~؉Ø	CŠØ‰àˆØ
ˆb‚yØ—‘“ˆØ˜[Ñ)ˆØ˜MÑ*ˆ
ؘ}Ñ-ˆ
ؘnÑ,ØDˆGØ ¨+°zÀ=Ð QÑQˆGàØØ"ñˆLð
�
×Ñ˜\Ô*ð�€Jð�3°WÑ<ˆàØؘq‘jñ
ˆð
�	×јÔ&Ø€Jr1���c
�����������������ó¶��—�t��������|	«������}	t��������|	«������}
|||||z���|ddœ}t��������||	j������������������«������}|xs�|
|���t��������t
��������fv�}
|s|dk(��s|dk(��r|	j������������������dk(��r||d<���n|
|���t��������k(��r4||	j������������������s||	j������������������dz��z���n||	j������������������z���z���|d<���nA|dk7��r<|
r||z���|	j������������������z���|d<���n$|
|���t��������k(��r||z���d|	j������������������z��z���|d<���|�j������������������|«�������	�|�d	���d
���}|	j������������������dk(��xr�|�d���d���dk7��}|
|���t
��������k(��r|s||	j������������������z���|�d
���d<���|�S�#�t��������$�r�Y�|�S�w�xY�w)a¡�� _push_to_list(lst : [str], func_name : str, char : str, line : int, offset : int,
                        first_arg_pos :int , first_item : int, in_list_literal : bool,
                        lead_spaces : int, args : str)

    Called when an opening bracket is encountered. A hash containing the
    necessary data to pin point errors and the indentation level is stored in
    the list and the list returned.
    r���)r2��r3��r4��r ���r‹���Úspacesr{���r/��r5���r ���r$���r���éýÿÿÿr‹���éþÿÿÿr2��r!���)r=���r#��rŒ���r>���r��r��r��ÚuniformÚindent_sizeÚKEYWORD3r9��Ú
IndexError)r��r‹���Úcharr®���r<��Ú
first_arg_posÚ
first_itemÚin_list_literalÚlead_spacesrH���r��Úpos_hashÚis_macroÚ
two_spacerÚparent_funcÚnon_bind_blocks���                r/���Ú
_push_to_listrW��ã��sª��€�ô�dÓ€DܘDÓ!€HØ!Ø#Ø%Ø &¨Ñ 6Ø&Øñ€Hô�˜Y¨¯©Ó5€HØÒH˜X iÑ0´X¼xÐ4HÐH€Já˜$ #š+¨$°#ª+¸$¿,¹,È)Ò:Sà#-ˆÒ à	)Ñ	¤Ò	(à#.Ø9=¿ºð�4:¸D×<LÑ<LÈqÑ<PÒ3Pà8>À×AQÑAQÑ8Qñ$TˆÒ ð�
bŠÙØ'2°VÑ';¸d×>NÑ>NÑ'NˆH^Ò$Ø
iÑ
 ¤HÒ
,Ø'2°VÑ';¸qÀ4×CSÑCSÑ?SÑ'TˆH^Ñ$à‡JJˆxÔð
ð�˜"‘g˜kÑ*ˆð�Ÿ™¨Ñ2ÒR°s¸2±w¸{Ñ7KÈsÑ7RˆØKÑ ¤HÒ,±^Ø&,¨t×/?Ñ/?Ñ&?ˆC‰GNÑ#ð�€Jøô�ò�
ØØ€Jð
ús���ÄAE�Å	EÅEc�����������������ó
��—�t��������|«������}t��������|«������}d}d}d}g�}d}d}d}	d}
g�}d}|xs�|	xs
�|
xs�|xs�|}
d}d}t��������|�«������}t��������|�|«������}g�}g�}g�}|D�]��}d}|}t	��������||||	|
|«������\��}}}|j������������������|«�������d}t
��������j������������������||«������}|r$t
��������j������������������|t��������|d���|«������|«������}d}|D�]��}||dz���|dz����}||dz
��|�}||dz���d�}|rd}|dz
��}Œ)|dk(��r|s|sd	}|d
k(��s|dk(��r(|j������������������dk(��r|
s|dk(��r|j������������������d
k(��s�n´|j������������������dvrS|dk(��rN|sL|dk(��r|
s|j������������������||f«�������|	dz
��}	n,|	r|dk(��r|	dz��}	|j������������������«��������n|	s
|
rd}d}
n||f}d	}
|
s~|	s||sz|dk(��r||f}t��������|«�������}|j������������������dk(��rV|sT|dk(��r|j������������������||f«�������|dz
��}n6|dk(��r1|r|j������������������«��������nd} | ||dœ}!|j������������������|!«�������|dz��}|dk(��r[|j������������������dk(��rL|sJ|sHt
��������j������������������d|||dz����«������rd	}|dk(��r%||f}n t
��������j������������������d|||dz����«������rd}d}|xs�|	xs
�|
xs�|xs�|}
|
r|dz
��}ŒÂ||z
��t��������t
��������j������������������d|«������d���«������z���|z
��}"|dv�rs|dv�r|j������������������dv�r|dz
��}Œt��������|||«������\��}#}$|d|#dz
���j!������������������d«������j#������������������«�������}%d}&t
��������j$������������������d|d|dz����«������rd	}&t
��������j$������������������d|«������r|j!������������������d«������j#������������������«�������}%|&rd}%|%d v�r€t
��������j$������������������d|«������j'������������������«�������}'||'d�}|t
��������j$������������������d!|«������j)������������������«�������d�j!������������������«�������}|d|j+������������������d"«�������}(|(dk7��r	t,��������||(<���t
��������j$������������������d!||dz���d�«������j'������������������«�������|z���dz���})t/��������|dd�|%||||#|)|&|$|«
������}n0|d#v�r,|d$v�r|j������������������dv�r|dz
��}Œ‚t1��������||dd�||"||«������}|r{|d%v�rw||d&���d'������t2��������k(��re|d(vst
��������j$������������������d)|«������s|d&���d*xx���dz
��cc<���|d&���d*���dk(��r0|d&���d+xx���|j4������������������rdn|j6������������������z��cc<���d,|d&���d*<���|dz
��}Œ�|dz
��}Œ�||||||||	|
||||d-œ
}*|*S�).aŽ�� indented_code(string : str, fname : str) -> [...]

    Arguments:
    fpath: Simply used in formatting the warning messages

    >>> indent_code("(print
'Hello)")
    {'bracket_locations': [],
     'comment_locations': [],
     'in_comment': 0,
     'in_newlisp_tag_string': False,
     'in_string': False,
     'in_symbol_with_space': False,
     'indented_code': ['(print
', " 'Hello)"],
     'last_quote_location': (),
     'last_symbol_location': (),
     'message_stack': [],
     'newlisp_brace_locations': [],
     'original_code': ['(print
', "'Hello)"],
     'first_tag_string': ()}


    The last entry in the list is the indented string.
    Fr���rY���r%���ru���r$���Nú\Tú;ú#r4���r6���)r5���r4���ú|ú"r{���ú}z.Attempt to close a non-existent newLISP stringr5��r/��r|���é���z	\[/text\])r1��r/��r{���)r/��r{���)r3���r4���z)]	

 z[^#]('|`|#)([ 	]*\(|\[)($|
)z^[^ 	]+[ 	]*($|
)r���)r��rÏ���z[ 	]*rt���)r.��r0��r^��)r.��r^��)rt���r™���r!���r‹���)rt���r™���r���z^[ 	]*(;|#\||$|
)rF��r ���iç��)
Ú
message_stackÚfirst_tag_stringÚin_newlisp_tag_stringÚlast_symbol_locationÚcomment_locationsÚnewlisp_brace_locationsÚ	in_stringr¯���Úin_symbol_with_spaceÚbracket_locationsÚlast_quote_locationÚ
original_codeÚ
indented_code)r=���r#��rr���r���rµ���r9��rv���Úfindallrw���r—���r>���r8��Úboolr%��rF���r,��Ústripr?���r}���r~���r���r&��r��rW��rD��r��rI��rJ��)+rj��rH���r��rf��Úin_newlisp_stringrb��re��ra��r£���r¯���rg��rd��rc��r°���r3��ri��Úline_endingÚ
code_linesrk��rh��r`��r®���Úescapedr³���r ���ÚregexrQ��r<��Ú	curr_charÚ	next_charÚ	prev_charÚsubstrrc���rC��Ú
real_positionrN��r)��r‹���rP��Úend_of_spaceÚ
macro_namerO��Úress+���                                           r/���Úindent_coder|����s­��€�ô2�dÓ€DܘDÓ!€Hð�€Ið�ÐØ!ÐØ ÐØÐð�€Jð�€JØ ÐØÐØÐð�!ò�3 Jò�3Ð2Fò�3Øò3Ø2ð�ð
�€Kð�Ðä" =Ó1€KÜ 
¨{Ó;€Jà€MàÐð�€MäˆØˆØˆ	ô�/:¸*Ø:KØ:>À
Ø:JÈDó/RÑ+ˆ
I˜|ð
�	×јYÔ'؈ܗj‘j ¨	Ó2ˆÙÜŸ™˜u¤h¨{¸1©~¸tÓ&DÀiÓPˆI؈Ü"ˆIØ! &¨1¡*¨V°a©ZÐ8ˆIØ! &¨1¡*¨VÐ4ˆIà˜v¨™z˜{Ð+ˆFáàØ˜!‘Øà˜DÒ Ñ):ÑCXàà˜SÒ  Y°#Ò%5¸$¿,¹,È)Ò:SÙ,Ø #Ò%¨$¯,©,¸(Ò*Bò�ð
�|‰|Ð#9Ñ9¸iÈ3Ò>NÙ%Ø Ò#Ñ,@Ø%×,Ñ,¨k¸6Ð-BÔCØ !‘O‘JÙ I°Ò$4Ø !‘OJØ%×)Ñ)Õ+Ù#Ù+Ø/1Ð,Ø/4Ñ,à0;¸VÐ/DÐ,Ø/3Ð,ñ
�)©JÑ:OØ Ò#Ø+6¸Ð*?Ð'Ü$(¨£OÐ 3IØ—<‘< 9Ò,±Yð�! CÒ'Ø/×6Ñ6¸ÀVÐ7LÔMØ)¨QÑ.Ñ)Ø" cÒ)Ù2Ø3×7Ñ7Õ9à&V˜Gà'.Ø(3Ø*0ñ,˜Lð
�*×0Ñ0°Ô>Ø)¨QÑ.Ð)à˜CÒ D§L¡L°IÒ$=Ù&©)ä—8‘8˜J¨	°&¸À!¹Ð(DÔEØ,0Ð)Ø'¨2Ò-Ø,7¸Ð+@Ñ(Ü—X‘X˜k¨9°V¸FÀQ¹JÐ+GÔHØ,1Ð)Ø')Ð$à(ò� >¨Jò� >Ð:Nò� >Ø$ò >Ø(=ð�
ñ� ð�˜!‘Ùð�$ jÑ0Ü”B—J‘J˜y¨$Ó/°Ñ2Ó3ñ4Ø6BñCˆMà˜OÒ+Ø 
Ñ*¨t¯|©|Ð?RÑ/Rð�˜a‘KFÙô�' v¨y¸$Ó?ñ�2
Ð1à" 1 ]°QÑ%6Ð7×=Ñ=¸kÓJ×PÑPÓR	Ø"'Ü—9‘9Ð=¸yÈÈ6ÐTUÉ:Ð?VÔWØ&*Oä—9‘9Ð3°VÔ<à &§¡¨[Ó 9× ?Ñ ?Ó AIá"ð
�!#IàÐ <Ñ<ô�$&§9¡9¨Y¸Ó#?×#CÑ#CÓ#ELØ# L MÐ2FØ#¤B§I¡I¨h¸Ó$?×$EÑ$EÓ$GÐ$HÐI×OÑOÓQFØ!'Ð(9¨¯©°SÓ)9Ð!:JØ! RÒ'Ü/7˜ Ñ,ô
� ŸY™Y x°¸6ÀA¹:¸;Ð1GÓH×LÑLÓNÐQWÑWÐZ[Ñ[
Ü$1Ð2CÁAÐ2FÈ	Ø2;¸[È&Ø2?ÀØ2AØ2DÀdó	%LÑ!ð�˜oÑ-Ø 
Ñ*¨t¯|©|Ð?RÑ/Rð�˜a‘KFÙä$2°9Ð>OÑPQÐ>RØ3>À
Ø39¸=ó%JÐ!ñ�! Y°+Ñ%=ØÐ.¨rÑ2°;Ñ?Ñ@ÄHÒLð� OÑ3ÜŸ	™	Ð"7¸ÔCð�& bÑ)¨(Ó3°qÑ8Ó3Ø$ RÑ(¨Ñ2°aÒ7Ø% bÑ)¨.Ó9Ø!Ÿ\š\™¨t×/?Ñ/?ñ@Ó9ð�7:Ð% bÑ)¨(Ñ3àa‰KŠFð_�#ð`�	qÑŠðA�ðD�'Ø,Ø!6Ø 4Ø.Ø#:ØØ Ø 4Ø.Ø2Ø#Ø&ñ€Cð�€Jr1���c�����������������ó ��‡—�	�ddl�Š‰j������������������«��������ˆfd„}ˆfd„}ˆfd„}t
��������j������������������d«������}|�D�]]��}|j������������������d«������r	�||«�������Œ|j������������������d	«������r	�||«�������Œ7|j������������������|«������r	�||«�������ŒQt��������|d¬
«�������Œ_�y#�t��������$�r&�t��������dj������������������t	��������|�«������«������«�������Y�yw�xY�w)zM colour_diff(diff_lines : lst)

    Print diff text to terminal in color
    r���Nr���c�����������������ó|���•—�t��������‰j������������������j������������������|�z���‰j������������������j������������������z���d¬«�������y)z Print added line in green r���©r~���N)ÚprintÚForeÚGREENÚWHITE©r–���Úcoloramas��� €r/���Úp_greenzcolour_diff.<locals>.p_greenC��s+���ø€�ä
ˆhm‰m×!Ñ! DÑ(¨8¯=©=×+>Ñ+>Ñ>ÀBÖGr1���c�����������������ó|���•—�t��������‰j������������������j������������������|�z���‰j������������������j������������������z���d¬«�������y)z% Print diff section header in yellow r���r��N)r€��r��ÚYELLOWrƒ��r„��s��� €r/���Úp_yellowzcolour_diff.<locals>.p_yellowG��s+���ø€�ä
ˆhm‰m×"Ñ" TÑ)¨H¯M©M×,?Ñ,?Ñ?ÀRÖHr1���c�����������������ó|���•—�t��������‰j������������������j������������������|�z���‰j������������������j������������������z���d¬«�������y)z Print removed line in red r���r��N)r€��r��ÚREDrƒ��r„��s��� €r/���Úp_redzcolour_diff.<locals>.p_redK��s+���ø€�ä
ˆhm‰m×Ñ $Ñ&¨¯©×)<Ñ)<Ñ<À"ÖEr1���z!@@\s+-\d\d,\d\d\s\+\d\d,\d\d\s+@@ú-ú+r��)
r…��ÚImportErrorr€��ÚjoinÚlistÚinitrv���ÚcompileÚ
startswithr}���)Ú
diff_linesr†��r‰��rŒ��Úsectionr®���r…��s���      @r/���r���r���4��s°���ø€�ðÛð�
‡MM„OôHôIôFô�j‰jÐ<Ó=€Gۈ؏?‰?˜3ÔÙ$KØ
_‰_˜SÔ
!ÙDMØ
^‰^˜DÔ
!ÙTNä$˜BÖñ�øô'�ò�ä
ˆbg‰g”d˜:Ó&Ó'Ô(Ùðús���ƒB�Â,C
ÃC
c�����������������ó~��—�t���������j������������������j������������������|«������}t��������|«������}|�d���D�]��}|j������������������sŒ|j
������������������r5||d<���t��������j������������������j�������������������dj������������������d"i�|¤Ž«�������ŒQt��������j������������������j�������������������dj������������������d"i�|¤Ž«�������Œ�|�d���rN|�d���D�]F��}|d���}|d���}|d���}d	}	|j������������������sŒ!t��������j������������������j������������������|	||||fz��«�������ŒH�|�d
���rD|�d
���D�]<��}
d}	|j������������������sŒt��������j������������������j������������������|	||
d���|
d
���fz��«�������Œ>�|�d���rA|�d���D�]9��}d}	|f|z���}|j������������������sŒt��������j������������������j������������������|	|z��«�������Œ;�|�d���r9d}	|f|�d���z���}|j������������������r"t��������j������������������j������������������|	|z��«�������|�d���r9d}	|f|�d���z���}|j������������������r"t��������j������������������j������������������|	|z��«�������|�d���r9d}	|f|�d���z���}|j������������������r"t��������j������������������j������������������|	|z��«�������|j������������������}
|
s|}
|�d���}dj������������������|«������}||�d���k(��rl|j
������������������r`d}	t��������j������������������j������������������|	|z��«�������|
|k7��r6t��������|
d«������5�}|j������������������|j������������������d«������«�������ddd«�������yy|j������������������rWt��������j ������������������|�d���|d¬ «������}|j"������������������rt#��������|«�������n=t%��������dj������������������t'��������|«������«������«�������n|j(������������������r
t%��������|d¬!«�������|j*������������������r6t��������|
d«������5�}|j������������������|j������������������d«������«�������ddd«�������yy#�1�sw�Y���yxY�w#�1�sw�Y���yxY�w)#z» _post_indentation(res : dict):

    Called after the string has been indented appropriately.
    It takes care of writing the file and checking for unclosed strings
    or comments.
    r`��rR���z
{fname}:{line}:{column}: {msg}z
:{line}:{column}: {msg}rh��r3��r4��r2��z
%s:%d:%d: Unmatched `%s're��z(
%s:%d:%d: Unclosed newLISP brace stringr���r%���rd��z%
%s:%d:%d: Unclosed multiline commentrc��z
%s:%d:%d: Unclosed symbolrf��z(
%s:%d:%d: String extends to end-of-fileri��rb��z,
%s:%d:%d: Tag string extends to end-of-filera��rk��r���rj��z>File '%s' has already been formatted. Leaving it unchanged...
ÚwbÚutf8Né���)Únr��rY���)r,���rB���Úbasenamer=���r���r���r8���r`���ra���rA���r���r��rO���Úencoder���ÚdifflibÚunified_diffr���r€��r‘��r���r���)r{��rH���ÚfpathrR���r6��r:��r®���r7��r2��rc���ÚbracerÕ���rd���r���rk��Ú
indent_resultÚ
indented_fileÚdiffs���                  r/���Ú_post_indentationr¥��Z��sž��€�ô�
G‰G×Ñ˜UÓ#€EܐdÓ€Dà?Ô#ˆØ<‹<؏zŠzØ$G‘Ü—
‘
× Ñ Ð!JÐ!C×!JÑ!JÑ!QÈSÑ!QÕRô�—
‘
× Ñ Ð!CÐ!<×!CÑ!CÑ!JÀcÑ!JÕKð�$ð�ÐÒð�Ð.Ô/ˆGؘ=Ñ)ˆDؘ]Ñ+ˆFØ Ñ,ˆIð�3ˆG؏|‹|Ü—
‘
× Ñ  ¨E°4¸ÀÐ+KÑ!KÕLð�0ð�Ð$Ò%ØÐ2Ô3ˆEØAˆG؏|‹|Ü—
‘
× Ñ  ¨E°5¸±8¸UÀ1¹XÐ+FÑ!FÕGð�4ð
�ÐÒØÐ.Ô/ˆGØ>ˆGؐ(˜WÑ$ˆC؏|‹|Ü—
‘
× Ñ  ¨3¡Õ/ð	�0ð�Ð!Ò"Ø/ˆØˆh˜Ð3Ñ4Ñ4ˆØ<Š<ÜJ‰J×Ñ˜W s™]Ô+à
ˆ;ÒØ=ˆØˆh˜Ð2Ñ3Ñ3ˆØ<Š<ÜJ‰J×Ñ˜W s™]Ô+à
Ð"Ò#ØAˆØˆh˜Ð/Ñ0Ñ0ˆØ<Š<ÜJ‰J×Ñ˜W s™]Ô+à×"Ñ"€KÙ؈à˜Ñ(€MØ—G‘G˜MÓ*€Mؘ˜OÑ,Ò,°·²ØSˆÜ
‰
×ј 5™Ô)ؘ%Òܐk 4Ó(ð�
B¨MØ×#Ñ# M×$8Ñ$8¸Ó$@ÔA÷
Bð�
Bð� ð�×ÒÜ×'Ñ'¨¨OÑ(<¸mÈqÔQˆDØ×ÒܘDÕ!äb—g‘gœd 4›jÓ)Õ*Ø
[Š[Ü- RÕ(à;Š;äk 4Ó(ð�
B¨MØ×#Ñ# M×$8Ñ$8¸Ó$@ÔA÷
Bð�
Bð�÷
Bð�
Bú÷
Bð�
Bús���Ê=!N'Í<!N3Î'N0Î3N<c�����������������ó ��—�t��������|�«������}|j������������������s5t��������j������������������j	������������������«�������}t��������||«������}t
��������|«�������|j������������������rTddl}|j������������������|j������������������«�������«������}|j������������������t��������|j������������������D�cg�c]��}||f‘Œ�c}«�������y|j������������������D�]��}t��������||«�������Œ�yc�c}w�)z‚ indent_files(arguments)

    Note: if the parallel option is provided, the files will be read and processed
    in parallel

    r���N)
r=���r���r8���ÚstdinrP���r|��r¥��ÚparallelÚmultiprocessingÚPoolÚ	cpu_countÚstarmapÚindent_file)rG���rH���Úcoder¢��r©��ÚpoolrR���s���       r/���Úindent_filesr°��¶��s›���€�ô�iÓ €D؏:Š:äy‰y~‰~ÓˆÜ# D¨$Ó/ˆ
ܘ-Ô(à‡}‚}ÛØ×#Ñ# O×$=Ñ$=Ó$?Ó@ˆØ‰”[¸d¿j¹jÖ"I°U E¨4¢=Ò"IÕJà—Z”ZˆEÜ˜˜tÕ$ñ� ùò�#Js���ÂC
c�����������������óê��—�t��������|«������}t��������j������������������j������������������|�«������}�t	��������|�«������}|j
������������������s|�j
������������������d«������rd|_��������nh|�j
������������������d«������rd|_��������nOt��������j������������������d|�«������rd|_��������n1|�j
������������������d«������s|�j
������������������d«������rd	|_��������nd
|_��������t��������||«������}|j������������������rt��������|�|«�������t��������||�¬«�������y)
a��
    indent_file(fname: string, args)

    1. Create a backup of the source file(backup_source_file())
    2. Read the file contents(read_file())
    3. Indent the code(indent_code())
    4. Write to the file or print the indented code(_post_indentation())

    z.lispr3���z.lspr4���z.clj[sc]{0,1}$r5���z.ssz.scmr6���r7���)r ��N)
r=���r,���rB���rC���rT���r>���Úendswithrv���r}���r|��r���re���r¥��)rR���rH���r®��r¢��s���    r/���r­��r­��Í��s½���€�ô�dÓ€DÜG‰G×Ñ˜uÓ%€EܐUÓ€D؏<Š<ð�>‰>˜'Ô"Ø!ˆDLØ
^‰^˜FÔ
#Ø$ˆDLÜ
Y‰YÐ'¨Ô
/Ø$ˆDLØ
^‰^˜EÔ
" e§n¡n°VÔ&<Ø#ˆDLà ˆDŒLÜ  dÓ+€Mà‡{‚{ä˜5 $Ô'äm¨5Ö1r1���c������������������ó<���—�t��������t��������j������������������dd�«�������y)z
 Entry point r%���N)r°��r8���r9���rY���r1���r/���Úmainr´��ð��s���€�ä”—‘˜!˜"Õr1���Ú__main__)N)Nr���)=Ú__doc__Ú
__future__r���r&���rg���r,���rv���r]���r8���rV���r��r��rž��Ú	functoolsr���r��Úbackports.functools_lru_cacher���r+���r0���r=���rT���rN���re���rk���rr���ry���rˆ���rŒ���r���r’���r—���rœ���rª���rµ���rn���ro���rm���ÚKEYWORD0r��r��rK��r��r��r��r��r��r��r��r��r#��r,��rD��rW��r|��r���r¥��r°��r­��r´��Ú__name__rY���r1���r/���ú<module>r¼�����sè��ðñõ�&ã�Û�Û�	Û�	Û�
Û�
Û�Û�Û�Û�ð8Ý#õ
�à€ñ�4ÔñOó�ðOód%òP)ò"3ó(ò,	,òñ�4Ôñó�ðó>6ñr�4Ôñó�ðñ0�4Ôñó�ðñ@�4Ôñ1ó�ð1ò*ò)ó *ðH�ó%ðV�€Ø€Ø	ˆBw€à€Ø€Ø€Ø€Ø€ò
5ð�ò"ð�òð�òð�ð�ˆ&€ñ�4Ôñ.ó�ð.ò(ò$óR:)òz*ð^�%)ó4ónWòt# óLYBòx%ò. 2òFð
�ˆzÒÙ…Fð�øðs&�ò�8ß7ð8ús���²D�ÄD)Ä(D)