harumi 1.4.4

Pure-Rust PDF — CJK font embedding (Chinese/Japanese/Korean), OCR text overlay, text extraction, HTML→PDF, page merge/split. WASM-ready, zero C deps.
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::fmt;

/// Errors returned by harumi operations.
#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
    /// A file system or stream I/O error.
    Io(std::io::Error),

    /// A structural problem in the PDF (malformed object graph, missing key, etc.).
    Pdf(lopdf::Error),

    /// The font format is not supported. Only TrueType (`.ttf`) and OpenType (`.otf`) are supported.
    UnsupportedFontKind,

    /// The font binary could not be parsed.
    FontParse(String),

    /// The requested page number does not exist in the document.
    PageNotFound(u32),

    /// A [`FontHandle`](crate::FontHandle) obtained from a different `Document` was used.
    InvalidFont(u32),

    /// An image could not be decoded (requires the `image` feature).
    #[cfg(feature = "image")]
    ImageDecode(String),

    #[cfg(not(feature = "image"))]
    #[doc(hidden)]
    _ImageDecode,

    /// A caller-supplied parameter is invalid (e.g. NaN coordinate, zero-size box).
    InvalidInput(String),

    /// A character in `new_text` is not present in the embedded font's ToUnicode mapping.
    /// The font may be subsetted and no longer contain the required glyph.
    FontCharNotMapped { ch: char, font_name: String },

    /// The password provided for an encrypted PDF was incorrect.
    WrongPassword,

    /// A certificate or private key could not be parsed (requires the `digital-signature` feature).
    #[cfg(feature = "digital-signature")]
    InvalidCertificate(String),

    #[cfg(not(feature = "digital-signature"))]
    #[doc(hidden)]
    _InvalidCertificate,

    /// A private key could not be parsed (requires the `digital-signature` feature).
    #[cfg(feature = "digital-signature")]
    InvalidPrivateKey(String),

    #[cfg(not(feature = "digital-signature"))]
    #[doc(hidden)]
    _InvalidPrivateKey,

    /// PKCS#12 file could not be parsed (requires the `digital-signature` feature).
    #[cfg(feature = "digital-signature")]
    Pkcs12Parse(String),

    #[cfg(not(feature = "digital-signature"))]
    #[doc(hidden)]
    _Pkcs12Parse,

    /// Signature operation failed (requires the `digital-signature` feature).
    #[cfg(feature = "digital-signature")]
    SignatureFailed(String),

    #[cfg(not(feature = "digital-signature"))]
    #[doc(hidden)]
    _SignatureFailed,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Io(e) => write!(f, "I/O error: {}", e),
            Error::Pdf(e) => write!(f, "PDF error: {}", e),
            Error::UnsupportedFontKind => write!(
                f,
                "unsupported font kind: only TrueType (.ttf) and OpenType (.otf) are supported"
            ),
            Error::FontParse(msg) => write!(f, "font parse error: {}", msg),
            Error::PageNotFound(page) => write!(f, "page {} not found", page),
            Error::InvalidFont(handle) => write!(f, "font handle {} is invalid", handle),
            #[cfg(feature = "image")]
            Error::ImageDecode(msg) => write!(f, "image decode error: {}", msg),
            #[cfg(not(feature = "image"))]
            Error::_ImageDecode => unreachable!(),
            Error::InvalidInput(msg) => write!(f, "invalid input: {}", msg),
            Error::FontCharNotMapped { ch, font_name } => {
                write!(
                    f,
                    "char '{}' not found in font '{}' ToUnicode mapping; font may be subsetted",
                    ch, font_name
                )
            }
            Error::WrongPassword => write!(f, "wrong password for encrypted PDF"),
            #[cfg(feature = "digital-signature")]
            Error::InvalidCertificate(msg) => write!(f, "invalid certificate: {}", msg),
            #[cfg(not(feature = "digital-signature"))]
            Error::_InvalidCertificate => unreachable!(),
            #[cfg(feature = "digital-signature")]
            Error::InvalidPrivateKey(msg) => write!(f, "invalid private key: {}", msg),
            #[cfg(not(feature = "digital-signature"))]
            Error::_InvalidPrivateKey => unreachable!(),
            #[cfg(feature = "digital-signature")]
            Error::Pkcs12Parse(msg) => write!(f, "PKCS#12 parse error: {}", msg),
            #[cfg(not(feature = "digital-signature"))]
            Error::_Pkcs12Parse => unreachable!(),
            #[cfg(feature = "digital-signature")]
            Error::SignatureFailed(msg) => write!(f, "signature failed: {}", msg),
            #[cfg(not(feature = "digital-signature"))]
            Error::_SignatureFailed => unreachable!(),
        }
    }
}

impl std::error::Error for Error {}

impl From<std::io::Error> for Error {
    fn from(e: std::io::Error) -> Self {
        Error::Io(e)
    }
}

impl From<lopdf::Error> for Error {
    fn from(e: lopdf::Error) -> Self {
        Error::Pdf(e)
    }
}

/// Alias for `std::result::Result<T, harumi::Error>`.
pub type Result<T> = std::result::Result<T, Error>;