pdf-font 1.0.0-beta.1

PDF font handling: CFF/Type1 parsing, CMap parsing, and PostScript scanning.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::ops::Range;
use std::sync::LazyLock;

use super::huffman::{self, HuffmanTable};
use super::reader::Reader;
use crate::cmap::CMapName;

pub(super) static BUNDLE: LazyLock<Bundle> = LazyLock::new(|| {
    let compressed = include_bytes!("../../../assets/cmaps.brotli");
    let mut decompressed = Vec::new();
    let mut reader = compressed.as_slice();

    brotli::BrotliDecompress(&mut reader, &mut decompressed)
        .expect("embedded cmap bundle decompression failed");

    let mut reader = Reader::new(&decompressed);
    let huff_size = reader
        .read_u32()
        .expect("embedded cmap bundle: missing huffman size") as usize;
    let huff_data = reader
        .read_bytes(huff_size)
        .expect("embedded cmap bundle: truncated huffman data");
    let (delta_table, count_table) =
        huffman::decode_tables(huff_data).expect("embedded cmap bundle: corrupt huffman tables");

    let mut entries = Vec::new();

    while !reader.at_end() {
        let start = reader.position();

        // Skip file magic and version.
        reader
            .read_bytes(6)
            .expect("embedded cmap bundle: truncated entry header");
        let file_len = reader
            .read_u32()
            .expect("embedded cmap bundle: missing file_len") as usize;

        reader
            .read_bytes(file_len - 10)
            .expect("embedded cmap bundle: truncated entry data");
        entries.push(start..start + file_len);
    }

    Bundle {
        data: decompressed,
        delta_table,
        count_table,
        entries,
    }
});

pub(super) struct Bundle {
    data: Vec<u8>,
    pub(super) delta_table: HuffmanTable,
    pub(super) count_table: HuffmanTable,
    entries: Vec<Range<usize>>,
}

/// Load the data for a cmap file, by name.
pub fn load_embedded(name: CMapName<'_>) -> Option<&'static [u8]> {
    // Get the index of the font of the cmap in the bundle. They are sorted
    // alphabetically.
    let idx = match name {
        CMapName::N83pvRksjH => 0,
        CMapName::N90msRksjH => 1,
        CMapName::N90msRksjV => 2,
        CMapName::N90mspRksjH => 3,
        CMapName::N90mspRksjV => 4,
        CMapName::N90pvRksjH => 5,
        CMapName::AddRksjH => 6,
        CMapName::AddRksjV => 7,
        CMapName::AdobeCns1Ucs2 => 8,
        CMapName::AdobeGb1Ucs2 => 9,
        CMapName::AdobeJapan1Ucs2 => 10,
        CMapName::AdobeKorea1Ucs2 => 11,
        CMapName::B5pcH => 12,
        CMapName::B5pcV => 13,
        CMapName::CnsEucH => 14,
        CMapName::CnsEucV => 15,
        CMapName::ETenB5H => 16,
        CMapName::ETenB5V => 17,
        CMapName::ETenmsB5H => 18,
        CMapName::ETenmsB5V => 19,
        CMapName::EucH => 20,
        CMapName::EucV => 21,
        CMapName::ExtRksjH => 22,
        CMapName::ExtRksjV => 23,
        CMapName::GbEucH => 24,
        CMapName::GbEucV => 25,
        CMapName::GbkEucH => 26,
        CMapName::GbkEucV => 27,
        CMapName::Gbk2kH => 28,
        CMapName::Gbk2kV => 29,
        CMapName::GbkpEucH => 30,
        CMapName::GbkpEucV => 31,
        CMapName::GbpcEucH => 32,
        CMapName::GbpcEucV => 33,
        CMapName::H => 34,
        CMapName::HKscsB5H => 35,
        CMapName::HKscsB5V => 36,
        CMapName::IdentityH => 37,
        CMapName::IdentityV => 38,
        CMapName::KscEucH => 39,
        CMapName::KscEucV => 40,
        CMapName::KscmsUhcH => 41,
        CMapName::KscmsUhcHwH => 42,
        CMapName::KscmsUhcHwV => 43,
        CMapName::KscmsUhcV => 44,
        CMapName::KscpcEucH => 45,
        CMapName::UniCnsUcs2H => 46,
        CMapName::UniCnsUcs2V => 47,
        CMapName::UniCnsUtf16H => 48,
        CMapName::UniCnsUtf16V => 49,
        CMapName::UniGbUcs2H => 50,
        CMapName::UniGbUcs2V => 51,
        CMapName::UniGbUtf16H => 52,
        CMapName::UniGbUtf16V => 53,
        CMapName::UniJisUcs2H => 54,
        CMapName::UniJisUcs2HwH => 55,
        CMapName::UniJisUcs2HwV => 56,
        CMapName::UniJisUcs2V => 57,
        CMapName::UniJisUtf16H => 58,
        CMapName::UniJisUtf16V => 59,
        CMapName::UniKsUcs2H => 60,
        CMapName::UniKsUcs2V => 61,
        CMapName::UniKsUtf16H => 62,
        CMapName::UniKsUtf16V => 63,
        CMapName::V => 64,
        CMapName::Custom(_) => return None,
    };

    let range = BUNDLE.entries.get(idx)?;

    Some(&BUNDLE.data[range.clone()])
}