README

moonbit-community/harfbuzz/common does not have a README file

#
CodepointBiMap

pub struct CodepointBiMap {
forward : CodepointMap
backward : CodepointMap
}

#
CodepointBiMap::backward

fn CodepointBiMap::backward(self : CodepointBiMap, rhs : UInt) -> UInt

#
CodepointBiMap::clear

fn CodepointBiMap::clear(self : CodepointBiMap) -> Unit

#
CodepointBiMap::del

fn CodepointBiMap::del(self : CodepointBiMap, lhs : UInt) -> Unit

#
CodepointBiMap::get

fn CodepointBiMap::get(self : CodepointBiMap, lhs : UInt) -> UInt

#
CodepointBiMap::has

fn CodepointBiMap::has(self : CodepointBiMap, lhs : UInt) -> Bool

#
CodepointBiMap::is_empty

fn CodepointBiMap::is_empty(self : CodepointBiMap) -> Bool

#
CodepointBiMap::keys

fn CodepointBiMap::keys(self : CodepointBiMap) -> Array[UInt]

#
CodepointBiMap::new

#
CodepointBiMap::population

fn CodepointBiMap::population(self : CodepointBiMap) -> Int

#
CodepointBiMap::set

fn CodepointBiMap::set(self : CodepointBiMap, lhs : UInt, rhs : UInt) -> Unit

#
CodepointBiMap::values

fn CodepointBiMap::values(self : CodepointBiMap) -> Array[UInt]

#
CodepointIncBiMap

pub struct CodepointIncBiMap {
forward : CodepointMap
back : Array[UInt]
}

#
CodepointIncBiMap::add

fn CodepointIncBiMap::add(self : CodepointIncBiMap, lhs : UInt) -> UInt

#
CodepointIncBiMap::add_set

fn CodepointIncBiMap::add_set(self : CodepointIncBiMap, set : CodepointSet) -> Unit

#
CodepointIncBiMap::backward

fn CodepointIncBiMap::backward(self : CodepointIncBiMap, rhs : UInt) -> UInt

#
CodepointIncBiMap::clear

fn CodepointIncBiMap::clear(self : CodepointIncBiMap) -> Unit

#
CodepointIncBiMap::get

fn CodepointIncBiMap::get(self : CodepointIncBiMap, lhs : UInt) -> UInt

#
CodepointIncBiMap::get_next_value

fn CodepointIncBiMap::get_next_value(self : CodepointIncBiMap) -> UInt

#
CodepointIncBiMap::has

fn CodepointIncBiMap::has(self : CodepointIncBiMap, lhs : UInt) -> Bool

#
CodepointIncBiMap::identity

fn CodepointIncBiMap::identity(self : CodepointIncBiMap, size : Int) -> Bool

#
CodepointIncBiMap::new

#
CodepointIncBiMap::population

fn CodepointIncBiMap::population(self : CodepointIncBiMap) -> Int

#
CodepointIncBiMap::skip

fn CodepointIncBiMap::skip(self : CodepointIncBiMap, count? : Int) -> UInt

#
CodepointIncBiMap::sort

fn CodepointIncBiMap::sort(self : CodepointIncBiMap) -> Unit

#
CodepointMap

pub struct CodepointMap {
map : Map[UInt, UInt]
}

#
CodepointMap::clear

fn CodepointMap::clear(self : CodepointMap) -> Unit

#
CodepointMap::copy

#
CodepointMap::del

fn CodepointMap::del(self : CodepointMap, key : UInt) -> Unit

#
CodepointMap::get

fn CodepointMap::get(self : CodepointMap, key : UInt) -> UInt

#
CodepointMap::has

fn CodepointMap::has(self : CodepointMap, key : UInt) -> Bool

#
CodepointMap::hash

fn CodepointMap::hash(self : CodepointMap) -> Int

#
CodepointMap::is_empty

fn CodepointMap::is_empty(self : CodepointMap) -> Bool

#
CodepointMap::is_equal

fn CodepointMap::is_equal(self : CodepointMap, other : CodepointMap) -> Bool

#
CodepointMap::iter

fn CodepointMap::iter(self : CodepointMap) -> Iter[(UInt, UInt)]

#
CodepointMap::keys

fn CodepointMap::keys(self : CodepointMap) -> Array[UInt]

#
CodepointMap::keys_set

fn CodepointMap::keys_set(self : CodepointMap) -> CodepointSet

#
CodepointMap::new

#
CodepointMap::next

fn CodepointMap::next(self : CodepointMap, idx? : Int) -> (Int, UInt, UInt)?

Iterate entries in a deterministic order (by key). Returns (next_index, key, value).

#
CodepointMap::population

fn CodepointMap::population(self : CodepointMap) -> Int

#
CodepointMap::set

fn CodepointMap::set(self : CodepointMap, key : UInt, value : UInt) -> Unit

#
CodepointMap::update

fn CodepointMap::update(self : CodepointMap, other : CodepointMap) -> Unit

#
CodepointMap::values

fn CodepointMap::values(self : CodepointMap) -> Array[UInt]

#
CodepointMap::values_set

fn CodepointMap::values_set(self : CodepointMap) -> CodepointSet

#
CodepointSet

pub struct CodepointSet {
set :
Set
[UInt]
}

#
CodepointSet::add

fn CodepointSet::add(self : CodepointSet, value : UInt) -> Unit

#
CodepointSet::add_array

fn CodepointSet::add_array(self : CodepointSet, values : ArrayView[UInt]) -> Unit

#
CodepointSet::add_range

fn CodepointSet::add_range(self : CodepointSet, first : UInt, last : UInt) -> Bool

#
CodepointSet::add_sorted_array

fn CodepointSet::add_sorted_array(self : CodepointSet, values : ArrayView[UInt]) -> Bool

#
CodepointSet::clear

fn CodepointSet::clear(self : CodepointSet) -> Unit

#
CodepointSet::del

fn CodepointSet::del(self : CodepointSet, value : UInt) -> Unit

#
CodepointSet::del_range

fn CodepointSet::del_range(self : CodepointSet, first : UInt, last : UInt) -> Unit

#
CodepointSet::get_max

fn CodepointSet::get_max(self : CodepointSet) -> UInt

#
CodepointSet::get_min

fn CodepointSet::get_min(self : CodepointSet) -> UInt

#
CodepointSet::has

fn CodepointSet::has(self : CodepointSet, value : UInt) -> Bool

#
CodepointSet::hash

fn CodepointSet::hash(self : CodepointSet) -> Int

#
CodepointSet::intersect

fn CodepointSet::intersect(self : CodepointSet, other : CodepointSet) -> CodepointSet

#
CodepointSet::intersect_in_place

fn CodepointSet::intersect_in_place(self : CodepointSet, other : CodepointSet) -> Unit

#
CodepointSet::intersects

fn CodepointSet::intersects(self : CodepointSet, first : UInt, last : UInt) -> Bool

#
CodepointSet::is_empty

fn CodepointSet::is_empty(self : CodepointSet) -> Bool

#
CodepointSet::is_equal

fn CodepointSet::is_equal(self : CodepointSet, other : CodepointSet) -> Bool

#
CodepointSet::is_subset

fn CodepointSet::is_subset(self : CodepointSet, other : CodepointSet) -> Bool

#
CodepointSet::may_intersect

fn CodepointSet::may_intersect(self : CodepointSet, other : CodepointSet) -> Bool

#
CodepointSet::new

#
CodepointSet::next

fn CodepointSet::next(self : CodepointSet, after? : UInt) -> UInt?

Return the next value after after (exclusive). Use codepoint_invalid to start.

#
CodepointSet::next_many

fn CodepointSet::next_many(self : CodepointSet, after? : UInt, size? : Int) -> Array[UInt]

#
CodepointSet::next_range

fn CodepointSet::next_range(self : CodepointSet, start? : UInt) -> (UInt, UInt)?

Return the next contiguous range at or after start.

#
CodepointSet::population

fn CodepointSet::population(self : CodepointSet) -> Int

#
CodepointSet::previous

fn CodepointSet::previous(self : CodepointSet, before? : UInt) -> UInt?

Return the previous value before before (exclusive). Use codepoint_invalid to start.

#
CodepointSet::previous_range

fn CodepointSet::previous_range(self : CodepointSet, end? : UInt) -> (UInt, UInt)?

Return the previous contiguous range ending at or before end.

#
CodepointSet::set_from

fn CodepointSet::set_from(self : CodepointSet, other : CodepointSet) -> Unit

#
CodepointSet::subtract

fn CodepointSet::subtract(self : CodepointSet, other : CodepointSet) -> CodepointSet

#
CodepointSet::subtract_in_place

fn CodepointSet::subtract_in_place(self : CodepointSet, other : CodepointSet) -> Unit

#
CodepointSet::symmetric_difference_in_place

fn CodepointSet::symmetric_difference_in_place(self : CodepointSet, other : CodepointSet) -> Unit

#
CodepointSet::to_sorted_array

fn CodepointSet::to_sorted_array(self : CodepointSet) -> Array[UInt]

#
CodepointSet::union

fn CodepointSet::union(self : CodepointSet, other : CodepointSet) -> CodepointSet

#
CodepointSet::union_in_place

fn CodepointSet::union_in_place(self : CodepointSet, other : CodepointSet) -> Unit

#
Direction

pub struct Direction {
raw : UInt
} derive(Eq, Show, ToJson)

Text direction with HarfBuzz-compatible numeric layout.

#
Direction::from_string

fn Direction::from_string(s : String, len? : Int) -> Direction

Convert a string to a direction (matches by first letter).

#
Direction::is_backward

fn Direction::is_backward(self : Direction) -> Bool

True when the direction moves backward.

#
Direction::is_forward

fn Direction::is_forward(self : Direction) -> Bool

True when the direction moves forward.

#
Direction::is_horizontal

fn Direction::is_horizontal(self : Direction) -> Bool

True when the direction is horizontal.

#
Direction::is_valid

fn Direction::is_valid(self : Direction) -> Bool

True when the direction is valid.

#
Direction::is_vertical

fn Direction::is_vertical(self : Direction) -> Bool

True when the direction is vertical.

#
Direction::reverse

fn Direction::reverse(self : Direction) -> Direction

Reverse a valid direction; invalid stays invalid.

#
Direction::to_string

fn Direction::to_string(self : Direction) -> String

Convert a direction to its string name.

#
Direction::to_uint

fn Direction::to_uint(self : Direction) -> UInt

Access the raw numeric representation.

#
Language

pub struct Language {
tag : String
} derive(Eq, Show, ToJson)

Language tag (BCP 47), stored in canonical lowercase form.

#
Language::as_string

fn Language::as_string(self : Language) -> String

Access the canonical language tag.

#
Language::from_string

fn Language::from_string(s : String, len? : Int) -> Language

Convert a string to a language value.

#
Language::is_valid

fn Language::is_valid(self : Language) -> Bool

True when the language is valid.

#
Language::matches

fn Language::matches(self : Language, specific : Language) -> Bool

Check whether specific is the same or more specific than self.

#
Language::to_string

fn Language::to_string(self : Language) -> String?

Return the canonical string, or None for invalid.

#
OverflowRecord

pub struct OverflowRecord {
parent : Int
child : Int
offset : Int
min : Int
max : Int
width : Int
is_signed : Bool
} derive(Eq, Show)

#
Script

pub struct Script {
tag : Tag
} derive(Eq, Show, ToJson)

Script tag (ISO 15924), stored as a Tag.

#
Script::from_iso15924_tag

fn Script::from_iso15924_tag(tag : Tag) -> Script

Convert an ISO 15924 tag to a script.

#
Script::from_string

fn Script::from_string(s : String, len? : Int) -> Script

Convert an ISO 15924 string to a script.

#
Script::horizontal_direction

fn Script::horizontal_direction(self : Script) -> Direction

Fetch the horizontal direction for the script.

#
Script::to_iso15924_tag

fn Script::to_iso15924_tag(self : Script) -> Tag

Convert a script to its ISO 15924 tag.

#
Script::to_tag

fn Script::to_tag(self : Script) -> Tag

Access the underlying tag.

#
SerializeError

pub enum SerializeError {
InvalidWidth
OutOfBounds
OffsetOverflow
InvalidLink
NegativeOffset
VirtualOrder
} derive(Eq, Show)

pub(all) struct SerializeLink {
width : Int
position : Int
objidx : Int
is_signed : Bool
whence : SerializeWhence
bias : Int
}

#
SerializeLink::new

fn SerializeLink::new(width : Int, position : Int, objidx : Int, is_signed? : Bool, whence? : SerializeWhence, bias? : Int) -> SerializeLink

#
SerializeObject

pub struct SerializeObject {
data : Bytes
real_links : Array[SerializeLink]
virtual_links : Array[Int]
}

#
SerializeObject::new

fn SerializeObject::new(data : Bytes) -> SerializeObject

#
SerializeWhence

pub(all) enum SerializeWhence {
Head
Tail
Absolute
} derive(Eq, Show)

#
Tag

pub struct Tag {
value : UInt
} derive(Eq, Hash, Show, ToJson)

Tag identifier (four bytes).

#
Tag::bytes

fn Tag::bytes(self : Tag) -> (Byte, Byte, Byte, Byte)

Extract the four bytes of the tag, in big-endian order.

#
Tag::from_bytes

fn Tag::from_bytes(b1 : Byte, b2 : Byte, b3 : Byte, b4 : Byte) -> Tag

Construct a tag from four bytes.

#
Tag::from_chars

fn Tag::from_chars(c1 : Char, c2 : Char, c3 : Char, c4 : Char) -> Tag

Construct a tag from four characters.

#
Tag::from_string

fn Tag::from_string(s : String, len? : Int) -> Tag

Construct a tag from a string, padding with spaces when shorter than 4.

#
Tag::to_string

fn Tag::to_string(self : Tag) -> String

Convert a tag to a four-character string.

#
Tag::to_uint

fn Tag::to_uint(self : Tag) -> UInt

Return the raw 32-bit value of the tag.

#
codepoint_invalid

let codepoint_invalid : UInt

#
direction_btt

let direction_btt : Direction

Bottom-to-top.

#
direction_invalid

let direction_invalid : Direction

Unset direction.

#
direction_ltr

let direction_ltr : Direction

Left-to-right.

#
direction_rtl

let direction_rtl : Direction

Right-to-left.

#
direction_ttb

let direction_ttb : Direction

Top-to-bottom.

#
language_invalid

let language_invalid : Language

Invalid language value.

#
map_value_invalid

let map_value_invalid : UInt

#
pack_object_order

fn pack_object_order(objects : ArrayView[SerializeObject]) -> Result[Array[Int], SerializeError]

Compute a packed order that satisfies virtual links.

#
parse_double

fn parse_double(s : StringView, start? : Int, end? : Int, whole? : Bool) -> (Double, Int)?

Parse a double from s[start:end). Returns (value, next_index) on success.

#
parse_int

fn parse_int(s : StringView, start? : Int, end? : Int, whole? : Bool) -> (Int, Int)?

Parse a signed integer from s[start:end). Returns (value, next_index) on success.

#
parse_uint

fn parse_uint(s : StringView, start? : Int, end? : Int, whole? : Bool, base? : Int) -> (UInt, Int)?

Parse an unsigned integer from s[start:end) with optional base. Returns (value, next_index).

#
repack_object_order

fn repack_object_order(objects : ArrayView[SerializeObject], max_iterations? : Int) -> Result[Array[Int], SerializeError]

#
script_adlam

let script_adlam : Script

#
script_ahom

let script_ahom : Script

#
script_anatolian_hieroglyphs

let script_anatolian_hieroglyphs : Script

#
script_arabic

let script_arabic : Script

#
script_armenian

let script_armenian : Script

#
script_avestan

let script_avestan : Script

#
script_balinese

let script_balinese : Script

#
script_bamum

let script_bamum : Script

#
script_bassa_vah

let script_bassa_vah : Script

#
script_batak

let script_batak : Script

#
script_bengali

let script_bengali : Script

#
script_beria_erfe

let script_beria_erfe : Script

#
script_bhaiksuki

let script_bhaiksuki : Script

#
script_bopomofo

let script_bopomofo : Script

#
script_brahmi

let script_brahmi : Script

#
script_braille

let script_braille : Script

#
script_buginese

let script_buginese : Script

#
script_buhid

let script_buhid : Script

#
script_canadian_syllabics

let script_canadian_syllabics : Script

#
script_carian

let script_carian : Script

#
script_caucasian_albanian

let script_caucasian_albanian : Script

#
script_chakma

let script_chakma : Script

#
script_cham

let script_cham : Script

#
script_cherokee

let script_cherokee : Script

#
script_chorasmian

let script_chorasmian : Script

#
script_common

let script_common : Script

#
script_coptic

let script_coptic : Script

#
script_cuneiform

let script_cuneiform : Script

#
script_cypriot

let script_cypriot : Script

#
script_cypro_minoan

let script_cypro_minoan : Script

#
script_cyrillic

let script_cyrillic : Script

#
script_deseret

let script_deseret : Script

#
script_devanagari

let script_devanagari : Script

#
script_dives_akuru

let script_dives_akuru : Script

#
script_dogra

let script_dogra : Script

#
script_duployan

let script_duployan : Script

#
script_egyptian_hieroglyphs

let script_egyptian_hieroglyphs : Script

#
script_elbasan

let script_elbasan : Script

#
script_elymaic

let script_elymaic : Script

#
script_ethiopic

let script_ethiopic : Script

#
script_garay

let script_garay : Script

#
script_georgian

let script_georgian : Script

#
script_glagolitic

let script_glagolitic : Script

#
script_gothic

let script_gothic : Script

#
script_grantha

let script_grantha : Script

#
script_greek

let script_greek : Script

#
script_gujarati

let script_gujarati : Script

#
script_gunjala_gondi

let script_gunjala_gondi : Script

#
script_gurmukhi

let script_gurmukhi : Script

#
script_gurung_khema

let script_gurung_khema : Script

#
script_han

let script_han : Script

#
script_hangul

let script_hangul : Script

#
script_hanifi_rohingya

let script_hanifi_rohingya : Script

#
script_hanunoo

let script_hanunoo : Script

#
script_hatran

let script_hatran : Script

#
script_hebrew

let script_hebrew : Script

#
script_hiragana

let script_hiragana : Script

#
script_imperial_aramaic

let script_imperial_aramaic : Script

#
script_inherited

let script_inherited : Script

#
script_inscriptional_pahlavi

let script_inscriptional_pahlavi : Script

#
script_inscriptional_parthian

let script_inscriptional_parthian : Script

#
script_invalid

let script_invalid : Script

#
script_javanese

let script_javanese : Script

#
script_kaithi

let script_kaithi : Script

#
script_kannada

let script_kannada : Script

#
script_katakana

let script_katakana : Script

#
script_kawi

let script_kawi : Script

#
script_kayah_li

let script_kayah_li : Script

#
script_kharoshthi

let script_kharoshthi : Script

#
script_khitan_small_script

let script_khitan_small_script : Script

#
script_khmer

let script_khmer : Script

#
script_khojki

let script_khojki : Script

#
script_khudawadi

let script_khudawadi : Script

#
script_kirat_rai

let script_kirat_rai : Script

#
script_lao

let script_lao : Script

#
script_latin

let script_latin : Script

#
script_lepcha

let script_lepcha : Script

#
script_limbu

let script_limbu : Script

#
script_linear_a

let script_linear_a : Script

#
script_linear_b

let script_linear_b : Script

#
script_lisu

let script_lisu : Script

#
script_lycian

let script_lycian : Script

#
script_lydian

let script_lydian : Script

#
script_mahajani

let script_mahajani : Script

#
script_makasar

let script_makasar : Script

#
script_malayalam

let script_malayalam : Script

#
script_mandaic

let script_mandaic : Script

#
script_manichaean

let script_manichaean : Script

#
script_marchen

let script_marchen : Script

#
script_masaram_gondi

let script_masaram_gondi : Script

#
script_math

let script_math : Script

#
script_medefaidrin

let script_medefaidrin : Script

#
script_meetei_mayek

let script_meetei_mayek : Script

#
script_mende_kikakui

let script_mende_kikakui : Script

#
script_meroitic_cursive

let script_meroitic_cursive : Script

#
script_meroitic_hieroglyphs

let script_meroitic_hieroglyphs : Script

#
script_miao

let script_miao : Script

#
script_modi

let script_modi : Script

#
script_mongolian

let script_mongolian : Script

#
script_mro

let script_mro : Script

#
script_multani

let script_multani : Script

#
script_myanmar

let script_myanmar : Script

#
script_nabataean

let script_nabataean : Script

#
script_nag_mundari

let script_nag_mundari : Script

#
script_nandinagari

let script_nandinagari : Script

#
script_new_tai_lue

let script_new_tai_lue : Script

#
script_newa

let script_newa : Script

#
script_nko

let script_nko : Script

#
script_nushu

let script_nushu : Script

#
script_nyiakeng_puachue_hmong

let script_nyiakeng_puachue_hmong : Script

#
script_ogham

let script_ogham : Script

#
script_ol_chiki

let script_ol_chiki : Script

#
script_ol_onal

let script_ol_onal : Script

#
script_old_hungarian

let script_old_hungarian : Script

#
script_old_italic

let script_old_italic : Script

#
script_old_north_arabian

let script_old_north_arabian : Script

#
script_old_permic

let script_old_permic : Script

#
script_old_persian

let script_old_persian : Script

#
script_old_sogdian

let script_old_sogdian : Script

#
script_old_south_arabian

let script_old_south_arabian : Script

#
script_old_turkic

let script_old_turkic : Script

#
script_old_uyghur

let script_old_uyghur : Script

#
script_oriya

let script_oriya : Script

#
script_osage

let script_osage : Script

#
script_osmanya

let script_osmanya : Script

#
script_pahawh_hmong

let script_pahawh_hmong : Script

#
script_palmyrene

let script_palmyrene : Script

#
script_pau_cin_hau

let script_pau_cin_hau : Script

#
script_phags_pa

let script_phags_pa : Script

#
script_phoenician

let script_phoenician : Script

#
script_psalter_pahlavi

let script_psalter_pahlavi : Script

#
script_rejang

let script_rejang : Script

#
script_runic

let script_runic : Script

#
script_samaritan

let script_samaritan : Script

#
script_saurashtra

let script_saurashtra : Script

#
script_sharada

let script_sharada : Script

#
script_shavian

let script_shavian : Script

#
script_siddham

let script_siddham : Script

#
script_sidetic

let script_sidetic : Script

#
script_signwriting

let script_signwriting : Script

#
script_sinhala

let script_sinhala : Script

#
script_sogdian

let script_sogdian : Script

#
script_sora_sompeng

let script_sora_sompeng : Script

#
script_soyombo

let script_soyombo : Script

#
script_sundanese

let script_sundanese : Script

#
script_sunuwar

let script_sunuwar : Script

#
script_syloti_nagri

let script_syloti_nagri : Script

#
script_syriac

let script_syriac : Script

#
script_tagalog

let script_tagalog : Script

#
script_tagbanwa

let script_tagbanwa : Script

#
script_tai_le

let script_tai_le : Script

#
script_tai_tham

let script_tai_tham : Script

#
script_tai_viet

let script_tai_viet : Script

#
script_tai_yo

let script_tai_yo : Script

#
script_takri

let script_takri : Script

#
script_tamil

let script_tamil : Script

#
script_tangsa

let script_tangsa : Script

#
script_tangut

let script_tangut : Script

#
script_telugu

let script_telugu : Script

#
script_thaana

let script_thaana : Script

#
script_thai

let script_thai : Script

#
script_tibetan

let script_tibetan : Script

#
script_tifinagh

let script_tifinagh : Script

#
script_tirhuta

let script_tirhuta : Script

#
script_todhri

let script_todhri : Script

#
script_tolong_siki

let script_tolong_siki : Script

#
script_toto

let script_toto : Script

#
script_tulu_tigalari

let script_tulu_tigalari : Script

#
script_ugaritic

let script_ugaritic : Script

#
script_unknown

let script_unknown : Script

#
script_vai

let script_vai : Script

#
script_vithkuqi

let script_vithkuqi : Script

#
script_wancho

let script_wancho : Script

#
script_warang_citi

let script_warang_citi : Script

#
script_yezidi

let script_yezidi : Script

#
script_yi

let script_yi : Script

#
script_zanabazar_square

let script_zanabazar_square : Script

#
serialize_objects

fn serialize_objects(objects : ArrayView[SerializeObject]) -> Result[Bytes, SerializeError]

Serialize objects into a contiguous buffer, patching offsets for real links.

#
serialize_objects_in_order

fn serialize_objects_in_order(objects : ArrayView[SerializeObject], order : ArrayView[Int]) -> Result[Bytes, SerializeError]

Serialize objects in a provided order.

#
serialize_objects_packed

fn serialize_objects_packed(objects : ArrayView[SerializeObject]) -> Result[Bytes, SerializeError]

Serialize objects after packing them to satisfy virtual link ordering.

#
serialize_objects_packed_with_order

fn serialize_objects_packed_with_order(objects : ArrayView[SerializeObject]) -> Result[(Bytes, Array[Int]), SerializeError]

Serialize objects after packing them to satisfy virtual link ordering, returning the order.

#
serialize_objects_repacked

fn serialize_objects_repacked(objects : ArrayView[SerializeObject], max_iterations? : Int) -> Result[Bytes, SerializeError]

#
serialize_objects_repacked_with_order

fn serialize_objects_repacked_with_order(objects : ArrayView[SerializeObject], max_iterations? : Int) -> Result[(Bytes, Array[Int]), SerializeError]

#
serialize_objects_with_offsets

fn serialize_objects_with_offsets(objects : ArrayView[SerializeObject]) -> Result[(Bytes, Array[Int]), SerializeError]

Serialize objects and return their start offsets in the original order.

#
tag_max

let tag_max : Tag

Maximum possible unsigned tag.

#
tag_max_signed

let tag_max_signed : Tag

Maximum possible signed tag.

#
tag_none

let tag_none : Tag

Unset tag.