Ë #»î(Œc�ãóÖ—ddlZddlZddlZddlmZddlmZmZmZddlmZejZ ejZ dZ dZ ejd d «ZGd „d «ZGd „d«Ze«ZGd„d«ZGd„d«ZGd„de«ZGd„de«ZGd„de«ZGd„de«ZGd„de«Zej3e««Gd„de«Zej3e««Gd„d e«Zej3e««Gd!„d"e«Zej3e««Gd#„d$e«Zej3e««d%„Ze«j?«Z y)&éNé)Úgetattr)ÚerrorÚi18nÚpycompaté)Ú stringutilsserversclientÚcompenginewireprotosupport)ÚnameÚserverpriorityÚclientprioritycó —eZdZd„Zdd„Zd„Zy)Ú propertycachecó4—||_|j|_y©N)ÚfuncÚ__name__r )Úselfrs ú?usr/lib/python3.12/site-packages/mercurial/utils/compression.pyÚ__init__zpropertycache.__init__$s€ØˆŒ Ø—M‘Mˆ� óNcóL—|j|«}|j||«|Sr)rÚ cachevalue)rÚobjÚtypeÚresults rÚ__get__zpropertycache.__get__(s"€Ø—‘˜3“ˆØ �‰˜˜VÔ$؈ rcó6—||j|j<yr)Ú__dict__r )rrÚvalues rrzpropertycache.cachevalue-s€à"'ˆ� ‰ �T—Y‘YÒrr)rÚ __module__Ú __qualname__rrr©rrrr#s„ò"óó (rrcón—eZdZdZd„Zd„Zd„Zd„Zd„Ze d„«Z e d„«Z d „Z d „Z dd „Zd „Zd „Zy)ÚcompressormanageraGHolds registrations of various compression engines. This class essentially abstracts the differences between compression engines to allow new compression formats to be added easily, possibly from extensions. Compressors are registered against the global instance by calling its ``register()`` method. cóJ—i|_i|_i|_i|_i|_yr)Ú_enginesÚ _bundlenamesÚ _bundletypesÚ_revlogheadersÚ _wiretypes©rs rrzcompressormanager.__init__=s(€ØˆŒ àˆÔàˆÔà ˆÔàˆ�rcó —|j|Sr©r'©rÚkeys rÚ __getitem__zcompressormanager.__getitem__Hs€Ø�}‰}˜SÑ!Ð!rcó—||jvSrr.r/s rÚ __contains__zcompressormanager.__contains__Ks€Ø�d—m‘mÐ#Ð#rcóH—t|jj««Sr)Úiterr'Úkeysr,s rÚ__iter__zcompressormanager.__iter__Ns€Ü�D—M‘M×&Ñ&Ó(Ó)Ð)rcóÈ—t|t«sttd««‚|j «}||j vr!t jtd«|z«‚|j«}|r’|\}}||jvr!t jtd«|z«‚||jvr0t jtd«||j|fz«‚|r||j|<||j|<|j«}|rY|j}||jvr0t jtd«||j|fz«‚||j|<|j«}|r>||jvr0t jtd«||j|fz«‚|r||j|<||j |<y)zxRegister a compression engine with the manager. The argument must be a ``compressionengine`` instance. s$argument must be a compressionengines(compression engine %s already registereds!bundle name %s already registereds'bundle type %s already registered by %ss5wire protocol compression %s already registered by %ss)revlog header %s already registered by %sN)Ú isinstanceÚcompressionengineÚ ValueErrorÚ_r r'rÚAbortÚ bundletyper(r)Úwireprotosupportr+Ú revlogheaderr*) rÚenginer Ú bundleinfoÚ bundlenamer>Ú wiresupportÚwiretyper@s rÚregisterzcompressormanager.registerQsê€ô ˜&Ô"3Ô4ÜœQÐFÓGÓHÐ Hà�{‰{‹}ˆà �4—=‘=Ñ Ü—+‘+ÜÐ=Ó>ÀÑEóð ð×&Ñ&Ó(ˆ Ù Ø%/Ñ "ˆJ˜ à˜T×.Ñ.Ñ.Ü—k‘kÜÐ:Ó;¸jÑHóðð˜T×.Ñ.Ñ.Ü—k‘kÜÐ@ÓAØ! 4×#4Ñ#4°ZÑ#@ÐAñBóðñ Ø04�×!Ñ! *Ñ-à,0ˆD× Ñ ˜jÑ )à×-Ñ-Ó/ˆ Ù Ø"×'Ñ'ˆHؘ4Ÿ?™?Ñ*Ü—k‘kÜð,óð  §¡°Ñ!:Ð;ñ <óðð)-ˆD�O‰O˜HÑ %à×*Ñ*Ó,ˆ Ù ˜L¨D×,?Ñ,?Ñ?Ü—+‘+ÜÐ>Ó?Ø ×!4Ñ!4°\Ñ!BÐCñDóð ñ Ø04ˆD× Ñ   Ñ -à$ˆ� ‰ �dÒrcóH—t|jj««Sr)Úsetr(r6r,s rÚsupportedbundlenamesz&compressormanager.supportedbundlenamesŽó€ä�4×$Ñ$×)Ñ)Ó+Ó,Ð,rcóH—t|jj««Sr)rHr)r6r,s rÚsupportedbundletypesz&compressormanager.supportedbundletypes’rJrcó¼—|j|j|}|j«s/tjt d«|j «z«‚|S)zÁObtain a compression engine registered to a bundle name. Will raise KeyError if the bundle type isn't registered. Will abort if the engine is known but not available. ó)compression engine %s could not be loaded)r'r(Ú availablerr=r<r )rrCrAs rÚ forbundlenamezcompressormanager.forbundlename–óU€ð—‘˜t×0Ñ0°Ñ<Ñ=ˆØ×ÑÔ!Ü—+‘+ÜÐ>Ó?À&Ç+Á+Ã-ÑOóð ðˆ rcó¼—|j|j|}|j«s/tjt d«|j «z«‚|S)zÁObtain a compression engine registered to a bundle type. Will raise KeyError if the bundle type isn't registered. Will abort if the engine is known but not available. rN)r'r)rOrr=r<r )rr>rAs rÚ forbundletypezcompressormanager.forbundletype¤rQrcó4‡—|ttfvsJ‚|tk(rdndŠ|jj«D�cgc]}|j|‘Œ}}|r |D�cgc]}|j «sŒ|‘Œ}}ˆfd„}t t||¬««Scc}wcc}w)zçObtain compression engines that support the wire protocol. Returns a list of engines in prioritized order, most desired first. If ``onlyavailable`` is set, filter out engines that can't be loaded. sserverprioritysclientprioritycóZ•—|j«}dt|‰«z|jfS)Néÿÿÿÿ)r?rr )ÚeÚwÚattrs €rÚgetkeyz6compressormanager.supportedwireengines..getkeyÂs.ø€ð×"Ñ"Ó$ˆAØœ  4Ó(Ñ(¨!¯&©&Ð0Ð 0r)r0)Ú SERVERROLEÚ CLIENTROLEr+Úvaluesr'rOÚlistÚsorted)rÚroleÚ onlyavailablerWÚenginesrZrYs @rÚsupportedwireenginesz&compressormanager.supportedwireengines²s•ø€ðœ ¤JÐ/Ñ/Ð/Ð/à$(¬JÒ$6Ñ ÐÓ?À&Ç+Á+Ã-ÑOóð ðˆ rcó:—|j|j|S)z�Obtain a compression engine registered to a revlog header. Will raise KeyError if the revlog header value isn't registered. )r'r*)rÚheaders rÚforrevlogheaderz!compressormanager.forrevlogheaderÓs€ð �}‰}˜T×0Ñ0°Ñ8Ñ9Ð9rN)T)rr!r"Ú__doc__rr1r3r7rFÚpropertyrIrLrPrSrcrerhr#rrr%r%2sb„ñò ò"ò$ò*ò;%ðzñ-óð-ðñ-óð-ò ò ó1ò2ó:rr%cóD—eZdZdZd„Zd„Zd„Zd„Zd„Zd d„Z d „Z d d „Z y) r:zuBase class for compression engines. Compression engines must implement the interface defined by this class. có—t«‚)z—Returns the name of the compression engine. This is the key the engine is registered under. This method must be implemented. ©ÚNotImplementedErrorr,s rr zcompressionengine.nameäó €ô"Ó#Ð#rcó—y)aWhether the compression engine is available. The intent of this method is to allow optional compression engines that may not be available in all installations (such as engines relying on C extensions that may not be present). Tr#r,s rrOzcompressionengine.availableís€ðrcó—y)a¥Describes bundle identifiers for this engine. If this compression engine isn't supported for bundles, returns None. If this engine can be used for bundles, returns a 2-tuple of strings of the user-facing "bundle spec" compression name and an internal identifier used to denote the compression format within bundles. To exclude the name from external usage, set the first element to ``None``. If bundle compression is supported, the class must also implement ``compressstream`` and `decompressorreader``. The docstring of this method is used in the help system to tell users about this engine. Nr#r,s rr>zcompressionengine.bundletypeös€ð rcó—y)a‹Declare support for this compression format on the wire protocol. If this compression engine isn't supported for compressing wire protocol payloads, returns None. Otherwise, returns ``compenginewireprotosupport`` with the following fields: * String format identifier * Integer priority for the server * Integer priority for the client The integer priorities are used to order the advertisement of format support by server and client. The highest integer is advertised first. Integers with non-positive values aren't advertised. The priority values are somewhat arbitrary and only used for default ordering. The relative order can be changed via config options. If wire protocol compression is supported, the class must also implement ``compressstream`` and ``decompressorreader``. Nr#r,s rr?z"compressionengine.wireprotosupports€ð.rcó—y)aPHeader added to revlog chunks that identifies this engine. If this engine can be used to compress revlogs, this method should return the bytes used to identify chunks compressed with this engine. Else, the method should return ``None`` to indicate it does not participate in revlog compression. Nr#r,s rr@zcompressionengine.revlogheader!s€ðrNcó—t«‚)aƒCompress an iterator of chunks. The method receives an iterator (ideally a generator) of chunks of bytes to be compressed. It returns an iterator (ideally a generator) of bytes of chunks representing the compressed output. Optionally accepts an argument defining how to perform compression. Each engine treats this argument differently. rm©rÚitÚoptss rÚcompressstreamz compressionengine.compressstream+s €ô"Ó#Ð#rcó—t«‚)zêPerform decompression on a file object. Argument is an object with a ``read(size)`` method that returns compressed data. Return value is an object with a ``read(size)`` that returns uncompressed data. rm©rÚfhs rÚdecompressorreaderz$compressionengine.decompressorreader7rorcó—t«‚)aLObtain an object that can be used to compress revlog entries. The object has a ``compress(data)`` method that compresses binary data. This method returns compressed binary data or ``None`` if the data could not be compressed (too small, not compressible, etc). The returned data should have a header uniquely identifying this compression format so decompression can be routed to this engine. This header should be identified by the ``revlogheader()`` return value. The object has a ``decompress(data)`` method that decompresses data. The method will only be called if ``data`` begins with ``revlogheader()``. The method should return the raw, uncompressed data or raise a ``StorageError``. The object is reusable but is not thread safe. rm©rrws rÚrevlogcompressorz"compressionengine.revlogcompressor@s €ô$"Ó#Ð#rr) rr!r"rir rOr>r?r@rxr|rr#rrr:r:Þs/„ñò $òòò$ò2ó $ò$ô$rr:có—eZdZd„Zd„Zd„Zy)Ú_CompressedStreamReadercóŒ—t|d«r|j|_n|j|_g|_d|_d|_y)NÚunbufferedreadrF)Ú safehasattrrƒÚ_readerÚreadÚ_pendingÚ_posÚ_eofrzs rrz _CompressedStreamReader.__init__Vs:€Ü �rÐ+Ô ,Ø×,Ñ,ˆD�LàŸ7™7ˆDŒL؈Œ ؈Œ ؈� rcó—t«‚rrm)rÚchunks rÚ _decompressz#_CompressedStreamReader._decompress_s €Ü!Ó#Ð#rcó4—g} |j�rt|jd«||jzkDr`|jd}|j||j|j|z«|xj|z c_dj |«S|jj d«}|jr:|j||jd«|t|«|jz z}n|j|«|t|«z}d|_|jr�Œ|j rdj |«S|jd«}|j|«|s)|js|j sdj |«S�Œ–)Nrri) r‡ÚlenrˆÚappendÚjoinÚpopr‰r…rŒ)rÚlÚbufÚnewbufr‹s rr†z_CompressedStreamReader.readbs?€ØˆØØ—-“-Ü�t—}‘} QÑ'Ó(¨1¨t¯y©y©=Ò8Ø!Ÿ]™]¨1Ñ-�FØ—J‘J˜v d§i¡i°$·)±)¸a±-Ð@ÔAØ—I’I ‘N•IØŸ8™8 C›=Ð(àŸ™×*Ñ*¨1Ó-�Ø—9’9Ø—J‘J˜v d§i¡i kÐ2Ô3Øœ˜V› t§y¡yÑ0Ñ0‘Aà—J‘J˜vÔ&Øœ˜V›Ñ$�AØ�” ð—-”-ð �yŠyØ—x‘x “}Ð$Ø—L‘L Ó'ˆEØ × Ñ ˜UÔ #Ù §¢°t·y²yà—x‘x “}Ð$ñ/rN)rr!r"rrŒr†r#rrr�r�Us„òò$ó%rr�có$‡—eZdZˆfd„Zd„ZˆxZS)Ú_GzipCompressedStreamReadercó^•—tt|� |«tj«|_yr)Úsuperr–rÚzlibÚ decompressobjÚ _decompobj©rr{Ú __class__s €rrz$_GzipCompressedStreamReader.__init__s#ø€Ü Ô)¨4Ñ9¸"Ô=Ü×,Ñ,Ó.ˆ�rcóL—|jj|«}|r|jj|«|jj «} |jd«|j «|j dk(rd|_yy#tj$rYywxYw)NóxT) r›Ú decompressr‡r�ÚcopyÚflushÚ unused_datar‰r™r)rr‹r”Úds rrŒz'_GzipCompressedStreamReader._decompressƒs…€Ø—‘×+Ñ+¨EÓ2ˆÙ Ø �M‰M× Ñ  Ô (Ø �O‰O× Ñ Ó "ˆð Ø �L‰L˜Ô Ø �G‰GŒIØ�}‰} Ò$Ø �• ð%øä�z‰zò Ù ð úsÁ7B  B#Â"B#©rr!r"rrŒÚ __classcell__©r�s@rr–r–~s ø„ô/ö rr–có$‡—eZdZˆfd„Zd„ZˆxZS)Ú_BZ2CompressedStreamReadercó^•—tt|� |«tj«|_yr)r˜r©rÚbz2ÚBZ2Decompressorr›rœs €rrz#_BZ2CompressedStreamReader.__init__’s#ø€Ü Ô(¨$Ñ8¸Ô<Ü×-Ñ-Ó/ˆ�rcó—|jj|«}|r|jj|« |jjd«}|r|jj|«nyŒ;#t$r d|_YywxYw©NTr)r›r r‡r�ÚEOFErrorr‰©rr‹r”s rrŒz&_BZ2CompressedStreamReader._decompress–s|€Ø—‘×+Ñ+¨EÓ2ˆÙ Ø �M‰M× Ñ  Ô (ð ØØŸ™×3Ñ3°CÓ8�ÙØ—M‘M×(Ñ(¨Õ0àð øô ò ؈DŽIð úsº:A6Á5A6Á6B ÂB r¥r§s@rr©r©‘s ø„ô0ö rr©có‡—eZdZˆfd„ZˆxZS)Ú#_TruncatedBZ2CompressedStreamReadercóž•—tt|� |«|jj d«}|r|j j |«yy)NóBZ)r˜r²rr›r r‡r�)rr{r”r�s €rrz,_TruncatedBZ2CompressedStreamReader.__init__¦sAø€Ü Ô1°4ÑAÀ"ÔEØ—‘×+Ñ+¨EÓ2ˆÙ Ø �M‰M× Ñ  Õ (ð r)rr!r"rr¦r§s@rr²r²¥s ø„÷)ð)rr²có$‡—eZdZˆfd„Zd„ZˆxZS)Ú_ZstdCompressedStreamReaderc󀕗tt|� |«||_|j «j «|_yr)r˜r¶rÚ_zstdÚZstdDecompressorršr›)rr{Úzstdr�s €rrz$_ZstdCompressedStreamReader.__init__®s3ø€Ü Ô)¨4Ñ9¸"Ô=؈Œ Ø×/Ñ/Ó1×?Ñ?ÓAˆ�rcó8—|jj|«}|r|jj|« |jjd«}|r|jj|«nyŒ;#|jj $r d|_YywxYwr®)r›r r‡r�r¸Ú ZstdErrorr‰r°s rrŒz'_ZstdCompressedStreamReader._decompress³s†€Ø—‘×+Ñ+¨EÓ2ˆÙ Ø �M‰M× Ñ  Ô (ð ØØŸ™×3Ñ3°CÓ8�ÙØ—M‘M×(Ñ(¨Õ0àð øð �z‰z×#Ñ#ò ؈DŽIð úsº:A6Á5A6Á6 BÂBr¥r§s@rr¶r¶­sø„ôBö rr¶cóN—eZdZd„Zd„Zd„Zd„Zd d„Zd„ZGd„d «Z d d „Z y) Ú _zlibenginecó—y)Nózlibr#r,s rr z_zlibengine.nameÃó€Ørcó—y)zÜzlib compression using the DEFLATE algorithm. All Mercurial clients should support this format. The compression algorithm strikes a reasonable balance between compression ratio and size. )sgzipsGZr#r,s rr>z_zlibengine.bundletypeÆs€ðrcó—tddd«S)NrÀé©Úcompewireprotosupportr,s rr?z_zlibengine.wireprotosupportÏó€Ü$ W¨b°"Ó5Ð5rcó—y)NrŸr#r,s rr@z_zlibengine.revlogheaderÒs€ØrNc#óÄK—|xsi}tj|jdd««}|D]}|j|«}|sŒ|–—Œ|j «–—y­w)NólevelrV)r™Ú compressobjÚgetÚcompressr¢©rrvrwÚzr‹Údatas rrxz_zlibengine.compressstreamÕsYèø€ØŠz�rˆä × Ñ ˜TŸX™X h°Ó3Ó 4ˆÛˆEØ—:‘:˜eÓ$ˆDòØ“ ð ð�g‰g‹i‹ùó ‚AA ÁA có—t|«Sr)r–rzs rr|z_zlibengine.decompressorreaderâs €Ü*¨2Ó.Ð.rcó —eZdZdd„Zd„Zd„Zy)ú _zlibengine.zlibrevlogcompressorNcó—||_yr)Ú_level)rÚlevels rrz)_zlibengine.zlibrevlogcompressor.__init__æs €ØˆD�Krcóp—t|«}|dkDsJ‚|dkry|dkrS|j€tj|«}n tj||j«}t|«|kr|Sy|j€tj«}n tj|j¬«}g}d}||kr0|dz}|j |j|||««|}||krŒ0|j |j ««ttt|««|krdj|«Sy)Nré,é@B©r×ir) rŽrÖr™rÍrËr�r¢ÚsumÚmapr�)rrÐÚinsizeÚ compressedrÏÚpartsÚposÚpos2s rrÍz)_zlibengine.zlibrevlogcompressor.compressés€Ü˜“YˆFà˜A’:Ð �:à˜Š{Øà˜7Ò"Ø—;‘;Ð&Ü!%§¡¨tÓ!4‘Jä!%§¡¨t°T·[±[Ó!A�JÜ�z“? VÒ+Ø%Ð%Øð —;‘;Ð&Ü×(Ñ(Ó*‘Aä×(Ñ(¨t¯{©{Ô;�AØ�Ø�ؘF’lØ ™=�DØ—L‘L §¡¨D°°T¨NÓ!;Ô<Ø�Cð˜F“lð— ‘ ˜QŸW™W›YÔ'ä”sœ3 “Ó'¨&Ò0ØŸ8™8 E›?Ð*ØrcóÌ— tj|«S#tj$r9}tjt d«t j |«z«‚d}~wwxYw)Nórevlog decompress error: %s)r™r rÚ StorageErrorr<r Ú forcebytestr)rrÐrWs rr z+_zlibengine.zlibrevlogcompressor.decompresssY€ð Ü—‘ tÓ,Ð,øÜ—:‘:ò Ü×(Ñ(ÜÐ4Ó5Ü ×-Ñ-¨aÓ0ñ1óðûð ús‚—A#ª4AÁA#r©rr!r"rrÍr r#rrÚzlibrevlogcompressorrÔås„ó ò# óJ rrècóN—d}|�|jd«}|j|«S)Ns zlib.level)rÌrè©rrwr×s rrz_zlibengine.revlogcompressors,€ØˆØ Ð Ø—H‘H˜]Ó+ˆEØ×(Ñ(¨Ó/Ð/rr) rr!r"r r>r?r@rxr|rèrr#rrr¾r¾Âs0„òòò6òó ò/÷0ñ0ôd0rr¾có,—eZdZd„Zd„Zd„Zdd„Zd„Zy)Ú _bz2enginecó—y)Nsbz2r#r,s rr z_bz2engine.name"s€Ørcó—y)a“An algorithm that produces smaller bundles than ``gzip``. All Mercurial clients should support this format. This engine will likely produce smaller bundles than ``gzip`` but will be significantly slower, both during compression and decompression. If available, the ``zstd`` engine can yield similar or better compression at much higher speeds. )óbzip2r´r#r,s rr>z_bz2engine.bundletype%s€ðrcó—tddd«S)NrïrrÅr,s rr?z_bz2engine.wireprotosupport5s€Ü$ X¨q°!Ó4Ð4rNc#óÄK—|xsi}tj|jdd««}|D]}|j|«}|sŒ|–—Œ|j «–—y­w)NrÊé )r«Ú BZ2CompressorrÌrÍr¢rÎs rrxz_bz2engine.compressstream8sWèø€ØŠz�rˆÜ × Ñ ˜dŸh™h x°Ó3Ó 4ˆÛˆEØ—:‘:˜eÓ$ˆDÚØ“ ðð �g‰g‹i‹ùrÑcó—t|«Sr)r©rzs rr|z_bz2engine.decompressorreaderBs €Ü)¨"Ó-Ð-rr)rr!r"r r>r?rxr|r#rrrìrì!s„òò ò 5óó.rrìcó—eZdZd„Zd„Zd„Zy)Ú_truncatedbz2enginecó—y)Ns bz2truncatedr#r,s rr z_truncatedbz2engine.nameJs€Ørcó—y)N)Ns _truncatedBZr#r,s rr>z_truncatedbz2engine.bundletypeMs€Ø$rcó—t|«Sr)r²rzs rr|z&_truncatedbz2engine.decompressorreaderRs €Ü2°2Ó6Ð6rN)rr!r"r r>r|r#rrröröIs„òò%ó 7rröcóN—eZdZd„Zd„Zd„Zd„Zd d„Zd„ZGd„d «Z d d „Z y) Ú _noopenginecó—y)Nónoner#r,s rr z_noopengine.nameZrÁrcó—y)zmNo compression is performed. Use this compression engine to explicitly disable compression. )rýsUNr#r,s rr>z_noopengine.bundletype]s€ð rcó—tddd«S)Nrýré rÅr,s rr?z_noopengine.wireprotosupportgs€Ü$ W¨a°Ó4Ð4rcó—y)Nór#r,s rr@z_noopengine.revlogheaderls€ØrNcó—|Srr#rus rrxz_noopengine.compressstreamoó€Øˆ rcó—|Srr#rzs rr|z_noopengine.decompressorreaderrrrcó—eZdZd„Zy)ú _noopengine.nooprevlogcompressorcó—yrr#)rrÐs rrÍz)_noopengine.nooprevlogcompressor.compressvs€ØrN)rr!r"rÍr#rrÚnooprevlogcompressorrus„ó rr có"—|j«Sr)r r~s rrz_noopengine.revlogcompressorys€Ø×(Ñ(Ó*Ð*rr) rr!r"r r>r?r@rxr|r rr#rrrûrûYs/„òòò5ò óò÷ñô+rrûcód—eZdZd„Zed„«Zd„Zd„Zd„Zd„Z d d„Z d „Z Gd „d «Z d d „Z y)Ú _zstdenginecó—y)Nózstdr#r,s rr z_zstdengine.name�rÁrcóJ— ddlm}|j|S#t$rYywxYw)Nr)rº)ÚrºÚ __version__Ú ImportError)rrºs rÚ_modulez_zstdengine._module„s,€ð Ý ð × Ò ØˆKøÜò Ùð ús ‚– "¡"có,—t|j«Sr)Úboolrr,s rrOz_zstdengine.available‘s€Ü�D—L‘LÓ!Ð!rcó—y)aìA modern compression algorithm that is fast and highly flexible. Only supported by Mercurial 4.1 and newer clients. With the default settings, zstd compression is both faster and yields better compression than ``gzip``. It also frequently yields better compression than ``bzip2`` while operating at much higher speeds. If this engine is available and backwards compatibility is not a concern, it is likely the best available engine. )rsZSr#r,s rr>z_zstdengine.bundletype”s€ðrcó—tddd«S)Nré2rÅr,s rr?z_zstdengine.wireprotosupport¢rÇrcó—y)Nó(r#r,s rr@z_zstdengine.revlogheader¥rÁrNc#óK—|xsi}|jdd«}|jdd«}|j}|j||¬«j«}|D]}|j |«}|sŒ|–—Œ|j «–—y­w)NrÊésthreadsr)r×Úthreads)rÌrÚZstdCompressorrËrÍr¢) rrvrwr×rrºrÏr‹rÐs rrxz_zstdengine.compressstream¨s…èø€ØŠz�rˆð—‘˜ 1Ó%ˆà—(‘(˜: qÓ)ˆà�|‰|ˆØ × Ñ  e°WÐ Ó =× IÑ IÓ KˆÛˆEØ—:‘:˜eÓ$ˆDÚØ“ ðð �g‰g‹i‹ùs ‚A0B Á3B có.—t||j«Sr)r¶rrzs rr|z_zstdengine.decompressorreaderºs€Ü*¨2¨t¯|©|Ó<Ð||jz}|j|||«}|r|j |«|}||krŒ>|j |j ««ttt|««|krdj|«Sy)NrrrÚr) rŽr#rÍrËr&r�r¢rÜrÝr�) rrÐrÞrßrÏÚchunksrárâr‹s rrÍz)_zstdengine.zstdrevlogcompressor.compressÈsð€Ü˜“YˆFà˜A’:Ð �:à˜Š{Øà˜7Ò"Ø!ŸZ™Z×0Ñ0°Ó6� Ü�z“? VÒ+Ø%Ð%Øà—J‘J×*Ñ*Ó,�Ø�Ø�ؘF’lØ ×!1Ñ!1Ñ1�DØŸJ™J t¨C° ~Ó6�EÙØŸ ™  eÔ,Ø�Cð ˜F“lð — ‘ ˜aŸg™g›iÔ(ä”sœ3 Ó'Ó(¨6Ò1ØŸ8™8 FÓ+Ð+Ørcóˆ—t|«} |jj«}g}d}||kr>||jz}|j |||«}|r|j |«|}||krŒ>dj |«S#t$r9}tjtd«tj|«z«‚d}~wwxYw)Nrrrä) rŽr$ršr(r r�r�Ú Exceptionrrår<r ræ) rrÐrÞÚdobjr*rárâr‹rWs rr z+_zstdengine.zstdrevlogcompressor.decompressåsƀܘ“YˆFð ð—z‘z×/Ñ/Ó1�Ø�Ø�ؘF’lØ ×!3Ñ!3Ñ3�DØ ŸO™O¨D°°T¨NÓ;�EÙØŸ ™  eÔ,Ø�Cð ˜F“lð—x‘x Ó'Ð'øÜò Ü×(Ñ(ÜÐ4Ó5Ü ×-Ñ-¨aÓ0ñ1óðûð ús�A A?Á.A?Á? CÂ4B<Â<CN)rrçr#rrÚzstdrevlogcompressorr!½s„ó Kò ó: rr.có˜—|xsi}|jd«}|€|jd«}|€d}|j|j|¬«S)Ns zstd.levelrÊrrÛ)rÌr.rrês rrz_zstdengine.revlogcompressorýsP€ØŠz�rˆØ—‘˜Ó'ˆØ ˆ=Ø—H‘H˜XÓ&ˆEØ ˆ=؈EØ×(Ñ(¨¯©¸UÐ(ÓCÐCrr)rr!r"r rrrOr>r?r@rxr|r.rr#rrr r €sJ„òðñ óð ò"ò ò6òóò$=÷>ñ>ô@Drr có�—i}Gd„d«}tD]°}t|}|j«sŒ|j«}|r|dsŒ5d|dtj|j«fz}|«}tj |«|_|jj |_|j|_|||d<Œ²|S)z@Obtains a list of available bundle compressions for use in help.có —eZdZy)ú*bundlecompressiontopics..docobjectN)rr!r"r#rrÚ docobjectr2s„Ø rr3rs ``%s`` %s) Ú compenginesrOr>rÚgetdocÚsysstrriÚ_origdocÚ _origfunc)Úitemsr3r rAÚbtÚdocr s rÚbundlecompressiontopicsr< s¿€ð €E÷ ñ ÷ˆÜ˜TÑ"ˆà×ÑÔ!Ø à × Ñ Ó ˆÙ˜˜AšØ à 2 a¡5¬(¯/©/¸&×:KÑ:KÓ*LÐ"MÑMˆá“ ˆÜ Ÿ™¨Ó,ˆŒ Ø×*Ñ*×2Ñ2ˆŒØ ×+Ñ+ˆŒàˆˆb�‰eŠ ð#ð& €Lr)!r«Ú collectionsr™rrrrrr r„r<r[r\Ú namedtuplerÆrr%r4r:r�r–r©r²r¶r¾rFrìrörûr r<r]Ú i18nfunctionsr#rrÚr@sŠðó ÛÛ å÷ñõ à×"Ñ"€ ð ‡F�F€ð€ Ø € à.˜ ×.Ñ.Ø Ø0óÐ÷ (ñ (÷f:ñf:ñR Ó!€ ÷t$ñt$÷n&%ñ&%ôRÐ"9ôô&Ð!8ôô()Ð*Dô)ôÐ"9ôô*Y0Ð#ôY0ðx ×Ñ‘[“]Ô#ô".Ð"ô".ðJ ×Ñ‘Z“\Ô"ô 7Ð+ô 7ð ×ÑÑ(Ó*Ô+ô!+Ð#ô!+ðH ×Ñ‘[“]Ô#ôDDÐ#ôDDðN ×Ñ‘[“]Ô#òñ@(Ó)×0Ñ0Ó2� r