Sign in

    moonbit-community/harfbuzz/ot/var does not have a README file

    VarError

    pub suberror VarError {
    UnexpectedEof
    InvalidFormat
    } derive(Eq, Show, ToJson)

    AvarMapping

    pub struct AvarMapping {
    from_raw : Int
    to_raw : Int
    } derive(Eq, Show, ToJson)

    AvarSegmentMap

    pub struct AvarSegmentMap {
    mappings : Array[AvarMapping]
    } derive(Eq, Show, ToJson)

    AvarSegmentMap::map_value

    fn AvarSegmentMap::map_value(self : AvarSegmentMap, value : Double) -> Double

    AvarTable

    pub struct AvarTable {
    axes : Array[AvarSegmentMap]
    } derive(Eq, Show, ToJson)

    AvarTable::axis_count

    fn AvarTable::axis_count(self : AvarTable) -> Int

    AvarTable::map_coords_16_16

    fn AvarTable::map_coords_16_16(self : AvarTable, coords : Array[Int]) -> Array[Int]

    AvarTable::parse

    fn AvarTable::parse(data : BytesView) -> Result[AvarTable, VarError]

    AxisCoord

    pub struct AxisCoord {
    tag :
    Tag

    value : Double
    } derive(Eq, Show, ToJson)

    AxisCoord::new

    AxisRecord

    pub struct AxisRecord {
    tag :
    Tag

    min_value : Double
    default_value : Double
    max_value : Double
    flags : Int
    name_id : Int
    } derive(Eq, Show, ToJson)

    AxisRecord::normalize_value

    fn AxisRecord::normalize_value(self : AxisRecord, value : Double) -> Double

    CffIndex

    type CffIndex derive(Show, ToJson)

    CvarTable

    pub struct CvarTable {
    version : Int
    tuple_data : TupleVariationData
    } derive(Show, ToJson)

    CvarTable::apply_to_cvt

    fn CvarTable::apply_to_cvt(self : CvarTable, cvt : Array[Int], coords : Array[Int]) -> Result[Array[Int], VarError]

    CvarTable::cvt_deltas

    fn CvarTable::cvt_deltas(self : CvarTable, coords : Array[Int], point_count : Int) -> Result[Array[Double], VarError]

    CvarTable::parse

    fn CvarTable::parse(data : BytesView, axis_count : Int) -> Result[CvarTable, VarError]

    DeltaSetIndexMap

    pub struct DeltaSetIndexMap {
    map_count : Int
    width : Int
    inner_bit_count : Int
    map_data : Bytes
    } derive(Eq, Show, ToJson)

    DeltaSetIndexMap::map

    fn DeltaSetIndexMap::map(self : DeltaSetIndexMap, value : UInt) -> UInt

    DeltaSetIndexMap::parse

    fn DeltaSetIndexMap::parse(data : BytesView, offset : Int) -> Result[DeltaSetIndexMap, VarError]

    FvarTable

    pub struct FvarTable {
    axes : Array[AxisRecord]
    instances : Array[InstanceRecord]
    } derive(Eq, Show, ToJson)

    FvarTable::axes

    FvarTable::axis_index

    fn FvarTable::axis_index(self : FvarTable, tag :
    Tag
    ) -> Int?

    FvarTable::instances

    fn FvarTable::instances(self : FvarTable) -> ArrayView[InstanceRecord]

    FvarTable::normalize_axis_value

    fn FvarTable::normalize_axis_value(self : FvarTable, axis_index : Int, value : Double) -> Double

    FvarTable::normalize_design_coords

    fn FvarTable::normalize_design_coords(self : FvarTable, coords : Array[Double]) -> Array[Int]

    FvarTable::parse

    fn FvarTable::parse(data : BytesView) -> Result[FvarTable, VarError]

    GvarTable

    pub struct GvarTable {
    axis_count : Int
    shared_tuple_count : Int
    shared_tuples_offset : Int
    glyph_count : Int
    flags : Int
    data_offset : Int
    offsets : Array[Int]
    data : Bytes
    } derive(Show, ToJson)

    GvarTable::glyph_deltas

    fn GvarTable::glyph_deltas(self : GvarTable, glyph : Int, coords : Array[Int], point_count : Int) -> Result[(Array[Double], Array[Double]?), VarError]

    GvarTable::glyph_tuple_variations

    fn GvarTable::glyph_tuple_variations(self : GvarTable, glyph : Int) -> Result[TupleVariationData?, VarError]

    GvarTable::glyph_variation_data

    fn GvarTable::glyph_variation_data(self : GvarTable, glyph : Int) -> Bytes?

    GvarTable::parse

    fn GvarTable::parse(data : BytesView) -> Result[GvarTable, VarError]

    GvarTable::shared_tuples

    fn GvarTable::shared_tuples(self : GvarTable) -> Result[Array[Int], VarError]

    HvarTable

    pub struct HvarTable {
    var_store : ItemVariationStore
    adv_map : DeltaSetIndexMap?
    lsb_map : DeltaSetIndexMap?
    rsb_map : DeltaSetIndexMap?
    } derive(Show, ToJson)

    HvarTable::advance_delta

    fn HvarTable::advance_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

    HvarTable::lsb_delta

    fn HvarTable::lsb_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

    HvarTable::parse

    fn HvarTable::parse(data : BytesView) -> Result[HvarTable, VarError]

    HvarTable::rsb_delta

    fn HvarTable::rsb_delta(self : HvarTable, glyph : UInt, coords : Array[Int]) -> Double

    InstanceRecord

    pub struct InstanceRecord {
    subfamily_name_id : Int
    flags : Int
    coordinates : Array[Double]
    postscript_name_id : Int?
    } derive(Eq, Show, ToJson)

    ItemVariationStore

    pub struct ItemVariationStore {
    region_list : VarRegionList
    data_sets : Array[VarData]
    } derive(Eq, Show, ToJson)

    ItemVariationStore::get_delta

    fn ItemVariationStore::get_delta(self : ItemVariationStore, var_idx : UInt, coords : Array[Int]) -> Double

    ItemVariationStore::parse

    fn ItemVariationStore::parse(data : BytesView) -> Result[ItemVariationStore, VarError]

    ItemVariationStore::region_count

    fn ItemVariationStore::region_count(self : ItemVariationStore, outer : Int) -> Int?

    ItemVariationStore::region_scalars

    fn ItemVariationStore::region_scalars(self : ItemVariationStore, outer : Int, coords : Array[Int]) -> Array[Double]?

    MultiItemVariationStore

    pub struct MultiItemVariationStore {
    region_list : SparseVarRegionList
    data_sets : Array[MultiVarData]
    } derive(Show, ToJson)

    MultiItemVariationStore::get_delta

    fn MultiItemVariationStore::get_delta(self : MultiItemVariationStore, var_idx : UInt, coords : Array[Int], out : Array[Double]) -> Unit

    MultiItemVariationStore::parse

    fn MultiItemVariationStore::parse(data : BytesView) -> Result[MultiItemVariationStore, VarError]

    MultiVarData

    pub struct MultiVarData {
    region_indices : Array[Int]
    delta_sets : CffIndex
    } derive(Show, ToJson)

    MvarRecord

    pub struct MvarRecord {
    tag :
    Tag

    var_idx : UInt
    } derive(Eq, Show, ToJson)

    MvarTable

    pub struct MvarTable {
    records : Array[MvarRecord]
    var_store : ItemVariationStore
    } derive(Show, ToJson)

    MvarTable::get_var

    fn MvarTable::get_var(self : MvarTable, tag :
    Tag
    , coords : Array[Int]) -> Double

    MvarTable::parse

    fn MvarTable::parse(data : BytesView) -> Result[MvarTable, VarError]

    SparseVarRegionAxis

    pub struct SparseVarRegionAxis {
    axis_index : Int
    axis : VarRegionAxis
    } derive(Eq, Show, ToJson)

    SparseVarRegionList

    pub struct SparseVarRegionList {
    regions : Array[SparseVariationRegion]
    } derive(Eq, Show, ToJson)

    SparseVariationRegion

    pub struct SparseVariationRegion {
    axes : Array[SparseVarRegionAxis]
    } derive(Eq, Show, ToJson)

    TupleHeader

    type TupleHeader derive(Show, ToJson)

    TupleVariation

    pub struct TupleVariation {
    peak : Array[Int]
    start : Array[Int]?
    end : Array[Int]?
    indices : Array[Int]?
    deltas_x : Array[Int]
    deltas_y : Array[Int]?
    } derive(Show, ToJson)

    TupleVariation::scalar

    fn TupleVariation::scalar(self : TupleVariation, coords : Array[Int]) -> Double

    TupleVariationData

    pub struct TupleVariationData {
    axis_count : Int
    tuple_headers : Array[TupleHeader]
    shared_points : Array[Int]?
    shared_points_size : Int
    data_offset : Int
    data : Bytes
    } derive(Show, ToJson)

    TupleVariationData::apply

    fn TupleVariationData::apply(self : TupleVariationData, coords : Array[Int], point_count : Int, is_gvar : Bool) -> Result[(Array[Double], Array[Double]?), VarError]

    TupleVariationData::decode

    fn TupleVariationData::decode(self : TupleVariationData, point_count : Int, is_gvar : Bool) -> Result[Array[TupleVariation], VarError]

    TupleVariationData::parse

    fn TupleVariationData::parse(data : BytesView, axis_count : Int, shared_tuples : Array[Int]) -> Result[TupleVariationData, VarError]

    VarData

    pub(all) struct VarData {
    item_count : Int
    word_count : Int
    long_words : Bool
    region_indices : Array[Int]
    deltas : Bytes
    } derive(Eq, Show, ToJson)

    VarRegionAxis

    pub(all) struct VarRegionAxis {
    start_coord : Int
    peak_coord : Int
    end_coord : Int
    } derive(Eq, Show, ToJson)

    VarRegionList

    pub(all) struct VarRegionList {
    axis_count : Int
    region_count : Int
    axes : Array[VarRegionAxis]
    } derive(Eq, Show, ToJson)

    VarcComponent

    pub struct VarcComponent {
    glyph : Int
    visible : Bool
    axis_indices : Array[Int]
    axis_values : Array[Double]
    coords : Array[Int]
    transform : VarcTransform
    } derive(Show, ToJson)

    VarcCondition

    pub enum VarcCondition {
    AxisRange(Int, Int, Int)
    Value(Int, Int)
    And(Array[VarcCondition])
    Or(Array[VarcCondition])
    Not(VarcCondition)
    } derive(Show, ToJson)

    VarcCondition::evaluate

    fn VarcCondition::evaluate(self : VarcCondition, coords : Array[Int], var_delta : (Int) -> Double?) -> Bool

    VarcTable

    pub struct VarcTable {
    version : Int
    coverage_offset : Int
    var_store_offset : Int
    condition_list_offset : Int
    axis_indices_offset : Int
    glyph_records_offset : Int
    data : Bytes
    } derive(Show, ToJson)

    VarcTable::axis_indices

    fn VarcTable::axis_indices(self : VarcTable, index : Int) -> Result[Array[Int], VarError]

    VarcTable::conditions

    fn VarcTable::conditions(self : VarcTable) -> Result[Array[VarcCondition], VarError]

    VarcTable::glyph_components

    fn VarcTable::glyph_components(self : VarcTable, glyph : Int, coords : Array[Int], base_coords : Array[Int]) -> Result[Array[VarcComponent], VarError]

    VarcTable::glyph_record

    fn VarcTable::glyph_record(self : VarcTable, glyph : Int) -> Result[Bytes?, VarError]

    VarcTable::parse

    fn VarcTable::parse(data : BytesView) -> Result[VarcTable, VarError]

    VarcTable::var_store

    fn VarcTable::var_store(self : VarcTable) -> Result[MultiItemVariationStore?, VarError]

    VarcTransform

    pub struct VarcTransform {
    translate_x : Double
    translate_y : Double
    rotation : Double
    scale_x : Double
    scale_y : Double
    skew_x : Double
    skew_y : Double
    tcenter_x : Double
    tcenter_y : Double
    } derive(Show, ToJson)

    VarcTransform::apply_to_bounds

    fn VarcTransform::apply_to_bounds(self : VarcTransform, x_min : Double, y_min : Double, x_max : Double, y_max : Double) -> (Double, Double, Double, Double)

    VarcTransform::apply_to_point

    fn VarcTransform::apply_to_point(self : VarcTransform, x : Double, y : Double) -> (Double, Double)

    fixed16_to_f2dot14

    fn fixed16_to_f2dot14(raw : Int) -> Int