rust3 rustc 1.48.0std؝-6bf3f16f340782cacoreƞ-3375e4f89d420e7acompiler_builtins-f74b197469e67088rustc_std_workspace_core扪ڹ8-5e0675f526ef5c6ballocץޯČ-1ebf406bd4ea5769libcɄ-dfbef8c525de0186unwindܽ݇!-bd645b20c6c7b56dcfg_ifшC-b9e1e523c0c29a77 hashbrownǰ-c6632ca171f954ddrustc_std_workspace_allocW-b5bfd0198c7b740drustc_demangleة-3ac2d0878c297d42 addr2lineƄ-12740563628e601fgimlin-0ac82a1e1820dd21object»-af517d7f13e7c960 miniz_oxide֕㵤 -a2ba33c985785afeadler˯-3f6e9f8f4afbea6d panic_unwindի-13f3099d50c21bc6 unicode_widthஒK-ad20b503d31ef93f&}ft\pY ͍f' W?stdP8M q unicode_width/d$1/[-Nj5<"սueQd-BO&H]Y: ,\nBW\j<NBSPL1SfI#G indentationЏ+6m: indentlZ u됹r ҭ}:֟-ݑڢ dedent$LQ!ɏˣJ yաT[4vҡL& 9Ŵ'"|De1aM-h splittingWQ/9y q WordSplitter m&\B3Уsplit BߓsSg-1'w~l)upg~r "aDʇ^split-˫*<]y'w!TZ2ޣbTo7}splitx4(ObK9'wLL&%0I].#M[3C=`2%βawY RB7Xk8!C s8#]8ns7tQ6ȳ'a$8c=EqRnewЈy>BN'*ILдw?GМ!'aE UiKkm}!S $Qj:8! with_splitter 8+HCk!initial_indent6m[ Ƃ~OQa!subsequent_indentp/v}*hV! break_words1SSF  NoHyphenationB#%8J$V.D^h> /xsl犑!4Vw,@t9Ffmtd:hC\$JG׀ǷJaСHclone}f*FF`HyphenSplitterxjp[⯟ Jcb6rPhu)9n\Lfmt{%Rf/krv U)NclonejPt7Z*0|*"Wrapper V%Y]Td.P'aFbjT@ ͝JQPST 3,yIPwidthm9?8 7iPinitial_indentl%Wa k@jPsubsequent_indent} <KwӸP break_wordsۆ΃0I 0bPsplitterj|AN.ڂ#"k.z:ʍmX'aThMpx#;XSYm0:S Xfmt J|-䴉ĐTInڱ\'a!y&A<>\S{>UHD{\clone_hunK IntoWrapIter׈E08oŲDP>t?te'a/~,-DteS B~HO$=Nzefmtƒ6WrapIter%aHi'wxSN䒢֚i'aPcS - ,c"&iSr:2 9Lqiwrapper_1s^jQ)iinner$w 7ꏎX]$'٤YoΣo'w(;o'aZkC=6,}"!oSØy:/8LzofmtץLDs>>iN WrapIterImpl71Ruqu t'a4OQqtsourceDotb=aIAt char_indices terminal. A quick example: ```no_run  extern crate textwrap; use textwrap::fill; fn main() {? let text = "textwrap: a small library for wrapping text.";B$ println!("{}", fill(text, 18));' } ```( This will display the following output:+ ```text  textwrap: a small library for wrapping text. ``` # Displayed Width vs Byte Size"C To word wrap text, one must know the width of each word so one canFB know when to break lines. This library measures the width of textEC using the [displayed width][unicode-width], not the size in bytes.FC This is important for non-ASCII text. ASCII characters such as `a`F@ and `!` are simple and take up one column each. This means thatC< the displayed width is equal to the string length in bytes.?@ However, non-ASCII characters and symbols take up more than oneCF byte when UTF-8 encoded: `é` is `0xc3 0xa9` (two bytes) and `⚙` isI7 `0xe2 0x9a 0x99` (three bytes) in UTF-8, respectively. : C This is why we take care to use the displayed width instead of the F> byte count when computing line lengths. All functions in this A- library handle Unicode characters like this. 0 0 [unicode-width]: https://docs.rs/unicode-width/ 3 doc    html_root_url https://docs.rs/textwrap/0.11.0 ! : deny    missing_docs   deny    missing_debug_implementations  ' P\X!`e-io28t9ABC'\u{a0}' A non-breaking space. C Functions related to adding and removing indentation from lines ofF text. = The functions here can be used to uniformly indent or dedent@' (unindent) word wrapped lines of text.ʄ*            9csprefix.# Add prefix to each non-empty line.& ``` use textwrap::indent;Å assert_eq!(indent("Dž Foo߅ Bar ", " "), " Foo  Bar  "); ```C Empty lines (lines consisting only of whitespace) are not indentedF; and the whitespace is replaced by a single newline (`\n`):> ``` use textwrap::indent;Ӈ assert_eq!(indent("ׇ Foo Bar \t Baz ", "->"), " ->Foo  ->Bar  ->Baz  ");ʈ ```҈ڈ; Leading and trailing whitespace on non-empty lines is keptވ> unchanged: ``` use textwrap::indent;҉< assert_eq!(indent(" \t Foo ", "->"), "-> \t Foo \n");։? ```   ) 9999      :   ;;;cˏsҏď 2 Removes common leading whitespace from each line.ƌ5A This function will look at each non-empty line and determine theDA maximum amount of whitespace that can be removed from all lines:ōD ``` use textwrap::dedent; assert_eq!(dedent(" 1st line̎ 2nd lineݎ 3rd line "), "  1st line  2nd line 3rd line  "); ``` DDՏ  Word splitting functionality.!? To wrap text into lines, long words sometimes need to be splitB6 across lines. The [`WordSplitter`] trait defines thisܾ9C functionality. [`HyphenSplitter`] is the default implementation ofF< this treat: it will simply split words on existing hyphens.ݿ?DHFJNL " An interface for splitting words.%C When the [`wrap_iter`] method will try to fit text into a line, itF? will eventually find a word that it too large the current textBD width. It will then call the currently configured `WordSplitter` toGA have it attempt to split the word into smaller parts. This traitD7 describes that functionality via the [`split`] method.:A If the `textwrap` crate has been compiled with the `hyphenation`DC feature enabled, you will find an implementation of `WordSplitter`FC by the `hyphenation::language::Corpus` struct. Use this struct forFB language-aware hyphenation. See the [`hyphenation` documentation]E for details.7 [`wrap_iter`]: ../struct.Wrapper.html#method.wrap_iter: [`split`]: #tymethod.split< [`hyphenation` documentation]: https://docs.rs/hyphenation/?SelfselfwordG; Return all possible splits of word. Each split is a triple>: with a head, a hyphen, and a tail where `head + &hyphen +=> &tail == word`. The hyphen can be empty if there is already aA hyphen in the head.9 The splits should go from smallest to longest and should<; include no split at all. So the word "technology" could be> split into ```no_run  vec![("tech", "-", "nology"),! ("technol", "-", "ogy"),! ("technolo", "-", "gy"),! ("technology", "", "")];! ``` Self Z 'w#[[[? `NoHyphenation` implements `WordSplitter` by not splitting theB word at all.D\selfwordk  \ 'w#\\\ 7 `HyphenSplitter` is the default `WordSplitter` used by:C `Wrapper::new`. It will split words on any existing hyphens in theF word. = It will only use hyphens that are surrounded by alphanumeric@> characters, which prevents a word like "--foo-bar" from beingA% split on the first or second hyphen.(J`selfword   ` 'w#``` P'a`'awidth u= Create a new Wrapper for wrapping at the specified width. By@< default, we allow words longer than `width` to be broken. A?9 [`HyphenSplitter`] will be used by default for splitting<9 words. See the [`WordSplitter`] trait for other options.</ [`HyphenSplitter`]: struct.HyphenSplitter.html2* [`WordSplitter`]: trait.WordSplitter.html- 'aa $$B$%&'()*,P"'aS'a"S##"e$e$ width&splitter&&; Use the given [`WordSplitter`] to create a new Wrapper for$>< wrapping at the specified width. By default, we allow words$?" longer than `width` to be broken.%%%* [`WordSplitter`]: trait.WordSplitter.html%-& $"'aeeee!!'''''' '''''h'((&e&h&h&'&e(((((((& Pe&e&e&&e'&h'&h'&h'&h'&e(width&splitter&&self,indent,,; Change [`self.initial_indent`]. The initial indentation is(>' used on the very first line of output.(*) # Examples))? Classic paragraph indentation can be achieved by specifying an)B; initial indentation and wrapping each paragraph by itself:*>* ```no_run*  # #![allow(unused_variables)]*! use textwrap::Wrapper;++7 let wrapper = Wrapper::new(15).initial_indent(" ");+: ```++5 [`self.initial_indent`]: #structfield.initial_indent,8, %"'aee "'ae!!---Jee-Jh-Jhh-J-Jee--,k,k,h,-Jh-self,indent,,self2indent22> Change [`self.subsequent_indent`]. The subsequent indentation-A5 is used on lines following the first line of output..8. # Examples..? Combining initial and subsequent indentation lets you format a/B# single paragraph as a bullet list:/&/ ```no_run0  # #![allow(unused_variables)]0! use textwrap::Wrapper;00 let wrapper = Wrapper::new(15)0" .initial_indent("* ")1 .subsequent_indent(" ");1! ```11; [`self.subsequent_indent`]: #structfield.subsequent_indent1>2 &"'aeeqe!!332Mee2Mhh2Mh2M2Mee332k2k2h22Mh3self2indent22self5setting55; Change [`self.break_words`]. This controls if words longer3>9 than `self.width` can be broken, or if they will be left4<$ sticking out into the right margin.4'4/ [`self.break_words`]: #structfield.break_words525 '"'aeee!!665Hee5Hhh5Hhh5H5Hee665k5k555H6self5setting55self<s=<< Fill a line of text at `self.width` characters. Strings are6?: wrapped based on their displayed width, not their size in7= bytes.7 7< The result is a string with newlines between each line. Use7?> the `wrap` method if you need access to the individual lines.8A8 # Complexities99? This method simply joins the lines produced by `wrap_iter`. As9B> such, it inherits the O(*n*) time and memory complexity where9A *n* is the input string length.:#: # Examples:: ```: use textwrap::Wrapper;;; let wrapper = Wrapper::new(15);;#F assert_eq!(wrapper.fill("Memory safety without garbage collection."),;I; "Memory safety\nwithout garbage\ncollection.");<> ```<< ("'ae eDD!<!> > >>>>> D><>>> >>>0>.>>>> > >> *e > > >>.> )ie> ?>.>0>0 (>0>0>. >. >>. >. >. >.>. >. >.>. )  >.>. >  >  >.>. ??? ? >.?>.> >  Somee> > > > >  >>>.>. >> e>>>> >/>>>?e?>; >;????? ? ? ??>;? ???????????? ????? ???????????? >???? ?<>>>> >D>  k<h=e>h>>0>.>>h>>.>.>. >.є>.> > > e>>>/e>;? D?;?ݕ?h?h? ???self<s=result> iter>. __next>. val> i>line><selfJsJJi< Wrap a line of text at `self.width` characters. Strings are@?: wrapped based on their displayed width, not their size in@= bytes.A A # ComplexitiesAA? This method simply collects the lines produced by `wrap_iter`.AB8 As such, it inherits the O(*n*) overall time and memoryB;1 complexity where *n* is the input string length.B4B # ExamplesCC ```C use textwrap::Wrapper;CC let wrap15 = Wrapper::new(15);C"; assert_eq!(wrap15.wrap("Concurrency without data races."),C> vec!["Concurrency",D" "without data",D# "races."]);EE let wrap20 = Wrapper::new(20);E"; assert_eq!(wrap20.wrap("Concurrency without data races."),E>' vec!["Concurrency without",F*! "data races."]);F$ ```FG< Notice that newlines in the input are preserved. This meansG?9 that they force a line break, regardless of how long theG< current line is:HH ```H use textwrap::Wrapper;HH let wrapper = Wrapper::new(40);H#6 assert_eq!(wrapper.wrap("First line.\nSecond line."),I91 vec!["First line.", "Second line."]);I4 ```JJJ )"'aeq#"'a!J!JJJJJJJ ҈J JJJ%J )#JJKJiJJhJJ%JJ%JJ%hJselfJsJJiselfYsYY? Lazily wrap a line of text at `self.width` characters. StringsKB> are wrapped based on their displayed width, not their size inKA bytes.L L9 The [`WordSplitter`] stored in [`self.splitter`] is usedL<> whenever when a word is too large to fit on the current line.LA? By changing the field, different hyphenation strategies can beMB implemented.MN # ComplexitiesNN? This method returns a [`WrapIter`] iterator which borrows thisNB: `Wrapper`. The algorithm used has a linear complexity, soN=? getting the next line from the iterator will take O(*w*) time,OB? where *w* is the wrapping width. Fully processing the iteratorPB9 will take O(*n*) time for an input string of length *n*.P<Q> When no indentation is used, each line returned is a slice ofQA; the input string and the memory overhead is thus constant.Q>: Otherwise new memory is allocated for each line returned.R=R # ExamplesRR ```S use std::borrow::Cow;S use textwrap::Wrapper;SS let wrap20 = Wrapper::new(20);S"C let mut wrap20_iter = wrap20.wrap_iter("Zero-cost abstractions.");SF> assert_eq!(wrap20_iter.next(), Some(Cow::from("Zero-cost")));TAB assert_eq!(wrap20_iter.next(), Some(Cow::from("abstractions.")));UE& assert_eq!(wrap20_iter.next(), None);U)V let wrap25 = Wrapper::new(25);V"C let mut wrap25_iter = wrap25.wrap_iter("Zero-cost abstractions.");VFL assert_eq!(wrap25_iter.next(), Some(Cow::from("Zero-cost abstractions.")));WO& assert_eq!(wrap25_iter.next(), None);W) ```XX) [`self.splitter`]: #structfield.splitterX,* [`WordSplitter`]: trait.WordSplitter.htmlX-# [`WrapIter`]: struct.WrapIter.htmlX&Y *"'ae +'weqi+'w"'ae!Y!ZZZZZZZZZ ;eZZZY^Y^tZZZYYYhYY^ZY^ZY^ZY^hZselfYsYYselfesed? Lazily wrap a line of text at `self.width` characters. StringsZB> are wrapped based on their displayed width, not their size in[A bytes.[ [9 The [`WordSplitter`] stored in [`self.splitter`] is used[<> whenever when a word is too large to fit on the current line.\A? By changing the field, different hyphenation strategies can be]B implemented.]] # Complexities]^1 This method consumes the `Wrapper` and returns a^4= [`IntoWrapIter`] iterator. Fully processing the iterator has^@? the same O(*n*) time complexity as [`wrap_iter`], where *n* is_B the length of the input string._#_ # Examples_` ```` use std::borrow::Cow;` use textwrap::Wrapper;`` let wrap20 = Wrapper::new(20);`"H let mut wrap20_iter = wrap20.into_wrap_iter("Zero-cost abstractions.");aK> assert_eq!(wrap20_iter.next(), Some(Cow::from("Zero-cost")));aAB assert_eq!(wrap20_iter.next(), Some(Cow::from("abstractions.")));bE& assert_eq!(wrap20_iter.next(), None);b) ```cc) [`self.splitter`]: #structfield.splitterc,* [`WordSplitter`]: trait.WordSplitter.htmlc-+ [`IntoWrapIter`]: struct.IntoWrapIter.htmld.! [`wrap_iter`]: #method.wrap_iterd$d ,"'aeeq`"'ae!!eeeeeeeeeed eeeffffeMkeMfffffde `eekeheeeeheeMkfeMfselfeseinnered kk01`.'ae)'a.S//.ekek kk.'a--selfk kYk 1.'ae -k-l l l l l kl ll ?elllllkYl k l l ll ll selfk kY pp67i3'w4'aS)'w3'a4S55434'a3'wppp qq4'a22selfq qXq 73'w4'a 2q2q q r r  Pqr ?rrrrqXq iq qq qr selfq qXr chsr"A Like `char::is_whitespace`, but non-breaking spaces don't count.rDrinlinerr 8sssss :ss s s s s s s sss  sss sssss rKsss ss ss s s schsrKsy(;=?t:'a'a::wrapperyszyy ;:'ae P:'ae :'a9S<<z9eyey zz{{{{{ D{{{{{h{|  |||| | h|| || zhzze{eze{eze{ezezez|z}}}}}}y zyhzzhzz{zh{ze{zh{ze|zh|wrapperyszyself}wrapper}}} =:'ae  :'a9S>>}9e}e} ~ ~ e~e~~~h~$~  h~$~~~h~!~ ~!~~~}}  }}~e~ ~!h~~$h~self}wrapper}}selfwrapper" ?:'ae 9S@@9ee c 2 5"€ ġހހހހ )̀ ̀͟>  e  h\ҀҀSomeee׀׀Some            ,e e    ʁ ʁ ʁ ́   ́ ց   ;*++ +*e eeӂ*e/<  ee e  h/ Z؅؅ Ņ =eŅ߅߅,$#    h! " "e # #e!e"!e##"## e !#! $,, h, Ɔ $Ɔ $eӆ%ӆ%eƆ&$%Ɔ &$%(e&e%$!'((h!(' (3e''͇)͇)ȇ Some)ȇ ч)  +*,94566eƋ 7Ƌ 7 867 867!:,,,//׉e//00 e00-- .e- .e-e.e-,Պ1Պ1e 2 2 Պ312Պ 312 7e3e21Y58eϋ7ϋ6Ӌ 9Ӌ 9e,459ߋ9ߋ54"#՞X :*; < <h=> ? ?eʍ@ʍ@eA?@ A?@$>Ae׍@׍?=e>ٍ>** e<=;%*ڍ=ڍ<+:; B"CDD:" DD C&DE CE')(B:+" ŽFŽFCSomeeɎGɎHɎH:؎IڎJڎJF؎IeJڎJɎɎ eHIG*ɎێIێHȎBGێGێF+C KKh׏LMMe N NB" eMNL, NM5 O3 P Q R S T TL  #hhhTS-.  RS T  >RQ/.L R3  *7QP0.3 Q5 5 (΂PO1.55 P3 U3 UO 23 V3 W3 X3 Y3 YU3 XY3 3 )XW3.33 X Z W Z4653 Y3 W 73  [ [WSome  \ \[ V\ \ [3 Y3 W ] ]Vh ^ ^VhؐF4 _ؐ5 `ؐ' aؐ bؐ be c d d] dc8.  V U3 S3 OՔ7 qՔ rՔ re s seՔ qrs s rҔ qAB dؐ' ebcؐ' ebc9.ؐ' aee c b f g g^ gf:. gؐ5 hafؐ5 haf;.ؐ5 `he f a i ieؐF _ `i i `Ր _<= _ ^ ] V 2 j k ke l m m] ml>. m nkl nkl?. jne l k) oej) oej@. ) eoe j eѓe p p^ Kp p _ ^ ] 7Ҕ I6 t t tCD w we x y z { {L  e{ezE.  u u eu u ee v ve˗* ev v H { yzh yxF. y |wx |wxG. ۘ+ e|e x w z ee } }e̙* e} } H tҔ I  q8 ~  e  e ~ ʚ ʚ  ~JKLW      L.  ,$#  h  eț ț eeeћћ##MN#ққ$,,ON, . ққӛӛKPN  ee QN(eeߜ!ߜߜhߜ!RN̜4e̜4 eSN̜4eee+e+ eTN+ee   םeם eUNםee Some  LVLKB;:~4*LKB;:~X4Y*Z   e e[ee  € ]^ġΠΠ _ՠՠ"  h   e e`a""ba"  Some "ӏ       2€ހ€ ހ̀eҀ׀e e eʁeee/<ee eeeh ؅;, h$h#h e e eƆ eӆެƆe!h͇;:eެeeeՊe ެՊ,9eeeƋ ެeӋ hh*h ee eʍެh "heŽhɎhɎ؎eڎh ׏ eh 53΂  ճ 3 υ3 υ3 33υ υh h ՐؐF4Րeؐ5Րeؐ'ՐeؐՐe Րhެؐ'Րe Րhެؐ5Րe eee hެެ)hՔ7eՔ e 6eee eh υ ެe8e e  ;,٭h$h#h e eț ;٭he eެeߜ!hߜެ̜4eެ+e ެםe ެ>e eh Π;"٭hhh  e self wrapperidxҀch׀ char_width  char_len lineremaining_text: final_word BiŽFhyphen Ksplits׏ Liter3 U__next3 Vval [head ]hyp ^lineline"swidth,? Fill a line of text at `width` characters. Strings are wrappedB9 based on their displayed width, not their size in bytes.<< The result is a string with newlines between each line. Use?7 [`wrap`] if you need access to the individual lines or:, [`wrap_iter`] for its iterator counterpart./ک ```ީ use textwrap::fill;B assert_eq!(fill("Memory safety without garbage collection.", 15),E; "Memory safety\nwithout garbage\ncollection.");Ȫ> ```B This function creates a Wrapper on the fly with default settings.EC If you need to set a language corpus for automatic hyphenation, or٫FD need to fill many strings, then it is suggested to create a WrapperG and call its [`fill` method].! [`wrap`]: fn.wrap.html! [`wrap_iter`]: fn.wrap_iter.html$1 [`fill` method]: struct.Wrapper.html#method.fillέ4 ADeDswidth3? Wrap a line of text at `width` characters. Strings are wrappedծB9 based on their displayed width, not their size in bytes.<կB This function creates a Wrapper on the fly with default settings.ٯEC If you need to set a language corpus for automatic hyphenation, orFD need to wrap many strings, then it is suggested to create a WrapperG and call its [`wrap` method].!бD The result is a vector of strings. Use [`wrap_iter`] if you need anԱG iterator version. # ExamplesŲ ```ɲ use textwrap::wrap;Ѳ8 assert_eq!(wrap("Concurrency without data races.", 15),; vec!["Concurrency"," "without data",̳# "races."]);8 assert_eq!(wrap("Concurrency without data races.", 20),;' vec!["Concurrency without",д*! "data races."]);$ ```! [`wrap_iter`]: fn.wrap_iter.html$1 [`wrap` method]: struct.Wrapper.html#method.wrapѵ4 BDe# swidthG> Lazily wrap a line of text at `width` characters. Strings are߶AA wrapped based on their displayed width, not their size in bytes.DB This function creates a Wrapper on the fly with default settings.E? It then calls the [`into_wrap_iter`] method. Hence, the returnBA value is an [`IntoWrapIter`], not a [`WrapIter`] as the functionD name would otherwise suggest.!ڹC If you need to set a language corpus for automatic hyphenation, or޹FD need to wrap many strings, then it is suggested to create a WrapperG: and call its [`wrap_iter`] or [`into_wrap_iter`] methods.= # Examples ```» use std::borrow::Cow;ʻ use textwrap::wrap_iter;@ let mut wrap20_iter = wrap_iter("Zero-cost abstractions.", 20);C> assert_eq!(wrap20_iter.next(), Some(Cow::from("Zero-cost")));ɼAB assert_eq!(wrap20_iter.next(), Some(Cow::from("abstractions.")));E& assert_eq!(wrap20_iter.next(), None);ѽ)@ let mut wrap25_iter = wrap_iter("Zero-cost abstractions.", 25);CL assert_eq!(wrap25_iter.next(), Some(Cow::from("Zero-cost abstractions.")));þO& assert_eq!(wrap25_iter.next(), None);) ```ſ4 [`wrap_iter`]: struct.Wrapper.html#method.wrap_iterɿ7> [`into_wrap_iter`]: struct.Wrapper.html#method.into_wrap_iterA+ [`IntoWrapIter`]: struct.IntoWrapIter.html.# [`WrapIter`]: struct.WrapIter.html& CDe`` E8 Use this as a [`Wrapper.splitter`] to avoid any kind of; hyphenation: ```( use textwrap::{Wrapper, NoHyphenation};+8 let wrapper = Wrapper::with_splitter(8, NoHyphenation);;A assert_eq!(wrapper.wrap("foo bar-baz"), vec!["foo", "bar-baz"]);D ```B [`Wrapper.splitter`]: ../struct.Wrapper.html#structfield.splitterE\E\DD  automatically_derived   allow    unused_qualifications  G\3\selff   G\ 2;F F  automatically_derived   allow    unused_qualifications  I\ \self   inline   I\\H H  \  \ self  K= Simple and default way to split words: splitting on existing@ hyphens only.A You probably don't need to use this type since it's already usedD by default by `Wrapper::new`.!`K`JJautomatically_derived allow  unused_qualificationsM`3`selff M`LLautomatically_derivedallow unused_qualificationsO` `self inline O``NN` `self ? A Wrapper holds settings for wrapping and filling text. Use itBD when the convenience [`wrap_iter`], [`wrap`] and [`fill`] functionsG are not flexible enough.! [`wrap_iter`]: fn.wrap_iter.html$ [`wrap`]: fn.wrap.html [`fill`]: fn.fill.htmlA The algorithm used by the `WrapIter` iterator (returned from theDB `wrap_iter` method) works by doing successive partial scans overEB words in the input string (where each single scan yields a singleEE line) so that the overall time and memory complexity is O(*n*) whereH' *n* is the length of the input string.*STUVWPQ'ae!'aQSRQRee 8 The width in columns at which the text will be wrapped.;ePP/ Indentation used for the first line of output.2 Q'aPP1 Indentation used for subsequent lines of output.4PP< Allow long words to be broken if they cannot fit on a line.?3 When set to `false`, some lines may be longer than6 `self.width`. PP= The method for splitting words. If the `hyphenation` feature@= is enabled, you can use a `hyphenation::Standard` dictionary@( here to get language-aware hyphenation.+ePP automatically_derivedallow unused_qualifications[PY'ae3'aYSZYZee 3eselff [Y'ae XXehhe     hWrapper  3        hwidth 3 1    hinitial_indenthsubsequent_indent !"##"#!" !!  #"$%%&''h break_words  &'()*++*+)*())%&($(&%+*'$,--.//hsplitter./012332312011-.0, 0.-32/,44 1445 2 e h 1hh hh hh hhhh ҌҌhh selff __self_0_0 __self_0_1 __self_0_2 __self_0_3 __self_0_4debug_trait_builder automatically_derivedallow unused_qualifications_P]'ae 'a]S^]^ee  eself inline _]'ae \\ehhe     e        h        eeh he    kҌehhhhҌҌeself __self_0_0 __self_0_1 __self_0_2 __self_0_3 __self_0_4 jj jj< An iterator over the lines of the input string which owns af?? `Wrapper`. An instance of `IntoWrapIter` is typically obtainedgB= through either [`wrap_iter`] or [`Wrapper::into_wrap_iter`].g@hE Each call of `.next()` method yields a line wrapped in `Some` if thehHD input hasn't been fully processed yet. Otherwise it returns `None`.hGi! [`wrap_iter`]: fn.wrap_iter.htmli$G [`Wrapper::into_wrap_iter`]: struct.Wrapper.html#method.into_wrap_iteriJcd`a'ae'aaSbabejej jjPa'ae``jjta'a`` jjjautomatically_derivedjjjallowjjj unused_qualificationsjjh`f'ae3'afSggfejej jselfjfjjj hf'ae eje jjkjjjjjjjjh IntoWrapIter  jjjjjjj j j j j j jhwrapperj j jjjjjjj jjj    jj j j jjj j jjjjjjjhinnerjjjjjjjjjkjjj jjjjjjjjjjjˊjjjjjjjjjjjj jjjjjhjhjjjhjhjj jjjjjhjhjj jjjjjselfjfj __self_0_0j __self_0_1jdebug_trait_builderj poow? An iterator over the lines of the input string which borrows alB; `Wrapper`. An instance of `WrapIter` is typically obtainedm>+ through the [`Wrapper::wrap_iter`] method.m.mE Each call of `.next()` method yields a line wrapped in `Some` if themHD input hasn't been fully processed yet. Otherwise it returns `None`.nGo= [`Wrapper::wrap_iter`]: struct.Wrapper.html#method.wrap_itero@mnij'wk'a'wj'akSljlkjk'aj'wppj'wpp p޸ppp j'wPk'aiipptk'aii oooautomatically_derivedoooallowooo unused_qualificationsoosip'wq'a3'wp'aqSrqprq'ap'wpop'wpp 3oselfofooo sp'wq'a ooo ppppoooooohWrapIterooooooo o o p p p phwrapperp p ppppppp poo    oo o o ooo o ooopppphinnerppppppppppooo oooooooooooˊoooooooooooo oo ppohohooohphpp pppoohphpppppooselfofo __self_0_0p __self_0_1pdebug_trait_builderot tA Common implementation details for `WrapIter` and `IntoWrapIter`.sDvwxyz{|}~tu'a9'auutt u'attuu u'attu uettv vettww ettww ettxxettxx ttyyttttautomatically_derivedtttallowttt unused_qualificationsttt'a3'aselftfttt 'a t y } /#!'%&*?--../$0c0 22269*=h?SKGRu[bb;cucddee(gWii -m'ao.=ٰb[{1i϶hnQE> @/;ma+So1#!)%&*A--0./&0e0"22269,=j?UKIRw[bb=cwcddee*gYii!/m(co/ ?$߰ha}3kնioSF@ F0 <ob,Tp4#!,%&*D--3./)0f0%22269-=k?VKJRx[bb@czcddee-g\ii"2m)fo0!@%ib6nֶjpVGC G1 ?rc /Ws'#%&,:--)./012338;'>BPY`bEccdeegRii8mlo˨ܲVv<dDŶM\2LH$6Dhz4\x-9+"#!1%&*K--:.//0k0+22 693=q?[K'PR*~[!bEcceee2gbii8mlo'F +  o<t"ܶ oĺu[HL Dw4\x$u$& K*-//0+2bebiɰKmҼFct }!"%!,--//00132388;,>BPY`bJcceeegeii=mqoɰKhBJrRa7ӼM)HdvI9a}![ %!,-/13G8;;>BPY`cegiLmoıFN\8-/ce s!%'-. 023Y8<D>BPY`cegiqmo˰MRVoHW!d%!L*(--./ 0?02D23[8<F>BPY` cYcc%eeegqiismo˰MjRV\b9qJY{/UGc !%b*6--%./0P02b23c8 <N>BPY`+caccNee fgiimoɨѰSr`d djA~Ww7]8'Okd*"3g8<R>BPY`cfgjmoh[ &"5e9 =P?;K/R][bdgQimCoU.y.Pdx#7K_}(BYm-OrBVm &?au & ? X v  ) = Q i }  C c   4 U l  . E \ r 9Pk%Gdx 3G[o@Th|';Om2I]q?b2F]s/Qe|  / H f  - A Y m 3 S p $ E \ r   5 L b ~ )@[|7Th#7K_s666667777% ;  ° eh   ee e  e3e3 h'# U׳D             ׳   ׳    ׳                                             B7DDDDD eee;DD@@AAAB͉*F*;*;*F*F; ;;;F*;;;)e&; 9e;)݆h*΂)*e ee ee; e)i`);*;;);*F;))΂  ̱" ee ee;HHHHHHHHH?>e>e?;>e>>>>>>>>?6==77766e66665;  ·,hh ,ïeD;,@ ;,ŷ,e, ,,,e),, ,e/ȸ/   /ȸ ȸ;ȸ; C&;; h;#######%$###############%׳r׳p׳;((((((( (%%%$$----ï-ŷ----ոG+M60ȸ0͹0;0͹0eȸ00ȸ0͹0e00͹0;0eȸ6666$e%@;%7`%;;;;;;  =`;`?`$`,`(`)`*`AB C;;ڃ5;·΂$C ee ẖ7C"crate@$crate=$crate:$cratecore4$cratecoreB$crate?$crate<$crate9$crate6$crate corecorecorecorecrateD$crateA$crate>$crate;$crate8$crate5$crate corecorecore@Ք=ؐF:>4Debug txCcore_intrinsics3Clone6;core_intrinsicsderive_clone_copy DebugxCcore_intrinsics3/B,?<Clone6;core_intrinsicsderive_clone_copy 9>6Debug oxCcore_intrinsics3DebugxCcore_intrinsics3Dprelude_importA>;Clone6;core_intrinsicsderive_clone_copy  8>5DebugxCcore_intrinsics3DebugjxCcore_intrinsics3derivejjderivet derivederivederiveow derive $$'%$2%$$=$=%$U$H$%$ %$0$%z$#$$m$$$`$$H%h')((((('"'%*(&&](&%%(&(&}%'r&j%'_&W%'L&U'U/home/seth/.cargo/registry/src/github.com-1ecc6299db9ec823/textwrap-0.11.0/src/lib.rsBG3C_k/NFG?C(, #GFGGD@DJ;GB14;( %$BCH%EFFI+*@7!9$D;EE0'EDAA72>6GED@:&,1 "="+CD*2H # C/GC&? =E$ F=G+&'"& CH' CA,7@" DBDFGF( (NC ,<)99#$ DBG@9 'C'($'C/) DA (>9 :.GFAFGGBGGAFCB 'KFJ.'KT. 12+H/ GFAFG9EG( 'PFJ. 123)E1 @CAIH%K/=1'C?/IHA8!E1&E %%E.#1CB.5 /1X,8A" ^.1 \ ?6*"+<,VVEEB>I'*B(0&/I+EF6,RL5,%A=`BG;C,&.J>-8*,D/E,D-EB$>JA3',+ ,=0  GGCB "7>?":C=@;0F?FGH"%5/ C=FGH"H<#$ <+%%56 BEFCE"GH>DBF*DP*8B/'J* $$1 2 G E 9 L J @ @ K *FAF(J EA.0  E@? #F;9  $>* S3 !TR TP = :> I :12  :@ = $:B E :H @I $P(2- >23  $!CP>2.  $D1P>:(F (F )C  $(P:RP--  E 'Q "K #CC 2@E %G :D :H =* 晑Ѥ춑]/home/seth/.cargo/registry/src/github.com-1ecc6299db9ec823/textwrap-0.11.0/src/indentation.rsN:x@K G A+' G?    ?@1$6%#  6EE  #>-/%& 9). ?$-G& C'J. C$S9# 6("  E*  . ' !; ' !; $ ' !5 ' !5 '"$&&' !5 '""$&&' !5 '#5 '$ #5 '*"%5 '+"%!5 '2,*#嗆M[/home/seth/.cargo/registry/src/github.com-1ecc6299db9ec823/textwrap-0.11.0/src/splitting.rs.Ip>a"C:G@ )&GCHE;EGGF;@CBFAC&&&& L<,