Vendor dependencies for 0.3.0 release

vendor/swash/src/feature/aat.rs

@@ -0,0 +1,91 @@
+use super::internal::{aat::morx, raw_tag};
+use super::util::*;
+
+pub use morx::chains;
+use morx::Chains;
+
+#[derive(Copy, Clone)]
+pub struct Features<'a> {
+    chains: Chains<'a>,
+    features: Option<morx::Features<'a>>,
+    kern: bool,
+    seen: SeenFeatures,
+}
+
+impl<'a> Features<'a> {
+    pub fn new(chains: Chains<'a>, kern: bool) -> Self {
+        Self {
+            chains,
+            features: None,
+            kern,
+            seen: SeenFeatures::new(),
+        }
+    }
+}
+
+impl<'a> Iterator for Features<'a> {
+    type Item = (u32, &'static str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.features.is_none() {
+                if let Some(chain) = self.chains.next() {
+                    self.features = Some(chain.features());
+                } else if self.kern {
+                    let tag = raw_tag(b"kern");
+                    let (_, desc) = desc_from_at(tag).unwrap_or((0, "Kerning"));
+                    self.kern = false;
+                    return Some((tag, desc));
+                } else {
+                    return None;
+                }
+            }
+            if let Some(features) = &mut self.features {
+                if let Some(feature) = features.next() {
+                    if let Some((index, tag, desc)) =
+                        desc_from_aat(feature.selector, feature.setting_selector)
+                    {
+                        if self.seen.mark(index) {
+                            return Some((tag, desc));
+                        }
+                    }
+                } else {
+                    self.features = None;
+                    continue;
+                }
+            }
+        }
+    }
+}
+
+pub type OnceItem<'a> = Option<Item<'a>>;
+// #[derive(Copy, Clone)]
+// pub struct OnceItem<'a> {
+//     pub item: Item<'a>,
+//     pub given: bool,
+// }
+
+// impl<'a> OnceItem<'a> {
+//     pub fn new(item: Item<'a>) -> Self {
+//         Self { item, given: false }
+//     }
+// }
+
+// impl<'a> Iterator for OnceItem<'a> {
+//     type Item = Item<'a>;
+
+//     fn next(&mut self) -> Option<Self::Item> {
+//         if self.given {
+//             None
+//         } else {
+//             self.given = true;
+//             Some(self.item)
+//         }
+//     }
+// }
+
+#[derive(Copy, Clone)]
+pub struct Item<'a> {
+    pub chains: Chains<'a>,
+    pub kern: bool,
+}

vendor/swash/src/feature/at.rs

@@ -0,0 +1,405 @@
+use super::super::Tag;
+use super::internal::{at::*, *};
+use super::util::*;
+
+#[derive(Copy, Clone)]
+pub struct Script<'a> {
+    data: Bytes<'a>,
+    gsub: u32,
+    gpos: u32,
+    gsub_offset: u32,
+    gpos_offset: u32,
+    tag: Tag,
+}
+
+impl<'a> Script<'a> {
+    pub fn languages(&self) -> Languages<'a> {
+        Languages::new(
+            self.data,
+            self.gsub,
+            self.gpos,
+            self.gsub_offset,
+            self.gpos_offset,
+        )
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct Scripts<'a> {
+    data: Bytes<'a>,
+    gsub: u32,
+    gpos: u32,
+    in_gsub: bool,
+    len: u16,
+    cur: u16,
+    done: bool,
+}
+
+impl<'a> Scripts<'a> {
+    pub fn new(data: Bytes<'a>, gsub: u32, gpos: u32) -> Self {
+        Self {
+            data,
+            gsub,
+            gpos,
+            in_gsub: true,
+            len: script_count(&data, gsub),
+            cur: 0,
+            done: false,
+        }
+    }
+
+    fn get_next(&mut self) -> Option<Script<'a>> {
+        if self.in_gsub {
+            if self.cur < self.len {
+                let index = self.cur;
+                self.cur += 1;
+                let (tag, offset) = script_at(&self.data, self.gsub, index)?;
+                let gpos_offset = script_by_tag(&self.data, self.gpos, tag).unwrap_or(0);
+                return Some(Script {
+                    data: self.data,
+                    gsub: self.gsub,
+                    gpos: self.gpos,
+                    gsub_offset: offset,
+                    gpos_offset,
+                    tag,
+                });
+            } else {
+                self.in_gsub = false;
+                self.cur = 0;
+                self.len = script_count(&self.data, self.gpos);
+            }
+        } else if self.cur < self.len {
+            let index = self.cur;
+            self.cur += 1;
+            let (tag, offset) = script_at(&self.data, self.gpos, index)?;
+            if script_by_tag(&self.data, self.gsub, tag).is_some() {
+                return None;
+            }
+            return Some(Script {
+                data: self.data,
+                gsub: self.gsub,
+                gpos: self.gpos,
+                gsub_offset: 0,
+                gpos_offset: offset,
+                tag,
+            });
+        } else {
+            self.done = true;
+        }
+        None
+    }
+}
+
+impl<'a> Iterator for Scripts<'a> {
+    type Item = Script<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while !self.done {
+            let item = self.get_next();
+            if item.is_some() {
+                return item;
+            }
+        }
+        None
+    }
+}
+
+/// Specifies language system specific features used for shaping glyphs in
+/// a particular script.
+#[derive(Copy, Clone)]
+pub struct Language<'a> {
+    data: Bytes<'a>,
+    gsub: u32,
+    gpos: u32,
+    gsub_offset: u32,
+    gpos_offset: u32,
+    tag: Tag,
+}
+
+/// An iterator over languages supported by a script.
+#[derive(Copy, Clone)]
+pub struct Languages<'a> {
+    data: Bytes<'a>,
+    gsub: u32,
+    gpos: u32,
+    gsub_script: u32,
+    gpos_script: u32,
+    in_gsub: bool,
+    len: u16,
+    cur: u16,
+    done: bool,
+}
+
+impl<'a> Languages<'a> {
+    fn new(data: Bytes<'a>, gsub: u32, gpos: u32, gsub_script: u32, gpos_script: u32) -> Self {
+        Self {
+            data,
+            gsub,
+            gpos,
+            gsub_script,
+            gpos_script,
+            in_gsub: true,
+            len: script_language_count(&data, gsub_script),
+            cur: 0,
+            done: false,
+        }
+    }
+
+    fn get_next(&mut self) -> Option<Language<'a>> {
+        if self.in_gsub {
+            if self.cur < self.len {
+                let index = self.cur;
+                self.cur += 1;
+                let (tag, offset) = script_language_at(&self.data, self.gsub_script, index)?;
+                let gsub_default = tag == DFLT;
+                let (gpos_offset, _) = if gsub_default {
+                    (
+                        script_default_language(&self.data, self.gpos_script).unwrap_or(0),
+                        true,
+                    )
+                } else {
+                    script_language_by_tag(&self.data, self.gpos_script, Some(tag))
+                        .unwrap_or((0, false))
+                };
+                return Some(Language {
+                    data: self.data,
+                    gsub: self.gsub,
+                    gpos: self.gpos,
+                    gsub_offset: offset,
+                    gpos_offset,
+                    tag,
+                });
+            } else {
+                self.in_gsub = false;
+                self.cur = 0;
+                self.len = script_language_count(&self.data, self.gpos_script);
+            }
+        } else if self.cur < self.len {
+            let index = self.cur;
+            self.cur += 1;
+            let (tag, offset) = script_language_at(&self.data, self.gpos_script, index)?;
+            if script_language_by_tag(&self.data, self.gsub_script, Some(tag)).is_some() {
+                return None;
+            }
+            return Some(Language {
+                data: self.data,
+                gsub: self.gsub,
+                gpos: self.gpos,
+                gsub_offset: 0,
+                gpos_offset: offset,
+                tag,
+            });
+        } else {
+            self.done = true;
+        }
+        None
+    }
+}
+
+impl<'a> Iterator for Languages<'a> {
+    type Item = Language<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while !self.done {
+            let item = self.get_next();
+            if item.is_some() {
+                return item;
+            }
+        }
+        None
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct WritingSystem<'a> {
+    lang: Language<'a>,
+    script_tag: Tag,
+}
+
+impl<'a> WritingSystem<'a> {
+    pub fn script_tag(&self) -> Tag {
+        self.script_tag
+    }
+
+    pub fn language_tag(&self) -> Tag {
+        self.lang.tag
+    }
+
+    pub fn features(&self) -> Features<'a> {
+        Features::new(&self.lang)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct WritingSystems<'a> {
+    scripts: Scripts<'a>,
+    langs: Option<Languages<'a>>,
+    script_tag: Tag,
+}
+
+impl<'a> WritingSystems<'a> {
+    pub fn new(scripts: Scripts<'a>) -> Self {
+        Self {
+            scripts,
+            langs: None,
+            script_tag: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for WritingSystems<'a> {
+    type Item = WritingSystem<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.langs.is_none() {
+                let script = self.scripts.next()?;
+                self.script_tag = script.tag;
+                self.langs = Some(script.languages());
+            }
+            if let Some(lang) = self.langs.as_mut().unwrap().next() {
+                return Some(WritingSystem {
+                    lang,
+                    script_tag: self.script_tag,
+                });
+            } else {
+                self.langs = None;
+            }
+        }
+    }
+}
+
+/// Represents a single typographic feature-- a substitution or positioning
+/// action that is a component of text shaping.
+#[derive(Copy, Clone)]
+pub struct Feature {
+    pub stage: u8,
+    pub tag: Tag,
+}
+
+#[derive(Copy, Clone)]
+pub struct Features<'a> {
+    data: Bytes<'a>,
+    gsub: u32,
+    gpos: u32,
+    gsub_language: u32,
+    gpos_language: u32,
+    stage: u8,
+    len: u16,
+    cur: u16,
+    done: bool,
+}
+
+impl<'a> Features<'a> {
+    fn new(language: &Language<'a>) -> Self {
+        Self {
+            data: language.data,
+            gsub: language.gsub,
+            gpos: language.gpos,
+            gsub_language: language.gsub_offset,
+            gpos_language: language.gpos_offset,
+            stage: 0,
+            len: language_feature_count(&language.data, language.gsub_offset),
+            cur: 0,
+            done: false,
+        }
+    }
+
+    fn get_next(&mut self) -> Option<Feature> {
+        let (gsubgpos, language) = match self.stage {
+            0 => (self.gsub, self.gsub_language),
+            _ => (self.gpos, self.gpos_language),
+        };
+        if self.cur < self.len {
+            let index = self.cur;
+            self.cur += 1;
+            let feature = language_feature_at(&self.data, language, index)?;
+            let (tag, _offset) = feature_at(&self.data, gsubgpos, feature)?;
+            return Some(Feature {
+                stage: self.stage,
+                tag,
+            });
+        } else if self.stage == 0 {
+            self.stage = 1;
+            self.len = language_feature_count(&self.data, self.gpos_language);
+            self.cur = 0;
+        } else {
+            self.done = true;
+        }
+        None
+    }
+}
+
+impl<'a> Iterator for Features<'a> {
+    type Item = Feature;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while !self.done {
+            let item = self.get_next();
+            if item.is_some() {
+                return item;
+            }
+        }
+        None
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct AllFeatures<'a> {
+    data: Bytes<'a>,
+    seen: SeenFeatures,
+    table: u32,
+    next_table: u32,
+    stage: u8,
+    len: u16,
+    cur: u16,
+}
+
+impl<'a> AllFeatures<'a> {
+    pub fn new(data: Bytes<'a>, gsub: u32, gpos: u32) -> Self {
+        let len = feature_count(&data, gsub);
+        Self {
+            data,
+            seen: SeenFeatures::new(),
+            table: gsub,
+            next_table: gpos,
+            stage: 0,
+            len,
+            cur: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for AllFeatures<'a> {
+    type Item = (u8, Tag);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.cur >= self.len {
+                if self.next_table == 0 {
+                    return None;
+                }
+                self.table = self.next_table;
+                self.next_table = 0;
+                self.stage = 1;
+                self.cur = 0;
+                self.len = feature_count(&self.data, self.table);
+                if self.len == 0 {
+                    return None;
+                }
+            }
+            let index = self.cur;
+            self.cur += 1;
+            if let Some((tag, _)) = feature_at(&self.data, self.table, index) {
+                match FEATURES.binary_search_by(|pair| pair.0.cmp(&tag)) {
+                    Ok(index) => {
+                        if self.seen.mark(index) {
+                            return Some((self.stage, tag));
+                        }
+                    }
+                    _ => continue,
+                }
+            }
+        }
+    }
+}

vendor/swash/src/feature/mod.rs

@@ -0,0 +1,269 @@
+mod aat;
+mod at;
+mod util;
+
+use super::internal::{self, raw_tag, Bytes, RawFont};
+use super::{FontRef, Tag};
+use crate::text::{Language, Script};
+
+const DFLT: u32 = raw_tag(b"DFLT");
+
+#[derive(Copy, Clone)]
+enum Kind {
+    None,
+    /// GSUB, GPOS offsets
+    At(u32, u32),
+    /// Morx offset, kerning available
+    Aat(u32, bool),
+}
+
+impl Kind {
+    fn from_font(font: &FontRef) -> Self {
+        let gsub = font.table_offset(raw_tag(b"GSUB"));
+        let gpos = font.table_offset(raw_tag(b"GPOS"));
+        if gsub != 0 || gpos != 0 {
+            return Self::At(gsub, gpos);
+        }
+        let morx = font.table_offset(raw_tag(b"morx"));
+        if morx != 0 {
+            let kern = font.table_offset(raw_tag(b"kern")) != 0
+                || font.table_offset(raw_tag(b"kerx")) != 0;
+            return Self::Aat(morx, kern);
+        }
+        Self::None
+    }
+}
+
+#[derive(Copy, Clone)]
+enum WritingSystemsKind<'a> {
+    None,
+    At(at::WritingSystems<'a>),
+    Aat(aat::OnceItem<'a>),
+}
+
+/// Iterator over a collection of writing systems.
+#[derive(Copy, Clone)]
+pub struct WritingSystems<'a> {
+    kind: WritingSystemsKind<'a>,
+}
+
+impl<'a> WritingSystems<'a> {
+    pub(crate) fn from_font(font: &FontRef<'a>) -> Self {
+        let kind = Kind::from_font(font);
+        WritingSystems {
+            kind: match kind {
+                Kind::At(gsub, gpos) => WritingSystemsKind::At(at::WritingSystems::new(
+                    at::Scripts::new(Bytes::new(font.data), gsub, gpos),
+                )),
+                Kind::Aat(morx, kern) => WritingSystemsKind::Aat(Some(aat::Item {
+                    chains: aat::chains(font.data, morx),
+                    kern,
+                })),
+                _ => WritingSystemsKind::None,
+            },
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+enum WritingSystemKind<'a> {
+    At(at::WritingSystem<'a>),
+    Aat(aat::Item<'a>),
+}
+
+impl<'a> Iterator for WritingSystems<'a> {
+    type Item = WritingSystem<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.kind {
+            WritingSystemsKind::At(iter) => {
+                let item = iter.next()?;
+                Some(WritingSystem {
+                    kind: WritingSystemKind::At(item),
+                    script_tag: item.script_tag(),
+                    lang_tag: item.language_tag(),
+                    lang: Language::from_opentype(item.language_tag()),
+                })
+            }
+            WritingSystemsKind::Aat(iter) => {
+                let item = iter.take()?;
+                Some(WritingSystem {
+                    kind: WritingSystemKind::Aat(item),
+                    script_tag: DFLT,
+                    lang_tag: DFLT,
+                    lang: None,
+                })
+            }
+            _ => None,
+        }
+    }
+}
+
+/// Script, language and associated typographic features available in a font.
+#[derive(Copy, Clone)]
+pub struct WritingSystem<'a> {
+    kind: WritingSystemKind<'a>,
+    script_tag: Tag,
+    lang_tag: Tag,
+    lang: Option<Language>,
+}
+
+impl<'a> WritingSystem<'a> {
+    /// Returns the OpenType script tag for the writing system.
+    pub fn script_tag(&self) -> Tag {
+        self.script_tag
+    }
+
+    /// Returns the OpenType language tag for the writing system.
+    pub fn language_tag(&self) -> Tag {
+        self.lang_tag
+    }
+
+    /// Returns the script for the writing system.
+    pub fn script(&self) -> Option<Script> {
+        Script::from_opentype(self.script_tag)
+    }
+
+    /// Returns the language for the writing system.
+    pub fn language(&self) -> Option<Language> {
+        self.lang
+    }
+
+    /// Returns an iterator over the features provided by the writing
+    /// system.
+    pub fn features(&self) -> Features<'a> {
+        Features {
+            kind: match self.kind {
+                WritingSystemKind::At(item) => FeaturesKind::At(item.features()),
+                WritingSystemKind::Aat(item) => {
+                    FeaturesKind::Aat(aat::Features::new(item.chains, item.kern))
+                }
+            },
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+enum FeaturesKind<'a> {
+    None,
+    At(at::Features<'a>),
+    AtAll(at::AllFeatures<'a>),
+    Aat(aat::Features<'a>),
+}
+
+/// Typographic rule that produces modifications to a sequence of glyphs.
+#[derive(Copy, Clone)]
+pub struct Feature {
+    tag: Tag,
+    name: Option<&'static str>,
+    action: Action,
+}
+
+impl Feature {
+    fn from_tag(tag: Tag, action: Action) -> Self {
+        Self {
+            tag,
+            name: util::desc_from_at(tag).map(|x| x.1),
+            action,
+        }
+    }
+
+    /// Returns the feature tag.
+    pub fn tag(&self) -> Tag {
+        self.tag
+    }
+
+    /// Returns the name of the feature, if available.
+    pub fn name(&self) -> Option<&'static str> {
+        self.name
+    }
+
+    /// Returns the action of the feature.
+    pub fn action(&self) -> Action {
+        self.action
+    }
+}
+
+/// Modification performed by a feature.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Action {
+    /// Replaces one or more glyphs such as in ligation.
+    Substitution,
+    /// Attaches one glyph to another such as in accent mark placement.
+    Attachment,
+    /// Adjusts the position of one or more glyphs such as in kerning.
+    Adjustment,
+}
+
+/// Iterator over a collection of typographic features.
+#[derive(Copy, Clone)]
+pub struct Features<'a> {
+    kind: FeaturesKind<'a>,
+}
+
+impl<'a> Features<'a> {
+    pub(crate) fn from_font(font: &FontRef<'a>) -> Self {
+        let kind = Kind::from_font(font);
+        Self {
+            kind: match kind {
+                Kind::At(gsub, gpos) => {
+                    FeaturesKind::AtAll(at::AllFeatures::new(Bytes::new(font.data), gsub, gpos))
+                }
+                Kind::Aat(morx, kern) => {
+                    FeaturesKind::Aat(aat::Features::new(aat::chains(font.data, morx), kern))
+                }
+                _ => FeaturesKind::None,
+            },
+        }
+    }
+}
+
+const MARK: u32 = raw_tag(b"mark");
+const MKMK: u32 = raw_tag(b"mkmk");
+
+impl<'a> Iterator for Features<'a> {
+    type Item = Feature;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.kind {
+            FeaturesKind::At(iter) => {
+                let item = iter.next()?;
+                let action = if item.stage == 0 {
+                    Action::Substitution
+                } else {
+                    match item.tag {
+                        MARK | MKMK => Action::Attachment,
+                        _ => Action::Adjustment,
+                    }
+                };
+                Some(Feature::from_tag(item.tag, action))
+            }
+            FeaturesKind::AtAll(iter) => {
+                let (stage, tag) = iter.next()?;
+                let action = if stage == 0 {
+                    Action::Substitution
+                } else {
+                    match tag {
+                        MARK | MKMK => Action::Attachment,
+                        _ => Action::Adjustment,
+                    }
+                };
+                Some(Feature::from_tag(tag, action))
+            }
+            FeaturesKind::Aat(iter) => {
+                let (tag, name) = iter.next()?;
+                let action = if tag == raw_tag(b"kern") {
+                    Action::Adjustment
+                } else {
+                    Action::Substitution
+                };
+                Some(Feature {
+                    tag,
+                    name: Some(name),
+                    action,
+                })
+            }
+            _ => None,
+        }
+    }
+}

vendor/swash/src/feature/util.rs

@@ -0,0 +1,269 @@
+use super::internal::{raw_tag, RawTag};
+
+#[derive(Copy, Clone)]
+pub struct SeenFeatures {
+    bits: [u32; 6],
+}
+
+impl SeenFeatures {
+    pub fn new() -> Self {
+        Self { bits: [0; 6] }
+    }
+
+    pub fn mark(&mut self, feature_index: usize) -> bool {
+        let word = &mut self.bits[feature_index / 32];
+        let bit = 1 << (feature_index % 32);
+        if *word & bit == 0 {
+            *word |= bit;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// Returns a feature description for the specified tag.
+pub fn desc_from_at(tag: RawTag) -> Option<(usize, &'static str)> {
+    Some(match FEATURES.binary_search_by(|e| e.0.cmp(&tag)) {
+        Ok(index) => (index, FEATURES[index].1),
+        _ => return None,
+    })
+}
+
+/// Returns a feature tag and description from an AAT feature
+/// and selector.
+pub fn desc_from_aat(feature: u16, selector: u16) -> Option<(usize, RawTag, &'static str)> {
+    let key = (feature << 8) | selector;
+    Some(match AAT_TO_AT.binary_search_by(|pair| pair.0.cmp(&key)) {
+        Ok(index) => {
+            let (tag, desc) = FEATURES[AAT_TO_AT[index].1 as usize];
+            (index, tag, desc)
+        }
+        _ => return None,
+    })
+}
+
+pub const FEATURES: [(u32, &'static str); 142] = [
+    (raw_tag(b"aalt"), "Access All Alternates"),
+    (raw_tag(b"abvf"), "Above-base Forms"),
+    (raw_tag(b"abvm"), "Above-base Mark Positioning"),
+    (raw_tag(b"abvs"), "Above-base Substitutions"),
+    (raw_tag(b"afrc"), "Alternative Fractions"),
+    (raw_tag(b"akhn"), "Akhands"),
+    (raw_tag(b"blwf"), "Below-base Forms"),
+    (raw_tag(b"blwm"), "Below-base Mark Positioning"),
+    (raw_tag(b"blws"), "Below-base Substitutions"),
+    (raw_tag(b"c2pc"), "Petite Capitals From Capitals"),
+    (raw_tag(b"c2sc"), "Small Capitals From Capitals"),
+    (raw_tag(b"calt"), "Contextual Alternates"),
+    (raw_tag(b"case"), "Case-Sensitive Forms"),
+    (raw_tag(b"ccmp"), "Glyph Composition / Decomposition"),
+    (raw_tag(b"cfar"), "Conjunct Form After Ro"),
+    (raw_tag(b"chws"), "Contextual Half-width Spacing"),
+    (raw_tag(b"cjct"), "Conjunct Forms"),
+    (raw_tag(b"clig"), "Contextual Ligatures"),
+    (raw_tag(b"cpct"), "Centered CJK Punctuation"),
+    (raw_tag(b"cpsp"), "Capital Spacing"),
+    (raw_tag(b"cswh"), "Contextual Swash"),
+    (raw_tag(b"curs"), "Cursive Positioning"),
+    (raw_tag(b"dist"), "Distances"),
+    (raw_tag(b"dlig"), "Discretionary Ligatures"),
+    (raw_tag(b"dnom"), "Denominators"),
+    (raw_tag(b"dtls"), "Dotless Forms"),
+    (raw_tag(b"expt"), "Expert Forms"),
+    (raw_tag(b"falt"), "Final Glyph on Line Alternates"),
+    (raw_tag(b"fin2"), "Terminal Forms #2"),
+    (raw_tag(b"fin3"), "Terminal Forms #3"),
+    (raw_tag(b"fina"), "Terminal Forms"),
+    (raw_tag(b"flac"), "Flattened accent forms"),
+    (raw_tag(b"frac"), "Fractions"),
+    (raw_tag(b"fwid"), "Full Widths"),
+    (raw_tag(b"half"), "Half Forms"),
+    (raw_tag(b"haln"), "Halant Forms"),
+    (raw_tag(b"halt"), "Alternate Half Widths"),
+    (raw_tag(b"hist"), "Historical Forms"),
+    (raw_tag(b"hkna"), "Horizontal Kana Alternates"),
+    (raw_tag(b"hlig"), "Historical Ligatures"),
+    (raw_tag(b"hngl"), "Hangul"),
+    (raw_tag(b"hojo"), "Hojo Kanji Forms"),
+    (raw_tag(b"hwid"), "Half Widths"),
+    (raw_tag(b"init"), "Initial Forms"),
+    (raw_tag(b"isol"), "Isolated Forms"),
+    (raw_tag(b"ital"), "Italics"),
+    (raw_tag(b"jalt"), "Justification Alternates"),
+    (raw_tag(b"jp78"), "JIS78 Forms"),
+    (raw_tag(b"jp83"), "JIS83 Forms"),
+    (raw_tag(b"jp90"), "JIS90 Forms"),
+    (raw_tag(b"jp04"), "JIS2004 Forms"),
+    (raw_tag(b"kern"), "Kerning"),
+    (raw_tag(b"lfbd"), "Left Bounds"),
+    (raw_tag(b"liga"), "Standard Ligatures"),
+    (raw_tag(b"ljmo"), "Leading Jamo Forms"),
+    (raw_tag(b"lnum"), "Lining Figures"),
+    (raw_tag(b"locl"), "Localized Forms"),
+    (raw_tag(b"ltra"), "Left-to-right alternates"),
+    (raw_tag(b"ltrm"), "Left-to-right mirrored forms"),
+    (raw_tag(b"mark"), "Mark Positioning"),
+    (raw_tag(b"med2"), "Medial Forms #2"),
+    (raw_tag(b"medi"), "Medial Forms"),
+    (raw_tag(b"mgrk"), "Mathematical Greek"),
+    (raw_tag(b"mkmk"), "Mark to Mark Positioning"),
+    (raw_tag(b"mset"), "Mark Positioning via Substitution"),
+    (raw_tag(b"nalt"), "Alternate Annotation Forms"),
+    (raw_tag(b"nlck"), "NLC Kanji Forms"),
+    (raw_tag(b"nukt"), "Nukta Forms"),
+    (raw_tag(b"numr"), "Numerators"),
+    (raw_tag(b"onum"), "Oldstyle Figures"),
+    (raw_tag(b"opbd"), "Optical Bounds"),
+    (raw_tag(b"ordn"), "Ordinals"),
+    (raw_tag(b"ornm"), "Ornaments"),
+    (raw_tag(b"palt"), "Proportional Alternate Widths"),
+    (raw_tag(b"pcap"), "Petite Capitals"),
+    (raw_tag(b"pkna"), "Proportional Kana"),
+    (raw_tag(b"pnum"), "Proportional Figures"),
+    (raw_tag(b"pref"), "Pre-Base Forms"),
+    (raw_tag(b"pres"), "Pre-base Substitutions"),
+    (raw_tag(b"pstf"), "Post-base Forms"),
+    (raw_tag(b"psts"), "Post-base Substitutions"),
+    (raw_tag(b"pwid"), "Proportional Widths"),
+    (raw_tag(b"qwid"), "Quarter Widths"),
+    (raw_tag(b"rand"), "Randomize"),
+    (raw_tag(b"rclt"), "Required Contextual Alternates"),
+    (raw_tag(b"rkrf"), "Rakar Forms"),
+    (raw_tag(b"rlig"), "Required Ligatures"),
+    (raw_tag(b"rphf"), "Reph Forms"),
+    (raw_tag(b"rtbd"), "Right Bounds"),
+    (raw_tag(b"rtla"), "Right-to-left alternates"),
+    (raw_tag(b"rtlm"), "Right-to-left mirrored forms"),
+    (raw_tag(b"ruby"), "Ruby Notation Forms"),
+    (raw_tag(b"rvrn"), "Required Variation Alternates"),
+    (raw_tag(b"salt"), "Stylistic Alternates"),
+    (raw_tag(b"sinf"), "Scientific Inferiors"),
+    (raw_tag(b"size"), "Optical size"),
+    (raw_tag(b"smcp"), "Small Capitals"),
+    (raw_tag(b"smpl"), "Simplified Forms"),
+    (raw_tag(b"ss01"), "Stylistic Set 1"),
+    (raw_tag(b"ss02"), "Stylistic Set 2"),
+    (raw_tag(b"ss03"), "Stylistic Set 3"),
+    (raw_tag(b"ss04"), "Stylistic Set 4"),
+    (raw_tag(b"ss05"), "Stylistic Set 5"),
+    (raw_tag(b"ss06"), "Stylistic Set 6"),
+    (raw_tag(b"ss07"), "Stylistic Set 7"),
+    (raw_tag(b"ss08"), "Stylistic Set 8"),
+    (raw_tag(b"ss09"), "Stylistic Set 9"),
+    (raw_tag(b"ss10"), "Stylistic Set 10"),
+    (raw_tag(b"ss11"), "Stylistic Set 11"),
+    (raw_tag(b"ss12"), "Stylistic Set 12"),
+    (raw_tag(b"ss13"), "Stylistic Set 13"),
+    (raw_tag(b"ss14"), "Stylistic Set 14"),
+    (raw_tag(b"ss15"), "Stylistic Set 15"),
+    (raw_tag(b"ss16"), "Stylistic Set 16"),
+    (raw_tag(b"ss17"), "Stylistic Set 17"),
+    (raw_tag(b"ss18"), "Stylistic Set 18"),
+    (raw_tag(b"ss19"), "Stylistic Set 19"),
+    (raw_tag(b"ss20"), "Stylistic Set 20"),
+    (raw_tag(b"ssty"), "Math script style alternates"),
+    (raw_tag(b"stch"), "Stretching Glyph Decomposition"),
+    (raw_tag(b"subs"), "Subscript"),
+    (raw_tag(b"sups"), "Superscript"),
+    (raw_tag(b"swsh"), "Swash"),
+    (raw_tag(b"titl"), "Titling"),
+    (raw_tag(b"tjmo"), "Trailing Jamo Forms"),
+    (raw_tag(b"tnam"), "Traditional Name Forms"),
+    (raw_tag(b"tnum"), "Tabular Figures"),
+    (raw_tag(b"trad"), "Traditional Forms"),
+    (raw_tag(b"twid"), "Third Widths"),
+    (raw_tag(b"unic"), "Unicase"),
+    (raw_tag(b"valt"), "Alternate Vertical Metrics"),
+    (raw_tag(b"vatu"), "Vattu Variants"),
+    (raw_tag(b"vchw"), "Vertical Contextual Half-width Spacing"),
+    (raw_tag(b"vert"), "Vertical Writing"),
+    (raw_tag(b"vhal"), "Alternate Vertical Half Metrics"),
+    (raw_tag(b"vjmo"), "Vowel Jamo Forms"),
+    (raw_tag(b"vkna"), "Vertical Kana Alternates"),
+    (raw_tag(b"vkrn"), "Vertical Kerning"),
+    (raw_tag(b"vpal"), "Proportional Alternate Vertical Metrics"),
+    (raw_tag(b"vrt2"), "Vertical Alternates and Rotation"),
+    (raw_tag(b"vrtr"), "Vertical Alternates for Rotation"),
+    (raw_tag(b"zero"), "Slashed Zero"),
+];
+
+pub const AAT_TO_AT: [(u16, u16); 77] = [
+    (256, 86),
+    (258, 53),
+    (260, 23),
+    (274, 15),
+    (276, 37),
+    (276, 39),
+    (782, 129),
+    (1024, 133),
+    (1024, 139),
+    (1536, 126),
+    (1537, 76),
+    (2561, 121),
+    (2562, 120),
+    (2563, 71),
+    (2564, 94),
+    (2817, 4),
+    (2818, 32),
+    (3588, 141),
+    (3850, 62),
+    (4868, 123),
+    (5120, 127),
+    (5121, 97),
+    (5122, 47),
+    (5123, 48),
+    (5124, 49),
+    (5130, 26),
+    (5131, 50),
+    (5132, 41),
+    (5133, 66),
+    (5134, 125),
+    (5376, 69),
+    (5377, 55),
+    (5632, 81),
+    (5632, 75),
+    (5633, 33),
+    (5634, 42),
+    (5635, 128),
+    (5636, 82),
+    (5637, 73),
+    (5637, 130),
+    (5637, 138),
+    (5638, 36),
+    (5638, 134),
+    (5889, 40),
+    (7170, 91),
+    (8194, 45),
+    (8448, 10),
+    (8450, 17),
+    (8704, 38),
+    (8706, 136),
+    (8962, 98),
+    (8964, 99),
+    (8966, 100),
+    (8968, 101),
+    (8970, 102),
+    (8972, 103),
+    (8974, 104),
+    (8976, 105),
+    (8978, 106),
+    (8980, 107),
+    (8982, 108),
+    (8984, 109),
+    (8986, 110),
+    (8988, 111),
+    (8990, 112),
+    (8992, 113),
+    (8994, 114),
+    (8996, 115),
+    (8998, 116),
+    (9000, 117),
+    (9216, 9),
+    (9218, 122),
+    (9220, 18),
+    (9473, 96),
+    (9474, 74),
+    (9729, 21),
+    (9730, 20),
+];