blitz-pdf 0.1.6 → 0.1.7

package/vendor/fontique/src/collection/query.rs

@@ -0,0 +1,392 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Query support.
+
+use crate::{Charmap, CharmapIndex};
+
+use super::super::{Collection, SourceCache, matching::match_fonts};
+
+use alloc::vec::Vec;
+use parlance::Script;
+use smallvec::SmallVec;
+
+use super::{
+    super::{Attributes, Blob, FallbackKey, FamilyId, FamilyInfo, GenericFamily, Synthesis},
+    Inner,
+};
+
+#[derive(Clone, Default)]
+pub(super) struct QueryState {
+    families: Vec<CachedFamily>,
+    fallback_families: Vec<CachedFamily>,
+    registered_families: Vec<CachedFamily>,
+}
+
+impl QueryState {
+    fn clear(&mut self) {
+        self.families.clear();
+        self.fallback_families.clear();
+        self.registered_families.clear();
+    }
+}
+
+/// State for font selection.
+///
+/// Instances of this can be obtained from [`Collection::query`].
+pub struct Query<'a> {
+    collection: &'a mut Inner,
+    state: &'a mut QueryState,
+    source_cache: &'a mut SourceCache,
+    attributes: Attributes,
+    fallbacks: Option<FallbackKey>,
+}
+
+impl<'a> Query<'a> {
+    pub(super) fn new(collection: &'a mut Collection, source_cache: &'a mut SourceCache) -> Self {
+        collection.query_state.clear();
+        collection.query_state.registered_families.extend(
+            collection
+                .inner
+                .registered_fallbacks()
+                .into_iter()
+                .map(CachedFamily::new),
+        );
+        Self {
+            collection: &mut collection.inner,
+            state: &mut collection.query_state,
+            source_cache,
+            attributes: Attributes::default(),
+            fallbacks: None,
+        }
+    }
+
+    /// Sets the ordered sequence of families to match against.
+    pub fn set_families<'f, I>(&mut self, families: I)
+    where
+        I: IntoIterator,
+        I::Item: Into<QueryFamily<'f>>,
+    {
+        self.state.families.clear();
+        for family in families {
+            let family = family.into();
+            match family {
+                QueryFamily::Named(name) => {
+                    if let Some(id) = self.collection.family_id(name) {
+                        self.state.families.push(CachedFamily::new(id));
+                    }
+                }
+                QueryFamily::Id(id) => {
+                    self.state.families.push(CachedFamily::new(id));
+                }
+                QueryFamily::Generic(generic) => {
+                    for id in self.collection.generic_families(generic) {
+                        self.state.families.push(CachedFamily::new(id));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Sets the primary attributes to match against.
+    pub fn set_attributes(&mut self, attributes: Attributes) {
+        if self.attributes != attributes {
+            for family in &mut self.state.families {
+                family.clear_fonts();
+            }
+            for family in self
+                .state
+                .fallback_families
+                .iter_mut()
+                .chain(&mut self.state.registered_families)
+            {
+                family.clear_fonts();
+            }
+            self.attributes = attributes;
+        }
+    }
+
+    /// Sets the script and locale for fallback fonts.
+    pub fn set_fallbacks(&mut self, key: impl Into<FallbackKey>) {
+        let key = key.into();
+        if self.fallbacks != Some(key) {
+            self.state.fallback_families.clear();
+            self.state.fallback_families.extend(
+                self.collection
+                    .fallback_families(key)
+                    .map(CachedFamily::new),
+            );
+            // HACK: always add a Han font to the fallback list to capture
+            // punctuation in the common script
+            // See <https://github.com/linebender/parley/issues/597>
+            self.state.fallback_families.extend(
+                self.collection
+                    .fallback_families(FallbackKey::new(Script::from_bytes(*b"Hani"), None))
+                    .map(CachedFamily::new),
+            );
+            self.fallbacks = Some(key);
+        }
+    }
+
+    /// Invokes the given callback with all fonts that match the current
+    /// settings.
+    ///
+    /// Return [`QueryStatus::Stop`] to end iterating over the matching
+    /// fonts or [`QueryStatus::Continue`] to continue iterating.
+    pub fn matches_with<'q>(&'q mut self, mut f: impl FnMut(&'q QueryFont) -> QueryStatus) {
+        for family in self
+            .state
+            .families
+            .iter_mut()
+            .chain(self.state.fallback_families.iter_mut())
+            .chain(self.state.registered_families.iter_mut())
+        {
+            match &mut family.family {
+                Entry::Error => continue,
+                Entry::Ok(..) => {}
+                status @ Entry::Vacant => {
+                    if let Some(info) = self.collection.family(family.id) {
+                        *status = Entry::Ok(info);
+                    } else {
+                        *status = Entry::Error;
+                        continue;
+                    }
+                }
+            }
+            let Entry::Ok(family_info) = &family.family else {
+                continue;
+            };
+            let bucket = load_bucket(
+                family_info,
+                self.attributes,
+                &mut family.best,
+                self.source_cache,
+            );
+            let mut yielded_default = false;
+            for font in bucket {
+                if font.family.1 == family_info.default_font_index() {
+                    yielded_default = true;
+                }
+                if f(font) == QueryStatus::Stop {
+                    return;
+                }
+            }
+            if yielded_default {
+                continue;
+            }
+            if let Some(font) = load_font(
+                family_info,
+                self.attributes,
+                &mut family.default,
+                self.source_cache,
+            ) && f(font) == QueryStatus::Stop
+            {
+                return;
+            }
+        }
+    }
+
+    /// Returns the [first available font] for the current settings: the first
+    /// font that [`matches_with`](Self::matches_with) would yield, if any.
+    ///
+    /// CSS additionally requires the font's `unicode-range` to include U+0020
+    /// SPACE; fontique has no `unicode-range`, so every available font qualifies.
+    ///
+    /// [first available font]: https://drafts.csswg.org/css-fonts-4/#first-available-font
+    pub fn first_available_font(&mut self) -> Option<QueryFont> {
+        let mut found = None;
+        self.matches_with(|font| {
+            found = Some(font.clone());
+            QueryStatus::Stop
+        });
+        found
+    }
+}
+
+impl Drop for Query<'_> {
+    fn drop(&mut self) {
+        self.state.clear();
+    }
+}
+
+/// Determines whether a font query operation will continue.
+///
+/// See [`Query::matches_with`].
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum QueryStatus {
+    /// Query should continue with the next font.
+    Continue,
+    /// Query should stop.
+    Stop,
+}
+
+/// Family descriptor for a font query.
+///
+/// This allows [`Query::set_families`] to
+/// take a variety of family types.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub enum QueryFamily<'a> {
+    /// A named font family.
+    Named(&'a str),
+    /// An identifier for a font family.
+    Id(FamilyId),
+    /// A generic font family.
+    Generic(GenericFamily),
+}
+
+impl<'a> From<&'a str> for QueryFamily<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::Named(value)
+    }
+}
+
+impl From<FamilyId> for QueryFamily<'static> {
+    fn from(value: FamilyId) -> Self {
+        Self::Id(value)
+    }
+}
+
+impl From<GenericFamily> for QueryFamily<'static> {
+    fn from(value: GenericFamily) -> Self {
+        Self::Generic(value)
+    }
+}
+
+/// Candidate font generated by a [`Query`].
+#[derive(Clone, Debug)]
+pub struct QueryFont {
+    /// Family identifier and index of the font in the family font list.
+    pub family: (FamilyId, usize),
+    /// Blob containing the font data.
+    pub blob: Blob<u8>,
+    /// Index of a font in a font collection (`ttc`) file.
+    pub index: u32,
+    /// Synthesis suggestions for this font based on the requested attributes.
+    pub synthesis: Synthesis,
+    /// Data used for constructing a character map for this font.
+    pub charmap_index: CharmapIndex,
+}
+
+impl QueryFont {
+    /// Attempts to construct a [Charmap] for this font.
+    pub fn charmap(&self) -> Option<Charmap<'_>> {
+        self.charmap_index.charmap(self.blob.as_ref())
+    }
+}
+
+/// Loads every font in `family` matching `attributes` (all coverage variants of the best match).
+fn load_bucket<'a>(
+    family: &FamilyInfo,
+    attributes: Attributes,
+    bucket: &'a mut Entry<SmallVec<[QueryFont; 1]>>,
+    source_cache: &mut SourceCache,
+) -> &'a [QueryFont] {
+    match bucket {
+        Entry::Error => &[],
+        Entry::Ok(fonts) => fonts,
+        status @ Entry::Vacant => {
+            *status = Entry::Error;
+            let indices = match_fonts(
+                family.fonts(),
+                attributes.width,
+                attributes.style,
+                attributes.weight,
+                true,
+            );
+            let mut fonts: SmallVec<[QueryFont; 1]> = SmallVec::new();
+            for index in indices {
+                let Some(font_info) = family.fonts().get(index) else {
+                    continue;
+                };
+                let Some(blob) = font_info.load(Some(source_cache)) else {
+                    continue;
+                };
+                fonts.push(QueryFont {
+                    family: (family.id(), index),
+                    blob: blob.clone(),
+                    index: font_info.index(),
+                    synthesis: font_info.synthesis(
+                        attributes.width,
+                        attributes.style,
+                        attributes.weight,
+                    ),
+                    charmap_index: font_info.charmap_index(),
+                });
+            }
+            if fonts.is_empty() {
+                return &[];
+            }
+            *status = Entry::Ok(fonts);
+            let Entry::Ok(fonts) = status else {
+                unreachable!()
+            };
+            fonts
+        }
+    }
+}
+
+fn load_font<'a>(
+    family: &FamilyInfo,
+    attributes: Attributes,
+    font: &'a mut Entry<QueryFont>,
+    source_cache: &mut SourceCache,
+) -> Option<&'a QueryFont> {
+    match font {
+        Entry::Error => None,
+        Entry::Ok(font) => Some(font),
+        status @ Entry::Vacant => {
+            // Set to error in case we fail. This simplifies
+            // the following code.
+            *status = Entry::Error;
+            let family_index = family.default_font_index();
+            let font_info = family.fonts().get(family_index)?;
+            let blob = font_info.load(Some(source_cache))?;
+            let blob_index = font_info.index();
+            let synthesis =
+                font_info.synthesis(attributes.width, attributes.style, attributes.weight);
+            *status = Entry::Ok(QueryFont {
+                family: (family.id(), family_index),
+                blob,
+                index: blob_index,
+                synthesis,
+                charmap_index: font_info.charmap_index(),
+            });
+            if let Entry::Ok(font) = status {
+                Some(font)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+struct CachedFamily {
+    id: FamilyId,
+    family: Entry<FamilyInfo>,
+    best: Entry<SmallVec<[QueryFont; 1]>>,
+    default: Entry<QueryFont>,
+}
+
+impl CachedFamily {
+    fn new(id: FamilyId) -> Self {
+        Self {
+            id,
+            family: Entry::Vacant,
+            best: Entry::Vacant,
+            default: Entry::Vacant,
+        }
+    }
+
+    fn clear_fonts(&mut self) {
+        self.best = Entry::Vacant;
+        self.default = Entry::Vacant;
+    }
+}
+
+#[derive(Clone)]
+enum Entry<T> {
+    Ok(T),
+    Vacant,
+    Error,
+}

package/vendor/fontique/src/fallback.rs

@@ -0,0 +1,293 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Support for script/language based font fallback.
+
+use super::{Language, Script, family::FamilyId};
+use alloc::vec::Vec;
+use hashbrown::HashMap;
+use smallvec::SmallVec;
+
+type FamilyList = SmallVec<[FamilyId; 1]>;
+
+/// Maps script and language pairs to font families.
+#[derive(Clone, Default, Debug)]
+pub struct FallbackMap {
+    fallbacks: HashMap<Script, PerScript>,
+}
+
+impl FallbackMap {
+    /// Returns the font fallback families for the given key.
+    pub fn get(&self, key: impl Into<FallbackKey>) -> Option<&[FamilyId]> {
+        let key = key.into();
+        let entry = self.fallbacks.get(&key.script)?;
+        if key.is_default() {
+            Some(entry.default.as_ref()?.as_slice())
+        } else {
+            for other in &entry.others {
+                if key.locale() == Some(other.0) {
+                    return Some(other.1.as_slice());
+                }
+            }
+            None
+        }
+    }
+
+    /// Inserts or replaces the fallback families for the given script and
+    /// language.
+    ///
+    /// Returns `false` if we don't track that particular pair of script and
+    /// language.
+    pub fn set(
+        &mut self,
+        key: impl Into<FallbackKey>,
+        families: impl Iterator<Item = FamilyId>,
+    ) -> bool {
+        self.set_or_append(key, families, true)
+    }
+
+    /// Inserts or appends the fallback families for the given script and
+    /// language.
+    ///
+    /// Returns `false` if we don't track that particular pair of script and
+    /// language.
+    pub fn append(
+        &mut self,
+        key: impl Into<FallbackKey>,
+        families: impl Iterator<Item = FamilyId>,
+    ) -> bool {
+        self.set_or_append(key, families, false)
+    }
+
+    fn set_or_append(
+        &mut self,
+        key: impl Into<FallbackKey>,
+        families: impl Iterator<Item = FamilyId>,
+        do_set: bool,
+    ) -> bool {
+        let key = key.into();
+        let script = key.script;
+        if key.is_tracked() {
+            if key.is_default() {
+                let existing_families = self
+                    .fallbacks
+                    .entry(script)
+                    .or_default()
+                    .default
+                    .get_or_insert(SmallVec::default());
+                if do_set {
+                    existing_families.clear();
+                }
+                existing_families.extend(families);
+                true
+            } else {
+                let locale = key
+                    .locale
+                    .expect("non-default fallback keys must have a locale");
+                let script_fallbacks = self.fallbacks.entry(script).or_default();
+                if let Some(existing_families) = script_fallbacks
+                    .others
+                    .iter_mut()
+                    .find(|x| x.0 == locale)
+                    .map(|x| &mut x.1)
+                {
+                    if do_set {
+                        existing_families.clear();
+                    }
+                    existing_families.extend(families);
+                } else {
+                    script_fallbacks.others.push((locale, families.collect()));
+                }
+                true
+            }
+        } else {
+            false
+        }
+    }
+}
+
+/// Describes a selector for fallback families.
+///
+/// This is a [`Script`] and optionally, a `locale`, represented as a [`Language`].
+///
+/// It can be constructed directly via [`FallbackKey::new`] or any of
+/// a variety of `From` implementations to improve the ease of use.
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct FallbackKey {
+    script: Script,
+    locale: Option<Language>,
+    is_default: bool,
+    is_tracked: bool,
+}
+
+impl FallbackKey {
+    /// Creates a new fallback key from the given script and locale.
+    pub fn new(script: impl Into<Script>, locale: Option<&Language>) -> Self {
+        let script = script.into();
+        let (locale, is_default, is_tracked) = match canonical_locale(script, locale) {
+            Some((is_default, locale)) => (locale, is_default, true),
+            None => (None, true, false),
+        };
+        Self {
+            script,
+            locale,
+            is_default,
+            is_tracked,
+        }
+    }
+
+    /// Returns the requested script.
+    pub fn script(&self) -> Script {
+        self.script
+    }
+
+    /// Returns a normalized version of the requested locale.
+    pub fn locale(&self) -> Option<Language> {
+        self.locale
+    }
+
+    /// Returns the requested locale as a string, if present.
+    pub fn locale_str(&self) -> Option<&str> {
+        self.locale.as_ref().map(Language::as_str)
+    }
+
+    /// Returns `true` if the requested locale is considered the "default"
+    /// language/region for the requested script.
+    ///
+    /// Always returns `true` when [`locale`](Self::locale) returns `None`.
+    pub fn is_default(&self) -> bool {
+        self.is_default
+    }
+
+    /// Returns `true` if the requested script and locale pair are actually
+    /// tracked for fallback.
+    pub fn is_tracked(&self) -> bool {
+        self.is_tracked
+    }
+}
+
+impl<S> From<(S, &str)> for FallbackKey
+where
+    S: Into<Script>,
+{
+    fn from(value: (S, &str)) -> Self {
+        let locale = Language::parse(value.1).ok();
+        Self::new(value.0, locale.as_ref())
+    }
+}
+
+impl<S> From<(S, &Language)> for FallbackKey
+where
+    S: Into<Script>,
+{
+    fn from(value: (S, &Language)) -> Self {
+        Self::new(value.0, Some(value.1))
+    }
+}
+
+impl From<Script> for FallbackKey {
+    fn from(value: Script) -> Self {
+        Self::new(value, None)
+    }
+}
+
+#[derive(Clone, Default, Debug)]
+struct PerScript {
+    default: Option<FamilyList>,
+    others: Vec<(Language, FamilyList)>,
+}
+
+fn canonical_locale(script: Script, locale: Option<&Language>) -> Option<(bool, Option<Language>)> {
+    let Some(locale) = locale else {
+        return Some((true, None));
+    };
+    let lang = locale.language();
+    let region = locale.region().unwrap_or_default();
+    let (is_default, token) = match &script.to_bytes() {
+        b"Arab" => match (lang, region) {
+            ("ar", "") => (true, "ar"),
+            ("ar", "IR") => (false, "ar-IR"),
+            ("fa", "") => (false, "fa"),
+            ("ks", "") => (false, "ks"),
+            ("ku", "IQ") => (false, "ku-IQ"),
+            ("ku", "IR") => (false, "ku-IR"),
+            ("la", "") => (false, "la"),
+            ("ota", "") => (false, "ota"),
+            ("pa", "PK") => (false, "pa-PK"),
+            ("ps", "AF") => (false, "ps-AF"),
+            ("ps", "PK") => (false, "ps-PK"),
+            ("sd", "") => (false, "sd"),
+            ("ug", "") => (false, "ug"),
+            ("ur", "") => (false, "ur"),
+            _ => return None,
+        },
+        b"Beng" => match (lang, region) {
+            ("bn", "") => (true, "bn"),
+            ("as", "") => (false, "as"),
+            ("mni", "") => (false, "mni"),
+            _ => return None,
+        },
+        b"Deva" => match (lang, region) {
+            ("hi", "") => (true, "hi"),
+            ("bh", "") => (false, "bh"),
+            ("bho", "") => (false, "bho"),
+            ("brx", "") => (false, "brx"),
+            ("doi", "") => (false, "doi"),
+            ("hne", "") => (false, "hne"),
+            ("kok", "") => (false, "kok"),
+            ("mai", "") => (false, "mai"),
+            ("mr", "") => (false, "mr"),
+            ("bne", "") => (false, "bne"),
+            ("sa", "") => (false, "sa"),
+            ("sat", "") => (false, "sat"),
+            _ => return None,
+        },
+        b"Ethi" => match (lang, region) {
+            ("gez", "") => (true, "gez"),
+            ("am", "") => (false, "am"),
+            ("byn", "") => (false, "byn"),
+            ("sid", "") => (false, "sid"),
+            ("ti", "ER") => (false, "ti-ER"),
+            ("ti", "ET") => (false, "ti-ET"),
+            ("tig", "") => (false, "tig"),
+            ("wal", "") => (false, "wal"),
+            _ => return None,
+        },
+        b"Hani" => match lang {
+            "ja" => (false, "ja"),
+            "ko" => (false, "ko"),
+            "zh" => {
+                match region {
+                    "HK" => (false, "zh-HK"),
+                    "TW" => (false, "zh-TW"),
+                    "MO" => (false, "zh-MO"),
+                    "SG" => (false, "zh-SG"),
+                    _ => {
+                        if locale.script() == Some("Hant") {
+                            (false, "zh-TW")
+                        } else {
+                            // Default to simplified Chinese
+                            (true, "zh-CN")
+                        }
+                    }
+                }
+            }
+            _ => return None,
+        },
+        b"Hebr" => match (lang, region) {
+            ("he", "") => (true, "he"),
+            ("yi", "") => (false, "yi"),
+            _ => return None,
+        },
+        b"Tibt" => match (lang, region) {
+            ("bo", "") => (true, "bo"),
+            ("dz", "") => (false, "dz"),
+            _ => return None,
+        },
+        _ => return None,
+    };
+    Some((
+        is_default,
+        Some(Language::parse(token).expect("valid canonical locale")),
+    ))
+}