src/wasm/rust/harfbuzz-wasm/src/lib.rs - third_party/harfbuzz - Git at Google

 #![warn(missing_docs)]
 #![allow(dead_code)]
 //! Interface to Harfbuzz's WASM exports
 //!
 //! This crate is designed to make it easier to write a
 //! WASM shaper for your font using Rust. It binds the
 //! functions exported by Harfbuzz into the WASM runtime,
 //! and wraps them in an ergonomic interface using Rust
 //! structures. For example, here is a basic shaping engine:
 //!
 //!
 //! ```rust
 //! #[wasm_bindgen]
 //! pub fn shape(font_ref: u32, buf_ref: u32) -> i32 {
 //!     let font = Font::from_ref(font_ref);
 //!     let mut buffer = GlyphBuffer::from_ref(buf_ref);
 //!     for mut item in buffer.glyphs.iter_mut() {
 //!         // Map character to glyph
 //!         item.codepoint = font.get_glyph(codepoint, 0);
 //!         // Set advance width
 //!         item.h_advance = font.get_glyph_h_advance(item.codepoint);
 //!     }
 //!     1
 //! }
 //! ```
 use std::ffi::{c_int, CStr, CString};

 #[cfg(feature = "kurbo")]
 use kurbo::BezPath;

 // We don't use #[wasm_bindgen] here because that makes
 // assumptions about Javascript calling conventions. We
 // really do just want to import some C symbols and run
 // them in unsafe-land!
 extern "C" {
     fn face_get_upem(face: u32) -> u32;
     fn font_get_face(font: u32) -> u32;
     fn font_get_glyph(font: u32, unicode: u32, uvs: u32) -> u32;
     fn font_get_scale(font: u32, x_scale: *mut i32, y_scale: *mut i32);
     fn font_get_glyph_extents(font: u32, glyph: u32, extents: *mut CGlyphExtents) -> bool;
     fn font_glyph_to_string(font: u32, glyph: u32, str: *const u8, len: u32);
     fn font_get_glyph_h_advance(font: u32, glyph: u32) -> i32;
     fn font_get_glyph_v_advance(font: u32, glyph: u32) -> i32;
     fn font_copy_glyph_outline(font: u32, glyph: u32, outline: *mut CGlyphOutline) -> bool;
     fn face_copy_table(font: u32, tag: u32, blob: *mut Blob) -> bool;
     fn buffer_copy_contents(buffer: u32, cbuffer: *mut CBufferContents) -> bool;
     fn buffer_set_contents(buffer: u32, cbuffer: &CBufferContents) -> bool;
     fn debugprint(s: *const u8);
     fn shape_with(
         font: u32,
         buffer: u32,
         features: u32,
         num_features: u32,
         shaper: *const u8,
     ) -> i32;
 }

 /// An opaque reference to a font at a given size and
 /// variation. It is equivalent to the `hb_font_t` pointer
 /// in Harfbuzz.
 #[derive(Debug)]
 pub struct Font(u32);

 impl Font {
     /// Initialize a `Font` struct from the reference provided
     /// by Harfbuzz to the `shape` function.
     pub fn from_ref(ptr: u32) -> Self {
         Self(ptr)
     }
     /// Call the given Harfbuzz shaper on a buffer reference.
     ///
     /// For example, `font.shape_with(buffer_ref, "ot")` will
     /// run standard OpenType shaping, allowing you to modify
     /// the buffer contents after glyph mapping, substitution
     /// and positioning has taken place.
     pub fn shape_with(&self, buffer_ref: u32, shaper: &str) {
         let c_shaper = CString::new(shaper).unwrap();
         unsafe {
             shape_with(self.0, buffer_ref, 0, 0, c_shaper.as_ptr() as *const u8);
         }
     }

     /// Return the font face object that this font belongs to.
     pub fn get_face(&self) -> Face {
         Face(unsafe { font_get_face(self.0) })
     }

     /// Map a Unicode codepoint to a glyph ID.
     ///
     /// The `uvs` parameter specifies a Unicode Variation
     /// Selector codepoint which is used in conjunction with
     /// [format 14 cmap tables](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences)
     /// to provide alternate glyph mappings for characters with
     /// Unicode Variation Sequences. Generally you will pass
     /// `0`.
     pub fn get_glyph(&self, unicode: u32, uvs: u32) -> u32 {
         unsafe { font_get_glyph(self.0, unicode, uvs) }
     }

     /// Get the extents for a given glyph ID, in its design position.
     pub fn get_glyph_extents(&self, glyph: u32) -> CGlyphExtents {
         let mut extents = CGlyphExtents::default();
         unsafe {
             font_get_glyph_extents(self.0, glyph, &mut extents);
         }
         extents
     }

     /// Get the default advance width for a given glyph ID.
     pub fn get_glyph_h_advance(&self, glyph: u32) -> i32 {
         unsafe { font_get_glyph_h_advance(self.0, glyph) }
     }

     /// Get the default vertical advance for a given glyph ID.
     fn get_glyph_v_advance(&self, glyph: u32) -> i32 {
         unsafe { font_get_glyph_v_advance(self.0, glyph) }
     }

     /// Get the name of a glyph.
     ///
     /// If no names are provided by the font, names of the form
     /// `gidXXX` are constructed.
     pub fn get_glyph_name(&self, glyph: u32) -> String {
         let mut s = [1u8; 32];
         unsafe {
             font_glyph_to_string(self.0, glyph, s.as_mut_ptr(), 32);
         }
         unsafe { CStr::from_ptr(s.as_ptr() as *const _) }
             .to_str()
             .unwrap()
             .to_string()
     }

     /// Get the X and Y scale factor applied to this font.
     ///
     /// This should be divided by the units per em value to
     /// provide a scale factor mapping from design units to
     /// user units. (See [`Face::get_upem`].)
     pub fn get_scale(&self) -> (i32, i32) {
         let mut x_scale: i32 = 0;
         let mut y_scale: i32 = 0;
         unsafe {
             font_get_scale(
                 self.0,
                 &mut x_scale as *mut c_int,
                 &mut y_scale as *mut c_int,
             )
         };
         (x_scale, y_scale)
     }

     #[cfg(feature = "kurbo")]
     /// Get the outline of a glyph as a vector of bezier paths
     pub fn get_outline(&self, glyph: u32) -> Vec<BezPath> {
         let mut outline = CGlyphOutline {
             n_points: 0,
             points: std::ptr::null_mut(),
             n_contours: 0,
             contours: std::ptr::null_mut(),
         };
         let end_pts_of_contours: &[usize] = unsafe {
             font_copy_glyph_outline(self.0, glyph, &mut outline);
             std::slice::from_raw_parts(outline.contours, outline.n_contours as usize)
         };
         let points: &[CGlyphOutlinePoint] =
             unsafe { std::slice::from_raw_parts(outline.points, outline.n_points as usize) };
         let mut results: Vec<BezPath> = vec![];
         let mut start_pt: usize = 0;
         for end_pt in end_pts_of_contours {
             let this_contour = &points[start_pt..*end_pt];
             start_pt = *end_pt;
             let mut path = BezPath::new();
             let mut ix = 0;
             while ix < this_contour.len() {
                 let point = &this_contour[ix];
                 match point.pointtype {
                     PointType::MoveTo => path.move_to((point.x as f64, point.y as f64)),
                     PointType::LineTo => path.line_to((point.x as f64, point.y as f64)),
                     PointType::QuadraticTo => {
                         ix += 1;
                         let end_pt = &this_contour[ix];
                         path.quad_to(
                             (point.x as f64, point.y as f64),
                             (end_pt.x as f64, end_pt.y as f64),
                         );
                     }
                     PointType::CubicTo => {
                         ix += 1;
                         let mid_pt = &this_contour[ix];
                         ix += 1;
                         let end_pt = &this_contour[ix];
                         path.curve_to(
                             (point.x as f64, point.y as f64),
                             (mid_pt.x as f64, mid_pt.y as f64),
                             (end_pt.x as f64, end_pt.y as f64),
                         );
                     }
                 }
                 ix += 1;
             }
             path.close_path();
             results.push(path);
         }
         results
     }
 }

 /// An opaque reference to a font face, equivalent to the `hb_face_t` pointer
 /// in Harfbuzz.
 ///
 /// This is generally returned from [`Font::get_face`].
 #[derive(Debug)]
 pub struct Face(u32);

 impl Face {
     /// Get a blob containing the contents of the given binary font table.
     pub fn reference_table(&self, tag: &str) -> Blob {
         let mut tag_u: u32 = 0;
         let mut chars = tag.chars();
         tag_u |= (chars.next().unwrap() as u32) << 24;
         tag_u |= (chars.next().unwrap() as u32) << 16;
         tag_u |= (chars.next().unwrap() as u32) << 8;
         tag_u |= chars.next().unwrap() as u32;
         let mut blob = Blob {
             data: std::ptr::null_mut(),
             length: 0,
         };
         unsafe {
             face_copy_table(self.0, tag_u, &mut blob);
         }
         blob
     }

     /// Get the face's design units per em.
     pub fn get_upem(&self) -> u32 {
         unsafe { face_get_upem(self.0) }
     }
 }

 /// Trait implemented by custom structs representing buffer items
 pub trait BufferItem {
     /// Construct an item in your preferred representation out of the info and position data provided by Harfbuzz.
     fn from_c(info: CGlyphInfo, position: CGlyphPosition) -> Self;
     /// Return info and position data to Harfbuzz.
     fn to_c(self) -> (CGlyphInfo, CGlyphPosition);
 }

 /// Generic representation of a Harfbuzz buffer item.
 ///
 /// By making this generic, we allow you to implement your own
 /// representations of buffer items; for example, in your shaper,
 /// you may want certain fields to keep track of the glyph's name,
 /// extents, or shape, so you would want a custom struct to represent
 /// buffer items. If you don't care about any of them, use the
 /// supplied `GlyphBuffer` struct.
 #[derive(Debug)]
 pub struct Buffer<T: BufferItem> {
     _ptr: u32,
     /// Glyphs in the buffer
     pub glyphs: Vec<T>,
 }

 impl<T: BufferItem> Buffer<T> {
     /// Construct a buffer from the pointer Harfbuzz provides to the WASM.
     ///
     /// The `Buffer` struct implements Drop, meaning that when the shaping
     /// function is finished, the buffer contents are sent back to Harfbuzz.
     pub fn from_ref(ptr: u32) -> Self {
         let mut c_contents = CBufferContents {
             info: std::ptr::null_mut(),
             position: std::ptr::null_mut(),
             length: 0,
         };

         unsafe {
             buffer_copy_contents(ptr, &mut c_contents) || panic!("Couldn't copy buffer contents")
         };
         let positions: Vec<CGlyphPosition> = unsafe {
             std::slice::from_raw_parts(c_contents.position, c_contents.length as usize).to_vec()
         };
         let infos: Vec<CGlyphInfo> = unsafe {
             std::slice::from_raw_parts(c_contents.info, c_contents.length as usize).to_vec()
         };
         Buffer {
             glyphs: infos
                 .into_iter()
                 .zip(positions.into_iter())
                 .map(|(i, p)| T::from_c(i, p))
                 .collect(),
             _ptr: ptr,
         }
     }
 }

 impl<T: BufferItem> Drop for Buffer<T> {
     fn drop(&mut self) {
         let mut positions: Vec<CGlyphPosition>;
         let mut infos: Vec<CGlyphInfo>;
         let glyphs = std::mem::take(&mut self.glyphs);
         (infos, positions) = glyphs.into_iter().map(|g| g.to_c()).unzip();
         let c_contents = CBufferContents {
             length: positions.len() as u32,
             info: infos[..].as_mut_ptr(),
             position: positions[..].as_mut_ptr(),
         };
         unsafe {
             if !buffer_set_contents(self._ptr, &c_contents) {
                 panic!("Couldn't set buffer contents");
             }
         }
     }
 }

 /// Some data provided by Harfbuzz.
 #[derive(Debug)]
 #[repr(C)]
 pub struct Blob {
     /// Length of the blob in bytes
     pub length: u32,
     /// A raw pointer to the contents
     pub data: *mut u8,
 }

 /// Glyph information in a buffer item provided by Harfbuzz
 ///
 /// You'll only need to interact with this if you're writing
 /// your own buffer item structure.
 #[repr(C)]
 #[derive(Debug, Clone)]
 pub struct CGlyphInfo {
     pub codepoint: u32,
     pub mask: u32,
     pub cluster: u32,
     pub var1: u32,
     pub var2: u32,
 }

 /// Glyph positioning information in a buffer item provided by Harfbuzz
 ///
 /// You'll only need to interact with this if you're writing
 /// your own buffer item structure.
 #[derive(Debug, Clone)]
 #[repr(C)]
 pub struct CGlyphPosition {
     pub x_advance: i32,
     pub y_advance: i32,
     pub x_offset: i32,
     pub y_offset: i32,
     pub var: u32,
 }

 /// Glyph extents
 #[derive(Debug, Clone, Default)]
 #[repr(C)]
 pub struct CGlyphExtents {
     /// The scaled left side bearing of the glyph
     pub x_bearing: i32,
     /// The scaled coordinate of the top of the glyph
     pub y_bearing: i32,
     /// The width of the glyph
     pub width: i32,
     /// The height of the glyph
     pub height: i32,
 }

 #[derive(Debug)]
 #[repr(C)]
 struct CBufferContents {
     length: u32,
     info: *mut CGlyphInfo,
     position: *mut CGlyphPosition,
 }

 /// Ergonomic representation of a Harfbuzz buffer item
 ///
 /// Harfbuzz buffers are normally split into two arrays,
 /// one representing glyph information and the other
 /// representing glyph positioning. In Rust, this would
 /// require lots of zipping and unzipping, so we zip them
 /// together into a single structure for you.
 #[derive(Debug, Clone, Copy)]
 pub struct Glyph {
     /// The Unicode codepoint or glyph ID of the item
     pub codepoint: u32,
     /// The index of the cluster in the input text where this came from
     pub cluster: u32,
     /// The horizontal advance of the glyph
     pub x_advance: i32,
     /// The vertical advance of the glyph
     pub y_advance: i32,
     /// The horizontal offset of the glyph
     pub x_offset: i32,
     /// The vertical offset of the glyph
     pub y_offset: i32,
     /// You can use this for whatever you like
     pub flags: u32,
 }
 impl BufferItem for Glyph {
     fn from_c(info: CGlyphInfo, pos: CGlyphPosition) -> Self {
         Self {
             codepoint: info.codepoint,
             cluster: info.cluster,
             x_advance: pos.x_advance,
             y_advance: pos.y_advance,
             x_offset: pos.x_offset,
             y_offset: pos.y_offset,
             flags: 0,
         }
     }
     fn to_c(self) -> (CGlyphInfo, CGlyphPosition) {
         let info = CGlyphInfo {
             codepoint: self.codepoint,
             cluster: self.cluster,
             mask: 0,
             var1: 0,
             var2: 0,
         };
         let pos = CGlyphPosition {
             x_advance: self.x_advance,
             y_advance: self.y_advance,
             x_offset: self.x_offset,
             y_offset: self.y_offset,
             var: 0,
         };
         (info, pos)
     }
 }

 #[repr(C)]
 #[allow(clippy::enum_variant_names)]
 #[derive(Clone, Debug)]
 enum PointType {
     MoveTo,
     LineTo,
     QuadraticTo,
     CubicTo,
 }

 #[repr(C)]
 #[derive(Clone, Debug)]
 struct CGlyphOutlinePoint {
     x: f32,
     y: f32,
     pointtype: PointType,
 }

 #[repr(C)]
 struct CGlyphOutline {
     n_points: usize,
     points: *mut CGlyphOutlinePoint,
     n_contours: usize,
     contours: *mut usize,
 }

 /// Our default buffer item struct. See also [`Glyph`].
 pub type GlyphBuffer = Buffer<Glyph>;

 /// Write a string to the Harfbuzz debug log.
 pub fn debug(s: &str) {
     let c_s = CString::new(s).unwrap();
     unsafe {
         debugprint(c_s.as_ptr() as *const u8);
     };
 }
	#![warn(missing_docs)]
	#![allow(dead_code)]
	//! Interface to Harfbuzz's WASM exports
	//!
	//! This crate is designed to make it easier to write a
	//! WASM shaper for your font using Rust. It binds the
	//! functions exported by Harfbuzz into the WASM runtime,
	//! and wraps them in an ergonomic interface using Rust
	//! structures. For example, here is a basic shaping engine:
	//!
	//!
	//! ```rust
	//! #[wasm_bindgen]
	//! pub fn shape(font_ref: u32, buf_ref: u32) -> i32 {
	//! let font = Font::from_ref(font_ref);
	//! let mut buffer = GlyphBuffer::from_ref(buf_ref);
	//! for mut item in buffer.glyphs.iter_mut() {
	//! // Map character to glyph
	//! item.codepoint = font.get_glyph(codepoint, 0);
	//! // Set advance width
	//! item.h_advance = font.get_glyph_h_advance(item.codepoint);
	//! }
	//! 1
	//! }
	//! ```
	use std::ffi::{c_int, CStr, CString};

	#[cfg(feature = "kurbo")]
	use kurbo::BezPath;

	// We don't use #[wasm_bindgen] here because that makes
	// assumptions about Javascript calling conventions. We
	// really do just want to import some C symbols and run
	// them in unsafe-land!
	extern "C" {
	fn face_get_upem(face: u32) -> u32;
	fn font_get_face(font: u32) -> u32;
	fn font_get_glyph(font: u32, unicode: u32, uvs: u32) -> u32;
	fn font_get_scale(font: u32, x_scale: mut i32, y_scale: mut i32);
	fn font_get_glyph_extents(font: u32, glyph: u32, extents: *mut CGlyphExtents) -> bool;
	fn font_glyph_to_string(font: u32, glyph: u32, str: *const u8, len: u32);
	fn font_get_glyph_h_advance(font: u32, glyph: u32) -> i32;
	fn font_get_glyph_v_advance(font: u32, glyph: u32) -> i32;
	fn font_copy_glyph_outline(font: u32, glyph: u32, outline: *mut CGlyphOutline) -> bool;
	fn face_copy_table(font: u32, tag: u32, blob: *mut Blob) -> bool;
	fn buffer_copy_contents(buffer: u32, cbuffer: *mut CBufferContents) -> bool;
	fn buffer_set_contents(buffer: u32, cbuffer: &CBufferContents) -> bool;
	fn debugprint(s: *const u8);
	fn shape_with(
	font: u32,
	buffer: u32,
	features: u32,
	num_features: u32,
	shaper: *const u8,
	) -> i32;
	}

	/// An opaque reference to a font at a given size and
	/// variation. It is equivalent to the `hb_font_t` pointer
	/// in Harfbuzz.
	#[derive(Debug)]
	pub struct Font(u32);

	impl Font {
	/// Initialize a `Font` struct from the reference provided
	/// by Harfbuzz to the `shape` function.
	pub fn from_ref(ptr: u32) -> Self {
	Self(ptr)
	}
	/// Call the given Harfbuzz shaper on a buffer reference.
	///
	/// For example, `font.shape_with(buffer_ref, "ot")` will
	/// run standard OpenType shaping, allowing you to modify
	/// the buffer contents after glyph mapping, substitution
	/// and positioning has taken place.
	pub fn shape_with(&self, buffer_ref: u32, shaper: &str) {
	let c_shaper = CString::new(shaper).unwrap();
	unsafe {
	shape_with(self.0, buffer_ref, 0, 0, c_shaper.as_ptr() as *const u8);
	}
	}

	/// Return the font face object that this font belongs to.
	pub fn get_face(&self) -> Face {
	Face(unsafe { font_get_face(self.0) })
	}

	/// Map a Unicode codepoint to a glyph ID.
	///
	/// The `uvs` parameter specifies a Unicode Variation
	/// Selector codepoint which is used in conjunction with
	/// [format 14 cmap tables](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences)
	/// to provide alternate glyph mappings for characters with
	/// Unicode Variation Sequences. Generally you will pass
	/// `0`.
	pub fn get_glyph(&self, unicode: u32, uvs: u32) -> u32 {
	unsafe { font_get_glyph(self.0, unicode, uvs) }
	}

	/// Get the extents for a given glyph ID, in its design position.
	pub fn get_glyph_extents(&self, glyph: u32) -> CGlyphExtents {
	let mut extents = CGlyphExtents::default();
	unsafe {
	font_get_glyph_extents(self.0, glyph, &mut extents);
	}
	extents
	}

	/// Get the default advance width for a given glyph ID.
	pub fn get_glyph_h_advance(&self, glyph: u32) -> i32 {
	unsafe { font_get_glyph_h_advance(self.0, glyph) }
	}

	/// Get the default vertical advance for a given glyph ID.
	fn get_glyph_v_advance(&self, glyph: u32) -> i32 {
	unsafe { font_get_glyph_v_advance(self.0, glyph) }
	}

	/// Get the name of a glyph.
	///
	/// If no names are provided by the font, names of the form
	/// `gidXXX` are constructed.
	pub fn get_glyph_name(&self, glyph: u32) -> String {
	let mut s = [1u8; 32];
	unsafe {
	font_glyph_to_string(self.0, glyph, s.as_mut_ptr(), 32);
	}
	unsafe { CStr::from_ptr(s.as_ptr() as *const _) }
	.to_str()
	.unwrap()
	.to_string()
	}

	/// Get the X and Y scale factor applied to this font.
	///
	/// This should be divided by the units per em value to
	/// provide a scale factor mapping from design units to
	/// user units. (See [`Face::get_upem`].)
	pub fn get_scale(&self) -> (i32, i32) {
	let mut x_scale: i32 = 0;
	let mut y_scale: i32 = 0;
	unsafe {
	font_get_scale(
	self.0,
	&mut x_scale as *mut c_int,
	&mut y_scale as *mut c_int,
	)
	};
	(x_scale, y_scale)
	}

	#[cfg(feature = "kurbo")]
	/// Get the outline of a glyph as a vector of bezier paths
	pub fn get_outline(&self, glyph: u32) -> Vec<BezPath> {
	let mut outline = CGlyphOutline {
	n_points: 0,
	points: std::ptr::null_mut(),
	n_contours: 0,
	contours: std::ptr::null_mut(),
	};
	let end_pts_of_contours: &[usize] = unsafe {
	font_copy_glyph_outline(self.0, glyph, &mut outline);
	std::slice::from_raw_parts(outline.contours, outline.n_contours as usize)
	};
	let points: &[CGlyphOutlinePoint] =
	unsafe { std::slice::from_raw_parts(outline.points, outline.n_points as usize) };
	let mut results: Vec<BezPath> = vec![];
	let mut start_pt: usize = 0;
	for end_pt in end_pts_of_contours {
	let this_contour = &points[start_pt..*end_pt];
	start_pt = *end_pt;
	let mut path = BezPath::new();
	let mut ix = 0;
	while ix < this_contour.len() {
	let point = &this_contour[ix];
	match point.pointtype {
	PointType::MoveTo => path.move_to((point.x as f64, point.y as f64)),
	PointType::LineTo => path.line_to((point.x as f64, point.y as f64)),
	PointType::QuadraticTo => {
	ix += 1;
	let end_pt = &this_contour[ix];
	path.quad_to(
	(point.x as f64, point.y as f64),
	(end_pt.x as f64, end_pt.y as f64),
	);
	}
	PointType::CubicTo => {
	ix += 1;
	let mid_pt = &this_contour[ix];
	ix += 1;
	let end_pt = &this_contour[ix];
	path.curve_to(
	(point.x as f64, point.y as f64),
	(mid_pt.x as f64, mid_pt.y as f64),
	(end_pt.x as f64, end_pt.y as f64),
	);
	}
	}
	ix += 1;
	}
	path.close_path();
	results.push(path);
	}
	results
	}
	}

	/// An opaque reference to a font face, equivalent to the `hb_face_t` pointer
	/// in Harfbuzz.
	///
	/// This is generally returned from [`Font::get_face`].
	#[derive(Debug)]
	pub struct Face(u32);

	impl Face {
	/// Get a blob containing the contents of the given binary font table.
	pub fn reference_table(&self, tag: &str) -> Blob {
	let mut tag_u: u32 = 0;
	let mut chars = tag.chars();
	tag_u \|= (chars.next().unwrap() as u32) << 24;
	tag_u \|= (chars.next().unwrap() as u32) << 16;
	tag_u \|= (chars.next().unwrap() as u32) << 8;
	tag_u \|= chars.next().unwrap() as u32;
	let mut blob = Blob {
	data: std::ptr::null_mut(),
	length: 0,
	};
	unsafe {
	face_copy_table(self.0, tag_u, &mut blob);
	}
	blob
	}

	/// Get the face's design units per em.
	pub fn get_upem(&self) -> u32 {
	unsafe { face_get_upem(self.0) }
	}
	}

	/// Trait implemented by custom structs representing buffer items
	pub trait BufferItem {
	/// Construct an item in your preferred representation out of the info and position data provided by Harfbuzz.
	fn from_c(info: CGlyphInfo, position: CGlyphPosition) -> Self;
	/// Return info and position data to Harfbuzz.
	fn to_c(self) -> (CGlyphInfo, CGlyphPosition);
	}

	/// Generic representation of a Harfbuzz buffer item.
	///
	/// By making this generic, we allow you to implement your own
	/// representations of buffer items; for example, in your shaper,
	/// you may want certain fields to keep track of the glyph's name,
	/// extents, or shape, so you would want a custom struct to represent
	/// buffer items. If you don't care about any of them, use the
	/// supplied `GlyphBuffer` struct.
	#[derive(Debug)]
	pub struct Buffer<T: BufferItem> {
	_ptr: u32,
	/// Glyphs in the buffer
	pub glyphs: Vec<T>,
	}

	impl<T: BufferItem> Buffer<T> {
	/// Construct a buffer from the pointer Harfbuzz provides to the WASM.
	///
	/// The `Buffer` struct implements Drop, meaning that when the shaping
	/// function is finished, the buffer contents are sent back to Harfbuzz.
	pub fn from_ref(ptr: u32) -> Self {
	let mut c_contents = CBufferContents {
	info: std::ptr::null_mut(),
	position: std::ptr::null_mut(),
	length: 0,
	};

	unsafe {
	buffer_copy_contents(ptr, &mut c_contents) \|\| panic!("Couldn't copy buffer contents")
	};
	let positions: Vec<CGlyphPosition> = unsafe {
	std::slice::from_raw_parts(c_contents.position, c_contents.length as usize).to_vec()
	};
	let infos: Vec<CGlyphInfo> = unsafe {
	std::slice::from_raw_parts(c_contents.info, c_contents.length as usize).to_vec()
	};
	Buffer {
	glyphs: infos
	.into_iter()
	.zip(positions.into_iter())
	.map(\|(i, p)\| T::from_c(i, p))
	.collect(),
	_ptr: ptr,
	}
	}
	}

	impl<T: BufferItem> Drop for Buffer<T> {
	fn drop(&mut self) {
	let mut positions: Vec<CGlyphPosition>;
	let mut infos: Vec<CGlyphInfo>;
	let glyphs = std::mem::take(&mut self.glyphs);
	(infos, positions) = glyphs.into_iter().map(\|g\| g.to_c()).unzip();
	let c_contents = CBufferContents {
	length: positions.len() as u32,
	info: infos[..].as_mut_ptr(),
	position: positions[..].as_mut_ptr(),
	};
	unsafe {
	if !buffer_set_contents(self._ptr, &c_contents) {
	panic!("Couldn't set buffer contents");
	}
	}
	}
	}

	/// Some data provided by Harfbuzz.
	#[derive(Debug)]
	#[repr(C)]
	pub struct Blob {
	/// Length of the blob in bytes
	pub length: u32,
	/// A raw pointer to the contents
	pub data: *mut u8,
	}

	/// Glyph information in a buffer item provided by Harfbuzz
	///
	/// You'll only need to interact with this if you're writing
	/// your own buffer item structure.
	#[repr(C)]
	#[derive(Debug, Clone)]
	pub struct CGlyphInfo {
	pub codepoint: u32,
	pub mask: u32,
	pub cluster: u32,
	pub var1: u32,
	pub var2: u32,
	}

	/// Glyph positioning information in a buffer item provided by Harfbuzz
	///
	/// You'll only need to interact with this if you're writing
	/// your own buffer item structure.
	#[derive(Debug, Clone)]
	#[repr(C)]
	pub struct CGlyphPosition {
	pub x_advance: i32,
	pub y_advance: i32,
	pub x_offset: i32,
	pub y_offset: i32,
	pub var: u32,
	}

	/// Glyph extents
	#[derive(Debug, Clone, Default)]
	#[repr(C)]
	pub struct CGlyphExtents {
	/// The scaled left side bearing of the glyph
	pub x_bearing: i32,
	/// The scaled coordinate of the top of the glyph
	pub y_bearing: i32,
	/// The width of the glyph
	pub width: i32,
	/// The height of the glyph
	pub height: i32,
	}

	#[derive(Debug)]
	#[repr(C)]
	struct CBufferContents {
	length: u32,
	info: *mut CGlyphInfo,
	position: *mut CGlyphPosition,
	}

	/// Ergonomic representation of a Harfbuzz buffer item
	///
	/// Harfbuzz buffers are normally split into two arrays,
	/// one representing glyph information and the other
	/// representing glyph positioning. In Rust, this would
	/// require lots of zipping and unzipping, so we zip them
	/// together into a single structure for you.
	#[derive(Debug, Clone, Copy)]
	pub struct Glyph {
	/// The Unicode codepoint or glyph ID of the item
	pub codepoint: u32,
	/// The index of the cluster in the input text where this came from
	pub cluster: u32,
	/// The horizontal advance of the glyph
	pub x_advance: i32,
	/// The vertical advance of the glyph
	pub y_advance: i32,
	/// The horizontal offset of the glyph
	pub x_offset: i32,
	/// The vertical offset of the glyph
	pub y_offset: i32,
	/// You can use this for whatever you like
	pub flags: u32,
	}
	impl BufferItem for Glyph {
	fn from_c(info: CGlyphInfo, pos: CGlyphPosition) -> Self {
	Self {
	codepoint: info.codepoint,
	cluster: info.cluster,
	x_advance: pos.x_advance,
	y_advance: pos.y_advance,
	x_offset: pos.x_offset,
	y_offset: pos.y_offset,
	flags: 0,
	}
	}
	fn to_c(self) -> (CGlyphInfo, CGlyphPosition) {
	let info = CGlyphInfo {
	codepoint: self.codepoint,
	cluster: self.cluster,
	mask: 0,
	var1: 0,
	var2: 0,
	};
	let pos = CGlyphPosition {
	x_advance: self.x_advance,
	y_advance: self.y_advance,
	x_offset: self.x_offset,
	y_offset: self.y_offset,
	var: 0,
	};
	(info, pos)
	}
	}

	#[repr(C)]
	#[allow(clippy::enum_variant_names)]
	#[derive(Clone, Debug)]
	enum PointType {
	MoveTo,
	LineTo,
	QuadraticTo,
	CubicTo,
	}

	#[repr(C)]
	#[derive(Clone, Debug)]
	struct CGlyphOutlinePoint {
	x: f32,
	y: f32,
	pointtype: PointType,
	}

	#[repr(C)]
	struct CGlyphOutline {
	n_points: usize,
	points: *mut CGlyphOutlinePoint,
	n_contours: usize,
	contours: *mut usize,
	}

	/// Our default buffer item struct. See also [`Glyph`].
	pub type GlyphBuffer = Buffer<Glyph>;

	/// Write a string to the Harfbuzz debug log.
	pub fn debug(s: &str) {
	let c_s = CString::new(s).unwrap();
	unsafe {
	debugprint(c_s.as_ptr() as *const u8);
	};
	}