package

Bidi
BidiClass
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
BidiProperties
ByteRange
- from_bounds
- start
- end
- len
- is_empty
- is_eq
- slice
- BoundsError
- SliceError
CanonicalCombiningClass
- property_name
- from_u8
- to_u8
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- is_eq
- fold_runs
- iter_runs
- PropertyName
- Run
- AliasError
Case
CodePoint
EastAsianWidth
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
  - is_eq
- PropertyName
- Run
- AliasError
Emoji
GeneralCategory
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
Grapheme
- iter_ranges
- ranges
- slices
- owned
- Cursor
  - init
  - push
  - finish
IndicPositionalCategory
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
IndicSyllabicCategory
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
JoiningGroup
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
JoiningType
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
LineBreak
Property
Scalar
- from_u32
- from_code_point
- to_u32
- to_code_point
- iter
- utf8_len
- to_utf8
- append_utf8
- to_str
- is_eq
- LocatedScalar
ScalarRange
- from_bounds
- start
- end
- len
- is_empty
- is_eq
- BoundsError
Script
- of_scalar
- extensions_of_scalar
- from_alias
- short_alias
- long_alias
- alias_count
- alias_at
- is_common
- is_inherited
- is_unknown
- is_explicit
- singleton
- contains
- len
- intersection
- explicit_members
- is_eq_set
- compare
- at
- walk
- to_list
- Value
  - is_eq
- ScriptSet
ScriptItemization
- policy_revision
- default
- with_preferred
- iter_runs
- fold_runs
- runs
- cursor_init
- cursor_push
- cursor_finish
- ConservativeScxV1
- Run
- Cursor
- Error
TextPosition
TextRange
- from_ranges
- from_positions
- start
- end
- byte_range
- scalar_range
- is_empty
- is_eq
- BoundsError
UnicodeVersion
- current
- major
- minor
- patch
- to_str
- is_eq
Utf8
- Problem
  - is_eq
- DecodeError
- Cursor
  - init
  - push
  - finish
VerticalOrientation
- property_name
- of_scalar
- short
- long
- alias_count
- alias_at
- parse
- fold_runs
- iter_runs
- Value
- PropertyName
- Run
- AliasError
Word
- iter_ranges
- fold_ranges
- ranges
- slices
- owned
- Cursor
  - init
  - push
  - finish

Bidi.default_limits : Limits
Bidi.paragraph_ranges : Str -> List(TextRange)
Bidi.analyze_paragraph : Str, BaseDirection, Limits -> Try(Analysis, Error)
Bidi.analyze_range : Str, TextRange, BaseDirection, Limits -> Try(Analysis, Error)
Bidi.paragraph_level : Analysis -> U8
Bidi.requested_base_direction : Analysis -> BaseDirection
Bidi.paragraph_range : Analysis -> TextRange
Bidi.entries : Analysis -> List(ScalarInfo)
Bidi.matched_brackets : Analysis -> List([Some(U64), None])
Bidi.levels : Analysis -> List(ResolvedLevel)
Bidi.direction : U8 -> Direction
Bidi.logical_runs : Analysis -> Iter(LevelRun)
Bidi.collect_logical_runs : Analysis -> List(LevelRun)
Bidi.reorder_line : Analysis, ScalarRange -> Try(LineOrder, Error)
Bidi.line_levels : LineOrder -> List(ResolvedLevel)
Bidi.visual_to_logical : LineOrder -> List(U64)
Bidi.logical_to_visual : LineOrder -> List([Some(U64), None])
Bidi.visual_runs : LineOrder -> List(VisualRun)
Bidi.line_mirroring : LineOrder -> List(MirrorInfo)
Bidi.BaseDirection : [Auto, LeftToRight, RightToLeft]
Bidi.Direction : [LeftToRight, RightToLeft]
Bidi.LimitStage : [Ingestion]
Bidi.ResolvedLevel : [Level(U8), RemovedByX9]
Bidi.Limits : { max_scalars : U64, max_bytes : U64 }
Bidi.Error : [ScalarLimitExceeded({ limit : U64, required : U64, stage : LimitStage, range : TextRange }), ByteLimitExceeded({ limit : U64, required : U64, stage : LimitStage, range : ByteRange }), MultipleParagraphs, InvalidParagraphRange(TextRange), LineOutOfBounds({ requested : ScalarRange, paragraph : ScalarRange })]
Bidi.ScalarInfo : { range : TextRange, scalar : Scalar, original_class : Value, working_class : Value, level : [Some(U8), None], matched_bracket : [Some(U64), None], non_rendering : Bool, needs_mirrored_glyph : Bool, mirroring_glyph : [Some(Scalar), None] }
Bidi.LevelRun : { range : TextRange, level : U8, direction : Direction }
Bidi.VisualRun : { logical_range : ScalarRange, level : U8, direction : Direction }
Bidi.Analysis := { requested_base : BaseDirection, paragraph_range : TextRange, paragraph_level : U8, entries : List(ScalarInfo), byte_len : U64, scalar_len : U64 }
Bidi.MirrorInfo : { needs_glyph : Bool, glyph : [Some(Scalar), None] }
Bidi.LineOrder := { line_range : ScalarRange, levels : List([Some(U8), None]), visual_to_logical : List(U64), logical_to_visual : List([Some(U64), None]), visual_runs : List(VisualRun), mirroring : List(MirrorInfo) }
Bidi.RunSequences := { links : List([Some(U64), None]), starts : List(U64), sos : List(Value), eos : List(Value) }
BidiClass.property_name : PropertyName
BidiClass.of_scalar : Scalar -> Value
BidiClass.short : Value -> Str
BidiClass.long : Value -> Str
BidiClass.alias_count : Value -> U8
BidiClass.alias_at : Value, U8 -> [Some(Str), None]
BidiClass.parse : Str -> Try(Value, AliasError)
BidiClass.fold_runs : Str, state, (state, Run -> state) -> state
BidiClass.iter_runs : Str -> Iter(Run)
BidiClass.Value : Value
BidiClass.PropertyName : { short : Str, long : Str }
BidiClass.Run : { range : TextRange, value : Value }
BidiClass.AliasError : [UnknownAlias]
BidiProperties.mirrored_property : PropertyName
BidiProperties.mirroring_glyph_property : PropertyName
BidiProperties.paired_bracket_property : PropertyName
BidiProperties.paired_bracket_type_property : PropertyName
BidiProperties.is_mirrored : Scalar -> Bool
BidiProperties.mirroring_glyph : Scalar -> [Some(Scalar), None]
BidiProperties.paired_bracket : Scalar -> [Some(PairedBracket), None]
BidiProperties.paired_bracket_type : Scalar -> PairedBracketType
BidiProperties.paired_bracket_type_short : PairedBracketType -> Str
BidiProperties.paired_bracket_type_long : PairedBracketType -> Str
BidiProperties.parse_paired_bracket_type : Str -> Try(PairedBracketType, AliasError)
BidiProperties.paired_bracket_type_alias_count : PairedBracketType -> U8
BidiProperties.paired_bracket_type_alias_at : PairedBracketType, U8 -> [Some(Str), None]
BidiProperties.mirrored_short : Bool -> Str
BidiProperties.mirrored_long : Bool -> Str
BidiProperties.mirrored_alias_count : Bool -> U8
BidiProperties.mirrored_alias_at : Bool, U8 -> [Some(Str), None]
BidiProperties.parse_mirrored : Str -> Try(Bool, AliasError)
BidiProperties.PropertyName : { short : Str, long : Str }
BidiProperties.PairedBracketType : [None, Open, Close]
BidiProperties.PairedBracket : { scalar : Scalar, kind : [Open, Close] }
BidiProperties.AliasError : [UnknownAlias]
ByteRange.from_bounds : U64, U64 -> Try(ByteRange, BoundsError)
ByteRange.start : ByteRange -> U64
ByteRange.end : ByteRange -> U64
ByteRange.len : ByteRange -> U64
ByteRange.is_empty : ByteRange -> Bool
ByteRange.is_eq : ByteRange, ByteRange -> Bool
ByteRange.slice : ByteRange, Str -> Try(Str, SliceError)
ByteRange.BoundsError : [EndBeforeStart]
ByteRange.SliceError : [NotScalarBoundary, OutOfBounds]
CanonicalCombiningClass.property_name : PropertyName
CanonicalCombiningClass.from_u8 : U8 -> CanonicalCombiningClass
CanonicalCombiningClass.to_u8 : CanonicalCombiningClass -> U8
CanonicalCombiningClass.of_scalar : Scalar -> CanonicalCombiningClass
CanonicalCombiningClass.short : CanonicalCombiningClass -> [Some(Str), None]
CanonicalCombiningClass.long : CanonicalCombiningClass -> [Some(Str), None]
CanonicalCombiningClass.alias_count : CanonicalCombiningClass -> U8
CanonicalCombiningClass.alias_at : CanonicalCombiningClass, U8 -> [Some(Str), None]
CanonicalCombiningClass.parse : Str -> Try(CanonicalCombiningClass, AliasError)
CanonicalCombiningClass.is_eq : CanonicalCombiningClass, CanonicalCombiningClass -> Bool
CanonicalCombiningClass.fold_runs : Str, state, (state, Run -> state) -> state
CanonicalCombiningClass.iter_runs : Str -> Iter(Run)
CanonicalCombiningClass.PropertyName : { short : Str, long : Str }
CanonicalCombiningClass.Run : { range : TextRange, value : CanonicalCombiningClass }
CanonicalCombiningClass.AliasError : [UnknownAlias]
Case.default_mapping_profile : MappingProfile
Case.unicode_default : MappingProfile
Case.turkic : MappingProfile
Case.lithuanian : MappingProfile
Case.default_fold_profile : FoldProfile
Case.full : FoldProfile
Case.simple : FoldProfile
Case.turkic_full : FoldProfile
Case.turkic_simple : FoldProfile
Case.limits : U64, U64, U64, U64, U64 -> Limits
Case.unlimited_limits : Limits
Case.mapping_profile_revision : MappingProfile -> [None, Some(MappingProfileRevision)]
Case.fold_profile_revision : FoldProfile -> [None, Some(FoldProfileRevision)]
Case.result_text : Result -> Str
Case.result_facts : Result -> List(Fact)
Case.result_unicode_version : Result -> UnicodeVersion
Case.result_operation : Result -> [Lower, Upper, Title, Fold]
Case.result_profile : Result -> [MappingUnicodeDefault, MappingTurkic, MappingLithuanian, FoldFull, FoldSimple, FoldTurkicFull, FoldTurkicSimple]
Case.result_profile_revision : Result -> [NoProfileRevision, MappingTurkicV1, MappingLithuanianV1, FoldSimpleV1, FoldTurkicV1]
Case.fact_input : Fact -> TextRange
Case.fact_output : Fact -> TextRange
Case.fact_shape : Fact -> [Unchanged, Simple, Expanded, Removed]
Case.fact_contextual : Fact -> Bool
Case.error_limit_resource : Error -> [NoLimitResource, InputBytes, InputScalars, OutputBytes, OutputScalars, Facts]
Case.error_kind : Error -> [LimitExceeded, CoordinateOverflow, InternalEncodingFault]
Case.error_limit : Error -> [Some({ limit : U64, required : U64 }), None]
Case.error_position : Error -> [NoErrorPosition, ErrorPosition(TextPosition)]
Case.to_lower : Str, MappingProfile, Limits -> Try(Result, Error)
Case.to_upper : Str, MappingProfile, Limits -> Try(Result, Error)
Case.to_title : Str, MappingProfile, Limits -> Try(Result, Error)
Case.fold : Str, FoldProfile, Limits -> Try(Result, Error)
Case.MappingProfile : [UnicodeDefault, Turkic, Lithuanian]
Case.FoldProfile : [Full, Simple, TurkicFull, TurkicSimple]
Case.MappingProfileRevision : [TurkicV1, LithuanianV1]
Case.FoldProfileRevision : [SimpleV1, TurkicV1]
Case.Shape : [Unchanged, Simple, Expanded, Removed]
Case.Fact : { input : TextRange, output : TextRange, shape : Shape, contextual : Bool }
Case.Limits : { max_input_bytes : U64, max_input_scalars : U64, max_output_bytes : U64, max_output_scalars : U64, max_mapping_facts : U64 }
Case.Error : [LimitExceeded({ resource : [InputBytes, InputScalars, OutputBytes, OutputScalars, Facts], limit : U64, required : U64 }), CoordinateOverflow({ at : TextPosition }), InternalEncodingFault]
Case.Result : { text : Str, facts : List(Fact), unicode_version : UnicodeVersion, operation : [Lower, Upper, Title, Fold], profile : [Mapping(MappingProfile), Folding(FoldProfile)], profile_revision : [None, Some([Mapping(MappingProfileRevision), Folding(FoldProfileRevision)])] }
CodePoint.from_u32 : U32 -> Try(CodePoint, [InvalidCodePoint])
CodePoint.to_u32 : CodePoint -> U32
CodePoint.is_scalar : CodePoint -> Bool
CodePoint.is_surrogate : CodePoint -> Bool
CodePoint.is_high_surrogate : CodePoint -> Bool
CodePoint.is_low_surrogate : CodePoint -> Bool
CodePoint.is_eq : CodePoint, CodePoint -> Bool
EastAsianWidth.property_name : PropertyName
EastAsianWidth.of_scalar : Scalar -> Value
EastAsianWidth.short : Value -> Str
EastAsianWidth.long : Value -> Str
EastAsianWidth.alias_count : Value -> U8
EastAsianWidth.alias_at : Value, U8 -> [Some(Str), None]
EastAsianWidth.parse : Str -> Try(Value, AliasError)
EastAsianWidth.fold_runs : Str, state, (state, Run -> state) -> state
EastAsianWidth.iter_runs : Str -> Iter(Run)
EastAsianWidth.Value := [Fullwidth, Wide, Ambiguous, Halfwidth, Neutral, Narrow]
EastAsianWidth.Value.is_eq : _
EastAsianWidth.PropertyName : { short : Str, long : Str }
EastAsianWidth.Run : { range : TextRange, value : Value }
EastAsianWidth.AliasError : [UnknownAlias]
Emoji.emoji_property : PropertyName
Emoji.presentation_property : PropertyName
Emoji.modifier_property : PropertyName
Emoji.modifier_base_property : PropertyName
Emoji.component_property : PropertyName
Emoji.extended_pictographic_property : PropertyName
Emoji.of_scalar : Scalar -> Properties
Emoji.is_emoji : Scalar -> Bool
Emoji.has_default_emoji_presentation : Scalar -> Bool
Emoji.is_modifier : Scalar -> Bool
Emoji.is_modifier_base : Scalar -> Bool
Emoji.is_component : Scalar -> Bool
Emoji.is_extended_pictographic : Scalar -> Bool
Emoji.variation_presentation : Scalar, Scalar -> [Some(Presentation), None]
Emoji.binary_short : Bool -> Str
Emoji.binary_long : Bool -> Str
Emoji.binary_alias_count : Bool -> U8
Emoji.binary_alias_at : Bool, U8 -> [Some(Str), None]
Emoji.parse_binary : Str -> Try(Bool, AliasError)
Emoji.fold_runs : Str, state, (state, Run -> state) -> state
Emoji.iter_runs : Str -> Iter(Run)
Emoji.Properties : Properties
Emoji.Presentation : [Text, Emoji]
Emoji.PropertyName : { short : Str, long : Str }
Emoji.Run : { range : TextRange, value : Properties }
Emoji.AliasError : [UnknownAlias]
GeneralCategory.property_name : PropertyName
GeneralCategory.of_scalar : Scalar -> Value
GeneralCategory.short : Value -> Str
GeneralCategory.long : Value -> Str
GeneralCategory.alias_count : Value -> U8
GeneralCategory.alias_at : Value, U8 -> [Some(Str), None]
GeneralCategory.parse : Str -> Try(Value, AliasError)
GeneralCategory.fold_runs : Str, state, (state, Run -> state) -> state
GeneralCategory.iter_runs : Str -> Iter(Run)
GeneralCategory.Value : GeneralCategory
GeneralCategory.PropertyName : { short : Str, long : Str }
GeneralCategory.Run : { range : TextRange, value : Value }
GeneralCategory.AliasError : [UnknownAlias]
Grapheme.iter_ranges : Str -> Iter(ByteRange)
Grapheme.ranges : Str -> List(ByteRange)
Grapheme.slices : Str -> List(Str)
Grapheme.owned : Str -> List(Str)
Grapheme.Cursor
Grapheme.Cursor.init : { } -> Cursor
Grapheme.Cursor.push : Cursor, Str, state, (state, ByteRange -> state) -> Try({ cursor : Cursor, state : state }, Error)
Grapheme.Cursor.finish : Cursor, state, (state, ByteRange -> state) -> Try({ cursor : Cursor, state : state }, Error)
IndicPositionalCategory.property_name : PropertyName
IndicPositionalCategory.of_scalar : Scalar -> Value
IndicPositionalCategory.short : Value -> Str
IndicPositionalCategory.long : Value -> Str
IndicPositionalCategory.alias_count : Value -> U8
IndicPositionalCategory.alias_at : Value, U8 -> [Some(Str), None]
IndicPositionalCategory.parse : Str -> Try(Value, AliasError)
IndicPositionalCategory.fold_runs : Str, state, (state, Run -> state) -> state
IndicPositionalCategory.iter_runs : Str -> Iter(Run)
IndicPositionalCategory.Value : Value
IndicPositionalCategory.PropertyName : { short : Str, long : Str }
IndicPositionalCategory.Run : { range : TextRange, value : Value }
IndicPositionalCategory.AliasError : [UnknownAlias]
IndicSyllabicCategory.property_name : PropertyName
IndicSyllabicCategory.of_scalar : Scalar -> Value
IndicSyllabicCategory.short : Value -> Str
IndicSyllabicCategory.long : Value -> Str
IndicSyllabicCategory.alias_count : Value -> U8
IndicSyllabicCategory.alias_at : Value, U8 -> [Some(Str), None]
IndicSyllabicCategory.parse : Str -> Try(Value, AliasError)
IndicSyllabicCategory.fold_runs : Str, state, (state, Run -> state) -> state
IndicSyllabicCategory.iter_runs : Str -> Iter(Run)
IndicSyllabicCategory.Value : Value
IndicSyllabicCategory.PropertyName : { short : Str, long : Str }
IndicSyllabicCategory.Run : { range : TextRange, value : Value }
IndicSyllabicCategory.AliasError : [UnknownAlias]
JoiningGroup.property_name : PropertyName
JoiningGroup.of_scalar : Scalar -> Value
JoiningGroup.short : Value -> Str
JoiningGroup.long : Value -> Str
JoiningGroup.alias_count : Value -> U8
JoiningGroup.alias_at : Value, U8 -> [Some(Str), None]
JoiningGroup.parse : Str -> Try(Value, AliasError)
JoiningGroup.fold_runs : Str, state, (state, Run -> state) -> state
JoiningGroup.iter_runs : Str -> Iter(Run)
JoiningGroup.Value : Value
JoiningGroup.PropertyName : { short : Str, long : Str }
JoiningGroup.Run : { range : TextRange, value : Value }
JoiningGroup.AliasError : [UnknownAlias]
JoiningType.property_name : PropertyName
JoiningType.of_scalar : Scalar -> Value
JoiningType.short : Value -> Str
JoiningType.long : Value -> Str
JoiningType.alias_count : Value -> U8
JoiningType.alias_at : Value, U8 -> [Some(Str), None]
JoiningType.parse : Str -> Try(Value, AliasError)
JoiningType.fold_runs : Str, state, (state, Run -> state) -> state
JoiningType.iter_runs : Str -> Iter(Run)
JoiningType.Value : Value
JoiningType.PropertyName : { short : Str, long : Str }
JoiningType.Run : { range : TextRange, value : Value }
JoiningType.AliasError : [UnknownAlias]
LineBreak.default_profile : Profile
LineBreak.preserve_graphemes_revision : ProfileRevision
LineBreak.profile_revision : Profile -> [None, Some(ProfileRevision)]
LineBreak.iter_boundaries : Str -> Iter(BreakBoundary)
LineBreak.iter_boundaries_with : Str, Profile -> Iter(BreakBoundary)
LineBreak.iter_opportunities : Str -> Iter(BreakOpportunity)
LineBreak.iter_opportunities_with : Str, Profile -> Iter(BreakOpportunity)
LineBreak.boundaries : Str -> List(BreakBoundary)
LineBreak.boundaries_with : Str, Profile -> List(BreakBoundary)
LineBreak.opportunities : Str -> List(BreakOpportunity)
LineBreak.opportunities_with : Str, Profile -> List(BreakOpportunity)
LineBreak.Profile : [UnicodeDefault, PreserveGraphemes]
LineBreak.ProfileRevision : [PreserveGraphemesV1]
LineBreak.Decision : [Mandatory, Allowed, Prohibited]
LineBreak.Authority : [NonTailorable, Tailorable]
LineBreak.BreakBoundary : BoundaryRecord
LineBreak.BreakOpportunity : OpportunityRecord
LineBreak.Cursor
LineBreak.Cursor.init : { } -> Cursor
LineBreak.Cursor.init_with : Profile -> Cursor
LineBreak.Cursor.push : Cursor, Str, state, (state, BreakOpportunity -> state) -> [Pushed({ cursor : Cursor, state : state, consumed : U64 }), Failed({ cursor : Cursor, state : state, consumed : U64, error : Error })]
LineBreak.Cursor.finish : Cursor, state, (state, BreakOpportunity -> state) -> [End({ cursor : Cursor, state : state }), Failed({ cursor : Cursor, state : state, error : Error })]
Property.default_ignorable_property : PropertyName
Property.variation_selector_property : PropertyName
Property.of_scalar : Scalar -> Row
Property.is_default_ignorable : Scalar -> Bool
Property.is_variation_selector : Scalar -> Bool
Property.binary_short : Bool -> Str
Property.binary_long : Bool -> Str
Property.binary_alias_count : Bool -> U8
Property.binary_alias_at : Bool, U8 -> [Some(Str), None]
Property.parse_binary : Str -> Try(Bool, AliasError)
Property.fold : Str, state, (state, Entry -> state) -> state
Property.iter : Str -> Iter(Entry)
Property.Row := { scalar : Scalar, row_id : RowId }
Property.Row.general_category : Row -> Value
Property.Row.canonical_combining_class : Row -> CanonicalCombiningClass
Property.Row.east_asian_width : Row -> Value
Property.Row.bidi_class : Row -> Value
Property.Row.bidi_mirrored : Row -> Bool
Property.Row.bidi_mirroring_glyph : Row -> [Some(Scalar), None]
Property.Row.bidi_paired_bracket : Row -> [Some(PairedBracket), None]
Property.Row.joining_type : Row -> Value
Property.Row.joining_group : Row -> Value
Property.Row.indic_syllabic_category : Row -> Value
Property.Row.indic_positional_category : Row -> Value
Property.Row.default_ignorable : Row -> Bool
Property.Row.variation_selector : Row -> Bool
Property.Row.vertical_orientation : Row -> Value
Property.Row.emoji : Row -> Properties
Property.Entry : { located : LocatedScalar, row : Row }
Property.PropertyName : { short : Str, long : Str }
Property.AliasError : [UnknownAlias]
Scalar.from_u32 : U32 -> Try(Scalar, [InvalidScalar])
Scalar.from_code_point : CodePoint -> Try(Scalar, [Surrogate])
Scalar.to_u32 : Scalar -> U32
Scalar.to_code_point : Scalar -> CodePoint
Scalar.iter : Str -> Iter(LocatedScalar)
Scalar.utf8_len : Scalar -> U8
Scalar.to_utf8 : Scalar -> List(U8)
Scalar.append_utf8 : List(U8), Scalar, U64 -> Try(List(U8), [OutputLimitExceeded({ limit : U64, required : U64 })])
Scalar.to_str : Scalar -> Try(Str, [InternalEncodingFault])
Scalar.is_eq : Scalar, Scalar -> Bool
Scalar.LocatedScalar : { scalar : Scalar, byte_range : ByteRange, scalar_index : U64 }
ScalarRange.from_bounds : U64, U64 -> Try(ScalarRange, BoundsError)
ScalarRange.start : ScalarRange -> U64
ScalarRange.end : ScalarRange -> U64
ScalarRange.len : ScalarRange -> U64
ScalarRange.is_empty : ScalarRange -> Bool
ScalarRange.is_eq : ScalarRange, ScalarRange -> Bool
ScalarRange.BoundsError : [EndBeforeStart]
Script.of_scalar : Scalar -> Value
Script.extensions_of_scalar : Scalar -> ScriptSet
Script.from_alias : Str -> Try(Value, [UnrecognizedScriptAlias])
Script.short_alias : Value -> Str
Script.long_alias : Value -> Str
Script.alias_count : Value -> U8
Script.alias_at : Value, U8 -> [Some(Str), None]
Script.is_common : Value -> Bool
Script.is_inherited : Value -> Bool
Script.is_unknown : Value -> Bool
Script.is_explicit : Value -> Bool
Script.singleton : Value -> ScriptSet
Script.contains : ScriptSet, Value -> Bool
Script.len : ScriptSet -> U64
Script.intersection : ScriptSet, ScriptSet -> [Some(ScriptSet), None]
Script.explicit_members : ScriptSet -> [Some(ScriptSet), None]
Script.is_eq_set : ScriptSet, ScriptSet -> Bool
Script.compare : ScriptSet, ScriptSet -> [Before, Equal, After]
Script.at : ScriptSet, U8 -> [Some(Value), None]
Script.walk : ScriptSet, state, (state, Value -> state) -> state
Script.to_list : ScriptSet -> List(Value)
Script.Value := [Adlm, Aghb, Ahom, Arab, Armi, Armn, Avst, Bali, Bamu, Bass, Batk, Beng, Berf, Bhks, Bopo, Brah, Brai, Bugi, Buhd, Cakm, Cans, Cari, Cham, Cher, Chrs, Copt, Cpmn, Cprt, Cyrl, Deva, Diak, Dogr, Dsrt, Dupl, Egyp, Elba, Elym, Ethi, Gara, Geor, Glag, Gong, Gonm, Goth, Gran, Grek, Gujr, Gukh, Guru, Hang, Hani, Hano, Hatr, Hebr, Hira, Hluw, Hmng, Hmnp, Hrkt, Hung, Ital, Java, Kali, Kana, Kawi, Khar, Khmr, Khoj, Kits, Knda, Krai, Kthi, Lana, Laoo, Latn, Lepc, Limb, Lina, Linb, Lisu, Lyci, Lydi, Mahj, Maka, Mand, Mani, Marc, Medf, Mend, Merc, Mero, Mlym, Modi, Mong, Mroo, Mtei, Mult, Mymr, Nagm, Nand, Narb, Nbat, Newa, Nkoo, Nshu, Ogam, Olck, Onao, Orkh, Orya, Osge, Osma, Ougr, Palm, Pauc, Perm, Phag, Phli, Phlp, Phnx, Plrd, Prti, Rjng, Rohg, Runr, Samr, Sarb, Saur, Sgnw, Shaw, Shrd, Sidd, Sidt, Sind, Sinh, Sogd, Sogo, Sora, Soyo, Sund, Sunu, Sylo, Syrc, Tagb, Takr, Tale, Talu, Taml, Tang, Tavt, Tayo, Telu, Tfng, Tglg, Thaa, Thai, Tibt, Tirh, Tnsa, Todr, Tols, Toto, Tutg, Ugar, Vaii, Vith, Wara, Wcho, Xpeo, Xsux, Yezi, Yiii, Zanb, Zinh, Zyyy, Zzzz]
Script.Value.is_eq : _
Script.ScriptSet := { word0 : U64, word1 : U64, word2 : U64, length : U8 }
ScriptItemization.policy_revision : Str
ScriptItemization.default : ConservativeScxV1
ScriptItemization.with_preferred : List(Value) -> ConservativeScxV1
ScriptItemization.iter_runs : Str, ConservativeScxV1 -> Iter(Run)
ScriptItemization.fold_runs : Str, ConservativeScxV1, state, (state, Run -> state) -> state
ScriptItemization.runs : Str, ConservativeScxV1 -> List(Run)
ScriptItemization.cursor_init : ConservativeScxV1, U64 -> Cursor
ScriptItemization.cursor_push : Cursor, Str, state, (state, Run -> state) -> [Pushed({ cursor : Cursor, state : state }), Failed({ cursor : Cursor, state : state, error : Error })]
ScriptItemization.cursor_finish : Cursor, state, (state, Run -> state) -> [FinishedCursor({ cursor : Cursor, state : state }), Failed({ cursor : Cursor, state : state, error : Error })]
ScriptItemization.ConservativeScxV1 := { preferred_scripts : List(Value) }
ScriptItemization.Run : { range : TextRange, script : Value }
ScriptItemization.Cursor := { machine : Machine, cluster : ClusterState, byte_offset : U64, scalar_offset : U64, pending : List(Unit), left : ExplicitNeighbor, last : [NoRun, LastRun(Run)], policy : ConservativeScxV1, max_pending_units : U64, status : CursorStatus }
ScriptItemization.Error : CursorError
TextPosition.from_offsets : U64, U64 -> TextPosition
TextPosition.byte_offset : TextPosition -> U64
TextPosition.scalar_offset : TextPosition -> U64
TextPosition.is_eq : TextPosition, TextPosition -> Bool
TextRange.from_ranges : ByteRange, ScalarRange -> TextRange
TextRange.from_positions : TextPosition, TextPosition -> Try(TextRange, BoundsError)
TextRange.start : TextRange -> TextPosition
TextRange.end : TextRange -> TextPosition
TextRange.byte_range : TextRange -> ByteRange
TextRange.scalar_range : TextRange -> ScalarRange
TextRange.is_empty : TextRange -> Bool
TextRange.is_eq : TextRange, TextRange -> Bool
TextRange.BoundsError : [ByteEndBeforeStart, ScalarEndBeforeStart]
UnicodeVersion.current : UnicodeVersion
UnicodeVersion.major : UnicodeVersion -> U16
UnicodeVersion.minor : UnicodeVersion -> U16
UnicodeVersion.patch : UnicodeVersion -> U16
UnicodeVersion.to_str : UnicodeVersion -> Str
UnicodeVersion.is_eq : UnicodeVersion, UnicodeVersion -> Bool
Utf8.Problem := [InvalidStartByte, UnexpectedEndOfSequence, ExpectedContinuation, OverlongEncoding, EncodesSurrogateHalf, CodePointTooLarge]
Utf8.Problem.is_eq : _
Utf8.DecodeError : { problem : Problem, offset : U64, sequence_start : U64 }
Utf8.Cursor
Utf8.Cursor.init : { } -> Cursor
Utf8.Cursor.push : Cursor, List(U8), state, (state, LocatedScalar -> [Continue(state), Stop(state)]) -> [Pushed({ cursor : Cursor, state : state, consumed : U64 }), Stopped({ cursor : Cursor, state : state, consumed : U64 }), Failed({ cursor : Cursor, state : state, consumed : U64, error : Error })]
Utf8.Cursor.finish : Cursor -> [End({ cursor : Cursor, byte_offset : U64, scalar_count : U64 }), Failed({ cursor : Cursor, error : Error })]
VerticalOrientation.property_name : PropertyName
VerticalOrientation.of_scalar : Scalar -> Value
VerticalOrientation.short : Value -> Str
VerticalOrientation.long : Value -> Str
VerticalOrientation.alias_count : Value -> U8
VerticalOrientation.alias_at : Value, U8 -> [Some(Str), None]
VerticalOrientation.parse : Str -> Try(Value, AliasError)
VerticalOrientation.fold_runs : Str, state, (state, Run -> state) -> state
VerticalOrientation.iter_runs : Str -> Iter(Run)
VerticalOrientation.Value : Value
VerticalOrientation.PropertyName : { short : Str, long : Str }
VerticalOrientation.Run : { range : TextRange, value : Value }
VerticalOrientation.AliasError : [UnknownAlias]
Word.iter_ranges : Str -> Iter(ByteRange)
Word.fold_ranges : Str, state, (state, ByteRange -> state) -> state
Word.ranges : Str -> List(ByteRange)
Word.slices : Str -> List(Str)
Word.owned : Str -> List(Str)
Word.Cursor
Word.Cursor.init : { } -> Cursor
Word.Cursor.push : Cursor, Str, state, (state, ByteRange -> state) -> [Pushed({ cursor : Cursor, state : state, consumed : U64 }), Failed({ cursor : Cursor, state : state, consumed : U64, error : Error })]
Word.Cursor.finish : Cursor, state, (state, ByteRange -> state) -> [End({ cursor : Cursor, state : state }), Failed({ cursor : Cursor, state : state, error : Error })]

Made by people who like to make nice things.