Vendor things

third-party/vendor/owned_ttf_parser/src/convert.rs

@@ -0,0 +1,39 @@
+/// Used to perform a cheap conversion to a [`Face`](struct.Face.html) reference.
+pub trait AsFaceRef {
+    /// Convert to a [`Face`](struct.Face.html) reference.
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_>;
+}
+
+impl AsFaceRef for ttf_parser::Face<'_> {
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        self
+    }
+}
+
+impl AsFaceRef for &ttf_parser::Face<'_> {
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        self
+    }
+}
+
+/// Trait exposing mutable operations on a [`ttf_parser::Face`].
+pub trait FaceMut {
+    /// Sets a variation axis coordinate.
+    ///
+    /// See [`ttf_parser::Face::set_variation`].
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()>;
+}
+impl FaceMut for ttf_parser::Face<'_> {
+    #[inline]
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        ttf_parser::Face::set_variation(self, axis, value)
+    }
+}
+impl FaceMut for &mut ttf_parser::Face<'_> {
+    #[inline]
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        ttf_parser::Face::set_variation(self, axis, value)
+    }
+}

third-party/vendor/owned_ttf_parser/src/lib.rs

@@ -0,0 +1,26 @@
+//! Extends [ttf_parser](https://docs.rs/ttf-parser) with owned version of
+//! [`Face`](struct.Face.html): [`OwnedFace`](struct.OwnedFace.html).
+//!
+//! Re-exports `ttf_parser::*`.
+//!
+//! # Example
+//! ```
+//! use owned_ttf_parser::{AsFaceRef, Face, OwnedFace};
+//!
+//! # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();
+//! let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();
+//! let face_ref: &Face<'_> = owned_face.as_face_ref();
+//!
+//! assert_eq!(face_ref.ascender(), 2254);
+//! ```
+#![cfg_attr(not(feature = "std"), no_std)]
+extern crate alloc;
+
+mod convert;
+mod owned;
+mod preparse;
+
+pub use convert::*;
+pub use owned::*;
+pub use preparse::*;
+pub use ttf_parser::*;

third-party/vendor/owned_ttf_parser/src/owned.rs

@@ -0,0 +1,159 @@
+use crate::preparse::{FaceSubtables, PreParsedSubtables};
+#[cfg(not(feature = "std"))]
+use alloc::{boxed::Box, vec::Vec};
+use core::{fmt, marker::PhantomPinned, mem, pin::Pin, slice};
+
+/// An owned version of font [`Face`](struct.Face.html).
+pub struct OwnedFace(Pin<Box<SelfRefVecFace>>);
+
+impl OwnedFace {
+    /// Creates an `OwnedFace` from owned data.
+    ///
+    /// You can set index for font collections. For simple ttf fonts set index to 0.
+    ///
+    /// # Example
+    /// ```
+    /// # use owned_ttf_parser::OwnedFace;
+    /// # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();
+    /// let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();
+    /// ```
+    // Note: not `try_from_vec` to better mimic `ttf_parser::Face::from_data`.
+    pub fn from_vec(data: Vec<u8>, index: u32) -> Result<Self, ttf_parser::FaceParsingError> {
+        let inner = SelfRefVecFace::try_from_vec(data, index)?;
+        Ok(Self(inner))
+    }
+
+    pub(crate) fn pre_parse_subtables(self) -> PreParsedSubtables<'static, Self> {
+        // build subtables referencing fake static data
+        let subtables = FaceSubtables::from(match self.0.face.as_ref() {
+            Some(f) => f,
+            None => unsafe { core::hint::unreachable_unchecked() },
+        });
+
+        // bundle everything together so self-reference lifetimes hold
+        PreParsedSubtables {
+            face: self,
+            subtables,
+        }
+    }
+
+    /// Extracts a slice containing the data passed into [`OwnedFace::from_vec`].
+    ///
+    /// # Example
+    /// ```
+    /// # use owned_ttf_parser::OwnedFace;
+    /// # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();
+    /// let data_clone = owned_font_data.clone();
+    /// let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();
+    /// assert_eq!(owned_face.as_slice(), data_clone);
+    /// ```
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0.data
+    }
+
+    /// Unwraps the data passed into [`OwnedFace::from_vec`].
+    ///
+    /// # Example
+    /// ```
+    /// # use owned_ttf_parser::OwnedFace;
+    /// # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();
+    /// let data_clone = owned_font_data.clone();
+    /// let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();
+    /// assert_eq!(owned_face.into_vec(), data_clone);
+    /// ```
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0.into_vec()
+    }
+}
+
+impl fmt::Debug for OwnedFace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "OwnedFace()")
+    }
+}
+
+impl crate::convert::AsFaceRef for OwnedFace {
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        self.0.inner_ref()
+    }
+}
+
+impl crate::convert::AsFaceRef for &OwnedFace {
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        self.0.inner_ref()
+    }
+}
+
+impl crate::convert::FaceMut for OwnedFace {
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        unsafe {
+            let mut_ref = Pin::as_mut(&mut self.0);
+            let mut_inner = mut_ref.get_unchecked_mut();
+            match mut_inner.face.as_mut() {
+                Some(face) => face.set_variation(axis, value),
+                None => None,
+            }
+        }
+    }
+}
+impl crate::convert::FaceMut for &mut OwnedFace {
+    #[inline]
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        (*self).set_variation(axis, value)
+    }
+}
+
+// Face data in a `Vec` with a self-referencing `Face`.
+struct SelfRefVecFace {
+    data: Vec<u8>,
+    face: Option<ttf_parser::Face<'static>>,
+    _pin: PhantomPinned,
+}
+
+impl SelfRefVecFace {
+    /// Creates an underlying face object from owned data.
+    fn try_from_vec(
+        data: Vec<u8>,
+        index: u32,
+    ) -> Result<Pin<Box<Self>>, ttf_parser::FaceParsingError> {
+        let face = Self {
+            data,
+            face: None,
+            _pin: PhantomPinned,
+        };
+        let mut b = Box::pin(face);
+        unsafe {
+            // 'static lifetime is a lie, this data is owned, it has pseudo-self lifetime.
+            let slice: &'static [u8] = slice::from_raw_parts(b.data.as_ptr(), b.data.len());
+            let mut_ref: Pin<&mut Self> = Pin::as_mut(&mut b);
+            let mut_inner = mut_ref.get_unchecked_mut();
+            mut_inner.face = Some(ttf_parser::Face::parse(slice, index)?);
+        }
+        Ok(b)
+    }
+
+    // Must not leak the fake 'static lifetime that we lied about earlier to the
+    // compiler. Since the lifetime 'a will not outlive our owned data it's
+    // safe to provide Face<'a>
+    #[inline]
+    #[allow(clippy::needless_lifetimes)] // explicit is nice as it's important 'static isn't leaked
+    fn inner_ref<'a>(self: &'a Pin<Box<Self>>) -> &'a ttf_parser::Face<'a> {
+        // Safety: if you have a ref `face` is always Some
+        unsafe { self.face.as_ref().unwrap_unchecked() }
+    }
+
+    fn into_vec(self: Pin<Box<Self>>) -> Vec<u8> {
+        // Safety: safe as `face` is dropped.
+        let mut me = unsafe { Pin::into_inner_unchecked(self) };
+        me.face.take(); // ensure dropped before taking `data`
+        mem::take(&mut me.data)
+    }
+}
+
+impl Drop for SelfRefVecFace {
+    fn drop(&mut self) {
+        self.face.take(); // ensure dropped before `data`
+    }
+}

third-party/vendor/owned_ttf_parser/src/preparse.rs

@@ -0,0 +1,153 @@
+//! Logic to avoid re-parsing subtables in ttf_parser::Face methods
+use crate::{AsFaceRef, FaceMut, OwnedFace};
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+use core::fmt;
+use ttf_parser::{cmap, kern, Face, GlyphId};
+
+/// A `Face` with cmap & kern subtables parsed once on initialization.
+///
+/// Provides much faster [`PreParsedSubtables::glyph_index`] &
+/// [`PreParsedSubtables::glyphs_hor_kerning`] methods compared to the
+/// `.as_face_ref()` equivalents that must parse their subtables on each call.
+///
+/// # Example
+/// ```
+/// use owned_ttf_parser::{AsFaceRef, GlyphId, OwnedFace, PreParsedSubtables};
+///
+/// # let owned_font_data = include_bytes!("../fonts/font.ttf").to_vec();
+/// let owned_face = OwnedFace::from_vec(owned_font_data, 0).unwrap();
+/// let faster_face = PreParsedSubtables::from(owned_face);
+///
+/// // Lookup a GlyphId using the pre-parsed cmap subtables
+/// // this is much faster than doing: .as_face_ref().glyph_index('x')
+/// assert_eq!(faster_face.glyph_index('x'), Some(GlyphId(91)));
+///
+/// // The rest of the methods are still available as normal
+/// assert_eq!(faster_face.as_face_ref().ascender(), 2254);
+/// ```
+#[derive(Clone)]
+pub struct PreParsedSubtables<'face, F> {
+    /// Underlying face.
+    pub face: F,
+    // note must not be public as could be self-referencing
+    pub(crate) subtables: FaceSubtables<'face>,
+}
+
+impl<'face> From<Face<'face>> for PreParsedSubtables<'face, Face<'face>> {
+    fn from(face: Face<'face>) -> Self {
+        let subtables = FaceSubtables::from(&face);
+        Self { face, subtables }
+    }
+}
+
+impl From<OwnedFace> for PreParsedSubtables<'static, OwnedFace> {
+    fn from(face: OwnedFace) -> Self {
+        face.pre_parse_subtables()
+    }
+}
+
+impl<F> fmt::Debug for PreParsedSubtables<'_, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "PreParsedSubtables")
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct FaceSubtables<'face> {
+    /// Unicode cmap subtables.
+    cmap: Vec<cmap::Subtable<'face>>,
+    /// Horizontal kern subtables.
+    h_kern: Vec<kern::Subtable<'face>>,
+}
+
+impl<'face> From<&Face<'face>> for FaceSubtables<'face> {
+    fn from(face: &Face<'face>) -> Self {
+        let cmap = face
+            .tables()
+            .cmap
+            .iter()
+            .flat_map(|cmap| cmap.subtables)
+            .filter(|st| st.is_unicode())
+            .collect();
+        let h_kern = face
+            .tables()
+            .kern
+            .iter()
+            .flat_map(|c| c.subtables)
+            .filter(|st| st.horizontal && !st.variable)
+            .collect();
+        Self { cmap, h_kern }
+    }
+}
+
+impl<F> PreParsedSubtables<'_, F> {
+    /// Maps a character to a `GlyphId` using pre-parsed unicode cmap subtables.
+    #[inline]
+    pub fn glyph_index(&self, c: char) -> Option<GlyphId> {
+        self.subtables
+            .cmap
+            .iter()
+            .find_map(|t| t.glyph_index(c.into()))
+    }
+
+    /// Maps a variation of a character to a `GlyphId` using pre-parsed unicode cmap subtables.
+    #[inline]
+    pub fn glyph_variation_index(&self, c: char, v: char) -> Option<GlyphId> {
+        self.subtables
+            .cmap
+            .iter()
+            .find_map(|t| t.glyph_variation_index(c.into(), v.into()))
+            .and_then(|r| match r {
+                cmap::GlyphVariationResult::Found(v) => Some(v),
+                cmap::GlyphVariationResult::UseDefault => self.glyph_index(c),
+            })
+    }
+
+    /// Returns horizontal kerning for a pair of glyphs using pre-parsed kern subtables.
+    #[inline]
+    pub fn glyphs_hor_kerning(&self, first: GlyphId, second: GlyphId) -> Option<i16> {
+        self.subtables
+            .h_kern
+            .iter()
+            .find_map(|st| st.glyphs_kerning(first, second))
+    }
+}
+
+impl<F> AsFaceRef for PreParsedSubtables<'_, F>
+where
+    F: AsFaceRef,
+{
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        self.face.as_face_ref()
+    }
+}
+impl<F> AsFaceRef for &PreParsedSubtables<'_, F>
+where
+    F: AsFaceRef,
+{
+    #[inline]
+    fn as_face_ref(&self) -> &ttf_parser::Face<'_> {
+        (*self).as_face_ref()
+    }
+}
+
+impl<F> FaceMut for PreParsedSubtables<'_, F>
+where
+    F: FaceMut,
+{
+    #[inline]
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        self.face.set_variation(axis, value)
+    }
+}
+impl<F> FaceMut for &mut PreParsedSubtables<'_, F>
+where
+    F: FaceMut,
+{
+    #[inline]
+    fn set_variation(&mut self, axis: ttf_parser::Tag, value: f32) -> Option<()> {
+        (*self).set_variation(axis, value)
+    }
+}