Files
boc/aamos-ledger-rust/target/debug/deps/libregex_syntax-5c07677829e16c4f.rmeta
T

3435 lines
1008 KiB
Plaintext
Raw Normal View History

rust
À#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁòÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥Ìýݰ¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®ËÅš-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLhž§Œaã¯>­-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0ÁtestsÁ,ðÆ$審Å,ºm$¯m
Å,´Í$©ÍÅ,‰J$þI¼Å,â´$×´ÊÅ,§a$œaìÅ,Õ‡$ʇãÅ,ñ¤$椊 Å,ôˆ$éˆÒ ageÁ( » unicode-ageÁ¼ Ò case_folding_simpleÁœW » unicode-caseÁÄ4 Ò general_categoryÁ„˜ »unicode-gencatÁÔs Ò grapheme_cluster_breakÁ´× »unicode-segmentÁܱ Ò perl_decimalÁdÓ » unicode-perlÁÄú Ò
perl_spaceÁTà »è
Äì Ò perl_wordÁLù »è
ÄÖ Ò
property_boolÁl® » unicode-boolÁÄ‹ Ò property_namesÁt »— ¼Í »Ù Äê »ü Ôˆ »è
Ĩ »unicode-scriptÁÔÆ »
Üæ üǽ Ò property_valuesÁ|ñ »— ¼¯ »Ù ÄÌ »ü Ôê »è
ÄŠ »¼ Ô¨ »
ÜÈ ü©½ Ò scriptÁ4® »¼ Ô‰ Ò script_extensionÁ„â »¼ Ô½ Ò sentence_breakÁt¡ »
Üû Ò
word_breakÁTÞ »
ܸ Ó Å,„t
$ùs
Å,íy $ây íÀ¤astÁ









parseÁ 
  
Í.¥0spanÁ0into_astÁ0into_class_set_itemÁ3¡330into_class_literalÁ7¡7is_hexÁis_capture_charÁ<>>æ >buildÁ>
nest_limitÁ>octalÁ>ignore_whitespaceÁ>empty_min_rangeÁEæ EíEparse_with_commentsÁEresetÁJ'sÁJ¡Jæ JparserÁJpatternÁJerrorÁJž
JšJJnext_capture_indexÁT Jadd_capture_nameÁV J«JÿJchar_atÁZ JbumpÁJbump_ifÁJis_lookaround_prefixÁJbump_and_bump_spaceÁJ
bump_spaceÁJpeekÁJ
peek_spaceÁJis_eofÁJposÁJãJ span_charÁJpush_alternateÁJpush_or_add_alternationÁhJ
push_groupÁj J pop_groupÁlJ
pop_group_endÁJpush_class_openÁJ pop_classÁJunclosed_class_errorÁJ
push_class_opÁJ pop_class_opÁtt¡tíw tëtparse_uncounted_repetitionÁtparse_counted_repetitionÁt parse_groupÁtparse_capture_nameÁt parse_flagsÁt
parse_flagÁtparse_primitiveÁt parse_escapeÁ t!maybe_parse_special_word_boundaryÁƒ t parse_octalÁt parse_hexÁtparse_hex_digitsÁtparse_hex_braceÁt
parse_decimalÁtparse_set_classÁtparse_set_class_rangeÁtparse_set_class_itemÁtparse_set_class_openÁtmaybe_parse_ascii_classÁtparse_unicode_classÁtparse_perl_classÁ'pÁ¡æ checkÁincrement_depthÁ decrement_depthÁšñšš¡š°ššfinishÁš visit_preÁš
visit_postÁšvisit_class_set_item_preÁšvisit_class_set_item_postÁšvisit_class_set_binary_op_preÁšvisit_class_set_binary_op_postÁspecialize_errÁ§¥
printÁ©©©©©©©©±>©³æ ³©æ ׸¨©º¨º°ººþºŒººvisit_alternation_inÁº¯ºÏúvisit_class_set_binary_op_inÁ©Æ¨Æ
fmt_group_preÁÈÆfmt_group_postÁÆfmt_repetitionÁËÆfmt_repetition_rangeÁÍÆ fmt_literalÁÏÆ
fmt_assertionÁÑÆ
fmt_set_flagsÁÆ fmt_flagsÁÔÔÔÆfmt_class_bracketed_preÁÆfmt_class_bracketed_postÁÆfmt_class_set_binary_op_kindÁÚÆfmt_class_perlÁÜÆfmt_class_asciiÁÞÆfmt_class_unicodeÁàà
visitorÁãããããããVisitorÁê°êêþê¹êŒêêùêvisit_concat_inÁê¯êÏêðêêª ãvisitÁø§ã HeapVisitorÁú'aÁústackÁú stack_classÁãFrameÁþÉ%þ
RepetitionÁ
ˆþGroupÁƒ
ƒˆþConcatÁheadÁtailÁþ AlternationÁÏ&Û&ã
ClassFrameÁŒÉ%ŒôŽÏ&ŽÛ&ŒBinaryÁopÁŒ BinaryLHSÁÊ'rhsÁŒ BinaryRHSÁÊ'õ'ã ClassInductÁšÉ%šœ
œˆšBinaryOpÁŸ
Ÿˆã¢É%¢æ ¢¡%¥§¢inductÁ§§¢popÁ¢ visit_classÁª§¢visit_class_preÁ¬§¢visit_class_postÁ®§¢ induct_classÁ¢óã²É%²childÁãµÉ%µ·*ã¸É%¸from_bracketedÁ¸from_setÁã¼É%¼×ã¿É%¿×
¹ÂãÂauxiliary_spanÁÆ

É×
Ë×Ì
Î×
Ð
Òï

Ô×
Ö
 Øï


Úæ ÚsplatÁÚ
with_startÁÚwith_endÁÚ is_one_lineÁÚis_emptyÁ
 áæ 
 ãemptyÁãflagsÁã«ãdotÁã assertionÁã
class_unicodeÁã
class_perlÁãclass_bracketedÁã
repetitionÁãgroupÁã alternationÁã¨ããã¤-ã has_subexprsÁ

ó×ô
öî
øî
úbyteÁ
üdigitsÁ
þ from_nameÁÿ

is_negatedÁ
ƒis_equalÁ
Cã¤-
ã
is_validÁ
pushÁ into_itemÁ
Ø0
Ñ- is_capturingÁ
capture_indexÁ
add_itemÁ
flag_stateÁ
 is_negationÁ
㜜 œ 
 ã¡¡ ¡ ¥ByteÁ¦
¦ˆ¥©×ª ¥BytesÁ¬
¬É%¬ˆ¥°É%°×¥ utf8_decodeÁ³eitherÁÇ Á÷Ã÷Æ×È'eÁÈ÷˸4Ë÷θ4ÎÎ×SpansÁÒñÒ¹Òline_number_widthÁÒby_lineÁÒ
multi_lineÁØñØfrom_formatterÁÚ¸4ÚØØnotateÁØ notate_lineÁØleft_pad_line_numberÁØline_number_paddingÁ repeat_charÁhirÁãããããããããã ã
ã ã ã
ããããããããããintervalÁûûûûûûûûƒšûšûˆšˆæ Š¥ˆì0ˆùˆ intervalsÁˆcase_fold_simpleÁˆCˆ intersectÁˆ
differenceÁˆsymmetric_differenceÁˆnegateÁˆ canonicalizeÁˆ is_canonicalÁûÉ%šó ûIntervalÁœBoundÁœlowerÁœupperÁœ set_lowerÁœ set_upperÁœ‰9œcreateÁœCœ¨9œ¹9œ
is_contiguousÁœis_intersection_emptyÁœ is_subsetÁûÒ:ª min_valueÁª max_valueÁªas_u32Áª incrementÁª decrementÁû°“<°¤<°µ<°Ã<°Ô<û“<¤<µ<Ã<Ô<㫼¼¼¼¼¼¼¼¼¼ ¼Çæ ÇextractÁÉÇÇ limit_classÁÇ limit_repeatÁÇlimit_literal_lenÁÇ limit_totalÁÇextract_concatÁÐÉ%КÇextract_alternationÁÓÉ%ÓšÇextract_repetitionÁÇextract_class_unicodeÁÇextract_class_bytesÁÇclass_over_limit_unicodeÁÇclass_over_limit_bytesÁÇcrossÁÛ ÇCÝ Ý Çenforce_literal_lenÁ¼á>¼ã is_prefixÁã is_suffixÁ¼æ>¼èÄ-èinfiniteÁè singletonÁèæ ìšìì èliteralsÁèì0ñ è make_inexactÁè
make_infiniteÁè
cross_forwardÁè
cross_reverseÁècross_preambleÁ÷É%èCèunion_into_emptyÁú ú ú èdedupÁþ èsortÁèreverse_literalsÁèminimize_by_preferenceÁèkeep_first_bytesÁèkeep_last_bytesÁè is_finiteÁè¤-è èis_exactÁ Š è
is_inexactÁŒ  è
max_union_lenÁè
max_cross_lenÁèmin_literal_lenÁ èmax_literal_lenÁ èlongest_common_prefixÁ èlongest_common_suffixÁ è!optimize_for_prefix_by_preferenceÁè!optimize_for_suffix_by_preferenceÁèoptimize_by_preferenceÁ  ATTEMPTSÁž    ¼£×¼¥ù¦¥¼¨exactÁ©¨inexactÁ«¨as_bytesÁ¨
into_bytesÁ¨¨¤-¨ƒE¨»B¨reverseÁ¨extendÁ¨®D¨ÆD¨ is_poisonousÁ¼¸÷¼ º÷»» ¼
¾É¼ À×¼ ÂminimizeÁà ÂinsertÁÅ ÂrootÁ create_stateÁ¼rankÁã×ÊÊÊÊÊÊÊÊÊÊ ÊÕ>Ê׿ ×ÊÚæ Ú×ܨÊÞ¨Þ°ÞÞþÞŒã ÞÞùÊç¨çwrite_literal_charÁçwrite_literal_byteÁçwrite_literal_class_byteÁã translateÁìììììììììì ì
ì ì ì
ìììììììììììÍ¥ì>ìæ utf8Áline_terminatorÁcase_insensitiveÁÁ5dot_matches_new_lineÁcrlfÁ
swap_greedÁunicodeÁìæ „Mì unwrap_exprÁunwrap_class_unicodeÁunwrap_class_bytesÁunwrap_repetitionÁ unwrap_groupÁunwrap_alternation_pipeÁìž'tÁžñž°žžþžŒ¤ ¤ žžùž¯žÏžðžª ž­­ ­ ì±þP±ñ±æ ±transÁ±ì0± push_charÁ· ± push_byteÁ±©)±pop_concat_exprÁ± pop_alt_exprÁ±Ç±Ñ-± set_flagsÁ±ast_literal_to_scalarÁ±case_fold_charÁÁ Á Á ±hir_dotÁ±
hir_assertionÁ± hir_captureÁ±hir_repetitionÁ±hir_unicode_classÁɱhir_ascii_unicode_classÁË ±hir_ascii_byte_classÁÍ ±hir_perl_unicode_classÁϱhir_perl_byte_classÁѱconvert_unicode_class_errorÁÓ ±unicode_fold_and_negateÁÕ ±bytes_fold_and_negateÁ±class_literal_byteÁìÙfrom_astÁÙmergeÁÙáNÙÁ5ÙOÙ©OÙ»OÙOìhir_ascii_class_bytesÁâ ì ascii_classÁääìascii_class_as_charsÁçç ãï#êêêêêêêêœ$ò°òòþò¹òŒòòùòâ$ê¡%û§ê¶%ýÉ%ýÓ%êó%É%ˆ&
ˆ`
ˆÁ&ˆÏ&ˆÛ&ç&Ï&Û&êŽÉ%Žæ Ž¡%§Ž“)Ž©)êÉ%·*㘘¹˜ããã×ãŸ× ã¢¢ into_kindÁ¢
propertiesÁ¢
into_partsÁã§Ä-§failÁ§«ª§classÁ§lookÁ§À.® §captureÁ§¨§ß.² ² §æ-ãsubsÁ·ã¹×ã»×ã ½×ã
¿‰9¿try_case_fold_simpleÁ¿ç9¿is_utf8Á¿ minimum_lenÁ¿ maximum_lenÁ¿¤-¿«ã È×Éã Ëæ ÌšËÄ-Ëì0ËùËrangesÁˉ9˶]Ëç9ËC˨9˹9ËË9Ëis_asciiÁÙ Ëé]Ëü]Ë«Ý Ë
to_byte_classÁß ã
áÉ%ááó ãå×ãçÒ:çß:çì:çù:çŠ;ç‰9ãîæ î¹îþîãóæ ôšóÄ-óì0óùóÞ^ó‰9óç9óCó¨9ó¹9óË9ó£_ óé]óü]ó«óto_unicode_classÁ ãÉ%ó ãÒ:ß:ì:ù:Š;‰9ãæ ¹þã×ãreversedÁas_reprÁ from_reprÁas_charÁãžwithÁã ã¡ã£é]£ü]£look_setÁ£look_set_prefixÁ£look_set_prefix_anyÁ£look_set_suffixÁ£look_set_suffix_anyÁ£Ú]£explicit_captures_lenÁ£static_explicit_captures_lenÁ£
is_literalÁ£is_alternation_literalÁ£ memory_usageÁ£C±š±¡± ± ± ã·Ä-·«·•\·¢\·À.¼ ¼ ¼ ·»\À ·¨Â    ·ß.Ç ãÉÄ-ÉÉðAÉɤ-ÉcontainsÁÉcontains_anchorÁÉcontains_anchor_haystackÁÉcontains_anchor_lineÁÉcontains_anchor_lfÁÉcontains_anchor_crlfÁÉ
contains_wordÁÉcontains_word_unicodeÁÉcontains_word_asciiÁÉùÉ«JÉ
set_insertÁÉremoveÁÉ
set_removeÁÉsubtractÁÉ set_subtractÁÉCÉ set_unionÁɨ9É
set_intersectÁÉ read_reprÁÉ
write_reprÁãå×ãççó ã class_charsÁã class_bytesÁãsingleton_charsÁãsingleton_bytesÁãlift_common_prefixÁî ¬ðððððíðöæ ööŽöŸö¾Nö«öáNöÁ5öOöOöÊNö©Oö»Oðæ íÞJBYTE_FREQUENCIESÁˆ »OŠ Š Š Š Š Š Š ¹Š Š ×Š Š ×Š ˜ æ ˜ mappingÁ˜ overlapsÁ  ˜ getÁž Š   É%  õ9  canonical_binaryÁŠ •\¤ Š   ¦ impÁŠ ÿ
¨ ºoŠ 
perl_digitÁª ºoŠ  hir_classÁ¬ Š is_word_characterÁ® ºoŠ PropertyValuesÁŠ canonical_gencatÁŠ canonical_scriptÁŠ canonical_propÁ³ ºoŠ canonical_valueÁµ µ Š ç ¸ ºoŠ  property_setÁº º Š agesÁ½ ½ ºo¿ ¿ Š gencatÁ ºoŠ Ñ
Ä ºoŠ î
Æ ºoŠ 
bool_propertyÁÈ ºoŠ gcbÁÊ ºoŠ wbÁÌ ºoŠ sbÁÎ ºoŠ symbolic_name_normalizeÁŠ symbolic_name_normalize_bytesÁunicode_tablesÁ¾NÓ Ó Ó Ó Ó Ó Ó Ó Ó MAX_UTF8_BYTESÁÓ Ý from_encoded_rangeÁÝ as_sliceÁß Ý Ý IÝ matchesÁÓ ä É%ä IntoIterÁä ä êÓ é ×ê Ó ì æ ì ètÓ ï ×Ó ñ æ ñ ñ ì0Ó  ScalarRangeÁõ ¹õ þÓ ø ×Ó ú ú ó ü ü Ó Ó  
splitÁ
Ø0
as_asciiÁ
£_
encodeÁÓ max_scalar_valueÁescapeÁ escape_intoÁis_meta_characterÁis_escapeable_characterÁ…ptry_is_word_characterÁ is_word_byteÁ PrimitiveÁŽ
LiteralÁ

ˆŽ
 AssertionÁ

ˆŽ
DotÁ

ˆŽ
PerlÁ˜
˜
ˆŽ
UnicodeÁ

ˆž
ƒ  
×
¢
Ö  ¥

ParserBuilderÁ§
«§
ާ
٤
Ã
¬
Ĩ
×ParserÁ°
Ȱ
µ1°
ް
١
initial_ignore_whitespaceÁ°
ð
«°
commentsÁ°
 stack_groupÁ°
à%°

capture_namesÁ°
scratchÁ½
ƒ¿
×ParserIÁÁ
Á
¡Á
¬Á
¹Æ
Æ
¡Æ
ƒÊ
Ê
¡Ê
×
GroupStateÁÎ
§&Ï
¨Ï
Ò.Ï
«Î
ç&Ó
Ó
ˆÖ
į
×
ClassStateÁÚ
OpenÁÛ
CÛ
setÁÚ
OpÁÞ
Þ
á
ċ
× NestLimiterÁå
ñå
å
¡å
Ȍ
depthÁë
ñë
ë
¡ë
שPrinterBuilderÁð
_priv穘
ƒ©ô
שPrinterÁö
¦©ø
שWriterÁú
¨ú
wtrÁ©ý
¨ý
×
ErrorÁ  ¹ ã
 ƒ
  ×
!ˆ Ö
"
# 
 ErrorKindÁ CaptureLimitExceededÁŽ
 ClassEscapeInvalidÁ
 ClassRangeInvalidÁ
 ClassRangeLiteralÁ
 
ClassUnclosedÁ
  DecimalEmptyÁ˜
 DecimalInvalidÁš
 EscapeHexEmptyÁœ
 EscapeHexInvalidÁž
 EscapeHexInvalidDigitÁ 
 EscapeUnexpectedEofÁ¢
 EscapeUnrecognizedÁ¤
 FlagDanglingNegationÁ¦
 
FlagDuplicateÁ¨ originalÁ FlagRepeatedNegationÁª ¨„ FlagUnexpectedEofÁ¬
 FlagUnrecognizedÁ®
 GroupNameDuplicateÁ° ¨„ GroupNameEmptyÁ²
 GroupNameInvalidÁ´
 GroupNameUnexpectedEofÁ
 
GroupUnclosedÁ¸
 
GroupUnopenedÁº
 NestLimitExceededÁ¼
¼ ˆ RepetitionCountInvalidÁ¿
 RepetitionCountDecimalEmptyÁÁ
 RepetitionCountUnclosedÁÃ
 RepetitionMissingÁÅ
 SpecialWordBoundaryUnclosedÁÇ
 SpecialWordBoundaryUnrecognizedÁÉ
 $SpecialWordOrRepetitionUnexpectedEofÁË
 UnicodeClassInvalidÁÍ
 UnsupportedBackreferenceÁÏ
 UnsupportedLookAroundÁÑ

$Ó ƒ
%Õ ×
&× Ö
'
(Ú 
SpanÁÜ ¹Ü þ
)
*à ƒ
+
,ã Ö
-
.æ 
PositionÁè ž
è šè 
/
0í ƒ
1
2ð Ö
3
4ó 
 WithCommentsÁõ ¿õ ¡{
5ø ƒ
6ú ×
7ü Ö
8
9ÿ 
CommentÁ ã commentÁ
: ƒ
; ×
<ˆ Ö
=
> 
AstÁ EmptyÁŽ
Ž ˆ FlagsÁ
 ˆ ¼x
 ˆ öx
 ˆ Øxš
š ˆ  ClassUnicodeÁ
 ˆ  ClassPerlÁ 
  ˆ ClassBracketedÁ£
£ ˆ ˆ&¦
¦ ˆ §&©
© ˆ ç&¬
¬ ˆ Á&¯
¯ ˆ
?² ƒ
@´ ×
A Ö
B
C¹ 
ç&» ã» astsÁ
D¾ ƒ
EÀ ×
FÂ Ö
G
HÅ 
Á&Ç ãÇ å
IÊ ƒ
JÌ ×
KÎ Ö
L
MÑ 
¼xÓ ãÓ Ó ®
N× ƒ
OÙ ×
PÛ Ö
Q
RÞ 
 LiteralKindÁà VerbatimÁá
à MetaÁã
à  SuperfluousÁå
à OctalÁç
à HexFixedÁé
é ˆà HexBraceÁì
ì ˆà SpecialÁï
ï ˆ
Sò ƒ
Tô ×
Uö Ö
V
Wù 
SpecialLiteralKindÁû BellÁü
û FormFeedÁþ
û TabÁ
û LineFeedÁ
û CarriageReturnÁ
û  VerticalTabÁ
û SpaceÁˆ

XŠ
ƒ
YŒ
×
ZŽ
Ö
[
\

HexLiteralKindÁ
©

 UnicodeShortÁ

 UnicodeLongÁ˜

]š
ƒ
^œ
×
_ž
Ö
`
a¡

Ž£
ã£
£
negatedÁ
b§
ƒ
c©
×
d«
Ö
e
f®


ClassPerlKindÁ°
DigitÁ±
°
Ç”³
°
WordÁµ

g·
ƒ
h¹
×
i»
Ö
j
k¾


ClassAsciiÁÀ
ãÀ
À
¬–
lÄ
ƒ
mÆ
×
nÈ
Ö
o
pË

ClassAsciiKindÁÍ
AlnumÁÎ
Í
AlphaÁÐ
Í
AsciiÁÒ
Í
BlankÁÔ
Í
CntrlÁÖ
Í
ƒ—Ø
Í
GraphÁÚ
Í
LowerÁÜ
Í
PrintÁÞ
Í
PunctÁà
Í
Ç”â
Í
UpperÁä
Í
£—æ
Í
XdigitÁè

qê
ƒ
rì
×
sî
Ö
t
uñ

ìó
ãó
¬–ó

v÷
ƒ
wù
×
xû
Ö
y
zþ

ClassUnicodeKindÁ OneLetterÁ
ˆ¦
ˆ
NamedValueÁÊ'Ð »
{ƒ
|×
}Ö
~

ClassUnicodeOpKindÁ~
ColonÁ
NotEqualÁ

ƒ
×
ŸÖ
ƒ
¢
«Ž¤ã¤¬–¤
¨ƒ
ª×
¬Ö
ˆ
¯
ClassSetÁ±²
²ˆ±Ñ(µ
µˆ
Џƒ
º×
Œ¼Ö

Ž¿
 ClassSetItemÁÁùŒÂ
ˆÁ¼xÅ
ňÁ¹È
ȈÁÿ˜Ë
ˈÁ§yÎ
ΈÁŽyÑ
шÁ BracketedÁÔ
ÔˆÁô×
׈
Úƒ
Ü×
ÞÖ

á

ClassSetRangeÁããã¹ãþ
çƒ
é×
ëÖ

˜î

ClassSetUnionÁðãðitemsÁ
óƒ
šõ×
÷Ö
œ
ú
ClassSetBinaryOpÁüãüüüõ'
žƒ
Ÿƒ×
 Ö
¡
¢ˆ
ClassSetBinaryOpKindÁŠ IntersectionÁ
Š
DifferenceÁ
ŠSymmetricDifferenceÁ

£
¤ƒ
¥
¦×
§Ö
¨
©š
Øxœãœ
ªŸƒ
«¡×
¬£Ö
­
®¦

AssertionKindÁ¨ StartLineÁ©
¨EndLineÁ«
¨ StartTextÁ­
¨EndTextÁ¯
¨ WordBoundaryÁ±
¨NotWordBoundaryÁ³
¨WordBoundaryStartÁµ
¨WordBoundaryEndÁ·
¨WordBoundaryStartAngleÁ¹
¨WordBoundaryEndAngleÁ»
¨WordBoundaryStartHalfÁ½
¨WordBoundaryEndHalfÁ¿

¯Áƒ
°Ã×
±ÅÖ
²
³È
ˆ&ÊãÊÊ'ÊgreedyÁÊ¿
´Ïƒ
µÑ×
ÓÖ
·
¸Ö
 RepetitionOpÁØãØ
¹Ûƒ
ºÝ×
»ßÖ
¼
½â
RepetitionKindÁä ZeroOrOneÁå
ä
ZeroOrMoreÁç
ä OneOrMoreÁé
ä¹ë
ëˆ
¾îƒ
¿ð×
ÀòÖ
Á
Âõ
RepetitionRangeÁ÷ExactlyÁø
øˆ÷AtLeastÁû
ûˆ÷BoundedÁþ
þˆþ
Ã
Ä×
ÅÖ
Æ
Ç
§&ã¿
ȃ
É×
ÊÖ
Ë
Ì
 GroupKindÁ˜ CaptureIndexÁ
ˆ˜ CaptureNameÁœ
starts_with_pÁœÐ ˜ NonCapturingÁŸ
Ÿˆ
Í¢ƒ
Τ×
ϦÖ
Ð
Ñ©
´®«ã«Ð «Ö
Ò¯ƒ
Ó±×
Ô³Ö
Õ
Ö
SetFlagsÁ¸ã¸Ñ-
×»ƒ
ؽ×
Ù¿Ö
Ú
ÛÂ
ÄãÄ΢
Üǃ
ÝÉ×
ÞËÖ
ß
àÎ
 FlagsItemÁÐãÐ
áÓƒ
âÕ×
ã×Ö
ä
åÚ

FlagsItemKindÁÜNegationÁÝ
ÜFlagÁß
߈
æâƒ
çä×
èæÖ
é
êé
òëCaseInsensitiveÁì
ë MultiLineÁî
ëDotMatchesNewLineÁð
ë SwapGreedÁò
ë§yô
ëCRLFÁö
ëIgnoreWhitespaceÁø

ë
ìûƒ
í
îþ×
ïÖ
ð
ñƒµEitherÁLeftÁRightÁµˆ
ˆˆ›µ
ˆµŽµŽ›µŽƒµµ›µ×µµ›µÖµšµš›µµµ›µ¦€¡ParseÁ¢
¢ˆ¡ TranslateÁ¥
¥ˆ¨ƒ ª×
¬Ö  ¯ˆ±¸4±±¹±errÁ±ã±aux_spanÁ
¸¸4¸¸×û IntervalSetÁ¼š¼Þ^¼foldedÁûÀšÀƒûÚÃ×ûIntervalSetIterÁÆ
ÆÉ%ƚƈûËÉ%ËšË×¼ ExtractorÁÏÏ¢>ϵ>ÏÉ>Ïâ>¼
Õƒ¼××Û Ý ¼ ExtractKindÁÛPrefixÁÜ
ÛSuffixÁÞ
¼àƒ¼â×¼SeqÁäžB¼æƒ¼èÖ¼¼ë¼¼xíbytesÁí¤H¼ðƒ¼òÖ¼¼õ¼÷ï
¼ù¼PreferenceTrieÁûstatesÁûètûnext_literal_indexÁ¼ÿ×¼StateÁR¼ƒ×¼>ʦʃÊ×ÊͦÊ×Êñ¨‡€Ê¨×ìTranslatorBuilderÁ¾NÊNÑ-ìƒì×ì
TranslatorÁŸÓ%ŸÑ-Ÿ¾NŸÊNì ¤ƒì
¦×ìHirFrameÁ¨ExprÁ©
©ˆ¨¼x¬
¬ˆ¨ì¯
¯ˆ¨
ClassBytesÁ²
²ˆ¨ˆ&µ
¨§&· old_flagsÁ¨Á&¹
¨ç&»
¨AlternationBranchÁ½
ì ¿ƒì Á×ì TranslatorIÁÃþPÃñÃRùì
ÈþPÈñȃìÌþPÌñÌ×ìÐáNÐÁ5ÐOЩOлOÐOììØƒììÛ×ìÝ>㦀ßß¹ßãããƒãå×ã çÖã!ã"êãþ€ìUnicodeNotAllowedÁí
ì InvalidUtf8Áï
ìInvalidLineTerminatorÁñ
ìUnicodePropertyNotFoundÁó
ìUnicodePropertyValueNotFoundÁõ
ìUnicodePerlClassNotFoundÁ÷
ìUnicodeCaseUnavailableÁù
ã#ûƒã$ý×ã%ÿÖã&ã'ãHirÁpropsÁã(ƒã)Öã*ã+ŒãHirKindÁŽùŒ
޼x
ˆŽClassÁ
ˆŽLookÁ
ˆŽˆ&š
šˆŽ`
ˆŽÁ& 
 ˆŽç&£
£ˆã,¦ƒã-¨×ã.ªÖã/ã0­ã¼x¯
¯ˆã1²ƒã2´Öã3ã4·ã”ǹ§yº
ºˆ¹ï2½
½ˆã5Àƒã6ÂÖã7ã8ÅãìÇð}ã9Ƀã:Ë×ã;ÍÖã<ã=ÐãClassUnicodeIterÁÒ
ÒÉ%Òˆã>ÖÉ%Ö×ãClassUnicodeRangeÁÙ¹Ùþã?ã@݃ãAãBà>ãCâÖãDãEåãFçï
ãGéã Àëð}ãHíƒãIï×ãJñÖãKãLôãClassBytesIterÁö
öÉ%öˆãMúÉ%ú×ãClassBytesRangeÁý¹ýþãNãOƒãPãQ>ãRÖãSãTãUï
ãVã®ÇStartÁ
 EndÁ
 StartLFÁ
 EndLFÁ
  StartCRLFÁœ
œ EndCRLFÁŸ
Ÿ  WordAsciiÁ¢
¢ WordAsciiNegateÁ¥
¥  WordUnicodeÁ¨
¨ WordUnicodeNegateÁ«
« WordStartAsciiÁ®
®  WordEndAsciiÁ±
± WordStartUnicodeÁ´
´ WordEndUnicodeÁ·
· WordStartHalfAsciiÁº
º WordEndHalfAsciiÁ½
½ WordStartHalfUnicodeÁÀ
À WordEndHalfUnicodeÁÃ
à ãWãXǃãYãZÊ×ã[ÌÖã\ã]Ïã`ÑÖÑÐ ÑÚã^Õƒã_××ã`ÙÖãaãbÜãˆ&ÞminÁÞmaxÁÞ¯©ÞÚãcãƒãdå×ãeçÖãfãgêãöxìAnyCharÁí
ìAnyByteÁï
ì
AnyCharExceptÁñ
ñˆìAnyCharExceptLFÁô
ìAnyCharExceptCRLFÁö
ì
AnyByteExceptÁø
øˆìAnyByteExceptLFÁû
ìAnyByteExceptCRLFÁý
ãhãiƒãjãkƒ×ãlÖãmãnˆã
PropertiesÁŠ
Šˆãoƒãp×ãqÖãrãsã PropertiesIÁé]ü]™d©dÛdÀdòd¾N•e²e«alternation_literalÁãt£ƒãu¥×ãv§ÖãwãxªãLookSetÁ¬´ãyãz¯ƒã{ã|²>ã}´Öã~ã·ã LookSetIterÁ¹ð}㻃ã½×ðöy¿¿¿ø6ðƒðÄ×ðÆ>ðÂzÈ¿Èø6ð˃ðÍ׊ ¦€ÏPropertyNotFoundÁÐ
ÏPropertyValueNotFoundÁÒ
ÏPerlClassNotFoundÁÔ
Š Ö׊ 
CaseFoldErrorÁØ
ØˆŠ Û׊ UnicodeWordErrorÁÝ
ÝˆŠ à׊ SimpleCaseFolderÁâtableÁââó Š  æ×Š 
ClassQueryÁèÉ%èì›ê
êˆè¼'í
íˆèByValueÁð
property_nameÁðproperty_valueÁŠ 
óÉ%ó׊ CanonicalClassQueryÁö¼'÷
÷ˆöGeneralCategoryÁú
úˆöScriptÁý
ýˆöÖÝåÝúÝŠ  ƒ×Š  ÖŠ 
Š ˆÓ  Utf8SequenceÁŠOneÁ
ˆŠTwoÁŽ
Žˆ ŠThreeÁ
ˆ ŠFourÁ
ˆ˜ Ó 
Ó  Ó  œƒ   Ó 
¡Ö¢ ¢ ¢ Ó Ó §Ó ©ï
Ó «Ó  Utf8RangeÁ­¹­þÓ Ó ±ƒÓ Ó ´ÖÓ Ó ·Ó ¹ï
Ó »Ó 
Utf8SequencesÁ½ range_stackÁÓ ¿×1
3
3
7
7
@
A
B
C
D
G
G
H
H
I
N
O
P
Q
R
S
T
V
V
X
Y
Z
\
]
]
^
_
`
a
b
c
d
e
f
g
h
j
l
n
o
p
q
r
s
w
y
z
{
|
}
~



ƒ



ˆ

Š

Œ

Ž






¡
¡
¢
¢
£
£
¤
¤
¥
¥
¦
¦
µ
¸
¸
¿
¿
À
À
Á
Â
Â
Ã
Ã
Å
Å
È
È
Ê
Ê
Ë
Ë
Í
Í
Ï
Ï
Ñ
Ñ
Ó
Ó
Ô
Ô
Ø
Ø
Ù
Ù
Ú
Ú
Ü
Ü
Þ
Þ
à
à
î
ï
ï
ð
ð
ñ
ò
ó
ó
ô
ô
õ
õ
ö
ö
÷
÷
ø
¥
§
§
©
ª
ª
¬
¬
¬
®
®
®
°
°
±
´
·
¾
¾
¾
Á
Á
Á
Ã
Ä
Å
Æ
Ê
Ê
Ê
Ì
Ì
Ì
Ï
Ï
Ï
Ñ
Ñ
Ó
Ó
Õ
Õ
Õ
×
×
Ù
Ù
ß
à
ð
ñ
ò
ô
ô
ô
û
ý
ÿ



ˆ
Š
Œ
Ž





˜
š
œ
¡
ª
ª
ª
²
²
²
³
Ç
Ç
Ç
Ñ
Ñ
Ñ
Ý
Þ
ß
à
á


Œ

Ž













ž
Ÿ
 
¡
¢
¢
¤
¤
¥
¥
¦
¦
§
§
¨
¨
©
©
É
É
Ë
Ì
Í
Î
Ï
Ð
Ó
Ö
Ö
×
×
Ø
Ø
Ù
Ù
Ú
Ú
Û
Û
Ý
Ý
à
à
ä
å
ð
ñ
ó
ô
õ
õ
ö
ö
ù
ù
ú
ú
þ



ƒ





Œ









š

¤
¤
¤
­
¯
°
±
²
³
´
´
µ

·
¿
Á
Á
Á
Ã
Å
Å
Ç
È
Ù
Ü
Ü
ã
ã
å
å
æ
é
ê
ë

Œ

Ž








¤
¤
§
§
¨
©
©
ª
ª
«
«
¬
¬
­
­
µ

·
¹
º
»
¼
½
¾
¿
¿
À
À
Á
Å
Æ
Æ
Ç
Ç
È
È
É
É
Ë
Ë
Í
Í
Ï
Ï
Ñ
Ñ
Ó
Ó
Õ
Õ
Õ
×
×
×
Ø
Ø
Ú
Û
Û
Ü
Ý
Þ
ß
à
á
â
ä
ç
ö
÷
÷
ø
ø
ù
ú
û





š

ž
ž
ž
 
 
 
£
¥
·
º
º
º
¼
¼
¼
¾
¾
¾
À
Á
Â
Ã
Ä
Å
Æ
Ç
É
É
É
Ï
Ð
Ñ
Ò
Ó
Ô
Õ
Õ
Ö
Ö
×
×
Ø
Ø
Ù
Û
Ü
Ý
ß
ä
æ
æ
æ
é
ê
ë
ì
í
í
ð
ñ
ò
÷
ø
ù
ú
û
ü
ü
ý
ý
þ
þ
ÿ
ÿ


ƒ


Š

Ž







˜
˜
˜
Ÿ
¡
¤
¥
¦
§
¨
©
ª
«
¬
­
®
¯
°
¹
º
¼
À
Â
Ç
Ð
Ñ
Ò
Ó
Ô
Ú
Ü
Þ
à
â
ã
ä
æ
æ
æ
é
ê
ë
ì
í
õ
ø
ù
ú
û
ü
ý
þ
ÿ



ƒ








š

ž
¢
£
£
¤
¬
±
²
³
´
µ
½
¿
Ð
Ñ
Þ
Þ
ß
á
â
ã
ã
ê
ê
ê
î
ð
ð
ð
ó
ô
ù
ù
ù
ü


ƒ





ˆ
ˆ
Ÿ
¡
¡
¡
£
¦
¦
­
¯
¯
¯
¾
À
À
À
É
Í
Í
Í
×
Ù
Ù
Ù
â
ä
ä
ä
ï
ï
ï
ó
õ
õ
õ
ù
ù
ù
ÿ
ÿ
ÿ





Œ
Œ
Ô
Ö
Ö
Ö
Ø
Û
Û
á
ä
ç
ç
î
ñ
ô
ô
ù
û
û
û
ý







Œ
Œ
³
µ
µ
µ
·
º
º
¿
Á
Á
Á
Ã
Æ
Æ
Ë
Í
Í
Í
Ï
Ò
Ò
Ø
Ú
Ú
Ú
Ü
ß
ß
ó
õ
õ
õ
÷
ú
ú











Ÿ
¢
¢
¨
ª
ª
ª
¬
¯
¯
¸
º
º
º
¼
¿
¿
Å
Ç
Ç
Ç
É
Ì
Ì
ë
í
í
í
ï
ò
ò
ø
ú
ú
ú
ü
ÿ
ÿ
Œ
Ž
Ž
Ž



œ
ž
ž
ž
 
£
£
©
«
«
«
­
°
°
¹
»
»
»
½
À
À
Û
Ý
Ý
Ý
ß
â
â
è
ê
ê
ê
ì
ï
ï
ô
ö
ö
ö
ø
û
û











˜


 
¢
¢
¢
¤
§
§
Â
Ä
Ä
Ä
Æ
É
É
Ð
Ò
Ò
Ò
Ô
×
×
Ü
Þ
Þ
Þ
à
ã
ã
ï
ñ
ñ
ñ
ó
ö
ö
ƒ




Š
Š







£
¥
¥
¥
§
ª
ª
°
²
²
²
´
·
·
¼
¾
¾
¾
À
Ã
Ã
È
Ê
Ê
Ê
Ì
Ï
Ï
Ô
Ö
Ö
Ö
Ø
Û
Û
ã
å
å
å
ç
ê
ê
ü
ÿ
ÿ
ÿ








 
 
©
«
«
«
­
°
°
»
»
»
Â
Å
Å
Å
Î
Î
Î
Ö
Ø
Ø
Ø
á
ã
ã
ã
ç
é
ì
ì
ñ
ó
ö
ö
ø
ø
ú
ú






Š
Œ
Œ
Œ






œ
ž
ž
ž
¥
§
§
§
À
Â
Â
Â
Ë
Ï
Ï
Ï
Ù
Ü
Ü
Ü
ä
æ
æ
æ
è
ë
ë
ü
þ
þ
þ

ƒ
ƒ
ˆ
Š


§
©
©
©
«
®
®
³
µ
¸
¸
Á
Ã
Æ
Æ
Ê
Ì
Ì
Ì
Î
Ñ
Ñ
Ø
Ø
Ø
Þ
ã
æ
æ
è
è
ê
ê
î
ð
ð
ð
ò
õ
õ
ü
ü
ü


Š
Š
Œ
Œ
Ž
Ž
È
Ë
Ë
Ë
Í
Ð
Ð
Ö
Ø
Ø
Ø
Ú
Ý
Ý
ä
æ
æ
æ
è
ë
ë







Ž






¤
¦
¦
¦
¨
«
«
°
µ
¸
¸
¼
¾
¾
¾
Ã
Å
Å
Å
Ì
Î
Î
Î
×
×
×
Ü
Ü
Ü
á
á
á
ç
ç
ç
õ
õ
õ







¢
¨
¨
ª
ª
¬
¬
²
µ
¸
¸
º
º
¼
¼
À
À
À
ꜪòØŽ


¼x
ˆ

Øx
ˆ

öx
ˆ˜

Žyš
ˆ
œ
§y
ˆˆ+d'${/x¿cã“ã“Ðì㓵ßã“ã“Ø§
§
öy¨
«©
Žª
Ÿ«
è8rç2Öì¿c¹•³¹•ذ
°
Âz ±
Ȳ
µ1³
Ž´
ٵ
ðz
÷
«¸
¡{¹
±{º
à%»
Ì{¼
á{J‰‹È¦"¦0¿c¤–ØÁ
Á
‡|Ä

¹’,« ãP‘¡¿cÜ—ØÎ
Ï
§&Ð
¨Ñ
Ò.Ò
«Ó
Ô
ç&Õ
ˆ—å½A¿c²˜ØÚ
Û
Ý}Ü
CÝ
ð}Þ
û}ß
à
ŽtÍ´Ëb¿c¢™¿cå
å
¬~é
Ȑ
ß~8ÿ;Öà‚^€ñ¡êšØð
ð
ñ
¦©&T
á!a¸
¿c隳隿cö
ö
Í÷
¦©Íukµ£©Gc¿cú
ú
ñü
‡€©}m'”/O¨ê雿cŒŽôÏ&ãÛ&ã¼'Ê'ãÔ'Ê'ããõ'ã€(˜Ê'ãõ'ãöûMœìM±É%¿cšœžˆãŸ Ñ(¡ˆãß8Þ–É%Ø  ¦€ 
 ¹
ƒ ã
ŒD¯f.˜¿c¾ž¾žÐ쾞µß¾ž¾žØ "Ž    °  Ï  í  ‹‚˜  ¥‚š  ¾‚œ  Ù‚ž Ÿ ô‚  ¡ ‘ƒ ¢ £ ³ƒ
¤ ¥ Óƒ ¦ § òƒ ¨ “„
© ¨„ª ¸„« ¨„¬ ­ Ý„® ¯ û„° ˜…± ¨„² ³ »…´ µ Ö… · ó…¸ ¹ –†º » °†¼ ½ ʆ¾ ˆ¿ À ð†Á  “‡à Ä »‡Å Æ ߇Ç È ý‡É Ê ¥ˆË Ì шÍ Î ‚‰Ï Ð ¢‰ Ñ Ò lj!¾ìÛ¿c»Ÿ»ŸÐ컟µß»Ÿ»Ÿ¾¾žÄc¾žÄc»ŸÛÜ Ü œŠÝ ¹Þ þËÅ»ÁK؈¥Š ˆ¥ˆ¥Ð숥µßˆ¥ˆ¥¿cˆ¥ºˆ¥í߈¥ˆ¥Ûè è çŠé ž
ê šë ¼"ɉ>4•ا¦Š §¦§¦Ð짦µß§¦§¦¿c§¦º§¦íß§¦§¦Øõ õ ¾‹ö ¿÷ ¡{rß›B¿cϧϧÐìϧµßϧϧØ  •Œ ム¬ŒŸÖ÷—žÿî¿c½¨½¨Ð콨µß½¨½¨Ø Ž  ùŒ ˆ   ˆ  ¼x ˆ ˜ öx ˆš  Øxœ ˆ ž ìŸ ˆ  ¡ Ž¢ ˆ£ ¤ «Ž¥ ˆ¦ § ˆ&¨ ˆ© ª §& « ˆ¬ ­ ç&
® ˆ¯ ° Á& ± ˆ.û™šoëA|¿c¬©¬©Ð쬩µß¬©¬©Äc¬©Ø» » ç&¼ ã½ åêŒnùì­Cú¿c·¬·¬Ðì·¬µß·¬·¬ØÇ Ç Á&È ãÉ åÇî‚×Ò¿c¥­¥­Ð쥭µß¥­¥­ØÓ Ó ¼xÔ ãÕ Ö ®êuïæ•|ö¿c“®“®Ðì“®µß“®“®Øà á â Ö‘ã ä ë‘å æ ü‘ç è ”’é ê ¦’ë ˆì í Ã’î ˆï ð à’ñ ˆó}­¯ó¿c‰¯‰¯Ð쉯µß‰¯‰¯Øû ü ý É“þ ÿ Ú“

ï“
ƒ
ÿ“

””

¯”ˆ

Ç”C-?mt¿cê°ê°Ðìê°µßê°ê°Ø


©

¯•˜

È•f’cÿ~3¿c°²°²Ðì°²µß°²°²Ø£
£
ޤ
ã¥
¦
¬–ÍξÍâûd¿c±³±³Ðì±³µß±³±³Ø°
±
²
ƒ—³
´
Ç”µ

£—jg&–çkœœ¿c©´©´Ðì©´µß©´©´ØÀ
À
ç—Á
ãÂ
Ã
¬–àê8ÒØëë¿c«µ«µÐ쫵µß«µ«µØÍ
Î
Ï
Û˜Ð
Ñ
í˜Ò
Ó
ÿ˜Ô
Õ
‘™Ö
×
£™Ø
Ù
ƒ—Ú
Û
ÙÜ
Ý
Õ™Þ
ß
ç™à
á
ù™ â
ã
Ç”
ä
å
™š æ
ç
£— è
é
¹š
3NâšÃŠ¿c£¶£¶Ð죶µß£¶£¶Øó
ó
ìô
ãõ
¬–ö
Y̳¢5QD=¿cà¸à¸Ðìีßà¸à¸Øì›ƒˆ¦ˆŸœˆÊ'Ð Š»YÚN LºÌ¿cععÐìعµßععØ~˜¢š´ÏefHnÑοc‚»‚»Ðì‚»µß‚»‚»Ø¤¤«Ž¥ã¦¬–§Ÿ^°Vg¿c‚¼‚¼Ð삼µß‚¼‚¼Ø±²³´ˆµÑ(·ˆQkíÊT±K¿cú¼ú¼Ðìú¼µßú¼ú¼ØÁÂÃùŒÄˆÅƼxLjÈɹʈËÌÿ˜ÍˆÎϧyЈÑÒŽyÓˆÔÕá Öˆ×ØôÙˆÖ^¯–ÞÓ„¿cû½û½Ðìû½µßû½û½ØããÌ¡äã广þ±u¯¸[¿c•À•ÀÐì•Àµß•À•ÀØðð±¢ñãò΢£F‘#„gÊ¿cŒÁŒÁÐìŒÁµßŒÁŒÁØüü“£ýãþÿõ'fîÐC@+í¿cûÁûÁÐìûÁµßûÁûÁÛŠŒŸ¤Ž¸¤Ϥ@_gQóëµ ØûŠ û¿cûÂûÂÐìûµßûÂûÂØœœØxãžЙ2_…A]Û¿c“Ä“ÄÐì“ĵߓēĨ¨ ©ª–¦«¬¬¦­®À¦¯°Ö¦±²ê¦³´ƒ§µŸ§·¸½§¹ºÙ§»¼ü§ ½¾¨
¿À¿¨ ÌBË^{IQ³¿c€Å€ÅÐì€Åµß€Å€ÅØÊʈ&ËãÌÊ'ͯ©Î¿K‰%ç3o¿c›Ç›ÇÐì›Çµß›Ç›ÇØØØý©ÙãÚ‹V3Ï÷½¿c›È›ÈÐì›Èµß›È›ÈØäåæïªçè…«éꜫëì¹íˆ\þ'oгV¿c‰É‰ÉÐì‰Éµß‰É‰ÉØ÷øù–¬úˆûü²¬ýˆþÿάˆ~„–E5iã¿c¤Ê¤ÊÐì¤Êµß¤Ê¤Êا&ŒãŽ¿}§qù¿cÊËÊËÐìÊ˵ßÊËÊËØ˜š“®ˆœ´®Ç®žÐ Ÿ ä®¡ˆÏ1 %—Dñ¿cÀÌÀÌÐìÀ̵ßÀÌÀÌØ««´®¬ã­Ð ®Ö|. *Vs®¯¿cãÍãÍÐìã͵ßãÍãÍØ¸¸–°¹ãºÑ-ZG[¼K¿cÚÎÚÎÐìÚεßÚÎÚÎØÄÄÅãÆ΢Õâ $¬h¬À¿cÈÏÈÏÐìÈϵßÈÏÈÏØÐÐÀ±ÑãÒ†#)® ¿c·Ð·ÐÐì·Ðµß·Ð·ÐØÜÝÞ®²ßàòáˆG“Ý·4´¿c¥Ñ¥ÑÐì¥Ñµß¥Ñ¥ÑÛëìí³îï¹³ðñϳòóí³ôõ§yö÷´øù¡´éš×ð§ë~rØŸÒŠ ŸÒ¿cŸÒŸÒÐìŸÒµßŸÒŸÒŒ"¬©Œ"ú¼¿c¦¦§Ä2¨ˆ À9âdv{º±¿c¬¬­ï2¯ˆ gG>㋹ÁÉ%؈µŠˆŒ›µˆƺ·ƒˆ_Ÿpµ›µ¿c†Õ†ÕÐì†Õµß†Õ†ÕØ¡¢£ð¶¤ˆ¥¦Š·§ˆ®ðŒ³?{¿c—Ö—ÖÐì—ֵߗ֗Öé—Ö¾žé—Ößߦ€àãá¹ãâããfõ ßdÔ¾—ÖÄc—Ö¿c±±ˆ´¹µ¸ã·”¸g@„nòìÕ¥¸4é±±ˆ´¹µ¸ã·”¸g@„nòìÕ¥¸4»Ÿ ¸4¾žé±±ˆ´¹µ¸ã·”¸g@„nòìÕ¥¸4ìíîðÃïðŽÄñò¦ÄóôÈÄõöìÄ÷ø•ÅùúºÅÏ=} I¤B ¸4­×Äc‘ØØ¼¼Á¸¾Þ^û¿ä¸ûÌÎ\mêKÊš¿cìÛìÛµßìÛìÛ¿cÆÆÇœ¹Êˆû Í@ĶÉ%šùMÛܪªØÏÏí¹Ð¼Ñ¢>¼Òµ>¼ÓÉ>¼Ôâ>¼Dm¬° R¿c¿Ý³¿ÝØÛÜÝݺÞßðºŽé˜I|žö¿c»Þ³»ÞØää»åžB¼(ÁßbŸ¢äßÐìßµßßß¿cßÃLßíí¼xî仼ï¤H¼=¾¡”¤ü²nØüßüßÐìüßµßüßüßíßüßüߺüßéüßéüßàüß
¿cüß¿cûû¿¼üÕ¼¼ýèt¼þë¼¼lÑ«µ¨©¿c’½R¼f4{kÈB³â؈¦Êùw–¬Ÿ%¿cÑâ³Ñâ¿cÍŽ¦Ê
‹ð¿cñ‡€Ê3\,qðh”˜œòÑãØµ¾˜¾NìÊNìšÑ-ì?uüÐG£ð¿c–ä³–äØŸŸ€¿ Ó%ì¡Ñ-좾Nì£ÊNìÞàzDéKbð¿cú䨍 ©ªÜ¿«ˆì¬­¼x®ˆì¯°ì±ˆì²³ À´ˆìµˆ&·§&¸ÔÀ칺Á&»¼ç&½¾ÿÀß];ø¿cßåêÃ÷ÁÆRìǹìœüdƒÀ§¶þPñØÔç¿cÔçÛÐÐÑáNìÒÁ5ìÓOìÔ©OìÕ»OìÖOìfƒó±îÑIOØ¸èŠ ¸è¿c¸è³¸èح׿c­×­×Ðì­×µß­×­×ØÂÚ¿cÂÚÂÚÐìÂÚµßÂÚÂÚ¾­×Äc­×ÄcÂÚØ–Æã©Æã_Z¿IÞñêÐìñêµßñêñêØŽùŒ¼xˆ”Lj˜®Çˆšˆ&œˆž`Ÿˆ ¡Á&¢ˆ£¤ç&¥ˆr·d
Ⱦš°¿cÛëÛëÐìÛëµßÛëÛë¿cñêÄcñêØ¯¯°¼x±ˆ ³=¹ñi0¤OîÐìîµßîî¿cîØ¹º»§y¼ˆ½¾ï2¿ˆ£@êOƒþéîÐìéîµßéîéî¿céîØÇÇìÈð}ãã &o*î“ä¿cêïêïÐìêïµßêïêï¿cÒÒÓ½ÊÕˆã ûXdöäÉ%ùMÒðÛÙÙÿÊÚ¹ãÛþã<†¢9gÙØñŠ ñ³ññÐìñµßññíßññºñ¿cñœñØëë Àìð}ãw},•dÊM3¿cØòØòÐìØòµßØòØò¿cöö÷ÎÌùˆã wíZMœDbÉ%ùMÀóÛýýŽÍþ¹ãÿþãD®eã=B¥ÎØ‹ôŠ ‹ô³‹ô‹ôÐì‹ôµß‹ô‹ôíß‹ô‹ôº‹ôœ‹ô¿c‹ôÛšÎ±ÎÆÎ˜šßΜöΞŸ ‘Ï¡¢£ªÏ¤¥¦Åϧ¨©æÏª«¬ƒÐ­®¯¦Ð°±²ÆÐ³´µäз¸†Ñ¹º»¦Ñ¼½¾ÊÑ¿ÀÁìÑÂÃÄ’ÒÅ_É*l`ÃçØÆõŠ Æõ¿cÆõÆõÐìÆõµßÆõÆõØÑÑ`ÒÖÓÐ ÔÚy𴜥¿cùùÐìùµßùùØÞÞˆ&ßÙÓàäÓᯩâÚÖÕçˆI´«¿cöùöùÐìöùµßöùöùÛìíîÁÔïðÕÔñòéÔóˆôõ‹Õö÷§ÕøùÅÕúˆûüçÕýþƒÖÄ#æ:L2´ØøúŠ øú¿cøúøúÐìøúµßøúøúŒ"ñêØŠŠäÖŒˆã ; !Êô²‚¿c‚ý‚ýÐì‚ýµß‚ý‚ýØ¼× é]ã˜ü]ã™dãš©dãÛdãœÀdãòdãž¾N㟕eã ²e㡫㢧Øãñ£¦v§):8¿cîýîýÐìîýµßîýîýÛ¬¬ûØ­´X1+3ÎLØÛÿŠ Ûÿ³ÛÿÛÿÐìÛÿµßÛÿÛÿ¿cÛÿع¹ÔÙºð}ãhòæ „”jÌ¿cá€ùMá€Ø¿¿öyÀ¿ðÁø6ð‚•È?^qÂ9¿c­³­ØÈÈÂzÉ¿ðÊø6ð@!aÌI’£þ¿c„‚¿cÏÐÑ„ÛÒÓ¡ÛÔÕÃÛüÜf›ö¿cØØÙîÛÚˆŠ 
žðƒÄcðƒ¿cââÏÜãçÜŠ äŠ åó Š òÁ'×pÝEg¿cèêëì›ìˆíî¼'ïˆðÖÝñåÝòúÝÑLFÏ`ÊGÉ%¿cö÷ø¼'ùˆŠ úûÕÞüˆŠ ýþùÞÿˆŠ ÖÝåÝŠ úÝŠ :üŒü^Iц†Ð솆µß††††Š ŠŒïßˆŽ‡àˆ¤àˆÃà˜ˆæ\•Ï9ÒdÛLJØLJLJÐìLJµßLJLJíßLJLJºLJÇL É%LJ¿cLJÛ­­Ï᮹¯þìãxh8ª¼ØÁ‰Š Á‰Á‰ÐìÁ‰µßÁ‰Á‰íßÁ‰Á‰ºÁ‰¿cÁ‰¿c½½Àâ¾ÕâÓ ÿ?P0HG¿cõ õ õuö ¹Ó ÷ þÓ ΘÎ_«Œ·ùMàŠòPàŠž
Ž
¬
§
½
°
Æ
Á
Ö
Î
á
Ú
ò
ð
 Ó  à Ü í è ø õ  ²  ¾ » Ê Ç × Ó ò à Š
û š

§
£
·
°
Ä
À
ê
Í
÷
ó
¨¤¸±ÚÁçãóðüŠŸœÁ¨ÏÊÛØîä÷¢˜¯«»¸ÇÄÓÐâÜû뎨¡À¼ÕÏàÛæäðí¤Ÿ¿¨ÈÃØÐãßû즎²¯À¹ÉÇÝÙíëýÇÕÑãÞ슣¯¬»¹Â¿ËÈœŠ±­ 
Ž
®
§
¿
°
Ê
Á
Ø
Î
ã
Ú
ë
å
ô
ð
ø
ö
ý
ú
¼Œ¿š  Õ  ÎÜ Ôè ú õ  ´  À » Ì Ç Ù Ó ô à Œ
û œ

©
£
¹
°
Æ
À
ì
Í
ù
ó
ª¤º±ÜÁéãõðƒüŠ¡œÃ¨ÑÊÝØðä÷¤˜±«½¸ÉÄÕÐäÜþ멦°¬ª¡¸±Ã¼ËÆ×ÏâÛ£äÀíÿûƒ¦ŸÁ¨ÌÃÛÐåßý쨎¹½¯È¹ËÇÖÒåÙïëúöýÊ×Ñåރ슥嬽¹Ä¿ÍÈÖÏÛØàÝæâóèƒöé Šï ­¿½ø õ ¢
Ž
ˆ  ×  ã Ü ð è ü õ ˆ   Â » Î Ç Û Ó ö à Ž
û ž

«
£
»
°
È
À
î
Í
û
ó
Ÿ¬¤¼±ÞÁëã÷ðüŠ£œÅ¨ÓÊߨòä÷¦˜³«¿¸ËÄ×ÐæÜ묡ƒ¼èäòíçßÿ쪎´¯Â¹ÍÇâÙñëýÌÙÑçÞ슧´¬ö¡Š´­¤
Ž
Š  Ù  å Ü ò è þ õ Š  ¸  Ä » Ð Ç Ý Ó ø à
û  

­
£
½
°
Ê
À
ð
Í
ý
ó
¡®¤¾±àÁíãùðüŠ¥œÇ¨ÕÊáØôäˆ÷¨˜µ«Á¸ÍÄÙÐèÜëš®¡êäôíéß쬎¯Ä¹ÏÇäÙóëˆýÎÛÑéÞ슩¬ö¦Š­¥
Ž
 Ú  æ Ü ó è ÿ õ  ¹  Å » Ñ Ç Þ Ó ù à
û ¡

®
£
¾
°
Ë
À
ñ
Í
þ
ó
¢¯¤¿±áÁîãúðˆüšŠ¦œÈ¨ÖÊâØõä÷©˜«Â¸ÎÄÚÐé܃믡¼ëäõíêßìŒ­Ž·¯Å¹ÐÇåÙôëýÏÜÑêވ슪·¬ˆö§Š·­<§
±ð
áÏæÛÕÝÐàÙý²¬Æ¿šå
ºú
žÃÈ Å¡œßØÝÉ Ë ó Æ¡Î±ßŸì»ØÝß Ü ì è Šúë×ÐÜÙýÆÿì®¬Š°­â Ü ï è ŠýëÚÐßÙƒýÉì±¬šŠ³­ÐÜ Öè ùíéÙý«Š»­ÒÜ Øè ÷íçÙý©Š¹­  ± Á¡Ã¡È±Ë±¸íºíÆáÒöç¹ú ½°¥ä¾íÞçÙýä 
ÿ ½Ø¿cjÅÐìµß³ ÕêS¾Äc
#Û FŠ TºTíß1Œ"1éùM*ª#ÃL àòœÇLòP
10Á<åË   æËéË
<îË   ïËòË
<÷Ë   øËûË@<€Ì   Ì„Ì@<‰Ì   ŠÌÌ
üäË-  Ì ü²Ë`žÑ©œÂËÑ©®Ñ©zÑ©FѩѩÞb4¦Ú «Ú+@;  ¦ÚOl/{¥°·½Ä{ _ }Á4ŸÛ ¤Û+@;  ŸÛOl/{¥°·½Ä{ _ }Á4‚Ý ‡Ý+@;  ‚ÝOl/{˜¥°·½Ä{ _ }Á4ÒÞ ×Þ+@;  ÒÞOl/{¥°·½Ä{ _ }Á4úà ÿà+@;  úàOl/{ž¥°·½Ä{ _ }Á4ã ’ã+@;  ãOl/{¡¥°·½Ä{ _ }Á4„å ‰å+@;  „åOl/{¤¥°·½Ä{ _ }Á4Ûå àå+@;  ÛåOl/{§¥°·½Ä{ _ }Á4Öç Ûç+@;  ÖçOl/{ª¥°·½Ä{ _ }Á4±è ¶è +@;  ±èO l/{ ­¥°·½Ä{ _ }Á<ÐêÕê
+@;  ÐêO
l/{
°¥°·½Ä{ _ }Á<æìëì +@;  æìO l/{ ³¥°·½Ä{ _ }Á<„ï‰ï +@;  „ïO l/{ ¥°·½Ä{ _ }Á<˜ññ
+@;  ˜ñO
l/{
¹¥°·½Ä{ _ }Á<‰óŽó+@;  ‰óOl/{¼¥°·½Ä{ _ }Á<ñôöô+@;  ñôOl/{¿¥°·½Ä{ _ }Á<àöåö+@;  àöOl/{Â¥°·½Ä{ _ }Á<ÆøËø+@;  ÆøOl/{Å¥°·½Ä{ _ }Á$ÍûTÇû @€€ €@€€€€€€€€
SÔ„ƒ Ä‚ Äþ ´À ´€  ¤Æ€ 
¤Š€ 
”Ôÿ  ¼—ÿ  ŒÝþ ¬¥þ |ïý |¿ý l“ý låü \½ü \“ü Lïû ¯ƒšü™ûÆõ$¸ûÆõ$¯û\àû<$„‡ \„‡
 އ•‡ü󅢑†Æõ$ˆ†Æõqx@T˜‰ @€€ €@€€€€€€€€
$Ú’ Û¼ÆõÄ®’  ô©’ Û¼Æõ Æ’ Ôä‘  üß‘  Û¼Æõ þ‘ ´ž‘  䙑 Û¼Æõ ´‘ ÄÖ  ôÑ Û¼Æõ î ¤’  
Ô Û¼Æõ ¦ ´Ì   äÇ Û¼Æõ â ”Š

 Ä… Û¼Æõ
œ
 ¤ÆŽ  
ÔÁŽ Û¼Æõ ÚŽ  ¼ÿ   ìú Û¼Æõ –Ž  Œ¾

¼¹ Û¼Æõ
Ï
 ¬ùŒ  ÜôŒ Û¼Æõ Ž  |ºŒ  ¬µŒ Û¼Æõ ÉŒ lý‹  œø‹ Û¼Æõ ŠŒ |¾‹  ¬¹‹ Û¼Æõ Í‹ \ƒ‹  ŒþŠ Û¼Æõ Ž‹ lÆŠ  œÁŠ Û¼Æõ ÓŠ LŠ  |ˆŠ Û¼Æõ –Š \Ò‰  ŒÍ‰ Û¼Æõ ݉ ï’œü܈
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÆõd$óˆÆõÆÆõÆõgÆõ¸Æõ ÆõZÆõ«ÆõüÆõMÆõžÆõïÆõ@ÆõÆõâÆõ3ÆõÆõÖÆõ' ®$©–T£– @€€ €@€€€€€€€€
S,ù› ¶%,Ê› À%,™› ·%,ìš Á%,½š  0,’š 0ç™ >À™ <4”™ ©Ö4å˜ ÃÖ¿˜ B•˜ bñ— RÏ— r«— $‹— ^é– zË– Aœüö•$”–Æõ$‹–\¼–:ü/¥" 5 7H 4[ 3n 2 1 0§ /º .Í -à gñ ò B C¨ å¹ ,Ì +ß *ò ) (˜ '« &¾ %Ñ $ä #÷ "Š ! 8°  Ã Ö é ü  ÿŸ ¯ ¤¿ Ï ˆß  ï ÿ ­ ÝŸ Þ¯ ¿ zÏ èß Êï ×ÿ à П ܯ Ì¿ »Ï ·ß ³ï ±ÿ ¨ ²Ÿ ȯ â¿ ÃÏ šß ¸ï ®ÿ ~ xŸ ¿¯ ¿ ÂÏ ªß ½ï ¢ÿ ¡
Ÿ
Á¯
Ž¿
Ï
«ß
°ï
¹ÿ
§ ºŸ p¯ ¯¿ ÀÏ ¼ß œï Œÿ  {Ÿ ¯ ¿ Ï Šà ð r
ß
 
ù°
ØÀ
îÐ
ìà
ýð
ã Ú æ  ÷° À ´Ð ñà éð ö ô ç  ° õÀ óÐ ûà ëð É Ä ð  Ö° ˜À Ð Íà µð   Ô¦ Ó¹ ÒÌ Õß äò Å ©˜ Ÿ« ƒ¾ ¬Ñ iä P÷ bŠ ` a° Qà ÏÖ é tü s ¢ µ È yÛ kî  m n§ |º oÍ Rà ló v  q¨ ¹ wÊ }Û ¥ì uý \Ž jŸ S° HÁ cÒ ]å Aö O ¦˜ í© £º ÇË ¾Ü áí Ñþ Ë Æ  Ù± Û ÎÓ êä øõ ž ï ÿ¨ ÿ¹ ÿÊ ÿÛ ÿì ÿý ÿŽ ÿŸ ÿ° ÿÁ ÿÒ ÿã ÿô ÿ ÿ ÿ§ ÿ¸ ÿÉ ÿÚ ÿë ÿü ÿ ÿž ÿ¯ ÿÀ ÿÑ ÿâ ÿó ÿ ÿ ÿ¦ ÿ· ÿÈ ÿÙ ÿê ÿû ÿŒ ÿ ÿ® ÿ¿ ÿÐ ÿá ÿò ÿƒ ÿ ÿ¥ ÿ ÿÇ ÿØ ÿé ÿú ÿ‹! ÿœ! ÿ­! ÿ¾! ÿÏ! ÿà! ÿñ! ÿ" ÿ“" ÿ¤" ÿµ" ÿÆ" ÿüÕ" ˆ L# 2256ÁMAX_UTF8_BYTESÁMAX_UTF8_BYTESÁ< Ž

%ã“1“®9@ Ž

%ã“1“Ä9@» Ž

%ã“1ˆ¥9@ Ž

%ã“1±³9@ Ž
œ
%ã“1à¸9@\®] Î
Ô
%²˜1·¬9@T¾'
þ'þˆ&ˆãƒ§&ˆãÁ&Ï&ãˆÛ&ãç&ŠÏ&ãÛ&ãÉ
þÇ ›ÇÒÙ,½(
þ'Ì…3 ÊË>E$¦9
š'šœžˆãŸ Ñ(¡ˆãß8Þ– û½ŠDÇ9
š '†ˆ3 ûÁ>EŒÐ-  ½ %»Ÿ18?,î‹   &¬©2žBoxÁ¡ˆˆ¢ˆl }.xψ¥çEçEèEGlobalÁ ¿±‡§í#§®,«Œ   &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏÚΑ‹}   &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏ“®‘‹}È  ˜ &¬©2ÌŠ:ALƒŽ   &¬©2žÚ‰¡ˆˆ¢ˆl }.xϓđ‹}dèŽ  ž &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏฑ‹}  ¡ &¬©2žÚ‰¡ˆˆ¢ˆl }.xϱ³‘‹}t  ¤ &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏ‚¼‘‹}Tƒ’  § &¬©2žÚ‰¡ˆˆ¢ˆl }.xϛǑ‹},Ê’  ª &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏÊË‘‹}\ 
­ &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏ·¬‘‹}4ã“  ° &¬©2žÚ‰¡ˆˆ¢ˆl }.xÏ¥­‘‹}DÐÈ à ê &‰¯2°²:AD®Ê à í &‰¯2°²:A<©Ë à ð &‰¯2ê°:ALÞú &ع28?,Ëû &ع2úHúHßûHÁ‘4Ý­f‰úM÷dk$à´ ±³&ú¼2û½:AD°µ ±&ú¼2ûÁ:A,ؽ ÁÃ&û½2ˆ¥:A<ƒ¾ ÁÆ&û½2“®:A,¿¾ ÁÉ&û½2•À:A,¿ ÁÌ&û½2«µ:A<ó¿ ÁÏ&û½2à¸:A$ÂÀ ÁÒ&û½2±³:ALùÁ ÁÕ&û½2±’:A,·Â ÁØ&û½2ŒÁ:A,žò äì&‰É2¤Ê:A<ïó ÷ù&¤Ê29@<ô ÷ü&¤Ê29@<²ô ÷ÿ)¤Ê5<CJd¶… ˜š&ÀÌ29@dÒ‡ ˜ &ÀÌ2ÈÏ:A$æ¦ Üà&¥Ñ2ŸÒ:A´a ¦§$Ô07>ÜÏ  ¬­'¬¬­ï2¯ˆ gG>㋹Áb ªámt ÐÕ×Õ -†Õ9ÐÕAH ÐÕ×Õ Œ-†Õ9×ÕAH ¡£%—Ö1¾ž9@L‡ ¡¦%—Ö1­×9@ü̇! Æ”Ý Ç-ÆÆÇœ¹Êˆû Í@Ķ”ÝnÄlÄlIterÁÇlµ ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSž”ÝÓÚ$¯5 ¨ª%ßå1ñê9@<Ç8 ¨­%ßå1ªBªBö­BbufÁ÷<®B÷<9)
-ÜnL‘‹ydŠ: ¨°%ßå1êï9@T«= ¨³%ßå1Øò9@ ƒ'ƒˆ&ˆê`ˆêˆÁ&Ï&êŠÛ&êç&ŒÏ&êÛ&ê°Å©Tç“ònÆ öùÑØ 'ò®3 ù>E<ÿâ Ž&Ûë2î:A,˜å Ž&Ûë2éî:A$÷å Ž˜&Ûë2Æõ:ATÃæ Ž&Ûë2öù:A<›ç Žž&Ûë2ù:A4Éé Ž¡&Ûë2ªBªBö­Bá«÷<®B÷<9)
-ÜnLñê‘‹y\²ì ޤ&Ûë2½´:A”êù ¯°&î2žÚ‰¡ˆˆ¢ˆl }.xϪᑋ}< … ¹»&éî2êï:A,˜† ¹¾&éî2Øò:Aü…ø ÒÓ)ÒÒÓ½ÊÕˆã ûXdöäfÆÆÇœ¹Êˆû Í@Ķñ£ªìã¿ ö÷(öö÷ÎÌùˆã wíZMœDbeÆÆÇœ¹Êˆû Í@Ķ‹ô¢©lî¸ ìò&øú28?lÀÀ ìù&øú29@¬©Ò Š&‚ý2žÚ‰¡ˆˆ¢ˆl }.xÏîý‘‹}Äÿ ØÙ% ƒ18?ÜÔ  ÝÞ%ðƒ18?L˜? èë'èêëì›ìˆíî¼'ïˆðÖÝñåÝòúÝÑLFÏ`ÊG¡¨4°A èî'ù¾3 <C4še öø%††1·À9@|áe öû%††1·À9@4§f öþ%††1·À9@Ö
ŠŒ%LJ1Á‰9@Ž
Š%LJ1Á‰GN
Š%LJ1Á‰GN$
Š%LJ1Á‰GN
¥µãð‡ Š Ò Ó ‡
ˆ
Š
Œ
íÀÝ= ¤,ð= ¦€,”> ¡í,¨> õÂz4¯> È öyl·> ¿
Ü„Ô> Ý ß4ý> úH üû„ üá: Ü:
This crate provides a robust regular expression parser.
This crate defines two primary types:
* [`Ast`](ast::Ast) is the abstract syntax of a regular expression.
An abstract syntax corresponds to a *structured representation* of the
concrete syntax of a regular expression, where the concrete syntax is the
pattern string itself (e.g., `foo(bar)+`). Given some abstract syntax, it
can be converted back to the original concrete syntax (modulo some details,
like whitespace). To a first approximation, the abstract syntax is complex
and difficult to analyze.
* [`Hir`](hir::Hir) is the high-level intermediate representation
("HIR" or "high-level IR" for short) of regular expression. It corresponds to
an intermediate state of a regular expression that sits between the abstract
syntax and the low level compiled opcodes that are eventually responsible for
executing a regular expression search. Given some high-level IR, it is not
possible to produce the original concrete syntax (although it is possible to
produce an equivalent concrete syntax, but it will likely scarcely resemble
the original pattern). To a first approximation, the high-level IR is simple
and easy to analyze.
These two types come with conversion routines:
* An [`ast::parse::Parser`] converts concrete syntax (a `&str`) to an
[`Ast`](ast::Ast).
* A [`hir::translate::Translator`] converts an [`Ast`](ast::Ast) to a
[`Hir`](hir::Hir).
As a convenience, the above two conversion routines are combined into one via
the top-level [`Parser`] type. This `Parser` will first convert your pattern to
an `Ast` and then convert the `Ast` to an `Hir`. It's also exposed as top-level
[`parse`] free function.
# Example
This example shows how to parse a pattern string into its HIR:
```
use regex_syntax::{hir::Hir, parse};
let hir = parse("a|b")?;
assert_eq!(hir, Hir::alternation(vec![
Hir::literal("a".as_bytes()),
Hir::literal("b".as_bytes()),
]));
# Ok::<(), Box<dyn std::error::Error>>(())
```
# Concrete syntax supported
The concrete syntax is documented as part of the public API of the
[`regex` crate](https://docs.rs/regex/%2A/regex/#syntax).
# Input safety
A key feature of this library is that it is safe to use with end user facing
input. This plays a significant role in the internal implementation. In
particular:
1. Parsers provide a `nest_limit` option that permits callers to control how
deeply nested a regular expression is allowed to be. This makes it possible
to do case analysis over an `Ast` or an `Hir` using recursion without
worrying about stack overflow.
2. Since relying on a particular stack size is brittle, this crate goes to
great lengths to ensure that all interactions with both the `Ast` and the
`Hir` do not use recursion. Namely, they use constant stack space and heap
space proportional to the size of the original pattern string (in bytes).
This includes the type's corresponding destructors. (One exception to this
is literal extraction, but this will eventually get fixed.)
# Error reporting
The `Display` implementations on all `Error` types exposed in this library
provide nice human readable errors that are suitable for showing to end users
in a monospace font.
# Literal extraction
This crate provides limited support for [literal extraction from `Hir`
values](hir::literal). Be warned that literal extraction uses recursion, and
therefore, stack size proportional to the size of the `Hir`.
The purpose of literal extraction is to speed up searches. That is, if you
know a regular expression must match a prefix or suffix literal, then it is
often quicker to search for instances of that literal, and then confirm or deny
the match using the full regular expression engine. These optimizations are
done automatically in the `regex` crate.
# Crate features
An important feature provided by this crate is its Unicode support. This
includes things like case folding, boolean properties, general categories,
scripts and Unicode-aware support for the Perl classes `\w`, `\s` and `\d`.
However, a downside of this support is that it requires bundling several
Unicode data tables that are substantial in size.
A fair number of use cases do not require full Unicode support. For this
reason, this crate exposes a number of features to control which Unicode
data is available.
If a regular expression attempts to use a Unicode feature that is not available
because the corresponding crate feature was disabled, then translating that
regular expression to an `Hir` will return an error. (It is still possible
construct an `Ast` for such a regular expression, since Unicode data is not
used until translation to an `Hir`.) Stated differently, enabling or disabling
any of the features below can only add or subtract from the total set of valid
regular expressions. Enabling or disabling a feature will never modify the
match semantics of a regular expression.
The following features are available:
* **std** -
Enables support for the standard library. This feature is enabled by default.
When disabled, only `core` and `alloc` are used. Otherwise, enabling `std`
generally just enables `std::error::Error` trait impls for the various error
types.
* **unicode** -
Enables all Unicode features. This feature is enabled by default, and will
always cover all Unicode features, even if more are added in the future.
* **unicode-age** -
Provide the data for the
[Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
This makes it possible to use classes like `\p{Age:6.0}` to refer to all
codepoints first introduced in Unicode 6.0
* **unicode-bool** -
Provide the data for numerous Unicode boolean properties. The full list
is not included here, but contains properties like `Alphabetic`, `Emoji`,
`Lowercase`, `Math`, `Uppercase` and `White_Space`.
* **unicode-case** -
Provide the data for case insensitive matching using
[Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
* **unicode-gencat** -
Provide the data for
[Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
This includes, but is not limited to, `Decimal_Number`, `Letter`,
`Math_Symbol`, `Number` and `Punctuation`.
* **unicode-perl** -
Provide the data for supporting the Unicode-aware Perl character classes,
corresponding to `\w`, `\s` and `\d`. This is also necessary for using
Unicode-aware word boundary assertions. Note that if this feature is
disabled, the `\s` and `\d` character classes are still available if the
`unicode-bool` and `unicode-gencat` features are enabled, respectively.
* **unicode-script** -
Provide the data for
[Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
`Latin` and `Thai`.
* **unicode-segment** -
Provide the data necessary to provide the properties used to implement the
[Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
`\p{sb=ATerm}`.
* **arbitrary** -
Enabling this feature introduces a public dependency on the
[`arbitrary`](https://crates.io/crates/arbitrary)
crate. Namely, it implements the `Arbitrary` trait from that crate for the
[`Ast`](crate::ast::Ast) type. This feature is disabled by default.
Á
¥µãð‡ Š Ò Ó ‡
ˆ
Š
Œ
í4À5¤4¦€3¡í2 õÂz1È öy0¿
Ü/Ý ß.úH ÈË΄Ð= Å”ã= º,€> d> ²ü€>% ©¬ž¡ÌË> ¬î> \†? ü:5
Defines an abstract syntax for regular expressions.
ÁŽ? ©ã è Ü Á˜ä÷à ¨ëÜŠ°
Í
 õ » Ç Ó û
£
À
ó
¤±ãðüœÊØ«¸ÄЮDK¿ß
Ú‰i
ß4vúH
Á~÷<
Á
öˆªB
¡%,­ øœ$<´êœ@,ZTb„tnwgiDƒLœ—?A24l¿ü83
This module provides a regular expression parser.
Á.:;§Ž
Î
§
°
Á
Ú
å
Y4R a$eá.É<kË/íyëÚ‰šßúH!ToStringÁD´—6"ÁÃ÷<#Á#öѪB$¿
'îŒ÷ (çŠè )œŠ$†Ü *µ4™+×w¼¥ Š
,¿wŒ¾
-$>tJKü>$AD58),,†T“$ü†#÷ùDÌÛ,Þ„ÞÒëÅǵ·¥§t‘ˆŠy{tÕ¥//Íì¥ áÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
⊾žY[ã“1237¼ÃÁ Áã“ Áˆ¥0 Ë0
1į
㓬©00
2
üÕwœØÂÃã“ ÂÁ
Á
‡|Ä

¹’,« ãP‘áֿٿڿ«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
û½¾ž0¡44 0Íìû ì û¤–
3û» /1Äûd‡üÕq”ØÄÅã“ ÄÁ
Á
‡|Ä

¹’,« ãP‘ÅûÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
“®¾ž0¡88 ˜0÷Ž ëˆ
7û$‡» #%ÔÄ
:® Îü†0|‰
;® firstÁ,¢ô๕=´=ì…<ˆ¹•<<
=”˹•?@ABCDì¦üä=: Create a new parser builder with a default configuration.Á­¹•>>
?ì»!üô B? Build a parser from this configuration with the given pattern.Á,Â!Æ Æ¹•¤–> È!>
@$É!ü2>üÛ&*' Set the nesting limit for this parser.ÁŠ'úü’'KH The nesting limit controls how deep the abstract syntax tree is allowedÁüâ'IF to be. If the AST exceeds the given limit (e.g., with too many nestedÁü°(52 groups), then an error is returned by the parser.Áê(úüò(GD The purpose of this limit is to act as a heuristic to prevent stackÁü¾)IF overflow for consumers that do structural induction on an `Ast` usingÁüŒ*GD explicit recursion. While this crate never does this (instead usingÁüØ*FC constant stack space and moving the call stack to the heap), otherÁ|£+ crates may.Á·+úü¿+HE This limit is not checked until the entire AST is parsed. Therefore,ÁüŒ,IF if callers want to put a limit on the amount of heap space used, thenÁüÚ,GD they should impose a limit on the length, in bytes, of the concreteÁü¦-C@ pattern string. In particular, this is viable since this parserÁüî-FC implementation will limit itself to heap space proportional to theÁü¹.! length of the pattern string.Áß.úüç.IF Note that a nest limit of `0` will return a nest limit error for mostÁüµ/JG patterns but not all. For example, a nest limit of `0` permits `a` butÁü„0JG not `ab`, since `ab` requires a concatenation, which results in a nestÁüÓ0JG depth of `1`. In general, a nest limit is not something that manifestsÁü¢1IF in an obvious way in the concrete syntax, therefore, it should not beÁÜð1 used in a granular way.ÁT—2Ç Ç¹•È¢> ¢2>
A$§2limitÁ,­2üÆ98üŠ3+( Whether to support octal syntax or not.Áº3úüÂ3HE Octal syntax is a little-known way of uttering Unicode codepoints inÁü4@= a regular expression. For example, `a`, `\x61`, `\u0061` andÁüÔ4IF `\141` are all equivalent regular expressions, where the last exampleÁ¼¢5 shows octal syntax.Á¾5úüÆ5KH While supporting octal syntax isn't in and of itself a problem, it doesÁü–6JG make good error messages harder. That is, in PCRE based regex engines,Áüå6A> syntax like `\0` invokes a backreference, which is explicitlyÁü«7HE unsupported in Rust's regex engine. However, many users expect it toÁüø7FC be supported. Therefore, when octal support is disabled, the errorÁüÃ8IF message will explicitly mention that backreferences aren't supported.Á9úü™9(% Octal syntax is disabled by default.Á,Í9È È¹•¬ª> Ó9>
B$Ø9ÿÞ9üì=Dü³:2/ Enable verbose mode in the regular expression.Áê:úüò:GD When enabled, verbose mode permits insignificant whitespace in manyÁü¾;GD places in the regular expression, as well as comments. Comments areÁüŠ<=: started using `#` and continue until the end of the line.ÁÌ<úüÔ<FC By default, this is disabled. It may be selectively enabled in theÁüŸ=HE regular expression by using the `x` flag regardless of this setting.ÁŒó=É É¹•æ®> …>>
C$Š>ÿ>ü±ABüñ>30 Allow using `{,n}` as an equivalent to `{0,n}`.Á©?úü±?HE When enabled, the parser accepts `{,n}
Á
‡|Ä

¹’,« ãP‘š˜ ˆ¥ü@ר ×Ü— ØãÍÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¾žJ ¡‚J
Vš˜$¢‚capÁ¨‚܃V¸ÂWÐÂWíÂWWVWš˜ ãÍ·Àü݆#Œà†Ù ÙÜ—J ò†J
Xš˜$ó†´Ôˆ$׈Ú ÚÜ—J ܈J
Yš˜$݈ü¢Š#<¥ŠÛ ÛÜ—J ­ŠJ
Zš˜$®Š´ ´Š©‹Z¸Â[ÐÂ[íÂ[[Z[š˜ ´ìŒ$ïŒÜ ÜÜ—J ôŒJ
\š˜$õŒüÿ’'<‚“ÝÞ ÝÜ— ÞJ Š“J
]š˜$‹“prefixÁ4‘“üú—&¤ý—ß ßÜ—J ’˜J
^š˜$“˜üÓš%œÖšà àÜ—J êšJ
_š˜$뚤àŸTãŸá áÜ—J îŸJ
`š˜$ïŸôž¨$¡¨â âÜ—Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙJ ¦¨J
aš˜$§¨ü½ª$TÀªã ãÜ—òÎJ ˪J
bš˜$̪ÄØ°4Û°ä äÜ—J â°J
cš˜$ã°Ì“²–²å åÜ—§¦J š²J
dš˜$›²´Ë³$γæ æÜ—ˆ¥J Ó³J
eš˜$Ô³ÜÈ´LË´ç çÜ—ˆ¥J Õ´J
fš˜$Ö´üλHtÑ»è èÜ—¥­Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥­¾žJ à»J
gš˜$Ứ4ë»üÚ¾6¼Ý¾é éÜ—¥­J õ¾J
hš˜$ö¾¨4ü¾„Ÿ¿üÐÇDTÓÇê êÜ—¥­„ÔJ ÞÇJ
jš˜$ßǨ4éÇ‚Íj¸ÂkÐÂkíÂkkjkš˜ ÈÏÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙüôÔIL÷Ôë ëÜ—¥­„ÔJ ÕJ
lš˜$‚Õ group_concatÁdŒÕ„ÌÕüÈä?lËäì ìÜ—¥­ó¶J ÙäJ
nš˜$Úä¨4ääü‹ôp|Žôí íÜ—ŒÁÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŒÁ¾žJ §ôJ
oš˜$¨ô parent_unionÁd¶ôüÑýLÔýî îÜ—ŒÁÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆµŠˆŒ›µˆƺ·ƒˆ_ŸpŒÁ‚¼¾žJ çýJ
pš˜$èý nested_unionÁdöýüªŽ,¤­Žï ïÜ—¾žJ ÂŽJ
qš˜$ÃŽülð ðÜ—ûÂŒÁŒÁJ §”J
rš˜$¨” next_kindÁL¶”
next_unionÁTä”ü€›;dƒ›ñ ñÜ—ú¼ú¼J J
sš˜$‘›õ'—›üŽ *u¡vuv¬» — ½»tš Ü—wyz{|}~ƒˆŠŒŽ“ VXô‚¡,…¡ò òÜ—ó¶t ‹¡t
wš˜$Œ¡4Ê¡w¸ÂxÐÂxíÂxxwxš˜ϧ¬©üå¢:œè¢ó óÜ—¸¹t ü¢t
yš˜$ý¢ü½·ŽÔÀ·ô ôÜ—¥­‰É„Ôt ä·t
zš˜$å·¨4÷·$”¸üÁÆiÄÄÆõ õÜ—¥­„Ôt æÆt
{š˜$çÆ¨4ùÆüÖçB\Ùçö öÜ—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆµŠˆŒ›µˆƺ·ƒˆ_ŸpÚÎÊ˾žt åçt
|š˜$æçüèýc”ëý÷ ÷Ü—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ã;žt ‡þt
}š˜$ˆþµ1l–þüˆ+\‹ø øÜ—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÈϾžt t
~š˜ü¸œ)T»œù ùÜ—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÒ¾žt Æœt
š˜$ÇœüÕ¤.|ؤú úÜ—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
㓾žt è¤t
š˜$é¤ü˯+dίû ûÜ—Ýìt Û¯t
š˜$ܯLÁÁ¸ÂÐÂ횘ê°ÝìäÄü÷Ú|üúÚ!ü üÜ—§¦Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zـžžt ¥Ût
ƒš˜$¦Ûwb_startÁD´Û¹Üƒ¸ÂÐÂ탚˜ü¿î%\Âîý ýÜ—“®t Îît
š˜$Ïîüëø+Lîøþ þÜ—Çt øøt
š˜$ùøüd„’ÿ ÿÜ—°²Çt ¬t
š˜ü¤c Ü—°²Çt Àt
ˆš˜üƒ&l† Ü——Ât t
š˜$•ü¨§8|«§ Ü—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‚¼¾žt »§t
Šš˜$¼§üï¼<¬ò¼ƒ ƒÜ—Žt ˆ½t
š˜$‰½üüË3¤ÿË Ü—Ýìt ”Ìt
Œš˜$•Ìü³Öb¤¶Ö Ü—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‚¼ŒÁ¾žt ÔÖt
š˜$ÕÖüºë<¼½ë Ü—Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ«µt Õët
Žš˜$Öëü¤ƒ:œ§ƒ Ü—Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
฾žt »ƒt
š˜$¼ƒüú™,„ý™ˆ ˆÜ—±³t Žšt
š˜$šüÑ¡6ñ¡ÍìÑš Þ¡ Ñš¤–tᡚ֡ڡ8:üŽ¢7‘¢
Á
‡|Ä

¹’,« ãP‘Ñšš
ñÑš» •¢üŒ£',£š ¬©²Å  £
ñÑš$•£¿›£üߣ8|⣊ Šš ˆ¥²Å ò£
ñÑš$÷£ã$ý£Ѥ¸Â˜Ð˜í˜˜˜Ñš–Ä Á
Á
‡|Ä

¹’,« ãP‘ÑšäÄìú§|ý§Œ Œš ¨
ñÑš$’¨ü»©Gñœ¡œïþ È©ÿtË©šžŸ ¡¢£¤¥¦ëìíïðóôõö¢ ¤¥£¡¦À©Ä©{}\‰ª4ŽªššDŸª¤ªšš¾ž컪4¾ªš²Åšš
 ñÑš$Ūüõª0LøªŽ š Ž¬©²Åš ‚«š
¡ñÑš$‡«¿«üµ°1T¸° 𠬩²Åš ðš
¢ñÑš$Ȱ¿ΰüɵdÄ̵ š û½²Åš 
£ñÑš$óµ¿üöºeÌùº š û½²Åš œ»š
¤ñÑš$¡»¿¯»ü•Àmì˜À š ûÁ²Åš ¿Àš
¥ñÑš$ÄÀ¿ÒÀü¸Áoô»Á˜ š ˜ûÁ²Åš ãÁš
¦ñÑš$èÁ_astÁ$öÁü˜Ämt›Ä슻Ÿ»ŸìŠ¥¨¨ÚŠ ªÄ
§âŠ 4²Ä÷$ÉÄtoÁãÄ+-üC>
This module provides a regular expression printer for `Ast`.
Áö
ð
ú
×O `©ª¿$k
©¬ï#$ã©®œ$<…ê©¯îŒ ©°LIfTYW`üY#M<u>@,.üòéš²´²ô˜<›éš±±
²œàéš´µÔúý©éš³³
´ÔÇ© éš´›³ г
µd‚ ´›·¸¼³ Ì•  Create a new printer.Áº ´›
·ü‘ Hüþ HE Print the given `Ast` to the given writer. The writer must implementÁüË
JG `fmt::Write`. Typical implementations of `fmt::Write` that can be usedÁüš EB here are a `fmt::Formatter` (which is available in `fmt::Display`Áüä (% implementations) or a `&mut String`.Á,˜ š š´› ¬©˜œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ È¦€ éBL¨¹¹ ­ Í옜 ž êb˜œ 
¸˜œ ¿¸ ‡€à 57üÄ
)¨»»Ò— É
ã—
雼½¾¿ÀÁÂÃÅëìíïðñóô÷ÅÿÁÂÀ¾km

ºººº„—ô¦é›³–ºº
¾˜œüá1œ œé› ¬©³–º îº
¿˜œ¿ùüÛ2žŸ žé› Ÿ¬©³–º éº
À˜œ¿ôüÓ1¤Ö   é›³–º ëº
Á˜œü²oĵ¡¢ ¡é› ¢û½Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
é›ìº ׺
˜œ¿êüÚpÌÝ£¤ £é› ¤û½¹º º
Øœ$…¿ÄÙü¼wä¿¥¦ ¥é› ¦ûÁ¹º åº
Řœ¿øìô ¨ÇÇÒ— ù ã—é›ÈÊËÍÏÑÓÔØÙÚÜÞà:<ü˜!<l!©§¨ §é› ¨Ê˳–Æ ©!Æ
Șœ$®!¿´!¬ã!üÛ&>tÞ&©©ª ©é› ªÊ˳–Æ í&Æ
ʘœ$ò&éŒ$ø&üÇ'BtÊ'©«¬ «é› ¬›Ç³–Æ Ù'Æ
˘œ$Þ'¿ä'Ô˜(ü–-d¤™-©­® ­é› ®¤Ê³–Æ ·-Æ
͘œ$¼-¿Ê-܉.ü€0<\ƒ0©¯° ¯é› °“®³–Æ 0Æ
Ϙœ$”0¿š0¼Ë0üŠ?@l?©±² ±é› ²“ij–Æ ›?Æ
јœ$ ?¿¦?ÌÙ?üôE?l÷E©³´ ³é› ´Úγ–Æ …FÆ
Ó˜œ$ŠF¿FüºG8L½G©µ µé› Èϳ–Æ ÇGÆ
Ô˜œ$ÌG¿ÒGTH$ŽHl”HüüMf¼ÿM©·¸ ·é› ¸‚¼³–Æ  NÆ
ؘœ$¥N¿³NüíOhÄðO©¹º ¹é› º‚¼³–Æ ’PÆ
Ù˜œ$—PéŒ$¥PüƒQqä†Q©»¼ »é› ¼û³–Æ ¬QÆ
Ú˜œ$±Q¿¿QüƒR üùSAtüS©½¾ ½é› ¾±³³–Æ ‹TÆ
ܘœ$T¿–TÌÉTüàWC|ãW©¿À ¿é› À«µ³–Æ óWÆ
Þ˜œ$øW¿þWÔ²XüÇfGŒÊf©Á Áé› Âำ–Æ ÜfÆ
à˜œ$áf¿çfägôÊg
êøúþŒšÁ
÷<ãåÁãåö
ªBãæ¿$.
ãèîŒ4
 ãé,
ceD
CT!
4(
%'Υ
ü;L
I A trait for visiting an abstract syntax tree (AST) in depth first order.Áˆ
úüŒH
E The principle aim of this trait is to enable callers to perform caseÁüÕL
I analysis on an abstract syntax tree without necessarily using recursion.矢O
L In particular, this permits callers to do case analysis with constant stackÁüòK
H usage, which can be important since the size of an abstract syntax treeÁü¾*
' may be proportional to end user input.Áé
úüíM
J Typical usage of this trait involves providing an implementation and
üè @
= This method is called before beginning traversal of the AST.Á,°
à ÃÞ·ê
ê
îÞ·
ü¥ <
üÉ
H
E This method is called on an `Ast` before descending into child `Ast`ÁT
 nodes.ÁL¨
ÄÅ ÄÞ· Ŭ©Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
â¸ê ²
ê
ïÞ·
éŒ
üß =
üþ G
D This method is called on an `Ast` after descending all of its childÁ„Ê
`Ast` nodes.ÁTâ
ÆÇ ÆÞ· Ǭ©·¿ê í
ê
ðÞ·
éŒ
üœ;
ü¹
3
0 This method is called between child nodes of anÁüñ
&
# [`Alternation`](ast::Alternation).Á¤Ÿ
È ÈÞ··¿ê ´
ê
ñÞ·
üº6
üôA
> This method is called between child nodes of a concatenation.Á|½
É ÉÞ··¿ê Í
ê
òÞ·
ü„p
üF
C This method is called on every [`ClassSetItem`](ast::ClassSetItem)矯'
$ before descending into child nodes.Áć
ÊË ÊÞ· Ëû½·¿ê ©
ê
óÞ·
éŒ
ü‡q
ü‘F
”ÄüÜ&
# after descending into child nodes.ÁÌŠ
ÌÍ ÌÞ· Íû½·¿ê ­
ê
ôÞ·
éŒ
üœy
ü•"
 This method is called on everyÁü¼F
C [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) before descending intoÁ„‡
child nodes.ÁìŸ
ÎÏ ÎÞ· ÏûÁ·¿ê Æ
ê
õÞ·
éŒ
ü¸z
ü²"
½ÇüÙK
H [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) after descending into childÁ
ï½ô»
ÐÑ ÐÞ· ÑûÁ·¿ê ã
ê
öÞ·
éŒ
üØx
üÏJ
G This method is called between the left hand and right hand child nodesÁüž5
2 of a [`ClassSetBinaryOp`](ast::ClassSetBinaryOp).ÁäÛ
ÒÓ ÒÞ· ÓûÁ·¿ê 
ê
÷Þ·$†
éŒ$”
üº L
üëD
A Executes an implementation of `Visitor` in constant stack space.Á°
úü´L
I This function will visit every node in the given `Ast` while calling theÁü:
7 appropriate methods provided by the [`Visitor`] trait.Á¼
úüÀJ
G The primary use case for this method is when one wants to perform caseÁü‹O
L analysis over an `Ast` without using a stack size proportional to the depthÁüÛO
L of the `Ast`. Namely, this method will instead use constant stack size, butÁü«J
G will use heap space proportional to the size of the `Ast`. This may beÁüöJ
G desirable in cases where the size of `Ast` is proportional to end userÁ
 input.ÁÌ
úüÐN
K If the visitor returns an error at any point, then visiting is stopped andÁÔŸ
 the error is returned.Á,Á
Ô Ô¬©§Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
žÕëžÕì§ùù Ø
ÍìžÕ Ç
êžÕ
øžÕ¿Ó
ï#<Þ
-/´Æ"
\Í"
ãÉ%ûûúú¶%üÓ%ãýà%ã
ÛHòsÞˆÉ%
ÛHòsÞˆüýÙ"
üÜ#
,Ü#
ãúúªBªBö­Bá«÷<®B÷<9)
-ÜnL É%¬©þˆ&ˆãƒ§&ˆãÁ&Ï&ãˆÛ&ãç&ŠÏ&ãÛ&ãÉ
þÉ%‘‹ü¬%3
\¬%
ãúúªBªBö­Bá«÷<®B÷<9)
-ÜnLã°œ‘‹tÁ&
,Æ&
ãÉ%ÿÿÍØÉ
þƒ É%›ÇÍØ É%ÊËÍØˆŠÌ&
ãþþ
É%ã›ÛÍØþþøÛœÉ'
ãþþ›ÛÔªÙªãþþ
É%øªûªã·ÛÍØþþñÜtÃ(
ãþþ·Û4À)
ãþþÍØl‡*
$‡*
ãþþÃØ|ã*
$ã*
ãþþ É%
¬©\æ+
ãþþÍØl²,
$²,
ãþþÃØ|Ž-
$Ž-
ãþþ¢Þœ.
T”.
ãÉ%°œöûMœìM±Ž˜Ÿ.
,“/
㌌°œÜÙ/
$Ù/
㌌ É%û½ìÃ0
$Ã0
㌌ É%
û½4ª1
㌌°œì³1
³1
㌌ É%ûÁLÆ2
㌌°œìÚ2
Ú2
㌌á´3
3
㌌ É%ú¼´¡3
¡3
㌌ÜáL³4
㌌°œì¿4
¿4
㌌á´Þ4
Þ4
㌌Üᤋ9
\9
ãÉ%ãß8Þ–œŸ žžàã ¡áãœ9
í­ò­ãšš
É%®®ãžàãššÝ㬫9
ãššžàÇ­Ì­ãšš
 É%ë­î­ãáãššÖäÌÐ9
ãššáÄï9
É%££Ž×¤¥§©ª¬®°±ô9
ÜŽ:
:
ãŽ×¢¢
¤É%üò:}
,õ:
ãÕ ÕŽ×ÃØ§Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
îæëîæì¢§¦¦ ;
¢Íìîæ û:
êîæ<þ:
¥É%îæ$•;
¿§;
ï#<Á;
:<üéKƒ
4ìK
ãÖ× ÖŽ×ÃØ ×îæÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍØÌ碧¨¨ ˆL
¢ûç óK
Œè<öK
§É%îæ$L
¿L
ï#<±L
24ü¿S5
ÂS
ãØ ØŽ×ÍØçé¢ ÆS
¢
©É%$ÇS
“)4ÍS
ü¡Y‰
\¤Y
ãÙÚ ÙŽ× É%‚¼ ÚîæÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ì碧«« ÅY
¢ûç °Y
Œè<³Y
ªÉ%îæ$ÊY
¿ØY
ï#<þY
24ü®f
|±f
ãÛÜÝ ÛŽ× Üã ÝîæÕ좧­­ Öf
¢ûç Áf
Œè<Äf
¬É%îæ$×f
¿åf
ï#<„g
24ü™jƒ
„œj
ãÞßà ÞŽ× ßã àîæÕ좧¯¯ Âj
¢ûç ­j
Œè<°j
®É%îæ$Ãj
¿Ñj
ï#<ðj
24üÚnG
dÝn
ãáâ áŽ× âãÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ°œ¢ ên
¢
°É%$ën
¿ñn
üìwE
Lïw
ãã ãŽ×°œÞñ¢ ùw
¢
±É%$úw
“)4€x
”ù|
É%³³ÍØ´þ|
Ôý}
,€~
ãä äÍØÃØ² †~
²
´É%$‡~
¼‡€
É%°œ·Œ€
ü’"
,•
ãå 尜㵠
µ
·É%
ÄÏ„
É%¹¹ãº»Ô„
üî„B
tñ„
ã¾ì㸸
ºÉ%¿€…
üç…6
Dê…
ãÜá㸸
»É%¿ó…
ü؇,
É%½½°œ¾Àc¾݇
ü‹ˆD
Žˆ
æçè æ°œ ç c cˆ¢cµ
 `£cá« `àB¤GS
è³–¼ ’ˆ
¼
¾É%$“ˆ
± ™ˆ
üóŠ-
É%ÀÀãÁÀcÁøŠ
ü§‹D
ª‹
éêë éã ê c cˆ¢cµ
 `£cá« `àB¤GS
ë³–¿ ®‹
¿
ÁÉ%$¯‹
± µ‹
¾žÃÄÅÆü´ ü" Return the type of this error.Á$»ì 쾞 컟 ÀÂ
ÃìŽ
üõ=: The original pattern string in which this error occurred.Á· úü¿ JG Every span reported by this error is reported in terms of this string.Á<•
í í¾ž íÂ
Â
Ä
Ü… üÏ
1. Return the span at which this error occurred.Á$Œ î   Â
Å$’ ü¦-üÁ HE Return an auxiliary span. This span exists only for some errors thatÁüŽ EB benefit from being able to point to two locations in the originalÁüØ EB regular expression. For example, "duplicate" errors will have theÁü¢
A> main error position set to the duplicate occurrence while itsÁüè
96 auxiliary span will be set to the initial occurrence.Át­ï ゙ۼݼÞ¼©ß¼à¼ÛἈcSñŸ«‡z٠ ¼Â
ÆüŒ? »À|ú>¼ô>¾žü±?!¾žÊÅcÊüÙ?DÜ?ðñò 𾞠ñ c cˆ¢cµ
 `£cá« `àB¤GS
ò³–É à?É
Ê$á?± ç?üÜ@%»ŸÌÅcÌüˆAD‹Aóôõ ó»Ÿ ô c cˆ¢cµ
 `£cá« `àB¤GS
õ³–Ë AË
Ì$A± –A|ÛAôŸgˆ¥ÏÀcÏüÄgDÇgö÷ø öˆ¥ ÷ c cˆ¢cµ
 `£cá« `àB¤GS
ø³–Î ËgÎ
Ï$Ìg± ÒgŒÐhˆ¥Ñ»Ñüèh'ëhùú ùˆ¥ úˆ¥¿ßÀßÁßLessÁÂßÃßÄß~Å߯ßÇßGreaterÁÈßåºÝÈnûê7Ð ïhÐ
Ñ$ðh¹
,öhÄÝiˆ¥ÓïßÓüüi7\ÿiûü ûˆ¥ üˆ¥Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙê‰Ò ‹jÒ
Ó$Œj¹
,jü£o"§¦ÕÀcÕüÌoDÏoýþÿ ý§¦ þ c cˆ¢cµ
 `£cá« `àB¤GS
ÿ³–Ô ÓoÔ
Õ$Ôo± Úo¬¨q§¦×»×üÄq+Çq §¦ §¦ê‰Ö ËqÖ
×$Ìq¹
,Òqä¢r§¦ÙïßÙüÅr;\Èrƒ §¦ ƒ§¦Ö‹Ø ÔrØ
Ù$Õr¹
,ÛrLªsˆ¥ÛÜÝÞßàüîs2üºs/, Create a new span with the given positions.Áõs§¦§¦ˆ¥ÚÚ
Û¹,ùsþŠtü“u#üÊtDA Create a new span using the given position as the start and end.Á,šu§¦ˆ¥ÚÚ
ÜÈ uü½v.üàuIF Create a new span by replacing the starting the position with the oneÁT®v given.ÁTÄvˆ¥§¦ˆ¥ÚÚ
Ý$ÏvÈÕvüøw,üwGD Create a new span by replacing the ending the position with the oneÁTéwÐ’Dÿwˆ¥§¦ˆ¥ÚÚ
Þ$ˆxÈŽxü›y!üÔxB? Returns true if and only if this span occurs on a single line.Á\¢y ˆ¥Ú ®yÚ
ß$¯yô‹{üóyIF Returns true if and only if this span is empty. That is, it points toÁüÁzEB a single position in the concrete syntax of a regular expression.ÁD{ ˆ¥Ú ›{Ú
à$œ{lâ{§¦âüÎ~Aüö{52 Create a new position with the given information.Á°|úü¸|IF `offset` is the absolute offset of the position, starting at `0` fromÁü†};8 the beginning of the regular expression pattern string.ÁÆ}úüÎ}/, `line` is the line number, starting at `1`.Á~úüŠ~?< `column` is the approximate column number, starting at `1`.ÁÕ~§¦áá
âž
4Ù~š$è~4õ~Dû“¬©äåæçèéêëìíîïðñòü®”üŠ” Create an "empty" AST item.Á,µ”ˆ¥¬©ãã
äã$»”ü¡• ôþ” Create a "flags" AST item.Á,¨•Úά©ãã
å° ®•ü”–!üï•  Create a "literal" AST item.Á<›–“®¬©ãã
æ° £–솗äå– Create a "dot" AST item.Áˆ¥¬©ãã
çã$‘—üù—%üÒ—" Create a "assertion" AST item.ÁL€˜“Ĭ©ãã
è° Š˜üû˜,üИ&# Create a "Unicode class" AST item.Ál‚™à¸¬©ãã
é° ü„š&üÜ™# Create a "Perl class" AST item.ÁT‹š±³¬©ãã
ê° –šü‰›0üÜš(% Create a "bracketed class" AST item.Á|‚¼¬©ãã
ë°  ›ü˜œ'üð›# Create a "repetition" AST item.ÁTŸœ›Ç¬©ãã
ì° ªœì•ôòœ Create a "group" AST item.Á,œÊˬ©ãã
í° ¢ü‰ž)üà$! Create a "alternation" AST item.Á\ž·¬¬©ãã
î° œžüŠŸüæž Create a "concat" AST item.Á4‘Ÿ¥­¬©ãã
ï° ˜ŸÜŽ üØŸ1. Return the span of this abstract syntax tree.Á$•  ¬© ˆ¥ã š ã
ð$› ô©¥üó¤1. Return true if and only if this Ast is empty.ÁD°¥ ¬©ã ¹¥ã
ñ$º¥ô˜§d›§
ˆ ˆ¬©ã ¨§ã
ò$©§ü¶­üåª/, Print a display representation of this Ast.Á•«úü™«MJ This does not preserve any of the original whitespace formatting that mayÁüç«KH have originally been present in the concrete syntax from which this AstÁ”³¬ was generated.ÁƬúüʬMJ This implementation uses constant stack space and heap space proportionalÁ옭 to the size of the `Ast`.Á¬©ôÅcôüÜ­Dß­Š ¬© Š c cˆ¢cµ
 `£cá« `àB¤GS
³–ó ã­ó
ô$ä­± ê­Ô¯®<®„¦±·¬÷üγ ü½±&# Return this alternation as an AST.Áè±úüð±JG If this alternation contains zero ASTs, then `Ast::empty` is returned.Áü¿²JG If this alternation contains exactly 1 AST, then the corresponding ASTÁü޳;8 is returned. Otherwise, `Ast::alternation` is returned.ÁDÕ³·¬¬©öö
÷$â³\η¥­ùüî¹ üà·(% Return this concatenation as an AST.Á¸úü•¸Jʯüä¸JŸ°ü³¹63 is returned. Otherwise, `Ast::concat` is returned.ÁDõ¹¥­¬©øø
ù$‚ºdÍ¿“®ûüòÀ üà¿GD If this literal was written as a `\x` hex escape, then this returnsÁü¬ÀA> the corresponding byte value. Otherwise, this returns `None`.Á$ùÀŒ Œ“®Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙú þÀú
û$ÿÀœÈÖ°²ýÜžØüâÖFC The number of digits that must be used with this literal form whenÁü­×?< used without brackets. When used with brackets, there is noÁüñ×(% restriction on the number of digits.Á4¥Ø °²ü ¬Øü
ý$­Øœú棶ÿüáé6ü”çGD Return the corresponding ClassAsciiKind variant for the given name.ÁàçúüèçDA The name given should correspond to the lowercase version of theÁü±èHE variant name. e.g., `cntrl` is the name for `ClassAsciiKind::Cntrl`.Áþèúü†éDA If no variant with the corresponding name exists, then `None` isÁlÏé
returned.ÁLèéŽ ŽÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ£¶þ øéþ
ÿÐ $ò餦êŒÅõà¸ü­÷ üÝõ0- Returns true if this class has been negated.Á’öúüšöFC Note that this takes the Unicode op into account, if it's present.ÁüåöC@ e.g., `is_negated` for `\P{scx!=Katakana}` will return `false`.ÁT´÷ ภ¿÷
$À÷¼Ìª‚»ô›«üêª,) Whether the op is an equality op or not.ÁD¢« ‚»ƒ ««ƒ
$¬«lϵú¼ˆü…¶,ìãµ Build a set from a union.Á,Œ¶ŒÁú¼
¿’¶Ü¥·üð¶0- Return the span of this character class set.Á$¬· ú¼ ˆ¥ ±·
$²·Ô‹¹D޹
 ú¼ —¹
ˆ$˜¹ŒÐÂû½ŠÜ¢ÃüèÂ52 Return the span of this character class set item.Á$©Ã û½ ˆ¥ ®Ã
Š$¯Ã”ÝÉ•ÀŒô§ËüöÉDA Returns true if and only if this character class range is valid.Á¿ÊúüÇÊJG The only case where a range is invalid is if its start is greater thanÁd–Ë its end.ÁD®Ë •À ·Ë
Œ$¸Ë”õÎŒÁŽüŒÓ*üŽÏ" Push a new item in this union.ÁµÏúü½ÏEB The ending position of this union's span is updated to the endingÁü‡ÐGD position of the span of the item given. If the union is empty, thenÁüÓÐGD the starting position of this union is set to the starting positionÁŒŸÑ of this item.ÁµÑúü½ÑGD In other words, if you only use this method to add items to a unionÁü‰ÒGD and you set the spans on each item correctly, then you should neverÁüÕÒ2/ need to adjust the span of the union directly.Á$“Ó ŒÁû½ ˜Ó
Ž$Ó÷$£Óü“×*üêÔ41 Return this union as a character class set item.Á£Õúü«Õ=: If this union contains zero items, then an empty union isÁüíÕEB returned. If this concatenation contains exactly 1 item, then theÁü·ÖEB corresponding item is returned. Otherwise, ClassSetItem::Union isÁl×÷»Lš×ŒÁû½
$¨×¤Èô¤Êô¬öüãô?< Returns true if and only if this repetition range is valid.Á§õúü¯õIF The only case where a repetition range is invalid is if it is boundedÁüýõ*' and its start is greater than its end.ÁD³ö ¤Ê ¼ö
$½öTüÊËü¤ý%ü üJG If this group is non-capturing, then this returns the (possibly empty)Áüïü0- set of flags. Otherwise, `None` is returned.Á,«ý ÊËÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ÈÏ ±ý
$²ýüŽÿ"üÑþ85 Returns true if and only if this group is capturing.Ád•ÿ˜ ˜ÊË ¢ÿ
$£ÿüˆ‚*üã€JG Returns the capture index of this group, if this is a capturing group.Á²úüºIF This returns a capture index precisely when `is_capturing` is `true`.Ál ÊËÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ 
$ž‚Tˆ˜ÈϘüŽš<ü™˜1. Add the given item to this sequence of flags.ÁϘúüטGD If the item was added successfully, then `None` is returned. If theÁü£™@= given item is a duplicate, then `Some(i)` is returned, whereÁüè™! `items[i].kind == item.kind`.Á
 `£cá« `àB¤GS
¡³–© µ©
ª± ¼×ªªìãÉ%®®ÈÔgG>㋹Á­¯ É%ªáÈÔNÅîÈÔ¬¬
­É%ç œë ¬¬Åîü‚
'É%±±ÈÔ²Àc²
ü°
@³
¢£¤ ¢ÈÔ £ c cˆ¢cµ
 `£cá« `àB¤GS
¤³–° ·
°
²É%$¸
± ¾
üŠC¥ ¥ªáÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 «
³ä»üÔ!×¥§Ý
´Ë/$ÛTž? 4¢? Lª? ,®? Ò⡱formatÁ4¸ß4&úHºô†D.—6»Á=÷<¼Á¼öKªB½¿`
¿ø6eãÀ,Ÿ¡ürtDFR,XCE46ü¡—ÖÂëÂüÇ!¾ž—ÖÁÁ
¸ÏüŽ—ÖÄëÄü´!­×—ÖÃÃ
ĸ¼ü— »À|…¼ÿ—Öü¼!—ÖÇÅcÇüäD禧¨ ¦—Ö § c cˆ¢cµ
 `£cá« `àB¤GS
¨³–Æ ëÆ
DZ òü?¸4ÉÉøØÊëÊüÕ$ÖÙøØÈÈ
ʸ4¸Ýü®?¸4ÌÌèÙÍëͳüô$ÏÛèÙËË
͸4¸üü½G¸4ÏÐÐÏÍìëØ ÆÄcëØ”É‘ØÑÅcÑÂ)+ü‹DŽ©ª« ©‘Ø ª c cˆ¢cµ
 `£cá« `àB¤GS
«³–Î Î
Ѹ4ëØ$“± „¿",Æ"ñÓÓÒÒü4Ô¹Õ™5Ö²5×Á5sÏsùxl“
ñsÏsùxl“
ÔÕÖ×Ì"#<#ÒÒ ñÄ¡%Œ¡%ÒÒäÝ'<Ý'ÒÒªBªBö­Bá«÷<®B÷<9)
-ÜnLªBªBö­Bá«÷<®B÷<9)
-ÜnLˆ¥‘‹‘‹ÔÀ)TÀ)ÒÒÂÿ”ß)ñÙÙ¸ýÚÝÞßàáä)ü¬*et¯*Û ñ±±ˆ´¹µ¸ã·”¸g@„nòìÕ¥ÛëØ¸ýØÜܾ*Ø“û Â*¤û”Å*
ÚñëØfmterÁ,â*57,.ü…2"ˆ2¬ ¬¸ýˆ¥Ø Œ2Ø
Ýñ$‘2ã$—2Ôë64î6­ ­¸ýÅšØ õ6Ø
Þñ$ö6üá=1\ä=® ®¸ýÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÅšØ ð=Ø
ßñ$ñ=´ ÷=üD2¤’D¯ ¯¸ýÅšØ §DØ
àñ$¨D¹ ®DüèG&œëG° °¸ýØ ÿGØ
áñ$€Hü“I/\IÅš
â® ¢Iü,«I\µ? üîé
Defines a high-level intermediate (HIR) representation for regular expressions.
The HIR is represented by the [`Hir`] type, and it principally constructed via
[translation](translate) from an [`Ast`](crate::ast::Ast). Alternatively, users
may use the smart constructors defined on `Hir` to build their own by hand. The
smart constructors simultaneously simplify and "optimize" the HIR, and are also
the same routines used by translation.
Most regex engines only have an HIR like this, and usually construct it
directly from the concrete syntax. This crate however first parses the
concrete syntax into an `Ast`, and only then creates the HIR from the `Ast`,
as mentioned above. It's done this way to facilitate better error reporting,
and to have a structured representation of a regex that faithfully represents
its concrete syntax. Namely, while an `Hir` value can be converted back to an
equivalent regex pattern string, it is unlikely to look like the original due
to its simplified structure.
Á½? û¼ÊìêêëìíîŽß쯰¹ÇÒÓÙëö÷ýÑÞ슬¹ÿ­1ãåãæÚ‰ ãèèòãéßúHãëô†—6ãìÁÕ÷<ãíÁãíöãªBã$‚ Ü ãðÂ:Dœ œãòÁ¸¼ãóœ¹Æãô»O<É Š ãõ¡%,ú  ûøœ$<
òùîÛl˜
ØúbeSVT™K8;üŒ/.1!ñ,ðåüð)×ÙÅdzµ¢¤,Þ ÌÞ ´
€d«

㜪¼ÆÇÿ$ ­1ûýûþp,¿cûÿpÂcûÿž,"‰fûö;ªBû»O<LŠ û$ŠŒz|TnIK|/<tE-ü“'šÍì¨Ü ˜œ¨ÜD›ìÛüö.šÄ• ûÕ•ìÛ·ßü«,®±² ±ìÛ ²ìÛ ±
¨Ü¹
ü‰ šÄ• ŽÕ•D‘ìÛŠŒŽ46üªE±¥ìÛˆ¥ˆÍ춘 µÇL¶˜´¸¶˜ÈL¨Ü
Ѝܶ˜ø8LÐ<>ü‘'$˜³ ³ìۨ܈ ˆ
Œ¨Üö7D¬ü*,$—*´ ´ìÛÆÆÇœ¹Êˆû Í@Ķ´¨Üˆ œ*ˆ
¨Ü$*üò+Lù+µ µìÛ µ
¨Üˆ ƒ,ˆ
ލÜ$„,üš/H„¡/ ìÛÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ƒˆ ²/ˆ
¨Ü$·/ü¹3/,À3·¸ ·ìÛ ¸ìÛˆ Æ3ˆ
¨Ü$Ë3¹
,Ñ3üÍ63LÔ6¹º ¹ìÛ ºìÛˆ Þ6ˆ
¨Ü$ã6¹
,é6üÅA4TÌA»¼ »ìÛ ¼ìÛˆ ×Aˆ
¨Ü$ÜA¹
,âAü½f>¤Äf½¾ ½ìÛ ¾ìÛˆ Ùfˆ
¨Ü$Þf¹
,äfÄj4j¿ ¿ìÛˆ jˆ
¨Ü$¢jÔ±|d´|ûÀ ÀìÛˆ Á|ˆ
¨Ü$Æ|ô€…dƒ…ûÁ ÁìÛˆ ˆ
¨Ü$‘…ü„ˆ/É%˜š˜Íì”Ý ˆÛÜšúMûM‰ˆ"$Lºˆ$¿ˆ É%”ÝüÒˆ#$Ո ÂÛÜÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙš¤ Úˆ
É%”Ý$߈ü—‰ZD¡‰œœ Ö·ü—‰³ØÞ·,¯‰Š Þ·$·‰¿cÞ·,¾‰³Þ·<ƉÞ·ЉµßÞ·Þ·LÕ‰íßÞ·Þ·Tቺ޷ַ­þ¥ ¦ ¦б¦¦tÓ¦dé¦Tÿ¦IÖ·ãþ¥Ö¦Ë ¦À±¦µÂ¦ªÓ¦šé¦Šÿ¦žŸ ¡¢£¤¥¦§¨©žŸ ¡¢£¤¥¦§¨©ÍìÞ·”ø‰ªɨ,„ŠÁ¨Ú¨ ¥©¡¨¤ §£Ÿ¦¢žŒø‰,ý‰œœüŠ,“ŠÃ ÃÞ·ɨœ ™Šœ
žÞ·$šŠü´Š,·ŠÄ ÄÞ·ɨœ ½Šœ
ŸÞ·$¾ŠüØŠ,LÛŠÅ ÅÞ·ɨœ 劜
 Þ·$êŠboundÁ,ðŠü‰‹,LŒ‹Æ ÆÞ·ɨœ –‹œ
¡Þ·$›‹êª,¡‹üº‹s„½‹ÇÈ ÇÞ· ȪBªBö­Bá«÷<®B÷<9)
-ÜnLÞ·‘‹Åœœ ׋œ
¢Þ·$Ø‹ø8Læ‹üÒŒ94ÕŒɨɨÞ·œœ
£Þ·ß:,ÜŒì:,ðŒü•-ÉÊ ÉÞ· ÊÞ·Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÞ·œ žœ
¤Þ·¹
üË“1LΓËÌ ËÞ· ÌÞ·µ¯œ Ø“œ
¥Þ·$Ù“¹
,ß“ü³—BT¶—ÍÎ ÍÞ· ÎÞ·µ¯µ¯œ Á—œ
¦Þ·$—¹
,È—üÇ -lÊ ÏÐ ÏÞ· ÐÞ·œ Ø œ
§Þ·$Ù ¹
,ß üì£5¬ï£ÑÒ ÑÞ· ÒÞ·œ …¤œ
¨Þ·$†¤¹
,Œ¤ü¶¦)L¹¦ÓÔ ÓÞ· ÔÞ·œ æœ
©Þ·$Ħ¹
,ʦų̈M,Ö¨ªªÖ·ų̈å¦$á¨þ¥,訠¦,ð¨¦ø¨Ó¦Lý¨é¦T‰©ÿ¦–©ªÖ·Z¦Uþ¥R ¦O¦LÓ¦Ié¦Fÿ¦CÖ·Цþ¥ ¦¦|Ó¦yé¦vÿ¦¬­®¯«¬­®¯®¬¯­«¼ ©L£©Þ·ªª
«Þ·¼¼©L¿©Þ·ªª
¬Þ·¼Ø©4Û©Þ·ªª
­Þ·$â©Üô©L÷©Þ·Þ·ªª
®Þ·$ªÜ”ªL—ªÞ·Þ·ªª
¯Þ·$¡ªŒ³ª±²³´µ«¬­®¯²µ±³´´ËªLΪ°°
±´þªL«°°
²´±«4´«°°
³$»«Ôì«Lï«°°
´$ù«Ô¸¬L»¬°°
µ$Ŭœƒ­·¸¹º»«¬­®¯»¹·º¸´­L ­
·´Ï­LÒ­
¸´‡®4Š®
¹$‘®ÔîLÆ®
º$ЮÔ€°Lƒ°
»$°
üŽ
Provides literal extraction from `Hir` expressions.
An [`Extractor`] pulls literals out of [`Hir`] expressions and returns a
[`Seq`] of [`Literal`]s.
The purpose of literal extraction is generally to provide avenues for
optimizing regex searches. The main idea is that substring searches can be an
order of magnitude faster than a regex search. Therefore, if one can execute
a substring search to find candidate match locations and only run the regex
search at those locations, then it is possible for huge improvements in
performance to be realized.
With that said, literal optimizations are generally a black art because even
though substring search is generally faster, if the number of candidates
produced is high, then it can create a lot of overhead by ping-ponging between
the substring search and the regex search.
Here are some heuristics that might be used to help increase the chances of
effective literal optimizations:
* Stick to small [`Seq`]s. If you search for too many literals, it's likely
to lead to substring search that is only a little faster than a regex search,
and thus the overhead of using literal optimizations in the first place might
make things slower overall.
* The literals in your [`Seq`] shouldn't be too short. In general, longer is
better. A sequence corresponding to single bytes that occur frequently in the
haystack, for example, is probably a bad literal optimization because it's
likely to produce many false positive candidates. Longer literals are less
likely to match, and thus probably produce fewer false positives.
* If it's possible to estimate the approximate frequency of each byte according
to some pre-computed background distribution, it is possible to compute a score
of how "good" a `Seq` is. If a `Seq` isn't good enough, you might consider
skipping the literal optimization and just use the regex engine.
(It should be noted that there are always pathological cases that can make
any kind of literal optimization be a net slower result. This is why it
might be a good idea to be conservative, or to even provide a means for
literal optimizations to be dynamically disabled if they are determined to be
ineffective according to some measure.)
You're encouraged to explore the methods on [`Seq`], which permit shrinking
the size of sequences in a preference-order preserving fashion.
Finally, note that it isn't strictly necessary to use an [`Extractor`]. Namely,
an `Extractor` only uses public APIs of the [`Seq`] and [`Literal`] types,
so it is possible to implement your own extractor. For example, for n-grams
or "inner" literals (i.e., not prefix or suffix literals). The `Extractor`
is mostly responsible for the case analysis over `Hir` expressions. Much of
the "trickier" parts are how to combine literal sequences, and that is all
implemented on [`Seq`].
Á
ÉÏÛäíû ¼¾í¥ë¼¿ NonZeroUsizeÁd¯²–¼ÀÁË÷<¼ÂÁ¼ÂöÕªB¼Ãø6$íã¼Å–Æó¼Æ$™µ·¤¦Œª‹,Ã{}DÐ[TàLç<>të2¿ÝÈÉËÌÍÎÏÐÓÖרÙÚÛÝàÌÁ4ü€385 Create a new extractor with a default configuration.Á½3úüÅ3=: The extractor can be optionally configured before callingÁü‡452 [`Extractor::extract`] to get a literal sequence.ÁÈ4¿ÝÇÇ
Èüë6'üª6<9 Execute the extractor and return a sequence of literals.Á<ò6ÕÖ Õ¿Ý ÖñêßÇ ú6Ç
É$û6ø67œ¡7üæI;ü›AKH Set the kind of literal sequence to extract from an [`Hir`] expression.ÁëAúüóADA The default is to extract prefixes, but suffixes can be selectedÁü¼BA> instead. The contract for prefixes is that every match of theÁü‚CKH corresponding `Hir` must start with one of the literals in the sequenceÁüÒCKH returned. Moreover, the _order_ of the sequence returned corresponds toÁÌ¢D the preference order.ÁÀDúüÈDB? Suffixes satisfy a similar contract in that every match of theÁüEIF corresponding `Hir` must end with one of the literals in the sequenceÁüÝEEB returned. However, there is no guarantee that the literals are inÁ¬§F preference order.ÁÁFúüÉFEB Remember that a sequence can be infinite. For example, unless theÁü“GJG limits are configured to be impractically large, attempting to extractÁüâGJG prefixes (or suffixes) for the pattern `[A-Z]` will return an infiniteÁü±HGD sequence. Generally speaking, if the sequence returned is infinite,ÁüýHKH then it is presumed to be unwise to do prefix (or suffix) optimizationsÁ¤ÍI for the pattern.Á$íI× ×¿Ý»ÞÉåÇ òIÇ
Ë$÷I$ýIüÖS=üÖJIF Configure a limit on the length of the sequence that is permitted forÁü¤KHE a character class. If a character class exceeds this limit, then theÁüñK)& sequence returned for it is infinite.ÁŸLúü§LHE This prevents classes like `[A-Z]` or `\pL` from getting turned intoÁüôL74 huge and likely unproductive sequences of literals.Á°Múl¸M
# ExampleÁÊMúüÒMNK This example shows how this limit can be lowered to decrease the toleranceÁü¥N>; for character classes being turned into literal sequences.ÁèNú<ðN ```ÁüüN>; use regex_syntax::{hir::literal::{Extractor, Seq}, parse};Á¿OúüÇO let hir = parse(r"[0-9]")?;ÁëOúüóO-* let got = Extractor::new().extract(&hir);Áì¥P let expected = Seq::new([ÁüÇP96 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",Á<…Q ]);Áô‘Q assert_eq!(expected, got);Á´Qúü¼QB? // Now let's shrink the limit and see how that changes things.ÁüƒR<9 let got = Extractor::new().limit_class(4).extract(&hir);ÁüÄR# let expected = Seq::infinite();ÁôìR®ìSúü—S.+ # Ok::<(), Box<dyn std::error::Error>>(())Á<ÊSåé\ÝSØ Ø¿Ý“ðÇ éSÇ
Ì$îSú¡,ôSüº^>üÐTJG Configure a limit on the total number of repetitions that is permittedÁüŸU)& before literal extraction is stopped.ÁÍUúüÕUB? This is useful for limiting things like `(abcde){50}`, or moreÁüœVGD insidiously, `(?:){1000000000}`. This limit prevents any one singleÁüèV:7 repetition from adding too much to a literal sequence.Á§Wúü¯WKH With this limit set, repetitions that exceed it will be stopped and anyÁüÿW=: literals extracted up to that point will be made inexact.ÁÁXúlÉX—èÛXúüãXJG This shows how to decrease the limit and compares it with the default.Á²Yú<ºYåéüÆYGD use regex_syntax::{hir::literal::{Extractor, Literal, Seq}, parse};ÁZúüšZ" let hir = parse(r"(abc){8}")?;ÁÁZúüÉZ-ÿêüûZ:7 let expected = Seq::new(["abcabcabcabcabcabcabcabc"]);Áôº[®ìÝ[úüå[Bâìü¬\=: let got = Extractor::new().limit_repeat(4).extract(&hir);Áüî\# let expected = Seq::from_iter([Áü–])& Literal::inexact("abcabcabcabc"),Á<Ä]žìôÐ]®ìó]úüû].ºî<®^åédÁ^Ù Ù¿Ý—úÇ Î^Ç
Í$Ó^ú¡,Ù^üþhCü¶_IF Configure a limit on the maximum length of any literal in a sequence.Á„`úüŒ`HE This is useful for limiting things like `(abcde){5}{5}{5}{5}`. WhileÁüÙ`C@ each repetition or literal in that regex is small, when all theÁü¡aHE repetitions are applied, one ends up with a literal of length `5^4 =ÁLîa 625`.Áüaúü„bIF With this limit set, literals that exceed it will be made inexact andÁüÒb  thus prevented from growing.Á÷búlÿb—è‘cúü™cJ ôècú<ðcåéüücGõÈdúüÐd(% let hir = parse(r"(abc){2}{2}{2}")?;Áýdúü…e-ÿêü·e:°öôöe®ì™fúü¡fBâìüèfC@ let got = Extractor::new().limit_literal_len(14).extract(&hir);Áü°g#â÷üØg+( Literal::inexact("abcabcabcabcab"),Á<ˆhžìô”h®ì·húü¿h.ºî<òhå錅iÚ Ú¿Ýš‚ Ç —iÇ
Î$œiú¡,¢iü›{=ü„jB? Configure a limit on the total number of literals that will beÁlËj÷»ÝjúüåjFC This is useful as a practical measure for avoiding the creation ofÁü°kGD large sequences of literals. While the extractor will automaticallyÁüükJG handle local creations of large sequences (for example, `[A-Z]` yieldsÁüËlDA an infinite sequence by default), large sequences can be createdÁü”m$! through non-local means as well.Á½múüÅmJG For example, `[ab]{3}{3}` would yield a sequence of length `512 = 2^9`Áü”nHE despite each of the repetitions being small on their own. This limitÁüánKH thus represents a "catch all" for avoiding locally small sequences fromÁü±o# combining into large sequences.ÁÙoúláo—èóoúüûoEB
literals.Á³öúü»öIF The slice returned may be empty, in which case, there are no literalsÁü‰÷! that can match this sequence.ÁDÄ÷ð ðßÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ð
üßè Í÷è
ð$Î÷ü®ü$ü˜ø/, Push a literal to the end of this sequence.ÁÌøúüÔø96 If this sequence is not finite, then this is a no-op.Á’ùúüšùB? Similarly, if the most recently added item of this sequence isÁüáùHE equivalent to the literal given, then it is not added. This reflectsÁü®úHE a `Seq`'s "set like" behavior, and represents a practical trade off.ÁüûúGD Namely, there is never any need to have two adjacent and equivalentÁüÇûEB literals in the same sequence, _and_ it is easy to detect in someÁT‘ü cases.Á$µüñ ñßüßè ºüè
ñ$¿ü‚± Åüòýñ¸ÂòÐÂòíÂòòñò üßƾ ôÍÿüÄþ63 Make all of the literals in this sequence inexact.Áÿþúü‡ÿ30 This is a no-op if this sequence is not finite.ÁdÔÿò òßè áÿè
ó$æÿüË‚üÀ30 Converts this sequence to an infinite sequence.Áøúü€‚85 This is a no-op if the sequence is already infinite.ÁlÒ‚ó óßè à‚è
ô$å‚ü™¡0ü–ƒHE Modify this sequence to contain the cross product between it and theÁœãƒ sequence given.Áûƒúüƒ„GD The cross product only considers literals in this sequence that areÁüÏ„63 exact. That is, inexact literals are not extended.ÁŠ…úü’…HE The literals are always drained from `other`, even if none are used.Áüß…DA This permits callers to reuse the sequence allocation elsewhere.Á¨†úü°†JG If this sequence is infinite, then this is a no-op, regardless of whatÁüÿ†KH `other` contains (and in this case, the literals are still drained fromÁüχKH `other`). If `other` is infinite and this sequence is finite, then thisÁüŸˆGD is a no-op, unless this sequence contains a zero-length literal. InÁüëˆKH which case, the infiniteness of `other` infects this sequence, and thisÁü»‰%" sequence is itself made infinite.Áå‰úüí‰FC Like [`Seq::union`], this may attempt to deduplicate literals. SeeÁü¸ŠEB [`Seq::dedup`] for how deduplication deals with exact and inexactÁl‚‹е ”‹úlœ‹—讋úü¶‹EB This example shows basic usage and how exact and inexact literalsÁl€Œ
interact.Á’Œú<šŒåéü¦Œ30 use regex_syntax::hir::literal::{Literal, Seq};ÁÞŒúüæŒ# let mut seq1 = Seq::from_iter([ÁôŽ Literal::exact("foo"),Áü±  Literal::inexact("bar"),Ážìüâ# let mut seq2 = Seq::from_iter([ÁüŠŽ! Literal::inexact("quux"),Áô°Ž Literal::exact("baz"),Á<ÓŽžìüߎ" seq1.cross_forward(&mut seq2);ÁúüŽ+( // The literals are pulled out of seq2.Áü¾$! assert_eq!(Some(0), seq2.len());Áçúüï#â÷ü—$! Literal::inexact("fooquux"),ÁüÀ! Literal::exact("foobaz"),Áüæ ÝÌ <‹‘žìü—‘ assert_eq!(expected, seq1);Á<»‘åéÇ‘úüÏ‘B? This example shows the behavior of when `other` is an infiniteÁl–’
sequence.Á¨’ú<°’åéü¼’3¼Ë ô’úüü’#‡Ì ô¤“´Ì üÇ“ ÝÌ <쓞ìüø“# let mut seq2 = Seq::infinite();Áü ”"¦Î Ç”úüÏ”EB // When seq2 is infinite, cross product doesn't add anything, butÁü™•/, // ensures all members of seq1 are inexact.ÁüÍ•#â÷üõ•  Literal::inexact("foo"),Áüš– ÝÌ <¿–žìüË–ÙÐ <ï–åéû–úüƒ—HE This example is like the one above, but shows what happens when thisÁüЗHE sequence contains an empty string. In this case, an infinite `other`Áü˜GD sequence infects this sequence (because the empty string means thatÁüé˜" there are no finite prefixes):Áú<˜™åéü¤™3¼Ë Ü™úüä™#‡Ì ôŒš´Ì ü¯š=: Literal::exact(""), // inexact provokes same behaviorÁüñš ÝÌ <–›žìü¢›#óÒ üÊ›"¦Î ñ›úäù› // seq1 is now infinite!Áüšœ assert!(!seq1.is_finite());Á<¾œåéÊœúüÒœA> This example shows the behavior of this sequence is infinite.Á˜úåéü¬3¼Ë äúüì# let mut seq1 = Seq::infinite();Áü”ž#–Í ô¼ž´Ì üßž ÝÌ <„ŸžìüŸ"¦Î ·Ÿúô¿Ÿ // seq1 remains unchanged.ÁüâŸ÷Ù ü† KH // Even though the literals in seq2 weren't used, it was still drained.ÁüÖ $–Ï <ÿ åél ¡ôõ ôß õßè ®¡è
õ$³¡¹
,¹¡ü©È0üǨDA Modify this sequence to contain the cross product between it andÁü©C@ the sequence given, where the sequences are treated as suffixesÁüØ©DA instead of prefixes. Namely, the sequence `other` is *prepended*Áü¡ªB? to `self` (as opposed to `other` being *appended* to `self` inÁäèª [`Seq::cross_forward`]).Á‰«úü‘«G®Â üÝ«6€Ã ˜¬úü ¬HÎà üí¬D¡Ä ¶­úü¾­JýÄ ü®KÒÅ üÝ®K¨Æ ü­¯GþÆ üù¯KÐÇ üɰ%¦È ó°úüû°FãÈ üƱE´É l²е ¢²úlª²—è¼²úüIJEºÊ l޳‰Ë  ³ú<¨³åéü´³3¼Ë ì³úüô³#‡Ì ôœ´´Ì ü¿´ ÝÌ <ä´žìüð´#–Í ü˜µ!ÄÍ ô¾µïÍ <ᵞìüíµ" seq1.cross_reverse(&mut seq2);Á”¶úüœ¶+àÎ ü̶$–Ï õ¶úüý¶#â÷ü¥·$! Literal::inexact("quuxfoo"),Áüη ÝÌ üó·! Literal::exact("bazfoo"),Á<™¸žìü¥¸ÙÐ <ɸåéÕ¸úüݸBžÑ l¤¹êÑ ¶¹ú<¾¹åéüʹ3¼Ë ‚ºúüŠº#‡Ì ô²º´Ì üÕº ÝÌ <úºžìü†»#óÒ ü®»"¥å Õ»úüÝ»E½Ó ü§¼/Ô üÛ¼#â÷üƒ½ ÖÔ ü¨½ ÝÌ <ͽžìüÙ½ÙÐ <ý½å鉾úü‘¾HÈÕ üÞ¾H›Ö ü«¿GîÖ ü÷¿" there are no finite suffixes):ÁžÀú<¦Àåéü²À3¼Ë êÀúüòÀ#‡Ì ôšÁ´Ì ü½Á=ÁØ üÿÁ ÝÌ <¤Âžìü°Â#óÒ üØÂ"¥å ÿÂúä‡ÃÐÙ ü¨Ã÷Ù <ÌÃåéØÃúüàÃC@ This example shows the behavior when this sequence is infinite.Á¨Äú<°Äåéü¼Ä3¼Ë ôÄúüüÄ#¿Û ü¤Å#–Í ôÌÅ´Ì üïÅ ÝÌ <”Æžìü Æ"¥å ÇÆúôÏÆÂÜ üòÆ÷Ù ü–ÇKúÜ üæÇ$–Ï <Èåél°Èö÷ öß ÷ßè ¾Èè
ö$Ãȹ
,ÉÈüŠØtؼø øßñð Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ øªBªBö­Bá«÷<®B÷<9)
-ÜnLüß‘‹Èñ èœØè
÷$±Ø¹
,¿Ø "ü†î(üÃá.+ Unions the `other` sequence into this one.ÁöáúüþáFC The literals are always drained out of the given `other` sequence,ÁüÉâJG even if they are being unioned into an infinite sequence. This permitsÁü˜ã@= the caller to reuse the `other` sequence in another context.ÁÝãúüåãDA Some literal deduping may be performed. If any deduping happens,Áü®äDA any leftmost-first or "preference" order match semantics will beÁt÷ä preserved.ÁŠåúl’å—è¤åúü¬å# This example shows basic usage.ÁÔåú<Üååéüèå(% use regex_syntax::hir::literal::Seq;Á•æúüæ-* let mut seq1 = Seq::new(&["foo", "bar"]);ÁüÏæ52 let mut seq2 = Seq::new(&["bar", "quux", "foo"]);ÁÔ‰ç seq1.union(&mut seq2);Á¨çúü°ç+àÎ üàç$–Ï ‰èúü‘èKH // Adjacent literals are deduped, but non-adjacent literals may not be.Áüáè?< assert_eq!(Seq::new(&["foo", "bar", "quux", "foo"]), seq1);Á<¥éåé±éúü¹éGD This example shows that literals are drained from `other` even whenÁü…ê! they aren't necessarily used.Á«êú<³êåéü¿ê(Äö ìêúüôê#¿Û üœë0- // Infinite sequences have no finite length.ÁüÑë! assert_eq!(None, seq1.len());Á÷ëúüÿë5¼÷ Ô¹ìû÷ Øìúüàì85 // seq1 is still infinite and seq2 has been drained.Áüí!’ü üÃí$–Ï <ìíåé,îøù øß ùßè “îè
ù$˜î¹
,žîü´‚3ü£òC@ Unions the `other` sequence into this one by splice the `other`Áüëò>; sequence at the position of the first zero-length literal.Á®óúü¶óKH This is useful for preserving preference order semantics when combiningÁü†ôFC two literal sequences. For example, in the regex `(a||f)+foo`, theÁüÑô>; correct preference order prefix sequence is `[a, foo, f]`.Á”õúüœõFŸò üçõJðò ü¶öJG the caller to reuse the `other` sequence in another context. Note thatÁü…÷IF the literals are drained even if no union is performed as well, i.e.,ÁüÓ÷>; when this sequence does not contain a zero-length literal.Á–øúüžøDô üçøDìô t°ùºõ ÃùúlËù—èÝùúüåù#ûõ úú<•úåéü¡ú(Äö ÎúúüÖú1. let mut seq1 = Seq::new(&["a", "", "f", ""]);ÁüŒû&# let mut seq2 = Seq::new(&["foo"]);Áü·û%" seq1.union_into_empty(&mut seq2);Ááûúüéû+àÎ ü™ü$–Ï üÂüHE // 'foo' gets spliced into seq1 where the first empty string occurs.Áüý30 assert_eq!(Seq::new(&["a", "foo", "f"]), seq1);Á<ÇýåéÓýúüÛýG“ú ü§þ!åú Íþú<Õþåéüáþ(Äö Žÿúü–ÿ-„÷ üÈÿ5¼÷ ü‚€%œ†
¬€úü´€@= // seq1 has no zero length literals, so no splicing happens.Áüù€0- assert_eq!(Seq::new(&["foo", "bar"]), seq1);Áü®>; // Even though no splicing happens, seq2 is still drained.Áüñ$–Ï <š‚åé„»‚úû úß ûßè Ì‚è
ú$Ñ‚¹
,ׂ4šƒú¸ÂûÐÂûíÂûûúû Ññ ˆ>ˆ>DrainÁŒ>
tail_startÁ÷<>tail_lenÁ÷<Ž>ù÷<>Á÷<…üò)«§üß‘‹á„ú¸ÂüÐÂüíÂüüúüþ ýŠú¸ÂýÐÂýíÂýýúý üß¼üé‹>; Deduplicate adjacent equivalent literals in this sequence.Á¬Œúü´ŒHE If adjacent literals are equivalent strings but one is exact and theÁüC@ other inexact, the inexact literal is kept and the exact one isÁ removed.ÁÚúüâ-* Deduping an infinite sequence is a no-op.Á”ŽúlœŽ—讎úü¶ŽGD This example shows how literals that are duplicate byte strings butÁü‚>; are not equivalent with respect to exactness are resolved.ÁÅúåéüÙ3¼Ë úü™" let mut seq = Seq::from_iter([ÁôÀ´Ì üã ÖÔ <ˆ‘žì„”‘
seq.dedup();Á©‘úü±‘?< assert_eq!(Seq::from_iter([Literal::inexact("foo")]), seq);Á<õ‘åé,–’ü üßè œ’è
þ$¡’d÷’þ¸ÂÿÐÂÿíÂÿÿþÿ üß üß´„œüÈ•63 Sorts this sequence of literals lexicographically.Áƒ–úü‹–JG Note that if, before sorting, if a literal that is a prefix of anotherÁüÚ–GD literal appears after it, then after sorting, the sequence will notÁü¦—EB represent the same preference order match semantics. For example,Áüð—DA sorting the sequence `[samwise, sam]` yields the sequence `[sam,Áü¹˜IF samwise]`. Under preference order semantics, the latter sequence willÁü‡™:7 never match `samwise` where as the first sequence can.ÁÆ™úlΙ—èà™úüè™#ûõ šú<˜šåéü¤š(Äö ÑšúüÙš41 let mut seq = Seq::new(&["foo", "quux", "bar"]);Á|’› seq.sort();Á¦›úü®›74 assert_eq!(Seq::new(&["bar", "foo", "quux"]), seq);Á<ê›åé$‹œý ýßè œè
$•œü§ "üÿœ2/ Reverses all of the literals in this sequence.Áúü¾2/ The order of the sequence itself is preserved.Áõú—èžúü—ž#ûõ ¿žú<ÇžåéüÓž(Äö €ŸúüˆŸ,) let mut seq = Seq::new(&["oof", "rab"]);ÁܹŸ seq.reverse_literals();ÁüÙŸ/, assert_eq!(Seq::new(&["foo", "bar"]), seq);Á< åé„® þ þßè ¿ è
$Ä ü«³(üë¡HE Shrinks this seq to its minimal size while respecting the preferenceÁÔ¸¢ order of its literals.Á×¢úüߢGD While this routine will remove duplicate literals from this seq, itÁü«£IF will also remove literals that can never match in a leftmost-first orÁüù£IF "preference order" search. Similar to [`Seq::dedup`], if a literal isÁüǤ74 deduped, then the one that remains is made inexact.Áƒ¥úü‹¥96 This is a no-op on seqs that are empty or not finite.ÁÉ¥úlÑ¥—èã¥úüë¥B? This example shows the difference between `{sam, samwise}` andÁ¬²¦ `{samwise, sam}`.Á̦ú<Ô¦åéüà¦3¼Ë ˜§úü §GD // If 'sam' comes before 'samwise' and a preference order search isÁüì§0- // executed, then 'samwise' can never match.Áü¡¨0- let mut seq = Seq::new(&["sam", "samwise"]);ÁüÖ¨! seq.minimize_by_preference();Áüü¨?< assert_eq!(Seq::from_iter([Literal::inexact("sam")]), seq);ÁÀ©úüÈ©JG // But if they are reversed, then it's possible for 'samwise' to matchÁü—ª+( // since it is given higher preference.ÁüǪ0- let mut seq = Seq::new(&["samwise", "sam"]);Áüüª!è©
ü¢«30 assert_eq!(Seq::new(&["samwise", "sam"]), seq);Á<Ú«åéæ«úüî«C@ This example shows that if an empty string is in this seq, thenÁü¶¬1. anything that comes after it can never match.Áì¬ú<ô¬åéü€­3¼Ë ¸­úüÀ­FC // An empty string is a prefix of all strings, so it automaticallyÁü‹®52 // inhibits any subsequent strings from matching.ÁüÅ®?< let mut seq = Seq::new(&["foo", "bar", "", "quux", "fox"]);Áü‰¯!è©
ü¯¯#â÷ôׯ´Ì ôú¯ Literal::exact("bar"),Áì° Literal::inexact(""),Á<¿°žìô˰ assert_eq!(expected, seq);Áî°úüö°KH // And of course, if it's at the beginning, then it makes it impossibleÁüƱ" // for anything else to match.Áüí±85 let mut seq = Seq::new(&["", "foo", "quux", "fox"]);Áüª²!è©
üв<9 assert_eq!(Seq::from_iter([Literal::inexact("")]), seq);Á<‘³åé´²³ÿ ÿßè ɳè
$γüع.üÒ´GD Trims all literals in this seq such that only the first `len` bytesÁüžµGD remain. If a literal has less than or equal to `len` bytes, then itÁüêµA> remains unchanged. Otherwise, it is trimmed and made inexact.Á°¶úl¸¶—èʶú<Ò¶åéüÞ¶3¼Ë –·úüž·2/ let mut seq = Seq::new(&["a", "foo", "quux"]);ÁäÕ· seq.keep_first_bytes(2);Áö·úüþ·#â÷䦸 Literal::exact("a"),ÁüǸ Literal::inexact("fo"),Áüë¸ Literal::inexact("qu"),Á<¹žìô›¹½±
<¾¹åé„ß¹ ßè ð¹è
ƒ$õ¹û¹ü´À-ü°»FC Trims all literals in this seq such that only the last `len` bytesÁüû»Gǵ
üǼA™¶
½úl•½—è§½ú<¯½åéü»½3¼Ë ó½úüû½2··
ܲ¾ seq.keep_last_bytes(2);ÁÒ¾úüÚ¾#â÷ä‚¿µ¸
ü£¿ Literal::inexact("oo"),ÁüÇ¿ Literal::inexact("ux"),Á<뿞ìô÷¿½±
<šÀåé|»À ßè ËÀè
$ÐÀÖÀüÅÃüŠÂ,) Returns true if this sequence is finite.Á»ÂúüÃÂFC When false, this sequence is infinite and must be treated as if itÁüŽÃ$! contains every possible literal.ÁLÌà ßè ÖÃè
$×Ãô‰Æü’ÄB? Returns true if and only if this sequence is finite and empty.ÁÙÄúüáÄHE An empty sequence never matches anything. It can only be produced byÁü®ÅHE literal extraction when the corresponding regex itself cannot match.ÁDƃ ƒßè ™Æè
$šÆüòÇ"üÓÆFC Returns the number of literals in this sequence if the sequence isÁüžÇA> finite. If the sequence is infinite, then `None` is returned.ÁùÇ ß§Ýè ýÇè
$þÇ4ºÈ¸ÂˆÐˆíˆˆˆ Ññ ôóÉüØÈHE Returns true if and only if all literals in this sequence are exact.Á¥Éúü­É30 This returns false if the sequence is infinite.ÁDúÉ ßè ƒÊè
$„Ê4ºÊ¸ÂŠÐŠíÂŠŠŠ ž¸ ÑʸÂÐÂíÂþ ü‹Ì üïÊJG Returns true if and only if all literals in this sequence are inexact.Á¾ËúüÆË2/ This returns true if the sequence is infinite.ÁT’Ì ßè Ìè
Œ$žÌ4ÓÌŒ¸ÂÐÂíÂŒÇÉ
êÌŒ¸ÂŽÐÂŽíÂŽŽŒŽþ üÃÎ9ü‰ÍDA Return the maximum length of the sequence that would result fromÁüÒÍFC unioning `self` with `other`. If either set is infinite, then thisÁœÎ returns `None`.ÁlÊΈ ß ˆß§Ýè ØÎè
$Ùι
,ßÎü¹Ñ9üóÏHE Return the maximum length of the sequence that would result from theÁüÀÐIF cross product of `self` with `other`. If either set is infinite, thenÁÄŽÑ this returns `None`.ÁlÀÑŠ ß Šß§Ýè ÎÑè
$Ïѹ
,ÕÑüŒÔ.üéÒ@= Returns the length of the shortest literal in this sequence.Á®Óúü¶ÓC@ If the sequence is infinite or empty, then this returns `None`.Á|“Ô ß§Ýè £Ôè
$¤ÔèÔ¸ÂÐÂíÂƾ ü¨Ö.ü†Õ?< Returns the length of the longest literal in this sequence.ÁÊÕúüÒÕC¾Ò
|¯ÖŒ Œß§Ýè ¿Öè
$Àք׸ÂÐÂíªÕ
ü­ß4ü¢×41 Returns the longest common prefix from this seq.ÁÛ×úüã×FC If the seq matches any literal or other contains no literals, thenÁü®Ø:7 there is no meaningful prefix and this returns `None`.ÁíØúlõØ—è‡ÙúüÙA> This shows some example seqs and their longest common prefix.ÁÕÙú<ÝÙåéüéÙ(Äö –ÚúüžÚ1. let seq = Seq::new(&["foo", "foobar", "fo"]);ÁüÔÚ>; assert_eq!(Some(&b"fo"[..]), seq.longest_common_prefix());Áü—Û(% let seq = Seq::new(&["foo", "foo"]);ÁüÄÛ?< assert_eq!(Some(&b"foo"[..]), seq.longest_common_prefix());ÁüˆÜ(% let seq = Seq::new(&["foo", "bar"]);ÁüµÜ<9 assert_eq!(Some(&b""[..]), seq.longest_common_prefix());ÁôöÜ let seq = Seq::new(&[""]);Áü™Ý<¨Ü
ÚÝúôâÝ let seq = Seq::infinite();Áü…Þ2/ assert_eq!(None, seq.longest_common_prefix());ÁܼÞ let seq = Seq::empty();ÁüÜÞ2ÛÝ
<“ßåé¬´ß ßÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ªáè Êßè
$ËßL‹ä¸ÂÐÂí  Öá
ü¼í4ü±å41 Returns the longest common suffix from this seq.ÁêåúüòåF²×
ü½æ:7 there is no meaningful suffix and this returns `None`.Áüæúl„ç—è–çúüžçA> This shows some example seqs and their longest common suffix.Áäçú<ìçåéüøç(Äö ¥èúü­è1. let seq = Seq::new(&["oof", "raboof", "of"]);Áüãè>; assert_eq!(Some(&b"of"[..]), seq.longest_common_suffix());Áü¦é(øÚ
üÓé?< assert_eq!(Some(&b"foo"[..]), seq.longest_common_suffix());Áü—ê(õÛ
üÄê<9 assert_eq!(Some(&b""[..]), seq.longest_common_suffix());Áô…ëîÜ
ü¨ë<°å
éëúôñë²Ý
ü”ì2/ assert_eq!(None, seq.longest_common_suffix());ÁÜËì—Þ
üëì2¯æ
<¢íåé¬ÃíŽ ŽßÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Žªáè Ùíè
$ÚíLÄò¸Â˜Ð˜í˜˜˜Çá
üʘ3ü÷óB? Optimizes this seq while treating its literals as prefixes andÁü¾ô41 respecting the preference order of its literals.Á÷ôúüÿôJG The specific way "optimization" works is meant to be an implementationÁüÎõFC detail, as it essentially represents a set of heuristics. The goalÁü™öIF that optimization tries to accomplish is to make the literals in thisÁüçöFC set reflect inputs that will result in a more effective prefilter.Áü²÷JG Principally by reducing the false positive rate of candidates found byÁüøHE the literals in this sequence. That is, when a match of a literal isÁüÎøIF found, we would like it to be a strong predictor of the overall matchÁüœùHE of the regex. If it isn't, then much time will be spent starting andÁüéùJG stopping the prefilter search and attempting to confirm the match onlyÁ¤¸ú to have it fail.ÁÑúúüÙú&# Some of those heuristics might be:Á„ûúüŒûIF * Identifying a common prefix from a larger sequence of literals, andÁüÚû=: shrinking the sequence down to that single common prefix.ÁüœüIF * Rejecting the sequence entirely if it is believed to result in veryÁüêüEB high false positive rate. When this happens, the sequence is madeÁl´ý