Harfrust

https://docs.rs/harfrust/
Admin
Harfrust is a complete HarfBuzz shaping algorithm port to Rust that enables complex text layout and...
Tokens:376,274
Snippets:1,783
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Setup Masks

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Configures feature masks for the buffer, including fractional slash handling, shaper-specific mask setup, and applying masks for individual features based on their tags and ranges.

```rust
fn setup_masks(ctx: &mut hb_ot_shape_context_t) {
    setup_masks_fraction(ctx);

    if let Some(func) = ctx.plan.shaper.setup_masks {
        func(ctx.plan, ctx.face, ctx.buffer);
    }

    for feature in ctx.features {
        if !feature.is_global() {
            let (mask, shift) = ctx.plan.ot_map.get_mask(feature.tag);
            ctx.buffer
                .set_masks(feature.value << shift, mask, feature.start, feature.end);
        }
    }
}
```

--------------------------------

### Setup Masks

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_use.rs.html

Allocates variables and sets up categories for shaping masks.

```rust
fn setup_masks(plan: &hb_ot_shape_plan_t, _: &hb_font_t, buffer: &mut hb_buffer_t) {
    let universal_plan = plan.data::<UniversalShapePlan>();

    // Do this before allocating use_category().
    if let Some(ref arabic_plan) = universal_plan.arabic_plan {
        crate::hb::ot_shaper_arabic::setup_masks_inner(arabic_plan, plan.script, buffer);
    }

    buffer.allocate_var(GlyphInfo::USE_CATEGORY_VAR);

    // We cannot setup masks here. We save information about characters
    // and setup masks later on in a pause-callback.
    for info in buffer.info_slice_mut() {
        info.set_use_category(super::ot_shaper_use_table::hb_use_get_category(
            info.glyph_id as usize,
        ));
    }
}
```

--------------------------------

### Setup Myanmar Character Properties

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_myanmar.rs.html

Allocates necessary variables for Myanmar character properties and iterates through the buffer to set these properties for each character. This is a setup step before shaping.

```rust
buffer.allocate_var(GlyphInfo::MYANMAR_CATEGORY_VAR);
    buffer.allocate_var(GlyphInfo::MYANMAR_POSITION_VAR);

    // No masks, we just save information about characters.
    for info in buffer.info_slice_mut() {
        info.set_myanmar_properties();
    }
```

--------------------------------

### Setup Khmer Category Masks

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_khmer.rs.html

Allocates a variable for Khmer category and sets properties for each glyph info. Mask setup is deferred to a pause-callback.

```rust
fn setup_masks(_: &hb_ot_shape_plan_t, _: &hb_font_t, buffer: &mut hb_buffer_t) {
    buffer.allocate_var(GlyphInfo::KHMER_CATEGORY_VAR);

    // We cannot setup masks here.  We save information about characters
    // and setup masks later on in a pause-callback.
    for info in buffer.info_slice_mut() {
        info.set_khmer_properties();
    }
}
```

--------------------------------

### Khmer Syllable Machine Start State

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_khmer_machine.rs.html

Defines the starting state for the Khmer syllable machine.

```rust
static khmer_syllable_machine_start: i32 = 21;
```

--------------------------------

### Setup Masks Fraction

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Conditionally sets up masks related to fractional slashes if the buffer has them and the plan supports fractions.

```rust
fn setup_masks_fraction(ctx: &mut hb_ot_shape_context_t) {
    let buffer = &mut ctx.buffer;
    if buffer.scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_FRACTION_SLASH == 0 || !ctx.plan.has_frac {
        return;
    }
    
}
```

--------------------------------

### Myanmar Syllable Machine Configuration

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_myanmar_machine.rs.html

Constants defining the starting state and error conditions for the machine.

```rust
static myanmar_syllable_machine_start: i32 = 0;
static myanmar_syllable_machine_first_final: i32 = 0;
static myanmar_syllable_machine_error: i32 = -1;
static myanmar_syllable_machine_en_main: i32 = 0;
```

--------------------------------

### Get table directory

Source: https://docs.rs/harfrust/latest/harfrust/struct.FontRef.html

Returns a reference to the font's table directory, which contains metadata about the font's tables.

```rust
pub fn table_directory(&self) -> &TableRef<'a, TableDirectoryMarker>
```

--------------------------------

### BufferFlags::empty() - Get Empty Flags

Source: https://docs.rs/harfrust/latest/harfrust/struct.BufferFlags.html

Returns a BufferFlags value with all bits unset. Use this as a starting point when no flags are required.

```rust
pub const fn empty() -> Self
```

--------------------------------

### Initialize hb_ot_map_builder_t

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_map.rs.html

Constructs a new `hb_ot_map_builder_t` instance. It initializes script and language indices by querying the font's layout tables.

```rust
pub fn new(
        face: &'a hb_font_t<'a>,
        script: Option<Script>,
        language: Option<&Language>,
    ) -> Self {
        // Fetch script/language indices for GSUB/GPOS.  We need these later to skip
        // features not available in either table and not waste precious bits for them.
        let (script_tags, lang_tags) = tag::tags_from_script_and_language(script, language);

        let mut found_script = [false; 2];
        let mut script_index = [None; 2];
        let mut chosen_script = [None; 2];
        let mut lang_index = [None; 2];

        for (table_index, table) in face.layout_tables() {
            if let Some((found, idx, tag)) = table.select_script(&script_tags) {
                chosen_script[table_index] = Some(tag);
                found_script[table_index] = found;
                script_index[table_index] = Some(idx);

                if let Some(idx) = table.select_script_language(idx, &lang_tags) {
                    lang_index[table_index] = Some(idx);
                }
            }
        }

        Self {
            face,
            found_script,
            script_index,
            chosen_script,
            lang_index,
            current_stage: [0, 0],
            feature_infos: Vec::new(),
            stages: [Vec::new(), Vec::new()],
            is_simple: false,
        }
    }
```

--------------------------------

### Get TypeId

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlan.html

Gets the `TypeId` of the current type. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Text Preprocessing Entry Point

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_thai.rs.html

Entry point for shaping logic, referencing external documentation for Thai OT shaping rules.

```rust
fn preprocess_text(plan: &hb_ot_shape_plan_t, face: &hb_font_t, buffer: &mut hb_buffer_t) {
    // This function implements the shaping logic documented here:
    //
    //   https://linux.thai.net/~thep/th-otf/shaping.html
    //
    // The first shaping rule listed there is needed even if the font has Thai
    // OpenType tables.  The rest do fallback positioning based on PUA codepoints.
}
```

--------------------------------

### Implement NoUninit for T

Source: https://docs.rs/harfrust/latest/harfrust/struct.GlyphPosition.html

Indicates that types implementing Pod do not require special handling for uninitialized memory.

```rust
impl<T> NoUninit for T
where T: Pod,

```

--------------------------------

### TableProvider: Get data for tag

Source: https://docs.rs/harfrust/latest/harfrust/struct.FontRef.html

Implementation of the TableProvider trait to get data for a specific table tag.

```rust
fn data_for_tag(&self, tag: Tag) -> Option<FontData<'a>>
```

--------------------------------

### Initialize AAT Apply Context

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/aat/layout_common.rs.html

Creates a new `AatApplyContext` with the provided shaping plan, font face, and buffer. Initializes `has_glyph_classes` based on the font face.

```rust
impl<'a> AatApplyContext<'a> {
    pub fn new(
        plan: &'a hb_ot_shape_plan_t,
        face: &'a hb_font_t<'a>,
        buffer: &'a mut hb_buffer_t,
    ) -> Self {
        Self {
            plan,
            face,
            buffer,
            has_glyph_classes: face.ot_tables.has_glyph_classes(),
            range_flags: None,
            subtable_flags: 0,
            buffer_is_reversed: false,
            using_buffer_glyph_set: false,
            first_set: None,
            second_set: None,
            machine_class_cache: None,
            start_end_safe_to_break: 0,
        }
    }
// ... other methods
```

--------------------------------

### Create New ShapePlanKey

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape_plan.rs.html

Initializes a new shape plan key with the specified script and direction. Language and features are initially unset.

```rust
pub fn new(script: Option<Script>, direction: Direction) -> Self {
        Self {
            script,
            direction,
            language: None,
            feature_variations: [None; 2],
            features: &[],
        }
    }
```

--------------------------------

### Buffer Management and Navigation Methods

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/buffer.rs.html

Methods for checking buffer state, pushing strings, and managing pre/post context for glyph processing.

```rust
    /// Checks that buffer contains no elements.
    pub fn is_empty(&self) -> bool {
        self.len == 0
    }

    fn push_str(&mut self, text: &str) {
        if !self.ensure(self.len + text.chars().count()) {
            return;
        }

        for (i, c) in text.char_indices() {
            self.info[self.len] = GlyphInfo {
                glyph_id: c as u32,
                cluster: i as u32,
                ..GlyphInfo::default()
            };
            self.len += 1;
        }
    }

    fn set_pre_context(&mut self, text: &str) {
        self.clear_context(0);
        for (i, c) in text.chars().rev().enumerate().take(CONTEXT_LENGTH) {
            self.context[0][i] = c as Codepoint;
            self.context_len[0] += 1;
        }
    }

    fn set_post_context(&mut self, text: &str) {
        self.clear_context(1);
        for (i, c) in text.chars().enumerate().take(CONTEXT_LENGTH) {
            self.context[1][i] = c as Codepoint;
            self.context_len[1] += 1;
        }
    }

    pub fn next_syllable(&self, mut start: usize) -> usize {
        if start >= self.len {
            return start;
        }

        let syllable = self.info[start].syllable();
        start += 1;
        while start < self.len && syllable == self.info[start].syllable() {
            start += 1;
        }

        start
    }

    #[inline]
    pub fn allocate_lig_id(&mut self) -> u8 {
        let mut lig_id = self.next_serial() & 0x07;

        if lig_id == 0 {
            lig_id = self.allocate_lig_id();
        }

        lig_id
    }
```

--------------------------------

### Check if breaking text at cluster start requires re-shaping

Source: https://docs.rs/harfrust/latest/harfrust/struct.GlyphInfo.html

Indicates if re-shaping is necessary when text is broken at the start of the cluster this glyph belongs to. If false, it's safe to break and shape sides separately, useful for optimizing paragraph layout.

```rust
pub fn unsafe_to_break(&self) -> bool
```

--------------------------------

### Configure Arabic Feature Planning

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_arabic.rs.html

Sets up OpenType features and GSUB pauses required for correct Arabic script shaping.

```rust
fn collect_features(planner: &mut hb_ot_shape_planner_t) {
    planner
        .ot_map
        .enable_feature(hb_tag_t::new(b"stch"), F_NONE, 1);
    planner.ot_map.add_gsub_pause(Some(record_stch));

    planner
        .ot_map
        .enable_feature(hb_tag_t::new(b"ccmp"), F_MANUAL_ZWJ, 1);
    planner
        .ot_map
        .enable_feature(hb_tag_t::new(b"locl"), F_MANUAL_ZWJ, 1);

    planner.ot_map.add_gsub_pause(None);

    for feature in ARABIC_FEATURES {
        let has_fallback = planner.script == Some(script::ARABIC) && !feature_is_syriac(*feature);
        let flags = if has_fallback { F_HAS_FALLBACK } else { F_NONE };
        planner
            .ot_map
            .add_feature(*feature, F_MANUAL_ZWJ | flags, 1);
        planner.ot_map.add_gsub_pause(None);
    }
    planner.ot_map.add_gsub_pause(Some(deallocate_buffer_var));

    planner
        .ot_map
        .enable_feature(hb_tag_t::new(b"rlig"), F_MANUAL_ZWJ | F_HAS_FALLBACK, 1);
}
```

--------------------------------

### Get ShapePlan Language

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlan.html

Retrieves the language associated with the ShapePlan.

```rust
pub fn language(&self) -> Option<&Language>
```

--------------------------------

### Get Default ShaperInstance

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShaperInstance.html

Returns the default value for the ShaperInstance type.

```rust
fn default() -> ShaperInstance
```

--------------------------------

### Implement CloneToUninit for T

Source: https://docs.rs/harfrust/latest/harfrust/enum.BufferClusterLevel.html

Nightly-only experimental API for copying data to uninitialized memory. Use with caution.

```rust
impl<T> CloneToUninit for T where T: Clone {}
```

--------------------------------

### Buffer Creation and Initialization

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/buffer.rs.html

Details the creation of a new Harfbuzz buffer and its default initial state.

```APIDOC
## POST /buffer/new

### Description
Creates a new `Buffer` instance with default settings.

### Method
POST

### Endpoint
`/buffer/new`

### Request Body
None

### Response
#### Success Response (200)
- **Buffer** (object) - A new `Buffer` instance.

### Response Example
```json
{
  "flags": "empty",
  "cluster_level": "HB_BUFFER_CLUSTER_LEVEL_DEFAULT",
  "invisible": null,
  "scratch_flags": "HB_BUFFER_SCRATCH_FLAG_DEFAULT",
  "not_found_variation_selector": null,
  "max_len": "MAX_LEN_DEFAULT",
  "max_ops": "MAX_OPS_DEFAULT",
  "direction": "Invalid",
  "script": null,
  "language": null,
  "successful": true,
  "have_output": false,
  "have_positions": false,
  "idx": 0,
  "len": 0,
  "out_len": 0,
  "info": [],
  "pos": [],
  "have_separate_output": false,
  "allocated_var_bits": 0,
  "serial": 0,
  "context": {},
  "context_len": [0, 0],
  "digest": {},
  "glyph_set": {}
}
```
```

--------------------------------

### Get ShapePlan Script

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlan.html

Retrieves the script of the text associated with the ShapePlan.

```rust
pub fn script(&self) -> Option<Script>
```

--------------------------------

### Get ShapePlan Direction

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlan.html

Retrieves the text direction associated with the ShapePlan.

```rust
pub fn direction(&self) -> Direction
```

--------------------------------

### Initialize LookupInfo Structure

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot/lookup.rs.html

Constructs a LookupInfo object from raw font data, parsing lookup details and subtables. Handles caching modes and property extraction.

```rust
impl LookupInfo {
    pub fn new(data: &LookupData) -> Option<Self> {
        let mut info = Self {
            is_subst: data.is_subst,
            ..Default::default()
        };
        let lookup_data = data.table_data.split_off(data.offset)?;
        let lookup: Lookup<()> = Lookup::read(lookup_data).ok()?;
        let lookup_type = lookup.lookup_type();
        let lookup_flag = lookup.lookup_flag();
        info.props = u32::from(lookup.lookup_flag().to_bits());
        if lookup_flag.to_bits() & LookupFlag::USE_MARK_FILTERING_SET.to_bits() != 0 {
            info.props |= (lookup.mark_filtering_set().unwrap_or_default() as u32) << 16;
        }
        if data.is_subst {
            info.is_reversed =
                is_reversed(data.table_data, &lookup, data.offset).unwrap_or_default();
        }
        let mut subtable_cache_user_cost = 0;
        info.subtables.reserve(lookup.sub_table_count() as usize);
        for (idx, subtable_offset) in lookup.subtable_offsets().iter().enumerate() {
            let cache_mode = if idx < 8 {
                SubtableExternalCacheMode::Full
            } else {
                SubtableExternalCacheMode::Small
            };
            let subtable_offset = subtable_offset.get().to_usize() + data.offset;
            if let Some((subtable_info, cache_cost)) = SubtableInfo::new(
                data.table_data,
                subtable_offset as u32,
                data.is_subst,
                lookup_type as u8,
                cache_mode,
            ) {
                info.digest.union(&subtable_info.digest);
                if cache_cost > subtable_cache_user_cost {
                    info.subtable_cache_user_idx = Some(info.subtables.len());
                    subtable_cache_user_cost = cache_cost;
                }
                info.subtables.push(subtable_info);
            }
        }
        info.subtables.shrink_to_fit();
        Some(info)
    }
}
```

--------------------------------

### Apply State Machine Kerning

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/kerning.rs.html

Initializes the state machine driver and begins the kerning loop.

```rust
fn apply_state_machine_kerning(
    c: &mut AatApplyContext,
    subtable: &aat::StateTable,
    is_cross_stream: bool,
) {
    let mut driver = StateMachineDriver {
        stack: [0; 8],
        depth: 0,
    };

    let mut state = START_OF_TEXT;
    c.buffer.idx = 0;
    loop {
        let class = if c.buffer.idx < c.buffer.len {
            get_class(
                subtable,
```

--------------------------------

### Get Current Index

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_layout_gsubgpos.rs.html

Returns the current buffer index (`buf_idx`) of the iterator.

```rust
pub fn index(&self) -> usize {
        self.buf_idx
    }
```

--------------------------------

### Get glyph names iterator

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/face.rs.html

Returns an iterator over the glyph names in the font.

```rust
pub(crate) fn glyph_names(&self) -> GlyphNames<'a> {
        GlyphNames::new(&self.font)
    }
```

--------------------------------

### Initialize hb_ot_shape_planner_t

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Constructor for the planner that categorizes the shaper and determines AAT morx application.

```rust
impl<'a> hb_ot_shape_planner_t<'a> {
    pub fn new(
        face: &'a hb_font_t<'a>,
        direction: Direction,
        script: Option<Script>,
        language: Option<&Language>,
    ) -> Self {
        let ot_map = hb_ot_map_builder_t::new(face, script, language);
        let aat_map = AatMapBuilder::default();

        let mut shaper = match script {
            Some(script) => hb_ot_shape_complex_categorize(
                script,
                direction,
                ot_map.chosen_script(TableIndex::GSUB),
            ),
            None => &DEFAULT_SHAPER,
        };

        let script_zero_marks = shaper.zero_width_marks != HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE;
        let script_fallback_position = shaper.fallback_position;

        // https://github.com/harfbuzz/harfbuzz/issues/2124
        let apply_morx = face.aat_tables.morx.is_some()
            && (direction.is_horizontal() || face.ot_tables.gsub.is_none());

        // https://github.com/harfbuzz/harfbuzz/issues/1528
        if apply_morx && !ptr::eq(ptr::from_ref(shaper), ptr::from_ref(&DEFAULT_SHAPER)) {
            shaper = &DUMBER_SHAPER;
        }

        hb_ot_shape_planner_t {
            face,
            direction,
            script,
            language: language.cloned(),
            ot_map,
            aat_map,
            apply_morx,
            script_zero_marks,
            script_fallback_position,
            shaper,
        }
    }
```

--------------------------------

### GET /extents

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/glyph_metrics.rs.html

Retrieves the bounding box extents for a given glyph ID.

```APIDOC
## GET /extents

### Description
Calculates the bounding box (x_min, x_max, y_min, y_max) for a specified glyph ID.

### Method
GET

### Endpoint
/extents

### Parameters
#### Path Parameters
- **gid** (GlyphId) - Required - The identifier of the glyph.

#### Query Parameters
- **coords** (F2Dot14[]) - Optional - Coordinate array for variation adjustments.

### Response
#### Success Response (200)
- **x_min** (i32) - Minimum X coordinate
- **x_max** (i32) - Maximum X coordinate
- **y_min** (i32) - Minimum Y coordinate
- **y_max** (i32) - Maximum Y coordinate

#### Response Example
{
  "x_min": 0,
  "x_max": 500,
  "y_min": -100,
  "y_max": 800
}
```

--------------------------------

### Initialize MorxSubtableCache

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/aat/layout_morx_table.rs.html

Constructs a new cache by analyzing the subtable kind and collecting relevant glyph and break information.

```rust
pub(crate) struct MorxSubtableCache {
    start_end_safe_to_break: u64,
    glyph_set: U32Set,
    class_cache: ClassCache,
}

impl MorxSubtableCache {
    pub(crate) fn new(subtable: &Subtable, num_glyphs: u32) -> Self {
        let mut start_end_safe_to_break = 0u64;
        let mut glyph_set = U32Set::default();
        if let Ok(kind) = subtable.kind() {
            match &kind {
                SubtableKind::Rearrangement(table) => {
                    start_end_safe_to_break =
                        collect_start_end_safe_to_break::<_, RearrangementCtx>(table);
                    collect_initial_glyphs::<_, RearrangementCtx>(
                        table,
                        &mut glyph_set,
                        num_glyphs,
                    );
                }
                SubtableKind::Contextual(table) => {
                    start_end_safe_to_break =
                        collect_start_end_safe_to_break::<_, ContextualCtx>(&table.state_table);
                    collect_initial_glyphs::<_, ContextualCtx>(
                        &table.state_table,
                        &mut glyph_set,
                        num_glyphs,
                    );
                }
                SubtableKind::Ligature(table) => {
                    start_end_safe_to_break =
                        collect_start_end_safe_to_break::<_, LigatureCtx>(&table.state_table);
                    collect_initial_glyphs::<_, LigatureCtx>(
                        &table.state_table,
                        &mut glyph_set,
                        num_glyphs,
                    );
                }
                SubtableKind::NonContextual(ref lookup) => {
                    lookup.collect_glyphs(&mut glyph_set, num_glyphs);
                }
                SubtableKind::Insertion(table) => {
                    start_end_safe_to_break =
                        collect_start_end_safe_to_break::<_, InsertionCtx>(&table.state_table);
                    collect_initial_glyphs::<_, InsertionCtx>(
                        &table.state_table,
                        &mut glyph_set,
                        num_glyphs,
                    );
                }
            }
        };
        MorxSubtableCache {
            start_end_safe_to_break,
            glyph_set,
            class_cache: ClassCache::new(),
        }
    }
}
```

--------------------------------

### Get default GlyphInfo value

Source: https://docs.rs/harfrust/latest/harfrust/struct.GlyphInfo.html

Returns the default value for the GlyphInfo type.

```rust
fn default() -> GlyphInfo
```

--------------------------------

### Get vertical origin for a glyph

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/face.rs.html

Calculates the vertical origin of a glyph using its metrics.

```rust
pub(crate) fn glyph_v_origin(&self, glyph: GlyphId) -> i32 {
        self.glyph_metrics
            .v_origin(glyph, self.ot_tables.coords)
            .unwrap_or_default()
    }
```

--------------------------------

### Configure Shaping Plan

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Initializes the shaping plan with layout maps, feature masks, and positioning logic.

```rust
let apply_fallback_kern = !(apply_gpos || apply_kerx || apply_kern);
        let zero_marks = self.script_zero_marks
            && !apply_kerx
            && (!apply_kern || !hb_ot_layout_has_machine_kerning(self.face));

        let has_gpos_mark = ot_map.get_1_mask(hb_tag_t::new(b"mark")) != 0;

        let mut adjust_mark_positioning_when_zeroing = !apply_gpos
            && !apply_kerx
            && (!apply_kern || !hb_ot_layout_has_cross_kerning(self.face));

        let fallback_mark_positioning =
            adjust_mark_positioning_when_zeroing && self.script_fallback_position;

        // If we're using morx shaping, we cancel mark position adjustment because
        // Apple Color Emoji assumes this will NOT be done when forming emoji sequences;
        // https://github.com/harfbuzz/harfbuzz/issues/2967.
        if apply_morx {
            adjust_mark_positioning_when_zeroing = false;
        }

        // According to Ned, trak is applied by default for "modern fonts", as detected by presence of STAT table.
        // https://github.com/googlefonts/fontations/issues/1492
        let apply_trak = self.face.font.trak().is_ok()
            && self
                .face
                .font
                .table_directory
                .table_records()
                .iter()
                .any(|table| table.tag() == "STAT");

        let mut plan = hb_ot_shape_plan_t {
            direction: self.direction,
            script: self.script,
            language: self.language,
            shaper: self.shaper,
            ot_map,
            aat_map,
            data: None,
            frac_mask,
            numr_mask,
            dnom_mask,
            rtlm_mask,
            kern_mask,
            requested_kerning,
            has_frac,
            has_vert,
            has_gpos_mark,
            zero_marks,
            fallback_glyph_classes,
            fallback_mark_positioning,
            adjust_mark_positioning_when_zeroing,
            apply_gpos,
            apply_kern,
            apply_fallback_kern,
            apply_kerx,
            apply_morx,
            apply_trak,
            user_features: features.into(),
        };

        if let Some(func) = self.shaper.create_data {
            plan.data = Some(func(&plan));
        }

        plan
    }
}
```

--------------------------------

### Get zeroed GlyphInfo value

Source: https://docs.rs/harfrust/latest/harfrust/struct.GlyphInfo.html

Returns a GlyphInfo value with all bits set to zero.

```rust
fn zeroed() -> Self
```

--------------------------------

### ShapePlanKey Methods

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlanKey.html

Provides methods for creating and configuring a ShapePlanKey.

```APIDOC
## impl<'a> ShapePlanKey<'a>

### pub fn new(script: Option<Script>, direction: Direction) -> Self

Creates a new shape plan key with the given script and direction.

#### Parameters
- **script** (Option<Script>) - The script to use for the key.
- **direction** (Direction) - The direction to use for the key.

### pub fn language(self, language: Option<&'a Language>) -> Self

Sets the language to use for this shape plan key.

#### Parameters
- **language** (Option<&'a Language>) - The language to set.

### pub fn instance(self, instance: Option<&ShaperInstance>) -> Self

Sets the instance to use for this shape plan key.

#### Parameters
- **instance** (Option<&ShaperInstance>) - The shaper instance to set.

### pub fn features(self, features: &'a [Feature]) -> Self

Sets the features to use for this shape plan key.

#### Parameters
- **features** (&'a [Feature]) - The features to set.

### pub fn matches(&self, plan: &hb_ot_shape_plan_t) -> bool

Returns true if this key is a match for the given shape plan.

#### Parameters
- **plan** (&hb_ot_shape_plan_t) - The shape plan to check against.

#### Returns
- bool - True if the key matches the plan, false otherwise.

### Request Example
```rust
// let key = ShapePlanKey::new(Some(Script::Latin), Direction::LeftToRight)
//     .language(Some(&language))
//     .instance(Some(&instance))
//     .features(&features);
```

### Response Example
```rust
// The `matches` method returns a boolean.
// let is_match = key.matches(&shape_plan);
```
```

--------------------------------

### Positioning by Plan

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Applies positioning rules based on the shaping plan, supporting GPOS, AAT layout, kerning, fallback kerning, and tracking features.

```rust
fn position_by_plan(plan: &hb_ot_shape_plan_t, face: &hb_font_t, buffer: &mut hb_buffer_t) {
    if plan.apply_gpos {
        ot_layout_gpos_table::position(plan, face, buffer);
    } else if plan.apply_kerx {
        aat::layout::position(plan, face, buffer);
    }
    if plan.apply_kern {
        kerning::hb_ot_layout_kern(plan, face, buffer);
    } else if plan.apply_fallback_kern {
        ot_shape_fallback::_hb_ot_shape_fallback_kern(plan, face, buffer);
    }

    if plan.apply_trak {
        aat::layout::track(plan, face, buffer);
    }
}
```

--------------------------------

### Get ShaperInstance Coordinates

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShaperInstance.html

Returns the underlying set of normalized coordinates for the shaper instance.

```rust
pub fn coords(&self) -> &[F2Dot14]
```

--------------------------------

### Matcher Implementation

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_layout_gsubgpos.rs.html

Logic for initializing the matcher and performing glyph matching checks.

```rust
impl matcher_t {
    fn new(ctx: &hb_ot_apply_context_t, context_match: bool) -> Self {
        matcher_t {
            lookup_props: ctx.lookup_props,
            // Ignore ZWNJ if we are matching GPOS, or matching GSUB context and asked to.
            ignore_zwnj: ctx.table_index == TableIndex::GPOS || (context_match && ctx.auto_zwnj),
            // Ignore ZWJ if we are matching context, or asked to.
            ignore_zwj: context_match || ctx.auto_zwj,
            // Ignore hidden glyphs (like CGJ) during GPOS.
            ignore_hidden: ctx.table_index == TableIndex::GPOS,
            mask: if context_match {
                u32::MAX
            } else {
                ctx.lookup_mask()
            },
            /* Per syllable matching is only for GSUB. */
            per_syllable: ctx.table_index == TableIndex::GSUB && ctx.per_syllable,
        }
    }

    fn may_match(
        &self,
        info: &mut GlyphInfo,
        glyph_data: u16,
        match_func: Option<&impl Fn(&mut GlyphInfo, u16) -> bool>,
        syllable: u8,
    ) -> may_match_t {
        if (info.mask & self.mask) == 0
            || (self.per_syllable && syllable != 0 && syllable != info.syllable())
        {
            return may_match_t::MATCH_NO;
        }

        if let Some(match_func) = match_func {
            return if match_func(info, glyph_data) {
                may_match_t::MATCH_YES
            } else {
                may_match_t::MATCH_NO
            };
        }
        may_match_t::MATCH_YES
    }
}
```

--------------------------------

### Perform Default Substitution

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shape.rs.html

Handles character rotation, normalization, and mask setup during substitution.

```rust
fn hb_ot_substitute_default(ctx: &mut hb_ot_shape_context_t) {
    rotate_chars(ctx);

    ctx.buffer
        .allocate_var(GlyphInfo::NORMALIZER_GLYPH_INDEX_VAR);

    ot_shape_normalize::_hb_ot_shape_normalize(ctx.plan, ctx.buffer, ctx.face);

    setup_masks(ctx);

    // This is unfortunate to go here, but necessary...
    if ctx.plan.fallback_mark_positioning {
        ot_shape_fallback::_hb_ot_shape_fallback_mark_position_recategorize_marks(
            ctx.plan, ctx.face, ctx.buffer,
        );
    }

    map_glyphs_fast(ctx.buffer);

    ctx.buffer
        .deallocate_var(GlyphInfo::NORMALIZER_GLYPH_INDEX_VAR);
}
```

--------------------------------

### UnicodeBuffer Methods

Source: https://docs.rs/harfrust/latest/harfrust/struct.UnicodeBuffer.html

Methods for initializing, configuring, and managing the state of a UnicodeBuffer.

```APIDOC
## UnicodeBuffer Methods

### Description
Methods to manage the lifecycle and properties of a UnicodeBuffer instance.

### Methods
- **new()** -> UnicodeBuffer: Create a new buffer.
- **len()** -> usize: Returns the number of unicode codepoints.
- **reserve(size: usize)** -> bool: Ensures capacity for size codepoints.
- **is_empty()** -> bool: Checks if buffer is empty.
- **push_str(str: &str)**: Pushes a string to the buffer.
- **set_pre_context(str: &str)**: Sets pre-context.
- **set_post_context(str: &str)**: Sets post-context.
- **add(codepoint: char, cluster: u32)**: Appends a character with a cluster value.
- **set_direction(direction: Direction)**: Sets text direction.
- **direction()** -> Direction: Returns text direction.
- **set_script(script: Script)**: Sets script from ISO15924 tag.
- **script()** -> Script: Gets ISO15924 script tag.
- **set_language(lang: Language)**: Sets buffer language.
- **language()** -> Option<Language>: Gets buffer language.
- **guess_segment_properties()**: Guesses direction, language, and script.
- **set_flags(flags: BufferFlags)**: Sets buffer flags.
- **flags()** -> BufferFlags: Gets buffer flags.
- **set_cluster_level(cluster_level: BufferClusterLevel)**: Sets cluster level.
- **cluster_level()** -> BufferClusterLevel: Retrieves cluster level.
- **reset_clusters()**: Resets clusters.
- **clear()**: Clears buffer contents.
```

--------------------------------

### Constant MYANMAR

Source: https://docs.rs/harfrust/latest/harfrust/script/constant.MYANMAR.html

Represents the MYANMAR script. No setup or imports are required to use this constant.

```rust
pub const MYANMAR: Script;
```

--------------------------------

### Apply Kerning Layout

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/kerning.rs.html

Main entry point for applying kerning to a buffer based on the provided shape plan and font face.

```rust
pub fn hb_ot_layout_kern(
    plan: &hb_ot_shape_plan_t,
    face: &hb_font_t,
    buffer: &mut hb_buffer_t,
) -> Option<()> {
    let mut c = AatApplyContext::new(plan, face, buffer);

    let (kern, subtable_caches) = c.face.aat_tables.kern.as_ref()?;

    let mut subtable_idx = 0;

    let mut seen_cross_stream = false;
    for subtable in kern.subtables() {
        let Ok(subtable) = subtable else { continue };

        let subtable_cache = subtable_caches.get(subtable_idx);
        let Some(subtable_cache) = subtable_cache.as_ref() else {
            break;
        };
        subtable_idx += 1;

        if subtable.is_variable() {
            continue;
        }

        if c.buffer.direction.is_horizontal() != subtable.is_horizontal() {
            continue;
        }

        c.first_set = Some(&subtable_cache.first_set);
        c.second_set = Some(&subtable_cache.second_set);
        c.machine_class_cache = Some(&subtable_cache.class_cache);
        c.start_end_safe_to_break = subtable_cache.start_end_safe_to_break;

        if !c.buffer_intersects_machine() {
            continue;
        }

        let reverse = c.buffer.direction.is_backward();
        let is_cross_stream = subtable.is_cross_stream();

        if !seen_cross_stream && is_cross_stream {
            seen_cross_stream = true;

            // Attach all glyphs into a chain.
            for pos in &mut c.buffer.pos {
                pos.set_attach_type(attach_type::CURSIVE);
                pos.set_attach_chain(if c.buffer.direction.is_forward() {
                    -1
                } else {
                    1
                });
                // We intentionally don't set BufferScratchFlags::HAS_GPOS_ATTACHMENT,
                // since there needs to be a non-zero attachment for post-positioning to
                // be needed.
            }
        }

        let Ok(kind) = subtable.kind() else {
            continue;
        };

        if reverse != c.buffer_is_reversed {
            c.reverse_buffer();
        }

        match kind {
            SubtableKind::Format0(format0) if plan.requested_kerning => {
                apply_simple_kerning(&mut c, &format0, is_cross_stream);
            }
            SubtableKind::Format1(format1) => {
                apply_state_machine_kerning(&mut c, &format1, is_cross_stream);
            }
            SubtableKind::Format2(format2) if plan.requested_kerning => {
                apply_simple_kerning(&mut c, &format2, is_cross_stream);
            }
            SubtableKind::Format3(format3) if plan.requested_kerning => {
                apply_simple_kerning(&mut c, &format3, is_cross_stream);
            }
            _ => {}
        }
    }
    if c.buffer_is_reversed {
        c.reverse_buffer();
    }
    Some(())
}
```

--------------------------------

### FeatureEvent Ord and PartialOrd Implementation

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/aat/map.rs.html

Implements ordering for `FeatureEvent` based on index, then start status.

```rust
impl Ord for FeatureEvent {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

impl PartialOrd for FeatureEvent {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        if self.index != other.index {
            Some(self.index.cmp(&other.index))
        } else if self.start != other.start {
            Some(self.start.cmp(&other.start))
        } else {
            Some(Ordering::Equal)
        }
    }
}
```

--------------------------------

### Create UniversalShapePlan

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_use.rs.html

Constructor for UniversalShapePlan. It initializes the 'rphf_mask' and creates an 'arabic_plan' if the script has Arabic joining features.

```rust
impl UniversalShapePlan {
    fn new(plan: &hb_ot_shape_plan_t) -> UniversalShapePlan {
        let mut arabic_plan = None;

        if plan.script.is_some_and(has_arabic_joining) {
            arabic_plan = Some(crate::hb::ot_shaper_arabic::data_create_arabic(plan));
        }

        UniversalShapePlan {
            rphf_mask: plan.ot_map.get_1_mask(hb_tag_t::new(b"rphf")),
            arabic_plan,
        }
    }
}
```

--------------------------------

### MALAYALAM Script Constant

Source: https://docs.rs/harfrust/latest/harfrust/script/constant.MALAYALAM.html

Represents the Malayalam script. No setup or imports are required to use this constant.

```rust
pub const MALAYALAM: Script;
```

--------------------------------

### Initialize KerxSubtableCache

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/aat/layout_kerx_table.rs.html

Constructs a new cache for kerning subtables, collecting glyph sets based on the subtable format.

```rust
impl KerxSubtableCache {
    pub(crate) fn new(subtable: &Subtable, num_glyphs: u32) -> Self {
        let mut start_end_safe_to_break = 0u64;
        let mut first_set = U32Set::default();
        let mut second_set = U32Set::default();
        if let Ok(kind) = subtable.kind() {
            match &kind {
                SubtableKind::Format0(format0) => {
                    format0.collect_glyphs(&mut first_set, &mut second_set, num_glyphs);
                }
                SubtableKind::Format1(format1) => {
                    start_end_safe_to_break = collect_start_end_safe_to_break(&format1.state_table);
                    collect_initial_glyphs(&format1.state_table, &mut first_set, num_glyphs);
                }
                SubtableKind::Format2(format2) => {
                    format2.collect_glyphs(&mut first_set, &mut second_set, num_glyphs);
                }
```

--------------------------------

### Apply Layout Table

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_layout.rs.html

Functions to initiate substitution and apply layout lookups from GSUB or GPOS tables.

```rust
pub fn hb_ot_layout_substitute_start(face: &hb_font_t, buffer: &mut hb_buffer_t) {
    _hb_ot_layout_set_glyph_props(face, buffer);
}

/// Applies the lookups in the given GSUB or GPOS table.
pub fn apply_layout_table<T: LayoutTable>(
    plan: &hb_ot_shape_plan_t,
    face: &hb_font_t,
    buffer: &mut hb_buffer_t,
    table: Option<&T>,
) {
    let mut ctx = OT::hb_ot_apply_context_t::new(T::INDEX, face, buffer);

    for (stage_index, stage) in plan.ot_map.stages(T::INDEX).iter().enumerate() {
        if let Some(table) = table {
            for lookup_map in plan.ot_map.stage_lookups(T::INDEX, stage_index) {
```

--------------------------------

### GEORGIAN Script Constant

Source: https://docs.rs/harfrust/latest/harfrust/script/constant.GEORGIAN.html

Represents the Georgian script. No additional setup is required to use this constant.

```rust
pub const GEORGIAN: Script;
```

--------------------------------

### ShaperInstance Initialization

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShaperInstance.html

Methods to create a new ShaperInstance from various font variation sources.

```APIDOC
## ShaperInstance Initialization

### Description
Methods to create a new ShaperInstance for a given font using different variation strategies.

### Methods
- **from_variations<V>(font: &FontRef<'_>, variations: V) -> Self**: Creates a new shaper instance from a list of variation settings in user space.
- **from_coords(font: &FontRef<'_>, coords: impl IntoIterator<Item = NormalizedCoord>) -> Self**: Creates a new shaper instance from a set of normalized coordinates in axis order.
- **from_named_instance(font: &FontRef<'_>, index: usize) -> Self**: Creates a new shaper instance using the variation position from a named instance at the specified index.
```

--------------------------------

### Get lookahead length of glyph buffer

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/buffer.rs.html

Calculates the remaining length available for lookahead in the glyph buffer.

```rust
pub fn lookahead_len(&self) -> usize {
        self.len - self.idx
    }
```

--------------------------------

### Create New ShapePlanKey

Source: https://docs.rs/harfrust/latest/harfrust/struct.ShapePlanKey.html

Creates a new shape plan key. Requires an optional script and direction.

```rust
pub fn new(script: Option<Script>, direction: Direction) -> Self
```

--------------------------------

### Get horizontal origin for a glyph

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/face.rs.html

Calculates the horizontal origin of a glyph, typically half of its horizontal advance.

```rust
pub(crate) fn glyph_h_origin(&self, glyph: GlyphId) -> i32 {
        self.glyph_h_advance(glyph) / 2
    }
```

--------------------------------

### Setup Syllables for Myanmar Shaper

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_myanmar.rs.html

Allocates syllable variables and identifies syllable boundaries within the buffer.

```rust
fn setup_syllables(_: &hb_ot_shape_plan_t, _: &hb_font_t, buffer: &mut hb_buffer_t) -> bool {
    buffer.allocate_var(GlyphInfo::SYLLABLE_VAR);

    super::ot_shaper_myanmar_machine::find_syllables_myanmar(buffer);

    let mut start = 0;
    let mut end = buffer.next_syllable(0);
    while start < buffer.len {
        buffer.unsafe_to_break(Some(start), Some(end));
        start = end;
        end = buffer.next_syllable(start);
    }

    false
}

```

--------------------------------

### Initialize IndicShapePlan

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot_shaper_indic.rs.html

Constructs the IndicShapePlan by determining spec versions and initializing feature masks.

```rust
        let is_old_spec = config.has_old_spec
            && plan
                .ot_map
                .chosen_script(TableIndex::GSUB)
                .is_none_or(|tag| tag.to_be_bytes()[3] != b'2');

        // Use zero-context would_substitute() matching for new-spec of the main
        // Indic scripts, and scripts with one spec only, but not for old-specs.
        // The new-spec for all dual-spec scripts says zero-context matching happens.
        //
        // However, testing with Malayalam shows that old and new spec both allow
        // context.  Testing with Bengali new-spec however shows that it doesn't.
        // So, the heuristic here is the way it is.  It should *only* be changed,
        // as we discover more cases of what Windows does.  DON'T TOUCH OTHERWISE.
        let zero_context = is_old_spec && script != Some(script::MALAYALAM);

        let mut mask_array = [0; INDIC_FEATURES.len()];
        for (i, feature) in INDIC_FEATURES.iter().enumerate() {
            mask_array[i] = if feature.1 & F_GLOBAL != 0 {
                0
            } else {
                plan.ot_map.get_1_mask(feature.0)
            }
        }

        // TODO: what is this?
        // let mut virama_glyph = None;
        // if config.virama != 0 {
        //     if let Some(g) = face.glyph_index(char::try_from(config.virama).unwrap()) {
        //         virama_glyph = Some(g.0 as u32);
        //     }
        // }

        IndicShapePlan {
            config,
            is_old_spec,
            // virama_glyph,
            rphf: IndicWouldSubstituteFeature::new(
                &plan.ot_map,
                hb_tag_t::new(b"rphf"),
                zero_context,
            ),
            pref: IndicWouldSubstituteFeature::new(
                &plan.ot_map,
                hb_tag_t::new(b"pref"),
                zero_context,
            ),
            blwf: IndicWouldSubstituteFeature::new(
                &plan.ot_map,
                hb_tag_t::new(b"blwf"),
                zero_context,
            ),
            pstf: IndicWouldSubstituteFeature::new(
                &plan.ot_map,
                hb_tag_t::new(b"pstf"),
                zero_context,
            ),
            vatu: IndicWouldSubstituteFeature::new(
                &plan.ot_map,
                hb_tag_t::new(b"vatu"),
                zero_context,
            ),
            mask_array,
        }
    }
}
```

--------------------------------

### PHOENICIAN Script Constant

Source: https://docs.rs/harfrust/latest/harfrust/script/constant.PHOENICIAN.html

Represents the Phoenician script. No specific setup or imports are required to use this constant.

```rust
pub const PHOENICIAN: Script;
```

--------------------------------

### ContextFormat2Cache Implementation

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/ot/contextual.rs.html

Handles contextual format 2 lookups by caching coverage and input class definitions.

```rust
    ) -> Option<()> {
        let glyph = ctx.buffer.cur(0).as_glyph();
        let SubtableExternalCache::ContextFormat2Cache(cache) = external_cache else {
            return None;
        };
        let offset_data = self.offset_data();
        coverage_binary_cached(
            |gid| cache.coverage.index(&offset_data, gid),
            glyph,
            &cache.coverage_cache,
        )?;
        let input_class = |gid| cache.input.class(&offset_data, gid);
        let index = get_class_cached(&input_class, &mut ctx.buffer.info[ctx.buffer.idx]) as usize;
        let set = self.class_seq_rule_sets().get(index)?.ok()?;
        apply_context_rules(
            ctx,
            &set.class_seq_rules(),
            match_class_cached(&input_class),
        )
    }

    fn cache_cost(&self) -> u32 {
        self.class_def()
            .ok()
            .map_or(0, |class_def| class_def.cost())
    }

    fn external_cache_create(&self, _mode: SubtableExternalCacheMode) -> SubtableExternalCache {
        let data = self.offset_data();
        SubtableExternalCache::ContextFormat2Cache(ContextFormat2Cache {
            coverage_cache: BinaryCache::new(),
            coverage: CoverageInfo::new(&data, self.coverage_offset().to_u32() as u16)
                .unwrap_or_default(),
            input: ClassDefInfo::new(&data, self.class_def_offset().to_u32() as u16)
                .unwrap_or_default(),
        })
    }
}
```

--------------------------------

### OLD_HUNGARIAN Constant

Source: https://docs.rs/harfrust/latest/harfrust/script/constant.OLD_HUNGARIAN.html

Represents the Old Hungarian script. No specific setup or imports are required to use this constant.

```rust
pub const OLD_HUNGARIAN: Script;
```

--------------------------------

### Get Combining Class of a Character

Source: https://docs.rs/harfrust/latest/src/harfrust/hb/unicode.rs.html

Returns the combining class of a Unicode character. This is used for reordering combining marks.

```rust
fn combining_class(self) -> u8 {
        _hb_ucd_ccc(self as usize)
    }
```
Tokens:
Raw