["aho_corasick",{"doc":"A library for finding occurrences of many patterns at …","t":"FFGGPPFPPFFFPPTPPTFFGGPPFFTFPGFPPPPPTNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNCNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOKGFFTTPPFPFTFFFTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMMMMMMMMNNNNNNMNNMMMNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFPPGFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AhoCorasick","AhoCorasickBuilder","AhoCorasickKind","Anchored","Anchored","Both","BuildError","ContiguousNFA","DFA","FindIter","FindOverlappingIter","Input","InvalidInputAnchored","InvalidInputUnanchored","LIMIT","LeftmostFirst","LeftmostLongest","MAX","Match","MatchError","MatchErrorKind","MatchKind","No","NoncontiguousNFA","PatternID","PatternIDError","SIZE","Span","Standard","StartKind","StreamFindIter","Unanchored","UnsupportedEmpty","UnsupportedOverlapping","UnsupportedStream","Yes","ZERO","anchored","as_i32","as_u32","as_u64","as_usize","ascii_case_insensitive","attempted","automaton","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","builder","byte_classes","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","contains","default","default","default","default","dense_depth","dfa","earliest","end","end","end","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","find","find_iter","find_overlapping","find_overlapping_iter","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_ne_bytes","from_ne_bytes_unchecked","from_u32_unchecked","get_anchored","get_earliest","get_range","get_span","hash","hash","hash","haystack","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","invalid_input_anchored","invalid_input_unanchored","is_anchored","is_done","is_empty","is_empty","is_match","kind","kind","kind","len","len","match_kind","match_kind","max_pattern_len","memory_usage","min_pattern_len","must","must","new","new","new","new","new","new","new_unchecked","next","next","next","nfa","offset","offset","one_more","packed","partial_cmp","pattern","patterns_len","prefilter","range","range","range","replace_all","replace_all_bytes","replace_all_with","replace_all_with_bytes","set_anchored","set_earliest","set_end","set_range","set_span","set_start","span","span","start","start","start","start_kind","start_kind","stream_find_iter","to_ne_bytes","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_find","try_find_iter","try_find_overlapping","try_find_overlapping_iter","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try
["anstream",{"doc":"<strong>Auto-adapting <code>stdout</code> / <code>stderr</code> streams</strong>","t":"PPPFEGPIIFCNNNNNNNNNNNNNNQQNNNNNNNNNNNNNNNNNNNNNNNNQQQHHCNNNNNNNNNNNNNNNNNNNFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKKKRMM","n":["Always","AlwaysAnsi","Auto","AutoStream","Buffer","ColorChoice","Never","Stderr","Stdout","StripStream","adapter","always","always_ansi","auto","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","choice","clone","clone_into","current_choice","default","eprint","eprintln","eq","flush","flush","fmt","fmt","fmt","from","from","from","global","into","into","into","into_inner","into_inner","is_terminal","is_terminal","lock","lock","lock","lock","never","new","new","panic","print","println","stderr","stdout","stream","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","write","write","write_all","write_all","write_fmt","write_fmt","write_global","write_vectored","write_vectored","StripBytes","StripBytesIter","StripStr","StripStrIter","StrippedBytes","StrippedStr","WinconBytes","WinconBytesIter","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","default","default","default","default","default","eq","eq","eq","eq","eq","eq","eq","eq","extend","extract_next","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","into_iter","into_vec","is_empty","new","new","new","new","next","next","next","next","next","strip_bytes","strip_next","strip_next","strip_str","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","AsLockedWrite","IsTerminal","RawStream","Write","as_locked_write","is_terminal"],"q":[[0,"anstream"],[76,"anstream::adapter"],[201,"anstream::stream"],[207,"std::io::error"],[208,"std::io"],[209,"core::fmt"],[210,"core::fmt"],[211,"core::fmt"],[212,"std::io::stdio"],[213,"core::fmt"],[214,"core::option"],[215,"alloc::string"]],"d":["Try very hard to emit colors.","Like <code>Always</code>, except it never tries to use anything other …","Use colors if the output device appears to support them","<code>std::io::Write</code> that adapts ANSI escape codes to the …","","Selection for overriding color output Selection for …","Never emit colors.","An adaptive wrapper around the global standard error …","An adaptive wrapper around the global standard output …","Only pass printable data to the inner <code>Write</code>","Gracefully degrade styled output","Force color, no matter what the inner <code>Write</code> supports.","Force ANSI escape codes to be passed through as-is, no …","Auto-adapt for the stream’s capabilities","","","","","","","Report the desired choice for the given stream","","","Prefer <code>AutoStream::choice</code>","","Prints to <code>stderr</code>.","Prints to <code>stderr</code>, with a newline.","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get the current <code>ColorChoice</code> state","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Get the wrapped <code>RawStream</code>","Get the wrapped <code>std::io::Write</code>","Returns <code>true</code> if the descriptor/handle refers to a …","Returns <code>true</code> if the descriptor/handle refers to a …","Get exclusive access to the <code>AutoStream</code>","Getexclusiveac
["anstyle",{"doc":"ANSI Text Styling","t":"PPFGTTPPPPPPPPPPTGPTTTTFFPTTTPPFPFTFTPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Ansi","Ansi256","Ansi256Color","AnsiColor","BLINK","BOLD","Black","Blue","BrightBlack","BrightBlue","BrightCyan","BrightGreen","BrightMagenta","BrightRed","BrightWhite","BrightYellow","CURLY_UNDERLINE","Color","Cyan","DASHED_UNDERLINE","DIMMED","DOTTED_UNDERLINE","DOUBLE_UNDERLINE","EffectIter","Effects","Green","HIDDEN","INVERT","ITALIC","Magenta","Red","Reset","Rgb","RgbColor","STRIKETHROUGH","Style","UNDERLINE","White","Yellow","b","bg_color","bitor","bitor","bitor_assign","bitor_assign","blink","bold","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bright","clear","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","cmp","cmp","contains","default","default","default","dimmed","effects","eq","eq","eq","eq","eq","eq","eq","eq","eq","fg_color","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_ansi","g","get_bg_color","get_effects","get_fg_color","get_underline_color","hash","hash","hash","hash","hash","hash","hash","hidden","index","insert","into","into","into","into","into","into","into","into","into_ansi","into_iter","invert","is_bright","is_plain","is_plain","italic","iter","new","new","next","on","on","on","on","on_default","on_default","on_default","on_default","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","r","remove","render","render","render","render_bg","render_bg","render_bg","render_bg","render_fg","render_fg","render_fg","render_fg","render_reset","set","strikethrough","sub","sub","sub_assign","sub_assign","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","underline","underline_color","write_reset_to","write_to"],"q":[[0,"anstyle"],[239,"core::option"],[240,"core::cmp"],[241,"core::fmt"],[242,"core::fmt"],[243,"core::convert"],[244,"core::fmt"],[245,"alloc::string"],[246,"core::result"],[247,"core::any"],[248,"std::io"],[249,"std::io::error"]],"d":["Available 4-bit ANSI color palette codes","256 (8-bit) color support","256 (8-bit) color support","Available 4-bit ANSI color palette codes","","","Black: #0 (foreground code <code>30</code>, background code <code>40</code>).","Blue: #4 (foreground code <code>34</code>, background code <code>44</code>).","Bright black: #0 (foreground code <code>90</code>, background code <code>100</code>).","Bright blue: #4 (foreground code <code>94</code>, background code <code>104</code>).","Bright cyan: #6 (foreground code <code>96</code>, background code <code>106</code>).","Bright green: #2 (foreground code <code>92</code>, background code <code>102</code>).","Bright magenta: #5 (foreground code <code>95</code>, background code <code>105</code>…","Bright red: #1 (foreground code <code>91</code>, background code <code>101</code>).","Bright white: #7 (foreground code <code>97</code>, background code <code>107</code>).","Bright yellow: #3 (foreground code <code>93</code>, background code <code>103</code>…","","Any ANSI color code scheme","Cyan: #6 (foreground code <code>36</code>, background code <code>46</code>).","","","","","Enumerate each enabled value in <code>Effects</code>","A set of text effects","Green:#2(foregro
["anstyle_parse",{"doc":"Parser for implementing virtual terminal emulators","t":"FKIFFFKFMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNGPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPGPPNNNNNNNNNNNNNNNNNNHNNNNNNNNNN","n":["AsciiParser","CharAccumulator","DefaultCharAccumulator","Params","ParamsIter","Parser","Perform","Utf8Parser","add","add","add","advance","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","csi_dispatch","default","default","default","default","eq","eq","eq","eq","esc_dispatch","execute","fmt","fmt","fmt","fmt","from","from","from","from","from","hook","into","into","into","into","into","into_iter","into_iter","is_empty","iter","len","new","next","osc_dispatch","print","put","size_hint","state","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","unhook","Action","Anywhere","BeginUtf8","Clear","Collect","CsiDispatch","CsiEntry","CsiIgnore","CsiIntermediate","CsiParam","DcsEntry","DcsIgnore","DcsIntermediate","DcsParam","DcsPassthrough","EscDispatch","Escape","EscapeIntermediate","Execute","Ground","Hook","Ignore","Nop","OscEnd","OscPut","OscStart","OscString","Param","Print","Put","SosPmApcString","State","Unhook","Utf8","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","default","default","eq","eq","fmt","fmt","from","from","into","into","state_change","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","type_id","type_id"],"q":[[0,"anstyle_parse"],[88,"anstyle_parse::state"],[151,"core::option"],[152,"core::clone"],[153,"core::default"],[154,"core::cmp"],[155,"core::fmt"],[156,"core::fmt"],[157,"core::any"]],"d":["Only allow parsing 7-bit ASCII","Build a <code>char</code> out of bytes","Most flexible <code>CharAccumulator</code> for <code>Parser</code> based on active …","","Immutable subparameter iterator.","Parser for raw <em>VTE</em> protocol which delegates actions to a …","Performs actions requested by the <code>Parser</code>","Allow parsing UTF-8","Build a <code>char</code> out of bytes","","","Advance the parser state","","","","","","","","","","","","","","","","","","","A final character has arrived for a CSI sequence","","","","","","","","","The final character of an escape sequence has arrived.","Execute a C0 or C1 control function.","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Invoked when a final character arrives in first part of …","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","Returns <code>true</code> if there are no parameters present.","Returns an iterator over all parameters and subparameters.","Returns the number of parameters.","Create a new Parser","","Dispatch an operating system command.","Draw a character to the screen and update states.","Pass bytes as part of a device control string to the …","","ANSI escape code parsing state machine","","","","","","","","","","","","","","","","","","","","Called when a device control string is terminated.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Transition to next <code>State</code>","","","","","","","","","",""],"i":[0,0,0,0,0,0,0,0,1,5,6,7,19,10,7,5,6,19,10,7,5,6,10,7,5,6,10,7,5,6,9,10,7,5,6,10,7,5,6,9,9,10,7,5,6,19,10,7,5,6,9,19,10,7,5,6,19,10,10,10,10,7,19,9,9,9,19,0,10,7,5,6,19,10,7,5,6,19,10,7,5,6,19,10,7,5,6,9,0,24,25,25,25,25
["anstyle_query",{"doc":"Low level terminal capability lookups","t":"HHHHHHHCH","n":["clicolor","clicolor_force","is_ci","no_color","term_supports_ansi_color","term_supports_color","truecolor","windows","enable_ansi_colors"],"q":[[0,"anstyle_query"],[8,"anstyle_query::windows"],[9,"core::option"]],"d":["Check CLICOLOR status","Check CLICOLOR_FORCE status","Report whether this is running in CI","Check NO_COLOR status","Check <code>TERM</code> for ANSI color support","Check <code>TERM</code> for color support","Check COLORTERM for truecolor support","Windows-specific style queries","Enable ANSI escape codes (…"],"i":[0,0,0,0,0,0,0,0,0],"f":"{{}{{d{b}}}}{{}b}00000`1","c":[],"p":[[1,"bool"],[6,"Option",9]],"b":[]}],\
["anyhow",{"doc":"githubcrates-iodocs-rs","t":"FKPFHPIQNNNQNNNNNNNMNNNNNNNNQNNENNNNNNNNNNNNNNNNNNNNNNNNM","n":["Chain","Context","Err","Error","Ok","Ok","Result","anyhow","as_ref","as_ref","backtrace","bail","borrow","borrow","borrow_mut","borrow_mut","chain","clone","clone_into","context","context","default","deref","deref_mut","downcast","downcast_mut","downcast_ref","drop","ensure","fmt","fmt","format_err","from","from","from","from","into","into","into_iter","is","len","msg","new","new","next","next_back","root_cause","size_hint","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","with_context"],"q":[[0,"anyhow"],[57,"core::error"],[58,"std::backtrace"],[59,"core::fmt"],[60,"core::marker"],[61,"core::marker"],[62,"core::fmt"],[63,"core::fmt"],[64,"core::any"],[65,"core::ops::function"]],"d":["Iterator of a chain of source errors.","Provides the <code>context</code> method for <code>Result</code>.","Contains the error value","The <code>Error</code> type, a wrapper around a dynamic error type.","Equivalent to Ok::<_, anyhow::Error>(value).","Contains the success value","<code>Result<T, Error></code>","Construct an ad-hoc error from a string or existing non-…","","","Get the backtrace for this Error.","Return early with an error.","","","","","An iterator of the chain of source errors contained by …","","","Wrap the error value with additional context.","Wrap the error value with additional context.","","","","Attempt to downcast the error object to a concrete type.","Downcast this error object by mutable reference.","Downcast this error object by reference.","","Return early with an error if a condition is not satisfied.","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","Returns true if <code>E</code> is the type held by this error object.","","Create a new error object from a printable error message.","Create a new error object from any error type.","","","","The lowest level cause of this error — this error’s …","","","","","","","","","","Wrap the error value with additional context that is …"],"i":[0,0,1,0,0,1,0,0,2,2,2,0,2,5,2,5,2,5,5,7,2,5,2,2,2,2,2,2,0,2,2,0,2,2,2,5,2,5,5,2,5,2,2,5,5,5,2,5,5,2,2,5,2,5,2,5,7],"f":"````{c{{b{c}}}{}}```{df}0{dh}`{ce{}{}}000{dj}{jj}{{ce}l{}{}}{{nc}{{b{ed}}}{A`AbAd}{}}{{dc}d{A`AbAd}}{{}j}{dc{}}0{d{{Af{cd}}}{A`AhAbAd}}{d{{Aj{c}}}{A`AhAbAd}}0{dl}`{{dAl}An}0`{cd{fAbAd}}{cc{}}{B`c{}}1>>>{dBb}{jBd}{cd{A`AhAbAd}}5{fj}{j{{Aj{c}}}{}}0{df}{j{{Bf{Bd{Aj{Bd}}}}}}{ce{}{}}{cBh{}}{c{{Af{e}}}{}{}}000{cBj{}}0{{ne}{{b{gd}}}{A`AbAd}{{Bn{}{{Bl{c}}}}}{}}","c":[],"p":[[8,"Result",0],[5,"Error",0],[10,"Error",57],[5,"Backtrace",58],[5,"Chain",0],[1,"unit"],[10,"Context",0],[10,"Display",59],[10,"Send",60],[10,"Sync",60],[6,"Result",61],[10,"Debug",59],[6,"Option",62],[5,"Formatter",59],[8,"Result",59],[1,"never"],[1,"bool"],[1,"usize"],[1,"tuple"],[5,"String",63],[5,"TypeId",64],[17,"Output"],[10,"FnOnce",65]],"b":[[8,"impl-AsRef%3Cdyn+Error%3E-for-Error"],[9,"impl-AsRef%3Cdyn+Error+%2B+Send+%2B+Sync%3E-for-Error"],[29,"impl-Debug-for-Error"],[30,"impl-Display-for-Error"]]}],\
["beef",{"doc":"Faster, more compact implementation of <code>Cow</code>.","t":"ICCFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNI","n":["Cow","generic","lean","Cow","as_ref","borrow","borrow","borrow_mut","borrowed","clone","clone_into","cmp","const_str","const_str","default","deref","drop","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","from","from","from","from","from","hash","into","into_owned","is_borrowed","is_owned","owned","partial_cmp","to_owned","to_string","try_from","try_into","type_id","unwrap_borrowed","Cow"],"q":[[0,"beef"],[3,"beef::generic"],[44,"beef::lean"],[45,"core::marker"],[46,"core::cmp"],[47,"core::cmp"],[48,"alloc::vec"],[49,"core::clone"],[50,"core::cmp"],[51,"core::fmt"],[52,"core::hash"],[53,"core::hash"],[54,"core::cmp"],[55,"core::any"]],"d":["Compact three word <code>Cow</code> that puts the ownership tag in …","This module contains the actual, albeit generic, …","Namespace containing the 2-word <code>Cow</code> implementation.","A clone-on-write smart pointer, mostly compatible with …","","","","","Borrowed data.","","","","Borrowed data.","Borrowed data.","","","","","","","","","","","","","","Returns the argument unchanged.","","","","","Calls <code>U::from(self)</code>.","Extracts the owned data.","Returns <code>true</code> if data is borrowed or had no capacity.","Returns <code>true</code> if data is owned and has non-0 capacity.","Owned data.","","","","","","","Extracts borrowed data.","Faster, 2-word <code>Cow</code>. This version is available only on …"],"i":[0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],"f":"````{{{b{ce}}}c{`d}`}{ce{}{}}10{c{{b{ce}}}{`d}`}{{{b{ce}}}{{b{ce}}}{`d}`}{{ce}f{}{}}{{{b{ce}}{b{ce}}}h{j`d}`}{l{{b{l`}}}}0{{}{{b{ce}}}{`d}`}7{{{b{ce}}}f{`d}`}{{{b{lc}}n}A``}{{{b{lc}}l}A``}{{{b{{Ab{c}}e}}{Ad{c}}}A`{AfAh}`}1{{{b{{Ab{c}}e}}{Ab{c}}}A`{AfAh}`}{{{b{eg}}{b{ci}}}A`{`d}{`d{Ah{c}}}``}1{{{b{ce}}Aj}Al{`And}`}{{{b{ce}}Aj}Al{`B`d}`}{{{Ad{c}}}{{b{{Ab{c}}e}}}Af`}{cc{}}{{{Bb{c}}}{{b{ce}}}{`d}`}{n{{b{lc}}}`}{c{{b{ce}}}{`d}`}{{{b{ce}}g}f{Bd`d}`Bf}{ce{}{}}{{{b{ce}}}{}{`d}`}{{{b{ce}}}A`{`d}`}0{{}{{b{ce}}}{`d}`}{{{b{eg}}{b{ci}}}{{Bh{h}}}{`d}{`d{Bj{c}}}``}4{cn{}}{c{{Bl{e}}}{}{}}0{cBn{}}{{{b{ce}}}c{`d}`}`","c":[],"p":[[5,"Cow",3],[10,"Sized",45],[1,"unit"],[6,"Ordering",46],[10,"Ord",46],[1,"str"],[5,"String",47],[1,"bool"],[1,"slice"],[5,"Vec",48],[10,"Clone",49],[10,"PartialEq",46],[5,"Formatter",50],[8,"Result",50],[10,"Debug",50],[10,"Display",50],[6,"Cow",51],[10,"Hash",52],[10,"Hasher",52],[6,"Option",53],[10,"PartialOrd",46],[6,"Result",54],[5,"TypeId",55]],"b":[[12,"impl-Cow%3C\'a,+str,+Wide%3E"],[13,"impl-Cow%3C\'a,+str,+Lean%3E"],[17,"impl-PartialEq%3CString%3E-for-Cow%3C\'_,+str,+U%3E"],[18,"impl-PartialEq%3Cstr%3E-for-Cow%3C\'_,+str,+U%3E"],[19,"impl-PartialEq%3CVec%3CT%3E%3E-for-Cow%3C\'_,+%5BT%5D,+U%3E"],[20,"impl-PartialEq%3C%26str%3E-for-Cow%3C\'_,+str,+U%3E"],[21,"impl-PartialEq%3C%5BT%5D%3E-for-Cow%3C\'_,+%5BT%5D,+U%3E"],[22,"impl-PartialEq%3CCow%3C\'_,+B,+V%3E%3E-for-Cow%3C\'_,+A,+U%3E"],[23,"impl-PartialEq%3C%26%5BT%5D%3E-for-Cow%3C\'_,+%5BT%5D,+U%3E"],[24,"impl-Debug-for-Cow%3C\'_,+T,+U%3E"],[25,"impl-Display-for-Cow%3C\'_,+T,+U%3E"],[26,"impl-From%3CVec%3CT%3E%3E-for-Cow%3C\'_,+%5BT%5D,+U%3E"],[28,"impl-From%3CCow%3C\'a,+T%3E%3E-for-Cow%3C\'a,+T,+U%3E"],[29,"impl-From%3CString%3E-for-Cow%3C\'_,+str,+U%3E"],[30,"impl-From%3C%26T%3E-for-Cow%3C\'a,+T,+U%3E"]]}],\
["bitflags",{"doc":"Generate types for C-style flags with ergonomic APIs.","t":"TEKRTTFKNNQMNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNCNNNNNNCNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNFKKNNNNNNHHHNNNMHHHNNNM","n":["ALL","BitFlags","Bits","Bits","EMPTY","FLAGS","Flag","Flags","all","all","bitflags","bits","borrow","borrow_mut","complement","complement","contains","contains","difference","difference","empty","empty","fmt","from","from_bits","from_bits","from_bits_retain","from_bits_truncate","from_bits_truncate","from_name","from_name","insert","insert","intersection","intersection","intersects","intersects","into","is_all","is_all","is_empty","is_empty","is_named","is_unnamed","iter","iter","iter","iter_names","iter_names","name","new","parser","remove","remove","set","set","symmetric_difference","symmetric_difference","toggle","toggle","try_from","try_into","type_id","union","union","value","Iter","IterNames","borrow","borrow","borrow_mut","borrow_mut","from","from","into","into","into_iter","into_iter","next","next","remaining","try_from","try_from","try_into","try_into","type_id","type_id","ParseError","ParseHex","WriteHex","borrow","borrow_mut","empty_flag","fmt","fmt","from","from_str","from_str_strict","from_str_truncate","into","invalid_hex_flag","invalid_named_flag","parse_hex","to_writer","to_writer_strict","to_writer_truncate","try_from","try_into","type_id","write_hex"],"q":[[0,"bitflags"],[66,"bitflags::iter"],[87,"bitflags::parser"],[110,"core::fmt"],[111,"core::fmt"],[112,"core::result"],[113,"core::any"],[114,"core::fmt"]],"d":["A value with all bits set.","","A bits type that can be used as storage for a flags type.","The underlying bits type.","A value with all bits unset.","The set of defined flags.","A defined flags value that may be named or unnamed.","A set of defined flags using a bits type as storage.","Get a flags value with all known bits set.","Get a flags value with all known bits set.","Generate a flags type.","Get the underlying bits value.","","","The bitwise negation (<code>!</code>) of the bits in a flags value, …","The bitwise negation (<code>!</code>) of the bits in a flags value, …","Whether all set bits in a source flags value are also set …","Whether all set bits in a source flags value are also set …","The intersection of a source flags value with the …","The intersection of a source flags value with the …","Get a flags value with all bits unset.","Get a flags value with all bits unset.","","Returns the argument unchanged.","Convert from a bits value.","Convert from a bits value.","Convert from a bits value exactly.","Convert from a bits value, unsetting any unknown bits.","Convert from a bits value, unsetting any unknown bits.","Get a flags value with the bits of a flag with the given …","Get a flags value with the bits of a flag with the given …","The bitwise or (<code>|</code>) of the bits in two flags values.","The bitwise or (<code>|</code>) of the bits in two flags values.","The bitwise and (<code>&</code>) of the bits in two flags values.","The bitwise and (<code>&</code>) of the bits in two flags values.","Whether any set bits in a source flags value are also set …","Whether any set bits in a source flags value are also set …","Calls <code>U::from(self)</code>.","Whether all known bits in this flags value are set.","Whether all known bits in this flags value are set.","Whether all bits in this flags value are unset.","Whether all bits in this flags value are unset.","Whether the flag is named.","Whether the flag is unnamed.","Yield the bits of a source flags value in a set of …","Yield a set of contained flags values.","Yield a set of contained flags values.","Yield a set of contained named flags values.","Yield a set of contained named flags values.","Get the name of this flag.","Define a flag.","Parsing flags from text.","The intersection of a source flags value with the …","The intersection of a source flags value with the …","Call <code>Flags::insert</code> when <code>value</code> is <code>true</code> or <code>Flags::remove</code> …","Call<code>Flags::
["cfg_if",{"doc":"A macro for defining <code>#[cfg]</code> if-else statements.","t":"Q","n":["cfg_if"],"q":[[0,"cfg_if"]],"d":["The main macro provided by this crate. See crate …"],"i":[0],"f":"`","c":[],"p":[],"b":[]}],\
["clap",{"doc":"<strong>Command Line Argument Parser for Rust</strong>","t":"PPPFGFFKPGFKPPPPPPIPPKPPPPFPPKPPPKPPPKGPNNNNNNNNNNNNNNQNNNNNNNNMMMMNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNMQMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNQNNMNNNNNNNNNNNNPPFGFGFFFPPPPPTPFPPFPPPPPKPFFFFPRFFFFFPGTPPPFFFFFKPFPPPRGFKFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNPPFGTTPPPPPPPPPPTGPTTTTFFPTTTPPFPFTFFTPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPPGGPFPPPPFKGPPPPPPPPPFPPPPPPPPIFPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFPPPPFFGFPGFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOO","n":["Always","AnyPath","Append","Arg","ArgAction","ArgGroup","ArgMatches","Args","Auto","ColorChoice","Command","CommandFactory","CommandName","CommandString","CommandWithArguments","Count","DirPath","EmailAddress","Error","ExecutablePath","FilePath","FromArgMatches","Help","HelpLong","HelpShort","Hostname","Id","Never","Other","Parser","Set","SetFalse","SetTrue","Subcommand","Unknown","Url","Username","ValueEnum","ValueHint","Version","about","action","after_help","after_long_help","alias","alias","aliases","aliases","allow_external_subcommands","allow_hyphen_values","allow_missing_positional","allow_negative_numbers","arg","arg","arg","arg_required_else_help","args","args","args_conflicts_with_subcommands","args_override_self","args_present","as_ref","as_str","augment_args","augment_args_for_update","augment_subcommands","augment_subcommands_for_update","author","before_help","before_long_help","bin_name","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","builder","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","color","command","command","command_for_update","conflicts_with","conflicts_with","conflicts_with_all","conflicts_with_all","contains_id","debug_assert","default","default","default","default","default","default","default","default_missing_value","default_missing_value_os","default_missing_values","default_missing_values_os","default_value","default_value_if","default_value_ifs","default_values","defer","disable_colored_help","disable_help_flag","disable_help_subcommand","disable_version_flag","display_name","display_order","display_order","dont_delimit_trailing_values","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","error","error","exclusive","external_subcommand_value_parser","find_subcommand","find_subcommand_mut","flatten_help","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_arg_matches","from_arg_matches_mut","from_str","from_str","from_str","get_about","get_action","get_after_help","get_after_long_help","get_all_aliases","get_all_aliases","get_all_long_flag_aliases","get_all_short_aliases","get_all_sho
["clap_derive",{"doc":"clap_derive","t":"YYYY","n":["Args","Parser","Subcommand","ValueEnum"],"q":[[0,"clap_derive"]],"d":["Generates the <code>Args</code> impl.","Generates the <code>Parser</code> implementation.","Generates the <code>Subcommand</code> impl.","Generates the <code>ValueEnum</code> impl."],"i":[0,0,0,0],"f":"````","c":[],"p":[],"b":[]}],\
["clap_lex",{"doc":"Minimal, flexible command-line parser","t":"FPPKFFGFPNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMMNNNNNNNNNNNNNNNNNNNMNNNNN","n":["ArgCursor","Current","End","OsStrExt","ParsedArg","RawArgs","SeekFrom","ShortFlags","Start","advance_by","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","contains","cursor","default","display","eq","eq","eq","eq","find","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from_args","hash","insert","into","into","into","into","into","into_iter","is_empty","is_empty","is_end","is_escape","is_long","is_negative_number","is_negative_number","is_short","is_stdio","new","next","next","next_flag","next_os","next_value_os","partial_cmp","partial_cmp","peek","peek_os","remaining","seek","split","split_once","starts_with","strip_prefix","to_long","to_owned","to_owned","to_owned","to_owned","to_owned","to_short","to_value","to_value_os","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_str","type_id","type_id","type_id","type_id","type_id"],"q":[[0,"clap_lex"],[111,"core::result"],[112,"core::cmp"],[113,"core::fmt"],[114,"core::option"],[115,"core::fmt"],[116,"core::convert"],[117,"core::iter::traits::iterator"],[118,"core::hash"],[119,"core::iter::traits::collect"],[120,"std::ffi::os_str"],[121,"core::any"]],"d":["Position within <code>RawArgs</code>","Sets the offset to the current position plus the specified …","Sets the offset to the size of this object plus the …","","Command-line Argument","Command-line arguments","Enumeration of possible methods to seek within an I/O …","Walk through short flags within a <code>ParsedArg</code>","Sets the offset to the provided number of bytes.","Move the iterator forward by <code>n</code> short flags","","","","","","","","","","","","","","","","","","","","","","","Returns <code>true</code> if the given pattern matches a sub-slice of …","Create a cursor for walking the arguments","","Safely print an argument that may contain non-UTF8 content","","","","","Returns the byte index of the first character of this …","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","<strong>NOTE:</strong> The argument returned will be the current binary.","","Inject arguments before the <code>RawArgs::next</code>","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","Argument is length of 0","No short flags left","Any remaining args?","Does the argument look like an argument escape (<code>--</code>)","Can treat as a long-flag","Does the argument look like a negative number?","Does the short flag look like a number","Can treat as a short-flag","Does the argument look like a stdio argument (<code>-</code>)","Example","Advance the cursor, returning the next <code>ParsedArg</code>","","Advance the iterator, returning the next short flag on …","Advance the cursor, returning a raw argument value.","Advance the iterator, returning everything left as a value","","","Return the next <code>ParsedArg</code>","Return a raw argument value.","Return all remaining raw arguments, advancing the cursor …","Adjust the cursor’s position","An iterator over substrings of this string slice, …","Splits the string on the first occurrence of the specified …","Returns <code>true</code> if the given pattern matches a prefix of this …","Returns a string slice with the prefix removed.","Treat as a long-flag","","","","","","Treat as a short-flag","Treat as a value","Treat as a value","","","","","","","","","","","Converts to a string slice.","","","","",""],"i":[0,8,8,0,0,0,0,0,8,1,5,6,7,1,8,5,6,7,1,8,5,6,7,1,8,5,6
["colorchoice",{"doc":"Global override of color control","t":"PPPGPNNNNNNNNNNNNN","n":["Always","AlwaysAnsi","Auto","ColorChoice","Never","borrow","borrow_mut","clone","default","eq","fmt","from","global","into","try_from","try_into","type_id","write_global"],"q":[[0,"colorchoice"],[18,"core::fmt"],[19,"core::fmt"],[20,"core::any"]],"d":["Try very hard to emit colors.","Like <code>Always</code>, except it never tries to use anything other …","Use colors if the output device appears to support them","Selection for overriding color output","Never emit colors.","","","","","","","Returns the argument unchanged.","Get the current <code>ColorChoice</code> state","Calls <code>U::from(self)</code>.","","","","Override the detected <code>ColorChoice</code>"],"i":[1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"f":"`````{ce{}{}}0{bb}{{}b}{{bb}d}{{bf}h}{cc{}}35{c{{j{e}}}{}{}}0{cl{}}{bn}","c":[],"p":[[6,"ColorChoice",0],[1,"bool"],[5,"Formatter",18],[8,"Result",18],[6,"Result",19],[5,"TypeId",20],[1,"unit"]],"b":[]}],\
["concolor",{"doc":"Control console coloring across all dependencies","t":"PPPFGPPPPGNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNN","n":["Always","AlwaysAnsi","Auto","Color","ColorChoice","Either","Never","Stderr","Stdout","Stream","ansi_color","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","color","default","eq","eq","fmt","fmt","fmt","from","from","from","get","into","into","into","to_owned","to_owned","to_owned","truecolor","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id"],"q":[[0,"concolor"],[50,"core::fmt"],[51,"core::fmt"],[52,"core::any"]],"d":["","","","Current color state for a <code>Stream</code>","Selection for overriding color output with [<code>set</code>][crate::set…","When unsure which will be used (lowest common denominator …","","","","Output stream to <code>get()</code> the <code>Color</code> state for","Should use ANSI coloring?","","","","","","","","","","","","","Should color be used?","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get the current <code>Color</code> state for a given <code>Stream</code>","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","Should use ANSI truecolor?","","","","","","","","",""],"i":[3,3,3,0,0,4,3,4,4,0,1,1,3,4,1,3,4,1,3,4,1,3,4,1,3,3,4,1,3,4,1,3,4,0,1,3,4,1,3,4,1,1,3,4,1,3,4,1,3,4],"f":"``````````{bd}{ce{}{}}00000{bb}{ff}{hh}{{ce}j{}{}}005{{}f}{{ff}d}{{hh}d}{{bl}n}{{fl}n}{{hl}n}{cc{}}00{hb}<<<<<<={c{{A`{e}}}{}{}}00000{cAb{}}00","c":[],"p":[[5,"Color",0],[1,"bool"],[6,"ColorChoice",0],[6,"Stream",0],[1,"unit"],[5,"Formatter",50],[8,"Result",50],[6,"Result",51],[5,"TypeId",52]],"b":[]}],\
["concolor_query",{"doc":"","t":"HHHHHHHCH","n":["clicolor","clicolor_force","is_ci","no_color","term_supports_ansi_color","term_supports_color","truecolor","windows","enable_ansi_colors"],"q":[[0,"concolor_query"],[8,"concolor_query::windows"],[9,"core::option"]],"d":["Check CLICOLOR status","Check CLICOLOR_FORCE status","Report whether this is running in CI","Check NO_COLOR status","Check <code>TERM</code> for ANSI color support","Check <code>TERM</code> for color support","Check COLORTERM for truecolor support","",""],"i":[0,0,0,0,0,0,0,0,0],"f":"{{}{{d{b}}}}{{}b}00000`1","c":[],"p":[[1,"bool"],[6,"Option",9]],"b":[]}],\
["edlang_check",{"doc":"","t":"H","n":["lowering_error_to_report"],"q":[[0,"edlang_check"],[1,"edlang_lowering::errors"],[2,"edlang_session"],[3,"alloc::string"],[4,"core::ops::range"],[5,"ariadne"]],"d":["Creates a report from a lowering error."],"i":[0],"f":"{{bd}{{n{{l{f{j{h}}}}}}}}","c":[],"p":[[6,"LoweringError",1],[5,"Session",2],[5,"String",3],[1,"usize"],[5,"Range",4],[1,"tuple"],[5,"Report",5]],"b":[]}],\
["edlang_driver",{"doc":"","t":"FOONNNNNNNNNNNNNNNNNNNNNNHNNONNNNNNNNNONNONONCONHNONNNNNNNNNNNNNNNNNNNNOOHNNNNONNNNNNNNNNNNNHH","n":["CompilerArgs","asm","ast","attr","augment_args","augment_args_for_update","bg","black","blink","blue","bold","borrow","borrow_mut","bright","bright_black","bright_blue","bright_cyan","bright_green","bright_magenta","bright_red","bright_white","bright_yellow","clear","command","command_for_update","compile","conceal","cyan","debug_info","dim","fg","fixed","fmt","from","from_arg_matches","from_arg_matches_mut","green","group_id","input","into","invert","ir","italic","library","linger","linker","llvm","magenta","main","mask","object","on_black","on_blue","on_bright","on_bright_black","on_bright_blue","on_bright_cyan","on_bright_green","on_bright_magenta","on_bright_red","on_bright_white","on_bright_yellow","on_cyan","on_fixed","on_green","on_magenta","on_primary","on_red","on_rgb","on_white","on_yellow","optlevel","output","parse_file","primary","quirk","rapid_blink","red","release","resetting","rgb","strike","try_from","try_into","type_id","underline","update_from_arg_matches","update_from_arg_matches_mut","whenever","white","wrap","yellow","link_binary","link_shared_lib"],"q":[[0,"edlang_driver"],[92,"edlang_driver::linker"],[94,"yansi::attr_quirk"],[95,"yansi::paint"],[96,"clap_builder::builder::command"],[97,"yansi::color"],[98,"std::path"],[99,"anyhow"],[100,"core::fmt"],[101,"core::fmt"],[102,"clap_builder"],[103,"core::result"],[104,"clap_builder::util::id"],[105,"core::option"],[106,"alloc::string"],[107,"edlang_ast"],[108,"alloc::vec"],[109,"yansi::attr_quirk"],[110,"yansi::condition"],[111,"std::path"]],"d":["","Output asm","Print the edlang AST","Enables the styling <code>Attribute</code> <code>value</code>.","","","Returns a styled value derived from <code>self</code> with the …","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Black</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Blink</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Blue</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Bold</code>.","","","Returns <code>self</code> with the <code>quirk()</code> set to <code>Quirk::Bright</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightBlack</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightBlue</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightCyan</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightGreen</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightMagenta</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightRed</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightWhite</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::BrightYellow</code>.","Returns <code>self</code> with the <code>quirk()</code> set to <code>Quirk::Clear</code>.","","","","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Conceal</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Cyan</code>.","Always add debug info","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Dim</code>.","Returns a styled value derived from <code>self</code> with the …","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Fixed</code>.","","Returns the argument unchanged.","","","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Green</code>.","","The input file.","Calls <code>U::from(self)</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Invert</code>.","Print the edlang IR","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Italic</code>.","Build as a library.","Returns<code>self</code>with
["edlang_lowering",{"doc":"","t":"CHHPPPPPGPPPPPPPPNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO","n":["errors","lower_modules","lower_type","BorrowNotMutable","CantTakeMutableBorrow","FunctionNotFound","IdNotFound","ImportNotFound","LoweringError","ModuleNotFound","NotMutable","NotMutableSelf","NotYetImplemented","ParamCountMismatch","UnexpectedType","UnrecognizedType","UseOfUndeclaredVariable","borrow","borrow_mut","clone","clone_into","fmt","fmt","from","into","to_owned","to_string","try_from","try_into","type_id","declare_span","declare_span","expected","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","file_id","found","function","has_args","id","import_span","message","module","module_span","name","name","name","needs","path_span","span","span","span","span","span","span","span","span","span","span","span","span","symbol","type_span"],"q":[[0,"edlang_lowering"],[3,"edlang_lowering::errors"],[30,"edlang_lowering::errors::LoweringError"],[73,"edlang_ast"],[74,"edlang_ir"],[75,"core::result"],[76,"edlang_ast"],[77,"core::fmt"],[78,"core::any"]],"d":["","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,4,4,4,4,4,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,14,15,16,17,18,19,20,21,22,23,16,24,25,14,15,26,16,18,25,22,19,23,17,19,20,21,24,25,26,17,18,20,21,22,23,16,24,25,14,15,26,19,20],"f":"`{{{d{b}}}{{j{fh}}}}```````````````{ce{}{}}0{hh}{{ce}Ab{}{}}{{hAd}Af}0{cc{}}44{cAh{}}{c{{j{e}}}{}{}}0{cAj{}}```````````````````````````````````````````","c":[],"p":[[5,"Module",73],[1,"slice"],[5,"ProgramBody",74],[6,"LoweringError",3],[6,"Result",75],[6,"Type",73],[5,"DefId",74],[5,"TypeInfo",74],[1,"unit"],[5,"Formatter",76],[8,"Result",76],[5,"String",77],[5,"TypeId",78],[15,"NotMutable",30],[15,"CantTakeMutableBorrow",30],[15,"UnexpectedType",30],[15,"ModuleNotFound",30],[15,"FunctionNotFound",30],[15,"ImportNotFound",30],[15,"BorrowNotMutable",30],[15,"UnrecognizedType",30],[15,"IdNotFound",30],[15,"NotYetImplemented",30],[15,"UseOfUndeclaredVariable",30],[15,"ParamCountMismatch",30],[15,"NotMutableSelf",30]],"b":[[21,"impl-Display-for-LoweringError"],[22,"impl-Debug-for-LoweringError"]]}],\
["edlang_session",{"doc":"","t":"PGPPPPPGFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOONNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Aggressive","DebugInfo","Default","Full","Less","None","None","OptLevel","Session","attr","attr","attr","bg","bg","bg","black","black","black","blink","blink","blink","blue","blue","blue","bold","bold","bold","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","bright","bright","bright","bright_black","bright_black","bright_black","bright_blue","bright_blue","bright_blue","bright_cyan","bright_cyan","bright_cyan","bright_green","bright_green","bright_green","bright_magenta","bright_magenta","bright_magenta","bright_red","bright_red","bright_red","bright_white","bright_white","bright_white","bright_yellow","bright_yellow","bright_yellow","clear","clear","clear","clone","clone","clone","clone_into","clone_into","clone_into","conceal","conceal","conceal","cyan","cyan","cyan","debug_info","dim","dim","dim","eq","eq","fg","fg","fg","file_paths","fixed","fixed","fixed","fmt","fmt","fmt","from","from","from","get_platform_library_ext","green","green","green","hash","hash","into","into","into","invert","invert","invert","italic","italic","italic","library","linger","linger","linger","magenta","magenta","magenta","mask","mask","mask","on_black","on_black","on_black","on_blue","on_blue","on_blue","on_bright","on_bright","on_bright","on_bright_black","on_bright_black","on_bright_black","on_bright_blue","on_bright_blue","on_bright_blue","on_bright_cyan","on_bright_cyan","on_bright_cyan","on_bright_green","on_bright_green","on_bright_green","on_bright_magenta","on_bright_magenta","on_bright_magenta","on_bright_red","on_bright_red","on_bright_red","on_bright_white","on_bright_white","on_bright_white","on_bright_yellow","on_bright_yellow","on_bright_yellow","on_cyan","on_cyan","on_cyan","on_fixed","on_fixed","on_fixed","on_green","on_green","on_green","on_magenta","on_magenta","on_magenta","on_primary","on_primary","on_primary","on_red","on_red","on_red","on_rgb","on_rgb","on_rgb","on_white","on_white","on_white","on_yellow","on_yellow","on_yellow","optlevel","output_asm","output_file","output_llvm","primary","primary","primary","quirk","quirk","quirk","rapid_blink","rapid_blink","rapid_blink","red","red","red","resetting","resetting","resetting","rgb","rgb","rgb","sources","strike","strike","strike","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","underline","underline","underline","whenever","whenever","whenever","white","white","white","wrap","wrap","wrap","yellow","yellow","yellow"],"q":[[0,"edlang_session"],[232,"yansi::attr_quirk"],[233,"yansi::paint"],[234,"yansi::color"],[235,"core::fmt"],[236,"core::fmt"],[237,"yansi::attr_quirk"],[238,"core::any"],[239,"yansi::condition"]],"d":["","","","","","","","","","Enables the styling <code>Attribute</code> <code>value</code>.","Enables the styling <code>Attribute</code> <code>value</code>.","Enables the styling <code>Attribute</code> <code>value</code>.","Returns a styled value derived from <code>self</code> with the …","Returns a styled value derived from <code>self</code> with the …","Returns a styled value derived from <code>self</code> with the …","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Black</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Black</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Black</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Blink</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Blink</code>.","Returns <code>self</code> with the <code>attr()</code> set to <code>Attribute::Blink</code>.","Returns <code>self</code> with the <code>fg()</code> set to <code>Color::Blue</code>.","Returns<code>self</code>withthe<c
["edlang_span",{"doc":"","t":"FNNNNNNNNNNONONNNNNN","n":["Span","borrow","borrow_mut","clone","clone_into","cmp","default","eq","fmt","from","hash","hi","into","lo","new","partial_cmp","to_owned","try_from","try_into","type_id"],"q":[[0,"edlang_span"],[20,"core::cmp"],[21,"core::fmt"],[22,"core::fmt"],[23,"core::option"],[24,"core::result"],[25,"core::any"]],"d":["","","","","","","","","","Returns the argument unchanged.","","","Calls <code>U::from(self)</code>.","","","","","","",""],"i":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"f":"`{ce{}{}}0{bb}{{ce}d{}{}}{{bb}f}{{}b}{{bb}h}{{bj}l}{cc{}}{{bc}dn}`8`{{A`A`}b}{{bb}{{Ab{f}}}}:{c{{Ad{e}}}{}{}}0{cAf{}}","c":[],"p":[[5,"Span",0],[1,"unit"],[6,"Ordering",20],[1,"bool"],[5,"Formatter",21],[8,"Result",21],[10,"Hasher",22],[1,"usize"],[6,"Option",23],[6,"Result",24],[5,"TypeId",25]],"b":[]}],\
["either",{"doc":"The enum <code>Either</code> with variants <code>Left</code> and <code>Right</code> is a general …","t":"GKFEPEPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQQNNNNNNN","n":["Either","IntoEither","IterEither","Left","Left","Right","Right","all","all","any","any","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_pin_mut","as_pin_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","borrow","borrow","borrow_mut","borrow_mut","cause","clone","clone","clone_from","clone_into","clone_into","cmp","collect","collect","consume","count","count","deref","deref_mut","description","either","either_into","either_with","eq","expect_left","expect_right","extend","factor_err","factor_first","factor_into_iter","factor_iter","factor_iter_mut","factor_none","factor_ok","factor_second","fill_buf","find","find","find_map","find_map","flip","flush","fmt","fmt","fmt","fold","fold","for_both","for_each","for_each","from","from","from","hash","into","into","into","into_either","into_either","into_either_with","into_either_with","into_future","into_inner","into_iter","into_iter","into_iter","is_left","is_right","iter","iter_mut","last","last","left","left_and_then","left_or","left_or_default","left_or_else","len","len","map","map_either","map_either_with","map_left","map_right","next","next","next_back","next_back","nth","nth","partial_cmp","partition","partition","poll","position","position","read","read_exact","read_line","read_to_end","read_to_string","read_until","rfind","rfind","rfold","rfold","right","right_and_then","right_or","right_or_default","right_or_else","seek","size_hint","size_hint","source","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","try_left","try_right","type_id","type_id","unwrap_left","unwrap_right","write","write_all","write_fmt"],"q":[[0,"either"],[157,"core::iter::traits::iterator"],[158,"core::ops::function"],[159,"core::convert"],[160,"std::path"],[161,"std::ffi::os_str"],[162,"core::ffi::c_str"],[163,"core::pin"],[164,"core::convert"],[165,"core::option"],[166,"core::clone"],[167,"core::cmp"],[168,"core::cmp"],[169,"std::io"],[170,"core::ops::deref"],[171,"core::ops::deref"],[172,"core::iter::traits::collect"],[173,"std::io::error"],[174,"std::io"],[175,"core::hash"],[176,"core::iter::traits::exact_size"],[177,"core::iter::traits::double_ended"],[178,"core::cmp"],[179,"core::task::poll"],[180,"core::future::future"],[181,"std::io"],[182,"alloc::vec"],[183,"std::io"],[184,"core::fmt"]],"d":["The enum <code>Either</code> with variants <code>Left</code> and <code>Right</code> is a general …","Provides methods for converting a type <code>Self</code> into either a …","Iterator that maps left or right iterators to …","","A value of type <code>L</code>.","","A value of type <code>R</code>.","","","","","Convert <code>&mut Either<L, R></code> to <code>Either<&mut L, &mut R></code>.","","","","","","","Convert <code>Pin<&mut Either<L, R>></code> to …","Convert <code>Pin<&Either<L, R>></code> to <code>Either<Pin<&L>, Pin<&R>></code>, …","Convert <code>&Either<L, R></code> to <code>Either<&L, &R></code>.","","","","","","","","","","","","","","","","","","","","","","","","","","Apply one of two functions depending on contents, unifying …","Convert the contained value into <code>T</code>","Like <code>either</code>, but provide some context to whichever of the …","","Returns the left value","Returns the right value","","Factors out a homogenous type from an <code>Either</code> of <code>Result</code>.","Factor out a homogeneous type from an either of pairs.","Converts an <code>Either</code> of <code>Iterator</code>s to be an <code>Iterator</code> of <code>Either</code>…","Borrows an <code>Either</code> of <code>Iterator</code>s to be an <code>Iterator</code> of <code>Either</code>s","Mutablyborrowsan<code>Either</code>of<code>I
["equivalent",{"doc":"<code>Equivalent</code> and <code>Comparable</code> are traits for key comparison in …","t":"KKMM","n":["Comparable","Equivalent","compare","equivalent"],"q":[[0,"equivalent"],[4,"core::cmp"],[5,"core::marker"]],"d":["Key ordering trait.","Key equivalence trait.","Compare self to <code>key</code> and return their ordering.","Compare self to <code>key</code> and return <code>true</code> if they are equal."],"i":[0,0,1,4],"f":"``{{bc}df}{{hc}jf}","c":[],"p":[[10,"Comparable",0],[6,"Ordering",4],[10,"Sized",5],[10,"Equivalent",0],[1,"bool"]],"b":[]}],\
["fnv",{"doc":"An implementation of the Fowler–Noll–Vo hash function.","t":"IIIFNNNNNNNNNNN","n":["FnvBuildHasher","FnvHashMap","FnvHashSet","FnvHasher","borrow","borrow_mut","default","finish","from","into","try_from","try_into","type_id","with_key","write"],"q":[[0,"fnv"],[15,"core::result"],[16,"core::any"]],"d":["A builder for default FNV hashers.","A <code>HashMap</code> using a default FNV hasher.","A <code>HashSet</code> using a default FNV hasher.","An implementation of the Fowler–Noll–Vo hash function.","","","","","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","","","","Create an FNV hasher starting with a state corresponding …",""],"i":[0,0,0,0,1,1,1,1,1,1,1,1,1,1,1],"f":"````{ce{}{}}0{{}b}{bd}{cc{}}3{c{{f{e}}}{}{}}0{ch{}}{db}{{b{l{j}}}n}","c":[],"p":[[5,"FnvHasher",0],[1,"u64"],[6,"Result",15],[5,"TypeId",16],[1,"u8"],[1,"slice"],[1,"unit"]],"b":[]}],\
["form_urlencoded",{"doc":"Parser and serializer for the …","t":"FIRPFFFPKNNMNNNNNNNNHNNNNNNMNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNN","n":["ByteSerialize","EncodingOverride","Finished","None","Parse","ParseIntoOwned","Serializer","Some","Target","append_key_only","append_pair","as_mut_string","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","byte_serialize","clear","clone","clone_into","encoding_override","extend_keys_only","extend_pairs","finish","finish","fmt","for_suffix","from","from","from","from","into","into","into","into","into_iter","into_iter","into_iter","into_owned","new","next","next","next","parse","size_hint","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id"],"q":[[0,"form_urlencoded"],[62,"alloc::string"],[63,"core::iter::traits::collect"],[64,"core::fmt"],[65,"core::fmt"],[66,"core::result"],[67,"core::any"]],"d":["Return value of <code>byte_serialize()</code>.","","","No value.","The return type of <code>parse()</code>.","Like <code>Parse</code>, but yields pairs of <code>String</code> instead of pairs of …","The <code>application/x-www-form-urlencoded</code> serializer.","Some value of type <code>T</code>.","","Serialize and append a name of parameter without any value.","Serialize and append a name/value pair.","","","","","","","","","","The <code>application/x-www-form-urlencoded</code> byte serializer.","Remove any existing name/value pair.","","","Set the character encoding to be used for names and values …","Serialize and append a number of names without values.","Serialize and append a number of name/value pairs.","","If this serializer was constructed with a string, take and …","","Create a new <code>application/x-www-form-urlencoded</code> serializer …","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","Return a new iterator that yields pairs of <code>String</code> instead …","Create a new <code>application/x-www-form-urlencoded</code> serializer …","","","","Convert a byte string in the …","","","","","","","","","","","","","",""],"i":[0,0,3,11,0,0,0,11,0,1,1,3,16,1,9,8,16,1,9,8,0,1,9,9,1,1,1,3,1,8,1,16,1,9,8,16,1,9,8,16,9,8,9,1,16,9,8,0,8,9,16,1,9,8,16,1,9,8,16,1,9,8],"f":"`````````{{{b{c}}d}{{b{c}}}f}{{{b{c}}dd}{{b{c}}}f}{{{f{}{{h{c}}}}}j{}}{ce{}{}}0000000{{{n{l}}}A`}{{{b{c}}}{{b{c}}}f}{AbAb}{{ce}Ad{}{}}{{{b{c}}Af}{{b{c}}}f}{{{b{c}}e}{{b{c}}}fAh}0{{{f{}{{h{c}}}}}c{}}{{{b{c}}}{}f}{{A`Aj}Al}{{cAn}{{b{c}}}f}{cc{}}000;;;;;;;{AbB`}{c{{b{c}}}f}{B`{{Bb{c}}}{}}{Ab{{Bb{c}}}{}}{A`{{Bb{d}}}}{{{n{l}}}Ab}{A`{{Bd{An{Bb{An}}}}}}{ce{}{}}{c{{Bf{e}}}{}{}}0000000{cBh{}}000","c":[],"p":[[5,"Serializer",0],[1,"str"],[10,"Target",0],[17,"Finished"],[5,"String",62],[1,"u8"],[1,"slice"],[5,"ByteSerialize",0],[5,"Parse",0],[1,"unit"],[8,"EncodingOverride",0],[10,"IntoIterator",63],[5,"Formatter",64],[8,"Result",64],[1,"usize"],[5,"ParseIntoOwned",0],[6,"Option",65],[1,"tuple"],[6,"Result",66],[5,"TypeId",67]],"b":[]}],\
["git2",{"doc":"libgit2 bindings for Rust","t":"TTTTTTPPPPPPPPPPPPFPPPPGPPFFGPPGTTPPPFFFFFPPPPFPFGFFPPTTTTTPPGPPPPPFPPPPFPFPPFPFFGPPPPPFFFITTTTTSTTPPPPPGPPFFPFFFFFGFFFFGFFGFFFFPGPPPTTPFFPFPGGPPTTTTTTTPPPPFGGPGPPPPPPPPPPTTTTTTTTTTTTTTTTTTTTTPFPPPFPFFPFFFFIFFPIPPKPPPTTPPPPPPPTFFPPPFPFFFFFFPPPTTTTTTTTTTTTTPPPPPPPPPPPPPPPFFFPGFPFFFFFPFPPPPPFGFFPPPPFFFFFFPPPPPFFPFFTTTTTPFPPPPPFGFFPFFGFFFFFFPFPFFFGPFPFFFGGPPFPFFFPTTTTTTTTTTPFPPFPPPPFFGIIFFFFFFGFPFPGFGFPPTTFPPPPFPGFIFPPPFFFGGPPTTTTTTPPPPPPPPPPPPPPIPTTFTTTTTTTTTTTTPPPFPFGFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNHHNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPFGPPPIIIFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
["hashbrown",{"doc":"This crate is a Rust port of Google’s high-performance …","t":"PPKFFFGNNNNNMNNNCCCNCNNNNOGFGGFFFFFFFFPPPFFFFFGFFPPPFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNFFGFFFFFPFFFPFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFGFFFFFPFPFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AllocError","CapacityOverflow","Equivalent","HashMap","HashSet","HashTable","TryReserveError","borrow","borrow_mut","clone","clone_into","eq","equivalent","equivalent","fmt","from","hash_map","hash_set","hash_table","into","raw","to_owned","try_from","try_into","type_id","layout","DefaultHashBuilder","Drain","Entry","EntryRef","ExtractIf","HashMap","IntoIter","IntoKeys","IntoValues","Iter","IterMut","Keys","Occupied","Occupied","Occupied","OccupiedEntry","OccupiedEntryRef","OccupiedError","RawEntryBuilder","RawEntryBuilderMut","RawEntryMut","RawOccupiedEntryMut","RawVacantEntryMut","Vacant","Vacant","Vacant","VacantEntry","VacantEntryRef","Values","ValuesMut","allocator","and_modify","and_modify","and_modify","and_replace_entry_with","and_replace_entry_with","and_replace_entry_with","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","clear","clone","clone","clone","clone","clone_from","clone_into","clone_into","clone_into","clone_into","contains_key","default","drain","entry","entry","entry_ref","eq","equivalent","extend","extend","extend","extract_if","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fold","fold","fold","fold","fold","fold","fold","fold","fold","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_hash","from_hash","from_iter","from_key","from_key","from_key_hashed_nocheck","from_key_hashed_nocheck","get","get","get","get","get_key_value","get_key_value","get_key_value_mut","get_key_value_mut","get_many_key_value_mut","get_many_key_value_unchecked_mut","get_many_mut","get_many_unchecked_mut","get_mut","get_mut","get_mut","get_mut","hasher","index","insert","insert","insert","insert","insert","insert","insert","insert","insert","insert","insert_hashed_nocheck","insert_key","insert_unique_unchecked","insert_with_hasher","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_key","into_key","into_key","into_key_value","into_keys","into_mut","into_mut","into_mut","into_values","is_empty","iter","iter_mut","key","key","key","key","key","key","key","key_mut","keys","len","len","len","len","len","len","len","len","len","len","next","
["heck",{"doc":"<strong>heck</strong> is a case conversion library.","t":"FFFFFFFFFFFMKKKKKKKKKKKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMMMMMNNNNNNNNMMMNNNNNNNNNNNNNNNNNNNNNNNN","n":["AsKebabCase","AsLowerCamelCase","AsPascalCase","AsShoutyKebabCase","AsShoutySnakeCase","AsShoutySnekCase","AsSnakeCase","AsSnekCase","AsTitleCase","AsTrainCase","AsUpperCamelCase","TO_SHOUTY_SNEK_CASE","ToKebabCase","ToLowerCamelCase","ToPascalCase","ToShoutyKebabCase","ToShoutySnakeCase","ToShoutySnekCase","ToSnakeCase","ToSnekCase","ToTitleCase","ToTrainCase","ToUpperCamelCase","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","to_kebab_case","to_lower_camel_case","to_pascal_case","to_shouty_kebab_case","to_shouty_snake_case","to_snake_case","to_snek_case","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_title_case","to_train_case","to_upper_camel_case","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id"],"q":[[0,"heck"],[105,"core::fmt"],[106,"core::fmt"],[107,"alloc::string"],[108,"core::result"],[109,"core::any"]],"d":["This wrapper performs a kebab case conversion in …","This wrapper performs a lower camel case conversion in …","This wrapper performs a upper camel case conversion in …","This wrapper performs a kebab case conversion in …","This wrapper performs a shouty snake case conversion in …","This wrapper performs a shouty snake case conversion in …","This wrapper performs a snake case conversion in …","This wrapper performs a snake case conversion in …","This wrapper performs a title case conversion in …","This wrapper performs a train case conversion in …","This wrapper performs a upper camel case conversion in …","CONVERT THIS TYPE TO SNEK CASE.","This trait defines a kebab case conversion.","This trait defines a lower camel case conversion.","<code>ToPascalCase</code> is an alias for <code>ToUpperCamelCase</code>. See …","This trait defines a shouty kebab case conversion.","This trait defines a shouty snake case conversion.","Oh heck, <code>ToShoutySnekCase</code> is an alias for <code>ToShoutySnakeCase</code>…","This trait defines a snake case conversion.","Oh heck, <code>SnekCase</code> is an alias for <code>ToSnakeCase</code>. See …","This trait defines a title case conversion.","This trait defines a train case conversion.","This trait defines an upper camel case conversion.","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Convert this type to kebab case.","Convert this type to lower camel case.","Convert this type to upper camel case.","Convert this type to shouty kebab case.","Convert this type to shouty snake case.","Convert this type to snake case.","Convert this type to snek case.","","","","","","","","","Convert this type to title case.","Convert this type to Train-Case.","Convert this type to upper camel case.","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,2,7,8,9,10,11,12,13,2,7,8,9,10,11,12,13,2,7,8
["idna",{"doc":"This Rust crate implements IDNA per the WHATWG URL Standard…","t":"FFFNNNNNNNNNNNNHHHNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNHHHH","n":["Config","Errors","Idna","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","check_hyphens","clone","clone_into","default","default","default","domain_to_ascii","domain_to_ascii_strict","domain_to_unicode","fmt","fmt","from","from","from","into","into","into","new","punycode","to_ascii","to_ascii","to_ascii_inner","to_owned","to_string","to_unicode","to_unicode","transitional_processing","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","use_idna_2008_rules","use_std3_ascii_rules","verify_dns_length","decode","decode_to_string","encode","encode_str"],"q":[[0,"idna"],[48,"idna::punycode"],[52,"alloc::string"],[53,"core::result"],[54,"core::fmt"],[55,"core::fmt"],[56,"alloc::vec"],[57,"core::option"]],"d":["","Errors recorded during UTS #46 processing.","","","","","","","","","","","","","","The domain to ASCII algorithm.","The domain to ASCII algorithm, with the <code>beStrict</code> flag set.","The domain to Unicode algorithm.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","Punycode (RFC 3492) implementation.","http://www.unicode.org/reports/tr46/#ToASCII","http://www.unicode.org/reports/tr46/#ToASCII","","","","http://www.unicode.org/reports/tr46/#ToUnicode","http://www.unicode.org/reports/tr46/#ToUnicode","","","","","","","","","","","","","","Convert Punycode to Unicode.","Convert Punycode to an Unicode <code>String</code>.","Convert Unicode to Punycode.","Convert an Unicode <code>str</code> to Punycode."],"i":[0,0,0,4,1,5,4,1,5,1,1,1,4,1,5,0,0,0,5,5,4,1,5,4,1,5,4,0,4,1,4,1,5,4,1,1,4,1,5,4,1,5,4,1,5,1,1,1,0,0,0,0],"f":"```{ce{}{}}00000{{bd}b}{bb}{{ce}f{}{}}{{}h}{{}b}{{}j}{l{{A`{nj}}}}0{l{{Ab{n{A`{fj}}}}}}{{jAd}Af}0{cc{}}00:::{bh}`{{hln}{{A`{fj}}}}{{bl}{{A`{nj}}}}{{hln}j}>{cn{}}3{{bl}{{Ab{n{A`{fj}}}}}}?{c{{A`{e}}}{}{}}00000{cAh{}}00{{bd}b}00{l{{An{{Al{Aj}}}}}}{l{{An{n}}}}{{{B`{Aj}}}{{An{n}}}}1","c":[],"p":[[5,"Config",0],[1,"bool"],[1,"unit"],[5,"Idna",0],[5,"Errors",0],[1,"str"],[5,"String",52],[6,"Result",53],[1,"tuple"],[5,"Formatter",54],[8,"Result",54],[5,"TypeId",55],[1,"char"],[5,"Vec",56],[6,"Option",57],[1,"slice"]],"b":[[18,"impl-Debug-for-Errors"],[19,"impl-Display-for-Errors"]]}],\
["indexmap",{"doc":"<code>IndexMap</code> is a hash table where the iteration order of the …","t":"KEEFNNNNNMNNNNNNQQNCCNNNNNFGFFFFFFFRFKPFKFFPFRFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNCMNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPKFFGFFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFKFFFFRNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Equivalent","IndexMap","IndexSet","TryReserveError","borrow","borrow_mut","clone","clone_into","eq","equivalent","equivalent","equivalent","equivalent","fmt","fmt","from","indexmap","indexset","into","map","set","to_owned","to_string","try_from","try_into","type_id","Drain","Entry","IndexMap","IndexedEntry","IntoIter","IntoKeys","IntoValues","Iter","IterMut","Key","Keys","MutableKeys","Occupied","OccupiedEntry","RawEntryApiV1","Slice","Splice","Vacant","VacantEntry","Value","Values","ValuesMut","and_modify","as_mut_slice","as_mut_slice","as_slice","as_slice","as_slice","as_slice","as_slice","binary_search_by","binary_search_by","binary_search_by_key","binary_search_by_key","binary_search_keys","binary_search_keys","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","clear","clone","clone","clone","clone","clone_from","clone_into","clone_into","clone_into","clone_into","cmp","collect","collect","collect","collect","collect","collect","collect","collect","collect","compare","contains_key","count","count","count","count","count","count","count","count","count","default","default","default","default","default","default","default","default","default","default","default","drain","drop","entry","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","extend","extend","first","first","first_mut","first_mut","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_iter","get","get","get","get_full","get_full_mut","get_full_mut2","get_full_mut2","get_index","get_index","get_index_entry","get_index_mut","get_index_mut","get_index_mut2","get_index_mut2","get_index_of","get_key_value","get_mut","get_mut","get_mut","get_range","get_range","get_range_mut","get_range_mut","hash","hasher","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","index_mut","insert","insert","insert","insert","insert_full","insert_sorted","insert_sorted","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_boxed_slice","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_key","into_keys","into_keys","into_mut","into_mut","into_slice","into_values","into_values","is_empty","is_empty","iter
["inkwell",{"doc":"Inkwell documentation is a work in progress.","t":"PPPPFPPGGGPPPPPPPPPGPGPPPGGPPPPPPPPPPPPPPPPPPGPPPPPPPPPPPGPPPPPPPPPPPPPPPPCCNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCDCCCNNNNNNNCCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCFGPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPFGPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPFGPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFFNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNTTTTPPPPKTTPPPPPPPPPPPPPPPPPFFFFFFIKKFFFFFFFFFGGFPTTTTPPPPPPPPPPTTTTPPPITTPTTPPPPTTPTTTTPPPPPTTTTTTTTPPTTTTPPTTTTPTTTTTTPTTTTTTTTPMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFGPPPFPPGKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNPPPPPPPPPPGFPFPPPPGPPFPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNRFFKNNNNNNMNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNFGPPNNNNNNNNNNHNNCNNNNNNHNNHHHHHNNNNNNNNNNHHPPGGPPPGFPPPPPPPGPPFFFFFNNNNNNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPKGFPPPKGKGPPFKFPPPFPPKFPPPRRFPPKFPPPRRGFPPPRRRFPPPFPNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPPKGPPKGFPPPPKPPRRRGKGFPPPPFPPPPPPPPPPSPPPPPPPPPFKFPPPPFPFPPFPFPPPGFPKPFPPPPGPPPPPPPPFPPPPFFPPFPKFPPPPPPPPPPPPPPFPPPPPPPPPPGPPPPFPPPPPNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["ATT","Acquire","AcquireRelease","Add","AddressSpace","Aggressive","And","AtomicOrdering","AtomicRMWBinOp","DLLStorageClass","Default","Default","Default","EQ","Export","FAdd","FMax","FMin","FSub","FloatPredicate","GeneralDynamicTLSModel","GlobalVisibility","Hidden","Import","InitialExecTLSModel","InlineAsmDialect","IntPredicate","Intel","Less","LocalDynamicTLSModel","LocalExecTLSModel","Max","Min","Monotonic","NE","Nand","None","NotAtomic","OEQ","OGE","OGT","OLE","OLT","ONE","ORD","OptimizationLevel","Or","PredicateFalse","PredicateTrue","Protected","Release","SGE","SGT","SLE","SLT","SequentiallyConsistent","Sub","ThreadLocalMode","UEQ","UGE","UGE","UGT","UGT","ULE","ULE","ULT","ULT","UMax","UMin","UNE","UNO","Unordered","Xchg","Xor","attributes","basic_block","borrow","borrow","borrow","borrow","borrow","borrow","borrow","
["inkwell_internals",{"doc":"These macros are only intended to be used by inkwell …","t":"XXX","n":["llvm_enum","llvm_versioned_item","llvm_versions"],"q":[[0,"inkwell_internals"]],"d":["This attribute macro allows you to decorate an enum …","This attribute is used to decorate enums, structs, or …","This macro can be used to specify version constraints for …"],"i":[0,0,0],"f":"```","c":[],"p":[],"b":[]}],\
["is_terminal",{"doc":"is-terminal is a simple utility that answers one question:","t":"KHM","n":["IsTerminal","is_terminal","is_terminal"],"q":[[0,"is_terminal"]],"d":["Extension trait to check whether something is a terminal.","Returns <code>true</code> if <code>this</code> is a terminal.","Returns true if this is a terminal."],"i":[0,0,2],"f":"`{cbd}{db}","c":[],"p":[[1,"bool"],[10,"IsTerminal",0]],"b":[]}],\
["is_terminal_polyfill",{"doc":"Polyfill for <code>is_terminal</code> stdlib feature for use with older …","t":"KM","n":["IsTerminal","is_terminal"],"q":[[0,"is_terminal_polyfill"]],"d":["Trait to determine if a descriptor/handle refers to a …","Returns <code>true</code> if the descriptor/handle refers to a …"],"i":[0,1],"f":"`{bd}","c":[],"p":[[10,"IsTerminal",0],[1,"bool"]],"b":[]}],\
["lalrpop_util",{"doc":"","t":"FPPGPPPNNNNNNNNNNNONNONNNNNNNNNQCNNNNNCNNNNNNNNNOOOOOOOFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPRPRIPPRRPIIFKKPRGRRRIRRIPPPMMMNNNNNOMOMMMNNNMNNMMMMMMMMMNNNNNNMOOOOOOOOO","n":["ErrorRecovery","ExtraToken","InvalidToken","ParseError","UnrecognizedEof","UnrecognizedToken","User","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","cmp","cmp","description","dropped_tokens","eq","eq","error","fmt","fmt","fmt","from","from","from","from","into","into","lalrpop_mod","lexer","map_error","map_location","map_token","partial_cmp","partial_cmp","state_machine","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","error","expected","expected","location","location","token","token","Matcher","MatcherBuilder","Token","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","cmp","eq","fmt","fmt","from","from","from","into","into","into","into_iter","matcher","new","next","partial_cmp","to_owned","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","Accept","Action","Err","Error","ErrorRecovery","ExtraToken","InvalidToken","Location","NonterminalIndex","Ok","ParseError","ParseResult","Parser","ParserAction","ParserDefinition","Reduce","ReduceIndex","SimulatedReduce","StateIndex","Success","Symbol","SymbolTriple","Token","TokenIndex","TokenTriple","UnrecognizedEof","UnrecognizedToken","User","action","as_reduce","as_shift","borrow","borrow","borrow_mut","borrow_mut","drive","dropped_tokens","eof_action","error","error_action","error_recovery_symbol","expected_tokens","expected_tokens_from_states","from","from","goto","into","into","is_error","is_reduce","is_shift","reduce","simulate_reduce","start_location","start_state","token_to_index","token_to_symbol","try_from","try_from","try_into","try_into","type_id","type_id","uses_error_recovery","error","expected","expected","location","location","token","token","nonterminal_produced","states_to_pop"],"q":[[0,"lalrpop_util"],[48,"lalrpop_util::ParseError"],[55,"lalrpop_util::lexer"],[92,"lalrpop_util::state_machine"],[156,"lalrpop_util::state_machine::ParseError"],[163,"lalrpop_util::state_machine::SimulatedReduce"],[165,"core::clone"],[166,"core::cmp"],[167,"core::cmp"],[168,"core::fmt"],[169,"core::ops::function"],[170,"core::cmp"],[171,"core::result"],[172,"core::any"],[173,"core::fmt"],[174,"core::convert"],[175,"core::iter::traits::collect"],[176,"core::marker"],[177,"core::iter::traits::iterator"],[178,"alloc::vec"]],"d":["","Generated by the parser when it encounters additional, …","Generated by the parser when it encounters a token (or …","","Generated by the parser when it encounters an EOF it did …","Generated by the parser when it encounters a token it did …","Custom error type.","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Define a module using the generated parse from a <code>.lalrpop</code> …","","","","","","","","","","","","","","","","","","The set of expected tokens: these names are taken from the …","The set of expected tokens: these names are taken from the …","","The end of the final token","The unexpected token of type <code>T</code> with a span given by the …","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","","","","","","","","","","","","","","","Identifies an action.","Contains the error value","Represents a “user error” – this can get produced by …","","Generated by the parser when it encounters additional, …","Generated by the parser when it encounters a token (or …","Represents a location in the input text. If you are using …","Identifies a nonterminal.","Containsthesuccessv
["lazy_static",{"doc":"A macro for declaring lazily evaluated statics.","t":"KHQ","n":["LazyStatic","initialize","lazy_static"],"q":[[0,"lazy_static"]],"d":["Support trait for enabling a few common operation on lazy …","Takes a shared reference to a lazy static and initializes …",""],"i":[0,0,0],"f":"`{cbd}`","c":[],"p":[[1,"unit"],[10,"LazyStatic",0]],"b":[]}],\
["libc",{"doc":"libc - Raw FFI bindings to platforms’ system libraries","t":"SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSHSSSSSSSSHSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHHHHHSSSHHHHHHHSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSGSSSSSSSSSSSFSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSIFFIIFIFFIIFFIIFIFIFIISSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHHHSHSSSSSSSGSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSHSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSHSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSISSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSHSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHHHHSSSSSSSHHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
["libz_sys",{"doc":"","t":"ISSSSSSSSSSSSSSSSSSSSSSSSSSSSSSOHHIOONNNNNNNNNNNNOOHHHHHOHHHHHHHHHHHHOOOOINNNNIGFIHHHHHHHHHHHHHHHHHHHOIHHHHHHHHHHHHHHHGNNNNOOOOOOOIOOOONNOONNNNNNNNNNNNIIIHIIIOIFIOOHH","n":["Bytef","Z_ASCII","Z_BEST_COMPRESSION","Z_BEST_SPEED","Z_BINARY","Z_BLOCK","Z_BUF_ERROR","Z_DATA_ERROR","Z_DEFAULT_COMPRESSION","Z_DEFAULT_STRATEGY","Z_DEFLATED","Z_ERRNO","Z_FILTERED","Z_FINISH","Z_FIXED","Z_FULL_FLUSH","Z_HUFFMAN_ONLY","Z_MEM_ERROR","Z_NEED_DICT","Z_NO_COMPRESSION","Z_NO_FLUSH","Z_OK","Z_PARTIAL_FLUSH","Z_RLE","Z_STREAM_END","Z_STREAM_ERROR","Z_SYNC_FLUSH","Z_TEXT","Z_TREES","Z_UNKNOWN","Z_VERSION_ERROR","adler","adler32","adler32_combine","alloc_func","avail_in","avail_out","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","comm_max","comment","compress","compress2","compressBound","crc32","crc32_combine","data_type","deflate","deflateBound","deflateCopy","deflateEnd","deflateInit2_","deflateInit_","deflateParams","deflatePrime","deflateReset","deflateSetDictionary","deflateSetHeader","deflateTune","done","extra","extra_len","extra_max","free_func","from","from","from","from","gzFile","gzFile_s","gz_header","gz_headerp","gzclearerr","gzclose","gzdirect","gzdopen","gzeof","gzerror","gzflush","gzgetc","gzgets","gzopen","gzputc","gzputs","gzread","gzrewind","gzseek","gzsetparams","gztell","gzungetc","gzwrite","hcrc","in_func","inflate","inflateBack","inflateBackEnd","inflateBackInit_","inflateCopy","inflateEnd","inflateGetHeader","inflateInit2_","inflateInit_","inflateMark","inflatePrime","inflateReset","inflateReset2","inflateSetDictionary","inflateSync","internal_state","into","into","into","into","msg","name","name_max","next_in","next_out","opaque","os","out_func","reserved","state","text","time","to_owned","to_owned","total_in","total_out","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","uInt","uLong","uLongf","uncompress","voidp","voidpc","voidpf","xflags","z_off_t","z_stream","z_streamp","zalloc","zfree","zlibCompileFlags","zlibVersion"],"q":[[0,"libz_sys"],[166,"core::result"],[167,"core::any"]],"d":["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,2,2,6,7,1,2,6,7,1,2,1,2,1,2,1,1,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,6,7,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,7,1,2,2,1,1,2,2,2,1,0,2,2,1,1,1,2,2,2,6,7,1,2,6,7,1,2,6,7,1,2,0,0,0,0,0,0,0,1,0,0,0,2,2,0,0],"f":"`````````````````````````````````````{ce{}{}}0000000{bb}{dd}{{ce}f{}{}}0`````````````````````````{cc{}}000`````````````````````````````````````````4444````````````44``{c{{h{e}}}{}{}}0000000{cj{}}000```````````````","c":[],"p":[[5,"gz_header",0],[5,"z_stream",0],[1,"unit"],[6,"Result",166],[5,"TypeId",167],[6,"gzFile_s",0],[6,"internal_state",0]],"b":[]}],\
["llvm_sys",{"doc":"Bindings to LLVM’s C API.","t":"PPPPPPPPPPPPPPPPPPPPPPPPGPPPPPPPPGPPPPPPPPPPPPPPPSISPPGPPPPGPPPPGPPPPPPGPPPPPPPPPPPPPGPPPPGPPPPPPIGGPPPPPPPPPPPPPPPPPPSSSSSISSSSPPPPPPPPPPPPPPPPPPPPPGPPPPPPPPGPPPPPPPPPPPPPPPPPGPPPPGPPPPPPPPGPPPPPGGPPPPPPGPPPGGGGGGGGGPPPPPGPPPPPPPPPPPPPPGPPPPPPPPPPPPPPPPPPPPPPPPPPGPPPPPGPPGGPPPPGPGPPPGGPGPPPPPPPPPPPPPPPIPPPPPCCCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCNNNNNNNNNNNNNNNNNNCCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCCCCCCCNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPPGHHHHNNNNNNNNNNNNHHHHHHHHHHHHSSSSSSNNNNFHHHHHHHHHNNNPGPHHHPPPHHNNNNNNNNNNNNHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHPHHPPPHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHPPPPPPHHHPSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSIPHHPPPPPPPHHHHPPPPPPHPHPPPPPHHHHHHHHHGPPPGPPPPPGPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPIHHHPPHHHHHHPPPGHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOHHHIHHSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSIFGHIOPPOPPFOOOONNNNNNNNNNNNNNNNNNNNNNNNHHHISIHHHGNNNNNNNNHIHHPPOOHHHHHHHHHHHHHHHHHHIHHHIHHHHHHHHHHHFIIIIIGGGHHHHHHOOPOPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHPGPNNNNNNNNGGGGFPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHIIHHHHHHHHHGHGHHHHHHHHHHHGIHHHHHHHIHHHHHHHHHHHHHHHHHHHHHHIHHGIHHHHHHHHHHHHHHHHHHHHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHIGPPPPPPPPPPPPPPPPHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIGGGGGIIINNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOFFGPPPPPIHIFIIFIFFFIFIFIFHHHHHHHHHHIIHHHHHHHHHHHHIHIHHHHHHIIHIIHIHIIHHHHHGPPIIHHHIHIHGPPHIHHHHHHHHHHHHIHIIIIHHHIIIHIGGGGGGGGGGGGGGGGGGGHHIHHHGPPIHIHIHIIHOOOOOOOOPPOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNIIHHHHHHHHHHHIIHHHHHHHHHHHHHIGGNNNNNNNNNNNNNNNNIIIIIIIIIIIIIIIIIIIIIHHHIHHHIHHHHHHHHHHIGGGGGHHHHHHIHHIGPPPPPPPHSNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHHHPHGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHPHGGHHHHHHHIIHHHHHHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNHPGPPPPGGPPPPPPPHHHHHHHHHHHHHHHHHHHPPPGHPGGPPGPPPPPHHHHHGHHHHHIHHHHHHIINNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCHHGIHHHHHHHHHHHHHNNNNNNNN","n":["LLVMAMDGPUCSCallConv","LLVMAMDGPUESCallConv","LLVMAMDGPUGSCallConv","LLVMAMDGPUHSCallConv","LLVMAMDGPUKERNELCallConv","LLVMAMDGPULSCallConv","LLVMAMDGPUPSCallConv","LLVMAMDGPUVSCallConv","LLVMARMAAPCSCallConv","LLVMARMAAPCSVFPCallConv","LLVMARMAPCSCallConv","LLVMAShr","LLVMAVRBUILTINCallConv","LLVMAVRINTRCallConv","LLVMAVRSIGNALCallConv","LLVMAdd","LLVMAddrSpaceCast","LLVMAlloca","LLVMAnd","LLVMAnyRegCallConv","LLVMAppendingLinkage","LLVMArgumentValueKind","LLVMArrayTypeKind","LLVMAtomicCmpXchg","LLVMAtomicOrdering","LLVMAtomicOrderingAcquire","LLVMAtomicOrderingAcquireRelease","LLVMAtomicOrderingMonotonic","LLVMAtomicOrderingNotAtomic","LLVMAtomicOrderingRelease","LLVMAtomicOrderingSequentiallyConsistent","LLVMAtomicOrderingUnordered","LLVMAtomicRMW","LLVMAtomicRMWBinOp","LLV
["log",{"doc":"A lightweight logging facade.","t":"PPPPPPGGKFFPFFFSFPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQNNMNNNNNNNQNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNMQQHNNHNNNNNNNNNNNNNNHHHHHNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNQ","n":["Debug","Debug","Error","Error","Info","Info","Level","LevelFilter","Log","Metadata","MetadataBuilder","Off","ParseLevelError","Record","RecordBuilder","STATIC_MAX_LEVEL","SetLoggerError","Trace","Trace","Warn","Warn","args","args","as_str","as_str","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","builder","builder","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","debug","default","default","enabled","eq","eq","eq","eq","eq","eq","eq","error","file","file","file_static","file_static","flush","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_str","from_str","hash","hash","hash","hash","info","into","into","into","into","into","into","into","into","iter","iter","level","level","level","level","line","line","log","log","log_enabled","logger","max","max","max_level","metadata","metadata","module_path","module_path","module_path_static","module_path_static","new","new","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","set_boxed_logger","set_logger","set_logger_racy","set_max_level","set_max_level_racy","target","target","target","target","to_level","to_level_filter","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","trace","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","warn"],"q":[[0,"log"],[183,"core::fmt"],[184,"core::cmp"],[185,"core::option"],[186,"core::fmt"],[187,"core::hash"],[188,"core::iter::traits::iterator"],[189,"alloc::boxed"],[190,"alloc::string"],[191,"core::any"]],"d":["The “debug” level.","Corresponds to the <code>Debug</code> log level.","The “error” level.","Corresponds to the <code>Error</code> log level.","The “info” level.","Corresponds to the <code>Info</code> log level.","An enum representing the available verbosity levels of the …","An enum representing the available verbosity level filters …","A trait encapsulating the operations required of a logger.","Metadata about a log message.","Builder for <code>Metadata</code>.","A level lower than all log levels.","The type returned by <code>from_str</code> when the string doesn’t …","The “payload” of a log message.","Builder for <code>Record</code>.","The statically resolved maximum log level.","The type returned by <code>set_logger</code> if <code>set_logger</code> has already …","The “trace” level.","Corresponds to the <code>Trace</code> log level.","The “warn” level.","Corresponds to the <code>Warn</code> log level.","The message body.","Set <code>args</code>.","Returns the string representation of the <code>Level</code>.","Returns the string representation of the <code>LevelFilter</code>.","","","","","","","","","","","","","","","","","Invoke the builder and return a <code>Record</code>","Returns a <code>Metadata</code> object.","Returns a new builder.","Returns a new builder.","","","","","","","","","","","","","Logs a message at the debug level.","","","Determines if a log message with the specified metadata …","","","","","","","","Logs a message at the error level.","The source file containing the message.","Set <code>file</code>","The source file containing the message, if it is a <code>'static</code> …","Set <code>file</code> to a <code>'static</code> string.","Flushes any buffered records.","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Ret
["logos",{"doc":"Logos","t":"PPPRRGGFKYFPPERIFNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNMNNNNNNNHNCNNNONNNNNNNNNNNNNNNNNNKTRKNMMMMMMM","n":["Emit","Emit","Error","Error","Extras","Filter","FilterResult","Lexer","Logos","Logos","Skip","Skip","Skip","Source","Source","Span","SpannedIter","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bump","clone","clone","clone_into","clone_into","deref","deref_mut","end","extras","fmt","from","from","from","from","from","into","into","into","into","into","into_iter","into_iter","lex","lexer","lexer_with_extras","morph","new","next","next","remainder","skip","slice","source","source","span","spanned","start","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","with_extras","Chunk","SIZE","Slice","Source","find_boundary","from_ptr","is_boundary","len","read","read_unchecked","slice","slice_unchecked"],"q":[[0,"logos"],[82,"logos::source"],[94,"core::clone"],[95,"core::fmt"],[96,"core::fmt"],[97,"core::default"],[98,"core::cmp"],[99,"core::fmt"],[100,"core::option"],[101,"core::any"],[102,"core::cmp"]],"d":["Emit a token with a given value <code>T</code>. Use <code>()</code> for unit …","Emit a token with a given value <code>T</code>. Use <code>()</code> for unit …","Emit a <code><Token as Logos>::ERROR</code> token.","Error type returned by the lexer. This can be set using …","Associated type <code>Extras</code> for the particular lexer. This can …","Type that can be returned from a callback, either …","Type that can be returned from a callback, either …","<code>Lexer</code> is the main struct of the crate that allows you to …","Trait implemented for an enum representing all tokens. You …","","Type that can be returned from a callback, informing the …","Skip current match, analog to <code>Skip</code>.","Skip current match, analog to <code>Skip</code>.","","Source type this token can be lexed from. This will …","Byte range in the source.","Iterator that pairs tokens with their position in the …","","","","","","","","","","","Bumps the end of currently lexed token by <code>n</code> bytes.","","","","","","","The upper bound of the range (exclusive).","Extras associated with the <code>Token</code>.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","The heart of Logos. Called by the <code>Lexer</code>. The …","Create a new instance of a <code>Lexer</code> that will produce tokens …","Create a new instance of a <code>Lexer</code> with the provided <code>Extras</code> …","Turn this lexer into a lexer for a new token type.","Create a new <code>Lexer</code>.","","","Get a slice of remaining source, starting at the end of …","Predefined callback that will inform the <code>Lexer</code> to skip a …","Get a string slice of the current token.","This module contains a bunch of traits necessary for …","Source from which this Lexer is reading tokens.","Get the range for the current token in <code>Source</code>.","Wrap the <code>Lexer</code> in an <code>Iterator</code> that produces tuples of …","The lower bound of the range (inclusive).","","","","","","","","","","","","","","","","","","Create a new <code>Lexer</code> with the provided <code>Extras</code>.","A fixed, statically sized chunk of data that can be read …","Size of the chunk being accessed in bytes.","A type this <code>Source</code> can be sliced into.","Trait for types the <code>Lexer</code> can read from.","For <code>&str</code> sources attempts to find the closest <code>char</code> …","Create a chunk from a raw byte pointer.","Check if <code>index</code> is valid for this <code>Source</code>, that is:","
["logos_codegen",{"doc":"Logos","t":"HH","n":["generate","strip_attributes"],"q":[[0,"logos_codegen"],[2,"proc_macro2"]],"d":["Generate a <code>Logos</code> implementation for the given struct, …","Strip all logos attributes from the given struct, allowing …"],"i":[0,0],"f":"{bb}0","c":[],"p":[[5,"TokenStream",2]],"b":[]}],\
["matchers",{"doc":"Regex matchers on character and byte streams.","t":"RFFFKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNN","n":["Automaton","Error","Matcher","Pattern","ToMatcher","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","debug_matches","debug_matches","description","display_matches","display_matches","flush","fmt","fmt","fmt","fmt","from","from","from","from_str","into","into","into","is_matched","kind","matcher","matcher","matcher","matches","matches","new","new_anchored","read_matches","read_matches","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","write","write_str"],"q":[[0,"matchers"],[60,"regex_automata::state_id"],[61,"core::clone"],[62,"regex_automata::dfa"],[63,"core::fmt"],[64,"core::fmt"],[65,"core::result"],[66,"core::fmt"],[67,"alloc::vec"],[68,"regex_automata::dense_imp"],[69,"regex_automata::sparse_imp"],[70,"core::convert"],[71,"std::io::error"],[72,"core::marker"],[73,"alloc::string"],[74,"core::any"]],"d":["","An error that occurred during the construction of a DFA.","A reference to a <code>Pattern</code> that matches a single input.","A compiled match pattern that can match multipe inputs, or …","","","","","","","","","","","","","","Returns <code>true</code> if this pattern matches the formatted output …","Returns <code>true</code> if this pattern matches the formatted output …","","Returns <code>true</code> if this pattern matches the formatted output …","Returns <code>true</code> if this pattern matches the formatted output …","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Returns <code>true</code> if this <code>Matcher</code> has matched any input that …","Return the kind of this error.","","","","Returns <code>true</code> if this pattern matches the given string.","Returns <code>true</code> if this pattern matches the formatted output …","Returns a new <code>Pattern</code> for the given regex, or an error if …","Returns a new <code>Pattern</code> anchored at the beginning of the …","Returns either a <code>bool</code> indicating whether or not this …","Returns either a <code>bool</code> indicating whether or not this …","","","","","","","","","","","","","","",""],"i":[20,0,0,0,0,1,6,7,1,6,7,1,6,7,1,6,7,1,6,7,1,6,6,1,6,7,7,1,6,7,1,1,6,7,6,7,20,1,1,1,6,1,1,1,6,1,6,7,7,1,6,7,1,6,7,1,6,7,6,6],"f":"`````{ce{}{}}00000{{{b{ce}}}{{b{ce}}}{df}{{j{}{{h{c}}}}f}}{{{l{ce}}}{{l{ce}}}{df}{{j{}{{h{c}}}}f}}{nn}{{ce}A`{}{}}00{{{b{ce}}g}Abd{{j{}{{h{c}}}}}Ad}{{{l{ce}}g}Abd{{j{}{{h{c}}}}}Ad}{nAf}{{{b{ce}}g}Abd{{j{}{{h{c}}}}}Ah}{{{l{ce}}g}Abd{{j{}{{h{c}}}}}Ah}{{{l{ce}}}{{Al{A`Aj}}}d{{j{}{{h{c}}}}}}{{{b{ce}}An}B`{dAd}{{j{}{{h{c}}}}Ad}}{{{l{ce}}An}B`{dAd}{{j{}{{h{c}}}}Ad}}{{nAn}{{Al{A`Bb}}}}0{cc{}}00{Af{{Al{bc}}}{}}???{{{l{ce}}}Abd{{j{}{{h{c}}}}}}{nBd}{{{Bh{}{{Bf{c}}}}}{{l{ec}}}{{j{}{{h{e}}}}}d}{{{b{c{Bl{{Bj{c}}c}}}}}{{l{ce}}}d{}}{{{b{c{C`{{Bj{Bn}}c}}}}}{{l{ce}}}d{}}{{{b{ce}}g}Abd{{j{}{{h{c}}}}}{{Cb{Af}}}}{{{l{ce}}g}Abd{{j{}{{h{c}}}}}{{Cb{Af}}}}{Af{{Al{bn}}}}0{{{b{ce}}g}{{Cd{Ab}}}d{{j{}{{h{c}}}}}Cf}{{{l{ce}}g}{{Cd{Ab}}}d{{j{}{{h{c}}}}}{CfCh}}{ce{}{}}00{cCj{}}{c{{Al{e}}}{}{}}00000{cCl{}}00{{{l{ce}}{Cn{Bn}}}{{Al{D`Aj}}}d{{j{}{{h{c}}}}}}{{{l{ce}}Af}B`d{{j{}{{h{c}}}}}}","c":[],"p":[[5,"Pattern",0],[10,"StateID",60],[10,"Clone",61],[17,"ID"],[10,"DFA",62],[5,"Matcher",0],[5,"Error",0],[1,"unit"],[1,"bool"],[10,"Debug",63],[1,"str"],[10,"Display",63],[5,"Error",64],[6,"Result",65],[5,"Formatter",63],[8,"Result",63],[5,"Error",63],[6,"ErrorKind",66],[17,"Automaton"],[10,"ToMatcher",0],[5,"Vec",67],[6,"DenseDFA",68],[1,"u8"],[6,"SparseDFA",69],[10,"AsRef",70],[8,"Result",64],[10,"Read",71],[10,"Sized",72],[5,"String",73],[5,"TypeId",74],[1,"slice"],[1,"usize"]],"b":[[25,"impl-Display-for-Error"],[26,"impl-Debug-for-Error"],[37,"impl-ToM
["nu_ansi_term",{"doc":"This is a library for controlling colors and formatting, …","t":"IHIFFIHIPPGPPPPPEPPPPPPPPPEPPFPFEPPNNNNCNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNOCNNNNNNNNNNNOOOOONOOONNNNNNNNNNNNNNNNNNONNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNHHNNNNFFJFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKPPFGMNNNNNNHNNNNNONNNNNNNNNNNONNNNNNNN","n":["AnsiByteString","AnsiByteStrings","AnsiByteStrings","AnsiGenericString","AnsiGenericStrings","AnsiString","AnsiStrings","AnsiStrings","Black","Blue","Color","Cyan","DarkGray","Default","Fixed","Green","Infix","LightBlue","LightCyan","LightGray","LightGreen","LightMagenta","LightPurple","LightRed","LightYellow","Magenta","Prefix","Purple","Red","Rgb","Rgb","Style","Suffix","White","Yellow","add","add","add","add","ansi","ansi_color_code","b","background","blink","blink","bold","bold","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","default","default","dimmed","dimmed","eq","eq","eq","eq","eq","fg","fmt","fmt","fmt","fmt","fmt","fmt","fmt","foreground","from","from","from","from","from","from","from","from","from","from_f32","from_hex","from_hex_string","g","gradient","gray","gray_f32","hidden","hidden","infix","infix","into","into","into","into","into","is_blink","is_bold","is_dimmed","is_hidden","is_italic","is_plain","is_reverse","is_strikethrough","is_underline","italic","italic","lerp","mul","mul","mul","mul","neg","neg","new","new","normal","on","on","paint","paint","prefix","prefix","r","reverse","reverse","strikethrough","strikethrough","style_ref","style_ref_mut","sub","sub","sub","sub","sub_string","suffix","suffix","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","underline","underline","unstyle","unstyled_len","write_to","write_to","write_to","write_to","Infix","Prefix","RESET","Suffix","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","into","into","into","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","ANSIColorCode","Background","Foreground","Gradient","TargetGround","ansi_color_code","at","borrow","borrow","borrow_mut","borrow_mut","build","build_all_gradient_text","clone","clone","clone_into","clone_into","code","end","eq","eq","fmt","fmt","from","from","from_color_rgb","into","into","new","reverse","start","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id"],"q":[[0,"nu_ansi_term"],[178,"nu_ansi_term::ansi"],[221,"nu_ansi_term::gradient"],[260,"alloc::string"],[261,"alloc::borrow"],[262,"core::marker"],[263,"core::cmp"],[264,"core::fmt"],[265,"core::fmt"],[266,"alloc::vec"],[267,"core::result"],[268,"core::any"],[269,"std::io::error"],[270,"std::io"]],"d":["An <code>AnsiByteString</code> represents a formatted series of bytes. …","A function to construct an <code>AnsiByteStrings</code> instance.","A set of <code>AnsiByteString</code>s collected together, in order to be","An <code>AnsiGenericString</code> includes a generic string type and a …","A set of <code>AnsiGenericStrings</code>s collected together, in order …","An ANSI String is a string coupled with the <code>Style</code> to …","A function to construct an <code>AnsiStrings</code> instance.","A set of <code>AnsiString</code>s collected together, in order to be …","Color #0 (foreground code <code>30</code>, background code <code>40</code>).","Color #4 (foreground code <code>34</code>, background code <code>44</code>).","A color is one specific type of ANSI escape code, and can …","Color #6 (foreground code <code>36</code>, background code <code>46</code>).","Color#0(foregroundcode
["once_cell",{"doc":"Overview","t":"CCCFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["race","sync","unsync","OnceBool","OnceBox","OnceNonZeroUsize","OnceRef","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","default","default","default","default","drop","fmt","fmt","fmt","fmt","from","from","from","from","get","get","get","get","get_or_init","get_or_init","get_or_init","get_or_init","get_or_try_init","get_or_try_init","get_or_try_init","get_or_try_init","into","into","into","into","new","new","new","new","set","set","set","set","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","Lazy","OnceCell","borrow","borrow","borrow_mut","borrow_mut","clone","clone_from","clone_into","default","default","deref","deref_mut","eq","fmt","fmt","force","force_mut","from","from","from","from","get","get","get_mut","get_mut","get_or_init","get_or_try_init","get_unchecked","into","into","into_inner","into_value","new","new","set","take","to_owned","try_from","try_from","try_insert","try_into","try_into","type_id","type_id","wait","with_value","Lazy","OnceCell","borrow","borrow","borrow_mut","borrow_mut","clone","clone_from","clone_into","default","default","deref","deref_mut","eq","fmt","fmt","force","force_mut","from","from","from","from","get","get","get_mut","get_mut","get_or_init","get_or_try_init","into","into","into_inner","into_value","new","new","set","take","to_owned","try_from","try_from","try_insert","try_into","try_into","type_id","type_id","with_value"],"q":[[0,"once_cell"],[3,"once_cell::race"],[64,"once_cell::sync"],[111,"once_cell::unsync"],[156,"core::fmt"],[157,"core::fmt"],[158,"core::num::nonzero"],[159,"core::ops::function"],[160,"alloc::boxed"],[161,"core::result"],[162,"core::any"],[163,"core::clone"],[164,"core::default"],[165,"core::cmp"],[166,"core::fmt"]],"d":["Thread-safe, non-blocking, “first one wins” flavor of …","Thread-safe, blocking version of <code>OnceCell</code>.","Single-threaded version of <code>OnceCell</code>.","A thread-safe cell which can be written to only once.","A thread-safe cell which can be written to only once.","A thread-safe cell which can be written to only once.","A thread-safe cell which can be written to only once.","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Gets a reference to the underlying value.","Gets a reference to the underlying value.","Gets the underlying value.","Gets the underlying value.","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Gets the contents of the cell, initializing it with <code>f</code> if …","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Creates a new empty cell.","Creates a new empty cell.","Creates a new empty cell.","Creates a new empty cell.","Sets the contents of this cell to <code>value</code>.","Sets the contents of this cell to <code>value</code>.","Sets the contents of this cell to <code>value</code>.","Sets the contents of this cell to <code>value</code>.","","","","","","","","","","","","","A value which is initialized on the first access.","A thread-safe cell which can be written to only once.","","","","","","","","","Creates a new lazy value using <code>Default</code> as the initializing …",""
["openssl_probe",{"doc":"","t":"SSFNNOOHNHHNHNHNN","n":["ENV_CERT_DIR","ENV_CERT_FILE","ProbeResult","borrow","borrow_mut","cert_dir","cert_file","find_certs_dirs","from","has_ssl_cert_env_vars","init_ssl_cert_env_vars","into","probe","try_from","try_init_ssl_cert_env_vars","try_into","type_id"],"q":[[0,"openssl_probe"],[17,"std::path"],[18,"alloc::vec"],[19,"core::result"],[20,"core::any"]],"d":["The OpenSSL environment variable to configure what …","The OpenSSL environment variable to configure what …","","","","","","Probe the system for the directory in which CA …","Returns the argument unchanged.","Check whether the OpenSSL <code>SSL_CERT_FILE</code> and/or <code>SSL_CERT_DIR</code>…","Probe for SSL certificates on the system, then configure …","Calls <code>U::from(self)</code>.","","","Probe for SSL certificates on the system, then configure …","",""],"i":[0,0,0,5,5,5,5,0,5,0,0,5,0,5,0,5,5],"f":"```{ce{}{}}0``{{}{{d{b}}}}{cc{}}{{}f}{{}h}4{{}j}{c{{l{e}}}{}{}}30{cn{}}","c":[],"p":[[5,"PathBuf",17],[5,"Vec",18],[1,"bool"],[1,"unit"],[5,"ProbeResult",0],[6,"Result",19],[5,"TypeId",20]],"b":[]}],\
["overload",{"doc":"Provides a macro to simplify operator overloading.","t":"Q","n":["overload"],"q":[[0,"overload"]],"d":["Overloads an operator. See the module level documentation …"],"i":[0],"f":"`","c":[],"p":[],"b":[]}],\
["percent_encoding",{"doc":"URLs use special characters to indicate the parts of the …","t":"FSSFFNNNNNNNNNNNNNNNNNNNNNNNNNHHHHNNNNNNNNNNNNNNNH","n":["AsciiSet","CONTROLS","NON_ALPHANUMERIC","PercentDecode","PercentEncode","add","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","decode_utf8","decode_utf8_lossy","fmt","fmt","from","from","from","into","into","into","into_iter","into_iter","next","next","percent_decode","percent_decode_str","percent_encode","percent_encode_byte","remove","size_hint","size_hint","to_owned","to_owned","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","utf8_percent_encode"],"q":[[0,"percent_encoding"],[50,"alloc::borrow"],[51,"core::str::error"],[52,"core::result"],[53,"core::fmt"],[54,"core::fmt"],[55,"alloc::string"],[56,"core::any"]],"d":["Represents a set of characters or bytes in the ASCII range.","The set of 0x00to 0x1F (C0 controls), and 0x7F (DEL).","Everything that is not an ASCII letter or digit.","The return type of <code>percent_decode</code>.","The return type of <code>percent_encode</code> and <code>utf8_percent_encode</code>.","","","","","","","","","","","","Decode the result of percent-decoding as UTF-8.","Decode the result of percent-decoding as UTF-8, lossily.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","","Percent-decode the given bytes.","Percent-decode the given string.","Percent-encode the given bytes with the given set.","Return the percent-encoding of the given byte.","","","","","","","","","","","","","","","","Percent-encode the UTF-8 encoding of the given string."],"i":[0,0,0,0,0,1,1,3,4,1,3,4,3,4,3,4,4,4,3,4,1,3,4,1,3,4,3,4,3,4,0,0,0,0,1,3,4,3,4,3,1,3,4,1,3,4,1,3,4,0],"f":"`````{{bd}b}{ce{}{}}00000{ff}{hh}{{ce}j{}{}}0{h{{Ab{{n{l}}A`}}}}{h{{n{l}}}}{{fAd}Af}{{hAd}Af}{cc{}}0088888{f{{Ah{l}}}}{h{{Ah{d}}}}{{{Aj{d}}}h}{lh}{{{Aj{d}}b}f}{dl}?{f{{An{Al{Ah{Al}}}}}}{h{{An{Al{Ah{Al}}}}}}{ce{}{}}0{cB`{}}{c{{Ab{e}}}{}{}}00000{cBb{}}00{{lb}f}","c":[],"p":[[5,"AsciiSet",0],[1,"u8"],[5,"PercentEncode",0],[5,"PercentDecode",0],[1,"unit"],[1,"str"],[6,"Cow",50],[5,"Utf8Error",51],[6,"Result",52],[5,"Formatter",53],[8,"Result",53],[6,"Option",54],[1,"slice"],[1,"usize"],[1,"tuple"],[5,"String",55],[5,"TypeId",56]],"b":[]}],\
["pin_project_lite",{"doc":"A lightweight version of pin-project written with …","t":"Q","n":["pin_project"],"q":[[0,"pin_project_lite"]],"d":["A macro that creates a projection type covering all the …"],"i":[0],"f":"`","c":[],"p":[],"b":[]}],\
["proc_macro2",{"doc":"githubcrates-iodocs-rs","t":"PPPGFPFPPFFPPPFPGFFGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNFENNNNNNNNNNNNNN","n":["Alone","Brace","Bracket","Delimiter","Group","Group","Ident","Ident","Joint","LexError","Literal","Literal","None","Parenthesis","Punct","Punct","Spacing","Span","TokenStream","TokenTree","as_char","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","byte_character","byte_string","c_string","call_site","character","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","default","delim_span","delimiter","eq","eq","eq","eq","extend","extend","extra","f32_suffixed","f32_unsuffixed","f64_suffixed","f64_unsuffixed","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_iter","from_iter","from_str","from_str","hash","i128_suffixed","i128_unsuffixed","i16_suffixed","i16_unsuffixed","i32_suffixed","i32_unsuffixed","i64_suffixed","i64_unsuffixed","i8_suffixed","i8_unsuffixed","into","into","into","into","into","into","into","into","into","into","into_iter","is_empty","isize_suffixed","isize_unsuffixed","join","located_at","mixed_site","new","new","new","new","new_raw","partial_cmp","resolved_at","set_span","set_span","set_span","set_span","set_span","source_text","spacing","span","span","span","span","span","span","span_close","span_open","stream","string","subspan","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","to_string","token_stream","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","u128_suffixed","u128_unsuffixed","u16_suffixed","u16_unsuffixed","u32_suffixed","u32_unsuffixed","u64_suffixed","u64_unsuffixed","u8_suffixed","u8_unsuffixed","unwrap","usize_suffixed","usize_unsuffixed","DelimSpan","borrow","borrow_mut","clone","clone_into","close","fmt","from","into","join","open","to_owned","try_from","try_into","type_id","IntoIter","TokenStream","borrow","borrow_mut","clone","clone_into","fmt","from","into","into_iter","next","size_hint","to_owned","try_from","try_into","type_id"],"q":[[0,"proc_macro2"],[230,"proc_macro2::extra"],[245,"proc_macro2::token_stream"],[261,"core::ffi::c_str"],[262,"core::cmp"],[263,"core::marker"],[264,"core::convert"],[265,"core::iter::traits::collect"],[266,"core::fmt"],[267,"core::fmt"],[268,"proc_macro"],[269,"core::hash"],[270,"core::option"],[271,"alloc::string"],[272,"core::ops::range"],[273,"core::any"]],"d":["E.g. <code>+</code> is <code>Alone</code> in <code>+ =</code>, <code>+ident</code> or <code>+()</code>.","<code>{ ... }</code>","<code>[ ... ]</code>","Describes how a sequence of token trees is delimited.","A delimited token stream.","A token stream surrounded by bracket delimiters.","A word of Rust code, which may be a keyword or legal …","An identifier.","E.g. <code>+</code> is <code>Joint</code> in <code>+=</code> or <code>'</code> is <code>Joint</code> in <code>'#</code>.","Error returned from <code>TokenStream::from_str</code>.","A literal string (<code>"hello"</code>), byte string (<code>b"hello"</code>), …","Aliteralcharacter(<code>'a'</code>),string(<
["quote",{"doc":"githubcrates-iodocs-rs","t":"KKKMMMMMQNNQQNNNNM","n":["IdentFragment","ToTokens","TokenStreamExt","append","append_all","append_separated","append_terminated","fmt","format_ident","into_token_stream","into_token_stream","quote","quote_spanned","span","span","to_token_stream","to_token_stream","to_tokens"],"q":[[0,"quote"],[18,"proc_macro2"],[19,"core::convert"],[20,"core::iter::traits::collect"],[21,"core::fmt"],[22,"core::fmt"]],"d":["Specialized formatting trait used by <code>format_ident!</code>.","Types that can be interpolated inside a <code>quote!</code> invocation.","TokenStream extension trait with methods for appending …","For use by <code>ToTokens</code> implementations.","For use by <code>ToTokens</code> implementations.","For use by <code>ToTokens</code> implementations.","For use by <code>ToTokens</code> implementations.","Format this value as an identifier fragment.","Formatting macro for constructing <code>Ident</code>s.","Convert <code>self</code> directly into a <code>TokenStream</code> object.","Convert <code>self</code> directly into a <code>TokenStream</code> object.","The whole point.","Same as <code>quote!</code>, but applies a given span to all tokens …","Span associated with this <code>IdentFragment</code>.","Span associated with this <code>IdentFragment</code>.","Convert <code>self</code> directly into a <code>TokenStream</code> object.","Convert <code>self</code> directly into a <code>TokenStream</code> object.","Write <code>self</code> to the given <code>TokenStream</code>."],"i":[0,0,0,1,1,1,1,7,0,6,6,0,0,7,7,6,6,6],"f":"```{{bc}d{{h{f}}}}{{bc}dj}{{bce}djl}0{{nA`}Ab}`{lAd}0``{n{{Ah{Af}}}}011{{lAd}d}","c":[],"p":[[10,"TokenStreamExt",0],[1,"unit"],[6,"TokenTree",18],[10,"Into",19],[10,"IntoIterator",20],[10,"ToTokens",0],[10,"IdentFragment",0],[5,"Formatter",21],[8,"Result",21],[5,"TokenStream",18],[5,"Span",18],[6,"Option",22]],"b":[]}],\
["regex",{"doc":"This crate provides routines for searching strings for …","t":"FFFFPGFFFFFFFKFFFFFFFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFFFFFKFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["CaptureLocations","CaptureMatches","CaptureNames","Captures","CompiledTooBig","Error","Match","Matches","NoExpand","Regex","RegexBuilder","RegexSet","RegexSetBuilder","Replacer","ReplacerRef","SetMatches","SetMatchesIntoIter","SetMatchesIter","Split","SplitN","SubCaptureMatches","Syntax","as_str","as_str","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","by_ref","by_ref","bytes","capture_locations","capture_names","captures","captures_at","captures_iter","captures_len","captures_read","captures_read_at","case_insensitive","case_insensitive","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","count","count","count","count","crlf","crlf","default","description","dfa_size_limit","dfa_size_limit","dot_matches_new_line","dot_matches_new_line","empty","end","eq","eq","escape","expand","extract","find","find_at","find_iter","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_str","get","get","ignore_whitespace","ignore_whitespace","index","index","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","is_empty","is_empty","is_match","is_match","is_match_at","is_match_at","iter","iter","len","len","len","len","len","line_terminator","line_terminator","matched","matched_any","matches","matches_at","multi_line","multi_line","name","nest_limit","nest_limit","new","new","new","new","next","next","next","next","next","next","next","next","next_back","next_back","no_expansion","no_expansion","no_expansion","no_expansion","octal","octal","patterns","range","replace","replace_all","replace_append","replace_append","replace_append","replacen","shortest_match","shortest_match_at","size_hint","size_hint","size_hint","size_hint","size_hint","size_limit","size_limit","split","splitn","start","static_captures_len","swap_greed","swap_greed","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","t
["regex_automata",{"doc":"This crate exposes a variety of regex engines used by the …","t":"PGPFPFPFFGGPPFFFFPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOOOOOFPFFPGPNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNOOOFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCPPFFPPFFPFPPPPFPFPFGFPGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNCNNNNNNNNONNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCCCCCCCCCCFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNHHFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNPPPGFFFPPPFPPPPPPPPPPPPNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNTTTTTTFFFTTTFFFFTTTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHNNNNNNNFFFONNNNNNONNNNNNNNNNNNNNNNNNNNNN","n":["All","Anchored","GaveUp","HalfMatch","HaystackTooLong","Input","LeftmostFirst","Match","MatchError","MatchErrorKind","MatchKind","No","Pattern","PatternID","PatternSet","PatternSetInsertError","PatternSetIter","Quit","Span","UnsupportedAnchored","Yes","anchored","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","clear","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","contains","contains","default","default","earliest","end","end","end","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","gave_up","get_anchored","get_earliest","get_range","get_span","hash","hash","hash","hash","haystack","haystack_too_long","hybrid","insert","into","into","into","into","into","into","into","into","into","into","into","into","into_iter","is_anchored","is_char_boundary","is_done","is_empty","is_empty","is_empty","is_full","iter","kind","len","len","len","meta","must","must","new","new","new","new","new","next","next_back","nfa","offset","offset","partial_cmp","pattern","pattern","pattern","quit","range","range","range","set_anchored","set_earliest","set_end","set_range","set_span","set_start","size_hint","span","span","start","start","start","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_insert","try_into","try_into","
["same_file",{"doc":"This crate provides a safe and simple <strong>cross platform</strong> way …","t":"FNNNNNNNNNNNNNNNHNNNNNN","n":["Handle","as_file","as_file_mut","as_raw_fd","borrow","borrow_mut","dev","eq","fmt","from","from_file","from_path","hash","ino","into","into_raw_fd","is_same_file","stderr","stdin","stdout","try_from","try_into","type_id"],"q":[[0,"same_file"],[23,"std::fs"],[24,"std::os::fd::raw"],[25,"core::fmt"],[26,"core::fmt"],[27,"std::path"],[28,"core::convert"],[29,"core::hash"],[30,"core::result"],[31,"core::any"]],"d":["A handle to a file that can be tested for equality with …","Return a reference to the underlying file.","Return a mutable reference to the underlying file.","","","","Return the underlying device number of this handle.","","","Returns the argument unchanged.","Construct a handle from a file.","Construct a handle from a path.","","Return the underlying inode number of this handle.","Calls <code>U::from(self)</code>.","","Returns true if the two file paths may correspond to the …","Construct a handle from stderr.","Construct a handle from stdin.","Construct a handle from stdout.","","",""],"i":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1],"f":"`{bd}0{bf}{ce{}{}}0{bh}{{bb}j}{{bl}n}{cc{}}{d{{A`{b}}}}{c{{A`{b}}}{{Ad{Ab}}}}{{bc}AfAh}678{{ce}{{A`{j}}}{{Ad{Ab}}}{{Ad{Ab}}}}{{}{{A`{b}}}}00{c{{Aj{e}}}{}{}}0{cAl{}}","c":[],"p":[[5,"Handle",0],[5,"File",23],[8,"RawFd",24],[1,"u64"],[1,"bool"],[5,"Formatter",25],[8,"Result",25],[8,"Result",26],[5,"Path",27],[10,"AsRef",28],[1,"unit"],[10,"Hasher",29],[6,"Result",30],[5,"TypeId",31]],"b":[]}],\
["serde_spanned",{"doc":"A serde-compatible spanned Value","t":"FNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Spanned","as_mut","as_ref","borrow","borrow","borrow_mut","clone","clone_into","cmp","deserialize","eq","fmt","from","get_mut","get_ref","hash","into","into_inner","new","partial_cmp","serialize","span","to_owned","try_from","try_into","type_id"],"q":[[0,"serde_spanned"],[26,"alloc::string"],[27,"core::clone"],[28,"core::cmp"],[29,"core::cmp"],[30,"serde::de"],[31,"serde::de"],[32,"core::fmt"],[33,"core::hash"],[34,"core::option"],[35,"core::cmp"],[36,"serde::ser"]],"d":["A spanned value, indicating the range at which it is …","","","","","","","","","","","","Returns the argument unchanged.","Returns a mutable reference to the contained value.","Returns a reference to the contained value.","","Calls <code>U::from(self)</code>.","Consumes the spanned value and returns the contained value.","Create a spanned value encompassing the given byte range.","","","Byte range","","","",""],"i":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"f":"`{{{b{c}}}c{}}0{ce{}{}}{{{b{d}}}f}1{{{b{c}}}{{b{c}}}h}{{ce}j{}{}}{{{b{c}}{b{c}}}ln}{c{{A`{{b{e}}}}}AbAd}{{{b{c}}{b{c}}}AfAh}{{{b{c}}Aj}AlAn}{cc{}}99{{{b{c}}e}jB`Bb}9:{{{Bf{Bd}}c}{{b{c}}}{}}{{{b{c}}{b{c}}}{{Bh{l}}}Bj}{{{b{c}}e}A`BlBn}{{{b{c}}}{{Bf{Bd}}}{}}={c{{A`{e}}}{}{}}0{cC`{}}","c":[],"p":[[5,"Spanned",0],[5,"String",26],[1,"str"],[10,"Clone",27],[1,"unit"],[6,"Ordering",28],[10,"Ord",28],[6,"Result",29],[10,"Deserializer",30],[10,"Deserialize",30],[1,"bool"],[10,"PartialEq",28],[5,"Formatter",31],[8,"Result",31],[10,"Debug",31],[10,"Hash",32],[10,"Hasher",32],[1,"usize"],[5,"Range",33],[6,"Option",34],[10,"PartialOrd",28],[10,"Serialize",35],[10,"Serializer",35],[5,"TypeId",36]],"b":[]}],\
["sharded_slab",{"doc":"A lock-free concurrent slab.","t":"KKFFTTTTTTFFTTFTFFNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Clear","Config","DefaultConfig","Entry","INITIAL_PAGE_SIZE","INITIAL_PAGE_SIZE","MAX_PAGES","MAX_PAGES","MAX_THREADS","MAX_THREADS","OwnedEntry","Pool","RESERVED_BITS","RESERVED_BITS","Slab","USED_BITS","UniqueIter","VacantEntry","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clear","clone","clone_into","contains","default","default","deref","deref","drop","drop","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get","get_owned","implementation","insert","insert","into","into","into","into","into","into","into","into_iter","key","key","key","new","new_with_config","next","pool","remove","take","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_iter","vacant_entry","OwnedRef","OwnedRefMut","Pool","Ref","RefMut","USED_BITS","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clear","create","create_owned","create_with","deref","deref","deref","deref","deref_mut","deref_mut","downgrade","downgrade","drop","drop","drop","drop","eq","eq","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from","get","get_owned","into","into","into","into","key","key","key","key","new","new_with_config","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id"],"q":[[0,"sharded_slab"],[104,"sharded_slab::pool"],[170,"core::default"],[171,"core::fmt"],[172,"core::fmt"],[173,"alloc::sync"],[174,"core::result"],[175,"core::any"],[176,"core::ops::function"]],"d":["Trait implemented by types which can be cleared in place, …","Configuration parameters which can be overridden to tune …","Default slab configuration values.","A handle that allows access to an occupied entry in a <code>Slab</code>.","The size of the first page in each shard.","The size of the first page in each shard.","The maximum number of pages in each shard in the slab.","The maximum number of pages in each shard in the slab.","The maximum number of threads which can access the slab.","The maximum number of threads which can access the slab.","An owned reference to an occupied entry in a <code>Slab</code>.","A lock-free concurrent object pool.","Sets a number of high-order bits in each index which are …","Sets a number of high-order bits in each index which are …","A sharded slab.","The number of bits in each index which are used by the …","An exclusive fused iterator over the items in a <code>Slab</code>.","A handle to a vacant entry in a <code>Slab</code>.","","","","","","","","","","","","","","","Clear all data in <code>self</code>, retaining the allocated capacithy.","","","Returns <code>true</code> if the slab contains a value for the given …","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Return a reference to the value associated with the given …","Return an owned reference to the value at the given index.","Notes on <code>sharded-slab</code>’s implementation and design.","Inserts a value into the slab, returning the integer index …","Insert a value in the entry.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","Returnsthekeyused
["smallvec",{"doc":"Small vectors in various sizes. These store a certain …","t":"PKPGFFRFKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNQNNNNMNNNNNNNNNNNNNNNNNNO","n":["AllocErr","Array","CapacityOverflow","CollectionAllocErr","Drain","IntoIter","Item","SmallVec","ToSmallVec","append","as_mut","as_mut_ptr","as_mut_slice","as_mut_slice","as_ptr","as_ref","as_slice","as_slice","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","clear","clone","clone","clone_from","clone_into","clone_into","cmp","dedup","dedup_by","dedup_by_key","default","deref","deref_mut","drain","drop","drop","drop","eq","extend","extend_from_slice","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_buf","from_buf_and_len","from_buf_and_len_unchecked","from_elem","from_iter","from_raw_parts","from_slice","from_vec","grow","hash","index","index_mut","inline_size","insert","insert_from_slice","insert_many","into","into","into","into","into_boxed_slice","into_inner","into_iter","into_iter","into_iter","into_iter","into_iter","into_vec","is_empty","len","len","new","next","next","next_back","next_back","partial_cmp","pop","push","remove","reserve","reserve_exact","resize","resize_with","retain","retain_mut","set_len","shrink_to_fit","size","size_hint","size_hint","smallvec","spilled","swap_remove","to_owned","to_owned","to_smallvec","to_string","truncate","try_from","try_from","try_from","try_from","try_grow","try_into","try_into","try_into","try_into","try_reserve","try_reserve_exact","type_id","type_id","type_id","type_id","with_capacity","layout"],"q":[[0,"smallvec"],[137,"smallvec::CollectionAllocErr"],[138,"core::clone"],[139,"core::cmp"],[140,"core::ops::function"],[141,"core::ops::range"],[142,"core::iter::traits::collect"],[143,"core::fmt"],[144,"core::fmt"],[145,"core::alloc::layout"],[146,"core::mem::maybe_uninit"],[147,"core::hash"],[148,"core::slice::index"],[149,"alloc::boxed"],[150,"core::result"],[151,"core::option"],[152,"alloc::string"],[153,"core::any"]],"d":["The allocator return an error","Types that can be used as the backing store for a <code>SmallVec</code>.","Overflow <code>usize::MAX</code> or other error during size computation","Error type for APIs with fallible heap allocation","An iterator that removes the items from a <code>SmallVec</code> and …","An iterator that consumes a <code>SmallVec</code> and yields its items …","The type of the array’s elements.","A <code>Vec</code>-like container that can store a small number of …","Convenience trait for constructing a <code>SmallVec</code>","Moves all the elements of <code>other</code> into <code>self</code>, leaving <code>other</code> …","","Returns a raw mutable pointer to the vector’s buffer.","Extracts a mutable slice of the entire vector.","Returns the remaining items of this iterator as a mutable …","Returns a raw pointer to the vector’s buffer.","","Extracts a slice containing the entire vector.","Returns the remaining items of this iterator as a slice.","","","","","","","","","","","The number of items the vector can hold without …","Remove all elements from the vector.","","","","","","","Removes consecutive duplicate elements.","Removes consecutive duplicate elements using the given …","Removes consecutive elements that map to the same key.","","","","Creates a draining iterator that removes the specified …","","","","","","Copy elements from a slice and append them to the vector.","","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Constructs a new <code>SmallVec</code> on the stack from an <code>A</code> without …","Constructs a new <code>SmallVec</code> on the stack from an <code>A</code> without …","Constructs a new <code>SmallVec</code> on the stack from an <code>A</code> without …","Createsa<code>SmallVec</code>with<code>n</code>copiesof<code>elem</code
["strsim",{"doc":"This library implements string similarity metrics.","t":"PPIPGNNHNNNNHHHHHHNHHHHHHHNNNN","n":["DifferentLengthArgs","Err","HammingResult","Ok","StrSimError","borrow","borrow_mut","damerau_levenshtein","eq","fmt","fmt","from","generic_damerau_levenshtein","generic_hamming","generic_jaro","generic_jaro_winkler","generic_levenshtein","hamming","into","jaro","jaro_winkler","levenshtein","normalized_damerau_levenshtein","normalized_levenshtein","osa_distance","sorensen_dice","to_string","try_from","try_into","type_id"],"q":[[0,"strsim"],[30,"core::fmt"],[31,"core::fmt"],[32,"core::fmt"],[33,"core::hash"],[34,"core::clone"],[35,"core::cmp"],[36,"alloc::string"],[37,"core::any"]],"d":["","Contains the error value","","Contains the success value","","","","Like optimal string alignment, but substrings can be …","","","","Returns the argument unchanged.","Like optimal string alignment, but substrings can be …","Calculates the number of positions in the two sequences …","Calculates the Jaro similarity between two sequences. The …","Like Jaro but gives a boost to sequences that have a …","Calculates the minimum number of insertions, deletions, …","Calculates the number of positions in the two strings …","Calls <code>U::from(self)</code>.","Calculates the Jaro similarity between two strings. The …","Like Jaro but gives a boost to strings that have a common …","Calculates the minimum number of insertions, deletions, …","Calculates a normalized score of the Damerau–Levenshtein …","Calculates a normalized score of the Levenshtein algorithm …","Like Levenshtein but allows for adjacent transpositions. …","Calculates a Sørensen-Dice similarity distance using …","","","",""],"i":[3,14,0,14,0,3,3,0,3,3,3,3,0,0,0,0,0,0,3,0,0,0,0,0,0,0,3,3,3,3],"f":"`````{ce{}{}}0{{bb}d}{{ff}h}{{fj}{{A`{ln}}}}{{fj}Ab}{cc{}}{{{Ad{c}}{Ad{c}}}d{AfAhAj}}{{gi}Al{}{{An{c}}}{{Bb{}{{B`{e}}}}}{{Bb{}{{B`{c}}}}}}{{ce}Bd{}{}}0{{ce}d{}{}}{{bb}Al}:{{bb}Bd}0:00:0{cBf{}}{c{{A`{e}}}{}{}}0{cBh{}}","c":[],"p":[[1,"str"],[1,"usize"],[6,"StrSimError",0],[1,"bool"],[5,"Formatter",30],[1,"unit"],[5,"Error",30],[6,"Result",31],[8,"Result",30],[1,"slice"],[10,"Eq",32],[10,"Hash",33],[10,"Clone",34],[8,"HammingResult",0],[10,"PartialEq",32],[17,"Item"],[10,"IntoIterator",35],[1,"f64"],[5,"String",36],[5,"TypeId",37]],"b":[[9,"impl-Display-for-StrSimError"],[10,"impl-Debug-for-StrSimError"]]}],\
["thread_local",{"doc":"Per-object thread-local storage","t":"FFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["CachedIntoIter","CachedIterMut","CachedThreadLocal","IntoIter","Iter","IterMut","ThreadLocal","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clear","clear","default","default","drop","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get","get","get_or","get_or","get_or_default","get_or_default","get_or_try","get_or_try","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","iter","iter_mut","iter_mut","new","new","next","next","next","next","next","size_hint","size_hint","size_hint","size_hint","size_hint","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","with_capacity"],"q":[[0,"thread_local"],[100,"core::marker"],[101,"core::fmt"],[102,"core::fmt"],[103,"core::ops::function"],[104,"core::default"],[105,"core::result"],[106,"core::any"]],"d":["An iterator that moves out of a <code>CachedThreadLocal</code>.","Mutable iterator over the contents of a <code>CachedThreadLocal</code>.","Wrapper around <code>ThreadLocal</code>.","An iterator that moves out of a <code>ThreadLocal</code>.","Iterator over the contents of a <code>ThreadLocal</code>.","Mutable iterator over the contents of a <code>ThreadLocal</code>.","Thread-local variable wrapper","","","","","","","","","","","","","","","Removes all thread-specific values from the <code>ThreadLocal</code>, …","Removes all thread-specific values from the <code>ThreadLocal</code>, …","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the element for the current thread, if it exists.","Returns the element for the current thread, if it exists.","Returns the element for the current thread, or creates it …","Returns the element for the current thread, or creates it …","Returns the element for the current thread, or creates a …","Returns the element for the current thread, or creates a …","Returns the element for the current thread, or creates it …","Returns the element for the current thread, or creates it …","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","","","","","","","","Returns an iterator over the local values of all threads …","Returns a mutable iterator over the local values of all …","Returns a mutable iterator over the local values of all …","Creates a new empty <code>CachedThreadLocal</code>.","Creates a new empty <code>ThreadLocal</code>.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Creates a new <code>ThreadLocal</code> with an initial capacity. If …"],"i":[0,0,0,0,0,0,0,1,18,17,4,8,9,11,1,18,17,4,8,9,11,1,4,1,4,4,1,4,8,9,11,1,18,17,4,8,9,11,1,4,1,4,1,4,1,4,1,18,17,4,8,9,11,1,1,18,17,4,4,4,8,9,11,4,1,4,1,4,18,17,8,9,11,18,17,8,9,11,1,18,17,4,8,9,11,1,18,17,4,8,9,11,1,18,17,4,8,9,11,4],"f":"```````{ce{}{}}0000000000000{{{b{c}}}df}{{{h{c}}}df}{{}{{b{c}}}f}{{}{{h{c}}}f}2{{{b{c}}j}l{fn}}{{{h{c}}j}l{fn}}{{{A`{c}}j}l{fn}}{{{Ab{c}}j}l{nfAd}}{{{Af{c}}j}l{nf}}{cc{}}000000{{{b{c}}}{{Ah{c}}}f}{{{h{c}}}{{Ah{c}}}f}{{{b{c}}e}cf{{Al{}{{Aj{c}}}}}}{{{h{c}}e}cf{{Al{}{{Aj{c}}}}}}{{{b{c}}}c{fAn}}{{{h{c}}}c{fAn}}{{{b{c}}g}{{B`{ce}}}f{}{{Al{}{{Aj{{B`{ce}}}}}}}}{{{h{c}}g}{{B`{ce}}}f{}{{Al{}{{Aj{{B`{ce}}}}}
["tinyvec",{"doc":"<code>tinyvec</code> provides 100% safe vec-like data structures.","t":"KFFFFTPPPPPPRFFGGGFFNNNQQNNNNNNNNNNNNNNNMNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Array","ArrayVec","ArrayVecDrain","ArrayVecIterator","ArrayVecSplice","CAPACITY","Heap","Heap","Heap","Inline","Inline","Inline","Item","SliceVec","SliceVecDrain","TinyVec","TinyVecDrain","TinyVecIterator","TinyVecSplice","TryFromSliceError","append","append","append","array_vec","array_vec","as_mut","as_mut","as_mut","as_mut_ptr","as_mut_ptr","as_mut_ptr","as_mut_slice","as_mut_slice","as_mut_slice","as_ptr","as_ptr","as_ptr","as_ref","as_ref","as_ref","as_slice","as_slice","as_slice","as_slice","as_slice","as_slice","as_slice_mut","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","capacity","capacity","clear","clear","clear","clone","clone","clone","clone_from","clone_from","clone_into","clone_into","clone_into","cmp","cmp","cmp","count","count","count","default","default","default","default","deref","deref","deref","deref_mut","deref_mut","deref_mut","drain","drain","drain","drain_to_vec","drain_to_vec_and_reserve","drop","drop","drop","eq","eq","eq","eq","eq","eq","eq","eq","extend","extend","extend","extend_from_slice","extend_from_slice","extend_from_slice","fill","fill","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","for_each","for_each","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_array_empty","from_array_len","from_array_len","from_iter","from_iter","from_slice_len","hash","hash","hash","index","index","index","index_mut","index_mut","index_mut","insert","insert","insert","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","is_empty","is_empty","is_empty","is_heap","is_inline","last","last","last","last","len","len","len","len","len","move_to_the_heap","move_to_the_heap_and_reserve","new","new","next","next","next","next","next","next","next","next_back","next_back","next_back","next_back","next_back","next_back","nth","nth","nth","nth","partial_cmp","partial_cmp","partial_cmp","pop","pop","pop","push","push","push","remove","remove","remove","reserve","reserve_exact","resize","resize","resize","resize_with","resize_with","resize_with","retain","retain","retain","set_len","set_len","shrink_to_fit","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","splice","splice","split_off","split_off","split_off","swap_remove","swap_remove","swap_remove","tiny_vec","tiny_vec","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","truncate","truncate","truncate","try_append","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_array_len","try_from_array_len","try_from_slice_len","try_insert","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_push","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","with_capacity"],"q":[[0,"tinyvec"],[352,"core::default"],[353,"core::clone"],[354,"core::cmp"],[355,"core::cmp"],[356,"alloc::vec"],[
["toml_datetime",{"doc":"A TOML-compatible datetime type","t":"PFFFGFPNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNONNNNNOOOONNNNONONNNNNNNNNNNNNNNNNNNNNNNNNOO","n":["Custom","Date","Datetime","DatetimeParseError","Offset","Time","Z","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","date","day","deserialize","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from_str","hour","into","into","into","into","into","minute","month","nanosecond","offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","second","serialize","time","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","year","minutes"],"q":[[0,"toml_datetime"],[99,"toml_datetime::Offset"],[100,"core::cmp"],[101,"core::result"],[102,"serde::de"],[103,"core::fmt"],[104,"core::fmt"],[105,"serde::ser"],[106,"alloc::string"],[107,"core::any"]],"d":["Offset between local time and UTC","A parsed TOML date value","A parsed TOML datetime value","Error returned from parsing a <code>Datetime</code> in the <code>FromStr</code> …","A parsed TOML time offset","A parsed TOML time value","A suffix which, when applied to a time, denotes a UTC …","","","","","","","","","","","","","","","","","","","","","","","","","Optional date. Required for: <em>Offset Date-Time</em>, <em>Local </em>…","Day: 1 to {28, 29, 30, 31} (based on month/year)","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Hour: 0 to 23","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Minute: 0 to 59","Month: 1 to 12","Nanosecond: 0 to <code>999_999_999</code>","Optional offset. Required for: <em>Offset Date-Time</em>.","","","","","Second: 0 to {58, 59, 60} (based on leap second rules)","","Optional time. Required for: <em>Offset Date-Time</em>, <em>Local </em>…","","","","","","","","","","","","","","","","","","","","","","","","","","Year: four digits","Minutes: -<code>1_440..1_440</code>"],"i":[5,0,0,0,0,0,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,3,4,5,1,3,1,1,3,4,5,1,1,2,2,3,3,4,4,5,5,1,1,1,2,3,4,5,1,4,1,2,3,4,5,4,3,4,1,1,3,4,5,4,1,1,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,3,18],"f":"```````{ce{}{}}000000000{bb}{dd}{ff}{hh}{jj}{{ce}l{}{}}0000{{bb}n}{{ff}n}{{hh}n}{{jj}n}``{c{{A`{b}}}Ab}{{bb}Ad}{{ff}Ad}{{hh}Ad}{{jj}Ad}{{bAf}Ah}0{{dAf}Ah}0{{fAf}Ah}0{{hAf}Ah}0{{jAf}Ah}0{cc{}}{hb}{fb}2222{Aj{{A`{bd}}}}`{ce{}{}}0000````{{bb}{{Al{n}}}}{{ff}{{Al{n}}}}{{hh}{{Al{n}}}}{{jj}{{Al{n}}}}`{{bc}A`An}`55555{cB`{}}0000{c{{A`{e}}}{}{}}000000000{cBb{}}0000``","c":[],"p":[[5,"Datetime",0],[5,"DatetimeParseError",0],[5,"Date",0],[5,"Time",0],[6,"Offset",0],[1,"unit"],[6,"Ordering",100],[6,"Result",101],[10,"Deserializer",102],[1,"bool"],[5,"Formatter",103],[8,"Result",103],[1,"str"],[6,"Option",104],[10,"Serializer",105],[5,"String",106],[5,"TypeId",107],[15,"Custom",99]],"b":[[38,"impl-Debug-for-Datetime"],[39,"impl-Display-for-Datetime"],[40,"impl-Debug-for-DatetimeParseError"],[41,"impl-Display-for-DatetimeParseError"],[42,"impl-Debug-for-Date"],[43,"impl-Display-for-Date"],[44,"impl-Display-for-Time"],[45,"impl-Debug-for-Time"],[46,"impl-Debug-for-Offset"],[47,"impl-Display-for-Offset"],[49,"impl-From%3CTime%3E-for-Datetime"],[50,"impl-From%3CDate%3E-for-Datetime"]]}],\
["tracing_attributes",{"doc":"A procedural macro attribute for instrumenting functions …","t":"X","n":["instrument"],"q":[[0,"tracing_attributes"]],"d":["Instruments a function to create and enter a <code>tracing</code> span …"],"i":[0],"f":"`","c":[],"p":[],"b":[]}],\
["tracing_core",{"doc":"Core primitives for <code>tracing</code>.","t":"KFFFEEFFFFKNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNCNNMMNNNNNNCMNMCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNCMQNMNNNNNMMNMCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFFNNNNNNNNNNNNNNNMNNHHNMNNNNNNNNFFFFNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNHHNNNNNNNNNNNNNHFNNNNNNNNNNFFFFFFKFKNNNNNNNNNNNNNNNNNNNHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNTTTTTTTTFFFFTFFTTTTTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFKNNNNNNNNNNNNNNNNNNMNMNMNNMNNNNNNNNNNNNNNNNNMNNMNMNNNNNNNNNNNNN","n":["Callsite","Dispatch","Event","Field","Interest","Kind","Level","LevelFilter","Metadata","Once","Subscriber","as_ref","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","call_once","call_once_force","callsite","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_span","cmp","cmp","current_span","default","dispatcher","downcast_raw","drop_span","enabled","enter","eq","eq","eq","eq","eq","eq","event","event","event_enabled","exit","field","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from_str","from_str","ge","ge","ge","ge","gt","gt","gt","gt","hash","hash","hash","identify_callsite","into","into","into","into","into","into","into","is_completed","le","le","le","le","lt","lt","lt","lt","max_level_hint","metadata","metadata","metadata","new","new_span","on_register_dispatch","partial_cmp","partial_cmp","partial_cmp","partial_cmp","record","record_follows_from","register_callsite","set_interest","span","subscriber","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_close","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","Callsite","DefaultCallsite","Identifier","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","eq","fmt","fmt","from","from","hash","interest","into","into","metadata","metadata","new","rebuild_interest_cache","register","register","set_interest","set_interest","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","DefaultGuard","Dispatch","SetGlobalDefaultError","WeakDispatch","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","clone_span","current_span","downcast_ref","downgrade","drop","drop_span","enabled","enter","event","exit","fmt","fmt","fmt","fmt","from","from","from","get_default","into","into","into","is","new","new_span","none","record","record_follows_from","register_callsite","set_default","set_global_default","to_owned","to_string","try_close","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","upgrade","with_default","Event","child_of","dispatch","fields","is_contextual","is_root","metadata","new","new_child_of","parent","record","DebugValue","DisplayValue","Empty","Field","FieldSet","Iter","Value","ValueSet","Visit","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","callsite","callsite","clone","clone","clone_into","clone_into","contains","debug","display","eq","eq","field","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","into","into","into","into","into","into","into_iter","into_iter","is_empty","is_empty","iter","len","len","name","new","next","record","record","record","record","record","record_bool","record_debug","record_error","record_f64","record_i128","record_i64","record_str","record_u128","record_u64","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_i
["tracing_log",{"doc":"Adapters for connecting unstructured log records from the …","t":"KKRFKRMMNNNNNNHNNMENCMNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AsLog","AsTrace","Log","LogTracer","NormalizeEvent","Trace","as_log","as_trace","borrow","borrow_mut","default","enabled","flush","fmt","format_trace","from","into","is_log","log","log","log_tracer","normalized_metadata","try_from","try_into","type_id","Builder","LogTracer","SetLoggerError","borrow","borrow","borrow_mut","borrow_mut","builder","default","fmt","fmt","fmt","from","from","ignore_all","ignore_crate","init","init","init_with_filter","into","into","new","new","to_string","try_from","try_from","try_into","try_into","type_id","type_id","with_max_level"],"q":[[0,"tracing_log"],[25,"tracing_log::log_tracer"],[56,"log"],[57,"core::fmt"],[58,"core::fmt"],[59,"tracing_core::metadata"],[60,"core::option"],[61,"core::result"],[62,"core::any"],[63,"core::fmt"],[64,"core::convert"],[65,"core::iter::traits::collect"],[66,"log"]],"d":["Trait implemented for <code>tracing</code> types that can be converted …","Trait implemented for <code>log</code> types that can be converted to a …","The <code>log</code> type that this type can be converted into.","A simple “logger” that converts all log records into …","Extends log <code>Event</code>s to provide complete <code>Metadata</code>.","The <code>tracing</code> type that this type can be converted into.","Returns the <code>log</code> equivalent of <code>self</code>.","Returns the <code>tracing</code> equivalent of <code>self</code>.","","","","","","","Format a log record as a trace event in the current span.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Returns whether this <code>Event</code> represents a log (from the <code>log</code> …","","","An adapter for converting <code>log</code> records into <code>tracing</code> <code>Event</code>s.","If this <code>Event</code> comes from a <code>log</code>, this method provides a new …","","","","Configures a new <code>LogTracer</code>.","A simple “logger” that converts all log records into …","The type returned by <code>set_logger</code> if <code>set_logger</code> has already …","","","","","Returns a builder that allows customizing a <code>LogTracer</code> and …","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Configures the <code>LogTracer</code> to ignore all log records whose …","Configures the <code>LogTracer</code> to ignore all log records whose …","Sets a <code>LogTracer</code> as the global logger for the <code>log</code> crate.","Constructs a new <code>LogTracer</code> with the provided configuration …","Sets up <code>LogTracer</code> as global logger for the <code>log</code> crate, with …","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Creates a new <code>LogTracer</code> that can then be used as a logger …","Returns a new <code>Builder</code> to construct a <code>LogTracer</code>.","","","","","","","","Sets a global maximum level for <code>log</code> records."],"i":[0,0,2,0,0,4,2,4,5,5,5,5,5,5,0,5,5,13,0,5,0,13,5,5,5,0,0,0,18,19,18,19,5,18,18,19,19,18,19,18,18,5,18,5,18,19,5,18,19,18,19,18,19,18,19,18],"f":"``````{{{d{}{{b{c}}}}}c{}}{{{h{}{{f{c}}}}}c{}}{ce{}{}}0{{}j}{{jl}n}{jA`}{{jAb}Ad}{Af{{Ah{A`}}}}{cc{}}6{Ajn}`{{jAf}A`}`{Aj{{An{Al}}}}{c{{B`{e}}}{}{}}0{cBb{}}```;;;;{{}Bd}0{{BdAb}Ad}{{BfAb}{{B`{A`Bh}}}}088{{Bde}Bd{{Bl{Bj}}}{{C`{}{{Bn{c}}}}}}{{Bdc}Bd{{Bl{Bj}}}}{{}{{B`{A`Bf}}}}{Bd{{B`{A`Bf}}}}{Cb{{B`{A`Bf}}}}{ce{}{}}0{{}j}9{cBj{}}<<<<;;{{Bdc}Bd{{Bl{Cb}}}}","c":[],"p":[[17,"Log"],[10,"AsLog",0],[17,"Trace"],[10,"AsTrace",0],[5,"LogTracer",0],[5,"Metadata",56],[1,"bool"],[1,"unit"],[5,"Formatter",57],[8,"Result",57],[5,"Record",56],[8,"Result",58],[10,"NormalizeEvent",0],[5,"Metadata",59],[6,"Option",60],[6,"Result",61],[5,"TypeId",62],[5,"Builder",25],[5,"SetLoggerError",25],[5,"Error",57],[5,"String",63],[10,"Into",64],[17,"Item"],[10,"IntoIterator",65],[6,"LevelFilter",56]],"b":[[35,"impl-Display-for-SetLoggerError"],[36,"impl-Debug-for-SetLoggerError"
["tracing_subscriber",{"doc":"Utilities for implementing and composing <code>tracing</code> …","t":"EEEECCCECCCHCCKKKKKKKKRCNCNCNMMMNMNNNNNNNNNMMFNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNFFTTFFTFKFFFFTFFTFTETNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNHNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNTFKKFIFKFFFRNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNHNNNNNNNNNCHMMNNNNNNNHNNNNNNNHNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCHNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNTTFFFTTTFFFFKKFTTFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNHMNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFFNNNNNNNNNNNNNNMNNNNNNNHNNNNNNNNHPPFPPFGKKFIFFFFFFRNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFKFKFKNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNEEEEEEFRFFKFFFKFNNNNNNNNNNNNNNNNNNNNNNMNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFNNNNNNNNNNNNNN","n":["EnvFilter","FmtSubscriber","Layer","Registry","field","filter","fmt","fmt","layer","prelude","registry","registry","reload","util","MakeExt","MakeOutput","MakeVisitor","RecordFields","Visit","VisitFmt","VisitOutput","VisitWrite","Visitor","debug","debug_alt","delimited","delimited","display","display_messages","finish","make_visitor","record","record_bool","record_debug","record_error","record_f64","record_i128","record_i64","record_str","record_u128","record_u64","visit","visit_with","writer","writer","Alt","borrow","borrow_mut","clone","clone_into","finish","fmt","from","into","make_visitor","new","record_bool","record_debug","record_f64","record_i64","record_str","record_u64","to_owned","try_from","try_into","type_id","writer","writer","Delimited","VisitDelimited","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","finish","fmt","fmt","from","from","into","into","make_visitor","new","new","record_bool","record_debug","record_i64","record_str","record_u64","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","writer","Messages","borrow","borrow_mut","clone","clone_into","finish","fmt","from","into","make_visitor","new","record_bool","record_debug","record_f64","record_i64","record_str","record_u64","to_owned","try_from","try_into","type_id","writer","writer","BadFieldName","Builder","DEBUG","DEFAULT_ENV","Directive","DynFilterFn","ERROR","EnvFilter","FilterExt","FilterFn","FilterId","Filtered","FromEnvError","INFO","LevelFilter","LevelParseError","OFF","ParseError","TRACE","Targets","WARN","add_directive","and","and","as_log","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","boxed","boxed","builder","callsite_enabled","callsite_enabled","callsite_enabled","callsite_enabled","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","combinator","current","default","default","default","description","dynamic_filter_fn","enabled","enabled","enabled","enabled","enabled","enabled","enabled","enabled","enabled","enabled","eq","eq","eq","event_enabled","filter","filter_fn","filter_mut","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","f
["unicode_normalization",{"doc":"Unicode character composition and decomposition utilities …","t":"FGPPFFFSKPNNNNNNNNNNCMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHHHHHHHHNNNNMNNNNMNNNNMNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHHH","n":["Decompositions","IsNormalized","Maybe","No","Recompositions","Replacements","StreamSafe","UNICODE_VERSION","UnicodeNormalization","Yes","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","char","cjk_compat_variants","cjk_compat_variants","cjk_compat_variants","cjk_compat_variants","cjk_compat_variants","clone","clone","clone","clone_into","clone_into","clone_into","eq","fmt","fmt","fmt","fmt","from","from","from","from","from","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","is_nfc","is_nfc_quick","is_nfc_stream_safe","is_nfc_stream_safe_quick","is_nfd","is_nfd_quick","is_nfd_stream_safe","is_nfd_stream_safe_quick","is_nfkc","is_nfkc_quick","is_nfkd","is_nfkd_quick","next","next","next","next","nfc","nfc","nfc","nfc","nfc","nfd","nfd","nfd","nfd","nfd","nfkc","nfkc","nfkc","nfkc","nfkc","nfkd","nfkd","nfkd","nfkd","nfkd","size_hint","size_hint","stream_safe","stream_safe","stream_safe","stream_safe","stream_safe","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","canonical_combining_class","compose","decompose_canonical","decompose_cjk_compat_variants","decompose_compatible","is_combining_mark","is_public_assigned"],"q":[[0,"unicode_normalization"],[115,"unicode_normalization::char"],[122,"core::iter::traits::iterator"],[123,"core::clone"],[124,"core::fmt"],[125,"core::fmt"],[126,"alloc::string"],[127,"core::result"],[128,"core::any"],[129,"core::ops::function"]],"d":["External iterator for a string decomposition’s …","The QuickCheck algorithm can quickly determine if a text …","The text may be normalized.","The text is definitely not normalized.","External iterator for a string recomposition’s …","External iterator for replacements for a string’s …","UAX15-D4: This iterator keeps track of how many …","","Methods for iterating over strings while applying Unicode …","The text is definitely normalized.","","","","","","","","","","","Methods for composing and decomposing characters.","A transformation which replaces CJK Compatibility …","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","","","","","Authoritatively check if a string is in NFC.","Quickly check if a string is in NFC, potentially returning …","Authoritatively check if a string is Stream-Safe NFC.","Quickly check if a string is Stream-Safe NFC.","Authoritatively check if a string is in NFD.","Quickly check if a string is in NFD.","Authoritatively check if a string is Stream-Safe NFD.","Quickly check if a string is Stream-Safe NFD.","Authoritatively check if a string is in NFKC.","Quickly check if a string is in NFKC.","Authoritatively check if a string is in NFKD.","Quickly check if a string is in NFKD.","","","","","An Iterator over the string in Unicode Normalization Form C","","","","","Returns an iterator over the string in Unicode …","","","","","An Iterator over the string in Unicode Normalization Form …","","","","","Returns an iterator over the string in Unicode …","","","","","","","An Iterator over the string with Conjoining Grapheme …","","","","","","","","","","","","","","","","","","","","","","","","","","Look up the canonical combining class for a codepoint.","Compose two characters into a single character, if …","Compute canonical Unicode decomposition for character. See …","C
["unicode_width",{"doc":"Determine displayed width of <code>char</code> and <code>str</code> types according …","t":"SKKMMMM","n":["UNICODE_VERSION","UnicodeWidthChar","UnicodeWidthStr","width","width","width_cjk","width_cjk"],"q":[[0,"unicode_width"],[7,"core::option"]],"d":["The version of Unicode that this version of unicode-width …","Methods for determining displayed width of Unicode …","Methods for determining displayed width of Unicode strings.","Returns the character’s displayed width in columns, or …","Returns the string’s displayed width in columns.","Returns the character’s displayed width in columns, or …","Returns the string’s displayed width in columns."],"i":[0,0,0,1,4,1,4],"f":"```{b{{f{d}}}}{hd}10","c":[],"p":[[10,"UnicodeWidthChar",0],[1,"usize"],[6,"Option",7],[10,"UnicodeWidthStr",0]],"b":[]}],\
["url",{"doc":"rust-url is an implementation of the URL Standard for the …","t":"PPPPPPPPPPPPPPPPPPPPPIPPPGPPPPPPPPPPPFGPGFFPGPPPPGPPPFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["AfterFragment","AfterHost","AfterPassword","AfterPath","AfterPort","AfterQuery","AfterScheme","AfterUsername","Backslash","BeforeFragment","BeforeHost","BeforePassword","BeforePath","BeforePort","BeforeQuery","BeforeScheme","BeforeUsername","C0SpaceIgnored","Domain","EmbeddedCredentials","EmptyHost","EncodingOverride","ExpectedDoubleSlash","ExpectedFileDoubleSlash","FileWithHostAndWindowsDrive","Host","IdnaError","InvalidDomainCharacter","InvalidIpv4Address","InvalidIpv6Address","InvalidPort","Ipv4","Ipv6","NonUrlCodePoint","None","NullInFragment","Opaque","OpaqueOrigin","Origin","Overflow","ParseError","ParseOptions","PathSegmentsMut","PercentDecode","Position","RelativeUrlWithCannotBeABaseBase","RelativeUrlWithoutBase","SetHostOnCannotBeABaseUrl","Some","SyntaxViolation","TabOrNewlineIgnored","Tuple","UnencodedAtSign","Url","UrlQuery","as_mut_string","as_ref","as_str","ascii_serialization","authority","base_url","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","cannot_be_a_base","clear","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","description","domain","drop","drop","encoding_override","eq","eq","eq","eq","eq","eq","extend","finish","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","form_urlencoded","fragment","from","from","from","from","from","from","from","from","from","from","from","from_directory_path","from_file_path","from_str","has_authority","has_host","hash","hash","hash","hash","host","host_str","index","index","index","index","into","into","into","into","into","into","into","into","into","into","into_string","is_special","is_tuple","join","make_relative","new_opaque","options","origin","parse","parse","parse","parse_opaque","parse_with_params","partial_cmp","partial_cmp","password","path","path_segments","path_segments_mut","pop","pop_if_empty","port","port_or_known_default","push","query","query_pairs","query_pairs_mut","scheme","set_fragment","set_host","set_ip_host","set_password","set_path","set_port","set_query","set_scheme","set_username","socket_addrs","syntax_violation_callback","to_file_path","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unicode_serialization","username"],"q":[[0,"url"],[251,"alloc::string"],[252,"core::option"],[253,"core::clone"],[254,"core::cmp"],[255,"core::cmp"],[256,"core::fmt"],[257,"core::fmt"],[258,"idna::uts46"],[259,"core::result"],[260,"std::path"],[261,"core::hash"],[262,"core::hash"],[263,"core::ops::range"],[264,"form_urlencoded"],[265,"form_urlencoded"],[266,"core::net::socket_addr"],[267,"alloc::vec"],[268,"std::io::error"],[269,"core::ops::function"],[270,"std::path"]],"d":["","","","","","","","","","","","","","","","","","","A DNS domain name, as ‘.’ dot-separated labels. …","","","","","","","The host name of an URL.","","","","","","An IPv4 address. <code>Url::host_str</code> returns the serialization …","An IPv6 address. <code>Url::host_str</code> returns the serialization …","","No value.","","A globally unique identifier","OpaqueidentifierforURLsthatha
["utf8parse",{"doc":"A table-driven UTF-8 Parser","t":"FKNNNNMNNNNNMNNNN","n":["Parser","Receiver","advance","borrow","borrow_mut","clone","codepoint","default","eq","fmt","from","into","invalid_sequence","new","try_from","try_into","type_id"],"q":[[0,"utf8parse"],[17,"core::fmt"],[18,"core::fmt"],[19,"core::any"]],"d":["A parser for Utf8 Characters","Handles codepoint and invalid sequence events from the …","Advance the parser","","","","Called whenever a codepoint is parsed successfully","","","","Returns the argument unchanged.","Calls <code>U::from(self)</code>.","Called when an invalid_sequence is detected","Create a new Parser","","",""],"i":[0,0,1,1,1,1,4,1,1,1,1,1,4,1,1,1,1],"f":"``{{bcd}fh}{ce{}{}}0{bb}{{hj}f}{{}b}{{bb}l}{{bn}A`}{cc{}}6{hf}4{c{{Ab{e}}}{}{}}0{cAd{}}","c":[],"p":[[5,"Parser",0],[1,"u8"],[1,"unit"],[10,"Receiver",0],[1,"char"],[1,"bool"],[5,"Formatter",17],[8,"Result",17],[6,"Result",18],[5,"TypeId",19]],"b":[]}],\
["walkdir",{"doc":"Crate <code>walkdir</code> provides an efficient and cross platform …","t":"FKPFFFPIFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["DirEntry","DirEntryExt","Err","Error","FilterEntry","IntoIter","Ok","Result","WalkDir","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","cause","clone","clone_into","contents_first","depth","depth","description","file_name","file_type","filter_entry","filter_entry","fmt","fmt","fmt","fmt","fmt","fmt","follow_links","follow_root_links","from","from","from","from","from","ino","ino","into","into","into","into","into","into_io_error","into_iter","into_iter","into_iter","into_path","io_error","loop_ancestor","max_depth","max_open","metadata","min_depth","new","next","next","path","path","path_is_symlink","same_file_system","skip_current_dir","skip_current_dir","sort_by","sort_by_file_name","sort_by_key","source","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id"],"q":[[0,"walkdir"],[91,"core::error"],[92,"core::option"],[93,"std::ffi::os_str"],[94,"std::fs"],[95,"core::ops::function"],[96,"core::fmt"],[97,"core::fmt"],[98,"std::path"],[99,"std::path"],[100,"core::cmp"],[101,"core::marker"],[102,"core::marker"],[103,"core::result"],[104,"core::any"]],"d":["A directory entry.","Unix-specific extension methods for <code>walkdir::DirEntry</code>","Contains the error value","An error produced by recursively walking a directory.","A recursive directory iterator that skips entries.","An iterator for recursively descending into a directory.","Contains the success value","A result type for walkdir operations.","A builder to create an iterator for recursively walking a …","","","","","","","","","","","","","","Yield a directory’s contents before the directory …","Returns the depth at which this entry was created relative …","Returns the depth at which this error occurred relative to …","","Return the file name of this entry.","Return the file type for the file that this entry points …","Yields only entries which satisfy the given predicate and …","Yields only entries which satisfy the given predicate and …","","","","","","","Follow symbolic links. By default, this is disabled.","Follow symbolic links if these are the root of the …","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the underlying <code>d_ino</code> field in the contained <code>dirent</code> …","Returns the underlying <code>d_ino</code> field in the contained <code>dirent</code> …","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Calls <code>U::from(self)</code>.","Similar to <code>io_error</code> except consumes self to convert to the …","","","","The full path that this entry represents.","Inspect the original <code>io::Error</code> if there is one.","Returns the path at which a cycle was detected.","Set the maximum depth of entries yield by the iterator.","Set the maximum number of simultaneously open file …","Return the metadata for the file that this entry points to.","Set the minimum depth of entries yielded by the iterator.","Create a builder for a recursive directory iterator …","Advances the iterator and returns the next value.","Advances the iterator and returns the next value.","The full path that this entry represents.","Returns the path associated with this error if one exists.","Returns <code>true</code> if and only if this entry was created from a …","Do not cross file system boundaries.","Skips the current directory.","Skips the current directory.","Set a function for sorting directory entries with a …","Sort directory entries by file name, to ensure a …","Set a function for sorting directory entries with a key …"
["winnow",{"doc":"winnow, making parsing a breeze","t":"EEEEEKEEENNCCNNCNNNNNNNNCNNNNNNNNMNNNNCNNNNCCNNHNNNNNNNNNNNNFKKKHHHHNNNNNHHHHHHHHNNHHHNHHHHHHNNNNHHHHHNNNNPGPPHHHHHHHHHHHHHHCNNNNNHHNNHHHHHHNHHHHHHHHHHHHHHHHHNNNNHHHHHHHHHHHKFFFFFFFFFFFKFFFFFFFFFFHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMHHHQHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNHHNNNNNNNNNNNNNNNNNNNNHHMHHHHHHHHHQHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKPPPPPPPPFPPPPPGKGPPKIPFPPPGPPPIFKPPPGGPPPGFFGPPNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNOMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNMNNNNNNNNOOONNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOEEEEKKKKFFFFRKGKPKPRFKKPKFRFRKFIKKKRKMMNNNNMNNNNMNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNMNNNNNMNNNNNMNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMONNNNNNNNNMMMMMMNNNNMNNNNNMMNNNNNMMNNNNNNNNMNNNNNMNNNNNMNNNNNMNNNNNMNNNNNNNNNNNMNNNNNNNNNNNNNNNMNNNNNMNNNNNMNNNNNMNNNNNNONNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNMNNNNNHHHHHHHH","n":["BStr","Bytes","IResult","Located","PResult","Parser","Partial","Stateful","Str","and_then","and_then","ascii","binary","by_ref","by_ref","combinator","complete_err","complete_err","context","context","default_value","default_value","err_into","err_into","error","flat_map","flat_map","map","map","output_into","output_into","parse","parse","parse_next","parse_peek","parse_peek","parse_to","parse_to","prelude","recognize","recognize","span","span","stream","token","try_map","try_map","unpeek","value","value","verify","verify","verify_map","verify_map","void","void","with_recognized","with_recognized","with_span","with_span","Caseless","HexUint","Int","Uint","alpha0","alpha1","alphanumeric0","alphanumeric1","as_bytes","borrow","borrow_mut","clone","clone_into","crlf","dec_int","dec_uint","digit0","digit1","escaped","escaped_transform","float","fmt","from","hex_digit0","hex_digit1","hex_uint","into","line_ending","multispace0","multispace1","newline","oct_digit0","oct_digit1","parse_next","parse_next","parse_next","slice_len","space0","space1","tab","take_escaped","till_line_ending","to_owned","try_from","try_into","type_id","Big","Endianness","Little","Native","be_f32","be_f64","be_i128","be_i16","be_i24","be_i32","be_i64","be_i8","be_u128","be_u16","be_u24","be_u32","be_u64","be_u8","bits","borrow","borrow_mut","clone","clone_into","eq","f32","f64","fmt","from","i128","i16","i24","i32","i64","i8","into","le_f32","le_f64","le_i128","le_i16","le_i24","le_i32","le_i64","le_i8","le_u128","le_u16","le_u24","le_u32","le_u64","le_u8","length_and_then","length_repeat","length_take","to_owned","try_from","try_into","type_id","u128","u16","u24","u32","u64","u8","bits","bool","bytes","pattern","take","Alt","AndThen","ByRef","CompleteErr","Context","DefaultValue","ErrInto","FlatMap","Map","OutputInto","ParseTo","ParserIterator","Permutation","Recognize","Repeat","Span","TryMap","Value","Verify","VerifyMap","Void","WithRecognized","WithSpan","alt","backtrack_err","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","choice","cond","cut_err","delimited","dispatch","empty","eof","fail","fill","finish","fold","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","iterator","next","not","opt","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","parse_next","pars
["yansi",{"doc":"A dead simple ANSI terminal color painting library.","t":"TGPPPPPPPPPPPPPPGPFPTPPPPPPPPTPKFPGPPPPPFPPPPNMNNNNNNNNNNOMNNNNNNNNNMNNNNNNNNMNNNNNNNNNMNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNMNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNOMNNNNNNNNNNNNMNNNNNNNNNHHNNNNNNMNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNMNNNNNNNNNHMNNNNNNNNNMNNNNNNNNNMNNNNNNNNMNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNNNNNNNNNNNMNNNNNNNNMNNNNNNNNNMNNNNNNNNNMNNNNNNNNMNNNNNNNNNMNNNNNNNNMNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNOHMNNNNNNNNNMNNNNNNNNMNNNNNNNNNMNNNNNNNN","n":["ALWAYS","Attribute","Black","Blink","Blue","Bold","Bright","BrightBlack","BrightBlue","BrightCyan","BrightGreen","BrightMagenta","BrightRed","BrightWhite","BrightYellow","Clear","Color","Conceal","Condition","Cyan","DEFAULT","Dim","Fixed","Green","Invert","Italic","Linger","Magenta","Mask","NEVER","OnBright","Paint","Painted","Primary","Quirk","RapidBlink","Red","Resetting","Rgb","Strike","Style","Underline","White","Wrap","Yellow","always","attr","attr","attr","attr","attr","attr","attr","attr","attr","attr","background","background","bg","bg","bg","bg","bg","bg","bg","bg","bg","bg","black","black","black","black","black","black","black","black","black","blink","blink","blink","blink","blink","blink","blink","blink","blink","blink","blue","blue","blue","blue","blue","blue","blue","blue","blue","bold","bold","bold","bold","bold","bold","bold","bold","bold","bold","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bright","bright","bright","bright","bright","bright","bright","bright","bright","bright","bright_black","bright_black","bright_black","bright_black","bright_black","bright_black","bright_black","bright_black","bright_black","bright_blue","bright_blue","bright_blue","bright_blue","bright_blue","bright_blue","bright_blue","bright_blue","bright_blue","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_cyan","bright_green","bright_green","bright_green","bright_green","bright_green","bright_green","bright_green","bright_green","bright_green","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_magenta","bright_red","bright_red","bright_red","bright_red","bright_red","bright_red","bright_red","bright_red","bright_red","bright_white","bright_white","bright_white","bright_white","bright_white","bright_white","bright_white","bright_white","bright_white","bright_yellow","bright_yellow","bright_yellow","bright_yellow","bright_yellow","bright_yellow","bright_yellow","bright_yellow","bright_yellow","cached","clear","clear","clear","clear","clear","clear","clear","clear","clear","clear","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","conceal","conceal","conceal","conceal","conceal","conceal","conceal","conceal","conceal","conceal","condition","cyan","cyan","cyan","cyan","cyan","cyan","cyan","cyan","cyan","default","default","default","deref","dim","dim","dim","dim","dim","dim","dim","dim","dim","dim","disable","enable","enabled","eq","eq","eq","eq","eq","fg","fg","fg","fg","fg","fg","fg","fg","fg","fixed","fixed","fixed","fixed","fixed","fixed","fixed","fixed","fixed","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt_prefix","fmt_suffix","foreground","foreground","from","from","from","from","from","from","from","from","from","from","from","green","green","green","green","green","green","green","green","green","hash","hash","hash","hash","hash","into","into","into","into","into","into","invert","invert","invert","invert","invert",
