🥮 mooncakes.io
    Sign in

    This version of the module is deprecated: Use moonbitlang/pdflite instead

    pdflite

    Download zip
    Author
    Version
    0.1.5
    License
    Apache-2.0
    Repository
    Last updated
    5 months ago
    Downloads
    8K

    #pdflite

    bobzhang/pdflite is a byte-oriented PDF toolkit for MoonBit. The root package exposes the public document model, object parser/writer, page tree helpers, content operators, text extraction, filters, images, fonts, encryption, and high-level read/write entry points.

    flowchart LR
  Bytes[PDF bytes] --> Reader[pdf_read_document_from_bytes]
  Reader --> Document[PdfDocument]
  Document --> Pages[page tree and resources]
  Document --> Objects[object table]
  Pages --> Content[content operators]
  Objects --> Writer[pdf_write_document]
  Content --> Writer
  Writer --> BytesOut[PDF bytes]

    Use this package when callers need a complete in-memory PDF document. Use the subpackages for narrower concerns such as byte primitives, transforms, Flate, dates, low-level cryptography, async file IO, or Markdown extraction.

    #What This Package Owns

    • The public PdfDocument representation and its object table.
    • PDF syntax objects such as arrays, dictionaries, streams, names, strings, numbers, booleans, nulls, and indirect references.
    • Readers for headers, trailers, classic xref tables, xref streams, object streams, damaged-startxref reconstruction, revisions, and encrypted inputs.
    • Writers for classic xref tables, xref streams, compressed xref streams, generated trailer IDs, incremental updates, and encrypted outputs.
    • Page-tree construction, page queries, resource renumbering, merge/extract helpers, bookmarks, destinations, annotations, optional content groups, and content stream operators.
    • Text/font/image helpers that need the full document graph.

    #Pedantic Boundaries

    • PDF byte data stays byte-oriented. PdfBytes is Bytes; PdfName and PdfString store raw bytes until an explicit text-decoding API is used.
    • Object numbers are one-based in normal document allocation. Missing or deferred objects are represented explicitly instead of being guessed.
    • Public parsing and writing APIs raise PdfError for typed failure classes. Tests should assert concrete errors where the input class is stable.
    • Methods that mutate a document mutate the in-memory object table directly. Functional wrapper APIs, when present, copy before mutation.
    • Encryption APIs distinguish authentication, object crypt filters, saved encryption state, denied permissions, and recryption paths.

    #Checked Examples

    Create a minimum valid document, serialize it, and read it back:

    ///|
    test "minimum document round trip" {
      let document = try! pdf_minimum_valid_pdf()
      let bytes = try! pdf_write_document(document)
      let version = try! pdf_read_header_from_bytes(bytes)
      if version.major != 1 || version.minor != 0 {
        fail("expected a PDF 1.0 header")
      }
      let parsed = try! pdf_read_document_from_bytes(bytes)
      inspect(try! parsed.endpage(), content="1")
    }

    Write byte-preserving PDF names. Names are bytes, not MoonBit Unicode strings:

    ///|
    test "name writer escapes delimiter bytes" {
      let name = pdf_name_of_bytes(try! pdf_bytes_of_int_array([47, 65, 32, 66]))
      @test.assert_eq(pdf_int_array_of_bytes(pdf_write_name(name)), [
        47, 65, 35, 50, 48, 66,
      ])
    }

    #Package Notes

    • PdfDocument owns the object table, root catalog pointer, trailer dictionary, encryption state, and revision metadata.
    • PdfObject values preserve PDF syntax-level objects, including byte strings, names, dictionaries, streams, and indirect references.
    • Read APIs raise PdfError for malformed input rather than silently repairing data. Reconstruction helpers are explicit APIs.
    • Writer APIs can emit classic xref tables, xref streams, compressed xref streams, generated trailer IDs, incremental updates, and encrypted output.

    #Verification Notes

    • README.mbt.md blocks are blackbox tests for the root package.
    • Most root tests should run on all MoonBit targets. Native-only random or file behavior belongs in targeted test files or the async_io package.
    • For public API changes, run moon info and review pkg.generated.mbti.
    • For behavior changes, run moon test; for native reader/writer coverage, also run native-target tests.

    PaperSize

    source

    A paper size expressed in a declared unit.

    Width and height are stored as given; conversion to PDF points happens at page-construction boundaries.

    PdfAesV3RandomField

    source

    Random material requested while constructing PDF 2.0 AESV3 encryption data.

    Provider callbacks receive this field tag and a byte length, allowing tests and reproducible builds to supply deterministic file keys, salts, and permissions padding.

    PdfBytes

    source
    type PdfBytes = Bytes

    PDF byte strings and byte streams.

    This is an alias for MoonBit Bytes because PDF strings and streams are byte sequences, not Unicode text. Use String only after an explicit PDF text decoding step.

    PdfCryptType

    source

    Object encryption algorithm used by the PDF security handlers.

    ARC4 carries key length in bits and security-handler revision. AESV3 carries whether the ISO/PDF 2.0 hash variant is in use.

    PdfDate

    source

    A PDF date with local time-zone offset components.

    The fields mirror PDF's D:YYYYMMDDHHmmSSOHH'mm' representation. Month and day default to 1 when omitted during parsing; time fields default to zero.

    PdfEncryptionMethod

    source

    Encryption method detected from or requested for a document.

    AES entries carry the effective EncryptMetadata flag. The PdfEncryptionAlreadyEncrypted value is used by writer paths that preserve existing encrypted object data rather than decrypting and re-encrypting it.

    PdfError

    source

    Error variants raised by pdflite parsing, writing, filtering, text, and encryption APIs.

    The variants intentionally stay specific enough for tests and callers to distinguish malformed input classes, while most public APIs expose them through the ordinary raise PdfError flow.

    PdfName

    source

    A PDF name token stored as its raw bytes without the leading slash.

    Names are byte-oriented in the PDF file format. Keeping the original bytes avoids accidental UTF-16 or UTF-8 interpretation while still allowing explicit views and owned-byte access.

    PdfPermission

    source

    Permission that may be denied by a PDF standard security handler.

    These values are expressed as a "ban list" in the public API: passing PdfNoPrint means printing is denied. They are converted to and from the PDF /P permission bit mask by pdf_p_of_permissions and pdf_permissions_of_p.

    PdfUnit

    source

    Units accepted by page and geometry helpers.

    PDF coordinates are ultimately expressed in points, but the public API keeps common paper and layout units explicit at call sites.

    Point2

    source

    A two-dimensional point in PDF user-space coordinates.

    TransformDecomposition

    source

    The decomposed components of an affine transform matrix.

    Values are expressed as scale, aspect ratio, rotation, shear, and translation components suitable for recomposition.

    TransformMatrix

    source

    A PDF affine transform matrix.

    The fields correspond to PDF's six-operand matrix [a b c d e f], where a point is transformed as x' = a*x + c*y + e and y' = b*x + d*y + f.

    TransformOp

    source

    A high-level affine transform operation.

    Operation lists preserve CamlPDF's transform model; they can be rendered for diagnostics or lowered to TransformMatrix for application to points.

    BitStream

    source
    pub struct BitStream {
      input : ByteCursor
      current_byte : Int
      bit_mask : Int
      bits_read : Int
    } derive(Eq, ToJson, 
    Debug    )

    A big-endian bit reader over a ByteCursor.

    The stream reads the most-significant bit of each byte first, matching the bit order used by PDF filters such as CCITT and Flate Huffman tables. align discards any unread bits in the current byte and resumes at the next byte boundary.

    BitStream::align

    source
    fn BitStream::align(self : BitStream) -> Unit

    Discards unread bits in the current byte and moves to the next byte boundary.

    BitStream::bits_read

    source
    fn BitStream::bits_read(self : BitStream) -> Int

    Returns the number of bits consumed from this stream.

    The count includes bits skipped by align.

    BitStream::get_bit

    source

    Reads one bit and returns it as a boolean.

    The return value is true for bit 1 and false for bit 0. Raises PdfError::EndOfInput if there is no byte available for the next bit.

    BitStream::get_bit_int

    source
    fn BitStream::get_bit_int(self : BitStream) -> Int raise 
    PdfError

    Reads one bit and returns it as integer 0 or 1.

    Raises PdfError::EndOfInput if there is no byte available for the next bit.

    BitStream::get_value_int

    source
    fn BitStream::get_value_int(self : BitStream, width : Int) -> Int raise 
    PdfError

    Reads up to 31 bits as a big-endian signed Int payload.

    This function only assembles the bit pattern; it does not sign-extend the result. Raises PdfError::InvalidBitCount for widths outside 0..=31 and PdfError::EndOfInput if the stream ends early.

    BitStream::get_value_int64

    source
    fn BitStream::get_value_int64(self : BitStream, width : Int) -> Int64 raise 
    PdfError

    Reads up to 32 bits as a big-endian Int64 payload.

    This is useful for PDF filter fields whose packed value may not fit the positive range of Int. Raises PdfError::InvalidBitCount for widths outside 0..=32 and PdfError::EndOfInput if the stream ends early.

    BitStream::position

    source
    fn BitStream::position(self : BitStream) -> BitStreamPosition

    Returns a restorable snapshot of the current bit position.

    BitStream::seek

    source
    fn BitStream::seek(self : BitStream, position : BitStreamPosition) -> Unit

    Restores this bit stream to a previously captured position.

    Raises PdfError::InvalidCursorPosition if the saved byte position is not valid for the underlying cursor.

    BitStreamPosition

    source
    pub struct BitStreamPosition {
      input_position : Int
      current_byte : Int
      bit_mask : Int
      bits_read : Int
    } derive(Eq, ToJson, 
    Debug    )

    A restorable snapshot of a BitStream position.

    The snapshot captures both the underlying byte cursor position and the partially consumed current byte, so seeking back to it is safe even in the middle of a byte.

    BitWriter

    source
    pub struct BitWriter {
      current_byte : Int
      bit_index : Int
      bytes : Array[Byte]
    } derive(Eq, ToJson, 
    Debug    )

    A big-endian bit writer that accumulates PDF bytes.

    Bits are packed most-significant first in each output byte. The final byte is zero-padded when align or to_bytes flushes a partially filled byte.

    BitWriter::align

    source
    fn BitWriter::align(self : BitWriter) -> Unit

    Flushes any partial output byte, padding its unread low bits with zero.

    BitWriter::append_aligned

    source
    fn BitWriter::append_aligned(self : BitWriter, other : BitWriter) -> BitWriter

    Appends another writer's bits after aligning this writer to a byte boundary.

    The returned writer is a copy; neither input writer is mutated.

    BitWriter::bit_length

    source
    fn BitWriter::bit_length(self : BitWriter) -> Int

    Returns the number of bits currently written, including an unflushed partial byte.

    BitWriter::put_bit

    source
    fn BitWriter::put_bit(self : BitWriter, bit : Int) -> Unit raise 
    PdfError

    Writes one bit, accepting only integer values 0 and 1.

    Raises PdfError::InvalidBit for any other value.

    BitWriter::put_value_int

    source
    fn BitWriter::put_value_int(self : BitWriter, width : Int, value : Int) -> Unit raise 
    PdfError

    Writes the low width bits of an Int in big-endian bit order.

    Raises PdfError::InvalidBitCount for widths outside 0..=31.

    BitWriter::put_value_int64

    source
    fn BitWriter::put_value_int64(self : BitWriter, width : Int, value : Int64) -> Unit raise 
    PdfError

    Writes the low width bits of an Int64 in big-endian bit order.

    Raises PdfError::InvalidBitCount for widths outside 0..=32.

    BitWriter::to_bytes

    source
    fn BitWriter::to_bytes(self : BitWriter) -> Bytes

    Returns the accumulated bytes, flushing a partial final byte if needed.

    ByteCursor

    source
    pub struct ByteCursor {
      data : BytesView
      position : Int
      offset : Int
      source : String
    } derive(Eq, ToJson, 
    Debug    )

    A mutable read cursor over a PDF byte view.

    ByteCursor keeps a source label for diagnostics and supports an optional logical offset. After set_offset, public positions are relative to that offset while absolute positions still refer to the underlying byte view.

    ByteCursor::absolute_position

    source
    fn ByteCursor::absolute_position(self : ByteCursor) -> Int

    Returns the current absolute position in the underlying byte view.

    ByteCursor::drop_pdf_whitespace

    source
    fn ByteCursor::drop_pdf_whitespace(self : ByteCursor) -> Unit

    Advance the cursor past PDF white space.

    The first non-whitespace byte, delimiter, or end of input is left unread.

    ByteCursor::ignore_until

    source
    fn ByteCursor::ignore_until(self : ByteCursor, stop : (Int) -> Bool, eof_is_delimiter? : Bool) -> Unit raise 
    PdfError

    Advances until stop matches the next byte.

    The delimiter byte is left unread. EOF handling follows read_until_view.

    ByteCursor::input_byte

    source
    fn ByteCursor::input_byte(self : ByteCursor) -> Int

    Reads one byte as an integer and advances the cursor.

    Returns pdf_no_more when reading past the end. This method always advances by one position, matching the historical parser cursor behavior.

    ByteCursor::input_pdf_error

    source
    fn ByteCursor::input_pdf_error(self : ByteCursor, message : String) -> String

    Formats an input error message with the source label and current logical position.

    ByteCursor::length

    source
    fn ByteCursor::length(self : ByteCursor) -> Int

    Returns the total length of the underlying byte view.

    ByteCursor::lex_pdf_bool

    source
    fn ByteCursor::lex_pdf_bool(self : ByteCursor) -> PdfLexeme

    Lex true or false at the current cursor position.

    The cursor first reads one regular token. Non-boolean tokens produce LexNone.

    ByteCursor::lex_pdf_comment

    source
    fn ByteCursor::lex_pdf_comment(self : ByteCursor) -> PdfLexeme

    Lex and skip a PDF comment.

    A comment starts with % and runs up to but not including the next newline. The comment text is intentionally not retained; this returns an empty LexComment payload. Non-comment input returns LexNone.

    ByteCursor::lex_pdf_delimiter

    source
    fn ByteCursor::lex_pdf_delimiter(self : ByteCursor) -> PdfLexeme

    Lex one PDF delimiter token.

    Recognizes [, ], <<, and >>. A single < or > is left unread and returns LexNone.

    ByteCursor::lex_pdf_hex_string

    source

    Lex a PDF hexadecimal string.

    The opening < must not be a dictionary delimiter <<. White space inside the hex string is ignored, odd trailing nibbles are padded in the PDF way, and invalid hex digits raise PdfError::InvalidHexEscape.

    ByteCursor::lex_pdf_keyword

    source

    Lex PDF structural keywords.

    Recognized keywords include obj, endobj, R, null, and endstream. If a token begins with endobj followed by extra bytes, only endobj is consumed so the suffix can be lexed by later calls.

    ByteCursor::lex_pdf_literal_string

    source
    fn ByteCursor::lex_pdf_literal_string(self : ByteCursor) -> PdfLexeme raise 
    PdfError

    Lex a PDF literal string.

    Literal strings are enclosed in parentheses, may contain balanced nested parentheses, and support the PDF backslash escapes for control characters, octal bytes, escaped parentheses, and line continuation. Unterminated strings raise PdfError::EndOfInput.

    ByteCursor::lex_pdf_name

    source

    Lex a PDF name object.

    Names start with / and keep the slash in the stored bytes. #xx hex escapes are decoded into raw bytes. Invalid escapes raise PdfError::InvalidHexEscape; non-name input returns LexNone without consuming it.

    ByteCursor::lex_pdf_number

    source
    fn ByteCursor::lex_pdf_number(self : ByteCursor) -> PdfLexeme

    Lex a PDF integer or real number.

    Integers are limited to MoonBit Int range; oversized integer-looking tokens fall back to real-number parsing. A leading doubled minus is accepted compatibly by dropping one minus sign.

    ByteCursor::lex_pdf_token

    source

    Lex one token from the current cursor position.

    This dispatcher skips white space, recognizes comments, primitives, delimiters, names, literal and hex strings, and selected keywords. It returns StopLexing at end of input and at markers that terminate object scanning, such as startxref or inline image data boundaries.

    ByteCursor::lex_pdf_tokens

    source

    Lex tokens until a stop marker or unmatched input is reached.

    StopLexing and LexNone terminate scanning and are not included in the returned token array.

    ByteCursor::nudge

    source
    fn ByteCursor::nudge(self : ByteCursor) -> Unit

    Advances the cursor by one byte, ignoring the value read.

    ByteCursor::peek

    source
    fn ByteCursor::peek(self : ByteCursor) -> Byte?

    Returns the next byte without consuming it, or None at end of input.

    ByteCursor::peek_byte

    source
    fn ByteCursor::peek_byte(self : ByteCursor) -> Int

    Returns the next byte as an integer without consuming it.

    Returns pdf_no_more at end of input.

    ByteCursor::peek_bytes

    source
    fn ByteCursor::peek_bytes(self : ByteCursor, length : Int) -> Bytes raise 
    PdfError

    Copies the next length bytes without advancing.

    Raises the same errors as peek_view.

    ByteCursor::peek_view

    source
    fn ByteCursor::peek_view(self : ByteCursor, length : Int) -> BytesView raise 
    PdfError

    Returns a read-only view of the next length bytes without advancing.

    Raises PdfError::InvalidReadLength for negative lengths and PdfError::EndOfInput if the requested range extends past the input.

    ByteCursor::position

    source
    fn ByteCursor::position(self : ByteCursor) -> Int

    Returns the current logical position, relative to the configured offset.

    ByteCursor::read_byte

    source
    fn ByteCursor::read_byte(self : ByteCursor) -> Byte?

    Reads one byte and advances the cursor, returning None at end of input.

    ByteCursor::read_byte_back

    source
    fn ByteCursor::read_byte_back(self : ByteCursor) -> Byte?

    Reads the previous byte and moves the cursor backward.

    Returns None when the cursor is at the logical start or when the resulting position is outside the underlying view.

    ByteCursor::read_bytes

    source
    fn ByteCursor::read_bytes(self : ByteCursor, length : Int) -> Bytes raise 
    PdfError

    Reads length bytes into owned PDF bytes and advances past them.

    Raises the same errors as read_view.

    ByteCursor::read_bytes_at

    source
    fn ByteCursor::read_bytes_at(self : ByteCursor, position : Int, length : Int) -> Bytes raise 
    PdfError

    Seeks to position, reads length bytes into owned PDF bytes, and advances past them.

    ByteCursor::read_jpeg_data

    source
    fn ByteCursor::read_jpeg_data(self : ByteCursor) -> Bytes raise 
    PdfError

    Reads JPEG data from the current cursor position through the EOI marker.

    The returned bytes include the terminal 0xFF 0xD9 marker. Raises PdfError::EndOfInput if the marker is not found before EOF.

    ByteCursor::read_line

    source

    Reads one line into owned PDF bytes.

    Raises PdfError::EndOfInput if called at EOF.

    ByteCursor::read_line_view

    source
    fn ByteCursor::read_line_view(self : ByteCursor) -> BytesView raise 
    PdfError

    Reads one line as a view, including the line-ending bytes when present.

    Both LF and CRLF are recognized. Raises PdfError::EndOfInput if called at EOF.

    ByteCursor::read_line_views

    source
    fn ByteCursor::read_line_views(self : ByteCursor) -> Array[BytesView]

    Reads all remaining lines as borrowed views.

    Each line view includes the line-ending bytes when they were present in the input.

    ByteCursor::read_lines

    source
    fn ByteCursor::read_lines(self : ByteCursor) -> Array[Bytes]

    Reads all remaining lines as owned PDF bytes.

    ByteCursor::read_pdf_header

    source

    Read the PDF header from the current cursor buffer.

    The reader probes the first 1024 bytes for %PDF-x.y. When found, the cursor offset is set to the header position and the cursor advances past the header. If no header is found, pdf_default_version is returned.

    ByteCursor::read_pdf_regular_token_view

    source
    fn ByteCursor::read_pdf_regular_token_view(self : ByteCursor) -> BytesView

    Skip PDF white space and read a regular token as a borrowed byte view.

    ByteCursor::read_remaining_bytes

    source
    fn ByteCursor::read_remaining_bytes(self : ByteCursor) -> Bytes

    Reads all remaining bytes into owned PDF bytes and advances to EOF.

    ByteCursor::read_until_pdf_whitespace_or_delimiter

    source
    fn ByteCursor::read_until_pdf_whitespace_or_delimiter(self : ByteCursor) -> BytesView

    Read a borrowed view up to PDF white space or a delimiter.

    The terminating byte is left unread so higher-level lexers can dispatch on delimiters after reading a regular token.

    ByteCursor::read_until_view

    source
    fn ByteCursor::read_until_view(self : ByteCursor, stop : (Int) -> Bool, eof_is_delimiter? : Bool) -> BytesView raise 
    PdfError

    Reads until stop matches the next byte and returns the bytes before it.

    The delimiter byte is not consumed. If EOF is reached and eof_is_delimiter is true, the remaining bytes are returned; otherwise PdfError::EndOfInput is raised.

    ByteCursor::read_view

    source
    fn ByteCursor::read_view(self : ByteCursor, length : Int) -> BytesView raise 
    PdfError

    Reads length bytes as a view and advances past them.

    Raises PdfError::InvalidReadLength for negative lengths and PdfError::EndOfInput if the requested range extends past the input.

    ByteCursor::read_view_at

    source
    fn ByteCursor::read_view_at(self : ByteCursor, position : Int, length : Int) -> BytesView raise 
    PdfError

    Seeks to position, then reads length bytes as a view.

    The returned view borrows the cursor input; use read_bytes_at when owned bytes are required.

    ByteCursor::remaining_length

    source
    fn ByteCursor::remaining_length(self : ByteCursor) -> Int

    Returns the number of unread bytes remaining from the absolute cursor position.

    ByteCursor::remaining_view

    source
    fn ByteCursor::remaining_view(self : ByteCursor) -> BytesView

    Returns a view of all bytes from the current position to the end of input.

    ByteCursor::rewind

    source

    Moves the cursor one byte backward.

    Raises PdfError::InvalidCursorPosition if the cursor is already at the logical start position.

    ByteCursor::seek

    source
    fn ByteCursor::seek(self : ByteCursor, position : Int) -> Unit raise 
    PdfError

    Moves the cursor to a logical position.

    The supplied position is interpreted relative to the configured offset. Seeking past the end is allowed so callers can probe EOF behavior; negative absolute positions raise PdfError::InvalidCursorPosition.

    ByteCursor::set_offset

    source
    fn ByteCursor::set_offset(self : ByteCursor, offset : Int) -> Unit raise 
    PdfError

    Sets the logical position offset used by position and seek.

    The offset can only be set once and must be non-negative. This is used when parsing substreams whose local position should start at zero while retaining absolute positions for diagnostics.

    ByteCursor::source

    source
    fn ByteCursor::source(self : ByteCursor) -> String

    Returns the diagnostic source label associated with this cursor.

    ByteCursor::to_bytes

    source
    fn ByteCursor::to_bytes(self : ByteCursor) -> Bytes

    Copies the underlying byte view into owned PDF bytes.

    ByteCursor::view

    source
    fn ByteCursor::view(self : ByteCursor) -> BytesView

    Returns the underlying read-only byte view without copying.

    ByteOutput

    source
    pub struct ByteOutput {
      data : Array[Byte]
      position : Int
      written_length : Int
    } derive(Eq, ToJson, 
    Debug    )

    A growable byte sink with seekable overwrite support.

    ByteOutput tracks the current write position separately from the highest position written, so callers may seek backward to patch bytes and then obtain only the initialized prefix with to_bytes.

    ByteOutput::length

    source
    fn ByteOutput::length(self : ByteOutput) -> Int

    Returns the highest written byte position.

    This is the length of the byte sequence returned by to_bytes.

    ByteOutput::position

    source
    fn ByteOutput::position(self : ByteOutput) -> Int

    Returns the current write position.

    ByteOutput::seek

    source
    fn ByteOutput::seek(self : ByteOutput, position : Int) -> Unit raise 
    PdfError

    Moves the write position.

    Seeking beyond the current length is allowed; unwritten gaps are filled with zero when data is later written. Negative positions raise PdfError::InvalidCursorPosition.

    ByteOutput::to_bytes

    source
    fn ByteOutput::to_bytes(self : ByteOutput) -> Bytes

    Returns the written prefix as owned PDF bytes.

    Bytes beyond length that were only preallocated are not included.

    ByteOutput::write_ascii

    source
    fn ByteOutput::write_ascii(self : ByteOutput, text : String) -> Unit raise 
    PdfError

    Encodes an ASCII string and writes the resulting bytes.

    The underlying @ascii.encode function is used intentionally; callers should pass bytes directly for non-ASCII PDF payloads.

    ByteOutput::write_byte

    source
    fn ByteOutput::write_byte(self : ByteOutput, value : Int) -> Unit raise 
    PdfError

    Writes one byte at the current position and advances by one.

    Raises PdfError::InvalidByte if value is outside the byte range 0..=255.

    ByteOutput::write_byte_at

    source
    fn ByteOutput::write_byte_at(self : ByteOutput, position : Int, value : Int) -> Unit raise 
    PdfError

    Seeks to position, writes one byte, and advances by one.

    Raises the same errors as seek and write_byte.

    ByteOutput::write_repeated_byte

    source
    fn ByteOutput::write_repeated_byte(self : ByteOutput, length : Int, value? : Int) -> Unit raise 
    PdfError

    Writes length copies of value and advances past them.

    The default value is zero. Raises PdfError::InvalidReadLength for invalid lengths and PdfError::InvalidByte for values outside 0..=255.

    ByteOutput::write_view

    source
    fn ByteOutput::write_view(self : ByteOutput, bytes : BytesView) -> Unit raise 
    PdfError

    Writes a byte view at the current position and advances past it.

    Raises PdfError::InvalidReadLength if the computed end position overflows.

    ByteOutput::write_view_at

    source
    fn ByteOutput::write_view_at(self : ByteOutput, position : Int, bytes : BytesView) -> Unit raise 
    PdfError

    Seeks to position, writes a byte view, and advances past it.

    Raises the same errors as seek and write_view.

    ByteOutput::write_view_slice

    source
    fn ByteOutput::write_view_slice(self : ByteOutput, bytes : BytesView, offset : Int, length : Int) -> Unit raise 
    PdfError

    Writes a slice of a byte view at the current position.

    Raises PdfError::InvalidCursorPosition for a negative offset, PdfError::InvalidReadLength for a negative or overflowing length, and PdfError::EndOfInput if the requested slice exceeds the input view.

    ObjectStreamReference

    source
    pub(all) struct ObjectStreamReference {
      object_stream_number : Int
      index : Int
    } derive(Eq, ToJson, 
    Debug    )

    Location of an object stored inside a PDF object stream.

    object_stream_number is the containing object stream number, and index is the zero-based entry index inside that stream.

    PdfAddTextFontSource

    source
    pub(all) enum PdfAddTextFontSource {
      PdfAddTextPreMadeFontPack(PdfFontPack)
      PdfAddTextExistingNamedFont
    } derive(Eq, ToJson, 
    Debug    )

    Font source options for cpdf add-text.

    This ports the source-level non-embedding Cpdfembed.cpdffont variants. TrueType EmbedInfo remains a separate embedding slice.

    PdfAddTextJustification

    source
    pub(all) enum PdfAddTextJustification {
      PdfAddTextLeftJustify
      PdfAddTextCentreJustify
      PdfAddTextRightJustify
    } derive(Eq, ToJson, 
    Debug    )

    Text justification values used by cpdf's add-text positioning helpers.

    PdfAddTextLinePlacement

    source
    pub(all) struct PdfAddTextLinePlacement {
      origin : 
    Point2
      base_rotation : Double
      text_rotation : Double
      rotation_offset : 
    Point2
      horizontal_offset : Double
      vertical_offset : Double
      justification_offset : Double
    } derive(Eq, ToJson, 
    Debug    )

    Resolved placement values for one cpdf add-text line.

    PdfAddTextLineWidths

    source
    pub(all) struct PdfAddTextLineWidths {
      text_width : Double
      widths : Array[Double]
      longest_width : Double
    } derive(Eq, ToJson, 
    Debug    )

    Width measurements for one cpdf add-text line and its expanded paragraph.

    PdfAddTextPreparedLine

    source
    pub(all) struct PdfAddTextPreparedLine {
      text : String
      text_bytes : Bytes
      urls : Array[PdfAddTextUrl]
      expanded_lines : Array[String]
      expanded_line_bytes : Array[Bytes]
      widths : PdfAddTextLineWidths
      placement : PdfAddTextLinePlacement
    } derive(Eq, ToJson, 
    Debug    )

    One cpdf add-text line after replacement expansion, URL stripping, width measurement, and placement resolution.

    PdfAddTextReplacementValues

    source
    pub(all) struct PdfAddTextReplacementValues {
      page_number : Int
      end_page : Int
      filename : String
      page_label : String
      end_label : String
      bates : Int
      bates_pad : Int?
      bookmarks : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    Values used to build cpdf add-text replacement callbacks.

    PdfAddTextResourceSetup

    source
    pub(all) struct PdfAddTextResourceSetup {
      resources : PdfObject
      font_dictionary : PdfObject
      unique_fontname : 
    PdfName
      unique_fontnames : Array[
    PdfName    ]
      extgstate_name : 
    PdfName    ?
    } derive(Eq, ToJson, 
    Debug    )

    Page resources prepared for one cpdf add-text line.

    PdfAddTextRotation

    source
    pub(all) enum PdfAddTextRotation {
      PdfAddTextRot0
      PdfAddTextRot90
      PdfAddTextRot180
      PdfAddTextRot270
    } derive(Eq, ToJson, 
    Debug    )

    Text rotation values used by cpdf's add-text positioning helpers.

    PdfAddTextUrl

    source
    pub(all) struct PdfAddTextUrl {
      url : String
      start : Int
      end : Int
    } derive(Eq, ToJson, 
    Debug    )

    A URL span parsed from cpdf add-text %URL[text|url] markup.

    start and end are byte offsets in the visible output line, matching OCaml cpdf's String.length accounting.

    PdfAddTextUrlAnnotationGeometry

    source

    Transformed geometry for one add-text URL annotation.

    PdfAddTextUrlLine

    source
    pub(all) struct PdfAddTextUrlLine {
      text : String
      urls : Array[PdfAddTextUrl]
    } derive(Eq, ToJson, 
    Debug    )

    One add-text line after stripping %URL[text|url] markup.

    PdfAfmData

    source
    pub(all) struct PdfAfmData {
      headers : Array[(Bytes, Bytes)]
      char_metrics : Array[(Int, Int)]
      kerns : Array[(Int, Int, Int)]
      char_name_widths : Array[(Bytes, Int)]
    } derive(Eq, ToJson, 
    Debug    )

    Parsed Adobe Font Metrics data used by standard-font helpers.

    Headers preserve raw key/value bytes. Character metrics store character codes and widths, kerns store pair adjustments, and char_name_widths preserves name-based widths for encodings that refer to glyph names.

    PdfAnnotation

    source
    pub(all) struct PdfAnnotation {
      subtype : PdfAnnotationSubtype
      contents : Bytes?
      subject : Bytes?
      rectangle : PdfRectangle
      border : PdfAnnotationBorder
      colour : PdfAnnotationColour?
      rest : PdfObject
    } derive(Eq, ToJson, 
    Debug    )

    Parsed PDF annotation dictionary.

    contents and subject are raw PDF string bytes. rectangle is required when reading from a PDF. rest preserves dictionary entries not modeled by the typed fields so they can be written back.

    PdfAnnotationBorder

    source
    pub(all) struct PdfAnnotationBorder {
      width : Double
      vertical_radius : Double
      horizontal_radius : Double
      style : PdfAnnotationStyle
      dash_array : Array[Int]
    } derive(Eq, ToJson, 
    Debug    )

    Parsed annotation border information.

    vertical_radius and horizontal_radius come from the legacy /Border array form. style and dash_array represent /BS dictionary entries when present.

    PdfAnnotationColour

    source
    pub(all) struct PdfAnnotationColour {
      red : Int
      green : Int
      blue : Int
    } derive(Eq, ToJson, 
    Debug    )

    RGB annotation colour from the /C entry.

    Components are stored as integer channel values after parsing PDF numbers.

    PdfAnnotationStyle

    source
    pub(all) enum PdfAnnotationStyle {
      AnnotationNoStyle
      AnnotationSolid
      AnnotationDashed
      AnnotationBeveled
      AnnotationInset
      AnnotationUnderlineStyle
    } derive(Eq, ToJson, 
    Debug    )

    Border style used by an annotation border dictionary.

    PdfAnnotationSubtype

    source
    pub(all) enum PdfAnnotationSubtype {
      AnnotationText
      AnnotationLink
      AnnotationFreeText
      AnnotationLine
      AnnotationSquare
      AnnotationCircle
      AnnotationPolygon
      AnnotationPolyLine
      AnnotationHighlight
      AnnotationUnderline
      AnnotationSquiggly
      AnnotationStrikeOut
      AnnotationStamp
      AnnotationCaret
      AnnotationInk
      AnnotationPopup(PdfAnnotation)
      AnnotationFileAttachment
      AnnotationSound
      AnnotationMovie
      AnnotationWidget
      AnnotationScreen
      AnnotationPrinterMark
      AnnotationTrapNet
      AnnotationWatermark
      AnnotationThreeDee
      AnnotationUnknown(
    PdfName    )
    } derive(Eq, ToJson, 
    Debug    )

    Supported annotation subtype.

    Popup annotations embed their resolved parent annotation when available. Unknown subtype names are preserved as AnnotationUnknown.

    PdfAttachment

    source
    pub(all) struct PdfAttachment {
      name : String
      pagenumber : Int
      data : Bytes?
      description : String?
      relationship : String?
    } derive(Eq, ToJson, 
    Debug    )

    One embedded file attachment.

    pagenumber == 0 represents a document-level attachment. Page attachments use one-based page numbers. data == None represents a malformed page-level attachment annotation with a file specification but no embedded-file stream.

    PdfBookmark

    source
    pub(all) struct PdfBookmark {
      level : Int
      text : Bytes
      target : PdfDestination
      is_open : Bool
      colour : PdfBookmarkColour
      flags : Int
    } derive(Eq, ToJson, 
    Debug    )

    One bookmark in the flattened outline representation.

    Bookmarks are ordered in preorder. level is zero-based nesting depth, text is the raw PDF title string bytes, and target is the parsed destination or preserved action.

    PdfBookmarkColour

    source
    pub(all) struct PdfBookmarkColour {
      red : Double
      green : Double
      blue : Double
    } derive(Eq, ToJson, 
    Debug    )

    Bookmark display colour from the PDF outline /C entry.

    PDF stores these as RGB real numbers, normally in the range 0.0 to 1.0.

    PdfBookmarkNode

    source
    type PdfBookmarkNode derive(Eq, ToJson, 
    Debug    )

    PdfCIDKeyedFont

    source
    pub(all) struct PdfCIDKeyedFont {
      basefont : 
    PdfName
      composite : PdfCompositeCIDFont
      encoding : PdfCMapEncoding
    } derive(Eq, ToJson, 
    Debug    )

    Parsed Type 0 font with descendant CIDFont and CMap encoding.

    PdfCIDKeyedFont::debug_name

    source
    fn PdfCIDKeyedFont::debug_name(self : PdfCIDKeyedFont) -> String

    Return a compact debug label containing the Type 0 base font name.

    PdfCIDKeyedFont::is_identity_h

    source
    fn PdfCIDKeyedFont::is_identity_h(self : PdfCIDKeyedFont) -> Bool

    Test whether this Type 0 font uses /Identity-H.

    PdfCIDKeyedFont::is_identity_v

    source
    fn PdfCIDKeyedFont::is_identity_v(self : PdfCIDKeyedFont) -> Bool

    Test whether this Type 0 font uses /Identity-V.

    PdfCIDKeyedFont::uses_two_byte_codes

    source
    fn PdfCIDKeyedFont::uses_two_byte_codes(self : PdfCIDKeyedFont) -> Bool

    Return true when this Type 0 font uses fixed two-byte character codes.

    PdfCIDSystemInfo

    source
    pub(all) struct PdfCIDSystemInfo {
      registry : Bytes
      ordering : Bytes
      supplement : Int
    } derive(Eq, ToJson, 
    Debug    )

    CID-system identity from a CIDFont or CMap dictionary.

    registry and ordering are stored as PDF bytes because PDF strings are byte sequences, not MoonBit String values.

    PdfCIDVerticalWidth

    source
    pub(all) struct PdfCIDVerticalWidth {
      width : Double
      vx : Double
      vy : Double
    } derive(Eq, ToJson, 
    Debug    )

    Vertical metrics for a CID in a composite font.

    The fields correspond to the PDF /W2 tuple: vertical width and horizontal displacement vector components.

    PdfCMapCodeSpace

    source
    pub(all) struct PdfCMapCodeSpace {
      length : Int
      first : Int
      last : Int
    } derive(Eq, ToJson, 
    Debug    )

    One parsed CMap code-space range.

    length is the character-code byte length, and first/last are the inclusive packed-byte bounds accepted by that range.

    PdfCMapEncoding

    source
    pub(all) enum PdfCMapEncoding {
      PdfPredefinedCMap(
    PdfName    )
      PdfCMap(Int)
      PdfExternalCMap(Int, PdfParsedCMap)
    } derive(Eq, ToJson, 
    Debug    )

    CMap source used by a Type 0 font.

    A CMap may be predefined by name, referenced as an external stream object, or parsed from that external stream together with its mapping tables.

    PdfCMapEncoding::is_identity_h

    source
    fn PdfCMapEncoding::is_identity_h(self : PdfCMapEncoding) -> Bool

    Test whether this CMap encoding is the predefined /Identity-H map.

    PdfCMapEncoding::is_identity_v

    source
    fn PdfCMapEncoding::is_identity_v(self : PdfCMapEncoding) -> Bool

    Test whether this CMap encoding is the predefined /Identity-V map.

    PdfCMapEncoding::uses_two_byte_codes

    source
    fn PdfCMapEncoding::uses_two_byte_codes(self : PdfCMapEncoding) -> Bool

    Return true when this CMap consumes text as fixed two-byte character codes.

    Identity CMaps and common UCS2/UTF16 predefined maps are treated as two-byte. Parsed external CMaps are two-byte only when all code spaces have length 2, or when they inherit an identity base with no explicit spaces.

    PdfCalculatedPosition

    source
    pub(all) struct PdfCalculatedPosition {
      x : Double
      y : Double
      rotation : Double
    } derive(Eq, ToJson, 
    Debug    )

    Absolute placement calculated from a position keyword and page bounds.

    PdfCalculatorFunction

    source
    pub(all) struct PdfCalculatorFunction {
      operations : Array[PdfCalculatorOp]
    } derive(Eq, ToJson, 
    Debug    )

    PDF function type 4, represented as parsed calculator operations.

    Evaluation starts with the function inputs on the stack and returns the numeric values left on the stack after all operations have run.

    PdfCalculatorOp

    source
    pub(all) enum PdfCalculatorOp {
      PdfCalculatorInt(Int)
      PdfCalculatorFloat(Double)
      PdfCalculatorAbs
      PdfCalculatorAdd
      PdfCalculatorAnd
      PdfCalculatorAtan
      PdfCalculatorBitshift
      PdfCalculatorBool(Bool)
      PdfCalculatorCeiling
      PdfCalculatorCos
      PdfCalculatorCopy
      PdfCalculatorCvi
      PdfCalculatorCvr
      PdfCalculatorSub
      PdfCalculatorMul
      PdfCalculatorDiv
      PdfCalculatorDup
      PdfCalculatorExch
      PdfCalculatorExp
      PdfCalculatorFloor
      PdfCalculatorIdiv
      PdfCalculatorIf(Array[PdfCalculatorOp])
      PdfCalculatorIfElse(Array[PdfCalculatorOp], Array[PdfCalculatorOp])
      PdfCalculatorIndex
      PdfCalculatorLn
      PdfCalculatorLog
      PdfCalculatorEq
      PdfCalculatorGe
      PdfCalculatorGt
      PdfCalculatorLe
      PdfCalculatorLt
      PdfCalculatorMod
      PdfCalculatorNe
      PdfCalculatorNeg
      PdfCalculatorNot
      PdfCalculatorOr
      PdfCalculatorPop
      PdfCalculatorRoll
      PdfCalculatorRound
      PdfCalculatorSin
      PdfCalculatorSqrt
      PdfCalculatorTruncate
      PdfCalculatorXor
    } derive(Eq, ToJson, 
    Debug    )

    Operation in a PDF type 4 PostScript calculator function.

    Literals push values onto the calculator stack. PdfCalculatorIf and PdfCalculatorIfElse store nested procedure bodies; the remaining variants correspond to PDF calculator-language operators.

    PdfCalculatorOp::debug_name

    source
    fn PdfCalculatorOp::debug_name(self : PdfCalculatorOp) -> String

    Return the calculator-language spelling for one operation.

    Procedure operations are formatted recursively in the same brace-delimited form accepted by the type 4 parser.

    PdfClassicXRefEntry

    source
    type PdfClassicXRefEntry derive(Eq, ToJson, 
    Debug    )

    PdfClipContour

    source
    pub(all) struct PdfClipContour {
      hole : Bool
      vertices : Array[PdfClipVertex]
    } derive(Eq, ToJson, 
    Debug    )

    One contour in a cpdf/GPC polygon.

    hole=true matches cpdf's 1 hole flag. hole=false matches cpdf's 0 exterior-contour flag.

    PdfClipContour::hole_flag

    source
    fn PdfClipContour::hole_flag(self : PdfClipContour) -> Int

    Return cpdf's integer hole flag for this contour.

    PdfClipContour::num_vertices

    source
    fn PdfClipContour::num_vertices(self : PdfClipContour) -> Int

    Number of vertices in this contour.

    PdfClipOperation

    source
    pub(all) enum PdfClipOperation {
      PdfClipDifference
      PdfClipIntersection
      PdfClipExclusiveOr
      PdfClipUnion
    } derive(Eq, ToJson, 
    Debug    )

    Boolean polygon operation used by cpdf's GPC-backed clipping helpers.

    PdfClipOperation::clip_polygons

    source

    Clip subject by clip using this cpdf/GPC operation.

    PdfClipOperation::gpc_code

    source
    fn PdfClipOperation::gpc_code(self : PdfClipOperation) -> Int

    Return the integer operation code used by cpdf's GPC binding.

    PdfClipPolygon

    source
    pub(all) struct PdfClipPolygon {
      contours : Array[PdfClipContour]
    } derive(Eq, ToJson, 
    Debug    )

    A cpdf/GPC polygon represented as an ordered list of contours.

    PdfClipPolygon::num_contours

    source
    fn PdfClipPolygon::num_contours(self : PdfClipPolygon) -> Int

    Number of contours in this polygon.

    PdfClipVertex

    source
    pub(all) struct PdfClipVertex {
      x : Double
      y : Double
    } derive(Eq, ToJson, 
    Debug    )

    A vertex in a cpdf/GPC polygon contour.

    PdfColourSpace

    source
    pub(all) enum PdfColourSpace {
      PdfDeviceGray
      PdfDeviceRGB
      PdfDeviceCMYK
      PdfCalGray(PdfTristimulusPoint, PdfTristimulusPoint, Double)
      PdfCalRGB(PdfTristimulusPoint, PdfTristimulusPoint, Array[Double], Array[Double])
      PdfLab(PdfTristimulusPoint, PdfTristimulusPoint, Array[Double])
      PdfICCBased(Int, PdfColourSpace, Array[Double], PdfObject?, PdfObject)
      PdfIndexed(PdfColourSpace, Array[(Int, Array[Int])])
      PdfPattern
      PdfPatternWithBaseColourSpace(PdfColourSpace)
      PdfSeparation(
    PdfName    , PdfColourSpace, PdfObject)
      PdfDeviceN(Array[
    PdfName    ], PdfColourSpace, PdfObject, PdfObject)
    } derive(Eq, ToJson, 
    Debug    )

    Parsed representation of the PDF colour spaces supported by this package.

    Device spaces represent the PDF built-ins. Calibrated and ICC-based spaces preserve their calibration data, indexed spaces hold an expanded lookup table, and separation or DeviceN spaces retain their tint transform objects for round-tripping.

    PdfColourSpace::content_json

    source
    fn PdfColourSpace::content_json(self : PdfColourSpace) -> Json

    Return cpdfcontent's JSON colour-space name.

    PdfColourSpace::debug_name

    source
    fn PdfColourSpace::debug_name(self : PdfColourSpace) -> String

    Return a diagnostic name for a colour space.

    Built-in spaces use their PDF names. Composite spaces include the diagnostic name of their alternate or base space, making the result useful for logs, snapshots, and error messages rather than for serialization.

    PdfColourSpace::name

    source

    Return the PDF colourant name carried by a separation space.

    Only PdfSeparation has a single associated colourant name in this API. Other colour spaces, including PdfDeviceN, return None.

    PdfCompositeCIDFont

    source
    pub(all) struct PdfCompositeCIDFont {
      cid_system_info : PdfCIDSystemInfo
      cid_basefont : 
    PdfName
      cid_fontdescriptor : PdfFontDescriptor
      cid_widths : Array[(Int, Double)]
      cid_widths2 : Array[(Int, PdfCIDVerticalWidth)]
      cid_default_width : Double
      cid_default_width2 : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    Parsed descendant CIDFont data for a Type 0 composite font.

    Width arrays are normalized into explicit CID-to-width entries while preserving the PDF default horizontal and vertical widths.

    PdfCompositionEntry

    source
    pub(all) struct PdfCompositionEntry {
      label : String
      bytes : Int
      percent : Double
    } derive(Eq, ToJson, 
    Debug    )

    PdfCompositionEntry::to_json

    source

    Convert a composition entry to the cpdf JSON row shape: [label, byte_count, percent].

    PdfContentAxialShading

    source
    pub(all) struct PdfContentAxialShading {
      axialshading_coords : (Double, Double, Double, Double)
      axialshading_domain : (Double, Double)
      axialshading_function : Array[PdfFunction]
      axialshading_extend : (Bool, Bool)
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentBoundingBox

    source
    pub(all) struct PdfContentBoundingBox {
      x0 : Double
      y0 : Double
      x1 : Double
      y1 : Double
      x2 : Double
      y2 : Double
      x3 : Double
      y3 : Double
    } derive(Eq, ToJson, 
    Debug    )

    Eight-point cpdfcontent bounding box quad.

    PdfContentBoundingBox::content_json

    source

    Return cpdfcontent's eight-number bbox array.

    PdfContentClippingOpResult

    source
    pub(all) struct PdfContentClippingOpResult {
      partial_path : PdfContentPartialPath
      clipping_path : Array[PdfPath]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentClippingState

    source
    pub(all) struct PdfContentClippingState {
      clipping_path : Array[PdfPath]
    } derive(Eq, ToJson, 
    Debug    )

    Clipping-only state exported for inline images, images, and shadings.

    PdfContentClippingState::content_json

    source

    Return cpdfcontent's JSON shape for clipping-only state.

    PdfContentColour

    source
    pub(all) enum PdfContentColour {
      PdfContentGrey(Double)
      PdfContentRGB(Double, Double, Double)
      PdfContentCMYK(Double, Double, Double, Double)
    } derive(Eq, ToJson, 
    Debug    )

    Colour value used by cpdf-style content colour rewrite operations.

    PdfContentColour::to_draw_colour

    source
    fn PdfContentColour::to_draw_colour(self : PdfContentColour) -> PdfDrawColour

    Convert a cpdf content colour into the draw colour variant.

    PdfContentColourValues

    source
    pub(all) enum PdfContentColourValues {
      PdfContentColourFloats(Array[Double])
      PdfContentColourNamed(String, Array[Double])
      PdfContentColourPattern
    } derive(Eq, ToJson, 
    Debug    )

    Colour operands carried by cpdfcontent's path drawing state.

    PdfContentColourValues::content_json

    source

    Return cpdfcontent's JSON shape for colour operands.

    PdfContentDashPattern

    source
    pub(all) struct PdfContentDashPattern {
      array : Array[Double]
      phase : Double
    } derive(Eq, ToJson, 
    Debug    )

    Dash pattern carried by cpdfcontent's path drawing state.

    PdfContentDashPattern::content_json

    source

    Return cpdfcontent's JSON shape for a path dash pattern.

    PdfContentFunctionShading

    source
    pub(all) struct PdfContentFunctionShading {
      funshading_domain : (Double, Double, Double, Double)
      funshading_matrix : 
    TransformMatrix
      funshading_function : PdfFunction
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentGlyphState

    source
    pub(all) struct PdfContentGlyphState {
      rendering_mode : Int
      knockout : Bool
      font : String
      font_size : Double
      clipping_path : Array[PdfPath]
    } derive(Eq, ToJson, 
    Debug    )

    Text state fields exported alongside glyph content objects.

    PdfContentGlyphState::content_json

    source
    fn PdfContentGlyphState::content_json(self : PdfContentGlyphState) -> Json

    Return cpdfcontent's JSON shape for glyph state.

    PdfContentInlineTextFilter

    source
    type PdfContentInlineTextFilter derive(Eq, 
    Debug    )

    PdfContentJsonEntry

    source
    pub(all) struct PdfContentJsonEntry {
      object : PdfContentObject
      state : PdfContentState
      bounding_box : PdfContentBoundingBox
    } derive(Eq, ToJson, 
    Debug    )

    One item in cpdfcontent's JSON content list.

    PdfContentJsonEntry::content_json

    source
    fn PdfContentJsonEntry::content_json(self : PdfContentJsonEntry) -> Json

    Return cpdfcontent's JSON shape for one content-list entry.

    PdfContentLexeme

    source
    type PdfContentLexeme derive(Eq, ToJson, 
    Debug    )

    PdfContentMarkedContent

    source
    pub(all) struct PdfContentMarkedContent {
      tag : String
      properties : PdfObject?
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentObject

    source
    pub(all) enum PdfContentObject {
      PdfContentGlyphObject(Int, String, String)
      PdfContentInlineImageObject
      PdfContentImageObject(String)
      PdfContentPathObject(PdfDrawnPath)
      PdfContentShadingObject(String)
    } derive(Eq, ToJson, 
    Debug    )

    Content objects emitted by cpdfcontent's JSON exporter.

    PdfContentObject::content_json

    source
    fn PdfContentObject::content_json(self : PdfContentObject) -> Json

    Return cpdfcontent's JSON shape for a content object.

    PdfContentOp

    source
    pub(all) enum PdfContentOp {
      Op_w(Double)
      Op_J(Int)
      Op_j(Int)
      Op_M(Double)
      Op_d(Array[Double], Double)
      Op_ri(
    PdfName    )
      Op_i(Double)
      Op_q
      Op_Q
      Op_cm(
    TransformMatrix    )
      Op_m(Double, Double)
      Op_l(Double, Double)
      Op_c(Double, Double, Double, Double, Double, Double)
      Op_v(Double, Double, Double, Double)
      Op_y(Double, Double, Double, Double)
      Op_h
      Op_re(Double, Double, Double, Double)
      Op_S
      Op_s
      Op_f
      Op_F
      Op_fstar
      Op_B
      Op_Bstar
      Op_b
      Op_bstar
      Op_n
      Op_W
      Op_Wstar
      Op_BT
      Op_ET
      Op_Tc(Double)
      Op_Tw(Double)
      Op_Tz(Double)
      Op_TL(Double)
      Op_Tf(
    PdfName    , Double)
      Op_Tr(Int)
      Op_Ts(Double)
      Op_Td(Double, Double)
      Op_TD(Double, Double)
      Op_Tm(
    TransformMatrix    )
      Op_Tstar
      Op_Tj(Bytes)
      Op_TJ(PdfObject)
      Op_quote(Bytes)
      Op_double_quote(Double, Double, Bytes)
      Op_d0(Double, Double)
      Op_d1(Double, Double, Double, Double, Double, Double)
      Op_G(Double)
      Op_g(Double)
      Op_RG(Double, Double, Double)
      Op_rg(Double, Double, Double)
      Op_K(Double, Double, Double, Double)
      Op_k(Double, Double, Double, Double)
      Op_gs(
    PdfName    )
      Op_CS(
    PdfName    )
      Op_cs(
    PdfName    )
      Op_SC(Array[Double])
      Op_sc(Array[Double])
      Op_SCN(Array[Double])
      Op_scn(Array[Double])
      Op_SCNName(
    PdfName    , Array[Double])
      Op_scnName(
    PdfName    , Array[Double])
      Op_sh(
    PdfName    )
      Op_Do(
    PdfName    )
      Op_InlineImage(PdfObject, PdfObject?, Bytes)
      Op_MP(
    PdfName    )
      Op_DP(
    PdfName    , PdfObject)
      Op_BMC(
    PdfName    )
      Op_BDC(
    PdfName    , PdfObject)
      Op_EMC
      Op_BX
      Op_EX
      Op_Unknown(Bytes)
    } derive(Eq, ToJson, 
    Debug    )

    Flat representation of PDF content stream operators.

    Text strings and unknown operators are stored as raw PDF bytes. Inline images carry their image dictionary, optional decode parameters, and image data; the parser decodes supported inline-image filters when it can do so safely.

    PdfContentOperatorFrame

    source
    pub(all) struct PdfContentOperatorFrame {
      ctm : 
    TransformMatrix
      partial_path : PdfContentPartialPath
      clipping_path : Array[PdfPath]
      path : PdfDrawnPath
      path_state : PdfContentPathState
      text_state : PdfContentTextState
      miter_limit : Double
      flatness : Double
      alpha_constant_stroke : Double
      alpha_constant_non_stroke : Double
      alpha_source : Bool
      smoothness : Double
      stroke_adjustment : Bool
      overprint_stroke : Bool
      overprint_non_stroke : Bool
      overprint_mode : Int
      black_generation : PdfObject
      undercolour_removal : PdfObject
      transfer : PdfObject
      halftone : PdfObject
      blend_mode : PdfObject
      soft_mask : PdfObject
      black_point_compensation : String
      marked_content_point : PdfContentMarkedContent?
      marked_content : Array[PdfContentMarkedContent]
      type3_d0 : PdfContentType3D0?
      type3_d1 : PdfContentType3D1?
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentOperatorResourceResult

    source
    pub(all) struct PdfContentOperatorResourceResult {
      state : PdfContentOperatorState
      entries : Array[PdfContentJsonEntry]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentOperatorState

    source
    pub(all) struct PdfContentOperatorState {
      ctm : 
    TransformMatrix
      partial_path : PdfContentPartialPath
      clipping_path : Array[PdfPath]
      path : PdfDrawnPath
      path_state : PdfContentPathState
      text_state : PdfContentTextState
      miter_limit : Double
      flatness : Double
      alpha_constant_stroke : Double
      alpha_constant_non_stroke : Double
      alpha_source : Bool
      smoothness : Double
      stroke_adjustment : Bool
      overprint_stroke : Bool
      overprint_non_stroke : Bool
      overprint_mode : Int
      black_generation : PdfObject
      undercolour_removal : PdfObject
      transfer : PdfObject
      halftone : PdfObject
      blend_mode : PdfObject
      soft_mask : PdfObject
      black_point_compensation : String
      marked_content_point : PdfContentMarkedContent?
      marked_content : Array[PdfContentMarkedContent]
      type3_d0 : PdfContentType3D0?
      type3_d1 : PdfContentType3D1?
      state_stack : Array[PdfContentOperatorFrame]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentOperatorState::content_apply_core_op

    source

    Apply cpdfcontent operators whose state effects do not require resources.

    This covers graphics-state stack operators, CTM concatenation, path construction/painting, clipping, path drawing state, direct graphics parameters, text state, marked-content state, and Type 3 glyph metrics. Font lookup, glyph emission, shadings, images, XObjects, and graphics-state dictionaries remain separate resource-backed slices.

    PdfContentOperatorState::content_apply_graphics_parameter_op

    source
    fn PdfContentOperatorState::content_apply_graphics_parameter_op(self : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Apply cpdfcontent direct graphics-parameter operators.

    PdfContentOperatorState::content_apply_graphics_state_op

    source
    fn PdfContentOperatorState::content_apply_graphics_state_op(self : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Apply cpdfcontent graphics-state stack and CTM operators.

    PdfContentOperatorState::content_apply_marked_content_op

    source
    fn PdfContentOperatorState::content_apply_marked_content_op(self : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Apply cpdfcontent marked-content state operators.

    PdfContentOperatorState::content_apply_text_show_op

    source

    Apply a text-showing operator and emit cpdfcontent glyph entries.

    PdfContentOperatorState::content_apply_type3_metrics_op

    source
    fn PdfContentOperatorState::content_apply_type3_metrics_op(self : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Apply cpdfcontent Type 3 glyph metric operators d0 and d1.

    PdfContentOperatorState::content_image_entry

    source

    Return the cpdfcontent JSON entry for an image XObject at the current CTM.

    PdfContentOperatorState::content_inline_image_entry

    source
    fn PdfContentOperatorState::content_inline_image_entry(self : PdfContentOperatorState) -> PdfContentJsonEntry

    Return the cpdfcontent JSON entry for an inline image at the current CTM.

    PdfContentOperatorState::content_path_entry

    source
    fn PdfContentOperatorState::content_path_entry(self : PdfContentOperatorState, stroking : Bool) -> PdfContentJsonEntry?

    Return the cpdfcontent JSON entry for the current drawn path, when nonempty.

    PdfContentOperatorState::content_shading_entry

    source

    Return the cpdfcontent JSON entry for a shading, when its bbox is valid.

    PdfContentOperatorState::content_text_glyph_entry

    source

    Return the cpdfcontent JSON entry for one placed text glyph.

    PdfContentOperatorState::content_unit_square_bounding_box

    source
    fn PdfContentOperatorState::content_unit_square_bounding_box(self : PdfContentOperatorState) -> PdfContentBoundingBox

    Return the CTM-transformed unit-square bounding box used for image objects.

    PdfContentOperatorTextResult

    source
    pub(all) struct PdfContentOperatorTextResult {
      state : PdfContentOperatorState
      entries : Array[PdfContentJsonEntry]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentPartialPath

    source
    pub(all) enum PdfContentPartialPath {
      PdfContentNoPartialPath
      PdfContentPartialPath(PdfContentPartialPathState)
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentPartialPath::content_apply_clipping_op

    source
    fn PdfContentPartialPath::content_apply_clipping_op(self : PdfContentPartialPath, clipping_path : ArrayView[PdfPath], op : PdfContentOp) -> PdfContentClippingOpResult

    Apply cpdfcontent clipping operator semantics for W and W*.

    The partial path is intentionally preserved. In PDF content streams, n commonly follows a clipping operator and clears the current path separately.

    PdfContentPartialPath::content_apply_path_op

    source

    Apply cpdfcontent path-construction and path-painting operator semantics.

    Non-path operators are ignored. Painting operators return the drawn path and clear the accumulated subpaths the same way process_op resets partial_path after emitting a path.

    PdfContentPartialPathState

    source
    pub(all) struct PdfContentPartialPathState {
      start_point : 
    Point2
      current_point : 
    Point2
      segments : Array[PdfPathSegment]
      subpaths : Array[PdfPathSubpath]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentPathOpResult

    source
    pub(all) struct PdfContentPathOpResult {
      partial_path : PdfContentPartialPath
      drawn_path : PdfDrawnPath?
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentPathState

    source
    pub(all) struct PdfContentPathState {
      clipping_path : Array[PdfPath]
      colourspace_stroke : PdfColourSpace
      colourspace_non_stroke : PdfColourSpace
      colour_stroke : PdfContentColourValues
      colour_non_stroke : PdfContentColourValues
      line_width : Double
      line_cap : Int
      line_join : Int
      dash_pattern : PdfContentDashPattern
      rendering_intent : String
    } derive(Eq, ToJson, 
    Debug    )

    Path drawing state exported by cpdfcontent's JSON view.

    PdfContentPathState::content_apply_path_state_op

    source
    fn PdfContentPathState::content_apply_path_state_op(self : PdfContentPathState, op : PdfContentOp) -> PdfContentPathState

    Apply the cpdfcontent path-state operators that do not require resources.

    PdfContentPathState::content_json

    source
    fn PdfContentPathState::content_json(self : PdfContentPathState) -> Json

    Return cpdfcontent's JSON shape for path drawing state.

    PdfContentPathState::content_with_clipping_path

    source
    fn PdfContentPathState::content_with_clipping_path(self : PdfContentPathState, clipping_path : ArrayView[PdfPath]) -> PdfContentPathState

    Return this path state with a replaced clipping path stack.

    PdfContentPattern

    source
    pub(all) enum PdfContentPattern {
      PdfContentColouredTilingPattern(PdfContentTiling)
      PdfContentUncolouredTilingPattern(PdfContentTiling)
      PdfContentShadingPattern(PdfContentShading)
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentRadialShading

    source
    pub(all) struct PdfContentRadialShading {
      radialshading_coords : (Double, Double, Double, Double, Double, Double)
      radialshading_domain : (Double, Double)
      radialshading_function : Array[PdfFunction]
      radialshading_extend : (Bool, Bool)
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentShading

    source
    pub(all) struct PdfContentShading {
      shading_colourspace : PdfObject
      shading_background : PdfObject?
      shading_bbox : PdfObject?
      shading_antialias : Bool
      shading_matrix : 
    TransformMatrix
      shading_extgstate : PdfObject
      shading : PdfContentShadingKind
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentShadingKind

    source
    pub(all) enum PdfContentShadingKind {
      PdfContentFunctionShading(PdfContentFunctionShading)
      PdfContentAxialShading(PdfContentAxialShading)
      PdfContentRadialShading(PdfContentRadialShading)
      PdfContentFreeFormGouraudShading
      PdfContentLatticeFormGouraudShading
      PdfContentCoonsPatchMesh
      PdfContentTensorProductPatchMesh
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentState

    source
    pub(all) enum PdfContentState {
      PdfContentStateGlyph(PdfContentGlyphState)
      PdfContentStatePath(PdfContentPathState)
      PdfContentStateClipping(PdfContentClippingState)
    } derive(Eq, ToJson, 
    Debug    )

    Content state variant carried by one cpdfcontent JSON entry.

    PdfContentState::content_json

    source
    fn PdfContentState::content_json(self : PdfContentState) -> Json

    Return cpdfcontent's JSON shape for a content state variant.

    PdfContentTextFontCacheEntry

    source
    pub(all) struct PdfContentTextFontCacheEntry {
      name : String
      font : PdfFont
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentTextGlyphPlacement

    source
    pub(all) struct PdfContentTextGlyphPlacement {
      charcode : Int
      text_matrix : 
    TransformMatrix
      width : Double
      pvx : Double
      pvy : Double
      advance_x : Double
      advance_y : Double
      bounding_box : PdfContentBoundingBox
    } derive(Eq, ToJson, 
    Debug    )

    Geometry emitted for one glyph by cpdfcontent-style text placement.

    PdfContentTextLayout

    source
    pub(all) struct PdfContentTextLayout {
      font_size : Double
      horizontal_scaling : Double
      character_spacing : Double
      word_spacing : Double
      rise : Double
      ctm : 
    TransformMatrix
      text_matrix : 
    TransformMatrix
    } derive(Eq, ToJson, 
    Debug    )

    Text-state fields needed by cpdfcontent's process_tj glyph placement.

    PdfContentTextLayoutResult

    source

    Result of placing one raw PDF text string with cpdfcontent text semantics.

    PdfContentTextOpResult

    source
    pub(all) struct PdfContentTextOpResult {
      text_state : PdfContentTextState
      glyphs : Array[PdfContentTextGlyphPlacement]
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentTextState

    source
    pub(all) struct PdfContentTextState {
      character_spacing : Double
      word_spacing : Double
      horizontal_scaling : Double
      leading : Double
      font : String
      current_font : PdfFont
      font_cache : Array[PdfContentTextFontCacheEntry]
      font_size : Double
      rendering_mode : Int
      rise : Double
      knockout : Bool
      text_matrix : 
    TransformMatrix
      line_matrix : 
    TransformMatrix
    } derive(Eq, ToJson, 
    Debug    )

    Text state tracked by cpdfcontent before glyph layout is emitted.

    PdfContentTextState::content_apply_text_op

    source

    Apply cpdfcontent text-state and text-showing operators with a known font.

    PdfContentTextState::content_apply_text_state_op

    source
    fn PdfContentTextState::content_apply_text_state_op(self : PdfContentTextState, op : PdfContentOp) -> PdfContentTextState

    Apply cpdfcontent text-state operators that do not require font resources.

    PdfContentTextState::content_cache_font

    source
    fn PdfContentTextState::content_cache_font(self : PdfContentTextState, name : String, font : PdfFont) -> PdfContentTextState

    PdfContentTextState::content_cached_font

    source
    fn PdfContentTextState::content_cached_font(self : PdfContentTextState, name : String) -> PdfFont?

    PdfContentTextState::content_glyph_state

    source
    fn PdfContentTextState::content_glyph_state(self : PdfContentTextState, clipping_path : ArrayView[PdfPath]) -> PdfContentGlyphState

    Return the JSON-facing glyph state for a text state and clipping path.

    PdfContentTextState::content_text_layout

    source

    Convert text state to the layout input used by cpdfcontent glyph placement.

    PdfContentTiling

    source
    pub(all) enum PdfContentTiling {
      PdfContentTiling
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentType3D0

    source
    pub(all) struct PdfContentType3D0 {
      width_x : Double
      width_y : Double
    } derive(Eq, ToJson, 
    Debug    )

    PdfContentType3D1

    source
    pub(all) struct PdfContentType3D1 {
      width_x : Double
      width_y : Double
      llx : Double
      lly : Double
      urx : Double
      ury : Double
    } derive(Eq, ToJson, 
    Debug    )

    PdfCoordRectangle

    source
    pub(all) struct PdfCoordRectangle {
      x : Double
      y : Double
      width : Double
      height : Double
    } derive(Eq, ToJson, 
    Debug    )

    A cpdf coordinate rectangle: origin plus width and height.

    PdfDecryptionResult

    source
    pub(all) struct PdfDecryptionResult {
      document : PdfDocument
      denied_permissions : Array[
    PdfPermission    ]
    } derive(Eq, ToJson, 
    Debug    )

    Result of successfully decrypting a document.

    document is a decrypted copy with encryption removed from the trailer and saved encryption state attached. denied_permissions is decoded from the original /P permission mask.

    PdfDestination

    source
    pub(all) enum PdfDestination {
      DestAction(PdfObject)
      DestNull
      DestNamed(
    PdfName    )
      DestString(Bytes)
      DestXYZ(PdfTargetPage, Double?, Double?, Double?)
      DestFit(PdfTargetPage)
      DestFitH(PdfTargetPage, Double?)
      DestFitV(PdfTargetPage, Double?)
      DestFitR(PdfTargetPage, Double, Double, Double, Double)
      DestFitB(PdfTargetPage)
      DestFitBH(PdfTargetPage, Double?)
      DestFitBV(PdfTargetPage, Double?)
    } derive(Eq, ToJson, 
    Debug    )

    A normalized PDF destination.

    The variants cover action dictionaries, named/string destinations, null destinations, and all standard page-view destination array forms.

    PdfDocument

    source
    pub struct PdfDocument {
      major : Int
      minor : Int
      root : Int
      objects : PdfObjects
      trailer_dict : PdfObject
      was_linearized : Bool
      saved_encryption : PdfSavedEncryption?
      first_xref : Int
      revision_read : Int
    } derive(Eq, ToJson, 
    Debug    )

    In-memory representation of one PDF document.

    A document stores the PDF version, catalog root number, object table, trailer dictionary, linearization flag, saved encryption metadata, first xref offset, and the revision count read from the input.

    PdfDocument::add_annotation

    source
    fn PdfDocument::add_annotation(self : PdfDocument, page : PdfPage, annotation : PdfAnnotation) -> PdfPage raise 
    PdfError

    Return a page value with an annotation prepended to /Annots.

    The annotation is written as a direct dictionary. Existing annotation arrays are preserved after the new entry; a non-array /Annots value raises.

    PdfDocument::add_bookmark_title

    source
    fn PdfDocument::add_bookmark_title(self : PdfDocument, filename : String, use_title : Bool) -> PdfDocument raise 
    PdfError

    Add a top-level title bookmark pointing at page one.

    Existing bookmarks are indented by one level. When use_title is true, the document metadata title is preferred, matching cpdf's XMP-over-Info precedence; otherwise the basename of filename is used.

    PdfDocument::add_bookmarks

    source

    Return a copy of the document with its outline tree replaced.

    The input must be in preorder using zero-based level values. Empty input removes existing bookmarks. New outline objects are allocated after the current maximum object number.

    PdfDocument::add_bookmarks_from_json

    source
    fn PdfDocument::add_bookmarks_from_json(self : PdfDocument, json : Json, verify? : Bool) -> PdfDocument raise 
    PdfError

    Return a copy of the document with bookmarks imported from cpdf JSON rows.

    PdfDocument::add_bookmarks_from_text

    source
    fn PdfDocument::add_bookmarks_from_text(self : PdfDocument, data : BytesView, verify? : Bool) -> PdfDocument raise 
    PdfError

    Return a copy of the document with bookmarks imported from cpdf text bytes.

    PdfDocument::add_object

    source
    fn PdfDocument::add_object(self : PdfDocument, object : PdfObject, generation? : Int) -> Int

    Add a parsed object using the next available object number.

    Returns the allocated object number and records an object-altered event.

    PdfDocument::add_object_given_number

    source
    fn PdfDocument::add_object_given_number(self : PdfDocument, number : Int, object : PdfObject, generation? : Int) -> Unit

    Add or replace a parsed object at an explicit object number.

    This records an object-altered event and updates the maximum object number if needed.

    PdfDocument::add_page_labels

    source
    fn PdfDocument::add_page_labels(self : PdfDocument, progress : Bool, style : PdfPageLabelStyle, prefix : Bytes?, start_value : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Add page-label ranges to the selected one-based page numbers.

    page_numbers is interpreted in its existing order; contiguous runs are labelled as ranges. When progress is true, each later range starts after the number of pages already labelled by earlier ranges.

    PdfDocument::add_page_labels_json

    source
    fn PdfDocument::add_page_labels_json(self : PdfDocument, json : Json) -> PdfDocument raise 
    PdfError

    Add page labels from cpdf's JSON page-label array shape.

    Each entry must contain labelstyle, labelprefix, startpage, and startvalue. Prefix strings are interpreted as UTF-8 and encoded as compact PDFDocStrings, matching cpdf's add_page_labels_json.

    PdfDocument::add_pagetree

    source
    fn PdfDocument::add_pagetree(self : PdfDocument, pages : ArrayView[PdfPage]) -> Int raise 
    PdfError

    Add a balanced page tree for pages and return its root object number.

    Page content objects that are not already indirect are inserted into the document. The document is mutated in place.

    PdfDocument::add_prefix

    source
    fn PdfDocument::add_prefix(self : PdfDocument, prefix : String) -> Unit raise 
    PdfError

    Prefix all page resource names and corresponding content references.

    If split content streams cannot be parsed independently, content streams are merged first. This mutates the document in place and is useful before combining pages from multiple documents.

    PdfDocument::add_root

    source

    Add or replace the catalog root pointing at a page-tree root.

    Existing catalog entries are preserved except /Type and /Pages; extras can add or replace other catalog entries. The document trailer /Root is updated and the document is mutated in place.

    PdfDocument::addtext_bookmark_for_page

    source
    fn PdfDocument::addtext_bookmark_for_page(self : PdfDocument, bookmarks : ArrayView[PdfBookmark], level : Int, page_number : Int) -> String raise 
    PdfError

    Return cpdf add-text's current bookmark text at level for page_number.

    The search is constrained to the current bookmark branch so section bookmarks from a previous chapter do not leak into a later chapter.

    PdfDocument::addtext_calc_textwidth

    source
    fn PdfDocument::addtext_calc_textwidth(self : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : BytesView) -> Double raise 
    PdfError

    Measure text bytes with cpdf add-text's selected font mode.

    This ports the local calc_textwidth branch in cpdfaddtext.ml. Font packs interpret text as UTF-8 so codepoints can select pack members; selected parsed fonts and existing page fonts treat text as the PDF text bytes to measure.

    PdfDocument::addtext_existing_font_resource

    source

    Resolve an existing page font for cpdf add-text.

    The requested name is first treated as a /Font resource key. If that is absent, the page font dictionary is scanned for an entry whose /BaseFont matches the requested name; the returned PdfName is the resource key to use in emitted text operators.

    PdfDocument::addtext_line_page

    source
    fn PdfDocument::addtext_line_page(self : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, text : String, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , horizontal_offset? : Double, vertical_offset? : Double, shift_x? : Double, shift_y? : Double, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfPage raise 
    PdfError

    Add one prepared cpdf add-text line to a page.

    This is the single-page counterpart of cpdf's local addtext_page: it prepares text and placement, installs resources, emits /CPDFSTAMP text operators, creates URL annotations, and appends or prepends the content.

    PdfDocument::addtext_line_widths

    source
    fn PdfDocument::addtext_line_widths(self : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : BytesView, expanded_lines : ArrayView[Bytes]) -> PdfAddTextLineWidths raise 
    PdfError

    Measure cpdf add-text's current line and expanded paragraph widths.

    This ports the local textwidth, allwidths, and longest_w block in cpdfaddtext.ml after replacement expansion and URL stripping.

    PdfDocument::addtext_opacity_resources

    source
    fn PdfDocument::addtext_opacity_resources(self : PdfDocument, resources : PdfObject, opacity : Double) -> (PdfObject, 
    PdfName    ?) raise 
    PdfError

    Return resources updated with cpdf add-text opacity graphics state.

    Opacity values below 1.0 allocate a unique /gs* entry under /ExtGState with both fill and stroke alpha set. Opaque values leave the resource dictionary unchanged and return no graphics-state name.

    PdfDocument::addtext_page_font_dictionary

    source
    fn PdfDocument::addtext_page_font_dictionary(self : PdfDocument, page : PdfPage) -> PdfObject

    Return the page font resource object used by cpdf add-text setup.

    Missing /Font resources are treated as an empty dictionary. Present values are resolved through the document and returned as-is, matching cpdf's Pdf.lookup_direct setup before unique font-name allocation.

    PdfDocument::addtext_page_label

    source
    fn PdfDocument::addtext_page_label(self : PdfDocument, page_number : Int) -> String raise 
    PdfError

    Return cpdf add-text's visible page label for a 1-based page number.

    Documents without page labels fall back to decimal page numbers.

    PdfDocument::addtext_page_lines

    source
    fn PdfDocument::addtext_page_lines(self : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, shift_x? : Double, shift_y? : Double, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfPage raise 
    PdfError

    Add all cpdf add-text lines to one page using cpdf paragraph advancement.

    This ports the outer per-line loop around cpdf's local addtext call: initial multi-line offsets, midline/topline baseline adjustment, repeated line emission, and rotation-dependent line advancement.

    PdfDocument::addtext_page_rest_with_annotations

    source
    fn PdfDocument::addtext_page_rest_with_annotations(self : PdfDocument, rest : PdfObject, annotations : ArrayView[PdfObject]) -> PdfObject raise 
    PdfError

    Return a page rest dictionary with cpdf add-text annotations prepended.

    Empty new annotation lists leave rest unchanged. Existing /Annots arrays are resolved through document; missing or malformed values are treated as empty, matching cpdf's add-text page update.

    PdfDocument::addtext_pages_with_font

    source
    fn PdfDocument::addtext_pages_with_font(self : PdfDocument, page_numbers : ArrayView[Int], lines : ArrayView[String], time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Add cpdf add-text lines to selected pages with an already resolved font.

    This ports the document/page-selection layer after font selection: selected one-based pages get page-local replacement callbacks, cpdf shift-coordinate parsing, and page-line emission. Font embedding and existing-font discovery remain separate slices.

    PdfDocument::addtext_prepare_line

    source
    fn PdfDocument::addtext_prepare_line(self : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : String, position : PdfPosition, relative_to_box? : 
    PdfName    , horizontal_offset? : Double, vertical_offset? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, raw? : Bool) -> PdfAddTextPreparedLine raise 
    PdfError

    Prepare one cpdf add-text line for later content and annotation emission.

    This ports the source-level block which expands page-local replacement fields, strips %URL[text|url] markup, measures the current and paragraph line widths, and resolves the final cpdf placement offsets.

    PdfDocument::addtext_rectangle

    source
    fn PdfDocument::addtext_rectangle(self : PdfDocument, page_numbers : ArrayView[Int], coord : String, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , outline? : Bool, line_width? : Double, opacity? : Double, underneath? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Add a cpdf-style rectangle stamp to selected one-based pages.

    The rectangle dimensions are parsed with cpdf coordinate syntax, placed relative to relative_to_box, wrapped as /CPDFSTAMP artifact content, and appended unless underneath is set.

    PdfDocument::addtext_replacement_values

    source
    fn PdfDocument::addtext_replacement_values(self : PdfDocument, bookmarks : ArrayView[PdfBookmark], page_number : Int, end_page : Int, filename : String, bates : Int, bates_pad : Int?) -> PdfAddTextReplacementValues raise 
    PdfError

    Build cpdf add-text replacement values from document-local state.

    PdfDocument::addtext_resource_setup

    source
    fn PdfDocument::addtext_resource_setup(self : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], opacity : Double) -> PdfAddTextResourceSetup raise 
    PdfError

    Prepare page resources for one cpdf add-text line.

    Selected-font and fontpack modes install new /Font entries and optional opacity resources. Existing-named-font mode reuses the page resources unchanged and suppresses opacity graphics state selection, matching cpdf's font = None branch.

    PdfDocument::addtext_selected_font_object

    source
    fn PdfDocument::addtext_selected_font_object(self : PdfDocument, font : PdfFont?) -> PdfObject? raise 
    PdfError

    Write the selected cpdf add-text font and return its indirect reference.

    Existing-named-font mode has no selected font to write, so None is preserved for callers that later reuse the page's current font resource.

    PdfDocument::addtext_url_annotation_references

    source
    fn PdfDocument::addtext_url_annotation_references(self : PdfDocument, text : String, urls : ArrayView[PdfAddTextUrl], measure : (String) -> Double raise 
    PdfError    , origin : 
    Point2    , horizontal_offset : Double, vertical_offset : Double, justification_offset : Double, rotation : Double, rotation_offset : 
    Point2    , page_rotation : Double, font : PdfFont?, fontname : String, font_size : Double, url_border : Bool) -> Array[PdfObject] raise 
    PdfError

    Build indirect URL link annotations for one cpdf add-text line.

    This mirrors cpdf's add-text annotation pass: each parsed URL span is measured against the visible line, converted to transformed quad points, and written as a new indirect annotation object.

    PdfDocument::addtext_width_of_existing_font_resource

    source
    fn PdfDocument::addtext_width_of_existing_font_resource(self : PdfDocument, page : PdfPage, fontname : 
    PdfName    , font_size : Double, text : BytesView) -> (
    PdfName    , Double) raise 
    PdfError

    Measure add-text bytes using an existing page font resource.

    PdfDocument::addtexts_with_font

    source
    fn PdfDocument::addtexts_with_font(self : PdfDocument, page_numbers : ArrayView[Int], text : String, time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Add cpdf add-text to selected pages with deterministic time and resolved fonts.

    This ports the outer source-level addtexts orchestration once callers have already chosen an existing font, parsed font, or font pack. It prepares the input text lines, skips empty visible output before writing fonts, writes selected/fontpack font objects, and delegates page rewriting to addtext_pages_with_font.

    PdfDocument::addtexts_with_source

    source
    fn PdfDocument::addtexts_with_source(self : PdfDocument, page_numbers : ArrayView[Int], text : String, time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font_source : PdfAddTextFontSource, fontname : 
    PdfName    , font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Add cpdf add-text to selected pages from a non-embedding font source.

    PdfDocument::all_pages_upright

    source
    fn PdfDocument::all_pages_upright(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bool raise 
    PdfError

    Return whether selected pages are rotation-free and have a near-zero origin.

    This ports cpdf's allupright predicate. Like the source, page numbers outside the document are ignored rather than treated as a range error.

    PdfDocument::all_pages_upright_only

    source
    fn PdfDocument::all_pages_upright_only(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bool raise 
    PdfError

    Return whether selected pages have no page dictionary rotation.

    This ports cpdf's alluprightonly, which intentionally does not require a (0, 0) media-box origin and ignores out-of-range page numbers.

    PdfDocument::annotations_json

    source
    fn PdfDocument::annotations_json(self : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Return cpdf's annotation JSON export for selected pages.

    Only indirect page annotation entries are exported, matching cpdf's JSON path. Page-object references in /P, /Dest, and action /D destinations without /Dest are rewritten to 1-based page numbers. Referenced ancillary objects are appended after annotation entries, excluding /Popup and /Parent links.

    PdfDocument::annotations_json_blob

    source
    fn PdfDocument::annotations_json_blob(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Return cpdf's annotation JSON export as UTF-8 JSON bytes.

    PdfDocument::annotations_of_page

    source

    Read annotations from a page's /Annots array.

    Missing or malformed /Annots entries are treated as no annotations. When a popup annotation and its parent both appear in the page array, the parent is skipped and represented through AnnotationPopup.

    PdfDocument::append_page_content

    source
    fn PdfDocument::append_page_content(self : PdfDocument, page_numbers : ArrayView[Int], content : BytesView, before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Append or prepend parsed content bytes to selected one-based pages.

    content is byte-oriented PDF content syntax, matching the OCaml source's string payload. Empty content is a no-op.

    PdfDocument::append_page_content_multiple

    source
    fn PdfDocument::append_page_content_multiple(self : PdfDocument, contents : ArrayView[Bytes], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Append or prepend one content byte payload per page.

    The payload list must match the current page count. Empty per-page payloads leave that page unchanged.

    PdfDocument::append_page_content_multiple_ops

    source
    fn PdfDocument::append_page_content_multiple_ops(self : PdfDocument, op_lists : ArrayView[Array[PdfContentOp]], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Append or prepend one content operator list per page.

    PdfDocument::append_page_content_ops

    source
    fn PdfDocument::append_page_content_ops(self : PdfDocument, page_numbers : ArrayView[Int], ops : ArrayView[PdfContentOp], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Append or prepend content operators to selected one-based pages.

    PdfDocument::apply_redaction_type

    source
    fn PdfDocument::apply_redaction_type(self : PdfDocument, annotation_type : String, page_numbers : ArrayView[Int]) -> Unit

    Apply annotations of annotation_type as if they were redactions.

    This mirrors the current cpdf stub, which intentionally performs no work.

    PdfDocument::apply_redactions

    source
    fn PdfDocument::apply_redactions(self : PdfDocument, page_numbers : ArrayView[Int]) -> Unit

    Apply redaction annotations.

    This mirrors the current cpdf stub, which intentionally performs no work.

    PdfDocument::attach_file

    source
    fn PdfDocument::attach_file(self : PdfDocument, filename : String, data : BytesView, keep_version? : Bool, page_number? : Int?, relationship? : String?, description? : String?) -> PdfDocument raise 
    PdfError

    Attach an in-memory file payload to the document or to a one-based page.

    The original document is left unchanged. filename supplies the attachment basename; the payload bytes are copied. When keep_version is false, PDF versions below 1.4 are bumped to 1.4 as in cpdf.

    PdfDocument::black_fills

    source
    fn PdfDocument::black_fills(self : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Paint fills on selected one-based pages and Form XObjects with colour.

    PdfDocument::black_lines

    source
    fn PdfDocument::black_lines(self : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Paint line strokes on selected one-based pages and Form XObjects with colour.

    PdfDocument::black_text

    source
    fn PdfDocument::black_text(self : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Paint text on selected one-based pages and Form XObjects with colour.

    PdfDocument::bookmark_name_of_spec

    source
    fn PdfDocument::bookmark_name_of_spec(self : PdfDocument, encoding : PdfMetadataEncoding, bookmarks : ArrayView[PdfBookmark], split_level : Int, spec : String, sequence : Int, filename : String, start_page : Int, end_page : Int) -> String raise 
    PdfError

    Expand cpdf's bookmark-based output filename specification.

    This ports the output-side name_of_spec helper. Bookmark-file parsing is intentionally separate; callers pass the already-read bookmark list.

    PdfDocument::bookmarks_json

    source
    fn PdfDocument::bookmarks_json(self : PdfDocument, json_preserve_actions? : Bool) -> Json raise 
    PdfError

    Return cpdf's full-document bookmark JSON listing.

    PdfDocument::bookmarks_json_blob

    source
    fn PdfDocument::bookmarks_json_blob(self : PdfDocument, json_preserve_actions? : Bool) -> Bytes raise 
    PdfError

    Return cpdf's full-document bookmark JSON listing as UTF-8 JSON bytes.

    PdfDocument::bookmarks_open_to_level

    source
    fn PdfDocument::bookmarks_open_to_level(self : PdfDocument, level : Int) -> PdfDocument raise 
    PdfError

    Return a copy of the document whose bookmarks are open below level.

    PdfDocument::bpc

    source
    fn PdfDocument::bpc(self : PdfDocument, image : PdfObject) -> PdfObject?

    Compatibility alias for PdfDocument::image_bits_per_component.

    PdfDocument::build_name_tree

    source
    fn PdfDocument::build_name_tree(self : PdfDocument, entries : ArrayView[(Bytes, PdfObject)]) -> PdfObject

    Build a PDF name tree from byte-string keys and object values.

    Entries are sorted by byte order. Empty input produces a leaf tree with an empty /Names array; larger inputs are split into child nodes with /Limits entries, allocating child objects in self as needed.

    PdfDocument::build_number_tree

    source
    fn PdfDocument::build_number_tree(self : PdfDocument, entries : ArrayView[(Int, PdfObject)]) -> PdfObject

    Build a PDF number tree from integer keys and object values.

    Entries are sorted numerically. Empty input produces a leaf tree with an empty /Nums array; larger inputs are split into child nodes with /Limits entries, allocating child objects in self as needed.

    PdfDocument::catalog

    source

    Return the resolved document catalog object.

    A /Root entry in the trailer dictionary is preferred over the stored root number. The selected reference is resolved through direct; if it resolves to PdfNull, this raises PdfError::RootExpected.

    PdfDocument::catalog_item

    source
    fn PdfDocument::catalog_item(self : PdfDocument, key : 
    PdfName    ) -> String

    Return a catalog item in cpdf's text-reporting form.

    PdfDocument::center_to_fit_pages

    source
    fn PdfDocument::center_to_fit_pages(self : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)]) -> PdfDocument raise 
    PdfError

    Centre selected pages on page-indexed target sizes without scaling content.

    This ports cpdf's center_to_fit composition: selected pages receive new media and crop boxes, art and bleed boxes are removed, then all known boxes are shifted by offsets calculated from the original page crop/media bounds.

    PdfDocument::change_boxes

    source
    fn PdfDocument::change_boxes(self : PdfDocument, page : PdfPage, transform : (Double, Double, Double, Double) -> (Double, Double, Double, Double)) -> PdfPage raise 
    PdfError

    Change /MediaBox and known page boxes with a coordinate transform.

    The callback receives (min_x, min_y, max_x, max_y) and returns replacement bounds. This ports cpdf's single-page change_boxes helper.

    PdfDocument::change_id

    source
    fn PdfDocument::change_id(self : PdfDocument, path : String, get_time : () -> Double) -> Unit raise 
    PdfError

    Replaces this document's trailer /ID entry.

    Raises PdfError::DictionaryExpected if the trailer is not a dictionary.

    PdfDocument::change_pages

    source
    fn PdfDocument::change_pages(self : PdfDocument, pages : ArrayView[PdfPage], change_references? : Bool, matrices? : ArrayView[(Int, 
    TransformMatrix    )], changes? : ArrayView[(Int, Int)]) -> PdfDocument raise 
    PdfError

    Replace the document page tree with pages.

    When change_references is true, page-object references in destinations, actions, annotations, and bookmarks are rewritten from the old page set to the new one. matrices can transform destination coordinates for pages whose geometry changed, and changes can map old page serials to new serials when page counts differ.

    PdfDocument::chop

    source
    fn PdfDocument::chop(self : PdfDocument, x : Int, y : Int, columns : Bool, btt : Bool, rtl : Bool, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Chop selected pages into an x by y grid.

    The page crop box is preferred when present. Chopped pages receive only a new media box; inherited/crop/trim/bleed/art boxes and annotations are removed from each generated piece, matching cpdf's chop behavior.

    PdfDocument::chop_hv

    source
    fn PdfDocument::chop_hv(self : PdfDocument, is_h : Bool, line : Double, columns : Bool, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Chop selected pages horizontally or vertically at line.

    PdfDocument::colour_space_components

    source
    fn PdfDocument::colour_space_components(self : PdfDocument, resources : PdfObject, object : PdfObject) -> Int raise 
    PdfError

    Return the number of components required by a colour-space object.

    Resource names are resolved through the supplied resources dictionary. Pattern spaces without a base colour space are rejected because their paint operators do not consume ordinary colour components.

    PdfDocument::colspace

    source

    Compatibility alias for PdfDocument::image_colour_space.

    PdfDocument::combine_pages

    source
    fn PdfDocument::combine_pages(self : PdfDocument, overlay : PdfDocument, fast? : Bool, scale_to_fit? : Bool, overlay_is_under? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Combine each page in this document with the corresponding page of overlay.

    The overlay is truncated or padded with blank A4 pages to match the under document length. Overlay resources are prefixed before merging, and bookmarks from both inputs are retained on the paired output pages.

    PdfDocument::combine_pdf_resources

    source
    fn PdfDocument::combine_pdf_resources(self : PdfDocument, first : PdfObject, second : PdfObject) -> PdfObject

    Merge two page resource dictionaries.

    Known resource categories such as /Font, /XObject, and /ColorSpace are concatenated; unknown top-level entries from both dictionaries are preserved. Later duplicate resource names are not renamed here.

    PdfDocument::combine_pdf_rests

    source
    fn PdfDocument::combine_pdf_rests(self : PdfDocument, first : PdfObject, second : PdfObject) -> PdfObject

    Merge two page rest dictionaries for future imposition support.

    Unknown entries from both dictionaries are preserved. /Annots arrays are resolved from either dictionary and concatenated, matching the CamlPDF cpdfimpose helper without porting the full imposition pipeline yet.

    PdfDocument::composition

    source

    Return cpdf-style composition buckets for a document.

    The result order is stable: images, fonts, content streams, structure info, attached files, xref table, piece info, then unclassified bytes.

    PdfDocument::composition_json

    source
    fn PdfDocument::composition_json(self : PdfDocument, file_size : Int) -> Json raise 
    PdfError

    Return the document composition in cpdf JSON row format.

    PdfDocument::composition_json_blob

    source
    fn PdfDocument::composition_json_blob(self : PdfDocument, file_size : Int) -> Bytes raise 
    PdfError

    Return the document composition serialized as UTF-8 JSON bytes.

    PdfDocument::contains_javascript

    source
    fn PdfDocument::contains_javascript(self : PdfDocument) -> Bool

    Return whether parsed document objects or the root names tree contain cpdf-style JavaScript markers.

    This follows cpdf's historical checks: /URI strings are detected only when they begin with lowercase javascript:, and /S is detected only when its resolved value is the PDF string /JavaScript.

    PdfDocument::content_apply_extgstate_alpha_op

    source
    fn PdfDocument::content_apply_extgstate_alpha_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent alpha parameters from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_compositing_op

    source
    fn PdfDocument::content_apply_extgstate_compositing_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent blend and black-point-compensation from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_dash_op

    source
    fn PdfDocument::content_apply_extgstate_dash_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState raise 
    PdfError

    Apply cpdfcontent dash parameters from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_font_op

    source
    fn PdfDocument::content_apply_extgstate_font_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState raise 
    PdfError

    Apply cpdfcontent font state from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_graphics_parameter_op

    source
    fn PdfDocument::content_apply_extgstate_graphics_parameter_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent scalar graphics parameters from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_halftone_op

    source
    fn PdfDocument::content_apply_extgstate_halftone_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent halftone objects from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_overprint_op

    source
    fn PdfDocument::content_apply_extgstate_overprint_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent overprint parameters from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_rendering_op

    source
    fn PdfDocument::content_apply_extgstate_rendering_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent smoothness and stroke-adjustment from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_resource_op

    source

    Apply cpdfcontent's source-shaped gs ExtGState resource dictionary.

    PdfDocument::content_apply_extgstate_text_op

    source
    fn PdfDocument::content_apply_extgstate_text_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent text-state fields from a resolved ExtGState dictionary.

    PdfDocument::content_apply_extgstate_transfer_op

    source
    fn PdfDocument::content_apply_extgstate_transfer_op(self : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Apply cpdfcontent transfer-function objects from a resolved ExtGState dictionary.

    PdfDocument::content_apply_font_resource_op

    source
    fn PdfDocument::content_apply_font_resource_op(self : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, font_name : 
    PdfName    , font_size : Double) -> PdfContentOperatorState raise 
    PdfError

    Apply cpdfcontent's resource-backed Tf font lookup and cache update.

    PdfDocument::content_apply_resource_op

    source

    Apply one cpdfcontent operator with resource-backed entry emission.

    PdfDocument::content_apply_text_resource_op

    source

    Apply cpdfcontent text operators that depend on page resources or font data.

    PdfDocument::content_entries_of_ops

    source
    fn PdfDocument::content_entries_of_ops(self : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Array[PdfContentJsonEntry] raise 
    PdfError

    Collect cpdfcontent JSON entries for one non-recursive content-operator list.

    PdfDocument::content_entries_of_ops_recursive

    source
    fn PdfDocument::content_entries_of_ops_recursive(self : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Array[PdfContentJsonEntry] raise 
    PdfError

    Collect cpdfcontent JSON entries for content operators, recursively walking Forms.

    PdfDocument::content_entries_of_page

    source

    Collect recursive cpdfcontent JSON entries for one page.

    PdfDocument::content_filter

    source
    fn PdfDocument::content_filter(self : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp], predicate : (PdfContentJsonEntry) -> Bool) -> Array[PdfContentOp] raise 
    PdfError

    Walk content entries, call predicate for each one, and return the original ops.

    PdfDocument::content_form_xobject_enter_state

    source

    Look up a named Form XObject resource and return the state used to enter it.

    PdfDocument::content_form_xobject_ops

    source

    Look up a named Form XObject resource and parse its content operators.

    PdfDocument::content_form_xobject_resources

    source
    fn PdfDocument::content_form_xobject_resources(self : PdfDocument, resources : PdfObject, name : 
    PdfName    ) -> PdfObject? raise 
    PdfError

    Look up a named Form XObject resource and return the resources used inside it.

    PdfDocument::content_image_entry_from_resources

    source

    Look up a named image XObject resource and return its cpdfcontent JSON entry.

    PdfDocument::content_json_of_ops

    source
    fn PdfDocument::content_json_of_ops(self : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Json raise 
    PdfError

    Serialize recursive cpdfcontent entries for one already-parsed operator list.

    PdfDocument::content_json_of_page

    source
    fn PdfDocument::content_json_of_page(self : PdfDocument, page : PdfPage) -> Json raise 
    PdfError

    Serialize recursive cpdfcontent entries for one page.

    PdfDocument::content_read_axial_shading

    source
    fn PdfDocument::content_read_axial_shading(self : PdfDocument, shading : PdfObject) -> PdfContentShadingKind raise 
    PdfError

    PdfDocument::content_read_function_shading

    source
    fn PdfDocument::content_read_function_shading(self : PdfDocument, shading : PdfObject) -> PdfContentShadingKind raise 
    PdfError

    PdfDocument::content_read_pattern

    source

    PdfDocument::content_read_radial_shading

    source
    fn PdfDocument::content_read_radial_shading(self : PdfDocument, shading : PdfObject) -> PdfContentShadingKind raise 
    PdfError

    PdfDocument::content_read_shading

    source

    PdfDocument::content_read_shading_pattern

    source
    fn PdfDocument::content_read_shading_pattern(self : PdfDocument, pattern : PdfObject) -> PdfContentPattern raise 
    PdfError

    PdfDocument::content_shading_entry_from_resources

    source
    fn PdfDocument::content_shading_entry_from_resources(self : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, name : 
    PdfName    ) -> PdfContentJsonEntry?

    Look up a named shading resource and return its cpdfcontent JSON entry.

    PdfDocument::contents_of_name_tree

    source
    fn PdfDocument::contents_of_name_tree(self : PdfDocument, tree : PdfObject) -> Array[(PdfObject, PdfObject)]

    Return the immediate key-value pairs contained in a name or number tree.

    The tree may store entries directly in /Names or /Nums, or indirectly in child nodes under /Kids. Entries are returned as raw PdfObject pairs, so callers that need typed name or number keys should use read_name_tree or read_number_tree.

    PdfDocument::copy

    source
    fn PdfDocument::copy(self : PdfDocument) -> PdfDocument

    Deep-copy the document object table and trailer.

    Parsed object containers and stream data are copied so mutations to the copy do not alter the original document's object graph.

    PdfDocument::copy_annotations_from

    source
    fn PdfDocument::copy_annotations_from(self : PdfDocument, source : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Return a copy of this document with annotations copied from source.

    PdfDocument::copy_font_from

    source
    fn PdfDocument::copy_font_from(self : PdfDocument, source : PdfDocument, font_name : String, font_page : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Copy a named font from source onto selected pages of this document.

    This ports cpdf's copy_font: both documents are first renumbered into one non-overlapping object space, the direct source font dictionary is added to selected target pages under its /BaseFont name, and all objects referenced by the copied font dictionary are copied into the target document.

    PdfDocument::copy_id_from

    source
    fn PdfDocument::copy_id_from(self : PdfDocument, source : PdfDocument, keep_version? : Bool) -> PdfDocument raise 
    PdfError

    Copy the trailer /ID from source onto this document.

    The original document is left unchanged. When keep_version is false, PDF 1.x outputs are bumped to at least 1.1, matching cpdf.

    PdfDocument::copy_page_box

    source
    fn PdfDocument::copy_page_box(self : PdfDocument, page_numbers : ArrayView[Int], from_box : 
    PdfName    , to_box : 
    PdfName    , mediabox_if_missing? : Bool) -> PdfDocument raise 
    PdfError

    Copy one page-box value to another on selected pages.

    Missing source boxes leave the page unchanged unless mediabox_if_missing is true, in which case the page /MediaBox is copied.

    PdfDocument::create_metadata

    source

    Create a fresh XMP metadata stream from the document /Info dictionary.

    PdfDocument::crop_pages

    source
    fn PdfDocument::crop_pages(self : PdfDocument, page_numbers : ArrayView[Int], boxes : ArrayView[(Double, Double, Double, Double)], box_name? : 
    PdfName    ) -> PdfDocument raise 
    PdfError

    Set a named page box on selected pages from a page-indexed (x, y, width,height) list.

    This ports cpdf's crop_pdf. By default it writes /CropBox; box_name can target another page-box dictionary entry. The selected pages use boxes[page_number - 1].

    PdfDocument::debug_objects

    source
    fn PdfDocument::debug_objects(self : PdfDocument) -> Bytes raise 
    PdfError

    Render the CamlPDF-style object dump used by cpdf debugging tools.

    The result is byte-oriented because PDF names, strings, and stream bodies are byte sequences in both CamlPDF and this package. Returning bytes also keeps tests exact without relying on stdout capture.

    PdfDocument::decompress

    source

    Decode supported filter stages from every parsed stream in the document.

    Encrypted documents are left unchanged. Unsupported filters are preserved with their remaining encoded bytes, matching pdf_decode_stream_until_unknown.

    PdfDocument::decrypt_single_stream

    source
    fn PdfDocument::decrypt_single_stream(self : PdfDocument, object_number : Int, generation : Int, stream : PdfObject, user_password? : BytesView?, owner_password? : BytesView?, no_encrypt_metadata? : Bool) -> PdfObject? raise 
    PdfError

    Decrypt one encrypted stream object with available passwords.

    Unencrypted documents return stream unchanged. Encrypted documents return None when no supplied password authenticates. The caller supplies the stream object's number and generation because object keys depend on them.

    PdfDocument::decrypt_with_owner_password

    source
    fn PdfDocument::decrypt_with_owner_password(self : PdfDocument, password : BytesView, no_encrypt_metadata? : Bool) -> PdfDecryptionResult? raise 
    PdfError

    Decrypt with an owner password only.

    Unencrypted documents return a copied document and empty denied permissions. Encrypted documents return None when the owner password does not authenticate.

    PdfDocument::decrypt_with_passwords

    source
    fn PdfDocument::decrypt_with_passwords(self : PdfDocument, user_password? : BytesView?, owner_password? : BytesView?, no_encrypt_metadata? : Bool) -> PdfDecryptionResult? raise 
    PdfError

    Decrypt this document using optional user and owner passwords.

    If the document is not encrypted, a copied document and empty permissions list are returned. If it is encrypted and no password works, the result is None; malformed encryption data still raises PdfError.

    PdfDocument::decrypt_with_user_password

    source
    fn PdfDocument::decrypt_with_user_password(self : PdfDocument, password : BytesView, no_encrypt_metadata? : Bool) -> PdfDecryptionResult? raise 
    PdfError

    Decrypt with a user password only.

    Unencrypted documents return a copied document and empty denied permissions. Encrypted documents return None when the user password does not authenticate.

    PdfDocument::determine_subformats

    source
    fn PdfDocument::determine_subformats(self : PdfDocument) -> Array[String] raise 
    PdfError

    Determine PDF/A, PDF/E, PDF/UA, PDF/VT, and PDF/X subformat markers.

    This ports cpdf's in-memory subformat detection. It recognizes simple XMP element and attribute forms and falls back to /Info /GTS_PDFXVersion.

    PdfDocument::dict_entries_json

    source
    fn PdfDocument::dict_entries_json(self : PdfDocument, key : 
    PdfName    , utf8? : Bool) -> Bytes raise 
    PdfError

    Return dictionary entry values in cpdf-style JSON format.

    PdfDocument::dict_entry_rendered_values

    source

    Render dictionary entry values as PDF object syntax.

    This is the side-effect-free native equivalent of cpdf's print_dict_entry.

    PdfDocument::dict_entry_values

    source

    Return resolved values for dictionary entries named key.

    Traversal mirrors cpdf's dictionary-entry reporting helpers: direct nested dictionaries, arrays, stream dictionaries, all parsed document objects, and the trailer are scanned. The matching value itself is resolved through the document object table.

    PdfDocument::direct

    source
    fn PdfDocument::direct(self : PdfDocument, object : PdfObject) -> PdfObject

    Resolve an object through the document object table.

    Direct objects are returned unchanged. Indirect references are followed recursively through parsed entries in self.objects; missing, unparsed, or excessively deep references resolve to PdfNull rather than raising.

    PdfDocument::draft

    source
    fn PdfDocument::draft(self : PdfDocument, only_remove : 
    PdfName    ?, boxes : Bool, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove image XObjects and inline images from selected pages.

    When only_remove is present, only matching image XObject invocations are removed and inline images are retained. When boxes is true, removed images are replaced by a crossed unit box, matching cpdf's draft mode.

    PdfDocument::draw

    source
    fn PdfDocument::draw(self : PdfDocument, page_numbers : ArrayView[Int], drawops : ArrayView[PdfDrawOp], struct_tree? : Bool, fast? : Bool, underneath? : Bool, filename? : String, bates? : Int, bates_pad? : Int?, time? : PdfStrftimeTime?, add_artifacts? : Bool, role_map? : String) -> PdfDocument raise 
    PdfError

    Draw cpdf draw operations on selected pages.

    This ports the page orchestration from cpdfdraw.ml: draw operations are split around PdfDrawNewPage, selected page ranges are advanced or padded between chunks, resources are merged into page resources, manual artifact back-channel markers are fixed before writing content, and struct_tree writes a fresh structure tree from rendered MCIDs only when the document has cpdf's fresh /StructTreeRoot placeholder. If a real structure tree is already present, or no fresh placeholder exists, requested structure mode artifacts the drawn content instead of replacing the tree. When role_map is not empty, it is parsed as the body of a PDF role-map dictionary and attached to the generated /StructTreeRoot.

    PdfDocument::draw_special_text_context

    source
    fn PdfDocument::draw_special_text_context(self : PdfDocument, page_number : Int, filename? : String, bates? : Int, bates_pad? : Int?, time? : PdfStrftimeTime?) -> PdfDrawSpecialTextContext raise 
    PdfError

    Build cpdf draw special-text context for one page of a document.

    PdfDocument::encrypt_128bit

    source
    fn PdfDocument::encrypt_128bit(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with the revision-3 128-bit ARC4 handler.

    denied_permissions is converted to the PDF /P mask. file_id can be supplied for deterministic output; when omitted, a generated file ID is added as needed.

    PdfDocument::encrypt_128bit_aesv2

    source
    fn PdfDocument::encrypt_128bit_aesv2(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with revision-4 AESV2 using native randomness.

    Fresh random IVs are generated for encrypted strings and streams. When file_id is empty, a random 16-byte first trailer ID is generated before deriving the encryption key.

    PdfDocument::encrypt_128bit_aesv2_with_iv_provider

    source
    fn PdfDocument::encrypt_128bit_aesv2_with_iv_provider(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with revision-4 AESV2.

    iv_provider supplies per-object 16-byte CBC IVs by object number, generation, and IV index. This makes tests reproducible while allowing production callers to provide secure random IVs.

    PdfDocument::encrypt_128bit_r4

    source
    fn PdfDocument::encrypt_128bit_r4(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with revision-4 128-bit ARC4.

    This writes a crypt-filter dictionary using /V2. encrypt_metadata=false follows the revision-4 no-metadata key derivation and stream policy.

    PdfDocument::encrypt_256bit_aesv3

    source
    fn PdfDocument::encrypt_256bit_aesv3(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], iso? : Bool, encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with AESV3/AES-256 using native randomness.

    Native random bytes supply the file key, salts, permissions padding, and per-object IVs. Set iso=true for the ISO/PDF 2.0 AESV3 hash variant.

    PdfDocument::encrypt_256bit_aesv3_iso

    source
    fn PdfDocument::encrypt_256bit_aesv3_iso(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with the ISO AESV3/AES-256 variant.

    This is the native-random convenience wrapper for encrypt_256bit_aesv3 with iso=true.

    PdfDocument::encrypt_256bit_aesv3_iso_with_providers

    source
    fn PdfDocument::encrypt_256bit_aesv3_iso_with_providers(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], random_provider : (
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    , iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with the ISO AESV3/AES-256 variant.

    This is a convenience wrapper around encrypt_256bit_aesv3_with_providers with iso=true.

    PdfDocument::encrypt_256bit_aesv3_with_providers

    source
    fn PdfDocument::encrypt_256bit_aesv3_with_providers(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], random_provider : (
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    , iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , iso? : Bool, encrypt_metadata? : Bool, file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with AESV3/AES-256 security.

    random_provider supplies the file key, salts, and permissions padding; iv_provider supplies CBC IVs for encrypted strings and streams. iso=true selects the ISO/PDF 2.0 hash variant.

    PdfDocument::encrypt_40bit

    source
    fn PdfDocument::encrypt_40bit(self : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], file_id? : BytesView) -> PdfDocument raise 
    PdfError

    Encrypt a copy of the document with the revision-2 40-bit ARC4 handler.

    denied_permissions is converted to the PDF /P mask. file_id can be supplied for deterministic output; when omitted, the document gets a CamlPDF-style generated file ID.

    PdfDocument::endpage

    source

    Return the number of pages by walking the page tree.

    PdfDocument::endpage_fast

    source

    Return the root page-tree /Count value without validating child pages.

    Missing or malformed counts return 0.

    PdfDocument::event_log

    source
    fn PdfDocument::event_log(self : PdfDocument) -> Array[(Int, PdfObjectEvent)]

    Return a copy of the document object mutation log.

    PdfDocument::extract_fontfile_bytes

    source
    fn PdfDocument::extract_fontfile_bytes(self : PdfDocument, page_number : Int, font_name : String) -> Bytes? raise 
    PdfError

    Return decoded embedded font-file bytes for a named page font, if present.

    This is the in-memory counterpart to cpdf's extract_fontfile, which writes the decoded font program to a path. Missing names or fonts without embedded font programs return None; malformed font dictionaries or font-file stream objects raise through the normal PDF error path.

    PdfDocument::extract_struct_tree

    source
    fn PdfDocument::extract_struct_tree(self : PdfDocument) -> Json raise 
    PdfError

    Extract the PDF/UA structure-tree object graph as cpdf-style CPDFJSON.

    PdfDocument::find_object_by_spec

    source
    fn PdfDocument::find_object_by_spec(self : PdfDocument, spec : String) -> PdfObject raise 
    PdfError

    Find an object using cpdf's object-spec grammar.

    "" selects the trailer dictionary, /A/B follows a trailer-rooted chain, 4/A follows a chain from object 4, and P1/A follows a chain from the first page object.

    PdfDocument::first_xref

    source
    fn PdfDocument::first_xref(self : PdfDocument) -> Int

    Return the byte offset of the first xref section read from the input.

    PdfDocument::flip_pages_horizontally

    source
    fn PdfDocument::flip_pages_horizontally(self : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Flip selected pages horizontally around the horizontal centre of each page's /MediaBox.

    This ports cpdf's hflip_pdf: page content, annotations, pattern matrices, and destination coordinates are transformed, while page boxes are left unchanged.

    PdfDocument::flip_pages_vertically

    source
    fn PdfDocument::flip_pages_vertically(self : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Flip selected pages vertically around the vertical centre of each page's /MediaBox.

    This ports cpdf's vflip_pdf: page content, annotations, pattern matrices, and destination coordinates are transformed, while page boxes are left unchanged.

    PdfDocument::font_from_name

    source
    fn PdfDocument::font_from_name(self : PdfDocument, font_name : String, page_number : Int) -> PdfObject raise 
    PdfError

    Resolve a cpdf font name path on a page.

    font_name is the name shown by list_fonts, such as /F1 for a page font or /Fm/FX for a font inside a Form XObject. Valid pages whose path is not found return PdfNull.

    PdfDocument::font_table

    source
    fn PdfDocument::font_table(self : PdfDocument, font_name : String, page_number : Int) -> Array[PdfFontTableEntry] raise 
    PdfError

    Return cpdf's font encoding table rows for one named page font.

    This is the in-memory counterpart to cpdf's print_font_table. Font names use the same page resource path syntax as font_from_name, such as /F1.

    PdfDocument::font_table_text

    source
    fn PdfDocument::font_table_text(self : PdfDocument, font_name : String, page_number : Int) -> Bytes raise 
    PdfError

    Render cpdf's plain-text font encoding table for one named page font.

    PdfDocument::fonts_json

    source
    fn PdfDocument::fonts_json(self : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Return cpdf's JSON font listing for selected pages.

    PdfDocument::fonts_json_blob

    source
    fn PdfDocument::fonts_json_blob(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Return cpdf's JSON font listing as UTF-8 JSON bytes.

    PdfDocument::get_annotations

    source
    fn PdfDocument::get_annotations(self : PdfDocument, encoding? : PdfMetadataEncoding) -> Array[(Int, Bytes)] raise 
    PdfError

    Return old-style annotation contents as (page_number, contents) pairs.

    Every annotation entry contributes one pair. Annotations without /Contents contribute an empty byte string, matching cpdf's old list behavior.

    PdfDocument::get_image_24bpp

    source
    fn PdfDocument::get_image_24bpp(self : PdfDocument, resources : PdfObject, image : PdfObject) -> PdfImage raise 
    PdfError

    Extract an image as either encoded image bytes or 24bpp RGB data.

    DCT/JPEG, JPX/JPEG2000, and JBIG2 streams are returned still encoded. Other supported image streams are decoded, have supported /Decode arrays applied, and are converted to PdfRawImage(width, height, PdfBPP24, data) where data is RGBRGB byte order.

    PdfDocument::get_number

    source
    fn PdfDocument::get_number(self : PdfDocument, object : PdfObject) -> Double raise 
    PdfError

    Read a PDF numeric object as a Double.

    The object is resolved first. PDF real numbers are returned directly and PDF integers are widened to Double; any other object raises PdfError::NumberExpected.

    PdfDocument::hard_box

    source
    fn PdfDocument::hard_box(self : PdfDocument, page_numbers : ArrayView[Int], box_name : 
    PdfName    , mediabox_if_missing? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Hard-clip selected pages to a page box by prepending a clipping rectangle.

    page_numbers are 1-based. box_name is usually /MediaBox, /CropBox, /TrimBox, /ArtBox, or /BleedBox. Missing non-media boxes raise unless mediabox_if_missing is true. In fast mode the clip stream is prepended without parsing existing content.

    PdfDocument::has_page_box

    source
    fn PdfDocument::has_page_box(self : PdfDocument, page_number : Int, box_name : 
    PdfName    ) -> Bool raise 
    PdfError

    Return whether a 1-based page has a named non-media page box.

    This mirrors cpdf's hasbox: invalid page numbers raise, and the check is performed against the page's explicit dictionary entries rather than treating /MediaBox as always present.

    PdfDocument::image_bits_per_component

    source
    fn PdfDocument::image_bits_per_component(self : PdfDocument, image : PdfObject) -> PdfObject?

    Return an image's /BitsPerComponent or abbreviated /BPC entry.

    Image masks default to 1 when no explicit value is present. The raw object is returned to preserve the PDF representation.

    PdfDocument::image_colour_space

    source
    fn PdfDocument::image_colour_space(self : PdfDocument, image : PdfObject, resources : PdfObject) -> PdfColourSpace raise 
    PdfError

    Read an image XObject colour space.

    /ImageMask true images are treated as PdfDeviceGray. Otherwise this reads /ColorSpace or /CS, resolving named spaces through resources.

    PdfDocument::image_resolution

    source
    fn PdfDocument::image_resolution(self : PdfDocument, page_numbers : ArrayView[Int], dpi : Double, inline? : Bool) -> Array[(Int, String, Int, Int, Double, Double, Int)] raise 
    PdfError

    Report image resolutions for selected pages.

    Results match cpdf's tuple order: page number, XObject name, image width, image height, horizontal DPI, vertical DPI, and object number. Entries are kept when either axis is below dpi.

    PdfDocument::image_resolution_json

    source
    fn PdfDocument::image_resolution_json(self : PdfDocument, page_numbers : ArrayView[Int], dpi : Double, inline? : Bool) -> Json raise 
    PdfError

    Report image resolution data as cpdf-style JSON rows.

    PdfDocument::image_resolution_json_blob

    source
    fn PdfDocument::image_resolution_json_blob(self : PdfDocument, page_numbers : ArrayView[Int], dpi : Double, inline? : Bool) -> Bytes raise 
    PdfError

    Report image resolution data as UTF-8 JSON bytes.

    PdfDocument::images_json

    source
    fn PdfDocument::images_json(self : PdfDocument, page_numbers : ArrayView[Int], inline? : Bool) -> Json raise 
    PdfError

    List image XObjects referenced by selected pages as cpdf-style JSON rows.

    PdfDocument::images_json_blob

    source
    fn PdfDocument::images_json_blob(self : PdfDocument, page_numbers : ArrayView[Int], inline? : Bool) -> Bytes raise 
    PdfError

    List image XObjects referenced by selected pages as UTF-8 JSON bytes.

    PdfDocument::impose

    source
    fn PdfDocument::impose(self : PdfDocument, x : Double, y : Double, fit? : Bool, columns? : Bool, rtl? : Bool, btt? : Bool, center? : Bool, margin? : Double, spacing? : Double, line_width? : Double, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Impose pages into cpdf-style sheets.

    In non-fit mode, x and y are grid dimensions; one of them may be zero to stack all pages in the other direction. In fit mode, x and y are the output page width and height, and the grid is calculated from the current page size.

    PdfDocument::indirect_number

    source
    fn PdfDocument::indirect_number(self : PdfDocument, key : 
    PdfName    , object : PdfObject) -> Int?

    Return the indirect object number stored under a dictionary key.

    The containing object is resolved before lookup, but the entry itself is inspected before dereferencing. This returns Some(number) only when the immediate entry value is PdfIndirect(number).

    PdfDocument::info_json

    source

    Return cpdf-style document information report fields as JSON.

    PdfDocument::info_json_blob

    source

    Return cpdf-style document information report fields as UTF-8 JSON bytes.

    PdfDocument::info_utf8

    source
    fn PdfDocument::info_utf8(self : PdfDocument, key : 
    PdfName    ) -> String

    Return one /Info dictionary entry as a UTF-8 string.

    PdfDocument::is_cidkeyed_font

    source
    fn PdfDocument::is_cidkeyed_font(self : PdfDocument, font : PdfObject) -> Bool

    Return true if a font dictionary is a Type 0 CID-keyed font.

    PdfDocument::is_encrypted

    source
    fn PdfDocument::is_encrypted(self : PdfDocument) -> Bool

    Return true when the trailer contains an /Encrypt entry.

    PdfDocument::is_missing_font

    source
    fn PdfDocument::is_missing_font(self : PdfDocument, font : PdfObject) -> Bool

    Return whether a font dictionary has no embedded font program.

    Type 3 fonts are never reported as missing, matching cpdf. Other fonts are missing when they have no /FontDescriptor, or when their descriptor lacks /FontFile, /FontFile2, and /FontFile3.

    PdfDocument::is_simple_font

    source
    fn PdfDocument::is_simple_font(self : PdfDocument, font : PdfObject) -> Bool

    Return true if a font dictionary has a simple-font subtype.

    PdfDocument::is_standard14_font

    source
    fn PdfDocument::is_standard14_font(self : PdfDocument, font : PdfObject) -> Bool

    Return true if a font dictionary is an unembedded standard 14 font.

    A matching Type1 or TrueType /BaseFont without explicit /Widths is treated as a standard-font dictionary.

    PdfDocument::is_xfa

    source
    fn PdfDocument::is_xfa(self : PdfDocument) -> Bool

    Return true when the catalog contains an AcroForm XFA entry.

    PdfDocument::iter_objects

    source
    fn PdfDocument::iter_objects(self : PdfDocument, callback : (Int, PdfObject) -> Unit raise) -> Unit raise

    Iterate over parsed objects in object-number order.

    The callback receives (number, object). Errors raised by the callback propagate to the caller.

    PdfDocument::iter_objects_in_order

    source
    fn PdfDocument::iter_objects_in_order(self : PdfDocument, callback : (Int, PdfObject) -> Unit raise) -> Unit raise

    Iterate over parsed objects in object-number order.

    This is the explicit-order variant used by iter_objects.

    PdfDocument::iter_objects_with_generation

    source
    fn PdfDocument::iter_objects_with_generation(self : PdfDocument, callback : (Int, Int, PdfObject) -> Unit raise) -> Unit raise

    Iterate over parsed objects with their generation numbers.

    The callback receives (number, generation, object) in object-number order, and any callback error is propagated.

    PdfDocument::iter_pages

    source
    fn PdfDocument::iter_pages(self : PdfDocument, page_numbers : ArrayView[Int], process : (Int, PdfPage) -> Unit raise 
    PdfError    ) -> Unit raise 
    PdfError

    Iterate over selected pages in document order.

    Page numbers outside the document are ignored.

    PdfDocument::iter_stream

    source
    fn PdfDocument::iter_stream(self : PdfDocument, callback : (PdfObject) -> Unit raise) -> Unit raise

    Iterate over parsed stream objects in object-number order.

    The callback receives the stream as a PdfObject so callers can use the same object-level helpers as for values read from arrays or dictionaries.

    PdfDocument::json_of_document

    source
    fn PdfDocument::json_of_document(self : PdfDocument, utf8? : Bool, parse_content? : Bool, clean_strings? : Bool, no_stream_data? : Bool, decompress_streams? : Bool) -> Json raise 
    PdfError

    Convert an in-memory document to CPDFJSON format with stream data included.

    This ports the basic document-output shape from cpdf's json_of_pdf: object -1 carries CPDFJSON metadata, object 0 carries the trailer, and positive object numbers reachable from the trailer or stored root are emitted in ascending order. When parse_content is set, page /Contents streams plus referenced Form XObject and Pattern streams are emitted as cpdf-style operation arrays, after multi-stream pages are precombined on a prepared copy of the document. When clean_strings is set for non-UTF8 output, UTF-16BE strings in positive objects are simplified while the trailer dictionary is left unchanged to match cpdf's /ID precaution. When no_stream_data is set, ordinary stream data is elided and CPDFJSON metadata records that omission. When decompress_streams is set, positive object streams are decoded through supported filters until the first unknown filter.

    PdfDocument::json_of_object

    source
    fn PdfDocument::json_of_object(self : PdfDocument, object : PdfObject, utf8? : Bool, clean_strings? : Bool, no_stream_data? : Bool, parse_content? : Bool) -> Json raise 
    PdfError

    Convert a single PDF object to CPDFJSON format.

    This exposes the single-object output side of cpdf's cpdfjson conversion. clean_strings mirrors cpdf's deprecated -output-json-clean-strings behavior for non-UTF8 output, and no_stream_data emits cpdf's stream-data elision placeholder. When parse_content is set, /FunctionType streams are decoded before output, matching cpdf's single-object parse-content behavior. Full document CPDFJSON import/export and parsed content-stream encoding are handled by json_of_document.

    PdfDocument::language

    source
    fn PdfDocument::language(self : PdfDocument) -> Bytes?

    Return the catalog /Lang value, if present.

    PdfDocument::list_annotations

    source
    fn PdfDocument::list_annotations(self : PdfDocument, page_numbers : ArrayView[Int], encoding? : PdfMetadataEncoding) -> Bytes raise 
    PdfError

    Render cpdf's old-style annotation listing for selected pages.

    Unlike get_annotations, this suppresses empty /Contents entries and returns the bytes cpdf would print instead of writing to stdout.

    PdfDocument::list_attached_files

    source

    List document-level and page-level file attachments.

    PdfDocument::list_bookmarks

    source
    fn PdfDocument::list_bookmarks(self : PdfDocument, page_numbers : ArrayView[Int], encoding? : PdfMetadataEncoding, json? : Bool, json_preserve_actions? : Bool) -> Bytes raise 
    PdfError

    Render cpdf's bookmark listing for selected pages.

    Text output matches cpdf's line-oriented bookmark format. When json is set, this returns UTF-8 JSON bytes for the same filtered bookmark set.

    PdfDocument::list_fonts

    source

    Return cpdf's font resource listing for selected pages.

    The listing walks page /Resources dictionaries and nested Form XObject resources. Duplicate indirect XObjects are processed once per call, matching cpdf's intended "do not process an xobject twice" behavior.

    PdfDocument::list_fonts_text

    source
    fn PdfDocument::list_fonts_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Render cpdf's plain-text font listing for selected pages.

    PdfDocument::list_spot_colours

    source

    Return spot colourant names from top-level /Separation colour-space objects.

    This follows cpdf's list_spot_colours scan: it iterates document objects and reports arrays whose first entry is /Separation; nested arrays inside dictionaries are not recursively scanned by this helper.

    PdfDocument::lookup_chain

    source

    Follow a sequence of dictionary keys and array pseudo-keys.

    Lookup starts from start; every successful step resolves indirect objects. An empty key sequence returns Some(start). If any step cannot be resolved, the result is None.

    PdfDocument::lookup_direct

    source

    Look up key in a dictionary or stream dictionary and resolve the value.

    The containing object is first passed through direct. If the object is not dictionary-like, the key is absent, or the resolved value is PdfNull, this returns None.

    PdfDocument::lookup_direct_or_array

    source
    fn PdfDocument::lookup_direct_or_array(self : PdfDocument, name : 
    PdfName    , object : PdfObject) -> PdfObject?

    Look up a dictionary entry, or address an array by a pseudo-key.

    Names that begin with /[ followed by decimal digits are treated as array indexes when object is a PdfArray; other names are resolved with lookup_direct. The returned value is resolved through direct.

    PdfDocument::lookup_direct_or_else

    source
    fn PdfDocument::lookup_direct_or_else(self : PdfDocument, first_key : 
    PdfName    , second_key : 
    PdfName    , object : PdfObject) -> PdfObject?

    Look up either of two alternative dictionary keys.

    first_key is preferred. second_key is checked only when the first lookup is absent or resolves to PdfNull.

    PdfDocument::lookup_object_or_null

    source
    fn PdfDocument::lookup_object_or_null(self : PdfDocument, number : Int) -> PdfObject

    Return a parsed object by number, or PdfNull if it is absent or deferred.

    PdfDocument::lookup_required

    source

    Look up a required dictionary entry and resolve the value.

    This is the raising counterpart to lookup_direct: it raises the caller supplied error when the containing object is not dictionary-like, when the key is absent, or when the resolved value is PdfNull.

    PdfDocument::map_objects_in_place

    source
    fn PdfDocument::map_objects_in_place(self : PdfDocument, transform : (PdfObject) -> PdfObject) -> Unit

    Transform every parsed document object in place.

    Deferred entries remain deferred and are not passed to transform.

    PdfDocument::map_pages

    source
    fn[T] PdfDocument::map_pages(self : PdfDocument, page_numbers : ArrayView[Int], process : (Int, PdfPage) -> T raise 
    PdfError    ) -> Array[T] raise 
    PdfError

    Map selected pages in document order.

    Page numbers outside the document are ignored.

    PdfDocument::mark_all_as_artifact

    source

    Mark every page content stream and referenced Form XObject as a PDF/UA artifact.

    PdfDocument::mark_info_item

    source
    fn PdfDocument::mark_info_item(self : PdfDocument, key : 
    PdfName    ) -> Bool

    Return a /MarkInfo boolean item, or false when absent/malformed.

    PdfDocument::mark_pdfua1

    source

    Return a copy of the document marked as PDF/UA-1 in its XMP metadata.

    PdfDocument::mark_pdfua2

    source
    fn PdfDocument::mark_pdfua2(self : PdfDocument, year : Int) -> PdfDocument raise 
    PdfError

    Return a copy of the document marked as PDF/UA-2 for the given revision year.

    PdfDocument::merge_content_streams

    source
    fn PdfDocument::merge_content_streams(self : PdfDocument) -> Unit raise 
    PdfError

    Merge multi-stream page contents into single decoded streams.

    Only page-like objects with /Resources are considered. The document is mutated in place and stream filters are decoded before concatenation.

    PdfDocument::merge_name_trees_no_clash

    source
    fn PdfDocument::merge_name_trees_no_clash(self : PdfDocument, trees : ArrayView[PdfObject]) -> PdfObject

    Merge several name trees when the caller guarantees there are no clashes.

    Entries are read from every input tree and rebuilt into a single sorted name tree. This function does not report duplicate keys; callers that require conflict handling should check the inputs before calling it.

    PdfDocument::merge_number_trees_no_clash

    source
    fn PdfDocument::merge_number_trees_no_clash(self : PdfDocument, trees : ArrayView[PdfObject]) -> PdfObject

    Merge several number trees when the caller guarantees there are no clashes.

    Entries are read from every input tree and rebuilt into a single sorted number tree. Duplicate-key handling follows the read/build helpers and is not reported as an error.

    PdfDocument::metadata

    source

    Extract the catalog metadata XML stream, decoding supported stream filters.

    PdfDocument::missing_fonts

    source

    Return cpdf's missing-font report for selected pages.

    This follows cpdf's current behavior by inspecting page /Font resources and descendant fonts. It does not recurse into Form XObjects; the cpdf source marks that as a separate FIXME.

    PdfDocument::missing_fonts_text

    source
    fn PdfDocument::missing_fonts_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Render cpdf's plain-text missing-font report for selected pages.

    PdfDocument::name_tree_lookup

    source
    fn PdfDocument::name_tree_lookup(self : PdfDocument, key : BytesView, tree : PdfObject) -> PdfObject?

    Look up a byte-string key in a PDF name tree.

    The BytesView key is copied into an owned PdfString because PDF objects own their byte storage. Prefer this method when the key is already available as PDF-encoded bytes.

    PdfDocument::name_tree_lookup_object

    source
    fn PdfDocument::name_tree_lookup_object(self : PdfDocument, key : PdfObject, tree : PdfObject) -> PdfObject?

    Look up a raw key object in a PDF name tree or number tree.

    /Limits entries are used to skip child nodes when they are comparable with key. The lookup accepts both direct leaf arrays and nested /Kids nodes, returning None for malformed nodes or missing keys.

    PdfDocument::number_tree_lookup

    source
    fn PdfDocument::number_tree_lookup(self : PdfDocument, key : Int, tree : PdfObject) -> PdfObject?

    Look up an integer key in a PDF number tree.

    PdfDocument::object_count

    source
    fn PdfDocument::object_count(self : PdfDocument) -> Int

    Return the number of entries in the document object table.

    PdfDocument::object_numbers

    source
    fn PdfDocument::object_numbers(self : PdfDocument) -> Array[Int]

    Return document object numbers in ascending order.

    PdfDocument::ocg_coalesce

    source

    Return a copy with same-named optional-content groups coalesced.

    The first group for each raw PDF name is kept. Duplicate group references in optional-content metadata and parsed document objects are rewritten to the kept object number, and duplicate OCG objects are removed.

    PdfDocument::ocg_get_list

    source
    fn PdfDocument::ocg_get_list(self : PdfDocument) -> Array[Bytes] raise 
    PdfError

    Return the raw PDF string names of catalog optional-content groups.

    This mirrors cpdf's ocg_get_list: missing optional-content metadata yields an empty list, and malformed individual group entries are skipped.

    PdfDocument::ocg_list_json

    source

    Return cpdf's optional-content group JSON listing.

    PdfDocument::ocg_list_json_blob

    source
    fn PdfDocument::ocg_list_json_blob(self : PdfDocument) -> Bytes raise 
    PdfError

    Return cpdf's optional-content group JSON listing as UTF-8 JSON bytes.

    PdfDocument::ocg_order_all

    source

    Return a copy of the document with every OCG listed in the default /Order.

    Documents without optional-content properties, without /OCGs, or without a default /D dictionary are returned unchanged.

    PdfDocument::ocg_rename

    source
    fn PdfDocument::ocg_rename(self : PdfDocument, old_name : Bytes, new_name : Bytes) -> PdfDocument

    Return a copy of the document with matching optional-content group names replaced.

    PdfDocument::ocg_replace_json

    source

    Return a copy with catalog /OCProperties replaced from cpdf OCG JSON.

    PdfDocument::open_action

    source

    Return the catalog /OpenAction in cpdf's reporting form.

    Destination arrays beginning with a page indirect reference are rewritten to one-based page numbers. For GoTo action dictionaries with /D, the destination is returned; other action objects are returned unchanged.

    PdfDocument::open_action_json_blob

    source
    fn PdfDocument::open_action_json_blob(self : PdfDocument) -> Bytes raise 
    PdfError

    Return the catalog /OpenAction as cpdf-style JSON bytes.

    PdfDocument::open_action_string

    source
    fn PdfDocument::open_action_string(self : PdfDocument) -> String raise 
    PdfError

    Return the catalog /OpenAction as cpdf-style PDF syntax.

    PdfDocument::pad_after

    source
    fn PdfDocument::pad_after(self : PdfDocument, page_numbers : ArrayView[Int], pad_with? : PdfDocument?) -> PdfDocument raise 
    PdfError

    Insert blank pages or pages from pad_with after selected one-based pages.

    PdfDocument::pad_before

    source
    fn PdfDocument::pad_before(self : PdfDocument, page_numbers : ArrayView[Int], pad_with? : PdfDocument?) -> PdfDocument raise 
    PdfError

    Insert blank pages or pages from pad_with before selected one-based pages.

    PdfDocument::pad_to_multiple

    source
    fn PdfDocument::pad_to_multiple(self : PdfDocument, multiple : Int) -> PdfDocument raise 
    PdfError

    Pad a document to a page count that is a multiple of multiple.

    Positive multiples append blank pages. Negative multiples prepend them. A multiple of zero is invalid.

    PdfDocument::page_content_json

    source
    fn PdfDocument::page_content_json(self : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Return cpdf's page-content JSON array for selected 1-based page numbers.

    PdfDocument::page_info_json

    source

    Return cpdf's page-info JSON array for selected 1-based page numbers.

    PdfDocument::page_info_json_blob

    source
    fn PdfDocument::page_info_json_blob(self : PdfDocument, page_numbers : ArrayView[Int], unit? : 
    PdfUnit    ) -> Bytes raise 
    PdfError

    Return cpdf's page-info JSON array as UTF-8 bytes.

    PdfDocument::page_info_text

    source
    fn PdfDocument::page_info_text(self : PdfDocument, page_numbers : ArrayView[Int], unit? : 
    PdfUnit    ) -> Bytes raise 
    PdfError

    Render cpdf's plain-text page-info report for selected pages.

    PdfDocument::page_number_of_target

    source
    fn PdfDocument::page_number_of_target(self : PdfDocument, destination : PdfDestination) -> Int raise 
    PdfError

    Resolve a destination target to a 1-based page number.

    PdfDocument::page_object_number

    source
    fn PdfDocument::page_object_number(self : PdfDocument, page_number : Int) -> Int? raise 
    PdfError

    Return the object number for a 1-based page number.

    Out-of-range page numbers return None.

    PdfDocument::page_reference_numbers

    source
    fn PdfDocument::page_reference_numbers(self : PdfDocument) -> Array[Int] raise 
    PdfError

    Return page object numbers in page-tree order.

    PdfDocument::pages_of_pagetree

    source

    Read the document page tree into PdfPage records.

    Inherited resources, media boxes, crop boxes, and rotation are resolved while walking the tree. Malformed page-tree structure raises PdfError.

    PdfDocument::pages_of_pagetree_quick

    source
    fn PdfDocument::pages_of_pagetree_quick(self : PdfDocument) -> Int raise 
    PdfError

    Count pages by walking the page tree without materializing PdfPage records.

    PdfDocument::parse_bookmark_json

    source
    fn PdfDocument::parse_bookmark_json(self : PdfDocument, json : Json, verify? : Bool) -> Array[PdfBookmark] raise 
    PdfError

    Parse cpdf's bookmark JSON array.

    PdfDocument::parse_bookmark_text

    source
    fn PdfDocument::parse_bookmark_text(self : PdfDocument, data : BytesView, verify? : Bool) -> Array[PdfBookmark] raise 
    PdfError

    Parse cpdf's plain text bookmark-file format.

    The input is byte-oriented. Bookmark titles are double-quoted UTF-8 text with cpdf's \\, \", and \n escapes; optional destinations are double-quoted PDF object snippets such as [1 /Fit].

    PdfDocument::parse_cmap

    source

    Decode and parse a CMap stream object in this document.

    The stream is decoded through its first filter, stream-dictionary metadata is merged with parsed metadata, and indirect /UseCMap bases are composed with cycle protection. Malformed or non-stream inputs raise PdfError.

    PdfDocument::parse_content_bytes_with_resources

    source
    fn PdfDocument::parse_content_bytes_with_resources(self : PdfDocument, resources : PdfObject, data : Bytes) -> Array[PdfContentOp] raise 
    PdfError

    Parse content bytes with page resources.

    This is the owned-byte wrapper for parse_content_view_with_resources.

    PdfDocument::parse_content_ops

    source

    Decode and parse a list of content stream objects from this document.

    Each input must resolve to a stream object. Stream filters are decoded before parsing, then the decoded streams are concatenated with whitespace. Use parse_content_ops_with_resources when inline-image length inference needs page resources.

    PdfDocument::parse_content_ops_with_resources

    source
    fn PdfDocument::parse_content_ops_with_resources(self : PdfDocument, resources : PdfObject, streams : ArrayView[PdfObject]) -> Array[PdfContentOp] raise 
    PdfError

    Decode and parse content stream objects with page resources.

    The resource dictionary is used for inline-image color-space component lookup when an unfiltered inline image has no reliable declared length.

    PdfDocument::parse_content_view_with_resources

    source
    fn PdfDocument::parse_content_view_with_resources(self : PdfDocument, resources : PdfObject, data : BytesView) -> Array[PdfContentOp] raise 
    PdfError

    Parse a content byte view with page resources.

    The input view is read directly; returned operators own any byte data they need to keep, such as text strings and inline-image data.

    PdfDocument::parse_coordinate

    source

    PdfDocument::parse_coordinate_rectangle

    source
    fn PdfDocument::parse_coordinate_rectangle(self : PdfDocument, text : String) -> PdfCoordRectangle raise 
    PdfError

    PdfDocument::parse_coordinate_rectangles

    source
    fn PdfDocument::parse_coordinate_rectangles(self : PdfDocument, text : String) -> Array[PdfCoordRectangle] raise 
    PdfError

    PdfDocument::parse_coordinates

    source

    PdfDocument::parse_function

    source
    fn PdfDocument::parse_function(self : PdfDocument, function_object : PdfObject) -> PdfFunction raise 
    PdfError

    Parse a PDF function object from this document.

    Supports PDF function types 0, 2, 3, and 4. Sampled and calculator functions are read from decoded stream data; interpolation and stitching functions are read from dictionaries. Raises for malformed dictionaries, invalid arities, stream decoding failures, or unsupported function types.

    PdfDocument::parse_matrix

    source

    Read a transformation matrix from a dictionary entry.

    If key is absent, the identity matrix is returned. Present values must be arrays of six numbers in PDF matrix order [a b c d e f]; malformed arrays raise PdfError::MatrixMalformed, and non-numeric entries raise PdfError::NumberExpected.

    PdfDocument::parse_pagespec

    source
    fn PdfDocument::parse_pagespec(self : PdfDocument, spec : String) -> Array[Int] raise 
    PdfError

    PdfDocument::parse_rectangle

    source

    Parse and normalize a PDF rectangle array.

    The input must resolve to an array of four numeric objects. Coordinates are normalized so the result always has lower bounds in min_x/min_y and upper bounds in max_x/max_y. Non-array inputs raise PdfError::RectangleExpected; malformed numeric entries raise PdfError::BadRectangle.

    PdfDocument::parse_single_number

    source
    fn PdfDocument::parse_single_number(self : PdfDocument, text : String) -> Double raise 
    PdfError

    PdfDocument::parse_units_string

    source
    fn PdfDocument::parse_units_string(self : PdfDocument, page : PdfPage, text : String) -> Array[Double] raise 
    PdfError

    PdfDocument::parsed_object_entries

    source
    fn PdfDocument::parsed_object_entries(self : PdfDocument) -> Array[(Int, Int, PdfObject)]

    Return parsed document objects as sorted (number, generation, object) triples.

    PdfDocument::pdf_decode_stream

    source
    fn PdfDocument::pdf_decode_stream(self : PdfDocument, object : PdfObject) -> PdfObject raise 
    PdfError

    Decode all supported filter stages from a stream object in this document.

    Indirect filter and decode-parameter objects are resolved through the document. Unsupported filters raise PdfError::FilterNotSupported.

    PdfDocument::pdf_decode_stream_until_unknown

    source
    fn PdfDocument::pdf_decode_stream_until_unknown(self : PdfDocument, object : PdfObject) -> PdfObject raise 
    PdfError

    Decode supported filter stages until the first unsupported filter.

    The unsupported filter and remaining filters stay in the stream dictionary; malformed supported filters still raise.

    PdfDocument::pdf_decode_streams_until_unknown

    source
    fn PdfDocument::pdf_decode_streams_until_unknown(self : PdfDocument) -> Unit raise 
    PdfError

    Decode supported filter stages on every parsed stream in the document.

    Streams already marked as decrypted stay in that state. Objects are updated in place and logged as altered when their stream data changes.

    PdfDocument::pdf_image_object_of_png_data

    source
    fn PdfDocument::pdf_image_object_of_png_data(self : PdfDocument, data : BytesView) -> PdfObject raise 
    PdfError

    Build a PDF image XObject for PNG data, adding an /SMask object to self when the PNG carries an alpha channel.

    PdfDocument::pdf_object_of_function

    source
    fn PdfDocument::pdf_object_of_function(self : PdfDocument, function : PdfFunction) -> PdfObject

    Build a PDF object for a parsed function.

    Interpolation functions are written as dictionaries. Stitching functions add child function objects to this document and reference them from the returned dictionary. Sampled and calculator variants currently write only the common function dictionary fields and do not recreate their stream data.

    PdfDocument::pdf_of_pages

    source
    fn PdfDocument::pdf_of_pages(self : PdfDocument, page_numbers : ArrayView[Int], retain_numbering? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Extract selected pages into a new document.

    page_numbers are 1-based. Bookmarks, destinations, annotations, and page labels are repaired for the retained pages where possible. retain_numbering preserves original page-label numbering; process_struct_tree trims tagged structure references to deleted pages.

    PdfDocument::pdf_type_typeset

    source
    fn PdfDocument::pdf_type_typeset(self : PdfDocument, process_struct_tree : Bool, lmargin : Double, rmargin : Double, tmargin : Double, bmargin : Double, paper : 
    PaperSize    , elements : ArrayView[PdfTypeElement]) -> PdfTypeTypesetResult raise 
    PdfError

    Typeset cpdftype elements into PDF pages and per-page tag metadata.

    The input stream is numbered, laid out, and paginated before content operators are emitted. The supplied document is mutated only for font and annotation objects; callers can add the returned pages to a page tree.

    PdfDocument::permissions

    source

    Decode the denied permissions from the document encryption dictionary.

    Unencrypted documents return an empty array. Encrypted documents parse /Encrypt and may raise if the encryption dictionary is malformed.

    PdfDocument::portfolio

    source
    fn PdfDocument::portfolio(self : PdfDocument, entries : ArrayView[PdfPortfolioEntry], mod_date? : Bytes?) -> PdfDocument raise 
    PdfError

    Build a PDF portfolio, also known as a PDF collection.

    The original document is left unchanged. mod_date can be supplied for deterministic output; otherwise the current cpdf-style date is used.

    PdfDocument::postpend_operators

    source
    fn PdfDocument::postpend_operators(self : PdfDocument, page : PdfPage, ops : ArrayView[PdfContentOp], fast? : Bool) -> PdfPage raise 
    PdfError

    Append content operators to a page.

    Normal mode parses existing content and wraps it with graphics-state protection before appending ops. fast mode appends a protected new stream without parsing existing content.

    PdfDocument::prepend_operators

    source
    fn PdfDocument::prepend_operators(self : PdfDocument, page : PdfPage, ops : ArrayView[PdfContentOp], fast? : Bool) -> PdfPage raise 
    PdfError

    Prepend content operators to a page.

    In normal mode existing content is parsed and merged into a single stream after ops. In fast mode a new stream is inserted before existing content without parsing the old streams.

    PdfDocument::presentation

    source
    fn PdfDocument::presentation(self : PdfDocument, range : ArrayView[Int], transition : String?, delay : Double?, horizontal : Bool, inward : Bool, direction : Int, effect_duration : Double) -> PdfDocument raise 
    PdfError

    Add presentation transition metadata to the selected 1-based page numbers.

    The accepted transition names match cpdf: Split, Blinds, Box, Wipe, Dissolve, and Glitter. Unknown names raise PdfError::SoftError("Unknown presentation type").

    PdfDocument::process_pages

    source

    Apply a cpdf-style page callback to selected pages.

    The callback returns the replacement page, the page serial whose destinations should be transformed, and the transform matrix. Page numbers outside the document are ignored, matching cpdf's range-membership behavior.

    PdfDocument::process_xobjects

    source

    Process Form XObjects referenced by a page resource dictionary.

    For each indirect /XObject with subtype /Form, process receives the document, page resources, and the form stream. It must return exactly one processed stream, which replaces the original form stream data.

    PdfDocument::read_annotation

    source

    Read one annotation dictionary from this document.

    The annotation object may be direct or indirect. /Rect is required. Popup parents are resolved recursively up to a bounded depth to avoid cycles.

    PdfDocument::read_bookmarks

    source
    fn PdfDocument::read_bookmarks(self : PdfDocument, preserve_actions? : Bool) -> Array[PdfBookmark] raise 
    PdfError

    Read the document outline tree as flattened bookmarks.

    When preserve_actions is false, actions with destinations are resolved to destinations where possible. When it is true, action dictionaries and named destinations are preserved more shallowly for round-tripping.

    PdfDocument::read_cid_system_info

    source
    fn PdfDocument::read_cid_system_info(self : PdfDocument, dictionary : PdfObject) -> PdfCIDSystemInfo raise 
    PdfError

    Read a CID-system-info dictionary.

    Registry and ordering are returned as byte strings, matching PDF string semantics. Missing or malformed required fields raise PdfError.

    PdfDocument::read_cidkeyed_font

    source

    Parse a Type 0 font dictionary into a CID-keyed font.

    This reads the descendant CIDFont, width data, descriptor, base font, and CMap encoding. External CMap streams are parsed when possible while still preserving the referenced stream object number.

    PdfDocument::read_colour_space

    source
    fn PdfDocument::read_colour_space(self : PdfDocument, resources : PdfObject, object : PdfObject) -> PdfColourSpace? raise 
    PdfError

    Parse a colour-space object using the document and resource dictionary.

    The parser resolves resource colour-space names and supports device spaces, pattern spaces with a base space, calibrated Gray/RGB/Lab spaces, ICCBased spaces, Indexed spaces, Separation spaces, and DeviceN spaces. Unsupported or malformed colour spaces return None; malformed numeric fields may raise PdfError.

    PdfDocument::read_destination

    source
    fn PdfDocument::read_destination(self : PdfDocument, object : PdfObject, shallow? : Bool) -> PdfDestination raise 
    PdfError

    Reads and normalizes a PDF destination object.

    When shallow is false, named and string destinations are resolved through the document catalog when possible. Unknown or malformed destination shapes are represented as DestNull.

    PdfDocument::read_encoding

    source

    Read the simple-font encoding from a font dictionary.

    Name encodings are recognized directly. Encoding dictionaries combine /BaseEncoding and /Differences; TrueType encodings additionally fall back to StandardEncoding for undefined entries. Missing or unrecognized encodings use PdfImplicitInFontFile.

    PdfDocument::read_font

    source

    Read any supported PDF font dictionary.

    The result is classified as standard 14, simple, or CID-keyed. A /ToUnicode stream, when present and parseable, is attached to the parsed font so extractors prefer explicit Unicode mappings.

    PdfDocument::read_font_descriptor

    source

    Read the /FontDescriptor dictionary attached to a font.

    Missing descriptors return None. Present descriptors are parsed tolerantly for optional numeric fields, while malformed required shapes such as an invalid /FontBBox still raise through the underlying object readers.

    PdfDocument::read_font_metrics

    source
    fn PdfDocument::read_font_metrics(self : PdfDocument, font : PdfObject) -> Array[Double]? raise 
    PdfError

    Read normalized one-byte font metrics for a simple or Type 3 font.

    The result contains 256 entries when /Widths, /FirstChar, and /LastChar are present and well formed. Missing metrics return None; malformed bounds or width arrays raise the corresponding font error.

    PdfDocument::read_name_tree

    source
    fn PdfDocument::read_name_tree(self : PdfDocument, tree : PdfObject) -> Array[(Bytes, PdfObject)]

    Read all entries from a PDF name tree as sorted byte-string keys.

    Malformed trees whose keys are not PdfString values return an empty array. Well-formed entries are sorted by byte order and duplicate keys are collapsed by the deduplication pass.

    PdfDocument::read_number_tree

    source
    fn PdfDocument::read_number_tree(self : PdfDocument, tree : PdfObject) -> Array[(Int, PdfObject)]

    Read all entries from a PDF number tree as sorted integer keys.

    Malformed trees whose keys are not PdfInteger values return an empty array. Well-formed entries are sorted numerically and duplicate keys are collapsed by the deduplication pass.

    PdfDocument::read_optional_content_groups

    source
    fn PdfDocument::read_optional_content_groups(self : PdfDocument) -> PdfOptionalContent? raise 
    PdfError

    Read catalog /OCProperties from the document.

    Returns None when the catalog has no optional-content properties. When properties are present, OCG entries are returned with their indirect object numbers so callers can preserve or renumber references before writing.

    PdfDocument::read_page_labels

    source

    Read the document catalog /PageLabels number tree.

    The returned start_page values are converted from PDF's zero-based page indexes to the public 1-based page numbering used by this module. Documents without page labels return an empty array.

    PdfDocument::read_simple_font

    source

    Parse a simple-font dictionary.

    Supported subtypes are Type1, MMType1, Type3, and TrueType. The returned value includes optional descriptors, metrics, Type 3 CharProc data, and the resolved simple-font encoding.

    PdfDocument::read_standard14_font

    source

    Read a standard 14 font dictionary.

    The dictionary must contain a recognized /BaseFont; its encoding is read with read_encoding so custom differences are preserved.

    PdfDocument::recompress

    source

    Compress uncompressed streams, and streams using older lossless filters, with /FlateDecode.

    Metadata streams and encrypted documents are left unchanged. The source document is copied before mutation, matching the rest of the high-level pdflite editing APIs.

    PdfDocument::recrypt_with_password

    source
    fn PdfDocument::recrypt_with_password(self : PdfDocument, password : BytesView) -> PdfDocument raise 
    PdfError

    Re-encrypt a previously decrypted document using its saved ARC4 settings.

    The document must have saved encryption state from a successful decrypt. The supplied password is authenticated against that state before the original encryption dictionary shape is restored.

    PdfDocument::recrypt_with_password_aesv2

    source
    fn PdfDocument::recrypt_with_password_aesv2(self : PdfDocument, password : BytesView) -> PdfDocument raise 
    PdfError

    Re-encrypt a decrypted AESV2 document using native random IVs.

    The document must carry saved encryption state from a previous decrypt operation; password is used to recover the file key for re-encryption.

    PdfDocument::recrypt_with_password_aesv2_with_iv_provider

    source
    fn PdfDocument::recrypt_with_password_aesv2_with_iv_provider(self : PdfDocument, password : BytesView, iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    ) -> PdfDocument raise 
    PdfError

    Re-encrypt a decrypted AESV2 document using its saved encryption settings.

    iv_provider supplies fresh IVs for encrypted object data. The saved encryption state determines passwords, permissions, and crypt-filter shape.

    PdfDocument::recrypt_with_password_aesv3

    source
    fn PdfDocument::recrypt_with_password_aesv3(self : PdfDocument, password : BytesView) -> PdfDocument raise 
    PdfError

    Re-encrypt a decrypted AESV3 document using native random IVs.

    The document must carry saved encryption state from a previous decrypt operation; password is used to recover the file key for re-encryption.

    PdfDocument::recrypt_with_password_aesv3_with_iv_provider

    source
    fn PdfDocument::recrypt_with_password_aesv3_with_iv_provider(self : PdfDocument, password : BytesView, iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    ) -> PdfDocument raise 
    PdfError

    Re-encrypt a decrypted AESV3 document using its saved encryption settings.

    iv_provider supplies fresh IVs for encrypted object data. The saved encryption state supplies the existing AESV3 password entries and file key wrapping metadata.

    PdfDocument::rectify_boxes

    source
    fn PdfDocument::rectify_boxes(self : PdfDocument, page : PdfPage, fast? : Bool) -> PdfPage raise 
    PdfError

    Rectify a page so its media-box origin is (0, 0).

    Known page boxes are shifted by the same amount, and page content, annotations, and pattern matrices receive the compensating translation.

    PdfDocument::redact_pages

    source
    fn PdfDocument::redact_pages(self : PdfDocument, page_numbers : ArrayView[Int], process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Redact whole selected pages by emptying their visible content.

    This ports cpdfpage's redact: selected pages keep their page geometry and rotation, but page content, resources, and /Annots are removed. When process_struct_tree is true, structure entries for the redacted pages are trimmed.

    PdfDocument::redact_path

    source
    fn PdfDocument::redact_path(self : PdfDocument, path : ArrayView[(Double, Double)], page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Return a copy of the document after applying cpdf's current path redaction.

    The upstream cpdfredact.redact implementation currently runs the page processor but does not rewrite page content, so this validates the selected page range and preserves the document.

    PdfDocument::referenced_object_numbers

    source
    fn PdfDocument::referenced_object_numbers(self : PdfDocument, object : PdfObject, no_follow_entries? : ArrayView[
    PdfName    ], no_follow_contains? : ArrayView[(
    PdfName    , PdfObject)]) -> Array[Int]

    Returns sorted object numbers reachable from object.

    Indirect references are followed through the document. Dictionary keys in no_follow_entries are skipped, and dictionaries containing any no_follow_contains marker entry are not traversed.

    PdfDocument::remove_added_text

    source
    fn PdfDocument::remove_added_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove text added by cpdf add-text stamping from selected one-based pages.

    PdfDocument::remove_all_metadata

    source

    Remove the catalog metadata entry and every parsed object whose /Type is /Metadata.

    PdfDocument::remove_all_text

    source
    fn PdfDocument::remove_all_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove all text-showing operators from selected one-based pages and their referenced Form XObjects.

    PdfDocument::remove_annotations

    source
    fn PdfDocument::remove_annotations(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Return a copy of the document with /Annots removed from selected pages.

    PdfDocument::remove_art

    source
    fn PdfDocument::remove_art(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove /ArtBox entries from selected pages.

    PdfDocument::remove_attached_files

    source

    Remove document-level embedded files and page-level file attachment annotations.

    The original document is left unchanged. Non-file-attachment annotations are preserved.

    PdfDocument::remove_bleed

    source
    fn PdfDocument::remove_bleed(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove /BleedBox entries from selected pages.

    PdfDocument::remove_bookmarks

    source

    Return a copy of the document with catalog /Outlines removed.

    The original document is not mutated; the returned document has a new root object and trailer root reference.

    PdfDocument::remove_chain

    source

    Remove a nested value along a path rooted at the trailer dictionary.

    Returns true when an entry was removed and false when the path is absent. Empty chains raise PdfError::DictionaryExpected. A single-key chain is treated as an invalid request when the key exists, preserving the trailer root rather than removing one of its direct entries.

    PdfDocument::remove_clipping

    source
    fn PdfDocument::remove_clipping(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove clipping paths from selected one-based pages and their Form XObjects.

    PdfDocument::remove_cropping

    source
    fn PdfDocument::remove_cropping(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove /CropBox entries from selected pages.

    PdfDocument::remove_dict_entry_everywhere

    source
    fn PdfDocument::remove_dict_entry_everywhere(self : PdfDocument, key : 
    PdfName    , search? : PdfObject?) -> Unit

    Remove dictionary entries named key throughout parsed objects and trailer.

    When search is supplied, an entry is removed only when its resolved value equals search. Nested dictionaries, arrays, and stream dictionaries are traversed recursively; deferred document objects are left untouched.

    PdfDocument::remove_duplicate_fonts

    source
    fn PdfDocument::remove_duplicate_fonts(self : PdfDocument) -> Unit

    Removes duplicate embedded font streams from this document.

    Streams are considered duplicates when both their dictionaries and decoded byte payloads match. References to duplicate streams are rewired to the first matching stream and duplicate objects are removed.

    PdfDocument::remove_embedded_fonts

    source

    Return a copy of the document with embedded font-file references removed.

    This ports cpdf's remove_fonts: every parsed /Type /Font dictionary with a /FontDescriptor receives a new descriptor object with /FontFile, /FontFile2, and /FontFile3 removed. The original document and original descriptor objects are left untouched.

    PdfDocument::remove_javascript

    source
    fn PdfDocument::remove_javascript(self : PdfDocument) -> Unit raise 
    PdfError

    Empty /JS strings, empty lowercase javascript: URI strings, and remove the /Root /Names /JavaScript chain.

    PdfDocument::remove_metadata

    source

    Remove the catalog /Metadata entry.

    PdfDocument::remove_object

    source
    fn PdfDocument::remove_object(self : PdfDocument, number : Int) -> Unit

    Remove an object from the document and record a deletion event.

    PdfDocument::remove_object_by_spec

    source
    fn PdfDocument::remove_object_by_spec(self : PdfDocument, spec : String) -> Unit raise 
    PdfError

    Remove an object by decimal object number string.

    PdfDocument::remove_optional_content_groups

    source
    fn PdfDocument::remove_optional_content_groups(self : PdfDocument) -> PdfDocument raise 
    PdfError

    Return a copy of the document with catalog /OCProperties removed.

    The original document is not mutated; the returned document receives a new root object and trailer root reference.

    PdfDocument::remove_page_box

    source

    Remove one page-box dictionary entry from selected pages.

    PdfDocument::remove_page_labels

    source

    Return a copy of the document with catalog /PageLabels removed.

    The original document is not mutated; the returned document has a new root object and trailer root reference.

    PdfDocument::remove_pdfua_mark

    source

    Return a copy of the document with PDF/UA XMP marker fields removed.

    PdfDocument::remove_struct_tree

    source

    Remove the structure tree and marked-content structure operators.

    This ports cpdfpage's remove_struct_tree: /StructTreeRoot, /StructParent, and /StructParents entries are removed throughout the document, and marked-content structure delimiters are stripped from page streams and referenced Form XObjects.

    PdfDocument::remove_trim

    source
    fn PdfDocument::remove_trim(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Remove /TrimBox entries from selected pages.

    PdfDocument::remove_unreferenced

    source
    fn PdfDocument::remove_unreferenced(self : PdfDocument) -> Unit raise 
    PdfError

    Remove objects that are no longer reachable from the trailer or root.

    References to deleted pages are first nulled from destinations and actions. The document is mutated in place.

    PdfDocument::renumber_objects

    source
    fn PdfDocument::renumber_objects(self : PdfDocument, changes : ArrayView[(Int, Int)]) -> PdfDocument raise 
    PdfError

    Return a copy of the document with object numbers remapped.

    changes maps old object numbers to new object numbers; omitted objects keep their original number. All indirect references, the root reference, trailer dictionary, and object-stream metadata are updated. Duplicate or nonpositive target numbers raise PdfError::InvalidObjectNumber.

    PdfDocument::renumber_objects_by_offset

    source
    fn PdfDocument::renumber_objects_by_offset(self : PdfDocument, offset : Int) -> PdfDocument raise 
    PdfError

    Return a copy with every object number increased by offset.

    offset == 0 returns a plain copy. Negative offsets raise PdfError::InvalidObjectNumber.

    PdfDocument::renumber_objects_compact

    source
    fn PdfDocument::renumber_objects_compact(self : PdfDocument) -> PdfDocument raise 
    PdfError

    Return a copy whose objects are numbered compactly from 1 in object order.

    PdfDocument::renumber_pages

    source

    Rename page resources so every page has independent resource names.

    Content streams and inline-image dictionaries are rewritten to use the new names, and each page resource dictionary is updated. This returns new page records; the source document object table is not rewritten.

    PdfDocument::replace_chain

    source

    Replace a value along a path rooted at the document trailer dictionary.

    Each name in chain selects a dictionary entry. Names of the form /[n] select array entries. Missing intermediate dictionary entries are created as nested dictionaries, and indirect intermediate objects are updated in the document object table. Raises when the chain is empty or when a non-container or invalid array position is encountered.

    PdfDocument::replace_dict_entry_everywhere

    source
    fn PdfDocument::replace_dict_entry_everywhere(self : PdfDocument, key : 
    PdfName    , value : PdfObject, search? : PdfObject?) -> Unit

    Replace dictionary entries named key throughout parsed objects and trailer.

    Missing keys are ignored. When search is supplied, only entries whose resolved current value equals search are replaced.

    PdfDocument::replace_inherit

    source
    fn PdfDocument::replace_inherit(self : PdfDocument, object_numbers : ArrayView[Int]) -> Unit raise 
    PdfError

    Materialize inherited page attributes onto page dictionaries.

    For each object number, inherited /MediaBox, /CropBox, /Rotate, and /Resources values are copied onto the page object when available. This is useful before page extraction or object-level rewriting.

    PdfDocument::replace_object_by_spec

    source
    fn PdfDocument::replace_object_by_spec(self : PdfDocument, spec : String, value : PdfObject) -> Unit raise 
    PdfError

    Replace an object using the cpdf object-spec grammar.

    PdfDocument::replace_stream_by_spec

    source
    fn PdfDocument::replace_stream_by_spec(self : PdfDocument, spec : String, data : BytesView) -> Unit raise 
    PdfError

    Replace a stream's bytes while preserving its dictionary except /Length.

    PdfDocument::replace_struct_tree

    source
    fn PdfDocument::replace_struct_tree(self : PdfDocument, json : Json) -> PdfDocument raise 
    PdfError

    Return a copy of the document with structure-tree objects replaced from JSON.

    PdfDocument::reveal_hidden_text

    source
    fn PdfDocument::reveal_hidden_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Reveal hidden text on selected one-based pages and their Form XObjects.

    This ports the cpdftweak.ml reveal-hidden-text behavior by removing all Tr text rendering-mode operators from selected content streams.

    PdfDocument::revision_read

    source
    fn PdfDocument::revision_read(self : PdfDocument) -> Int

    Return the number of document revisions read from the input.

    PdfDocument::root

    source
    fn PdfDocument::root(self : PdfDocument) -> Int

    Return the catalog root object number tracked on the document.

    PdfDocument::rotate_contents

    source
    fn PdfDocument::rotate_contents(self : PdfDocument, rotation : Double, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Rotate selected page contents around each page's /MediaBox center.

    This ports cpdfpage's rotate_contents: page boxes and /Rotate entries are left unchanged, while content streams, annotations, pattern matrices, and destination coordinates are transformed.

    PdfDocument::rotate_pages

    source
    fn PdfDocument::rotate_pages(self : PdfDocument, rotation : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Set selected page /Rotate entries to an absolute rotation in degrees.

    PdfDocument::rotate_pages_by

    source
    fn PdfDocument::rotate_pages_by(self : PdfDocument, rotation : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Add rotation degrees to selected page /Rotate entries.

    PdfDocument::scale_contents

    source
    fn PdfDocument::scale_contents(self : PdfDocument, page_numbers : ArrayView[Int], position : PdfPosition, scale : Double, fast? : Bool) -> PdfDocument raise 
    PdfError

    Scale selected page contents and annotations around a cpdf-style position.

    The transform origin is calculated from /CropBox when present, otherwise /MediaBox. Destination references for scaled pages are transformed with the same matrix.

    PdfDocument::scale_pages

    source
    fn PdfDocument::scale_pages(self : PdfDocument, page_numbers : ArrayView[Int], scales : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Scale selected pages by per-page x/y factors, including boxes and content.

    This ports cpdf's scale_pdf: selected page boxes, content streams, annotations, pattern matrices, and destination coordinates are transformed by a scale matrix around the origin.

    PdfDocument::scale_to_fit_pages

    source
    fn PdfDocument::scale_to_fit_pages(self : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], position? : PdfPosition, input_scale? : Double, fast? : Bool) -> PdfDocument raise 
    PdfError

    Scale selected pages to fit target page sizes while preserving aspect ratio.

    PdfDocument::scale_to_fit_rotate_pages

    source
    fn PdfDocument::scale_to_fit_rotate_pages(self : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], rotation : Int, fast? : Bool) -> PdfDocument raise 
    PdfError

    Conditionally rotate selected pages to better fit target sizes, then upright the same pages.

    This ports cpdf's scale_to_fit_rotate: if a page and its target size have opposite orientation, the page dictionary rotation is adjusted by rotation; upright_pages is then applied to the selected range.

    PdfDocument::select_object_numbers

    source
    fn PdfDocument::select_object_numbers(self : PdfDocument, predicate : (PdfObject) -> Bool) -> Array[Int]

    Return parsed object numbers whose objects satisfy predicate.

    Deferred objects are not loaded by this helper. Results follow ascending object-number order.

    PdfDocument::set_annotations_json

    source
    fn PdfDocument::set_annotations_json(self : PdfDocument, json : Json) -> PdfDocument raise 
    PdfError

    Return a copy of the document with cpdf annotation JSON appended.

    Existing objects are first renumbered above the imported annotation object range, matching cpdf's collision-avoidance strategy. Header rows and other nonpositive extra-object rows are ignored; positive extra objects are added before page annotations are rebuilt.

    PdfDocument::set_first_xref

    source
    fn PdfDocument::set_first_xref(self : PdfDocument, first_xref : Int) -> Unit

    Set the byte offset of the first xref section read from the input.

    PdfDocument::set_info_entry

    source
    fn PdfDocument::set_info_entry(self : PdfDocument, key : 
    PdfName    , value : PdfObject, version : Int, keep_version? : Bool, xmp_also? : Bool, xmp_just_set? : Bool) -> PdfDocument raise 
    PdfError

    Set or replace one /Info dictionary entry.

    PdfDocument::set_language

    source
    fn PdfDocument::set_language(self : PdfDocument, language : BytesView) -> PdfDocument raise 
    PdfError

    Set the catalog /Lang value.

    PdfDocument::set_mediaboxes

    source
    fn PdfDocument::set_mediaboxes(self : PdfDocument, page_numbers : ArrayView[Int], boxes : ArrayView[(Double, Double, Double, Double)]) -> PdfDocument raise 
    PdfError

    Set /MediaBox on selected pages from a page-indexed (x, y, width, height) list.

    boxes must contain one entry for every page in the document, matching cpdf's rectangle parser. page_numbers selects which page entries are applied, and each selected page uses boxes[page_number - 1].

    PdfDocument::set_metadata_date

    source
    fn PdfDocument::set_metadata_date(self : PdfDocument, date : String) -> PdfDocument raise 
    PdfError

    Set the XMP /Metadata stream's xmp:MetadataDate field.

    PdfDocument::set_metadata_from_bytes

    source
    fn PdfDocument::set_metadata_from_bytes(self : PdfDocument, data : BytesView, keep_version? : Bool) -> PdfDocument raise 
    PdfError

    Set the catalog metadata XML stream from in-memory bytes.

    PdfDocument::set_non_full_screen_page_mode

    source
    fn PdfDocument::set_non_full_screen_page_mode(self : PdfDocument, mode : String) -> PdfDocument raise 
    PdfError

    Set /ViewerPreferences /NonFullScreenPageMode.

    PdfDocument::set_open_action

    source
    fn PdfDocument::set_open_action(self : PdfDocument, page_number : Int, fit? : Bool, destination? : PdfObject?) -> PdfDocument raise 
    PdfError

    Set the catalog /OpenAction to a GoTo action.

    page_number is one-based. When destination is supplied and starts with a page number integer, that integer is rewritten to the corresponding page indirect reference.

    PdfDocument::set_page_box

    source
    fn PdfDocument::set_page_box(self : PdfDocument, page_numbers : ArrayView[Int], box_name : 
    PdfName    , min_x : Double, max_x : Double, min_y : Double, max_y : Double) -> PdfDocument raise 
    PdfError

    Set a fixed named page box on selected pages.

    The scalar argument order mirrors cpdf's historical setBox: (min_x, max_x, min_y, max_y).

    PdfDocument::set_page_layout

    source
    fn PdfDocument::set_page_layout(self : PdfDocument, layout : String) -> PdfDocument raise 
    PdfError

    Set the catalog /PageLayout value using a name without the leading slash.

    PdfDocument::set_page_mode

    source
    fn PdfDocument::set_page_mode(self : PdfDocument, mode : String) -> PdfDocument raise 
    PdfError

    Set the catalog /PageMode value using a name without the leading slash.

    PdfDocument::set_revision_read

    source
    fn PdfDocument::set_revision_read(self : PdfDocument, revision_read : Int) -> Unit

    Set the number of document revisions read from the input.

    PdfDocument::set_root

    source
    fn PdfDocument::set_root(self : PdfDocument, root : Int) -> Unit

    Set the catalog root object number.

    PdfDocument::set_trailer_dict

    source
    fn PdfDocument::set_trailer_dict(self : PdfDocument, trailer_dict : PdfObject) -> Unit

    Replace the document trailer dictionary object.

    PdfDocument::set_version

    source
    fn PdfDocument::set_version(self : PdfDocument, major : Int, minor : Int) -> Unit

    Set the PDF version stored on the document.

    PdfDocument::set_viewer_preference

    source
    fn PdfDocument::set_viewer_preference(self : PdfDocument, key : 
    PdfName    , value : PdfObject, version : Int, keep_version? : Bool) -> PdfDocument raise 
    PdfError

    Set or replace one /ViewerPreferences dictionary entry.

    PdfDocument::set_was_linearized

    source
    fn PdfDocument::set_was_linearized(self : PdfDocument, was_linearized : Bool) -> Unit

    Set whether the source PDF was marked as linearized.

    PdfDocument::shift_boxes

    source
    fn PdfDocument::shift_boxes(self : PdfDocument, page_numbers : ArrayView[Int], offsets : ArrayView[(Double, Double)]) -> PdfDocument raise 
    PdfError

    Shift /MediaBox and known page boxes by page-indexed offsets.

    This ports cpdf's shift_boxes: offsets are indexed by absolute page number and content streams, annotations, and destination coordinates are not moved.

    PdfDocument::shift_pages

    source
    fn PdfDocument::shift_pages(self : PdfDocument, page_numbers : ArrayView[Int], offsets : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Shift selected page contents and annotations by per-page offsets.

    page_numbers are 1-based and offsets must contain one (dx, dy) pair for each selected page. Destination references for shifted pages are transformed with the same matrix.

    PdfDocument::shortest_unused_prefix

    source
    fn PdfDocument::shortest_unused_prefix(self : PdfDocument) -> String

    Return the shortest ASCII prefix unused by page resource names.

    The prefix is suitable for add_prefix when merging pages from independent documents with potentially colliding resource names.

    PdfDocument::show_annotation_bounding_boxes

    source
    fn PdfDocument::show_annotation_bounding_boxes(self : PdfDocument, page_numbers : ArrayView[Int], light? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Draw bounding boxes around annotations on selected one-based pages.

    This ports the implemented annotation-overlay part of CamlPDF's redaction helper. Each annotation rectangle is stroked in yellow, or light yellow when light is set, and appended through the existing page-content rewrite path.

    PdfDocument::show_bounding_boxes

    source
    fn PdfDocument::show_bounding_boxes(self : PdfDocument, page_numbers : ArrayView[Int], shape? : PdfRectangle?, light? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Draw bounding boxes around annotations and selected page-content objects.

    PdfDocument::show_page_boxes

    source
    fn PdfDocument::show_page_boxes(self : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Draw coloured outlines for the standard page boxes on selected pages.

    This ports cpdf's show_boxes: /MediaBox, /CropBox, /ArtBox, /TrimBox, and /BleedBox are appended as artifact-marked stroked rectangles when present.

    PdfDocument::size_attached_files

    source
    fn PdfDocument::size_attached_files(self : PdfDocument) -> Int raise 
    PdfError

    Return the total raw byte size of all embedded file attachment streams.

    PdfDocument::squeeze

    source
    fn PdfDocument::squeeze(self : PdfDocument, page_data? : Bool) -> PdfDocument raise 
    PdfError

    Remove duplicate non-page, non-annotation objects, rewrite references to the first matching object, and recompress eligible streams.

    When page_data is true, page content streams and referenced Form XObjects are parsed and serialized into normalized uncompressed streams when doing so will not rewrite shared page content streams.

    PdfDocument::stamp_as_xobject

    source

    Stamp the first page of overlay into this document as a Form XObject.

    The returned name is the resource name added to each selected base page. The overlay page itself is not retained as a visible page; its content and resources are embedded in the new Form XObject. Existing bookmarks in the base document are preserved and retargeted to the rebuilt page tree.

    PdfDocument::stamp_pages

    source
    fn PdfDocument::stamp_pages(self : PdfDocument, page_numbers : ArrayView[Int], overlay : PdfDocument, relative_to_box? : 
    PdfName    , position? : PdfPosition, topline? : Bool, midline? : Bool, fast? : Bool, scale_to_fit? : Bool, is_over? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Stamp the first page of overlay onto selected pages by merging content.

    PdfDocument::stream_object_entries

    source
    fn PdfDocument::stream_object_entries(self : PdfDocument) -> Array[(Int, Int, PdfStream)]

    Return parsed stream-object entries in object-number order.

    PdfDocument::stretch_pages

    source
    fn PdfDocument::stretch_pages(self : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Stretch selected pages to target sizes without preserving aspect ratio.

    This ports cpdfpage's stretch: the current /CropBox when present, otherwise /MediaBox, determines the source width and height. Page boxes, content streams, annotations, pattern matrices, and destination coordinates are transformed by the computed x/y scale.

    PdfDocument::string_of_pagespec

    source
    fn PdfDocument::string_of_pagespec(self : PdfDocument, pages : ArrayView[Int]) -> String raise 
    PdfError

    PdfDocument::struct_tree_json_blob

    source
    fn PdfDocument::struct_tree_json_blob(self : PdfDocument) -> Bytes raise 
    PdfError

    Extract the PDF/UA structure-tree JSON as UTF-8 bytes.

    PdfDocument::struct_tree_text

    source
    fn PdfDocument::struct_tree_text(self : PdfDocument) -> Bytes raise 
    PdfError

    Render cpdf's printed PDF/UA structure tree as UTF-8 bytes.

    PdfDocument::target_of_page_number

    source
    fn PdfDocument::target_of_page_number(self : PdfDocument, page_number : Int) -> PdfDestination raise 
    PdfError

    Build a fit destination for a 1-based page number.

    Out-of-range page numbers return DestNull.

    PdfDocument::test_extract_text

    source
    fn PdfDocument::test_extract_text(self : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Return cpdf's simple test text extraction bytes for selected 1-based pages.

    PdfDocument::test_matterhorn_json

    source
    fn PdfDocument::test_matterhorn_json(self : PdfDocument, test_name : String) -> Json raise 
    PdfError

    Return cpdf-style PDF/UA Matterhorn failures as JSON.

    The current migration covers content-marking checks 01-003, 01-004, 01-005, and 01-007, role-map checks 02-001, 02-003, and 02-004, XMP metadata and DisplayDocTitle checks 06-001 through 07-002, and structure syntax checks 09-004 through 09-008, character-code Unicode mapping check 10-001, natural-language top-level /Lang check 11-001 plus source-unimplemented language checks 11-002 through 11-006, structure-tree attribute checks 13-004, 15-003, 17-002, 17-003, 19-003, and 19-004, heading checks 14-002, 14-003, 14-006, and 14-007, optional-content configuration checks 20-001 through 20-003, embedded file-spec check 21-001, XFA dynamicRender check 25-001, encryption checks 26-001 and 26-002, annotation parent structure check 28-002, annotation contents-or-Alt check 28-004, source-compatible form-field no-op check 28-005, annotation subtype and tab-order checks 28-006 through 28-009, annotation structure-parent checks 28-010 and 28-011, link annotation contents check 28-012, media-clip checks 28-014 and 28-015, file-attachment no-op 28-016, PrinterMark object and appearance checks 28-017 and 28-018, plus reference-XObject checks 30-001 and 30-002, plus font CIDSystemInfo/CIDToGIDMap/CMap checks 31-001 through 31-009, and source-unimplemented font-file checks 31-011 through 31-016, 31-018, and 31-030, plus TrueType encoding dictionary and cmap checks 31-017 and 31-019 through 31-026, and ToUnicode presence/value checks 31-027 through 31-029. Passing "" runs the covered subset; unsupported individual test names raise a soft error until their source checks are ported.

    PdfDocument::test_matterhorn_text

    source
    fn PdfDocument::test_matterhorn_text(self : PdfDocument, test_name : String) -> Bytes raise 
    PdfError

    Return cpdf-style text lines for the covered Matterhorn failures.

    PdfDocument::text_extractor_of_font

    source

    Read a font dictionary and return a text extractor for it.

    PdfDocument::thin_lines

    source
    fn PdfDocument::thin_lines(self : PdfDocument, page_numbers : ArrayView[Int], width : Double) -> PdfDocument raise 
    PdfError

    Set a minimum line width on selected one-based pages.

    Passing a negative width sets the corresponding maximum line width, as in cpdf's thinlines implementation.

    PdfDocument::toc_add_bookmark

    source
    fn PdfDocument::toc_add_bookmark(self : PdfDocument, title : BytesView) -> PdfDocument raise 
    PdfError

    Prepend the generated table-of-contents bookmark.

    Existing bookmarks are preserved at their current levels and order. The new bookmark targets the first page of the current document, which should be the first inserted TOC page after toc_insert_pages.

    PdfDocument::toc_insert_pages

    source

    Prepend already-typeset TOC pages and shift existing page labels.

    Page references in destinations, annotations, open actions, and bookmarks are rewritten from original one-based page serials to their new serials after the inserted TOC pages.

    PdfDocument::toc_type_elements

    source
    fn PdfDocument::toc_type_elements(self : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, dotleader : Bool, process_struct_tree : Bool, labels : ArrayView[PdfPageLabel], bookmarks : ArrayView[PdfBookmark], page_width : Double, margin : Double) -> Array[PdfTypeElement] raise 
    PdfError

    Build the cpdftype element stream for a table of contents.

    page_width and margin are the already-resolved first-page dimensions from cpdftoc's caller. Actual page typesetting and insertion remain a separate step.

    PdfDocument::toc_typeset_pages

    source
    fn PdfDocument::toc_typeset_pages(self : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, dotleader : Bool, process_struct_tree : Bool, labels : ArrayView[PdfPageLabel], bookmarks : ArrayView[PdfBookmark]) -> PdfTypeTypesetResult raise 
    PdfError

    Typeset a TOC element stream into pages using cpdftoc's first-page geometry.

    The first page's /MediaBox defines the paper size and base margin, while an inherited /CropBox, when present, narrows the content width, offsets the margins, and is copied onto the generated TOC pages. This helper does not insert the pages into the source document.

    PdfDocument::toc_used_codepoints

    source
    fn PdfDocument::toc_used_codepoints(self : PdfDocument, labels : ArrayView[PdfPageLabel], title : BytesView, bookmarks : ArrayView[PdfBookmark]) -> Array[Int] raise 
    PdfError

    Return the unique Unicode codepoints cpdftoc needs before embedding a font.

    The scan includes the dot used by ellipses/leaders, the TOC title, bookmark titles, and the visible page-label text for each bookmark target. The returned order is first occurrence for deterministic callers and tests.

    PdfDocument::toc_with_fontpack

    source
    fn PdfDocument::toc_with_fontpack(self : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, bookmark? : Bool, dotleader? : Bool) -> PdfDocument raise 
    PdfError

    Add a table of contents using an already prepared font pack.

    This composes the non-structure-tree cpdftoc path: read existing bookmarks and labels, typeset TOC pages, prepend them, shift page labels, and optionally add the generated TOC bookmark. Documents without bookmarks are returned unchanged.

    PdfDocument::toc_with_source

    source
    fn PdfDocument::toc_with_source(self : PdfDocument, source : PdfTocFontSource, font_size : Double, title : BytesView, bookmark? : Bool, dotleader? : Bool) -> PdfDocument raise 
    PdfError

    Add a table of contents using a cpdftoc font source.

    Existing named fonts are rejected for TOCs, matching cpdf. Embeddable TrueType font sources will be handled by a later embedding slice.

    PdfDocument::trailer_dict

    source
    fn PdfDocument::trailer_dict(self : PdfDocument) -> PdfObject

    Return the current trailer dictionary object.

    The returned object may share mutable container state with the document.

    PdfDocument::transform_annotations

    source

    Transform annotation geometry referenced by a page dictionary.

    Applies matrix to /Rect, /QuadPoints, and /L entries. Indirect annotations are updated in this document; direct annotation dictionaries in the page's /Annots array are updated in place.

    PdfDocument::transform_bookmark

    source

    Transform a bookmark destination by a matrix.

    Only the destination is changed; level, text, open state, colour, and flags are preserved.

    PdfDocument::transform_destination

    source

    Applies a page transform matrix to destination coordinates.

    Only destinations tied to page objects are transformed. Named destinations, string destinations, non-page-number actions, and already page-number-based targets are preserved.

    PdfDocument::transform_quadpoints

    source

    Transform PDF annotation quadpoints in groups of eight coordinates.

    Each complete group is interpreted as four (x, y) pairs and transformed by matrix. A complete group containing a non-numeric value is preserved unchanged, as is any trailing partial group. Non-array inputs are returned unchanged.

    PdfDocument::transform_rect

    source

    Transform a rectangle and return the bounding PDF rectangle array.

    All four corners are transformed with matrix, then the axis-aligned bounds of those transformed points are written as [minX minY maxX maxY].

    PdfDocument::trim_marks

    source
    fn PdfDocument::trim_marks(self : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Add trim marks around /TrimBox on selected pages.

    Pages without a valid /TrimBox are left unchanged, matching cpdf's trim_marks.

    PdfDocument::trim_structure_tree

    source
    fn PdfDocument::trim_structure_tree(self : PdfDocument, page_numbers : ArrayView[Int]) -> Unit raise 
    PdfError

    Trim structure-tree entries that point to pages outside the selected pages.

    page_numbers uses the same page-selection numbering as the page helpers. The document is mutated in place by deleting structure objects tied to removed pages and pruning /K arrays that reference them.

    PdfDocument::twoup

    source
    fn PdfDocument::twoup(self : PdfDocument, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Legacy cpdf two-up operation.

    This scales source pages down, imposes them 2x1, rotates/uprights the imposed sheets, then scales each sheet back to the first page's original size.

    PdfDocument::twoup_stack

    source
    fn PdfDocument::twoup_stack(self : PdfDocument, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Legacy cpdf two-up stack operation.

    This first imposes source pages in a 2x1 non-fit grid, then rotates the imposed sheets by -90 degrees and uprights them into ordinary page geometry.

    PdfDocument::upright_pages

    source
    fn PdfDocument::upright_pages(self : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Remove page dictionary rotation from selected pages by transforming page data.

    Page content, annotations, known page boxes, and destinations are transformed into an upright coordinate system. Non-zero /MediaBox origins are shifted back to (0, 0) after rotation.

    PdfDocument::version

    source
    fn PdfDocument::version(self : PdfDocument) -> (Int, Int)

    Return the PDF version as (major, minor).

    PdfDocument::viewer_preference_item

    source
    fn PdfDocument::viewer_preference_item(self : PdfDocument, key : 
    PdfName    ) -> String

    Return a viewer-preference item in cpdf's text-reporting form.

    PdfDocument::was_linearized

    source
    fn PdfDocument::was_linearized(self : PdfDocument) -> Bool

    Return whether the source PDF was marked as linearized.

    PdfDocument::what_encryption

    source

    Return the document encryption method, or None for unencrypted documents.

    Unknown or unsupported encryption dictionaries may also return None after the dictionary has been parsed.

    PdfDocument::write_colour_space

    source
    fn PdfDocument::write_colour_space(_self : PdfDocument, space : PdfColourSpace) -> PdfObject

    Serialize a colour space for writing into a PDF object graph.

    This delegates to pdf_object_of_colour_space and returns PdfNull when the parsed colour space is not representable as a valid PDF object.

    PdfDocument::write_encoding

    source
    fn PdfDocument::write_encoding(self : PdfDocument, encoding : PdfEncoding) -> Int raise 
    PdfError

    Write a custom encoding dictionary and return its object number.

    Currently this supports /Differences over an implicit base encoding, which is the form needed by the font writer. Unsupported encodings raise PdfError::EncodingWriteUnsupported.

    PdfDocument::write_font

    source
    fn PdfDocument::write_font(self : PdfDocument, font : PdfFont, objnum? : Int?) -> Int raise 
    PdfError

    Write a parsed font into the document and return its object number.

    Standard fonts, Type 3 fonts with descriptors, and TrueType fonts with descriptors are supported. objnum can force the destination object number for rewrite workflows. Unsupported font shapes raise PdfError::FontWriteUnsupported.

    PdfDocument::write_optional_content_groups

    source
    fn PdfDocument::write_optional_content_groups(self : PdfDocument, optional_content : PdfOptionalContent) -> PdfDocument raise 
    PdfError

    Return a copy of the document with catalog /OCProperties replaced.

    OCG dictionaries are written using the object numbers stored in optional_content.ocgs. Configuration dictionaries are added as new objects, and the original document is left unchanged.

    PdfDocument::write_page_labels

    source

    Return a copy of the document with catalog /PageLabels replaced.

    Public start_page values are written as zero-based PDF number-tree keys. Passing an empty label list removes any existing page-label tree.

    PdfDocument::xmp_info

    source
    fn PdfDocument::xmp_info(self : PdfDocument, key : 
    PdfName    ) -> String

    Return XMP metadata corresponding to a legacy /Info key.

    PdfDocument::xmp_info_json

    source

    Return cpdf-style XMP metadata report fields as JSON.

    PdfDocument::xmp_info_json_blob

    source
    fn PdfDocument::xmp_info_json_blob(self : PdfDocument) -> Bytes raise 
    PdfError

    Return cpdf-style XMP metadata report fields as UTF-8 JSON bytes.

    PdfDrawColour

    source
    pub(all) enum PdfDrawColour {
      PdfDrawNoCol
      PdfDrawRGB(Double, Double, Double)
      PdfDrawGrey(Double)
      PdfDrawCYMK(Double, Double, Double, Double)
    } derive(Eq, ToJson, 
    Debug    )

    Colour specification used by cpdf draw operations.

    The CYMK spelling follows the OCaml source variant name in cpdfdraw.ml.

    PdfDrawControl

    source
    pub struct PdfDrawControl {
      frames : Array[PdfDrawControlFrame]
      xobject_bbox : PdfCoordRectangle
      font_name : String
      font_size : Double
      fontpack : PdfFontPack?
      fontpack_initialized : Bool
      paragraph_indent : Double?
      role_map : String
      auto_artifacts : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Stateful builder for cpdf draw-control operations.

    This ports the frame-stack behavior from cpdfdrawcontrol.ml: ordinary operations are appended to the current frame; text sections, pushed graphics groups, and form XObjects collect nested operations and collapse them into TextSection, Qq, and FormXObject operations when closed.

    PdfDrawControl::add_bezier

    source
    fn PdfDrawControl::add_bezier(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_bezier13

    source
    fn PdfDrawControl::add_bezier13(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_bezier23

    source
    fn PdfDrawControl::add_bezier23(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_char_space

    source
    fn PdfDrawControl::add_char_space(self : PdfDrawControl, spacing : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_circle

    source
    fn PdfDrawControl::add_circle(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_default_fontpack

    source
    fn PdfDrawControl::add_default_fontpack(self : PdfDrawControl, font_name : String) -> Unit raise 
    PdfError

    Append the current font pack once under font_name.

    This ports cpdfdrawcontrol.ml's add_default_fontpack fontname helper. Calling set_fontpack resets the one-shot guard.

    PdfDrawControl::add_element_info

    source
    fn PdfDrawControl::add_element_info(self : PdfDrawControl, key : String, value : PdfObject) -> Unit raise 
    PdfError

    PdfDrawControl::add_image

    source
    fn PdfDrawControl::add_image(self : PdfDrawControl, name : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_jpeg2000_data

    source
    fn PdfDrawControl::add_jpeg2000_data(self : PdfDrawControl, name : String, data : BytesView) -> Unit raise 
    PdfError

    Append a JPEG2000 image XObject operation from supplied image bytes.

    This ports the data-supplied branch of cpdfdrawcontrol.ml's addjpeg2000.

    PdfDrawControl::add_jpeg_data

    source
    fn PdfDrawControl::add_jpeg_data(self : PdfDrawControl, name : String, data : BytesView) -> Unit raise 
    PdfError

    Append a JPEG image XObject operation from supplied image bytes.

    This ports the data-supplied branch of cpdfdrawcontrol.ml's addjpeg.

    PdfDrawControl::add_leading

    source
    fn PdfDrawControl::add_leading(self : PdfDrawControl, leading : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_line

    source
    fn PdfDrawControl::add_line(self : PdfDrawControl, document : PdfDocument, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_namespace

    source
    fn PdfDrawControl::add_namespace(self : PdfDrawControl, namespace_name : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_new_page

    source

    PdfDrawControl::add_newline

    source

    PdfDrawControl::add_op

    source

    Append one operation to the current frame.

    PdfDrawControl::add_opacity

    source
    fn PdfDrawControl::add_opacity(self : PdfDrawControl, opacity : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_para

    source
    fn PdfDrawControl::add_para(self : PdfDrawControl, document : PdfDocument, spec : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_paras

    source
    fn PdfDrawControl::add_paras(self : PdfDrawControl, document : PdfDocument, spec : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_png_data

    source
    fn PdfDrawControl::add_png_data(self : PdfDrawControl, document : PdfDocument, name : String, data : BytesView) -> Unit raise 
    PdfError

    Append a PNG image XObject operation from supplied image bytes.

    document is used when the PNG needs an alpha-mask object, matching cpdfdrawcontrol.ml's addpng pdf ?data boundary.

    PdfDrawControl::add_rect

    source
    fn PdfDrawControl::add_rect(self : PdfDrawControl, document : PdfDocument, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_render_mode

    source
    fn PdfDrawControl::add_render_mode(self : PdfDrawControl, mode : Int) -> Unit raise 
    PdfError

    PdfDrawControl::add_rise

    source
    fn PdfDrawControl::add_rise(self : PdfDrawControl, rise : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_special_text

    source
    fn PdfDrawControl::add_special_text(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_stroke_opacity

    source
    fn PdfDrawControl::add_stroke_opacity(self : PdfDrawControl, opacity : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_structure_tag

    source
    fn PdfDrawControl::add_structure_tag(self : PdfDrawControl, tag : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_tag

    source
    fn PdfDrawControl::add_tag(self : PdfDrawControl, tag : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_text

    source
    fn PdfDrawControl::add_text(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_text_scale

    source
    fn PdfDrawControl::add_text_scale(self : PdfDrawControl, scale : Double) -> Unit raise 
    PdfError

    PdfDrawControl::add_to

    source
    fn PdfDrawControl::add_to(self : PdfDrawControl, document : PdfDocument, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::add_word_space

    source
    fn PdfDrawControl::add_word_space(self : PdfDrawControl, spacing : Double) -> Unit raise 
    PdfError

    PdfDrawControl::auto_artifacts

    source
    fn PdfDrawControl::auto_artifacts(self : PdfDrawControl) -> Bool

    Return whether automatic artifact wrapping is enabled on this state.

    PdfDrawControl::begin_artifact

    source

    PdfDrawControl::begin_text_section

    source
    fn PdfDrawControl::begin_text_section(self : PdfDrawControl) -> Unit

    Start a text-section frame.

    PdfDrawControl::clip

    source

    PdfDrawControl::clip_even_odd

    source

    PdfDrawControl::close_path

    source

    PdfDrawControl::current_frame_name

    source
    fn PdfDrawControl::current_frame_name(self : PdfDrawControl) -> String raise 
    PdfError

    Return the current frame name.

    PdfDrawControl::current_ops

    source

    Return a copy of the operations collected in the current frame.

    PdfDrawControl::depth

    source
    fn PdfDrawControl::depth(self : PdfDrawControl) -> Int

    Return the current stack depth.

    PdfDrawControl::end_artifact

    source

    PdfDrawControl::end_element_info

    source
    fn PdfDrawControl::end_element_info(self : PdfDrawControl, key : String) -> Unit raise 
    PdfError

    PdfDrawControl::end_structure_tag

    source
    fn PdfDrawControl::end_structure_tag(self : PdfDrawControl) -> Unit raise 
    PdfError

    PdfDrawControl::end_tag

    source

    PdfDrawControl::end_text_section

    source
    fn PdfDrawControl::end_text_section(self : PdfDrawControl) -> Unit raise 
    PdfError

    Finish the current text-section frame and append a PdfDrawTextSection op.

    PdfDrawControl::end_xobject

    source

    Finish the current form XObject and append a PdfDrawFormXObject op.

    PdfDrawControl::fill

    source

    PdfDrawControl::fill_even_odd

    source

    PdfDrawControl::font_name

    source
    fn PdfDrawControl::font_name(self : PdfDrawControl) -> String

    Return the current draw-control font name.

    This is the per-instance counterpart of cpdfdrawcontrol.ml's getfontname callback.

    PdfDrawControl::font_size

    source
    fn PdfDrawControl::font_size(self : PdfDrawControl) -> Double

    Return the current draw-control font size.

    This is the per-instance counterpart of cpdfdrawcontrol.ml's getfontsize callback.

    PdfDrawControl::fontpack_initialized

    source
    fn PdfDrawControl::fontpack_initialized(self : PdfDrawControl) -> Bool

    Return whether the current font pack has been emitted once.

    This exposes the per-instance state corresponding to cpdf's fontpack_initialised ref.

    PdfDrawControl::matrix_rotate

    source
    fn PdfDrawControl::matrix_rotate(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::matrix_scale

    source
    fn PdfDrawControl::matrix_scale(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::matrix_shear_x

    source
    fn PdfDrawControl::matrix_shear_x(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::matrix_shear_y

    source
    fn PdfDrawControl::matrix_shear_y(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::matrix_translate

    source
    fn PdfDrawControl::matrix_translate(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::ops

    source

    Return a copy of the operations collected in the main frame.

    PdfDrawControl::paragraph_indent

    source
    fn PdfDrawControl::paragraph_indent(self : PdfDrawControl) -> Double?

    Return the current paragraph indent used by add_paras.

    This is the per-instance counterpart of cpdfdrawcontrol.ml's getindent callback.

    PdfDrawControl::pop_group

    source

    Finish the current pushed graphics-state frame and append a PdfDrawQq op.

    PdfDrawControl::push_group

    source
    fn PdfDrawControl::push_group(self : PdfDrawControl) -> Unit

    Start a pushed graphics-state frame.

    PdfDrawControl::role_map

    source
    fn PdfDrawControl::role_map(self : PdfDrawControl) -> String

    Return the role-map body configured on this draw-control state.

    PdfDrawControl::set_auto_artifacts

    source
    fn PdfDrawControl::set_auto_artifacts(self : PdfDrawControl, enabled : Bool) -> Unit

    Enable or disable automatic artifact wrapping for structured draw output.

    PdfDrawControl::set_auto_tag

    source
    fn PdfDrawControl::set_auto_tag(self : PdfDrawControl, enabled : Bool) -> Unit raise 
    PdfError

    PdfDrawControl::set_dash_pattern

    source
    fn PdfDrawControl::set_dash_pattern(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_fill

    source
    fn PdfDrawControl::set_fill(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    Append a fill colour operation parsed from a cpdf draw-control argument.

    PdfDrawControl::set_font

    source
    fn PdfDrawControl::set_font(self : PdfDrawControl, font_name : String, font_size : Double) -> Unit

    PdfDrawControl::set_font_name

    source
    fn PdfDrawControl::set_font_name(self : PdfDrawControl, font_name : String) -> Unit

    PdfDrawControl::set_font_size

    source
    fn PdfDrawControl::set_font_size(self : PdfDrawControl, font_size : Double) -> Unit

    PdfDrawControl::set_fontpack

    source
    fn PdfDrawControl::set_fontpack(self : PdfDrawControl, fontpack : PdfFontPack?) -> Unit

    PdfDrawControl::set_line_cap

    source
    fn PdfDrawControl::set_line_cap(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_line_join

    source
    fn PdfDrawControl::set_line_join(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_line_thickness

    source
    fn PdfDrawControl::set_line_thickness(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_matrix

    source
    fn PdfDrawControl::set_matrix(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_miter_limit

    source
    fn PdfDrawControl::set_miter_limit(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    PdfDrawControl::set_paragraph_indent

    source
    fn PdfDrawControl::set_paragraph_indent(self : PdfDrawControl, indent : Double?) -> Unit

    PdfDrawControl::set_role_map

    source
    fn PdfDrawControl::set_role_map(self : PdfDrawControl, role_map : String) -> Unit

    Set the role-map body used by structured draw output.

    The value follows cpdf's -rolemap convention: pass entries such as "/H1 /H /Aside /Div" without the surrounding << >>.

    PdfDrawControl::set_stroke

    source
    fn PdfDrawControl::set_stroke(self : PdfDrawControl, text : String) -> Unit raise 
    PdfError

    Append a stroke colour operation parsed from a cpdf draw-control argument.

    PdfDrawControl::set_xobject_bbox

    source
    fn PdfDrawControl::set_xobject_bbox(self : PdfDrawControl, bbox : PdfCoordRectangle) -> Unit

    Set the bounding box used for the next closed form XObject.

    PdfDrawControl::set_xobject_bbox_from_string

    source
    fn PdfDrawControl::set_xobject_bbox_from_string(self : PdfDrawControl, document : PdfDocument, text : String) -> Unit raise 
    PdfError

    Parse and set the bounding box used for the next closed form XObject.

    This ports cpdfdrawcontrol.ml's xobjbbox command helper.

    PdfDrawControl::start_xobject

    source
    fn PdfDrawControl::start_xobject(self : PdfDrawControl, name : String) -> Unit

    Start collecting a named form XObject.

    PdfDrawControl::stroke

    source

    PdfDrawControl::stroke_fill

    source

    PdfDrawControl::stroke_fill_even_odd

    source
    fn PdfDrawControl::stroke_fill_even_odd(self : PdfDrawControl) -> Unit raise 
    PdfError

    PdfDrawControl::use_xobject

    source
    fn PdfDrawControl::use_xobject(self : PdfDrawControl, name : String) -> Unit raise 
    PdfError

    PdfDrawControlFrame

    source
    pub(all) struct PdfDrawControlFrame {
      name : String
      ops : Array[PdfDrawOp]
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawExtGStateResource

    source
    pub(all) struct PdfDrawExtGStateResource {
      kind : 
    PdfName
      value : Double
      name : 
    PdfName
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawFontPackState

    source
    pub(all) struct PdfDrawFontPackState {
      identifier : String
      fontpack : PdfFontPack
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawFontResource

    source
    pub(all) struct PdfDrawFontResource {
      identifier : String
      font_index : Int
      resource_name : 
    PdfName
      object_number : Int
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawJustification

    source
    pub(all) enum PdfDrawJustification {
      PdfDrawLeft
      PdfDrawRight
      PdfDrawCentre
    } derive(Eq, ToJson, 
    Debug    )

    Paragraph justification used by cpdf draw operations.

    PdfDrawOp

    source
    pub(all) enum PdfDrawOp {
      PdfDrawRect(Double, Double, Double, Double)
      PdfDrawBezier(Double, Double, Double, Double, Double, Double)
      PdfDrawBezier23(Double, Double, Double, Double)
      PdfDrawBezier13(Double, Double, Double, Double)
      PdfDrawTo(Double, Double)
      PdfDrawLine(Double, Double)
      PdfDrawClosePath
      PdfDrawSetFill(PdfDrawColour)
      PdfDrawSetStroke(PdfDrawColour)
      PdfDrawSetLineThickness(Double)
      PdfDrawSetLineCap(Int)
      PdfDrawSetLineJoin(Int)
      PdfDrawSetMiterLimit(Double)
      PdfDrawSetDashPattern(Array[Double], Double)
      PdfDrawMatrix(
    TransformMatrix    )
      PdfDrawQq(Array[PdfDrawOp])
      PdfDrawFill
      PdfDrawFillEvenOdd
      PdfDrawStroke
      PdfDrawFillStroke
      PdfDrawFillStrokeEvenOdd
      PdfDrawClip
      PdfDrawClipEvenOdd
      PdfDrawFormXObject(Double, Double, Double, Double, String, Array[PdfDrawOp])
      PdfDrawUse(String)
      PdfDrawImageXObject(String, PdfObject)
      PdfDrawImage(String)
      PdfDrawNewPage
      PdfDrawOpacity(Double)
      PdfDrawSOpacity(Double)
      PdfDrawFontPack(String, PdfFontPack, Array[Int])
      PdfDrawFont(String, Double)
      PdfDrawTextSection(Array[PdfDrawOp])
      PdfDrawText(String)
      PdfDrawSpecialText(String)
      PdfDrawPara(Double?, PdfDrawJustification, Double, Array[String])
      PdfDrawNewline
      PdfDrawLeading(Double)
      PdfDrawCharSpace(Double)
      PdfDrawWordSpace(Double)
      PdfDrawTextScale(Double)
      PdfDrawRenderMode(Int)
      PdfDrawRise(Double)
      PdfDrawTag(String)
      PdfDrawEndTag
      PdfDrawSTag(String)
      PdfDrawEndSTag
      PdfDrawBeginArtifact
      PdfDrawEndArtifact
      PdfDrawNamespace(String)
      PdfDrawEltInfo(String, PdfObject)
      PdfDrawEndEltInfo(String)
      PdfDrawAutoTag(Bool)
    } derive(Eq, ToJson, 
    Debug    )

    Source-level cpdf draw operation.

    This mirrors the operation shape from cpdfdraw.ml. The first rendering slice converts path, graphics-state, colour, matrix, and paint operations to PdfContentOp; structure and page-level operations are represented here and will be rendered by later cpdfdraw slices.

    PdfDrawOp::debug_name

    source
    fn PdfDrawOp::debug_name(self : PdfDrawOp) -> String

    Return the cpdf diagnostic spelling for one draw operation.

    PdfDrawOp::to_content_ops

    source

    Convert one cpdf draw operation to flat PDF content operators.

    The currently ported rendering subset covers the direct operator mappings in the front of cpdfdraw.ml's ops_of_drawop: graphics state, matrix, path, colour, paint, clip, q/Q grouping, resource-backed XObjects, fontpack text, and paragraph layout. Later slices will fill in tagged-content and page-level rendering.

    PdfDrawOp::to_content_ops_with_context

    source

    Convert one cpdf draw operation using resource state and special-text data.

    PdfDrawOp::to_content_ops_with_document

    source
    fn PdfDrawOp::to_content_ops_with_document(self : PdfDrawOp, state : PdfDrawRenderState, document : PdfDocument) -> Array[PdfContentOp] raise 
    PdfError

    Convert one cpdf draw operation using resource state and a document for indirect object allocation.

    PdfDrawOp::to_content_ops_with_document_context

    source
    fn PdfDrawOp::to_content_ops_with_document_context(self : PdfDrawOp, state : PdfDrawRenderState, document : PdfDocument, context : PdfDrawSpecialTextContext) -> Array[PdfContentOp] raise 
    PdfError

    Convert one cpdf draw operation using document resources and special-text data.

    PdfDrawOp::to_content_ops_with_state

    source
    fn PdfDrawOp::to_content_ops_with_state(self : PdfDrawOp, state : PdfDrawRenderState) -> Array[PdfContentOp] raise 
    PdfError

    Convert one cpdf draw operation using resource allocation state.

    PdfDrawRenderState

    source
    pub(all) struct PdfDrawRenderState {
      resource_number : Int
      marked_content_id : Int
      extgstates : Array[PdfDrawExtGStateResource]
      xobjects : Array[PdfDrawXObjectResource]
      form_xobjects : Array[PdfDrawXObjectResource]
      fonts : Array[PdfDrawFontResource]
      fontpacks : Array[PdfDrawFontPackState]
      current_fontpack_identifier : String
      current_fontpack : PdfFontPack
      font_size : Double
      structure_tree_enabled : Bool
      auto_tag : Bool
      structure_page_number : Int
      structure_data : Array[PdfDrawStructureData]
      page_names : Array[
    PdfName    ]
    } derive(Eq, ToJson, 
    Debug    )

    Resource allocation state for rendering cpdf draw operations.

    This ports the resource-numbering and ExtGState cache used by cpdfdraw.ml's res/fresh_name/extgstate helpers. Later rendering slices will extend this state with tagged-content resources.

    PdfDrawRenderState::resources

    source

    Return the resource dictionary needed by the operations rendered so far.

    PdfDrawSpecialTextContext

    source
    pub(all) struct PdfDrawSpecialTextContext {
      time : PdfStrftimeTime
      replacement_values : PdfAddTextReplacementValues
    } derive(Eq, ToJson, 
    Debug    )

    Page-local context used to render PdfDrawSpecialText.

    PdfDrawStructureData

    source
    pub(all) enum PdfDrawStructureData {
      PdfDrawStructureMCID(String, Int, Int)
      PdfDrawStructureBeginTree(String)
      PdfDrawStructureEndTree
      PdfDrawStructureNamespace(String)
      PdfDrawStructureElementInfo(String, PdfObject)
      PdfDrawStructureEndElementInfo(String)
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawXObjectResource

    source
    pub(all) struct PdfDrawXObjectResource {
      source_name : String
      resource_name : 
    PdfName
      object_number : Int
    } derive(Eq, ToJson, 
    Debug    )

    PdfDrawnPath

    source
    pub(all) struct PdfDrawnPath {
      stroked : Bool
      filled : Bool
      path : PdfPath
    } derive(Eq, ToJson, 
    Debug    )

    A cpdfcontent drawn path, pairing path geometry with paint flags.

    PdfDrawnPath::content_json

    source
    fn PdfDrawnPath::content_json(self : PdfDrawnPath) -> Json

    Return cpdfcontent's JSON shape for a drawn path.

    PdfEncoding

    source
    pub(all) enum PdfEncoding {
      PdfImplicitInFontFile
      PdfStandardEncoding
      PdfMacRomanEncoding
      PdfWinAnsiEncoding
      PdfMacExpertEncoding
      PdfCustomEncoding(PdfEncoding, Array[PdfEncodingDifference])
      PdfFillUndefinedWithStandard(PdfEncoding)
    } derive(Eq, ToJson, 
    Debug    )

    Simple-font character encoding.

    PdfCustomEncoding layers /Differences over a base encoding. PdfFillUndefinedWithStandard models TrueType behavior where undefined entries fall back to StandardEncoding.

    PdfEncoding::debug_name

    source
    fn PdfEncoding::debug_name(self : PdfEncoding) -> String

    Return a human-readable encoding label.

    PdfEncoding::pdf_name

    source

    Return the PDF name for a built-in simple-font encoding.

    Custom, implicit, and fallback encodings do not have a direct PDF name and return None.

    PdfEncoding::reverse_table

    source

    Expand this encoding to glyph-name to character-code entries.

    The order follows table; duplicate glyph names are preserved rather than collapsed.

    PdfEncoding::table

    source

    Expand this encoding to a table of defined character-code to glyph-name entries.

    Only codes with a known glyph name are emitted. The table is ordered by increasing one-byte character code.

    PdfEncodingDifference

    source
    pub(all) struct PdfEncodingDifference {
      name : 
    PdfName
      code : Int
    } derive(Eq, ToJson, 
    Debug    )

    One /Differences entry in a simple-font encoding dictionary.

    code is the one-byte character code that maps to name.

    PdfEncryptionValues

    source
    type PdfEncryptionValues derive(Eq, ToJson, 
    Debug    )

    Parsed standard-security-handler values from an encryption dictionary.

    Password entries, permission masks, file IDs, and optional AESV3 wrapping entries are stored as PDF bytes. crypt_type describes the actual object encryption algorithm used for strings and streams.

    PdfFont

    source
    pub(all) enum PdfFont {
      PdfFontStandard(PdfStandardFontData)
      PdfFontSimple(PdfSimpleFont)
      PdfFontCIDKeyed(PdfCIDKeyedFont)
    } derive(Eq, ToJson, 
    Debug    )

    Parsed font model used by text extraction and font writing.

    PdfFont::content_bytes_of_charcode

    source
    fn PdfFont::content_bytes_of_charcode(self : PdfFont, charcode : Int) -> Bytes raise 
    PdfError

    Convert a cpdfcontent glyph character code back to raw PDF string bytes.

    CID-keyed fonts write the code as two big-endian bytes. Standard and simple fonts write a single byte. Out-of-range bytes raise PdfError::InvalidByte, matching the source helper's char_of_int failure cases.

    PdfFont::content_charcodes_of_bytes

    source
    fn PdfFont::content_charcodes_of_bytes(self : PdfFont, bytes : BytesView) -> Array[Int]

    Split raw PDF string bytes into cpdfcontent character codes for self.

    Standard and simple fonts use one byte per character code. CID-keyed fonts use fixed two-byte big-endian character codes, and malformed odd-length inputs return an empty array to match cpdf's charcodes_of_string.

    PdfFont::content_extra_metrics

    source
    fn PdfFont::content_extra_metrics(self : PdfFont) -> (Double, Double)

    Return cpdfcontent's extra vertical metrics for text bounding boxes.

    Type 3 fonts transform their font bbox through the font matrix. Other described simple fonts and CID fonts use the descriptor bbox when present, falling back to ascent/descent only for a zero bbox. Standard fonts read the AFM FontBBox header, with Ascender/Descender as the zero-bbox fallback.

    PdfFont::content_is_vertical

    source
    fn PdfFont::content_is_vertical(self : PdfFont) -> Bool

    Return whether cpdfcontent treats this font as vertical text.

    This intentionally mirrors cpdfcontent's narrow vertical helper: only the predefined /Identity-V CMap is vertical among predefined maps, and parsed external CMaps are vertical only when their wmode is 1.

    PdfFont::content_text_layout_of_bytes

    source
    fn PdfFont::content_text_layout_of_bytes(self : PdfFont, text : BytesView, layout : PdfContentTextLayout) -> PdfContentTextLayoutResult

    Place one raw PDF text string as cpdfcontent's process_tj does.

    The returned glyph widths and placement vectors are normalized through the same Type 3-versus-1000-unit divisor as the source function. The result's text_matrix is the matrix after all glyph advances have been applied.

    PdfFont::content_text_layout_of_tj_array

    source
    fn PdfFont::content_text_layout_of_tj_array(self : PdfFont, elements : ArrayView[PdfObject], layout : PdfContentTextLayout) -> PdfContentTextLayoutResult

    Place a normalized PDF TJ array as cpdfcontent's process_capital_tj does.

    PdfString operands are delegated to content_text_layout_of_bytes. PdfReal operands adjust the current text matrix. Other operands are ignored, matching the source function and the local content parser's normalized TJ array shape.

    PdfFont::content_width_of_charcode

    source
    fn PdfFont::content_width_of_charcode(self : PdfFont, charcode : Int) -> (Double, Double, Double)

    Return cpdfcontent's glyph-space width triple for one character code.

    The tuple is (width, pvx, pvy). Horizontal simple and standard fonts use only width; vertical CID fonts may also return the vertical displacement vector components from /W2 or the default vertical metrics.

    PdfFont::debug_name

    source
    fn PdfFont::debug_name(self : PdfFont) -> String

    Return a human-readable label for a parsed font.

    PdfFont::embedded_fontfile_number

    source
    fn PdfFont::embedded_fontfile_number(self : PdfFont) -> Int?

    Return the embedded font-file stream object number for a parsed font.

    PdfFont::is_identity_h

    source
    fn PdfFont::is_identity_h(self : PdfFont) -> Bool

    Test whether this font is a Type 0 font using /Identity-H.

    PdfFont::is_identity_v

    source
    fn PdfFont::is_identity_v(self : PdfFont) -> Bool

    Test whether this font is a Type 0 font using /Identity-V.

    PdfFont::text_extractor

    source
    fn PdfFont::text_extractor(self : PdfFont) -> PdfTextExtractor

    Build a text extractor for an already parsed font.

    PdfFont::uses_two_byte_codes

    source
    fn PdfFont::uses_two_byte_codes(self : PdfFont) -> Bool

    Return true when this font consumes fixed two-byte text character codes.

    PdfFontDescriptor

    source
    pub(all) struct PdfFontDescriptor {
      ascent : Double
      descent : Double
      avgwidth : Double
      maxwidth : Double
      flags : Int
      fontbbox : PdfRectangle
      italicangle : Double
      capheight : Double
      xheight : Double
      stemv : Double
      fontfile : PdfFontFile?
      charset : Array[
    PdfName    ]?
      tounicode : Array[(Int, Bytes)]?
    } derive(Eq, ToJson, 
    Debug    )

    Parsed PDF font descriptor metrics and optional embedded font metadata.

    Numeric fields use PDF glyph-space units. tounicode stores decoded /ToUnicode mappings when the surrounding font dictionary provides them, so text extraction can prefer explicit Unicode mappings over glyph names.

    PdfFontFile

    source
    pub(all) enum PdfFontFile {
      PdfFontFile(Int)
      PdfFontFile2(Int)
      PdfFontFile3(Int)
    } derive(Eq, ToJson, 
    Debug    )

    Reference to an embedded font program stream in a font descriptor.

    The integer is the object number for /FontFile, /FontFile2, or /FontFile3; the constructor records which descriptor key supplied it.

    PdfFontFile::object_number

    source
    fn PdfFontFile::object_number(self : PdfFontFile) -> Int

    Return the object number referenced by an embedded font-file marker.

    PdfFontListEntry

    source
    pub(all) struct PdfFontListEntry {
      page : Int
      name : String
      subtype : String
      basefont : String
      encoding : String
      font : PdfObject
    } derive(Eq, ToJson, 
    Debug    )

    One font resource entry reported by cpdf-style font listing.

    page is one-based. name, subtype, basefont, and encoding are PDF names rendered with their leading slash; missing non-name fields are empty strings to match cpdf's text listing and JSON-null conversion.

    PdfFontPack

    source
    pub(all) struct PdfFontPack {
      fonts : Array[PdfFont]
      entries : Array[PdfFontPackEntry]
    } derive(Eq, ToJson, 
    Debug    )

    A cpdf-style font pack.

    The pack stores the fonts that can be selected while typesetting text and a Unicode codepoint lookup table returning the font index and one-byte character code. This ports the source-level cpdfembed.ml abstraction without committing the public API to a hash-table representation.

    PdfFontPack::get_char

    source
    fn PdfFontPack::get_char(self : PdfFontPack, codepoint : Int) -> (Int, Int, PdfFont)?

    Look up one Unicode codepoint in a font pack.

    Returns (charcode, font_index, font) when the codepoint can be represented.

    PdfFontPackEntry

    source
    pub(all) struct PdfFontPackEntry {
      codepoint : Int
      font_index : Int
      charcode : Int
    } derive(Eq, ToJson, 
    Debug    )

    One codepoint-to-font mapping in a cpdf-style font pack.

    PdfFontTableEntry

    source
    pub(all) struct PdfFontTableEntry {
      code : Int
      unicode : String
      utf8 : String
      unicode_name : String
      glyphnames : String
    } derive(Eq, ToJson, 
    Debug    )

    One row from cpdf's font encoding table.

    unicode_name is empty when this port has no Unicode character-name table entry for the codepoint. utf8 is <nonprintable> for C0/C1 controls.

    PdfFunction

    source
    pub(all) struct PdfFunction {
      func : PdfFunctionKind
      domain : Array[Double]
      range : Array[Double]?
    } derive(Eq, ToJson, 
    Debug    )

    Parsed PDF function with common domain and optional output range.

    domain is stored as low/high pairs, one pair per input. range, when present, is stored as output low/high pairs and is used to clamp evaluation results.

    PdfFunction::debug_string

    source
    fn PdfFunction::debug_string(self : PdfFunction) -> String

    Format a parsed function as multi-line diagnostic text.

    The output follows CamlPDF's debug printer shape and is intended for inspection, not for writing a PDF function object.

    PdfFunction::eval

    source
    fn PdfFunction::eval(self : PdfFunction, inputs : ArrayView[Double]) -> Array[Double] raise 
    PdfError

    Evaluate a PDF function for the supplied inputs.

    Inputs are clamped to domain before dispatch. The evaluated output is clamped to range when one is present. Raises PdfError::BadFunctionEvaluation when arities, sampled-table indexes, calculator stack types, or child stitching bounds are invalid.

    PdfFunctionKind

    source
    pub(all) enum PdfFunctionKind {
      PdfFunctionSampled(PdfSampledFunction)
      PdfFunctionInterpolation(PdfInterpolationFunction)
      PdfFunctionStitching(PdfStitchingFunction)
      PdfFunctionCalculator(PdfCalculatorFunction)
    } derive(Eq, ToJson, 
    Debug    )

    Discriminated PDF function body for supported /FunctionType values.

    PdfImage

    source
    pub(all) enum PdfImage {
      PdfJPEG(Bytes, Array[Double]?)
      PdfJPEG2000(Bytes, Array[Double]?)
      PdfJBIG2(Bytes, Array[Double]?, Int?)
      PdfRawImage(Int, Int, PdfPixelLayout, Bytes)
    } derive(Eq, ToJson, 
    Debug    )

    Extracted PDF image data.

    JPEG, JPEG2000, and JBIG2 variants keep their encoded bytes and optional decode array. PdfJBIG2 also carries the optional /JBIG2Globals object number. PdfRawImage stores width, height, layout, and decoded pixel bytes.

    PdfInterpolationFunction

    source
    pub(all) struct PdfInterpolationFunction {
      c0 : Array[Double]
      c1 : Array[Double]
      n : Double
    } derive(Eq, ToJson, 
    Debug    )

    PDF function type 2, exponential interpolation.

    c0 and c1 are the output vectors at the low and high ends of the input domain, and n is the exponent used to shape interpolation between them.

    PdfLexeme

    source
    pub(all) enum PdfLexeme {
      LexNull
      LexBool(Bool)
      LexInt(Int)
      LexReal(Double)
      LexString(Bytes)
      LexName(
    PdfName    )
      LexLeftSquare
      LexRightSquare
      LexLeftDict
      LexRightDict
      LexStream(PdfStreamData)
      LexEndStream
      LexObj
      LexEndObj
      LexR
      LexComment(Bytes)
      StopLexing
      LexNone
    } derive(Eq, ToJson, 
    Debug    )

    Token produced by the low-level PDF lexer.

    String, name, and comment payloads are byte-oriented PDF data. StopLexing is an internal stop marker used when object lexing reaches stream/xref boundaries, and LexNone means no token matched at the current cursor position.

    PdfMetadataEncoding

    source
    pub(all) enum PdfMetadataEncoding {
      PdfMetadataRaw
      PdfMetadataUTF8
      PdfMetadataStripped
    } derive(Eq, ToJson, 
    Debug    )

    PdfMissingFontEntry

    source
    pub(all) struct PdfMissingFontEntry {
      page : Int
      name : String
      subtype : String
      basefont : String
      encoding : String
    } derive(Eq, ToJson, 
    Debug    )

    One cpdf-style missing-font report entry.

    encoding == "Built-in" records cpdf's fallback when a missing font does not have a named /Encoding.

    PdfObject

    source
    pub(all) enum PdfObject {
      PdfNull
      PdfBoolean(Bool)
      PdfInteger(Int)
      PdfReal(Double)
      PdfString(Bytes)
      PdfNameObject(
    PdfName    )
      PdfArray(Array[PdfObject])
      PdfDictionary(Array[(
    PdfName    , PdfObject)])
      PdfStreamObject(PdfStream)
      PdfIndirect(Int)
    } derive(Eq, ToJson, 
    Debug    )

    The core in-memory representation of a parsed PDF object.

    Strings and names are byte-oriented PDF values, not MoonBit Unicode strings. PdfIndirect(number) is an unresolved reference by object number; callers that need the referenced object should resolve it through a PdfDocument.

    PdfObject::add_dict_entry

    source

    Add or replace a dictionary entry.

    PdfNull is promoted to a one-entry dictionary. Existing keys are replaced in place. New keys are inserted using the historical CamlPDF order, which places the new entry before existing entries. Stream objects mutate their stream dictionary and return the same stream object.

    PdfObject::dictionary_view

    source

    Borrow the dictionary entries of a dictionary-like object.

    Plain dictionaries return their entries. Stream objects return the entries of their stream dictionary when that dictionary is itself a PdfDictionary. Other objects return None.

    PdfObject::find_indirect

    source

    Return the object number of an immediate indirect dictionary entry.

    Only plain dictionaries are accepted. Missing keys and non-indirect values return None; non-dictionary inputs raise PdfError::DictionaryExpected.

    PdfObject::get_stream

    source
    fn PdfObject::get_stream(self : PdfObject) -> Unit raise 
    PdfError

    Materialize a stream in place.

    Deferred stream data is read, decrypted if needed, stored back as StreamGot, and /Length is corrected when the stream dictionary is a PDF dictionary. Calling this on an already materialized stream is a no-op. Non-stream objects raise PdfError::ParseStreamExpected.

    PdfObject::lookup_immediate

    source
    fn PdfObject::lookup_immediate(self : PdfObject, key : 
    PdfName    ) -> PdfObject?

    Look up a key without resolving indirect references.

    Dictionary and stream-dictionary entries are searched in stored order. The returned object is the immediate value stored under key; use document-level lookup helpers when indirect references should be resolved.

    PdfObject::remove_dict_entry

    source

    Remove a dictionary entry if present.

    Missing keys are ignored for dictionaries. Stream objects mutate their stream dictionary and return the same stream object. Non-dictionary inputs raise PdfError::DictionaryExpected.

    PdfObject::replace_dict_entry

    source

    Replace an existing dictionary entry.

    The key must already exist in a plain dictionary or stream dictionary. Missing keys and non-dictionary inputs raise PdfError::DictionaryKeyNotFound.

    PdfObject::stream_bytes

    source
    fn PdfObject::stream_bytes(self : PdfObject) -> Bytes raise 
    PdfError

    Return a stream object's materialized bytes.

    StreamGot data is returned directly. Deferred StreamToGet data is read from its source cursor and decrypted if necessary, but this method does not mutate the stream object or update /Length; use get_stream for that. Non-stream objects raise PdfError::ParseStreamExpected.

    PdfObject::unique_key

    source

    Generate a dictionary key with the form /<prefix><n> that is not in use.

    The scan starts at n = 0 and increments until the name is absent from the dictionary or stream dictionary. Non-dictionary-like objects raise PdfError::DictionaryExpected.

    PdfObjectData

    source
    pub(all) enum PdfObjectData {
      ObjectParsed(PdfObject)
      ObjectParsedAlreadyDecrypted(PdfObject)
      ObjectToParse
      ObjectToParseFromObjectStream(ObjectStreamReference)
    } derive(Eq, ToJson, 
    Debug    )

    Loading state for one entry in the document object table.

    Parsed variants hold objects that are ready to use. ObjectToParse marks an object that is known from an xref table but has not been read yet. ObjectToParseFromObjectStream records the object-stream location needed to load compressed objects lazily.

    PdfObjectEntry

    source
    pub(all) struct PdfObjectEntry {
      data : PdfObjectData
      generation : Int
    } derive(Eq, ToJson, 
    Debug    )

    One object-table entry together with its generation number.

    The data field is mutable so parsers can replace deferred states with parsed objects after lazy loading.

    PdfObjectEvent

    source
    pub(all) enum PdfObjectEvent {
      ObjectAltered
      ObjectDeleted
    } derive(Eq, ToJson, 
    Debug    )

    Mutation event recorded for incremental-write style bookkeeping.

    PdfObjectMap

    source

    Sparse map from object number to object-table entry.

    This is a thin wrapper around a hash map. It does not track maximum object number or mutation events; use PdfObjects for document-level bookkeeping.

    PdfObjectMap::contains

    source
    fn PdfObjectMap::contains(self : PdfObjectMap, number : Int) -> Bool

    Return whether number has an entry in the object map.

    PdfObjectMap::get_entry

    source
    fn PdfObjectMap::get_entry(self : PdfObjectMap, number : Int) -> PdfObjectEntry?

    Return the object-table entry for number, if present.

    PdfObjectMap::length

    source
    fn PdfObjectMap::length(self : PdfObjectMap) -> Int

    Return the number of entries in the object map.

    PdfObjectMap::lookup_parsed_or_null

    source
    fn PdfObjectMap::lookup_parsed_or_null(self : PdfObjectMap, number : Int) -> PdfObject

    Return a parsed object or PdfNull for missing/deferred entries.

    Both normal parsed objects and already-decrypted parsed objects are returned. Deferred states such as ObjectToParse are treated as absent by this helper.

    PdfObjectMap::object_numbers

    source
    fn PdfObjectMap::object_numbers(self : PdfObjectMap) -> Array[Int]

    Return all object numbers in ascending order.

    PdfObjectMap::remove

    source
    fn PdfObjectMap::remove(self : PdfObjectMap, number : Int) -> Unit

    Remove an object-number entry from the map.

    Missing numbers are ignored.

    PdfObjectMap::set_entry

    source
    fn PdfObjectMap::set_entry(self : PdfObjectMap, number : Int, entry : PdfObjectEntry) -> Unit

    Set or replace the entry for an object number.

    This low-level map operation does not update any mutation log.

    PdfObjects

    source
    pub struct PdfObjects {
      max_object_number : Int
      object_map : PdfObjectMap
      object_stream_ids : 
    HashMap    [Int, Int]
      log : Array[(Int, PdfObjectEvent)]
    } derive(Eq, ToJson, 
    Debug    )

    Document object table with allocation, object-stream, and mutation metadata.

    PdfObjects owns the sparse object map, tracks the highest object number allocated so far, records object-stream identifiers, and stores an alteration log used by writers and tests.

    PdfObjects::add_object

    source
    fn PdfObjects::add_object(self : PdfObjects, object : PdfObject, generation? : Int) -> Int

    Add a parsed object using the next available object number.

    Returns the allocated object number and records an ObjectAltered event.

    PdfObjects::add_object_given_number

    source
    fn PdfObjects::add_object_given_number(self : PdfObjects, number : Int, object : PdfObject, generation? : Int) -> Unit

    Add or replace a parsed object at an explicit object number.

    This updates the maximum object number, stores an ObjectParsed entry, and appends ObjectAltered to the mutation log.

    PdfObjects::get_entry

    source
    fn PdfObjects::get_entry(self : PdfObjects, number : Int) -> PdfObjectEntry?

    Return the object-table entry for number, if present.

    PdfObjects::length

    source
    fn PdfObjects::length(self : PdfObjects) -> Int

    Return the number of object entries currently stored.

    PdfObjects::log

    source
    fn PdfObjects::log(self : PdfObjects) -> Array[(Int, PdfObjectEvent)]

    Return a copy of the object mutation log.

    PdfObjects::lookup_object_or_null

    source
    fn PdfObjects::lookup_object_or_null(self : PdfObjects, number : Int) -> PdfObject

    Return a parsed object by number, or PdfNull if it is absent or deferred.

    PdfObjects::map_objects_in_place

    source
    fn PdfObjects::map_objects_in_place(self : PdfObjects, transform : (PdfObject) -> PdfObject) -> Unit

    Transform every parsed object in place.

    Parsed and already-decrypted entries keep their state tags after the object value is transformed. Deferred entries are left unchanged.

    PdfObjects::max_object_number

    source
    fn PdfObjects::max_object_number(self : PdfObjects) -> Int

    Return the highest object number allocated or loaded so far.

    PdfObjects::object_numbers

    source
    fn PdfObjects::object_numbers(self : PdfObjects) -> Array[Int]

    Return stored object numbers in ascending order.

    PdfObjects::parsed_entries

    source
    fn PdfObjects::parsed_entries(self : PdfObjects) -> Array[(Int, Int, PdfObject)]

    Return parsed object entries as (number, generation, object) triples.

    Results are sorted by object number and exclude deferred entries.

    PdfObjects::remove_object

    source
    fn PdfObjects::remove_object(self : PdfObjects, number : Int) -> Unit

    Remove an object entry and record a deletion event.

    The deletion is logged even if the object number was not present.

    PdfObjects::set_entry

    source
    fn PdfObjects::set_entry(self : PdfObjects, number : Int, entry : PdfObjectEntry) -> Unit

    Set or replace an object-table entry without logging an alteration.

    The tracked maximum object number is raised when number exceeds the previous maximum.

    PdfObjects::stream_entries

    source
    fn PdfObjects::stream_entries(self : PdfObjects) -> Array[(Int, Int, PdfStream)]

    Return parsed stream objects as (number, generation, stream) triples.

    Results are sorted by object number and exclude non-stream or deferred entries.

    PdfOcg

    source
    pub(all) struct PdfOcg {
      name : Bytes
      intent : Array[
    PdfName    ]
      usage : PdfOcgUsage?
    } derive(Eq, ToJson, 
    Debug    )

    One PDF optional content group dictionary.

    The group's indirect object number is stored outside this record in PdfOptionalContent.ocgs; name is the raw PDF string bytes.

    PdfOcgAppDict

    source
    pub(all) struct PdfOcgAppDict {
      event : PdfOcgEvent
      ocgs : Array[Int]
      category : Array[
    PdfName    ]
    } derive(Eq, ToJson, 
    Debug    )

    Optional-content usage application dictionary.

    ocgs contains indirect object numbers of optional content groups, and category stores the PDF usage-category names for the application.

    PdfOcgConfig

    source
    pub(all) struct PdfOcgConfig {
      name : Bytes?
      creator : Bytes?
      base_state : PdfOcgState
      on : Array[Int]
      off : Array[Int]
      intent : Array[
    PdfName    ]
      usage_applications : Array[PdfOcgAppDict]
      order : Array[(Bytes?, Array[Int])]?
      list_mode : PdfOcgListMode
      radio_button_groups : Array[Array[Int]]?
      locked : Array[Int]
    } derive(Eq, ToJson, 
    Debug    )

    Optional-content configuration dictionary.

    Arrays such as on, off, locked, radio-button groups, and order entries contain OCG indirect object numbers. order preserves the PDF layer-panel grouping labels as raw string bytes.

    PdfOcgEvent

    source
    pub(all) enum PdfOcgEvent {
      OcgView
      OcgPrint
      OcgExport
    } derive(Eq, ToJson, 
    Debug    )

    Event context used by optional-content usage application dictionaries.

    PdfOcgListMode

    source
    pub(all) enum PdfOcgListMode {
      OcgAllPages
      OcgVisiblePages
    } derive(Eq, ToJson, 
    Debug    )

    Policy for whether the layer list is shown on all pages or only visible pages.

    PdfOcgState

    source
    pub(all) enum PdfOcgState {
      OcgOn
      OcgOff
      OcgUnchanged
    } derive(Eq, ToJson, 
    Debug    )

    Default visibility state for optional content groups in a configuration.

    PdfOcgUsage

    source
    pub(all) struct PdfOcgUsage {
      creator_info : (Bytes, 
    PdfName    )?
      language : (Bytes, 
    PdfName    ?)?
      export_state : 
    PdfName    ?
      zoom_min : Double?
      zoom_max : Double?
      print_subtype : 
    PdfName    ?
      print_state : 
    PdfName    ?
      view_state : 
    PdfName    ?
      user : (
    PdfName    , Array[Bytes])?
      page_element_subtype : 
    PdfName    ?
    } derive(Eq, ToJson, 
    Debug    )

    Usage dictionary for a PDF optional content group.

    Byte fields preserve PDF string bytes exactly. Name fields preserve the corresponding PDF names for creator, language, export, zoom, print, view, user, and page-element usage hints.

    PdfOptionalContent

    source
    pub(all) struct PdfOptionalContent {
      ocgs : Array[(Int, PdfOcg)]
      default_config : PdfOcgConfig
      configs : Array[PdfOcgConfig]
    } derive(Eq, ToJson, 
    Debug    )

    Complete catalog optional-content properties.

    ocgs pairs each group's existing indirect object number with the parsed group dictionary. default_config maps /D; configs maps alternate entries from /Configs.

    PdfPNG

    source
    pub(all) struct PdfPNG {
      width : Int
      height : Int
      bit_depth : Int
      color_type : Int
      idat : Bytes
    } derive(Eq, ToJson, 
    Debug    )

    Parsed PNG metadata and concatenated IDAT payload.

    This mirrors the small Cpdfpng surface needed for image insertion: non-palette, non-interlaced PNGs with their compressed IDAT bytes preserved.

    PdfPage

    source
    pub(all) struct PdfPage {
      content : Array[PdfObject]
      mediabox : PdfObject
      resources : PdfObject
      rotate : PdfPageRotation
      rest : PdfObject
    } derive(Eq, ToJson, 
    Debug    )

    In-memory page description used by page-tree read and write helpers.

    content stores stream objects or indirect stream references. mediabox, resources, and rest preserve PDF objects so byte-oriented dictionary data is not forced through MoonBit strings.

    PdfPageLabel

    source
    pub(all) struct PdfPageLabel {
      label_style : PdfPageLabelStyle
      label_prefix : Bytes?
      start_page : Int
      start_value : Int
    } derive(Eq, ToJson, 
    Debug    )

    One page-label range.

    start_page is 1-based. start_value is the numeric value shown on that page before style formatting, and label_prefix is stored as PDF bytes.

    PdfPageLabelStyle

    source
    pub(all) enum PdfPageLabelStyle {
      PageLabelDecimalArabic
      PageLabelUppercaseRoman
      PageLabelLowercaseRoman
      PageLabelUppercaseLetters
      PageLabelLowercaseLetters
      PageLabelNoLabelPrefixOnly
    } derive(Eq, ToJson, 
    Debug    )

    Numbering style used for a page-label range.

    PageLabelNoLabelPrefixOnly means no numeric suffix is generated; only the optional prefix contributes to the visible label.

    PdfPageLabelStyle::debug_name

    source
    fn PdfPageLabelStyle::debug_name(self : PdfPageLabelStyle) -> String

    Return a stable debug name for a page-label style.

    PdfPageRotation

    source
    pub(all) enum PdfPageRotation {
      Rotate0
      Rotate90
      Rotate180
      Rotate270
    } derive(Eq, ToJson, 
    Debug    )

    Page rotation normalized to the four rotations allowed by PDF page dictionaries.

    PdfParsedCMap

    source
    pub(all) struct PdfParsedCMap {
      map : Array[(Int, Bytes)]
      cid_map : Array[(Int, Int)]
      notdef_map : Array[(Int, Int)]
      codespaces : Array[PdfCMapCodeSpace]
      usecmap : 
    PdfName    ?
      wmode : Int?
      cmap_name : 
    PdfName    ?
      cmap_type : Int?
      cid_system_info : PdfCIDSystemInfo?
    } derive(Eq, ToJson, 
    Debug    )

    Parsed CMap or ToUnicode stream data.

    map stores character-code to UTF-16BE bytes from bfchar/bfrange, cid_map stores character-code to CID mappings, and notdef_map stores notdef fallback CIDs. Optional metadata is taken from the stream body or stream dictionary when available.

    PdfParsedIndirectObject

    source
    pub(all) struct PdfParsedIndirectObject {
      number : Int
      generation : Int
      object : PdfObject
    } derive(Eq, ToJson, 
    Debug    )

    A parsed indirect object with object number, generation, and payload.

    PdfPath

    source
    pub(all) struct PdfPath {
      winding_rule : PdfPathWindingRule
      subpaths : Array[PdfPathSubpath]
    } derive(Eq, ToJson, 
    Debug    )

    A cpdf-style path.

    PdfPath::bounds

    source
    fn PdfPath::bounds(self : PdfPath) -> PdfRectangle

    Return cpdfcontent's axis-aligned bounding box for a path.

    Empty paths return a zero rectangle, matching cpdfcontent.ml.

    PdfPath::content_bounding_box

    source
    fn PdfPath::content_bounding_box(self : PdfPath, ctm : 
    TransformMatrix    , line_width : Double, stroking : Bool) -> PdfContentBoundingBox?

    Return cpdfcontent's emitted path bounding-box quad.

    The path is first transformed by the current transformation matrix. When stroking is true, the transformed line-width vector expands the box by half its absolute x/y displacement, matching emit_path_bounding_box.

    PdfPath::transform

    source

    Transform every point in a path.

    PdfPathClosure

    source
    pub(all) enum PdfPathClosure {
      PdfPathClosed
      PdfPathOpen
    } derive(Eq, ToJson, 
    Debug    )

    Whether a subpath is open or closed.

    PdfPathHole

    source
    pub(all) enum PdfPathHole {
      PdfPathHole
      PdfPathNotHole
    } derive(Eq, ToJson, 
    Debug    )

    Whether a subpath is a hole in the containing path.

    PdfPathSegment

    source

    One straight or Bezier path segment.

    PdfPathSegment::bounds

    source

    Return cpdfcontent's control-point bounding box for a path segment.

    Bezier bounds intentionally include the two control points rather than solving for curve extrema, matching cpdfcontent.ml's bbox_of_segment.

    PdfPathSegment::content_json

    source
    fn PdfPathSegment::content_json(self : PdfPathSegment) -> Json

    Return cpdfcontent's JSON shape for one path segment.

    PdfPathSegment::transform

    source

    Transform every point in a path segment.

    PdfPathSubpath

    source
    pub(all) struct PdfPathSubpath {
      hole : PdfPathHole
      closure : PdfPathClosure
      segments : Array[PdfPathSegment]
    } derive(Eq, ToJson, 
    Debug    )

    A cpdf-style subpath.

    PdfPathSubpath::content_json

    source
    fn PdfPathSubpath::content_json(self : PdfPathSubpath) -> Json

    Return cpdfcontent's JSON shape for one subpath.

    The hole flag is intentionally not emitted, matching cpdfcontent.ml.

    PdfPathWindingRule

    source
    pub(all) enum PdfPathWindingRule {
      PdfPathEvenOdd
      PdfPathNonZero
    } derive(Eq, ToJson, 
    Debug    )

    Fill rule for a cpdf-style path.

    PdfPixelLayout

    source
    pub(all) enum PdfPixelLayout {
      PdfBPP1
      PdfBPP8
      PdfBPP24
      PdfBPP48
    } derive(Eq, ToJson, 
    Debug    )

    Pixel layout for extracted raw image data.

    PdfPortfolioEntry

    source
    pub(all) struct PdfPortfolioEntry {
      filename : String
      data : Bytes
      relationship : String?
      description : String?
    } derive(Eq, ToJson, 
    Debug    )

    One file to embed in a PDF portfolio.

    filename is used for the portfolio name-tree key and its basename is used for the file specification names. data is the raw embedded-file payload.

    PdfPosition

    source
    pub(all) enum PdfPosition {
      PdfPositionPosCentre(Double, Double)
      PdfPositionPosLeft(Double, Double)
      PdfPositionPosRight(Double, Double)
      PdfPositionTop(Double)
      PdfPositionTopLeft(Double, Double)
      PdfPositionTopRight(Double, Double)
      PdfPositionLeft(Double)
      PdfPositionBottomLeft(Double, Double)
      PdfPositionBottom(Double)
      PdfPositionBottomRight(Double, Double)
      PdfPositionRight(Double)
      PdfPositionDiagonal
      PdfPositionReverseDiagonal
      PdfPositionCentre
    } derive(Eq, ToJson, 
    Debug    )

    Position keywords used by cpdf-style text and layout operations.

    PdfRectangle

    source
    pub(all) struct PdfRectangle {
      min_x : Double
      min_y : Double
      max_x : Double
      max_y : Double
    } derive(Eq, ToJson, 
    Debug    )

    A normalized rectangle in PDF user-space coordinates.

    min_x and min_y are always the lower bounds, and max_x and max_y are always the upper bounds. Parsers normalize PDF rectangle arrays whose coordinates are written in the opposite order.

    PdfSampledFunction

    source
    pub(all) struct PdfSampledFunction {
      size : Array[Int]
      order : Int
      encode : Array[Double]
      decode : Array[Double]
      bits_per_sample : Int
      samples : Array[Int]
    } derive(Eq, ToJson, 
    Debug    )

    PDF function type 0, sampled from a packed sample table.

    size gives the sample count for each input dimension. encode maps clamped domain inputs to sample coordinates, decode maps sample values to output values, and samples stores decoded integer samples with the first input dimension varying fastest.

    PdfSavedEncryption

    source
    type PdfSavedEncryption derive(Eq, ToJson, 
    Debug    )

    Saved encryption state retained on a decrypted document.

    Recrypt helpers use this to put a previously encrypted document back into its original security-handler shape after edits.

    PdfSimpleFont

    source
    pub(all) struct PdfSimpleFont {
      fonttype : PdfSimpleFontType
      basefont : 
    PdfName    ?
      firstchar : Int
      lastchar : Int
      widths : Array[Int]
      fontdescriptor : PdfFontDescriptor?
      fontmetrics : Array[Double]?
      encoding : PdfEncoding
    } derive(Eq, ToJson, 
    Debug    )

    Parsed simple-font dictionary.

    The record preserves declared widths and descriptors when present. Missing metrics are resolved from standard-font fallback data where possible.

    PdfSimpleFont::debug_name

    source
    fn PdfSimpleFont::debug_name(self : PdfSimpleFont) -> String

    Return a multi-line debug summary for this simple font.

    PdfSimpleFontType

    source
    pub(all) enum PdfSimpleFontType {
      PdfType1
      PdfMMType1
      PdfType3(PdfType3Glyphs)
      PdfTrueType
    } derive(Eq, ToJson, 
    Debug    )

    Simple-font subtype recognized by the PDF text layer.

    Type 1, MMType1, Type 3, and TrueType fonts all use one-byte character codes after their encoding differences have been applied.

    PdfSimpleFontType::debug_name

    source
    fn PdfSimpleFontType::debug_name(self : PdfSimpleFontType) -> String

    Return a human-readable simple-font subtype label.

    Type 3 labels include the declared CharProc names to make debugging parsed glyph programs easier.

    PdfStandardFont

    source
    pub(all) enum PdfStandardFont {
      PdfTimesRoman
      PdfTimesBold
      PdfTimesItalic
      PdfTimesBoldItalic
      PdfHelvetica
      PdfHelveticaBold
      PdfHelveticaOblique
      PdfHelveticaBoldOblique
      PdfCourier
      PdfCourierBold
      PdfCourierOblique
      PdfCourierBoldOblique
      PdfSymbol
      PdfZapfDingbats
    } derive(Eq, ToJson, 
    Debug    )

    The built-in PDF standard 14 font faces.

    These values name the base fonts that a conforming PDF reader is expected to know without an embedded font program. The variants match the canonical PDF names used in /BaseFont entries.

    PdfStandardFont::afm_data

    source

    Returns the Adobe Font Metrics data for this standard font.

    PdfStandardFont::baseline_adjustment

    source
    fn PdfStandardFont::baseline_adjustment(self : PdfStandardFont) -> Int

    Return a synthetic baseline adjustment for simple standard-font placement.

    The value is derived from the font ascent-like metrics used by the original CamlPDF helpers and is expressed in glyph-space units.

    PdfStandardFont::flags

    source
    fn PdfStandardFont::flags(self : PdfStandardFont) -> Int

    Return PDF font descriptor flags for this standard font.

    The flags distinguish symbolic fonts, fixed-pitch Courier faces, and the nonsymbolic roman faces according to the PDF font descriptor bit layout.

    PdfStandardFont::name

    source
    fn PdfStandardFont::name(self : PdfStandardFont) -> String

    Return the canonical standard-font name without the leading PDF slash.

    PdfStandardFont::pdf_name

    source

    Return the canonical PDF name object for this standard font.

    The returned name includes the leading slash in the underlying PdfName bytes and is suitable for /BaseFont dictionary entries.

    PdfStandardFont::stemv

    source
    fn PdfStandardFont::stemv(self : PdfStandardFont) -> Int

    Return the standard-font StemV descriptor value used when writing fonts.

    PdfStandardFont::text_width

    source
    fn PdfStandardFont::text_width(self : PdfStandardFont, encoding : PdfEncoding, text : BytesView, kern? : Bool) -> Int

    Computes the width of byte-encoded text for this standard font.

    PdfStandardFontData

    source
    pub(all) struct PdfStandardFontData {
      font : PdfStandardFont
      encoding : PdfEncoding
    } derive(Eq, ToJson, 
    Debug    )

    Parsed standard-font data with its active character encoding.

    Standard 14 fonts do not carry embedded metrics in normal PDF files, so extraction combines the font identity with the chosen simple-font encoding.

    PdfStandardFontData::debug_name

    source
    fn PdfStandardFontData::debug_name(self : PdfStandardFontData) -> String

    Return a compact debug label for this standard font data.

    PdfStandardFontData::text_width

    source
    fn PdfStandardFontData::text_width(self : PdfStandardFontData, text : BytesView, kern? : Bool) -> Int

    Computes the width of byte-encoded text using this standard-font data and its encoding.

    PdfStitchingFunction

    source
    pub(all) struct PdfStitchingFunction {
      functions : Array[PdfFunction]
      bounds : Array[Double]
      stitch_encode : Array[Double]
    } derive(Eq, ToJson, 
    Debug    )

    PDF function type 3, stitching several child functions over one input.

    bounds partitions the parent domain, and stitch_encode maps each chosen segment into the selected child function's input domain.

    PdfStream

    source
    pub(all) struct PdfStream {
      dictionary : PdfObject
      data : PdfStreamData
    } derive(Eq, ToJson, 
    Debug    )

    A PDF stream object: dictionary metadata plus stream bytes.

    The dictionary and data fields are mutable because helpers such as get_stream and the dictionary update methods materialize stream data and update stream dictionaries in place.

    PdfStreamData

    source
    pub(all) enum PdfStreamData {
      StreamGot(Bytes)
      StreamToGet(ToGet)
    } derive(Eq, ToJson, 
    Debug    )

    Storage state for a PDF stream body.

    StreamGot stores already materialized bytes. StreamToGet stores a deferred slice of an input buffer, optionally with stream decryption metadata that is applied when the data is read.

    PdfStreamDataCrypt

    source
    pub(all) enum PdfStreamDataCrypt {
      PdfStreamDataNoCrypt
      PdfStreamDataArc4Decrypt(Int, Int, Bytes, Int)
      PdfStreamDataAesV2Decrypt(Int, Int, Bytes, Int)
      PdfStreamDataAesV3Decrypt(Bytes)
    } derive(Eq, ToJson, 
    Debug    )

    Decryption metadata associated with deferred stream data.

    The variants correspond to the stream ciphers supported by the PDF security handler. Object-specific ciphers store object number, generation, file key, and key length; AES-V3 stores the already derived file key.

    PdfStreamEncoding

    source
    pub(all) enum PdfStreamEncoding {
      PdfStreamASCIIHex
      PdfStreamASCII85
      PdfStreamRunLength
      PdfStreamFlate
      PdfStreamCCITT(Int, Int)
      PdfStreamCCITTG4(Int, Int)
    } derive(Eq, ToJson, 
    Debug    )

    Stream encoding requested by high-level stream encode helpers.

    CCITT variants carry image columns and rows because those values are needed in /DecodeParms when writing fax-compressed image streams.

    PdfStreamEncoding::filter_name

    source

    Return the PDF filter name for this stream encoding.

    PdfStreamPredictor

    source
    pub(all) enum PdfStreamPredictor {
      PdfStreamPredictorTIFF2
      PdfStreamPredictorPNGNone
      PdfStreamPredictorPNGSub
      PdfStreamPredictorPNGUp
      PdfStreamPredictorPNGAverage
      PdfStreamPredictorPNGPaeth
      PdfStreamPredictorPNGOptimum
    } derive(Eq, ToJson, 
    Debug    )

    PNG/TIFF predictor requested when encoding stream data.

    Predictor values correspond to PDF /Predictor numbers.

    PdfStreamPredictor::number

    source
    fn PdfStreamPredictor::number(self : PdfStreamPredictor) -> Int

    Return the PDF /Predictor number for this predictor.

    PdfStrftimeTime

    source
    pub(all) struct PdfStrftimeTime {
      tm_sec : Int
      tm_min : Int
      tm_hour : Int
      tm_mday : Int
      tm_mon : Int
      tm_year : Int
      tm_wday : Int
      tm_yday : Int
      tm_isdst : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Platform-independent time record used by cpdf-style strftime.

    tm_year is years since 1900 and tm_mon is zero-based, matching C/Unix struct tm and OCaml's Unix.tm.

    PdfTargetPage

    source
    pub(all) enum PdfTargetPage {
      TargetPageObject(Int)
      TargetOtherDocPageNumber(Int)
    } derive(Eq, ToJson, 
    Debug    )

    A destination target page reference.

    PDF destination arrays may refer either to a page object or to a page number in another document.

    PdfTextExtractor

    source
    pub(all) struct PdfTextExtractor {
      font : PdfFont
    } derive(Eq, ToJson, 
    Debug    )

    Text extractor bound to a parsed font.

    The extractor converts PDF text-string bytes to character codes, glyph names, and Unicode codepoints according to the font's encoding data.

    PdfTextExtractor::charcode_of_codepoint

    source
    fn PdfTextExtractor::charcode_of_codepoint(self : PdfTextExtractor, codepoint : Int) -> Int?

    Return a PDF character code that can encode one Unicode codepoint.

    The lookup prefers explicit ToUnicode reverse mappings, then predefined or external CMap reverse lookup, then simple-font glyph names. None means the current font has no known single-codepoint representation.

    PdfTextExtractor::codepoints_of_text

    source
    fn PdfTextExtractor::codepoints_of_text(self : PdfTextExtractor, text : BytesView) -> Array[Int] raise 
    PdfError

    Extract Unicode codepoints from PDF text bytes.

    /ToUnicode mappings take precedence. External CMaps, predefined CMaps, glyph names, and font-specific fallbacks are used when no explicit ToUnicode mapping exists. Multi-codepoint glyph names are flattened into the returned array.

    PdfTextExtractor::glyphnames_and_codepoints_of_text

    source
    fn PdfTextExtractor::glyphnames_and_codepoints_of_text(self : PdfTextExtractor, text : BytesView) -> Array[PdfTextGlyph] raise 
    PdfError

    Resolve glyph names and Unicode codepoints for each character code in text.

    This lower-level extractor exposes both sides of the mapping. The input is a PDF text byte sequence, not a MoonBit String, and malformed byte segmentation raises PdfError.

    PdfTextExtractor::glyphnames_of_text

    source

    Resolve only glyph names from PDF text bytes.

    This bypasses Unicode conversion and is useful for callers that need the encoded glyph identity rather than extracted text.

    PdfTextExtractor::text_width

    source
    fn PdfTextExtractor::text_width(self : PdfTextExtractor, text : BytesView) -> Double raise 
    PdfError

    Measure PDF text bytes in glyph-space units for this extractor's font.

    Text bytes are segmented according to the font encoding. Malformed byte sequences raise PdfError, and missing metrics contribute width 0.

    PdfTextGlyph

    source
    pub(all) struct PdfTextGlyph {
      glyphname : 
    PdfName
      codepoints : Array[Int]
    } derive(Eq, ToJson, 
    Debug    )

    Extracted glyph result for one character code.

    glyphname is the resolved PDF glyph name and codepoints is the Unicode scalar sequence inferred from ToUnicode, CMap, or Adobe glyph-list data.

    PdfTocFontSource

    source
    pub(all) enum PdfTocFontSource {
      PdfTocPreMadeFontPack(PdfFontPack)
      PdfTocExistingNamedFont
    } derive(Eq, ToJson, 
    Debug    )

    Font source options for table-of-contents generation.

    This ports the non-embedding cpdftoc font-source dispatch. TrueType EmbedInfo remains a separate embedding slice.

    PdfTristimulusPoint

    source
    pub(all) struct PdfTristimulusPoint {
      x : Double
      y : Double
      z : Double
    } derive(Eq, ToJson, 
    Debug    )

    A CIE tristimulus point used by calibrated PDF colour spaces.

    The fields represent the X, Y, and Z components used for white point and black point entries in /CalGray, /CalRGB, and /Lab dictionaries.

    PdfType3Glyphs

    source

    Type 3 font glyph-program data.

    charprocs keeps glyph names paired with their drawing streams and resources is the Type 3 resource dictionary used when interpreting those glyph programs.

    PdfTypeElement

    source
    pub(all) enum PdfTypeElement {
      PdfTypeText(Bytes)
      PdfTypeHGlue(Double)
      PdfTypeVGlue(Double)
      PdfTypeNewLine
      PdfTypeNewPage
      PdfTypeFont(String, PdfFont, Double)
      PdfTypeBeginDest(PdfDestination, String?)
      PdfTypeEndDest
      PdfTypeBeginDocument
      PdfTypeTag(String, Int)
      PdfTypeEndTag
    } derive(Eq, ToJson, 
    Debug    )

    Element stream consumed by the cpdftype layout pipeline.

    PdfTypeText stores raw one-byte PDF charcodes, matching the OCaml char list representation rather than Unicode text.

    PdfTypeTypesetResult

    source
    pub(all) struct PdfTypeTypesetResult {
      pages : Array[PdfPage]
      tags : Array[Array[(String, Int)]]
    } derive(Eq, ToJson, 
    Debug    )

    Pages and per-page structure tags produced by the cpdftype typesetter.

    PdfUASubformat

    source
    pub(all) enum PdfUASubformat {
      PdfUA1
      PdfUA2
    } derive(Eq, ToJson, 
    Debug    )

    PDF/UA subformat selector used by CamlPDF-facing creation helpers.

    PdfUnicodeDataEntry

    source
    pub(all) struct PdfUnicodeDataEntry {
      code_value : String
      character_name : String
      general_category : String
      canonical_combining_classes : String
      bidirectional_category : String
      character_decomposition_mapping : String
      decimal_digit_value : String
      digit_value : String
      numeric_value : String
      mirrored : String
      unicode_10_name : String
      iso_10646_comment_field : String
      uppercase_mapping : String
      lowercase_mapping : String
      titlecase_mapping : String
    } derive(Eq, ToJson, 
    Debug    )

    One row from UnicodeData.txt as exposed by cpdf's Cpdfunicodedata.t.

    UnicodeData.txt is an ASCII, semicolon-separated data file. The fields stay as strings to match cpdf's public record and to avoid silently choosing semantics for numeric-looking values such as code values and mappings.

    PdfVersion

    source
    pub(all) struct PdfVersion {
      major : Int
      minor : Int
    } derive(Eq, ToJson, 
    Debug    )

    Parsed PDF header version.

    The fields correspond to the digits in a %PDF-major.minor header.

    PdfWriteEncryption

    source
    pub(all) struct PdfWriteEncryption {
      encryption_method : 
    PdfEncryptionMethod
      user_password : Bytes
      owner_password : Bytes
      denied_permissions : Array[
    PdfPermission    ]
    } derive(Eq, ToJson, 
    Debug    )

    Encryption options for pdf_write_document_options.

    Passwords are stored as owned PDF bytes so callers can pass borrowed BytesView values safely.

    PdfWriteMode

    source
    pub(all) enum PdfWriteMode {
      PdfWriteClassic
      PdfWriteXRefStream
      PdfWriteCompressedXRefStream
    } derive(Eq, ToJson, 
    Debug    )

    Cross-reference format used when serializing a document.

    Classic writes a traditional xref table and trailer. XRefStream writes an uncompressed xref stream, and CompressedXRefStream wraps that stream in Flate compression.

    ToGet

    source
    pub(all) struct ToGet {
      input : ByteCursor
      position : Int
      length : Int
      crypt : PdfStreamDataCrypt
    } derive(Eq, ToJson, 
    Debug    )

    A deferred stream-data slice read from an input cursor.

    position and length identify the raw byte range in input; crypt records the decryption operation to apply when the bytes are materialized. This lets the reader keep large stream bodies lazy until a caller requests their bytes.

    ToGet::crypt

    source
    fn ToGet::crypt(self : ToGet) -> PdfStreamDataCrypt

    Return the decryption metadata for a deferred stream slice.

    ToGet::input

    source
    fn ToGet::input(self : ToGet) -> ByteCursor

    Return the source cursor used by a deferred stream slice.

    ToGet::length

    source
    fn ToGet::length(self : ToGet) -> Int

    Return the byte length of a deferred stream slice.

    ToGet::position

    source
    fn ToGet::position(self : ToGet) -> Int

    Return the start position of a deferred stream slice.

    The value is interpreted relative to the ByteCursor's offset when the stream is materialized.

    bit_writer_new

    source
    fn bit_writer_new() -> BitWriter

    Creates an empty bit writer.

    bitstream_of_bytes

    source
    fn bitstream_of_bytes(data : Bytes, source? : String) -> BitStream

    Creates a bit stream over owned PDF bytes.

    The optional source label is forwarded to the underlying cursor and is used in parse error messages.

    bitstream_of_cursor

    source
    fn bitstream_of_cursor(input : ByteCursor) -> BitStream

    Creates a bit stream that reads from an existing byte cursor.

    bitstream_of_view

    source
    fn bitstream_of_view(data : BytesView, source? : String) -> BitStream

    Creates a bit stream over a read-only byte view.

    The returned reader does not copy data; callers that need ownership should pass owned bytes explicitly.

    byte_cursor_of_bytes

    source
    fn byte_cursor_of_bytes(data : Bytes, source? : String) -> ByteCursor

    Creates a cursor over owned PDF bytes.

    The cursor borrows the byte storage through a view and does not copy it.

    byte_cursor_of_view

    source
    fn byte_cursor_of_view(data : BytesView, source? : String) -> ByteCursor

    Creates a cursor over a byte view.

    The optional source label appears in parse error messages.

    byte_output_new

    source
    fn byte_output_new(initial_size? : Int) -> ByteOutput raise 
    PdfError

    Creates an empty output buffer.

    initial_size preallocates zero-filled capacity but does not count as written output. Raises PdfError::InvalidReadLength for negative sizes.

    decompress_pdf

    source
    fn decompress_pdf(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::decompress.

    paper_a0

    source

    ISO A0 paper, 841 mm by 1189 mm.

    paper_a1

    source

    ISO A1 paper, 594 mm by 841 mm.

    paper_a10

    source

    ISO A10 paper, 26 mm by 37 mm.

    paper_a2

    source

    ISO A2 paper, 420 mm by 594 mm.

    paper_a3

    source

    ISO A3 paper, 297 mm by 420 mm.

    paper_a4

    source

    ISO A4 paper, 210 mm by 297 mm.

    paper_a5

    source

    ISO A5 paper, 148 mm by 210 mm.

    paper_a6

    source

    ISO A6 paper, 105 mm by 148 mm.

    paper_a7

    source

    ISO A7 paper, 74 mm by 105 mm.

    paper_a8

    source

    ISO A8 paper, 52 mm by 74 mm.

    paper_a9

    source

    ISO A9 paper, 37 mm by 52 mm.

    paper_size_make

    source
    fn paper_size_make(unit : 
    PdfUnit    , width : Double, height : Double) -> 
    PaperSize

    Creates a paper size from a unit, width, and height.

    paper_uslegal

    source

    US Legal paper, 8.5 inches by 14 inches.

    paper_usletter

    source

    US Letter paper, 8.5 inches by 11 inches.

    pdf_add_annotation

    source
    fn pdf_add_annotation(document : PdfDocument, page : PdfPage, annotation : PdfAnnotation) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_annotation.

    pdf_add_bookmark_title

    source
    fn pdf_add_bookmark_title(filename : String, use_title : Bool, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_bookmark_title.

    pdf_add_bookmarks

    source
    fn pdf_add_bookmarks(bookmarks : ArrayView[PdfBookmark], document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_bookmarks.

    pdf_add_bookmarks_from_json

    source
    fn pdf_add_bookmarks_from_json(verify : Bool, json : Json, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_bookmarks_from_json.

    pdf_add_bookmarks_from_text

    source
    fn pdf_add_bookmarks_from_text(verify : Bool, data : BytesView, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_bookmarks_from_text.

    pdf_add_page_labels

    source
    fn pdf_add_page_labels(document : PdfDocument, progress : Bool, style : PdfPageLabelStyle, prefix : Bytes?, start_value : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_page_labels.

    pdf_add_page_labels_json

    source
    fn pdf_add_page_labels_json(document : PdfDocument, json : Json) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_page_labels_json.

    pdf_add_pagetree

    source
    fn pdf_add_pagetree(pages : ArrayView[PdfPage], document : PdfDocument) -> (PdfDocument, Int) raise 
    PdfError

    Copy a document, add a page tree, and return the copy with the tree root.

    pdf_add_prefix

    source
    fn pdf_add_prefix(document : PdfDocument, prefix : String) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::add_prefix.

    pdf_add_root

    source
    fn pdf_add_root(page_root_number : Int, extras : ArrayView[(
    PdfName    , PdfObject)], document : PdfDocument) -> PdfDocument raise 
    PdfError

    Copy a document, add a catalog root, and return the copy.

    pdf_addtext_allocate_font_names

    source

    Allocate cpdf add-text font resource names for the selected font and optional font pack.

    pdf_addtext_apply_justification_offset

    source
    fn pdf_addtext_apply_justification_offset(rotation : PdfAddTextRotation, horizontal_offset : Double, vertical_offset : Double, justification_offset : Double) -> (Double, Double)

    Apply cpdf's scalar justification offset to (horizontal, vertical).

    pdf_addtext_baseline_offsets

    source
    fn pdf_addtext_baseline_offsets(font : PdfFont?, font_size : Double, position : PdfPosition, rotation : PdfAddTextRotation, midline : Bool, topline : Bool) -> (Double, Double)

    Return cpdf's (horizontal, vertical) baseline shift for midline/topline add-text placement.

    pdf_addtext_bates_number

    source
    fn pdf_addtext_bates_number(bates : Int, page_number : Int, bates_pad : Int?) -> String

    Format cpdf add-text's %Bates replacement for one page.

    pdf_addtext_bookmark_for_page

    source
    fn pdf_addtext_bookmark_for_page(document : PdfDocument, bookmarks : ArrayView[PdfBookmark], level : Int, page_number : Int) -> String raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_bookmark_for_page.

    pdf_addtext_calc_textwidth

    source
    fn pdf_addtext_calc_textwidth(document : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : BytesView) -> Double raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_calc_textwidth.

    pdf_addtext_cap_height

    source
    fn pdf_addtext_cap_height(font : PdfFont?, fontname : String) -> Double?

    Return the cap height used by cpdf add-text URL link rectangles.

    Explicit simple-font descriptors win. Otherwise fontname is resolved as a Standard 14 font name without a leading slash, matching cpdf's fallback.

    pdf_addtext_charcodes_of_utf8

    source
    fn pdf_addtext_charcodes_of_utf8(font : PdfFont, text : String) -> Bytes raise 
    PdfError

    Convert UTF-8 add-text input to PDF charcode bytes for font.

    Codepoints not representable by the font are skipped, matching cpdf's option_map behavior in charcodes_of_utf8.

    pdf_addtext_colour_op

    source
    fn pdf_addtext_colour_op(colour : PdfContentColour) -> PdfContentOp

    Build the cpdf add-text fill colour operator.

    pdf_addtext_colour_op_stroke

    source
    fn pdf_addtext_colour_op_stroke(colour : PdfContentColour) -> PdfContentOp

    Build the cpdf add-text stroke colour operator.

    pdf_addtext_diagonal_offsets

    source
    fn pdf_addtext_diagonal_offsets(bounds : PdfRectangle, position : PdfPosition, rotation : PdfAddTextRotation, text_width : Double, horizontal_offset : Double, vertical_offset : Double, base_rotation : Double) -> (Double, Double)

    Adjust cpdf add-text offsets for diagonal and reverse-diagonal placement.

    pdf_addtext_effective_encoding

    source
    fn pdf_addtext_effective_encoding(font : PdfFont?) -> PdfEncoding

    Return the text encoding cpdf add-text uses for the selected font.

    pdf_addtext_existing_font_resource

    source

    Compatibility wrapper for PdfDocument::addtext_existing_font_resource.

    pdf_addtext_expand_lines_with_time

    source
    fn pdf_addtext_expand_lines_with_time(time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)]) -> Array[String] raise 
    PdfError

    Expand add-text lines and strip URL markup before line measurement.

    This mirrors cpdf's expand_lines behavior after callers have supplied the document-specific replacement callbacks.

    pdf_addtext_fontpack_resource_dictionary

    source
    fn pdf_addtext_fontpack_resource_dictionary(fontdict : PdfObject, unique_fontnames : ArrayView[
    PdfName    ], font_objects : ArrayView[Int]) -> PdfObject raise 
    PdfError

    Replace cpdf add-text fontpack placeholders with embedded font references.

    pdf_addtext_get_urls_line

    source
    fn pdf_addtext_get_urls_line(line : String) -> PdfAddTextUrlLine raise 
    PdfError

    Strip cpdf add-text %URL[text|url] markup from one line.

    The returned URL spans use byte offsets in the stripped visible text, as in cpdf's get_urls_line helper.

    pdf_addtext_initial_line_offsets

    source
    fn pdf_addtext_initial_line_offsets(position : PdfPosition, line_count : Int, line_spacing : Double, font_size : Double) -> (Double, Double)

    Return cpdf's initial (horizontal, vertical) offset for a multi-line add-text paragraph.

    pdf_addtext_install_font_resource

    source
    fn pdf_addtext_install_font_resource(resources : PdfObject, fontdict : PdfObject, unique_fontname : 
    PdfName    , font_object : PdfObject?) -> PdfObject raise 
    PdfError

    Install one selected add-text font resource into a page resource dictionary.

    pdf_addtext_install_fontpack_resources

    source
    fn pdf_addtext_install_fontpack_resources(resources : PdfObject, fontdict : PdfObject, unique_fontnames : ArrayView[
    PdfName    ], font_objects : ArrayView[Int]) -> PdfObject raise 
    PdfError

    Install cpdf add-text fontpack resources into a page resource dictionary.

    pdf_addtext_justification_offset

    source
    fn pdf_addtext_justification_offset(rotation : PdfAddTextRotation, longest_width : Double, width : Double, position : PdfPosition, justification : PdfAddTextJustification) -> Double

    Return cpdf's add-text justification offset for the current line.

    longest_width is the maximum rendered width among the expanded text lines, and width is the current line width.

    pdf_addtext_line_advance

    source
    fn pdf_addtext_line_advance(rotation : PdfAddTextRotation, line_spacing : Double, font_size : Double) -> (Double, Double)

    Return cpdf's per-line (horizontal, vertical) advance for add-text.

    pdf_addtext_line_page

    source
    fn pdf_addtext_line_page(document : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, text : String, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , horizontal_offset? : Double, vertical_offset? : Double, shift_x? : Double, shift_y? : Double, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_line_page.

    pdf_addtext_line_placement

    source
    fn pdf_addtext_line_placement(bounds : PdfRectangle, position : PdfPosition, rotation : PdfAddTextRotation, text_width : Double, longest_width : Double, horizontal_offset : Double, vertical_offset : Double, justification : PdfAddTextJustification) -> PdfAddTextLinePlacement

    Resolve cpdf add-text placement values for one line.

    This combines cpdf's calculate_position, diagonal offset correction, justification offset application, explicit text rotation, and rotation-origin offset selection.

    pdf_addtext_line_widths

    source
    fn pdf_addtext_line_widths(document : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : BytesView, expanded_lines : ArrayView[Bytes]) -> PdfAddTextLineWidths raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_line_widths.

    pdf_addtext_lines_for_rotation

    source
    fn pdf_addtext_lines_for_rotation(text : String, rotation : PdfAddTextRotation) -> Array[String] raise 
    PdfError

    Split and unescape add-text lines, reversing them for upside-down rotations.

    pdf_addtext_longest_width

    source
    fn pdf_addtext_longest_width(widths : ArrayView[Double]) -> Double raise 
    PdfError

    Return the widest add-text line width.

    pdf_addtext_measurement_bytes

    source
    fn pdf_addtext_measurement_bytes(font : PdfFont?, fontpack : PdfFontPack?, raw : Bool, text : String) -> Bytes raise 
    PdfError

    Return the byte string cpdf add-text uses for measuring a visible line.

    Raw mode and font-pack mode keep UTF-8 bytes. Selected simple-font mode converts Unicode text to PDF character codes first, matching cpdf's non-raw line measurement path.

    pdf_addtext_opacity_resources

    source
    fn pdf_addtext_opacity_resources(document : PdfDocument, resources : PdfObject, opacity : Double) -> (PdfObject, 
    PdfName    ?) raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_opacity_resources.

    pdf_addtext_page_font_dictionary

    source
    fn pdf_addtext_page_font_dictionary(document : PdfDocument, page : PdfPage) -> PdfObject

    Compatibility wrapper for PdfDocument::addtext_page_font_dictionary.

    pdf_addtext_page_label

    source
    fn pdf_addtext_page_label(document : PdfDocument, page_number : Int) -> String raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_page_label.

    pdf_addtext_page_lines

    source
    fn pdf_addtext_page_lines(document : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, shift_x? : Double, shift_y? : Double, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_page_lines.

    pdf_addtext_page_rest_with_annotations

    source
    fn pdf_addtext_page_rest_with_annotations(document : PdfDocument, rest : PdfObject, annotations : ArrayView[PdfObject]) -> PdfObject raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_page_rest_with_annotations.

    pdf_addtext_pages_with_font

    source
    fn pdf_addtext_pages_with_font(document : PdfDocument, page_numbers : ArrayView[Int], lines : ArrayView[String], time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_pages_with_font.

    pdf_addtext_prepare_line

    source
    fn pdf_addtext_prepare_line(document : PdfDocument, page : PdfPage, time : PdfStrftimeTime, lines : ArrayView[String], replacements : ArrayView[(String, () -> String)], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, text : String, position : PdfPosition, relative_to_box? : 
    PdfName    , horizontal_offset? : Double, vertical_offset? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, raw? : Bool) -> PdfAddTextPreparedLine raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_prepare_line.

    pdf_addtext_process_text_with_time

    source
    fn pdf_addtext_process_text_with_time(time : PdfStrftimeTime, text : String, replacements : ArrayView[(String, () -> String)]) -> String

    Apply cpdf add-text replacements, then run the cpdf strftime pass.

    Replacement callbacks are only evaluated for markers that occur in text, matching cpdf's string_replace_all_lazy helper.

    pdf_addtext_rectangle

    source
    fn pdf_addtext_rectangle(document : PdfDocument, page_numbers : ArrayView[Int], coord : String, colour : PdfContentColour, position : PdfPosition, relative_to_box? : 
    PdfName    , outline? : Bool, line_width? : Double, opacity? : Double, underneath? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_rectangle.

    pdf_addtext_rectangle_ops

    source
    fn pdf_addtext_rectangle_ops(x : Double, y : Double, width : Double, height : Double, colour : PdfContentColour, outline : Bool, line_width : Double, extgstate_name : 
    PdfName    ?) -> Array[PdfContentOp]

    Build cpdf add-rectangle content operators after placement is resolved.

    pdf_addtext_rectangle_origin

    source
    fn pdf_addtext_rectangle_origin(bounds : PdfRectangle, position : PdfPosition, width : Double, height : Double) -> (Double, Double)

    Calculate the cpdf add-rectangle lower-left origin after placement.

    pdf_addtext_replacement_pairs

    source
    fn pdf_addtext_replacement_pairs(values : PdfAddTextReplacementValues) -> Array[(String, () -> String)]

    Build cpdf add-text replacement callbacks for page-local fields.

    Page labels and bookmark strings are supplied by the caller; this helper preserves cpdf's marker names and Bates/roman/page-number formatting.

    pdf_addtext_replacement_values

    source
    fn pdf_addtext_replacement_values(document : PdfDocument, bookmarks : ArrayView[PdfBookmark], page_number : Int, end_page : Int, filename : String, bates : Int, bates_pad : Int?) -> PdfAddTextReplacementValues raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_replacement_values.

    pdf_addtext_resource_setup

    source
    fn pdf_addtext_resource_setup(document : PdfDocument, page : PdfPage, font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_object : PdfObject?, fontpack_font_objects : ArrayView[Int], opacity : Double) -> PdfAddTextResourceSetup raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_resource_setup.

    pdf_addtext_rotation_offsets

    source
    fn pdf_addtext_rotation_offsets(position : PdfPosition, rotation : PdfAddTextRotation, text_width : Double) -> (Double, Double)

    Return cpdf's rotation-dependent text origin offset.

    pdf_addtext_rotation_radians

    source
    fn pdf_addtext_rotation_radians(rotation : PdfAddTextRotation) -> Double

    Convert cpdf add-text's explicit rotation enum to content rotation radians.

    pdf_addtext_selected_font_object

    source
    fn pdf_addtext_selected_font_object(document : PdfDocument, font : PdfFont?) -> PdfObject? raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_selected_font_object.

    pdf_addtext_split_at_newline

    source
    fn pdf_addtext_split_at_newline(text : String) -> Array[String]

    Split add-text input at cpdf's literal \n line marker.

    A doubled backslash before n is preserved as text, matching cpdf's split_at_newline helper.

    pdf_addtext_text_ops

    source
    fn pdf_addtext_text_ops(font : PdfFont?, fontpack : PdfFontPack?, x : Double, y : Double, base_rotation : Double, horizontal_offset : Double, vertical_offset : Double, outline : Bool, line_width : Double, unique_fontname : 
    PdfName    , unique_fontnames : ArrayView[
    PdfName    ], extgstate_name : 
    PdfName    ?, colour : PdfContentColour, font_size : Double, text : String, text_rotation : Double, rotation_h_offset : Double, rotation_v_offset : Double) -> Array[PdfContentOp] raise 
    PdfError

    Build cpdf add-text text-stamp content operators after placement is resolved.

    This ports the source-level cpdfaddtext.ml ops helper, including /CPDFSTAMP artifact wrapping, placement matrix, outline rendering mode, colour operators, optional opacity graphics state, simple-font charcode conversion, and fontpack run switching.

    pdf_addtext_unescape_string

    source
    fn pdf_addtext_unescape_string(text : String) -> String raise 
    PdfError

    Decode cpdf add-text backslash escapes after line splitting.

    Three-digit octal escapes emit one byte, doubled backslashes emit one backslash, and other non-newline escapes drop the backslash.

    pdf_addtext_url_annotation

    source

    Build cpdf's URL link annotation object for add-text markup.

    pdf_addtext_url_annotation_geometry

    source
    fn pdf_addtext_url_annotation_geometry(origin : 
    Point2    , horizontal_offset : Double, vertical_offset : Double, justification_offset : Double, rotation : Double, rotation_offset : 
    Point2    , page_rotation : Double, start_width : Double, end_width : Double, height : Double) -> PdfAddTextUrlAnnotationGeometry

    Calculate the transformed quad points and bounds for an add-text URL span.

    pdf_addtext_url_annotation_height

    source
    fn pdf_addtext_url_annotation_height(font : PdfFont?, fontname : String, font_size : Double) -> Double

    Return cpdf's add-text URL annotation height for a font selection.

    pdf_addtext_url_annotation_references

    source
    fn pdf_addtext_url_annotation_references(document : PdfDocument, text : String, urls : ArrayView[PdfAddTextUrl], measure : (String) -> Double raise 
    PdfError    , origin : 
    Point2    , horizontal_offset : Double, vertical_offset : Double, justification_offset : Double, rotation : Double, rotation_offset : 
    Point2    , page_rotation : Double, font : PdfFont?, fontname : String, font_size : Double, url_border : Bool) -> Array[PdfObject] raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_url_annotation_references.

    pdf_addtext_url_annotation_widths

    source
    fn pdf_addtext_url_annotation_widths(text : String, url : PdfAddTextUrl, measure : (String) -> Double) -> (Double, Double) raise 
    PdfError

    Measure cpdf's start and end prefix widths for an add-text URL span.

    pdf_addtext_used_codepoints

    source
    fn pdf_addtext_used_codepoints(lines : ArrayView[String]) -> Array[Int] raise 
    PdfError

    Return the unique Unicode codepoints used by expanded add-text lines.

    This mirrors cpdf's pre-embedding used scan after replacement expansion and URL stripping. The returned order is first occurrence for deterministic callers and tests.

    pdf_addtext_width_of_existing_font_resource

    source
    fn pdf_addtext_width_of_existing_font_resource(document : PdfDocument, page : PdfPage, fontname : 
    PdfName    , font_size : Double, text : BytesView) -> (
    PdfName    , Double) raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtext_width_of_existing_font_resource.

    pdf_addtext_width_of_fontpack

    source
    fn pdf_addtext_width_of_fontpack(fontpack : PdfFontPack, font_size : Double, text : String) -> Double raise 
    PdfError

    Measure UTF-8 add-text with a cpdf font pack at font_size.

    pdf_addtext_width_of_selected_font

    source
    fn pdf_addtext_width_of_selected_font(font : PdfFont, font_size : Double, text : BytesView) -> Double

    Measure add-text bytes with the selected parsed font at font_size.

    pdf_addtext_width_of_text

    source
    fn pdf_addtext_width_of_text(font : PdfFont, text : BytesView) -> Double

    Measure cpdf add-text charcode bytes with simple-font metrics.

    This mirrors cpdf's narrow width_of_text helper: only simple fonts with explicit fontmetrics are measured, and any missing metric makes the whole result 0.

    pdf_addtexts_with_font

    source
    fn pdf_addtexts_with_font(document : PdfDocument, page_numbers : ArrayView[Int], text : String, time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font : PdfFont?, fontpack : PdfFontPack?, fontname : 
    PdfName    , font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtexts_with_font.

    pdf_addtexts_with_source

    source
    fn pdf_addtexts_with_source(document : PdfDocument, page_numbers : ArrayView[Int], text : String, time : PdfStrftimeTime, bookmarks : ArrayView[PdfBookmark], font_source : PdfAddTextFontSource, fontname : 
    PdfName    , font_size : Double, line_spacing : Double, colour : PdfContentColour, position : PdfPosition, filename? : String, bates? : Int, bates_pad? : Int?, relative_to_box? : 
    PdfName    , shift? : String, opacity? : Double, justification? : PdfAddTextJustification, rotation? : PdfAddTextRotation, midline? : Bool, topline? : Bool, outline? : Bool, line_width? : Double, underneath? : Bool, fast? : Bool, raw? : Bool, url_border? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::addtexts_with_source.

    pdf_allupright

    source
    fn pdf_allupright(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bool raise 
    PdfError

    Compatibility wrapper for PdfDocument::all_pages_upright.

    pdf_alluprightonly

    source
    fn pdf_alluprightonly(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bool raise 
    PdfError

    Compatibility wrapper for PdfDocument::all_pages_upright_only.

    pdf_annotation_make

    source
    fn pdf_annotation_make(subtype : PdfAnnotationSubtype, contents? : Bytes?, border? : PdfAnnotationBorder, rectangle? : PdfRectangle, colour? : PdfAnnotationColour?, subject? : Bytes?) -> PdfAnnotation

    Build an annotation value with CamlPDF-compatible defaults.

    Defaults are no contents, no subject, a zero rectangle, default border, no colour, and no preserved extra dictionary entries.

    pdf_annotation_make_border

    source
    fn pdf_annotation_make_border(width : Double, vertical_radius? : Double, horizontal_radius? : Double, style? : PdfAnnotationStyle, dash_array? : ArrayView[Int]) -> PdfAnnotationBorder

    Build an annotation border, copying the supplied dash array.

    pdf_annotations_of_page

    source
    fn pdf_annotations_of_page(document : PdfDocument, page : PdfPage) -> Array[PdfAnnotation] raise 
    PdfError

    Compatibility wrapper for PdfDocument::annotations_of_page.

    pdf_append_page_content

    source
    fn pdf_append_page_content(document : PdfDocument, page_numbers : ArrayView[Int], content : BytesView, before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::append_page_content.

    pdf_append_page_content_multiple

    source
    fn pdf_append_page_content_multiple(document : PdfDocument, contents : ArrayView[Bytes], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::append_page_content_multiple.

    pdf_append_page_content_multiple_ops

    source
    fn pdf_append_page_content_multiple_ops(document : PdfDocument, op_lists : ArrayView[Array[PdfContentOp]], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::append_page_content_multiple_ops.

    pdf_append_page_content_ops

    source
    fn pdf_append_page_content_ops(document : PdfDocument, page_numbers : ArrayView[Int], ops : ArrayView[PdfContentOp], before? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::append_page_content_ops.

    pdf_apply_redaction_type

    source
    fn pdf_apply_redaction_type(document : PdfDocument, annotation_type : String, page_numbers : ArrayView[Int]) -> Unit

    Compatibility wrapper for PdfDocument::apply_redaction_type.

    pdf_apply_redactions

    source
    fn pdf_apply_redactions(document : PdfDocument, page_numbers : ArrayView[Int]) -> Unit

    Compatibility wrapper for PdfDocument::apply_redactions.

    pdf_array

    source
    fn pdf_array(values : ArrayView[PdfObject]) -> PdfObject

    Construct a PDF array from a read-only view of object values.

    The outer array is newly allocated, but the contained PdfObject values are copied by value rather than deep-copied.

    pdf_ascii85_decode

    source
    fn pdf_ascii85_decode(data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_ascii85_decode_view.

    pdf_ascii85_decode_view

    source
    fn pdf_ascii85_decode_view(data : BytesView) -> Bytes raise 
    PdfError

    Decode PDF ASCII85Decode data.

    Whitespace is ignored. Missing terminators, malformed partial groups, invalid z placement, and overflowing groups raise PdfError::InvalidASCII85Data.

    pdf_ascii85_encode

    source
    fn pdf_ascii85_encode(data : Bytes) -> Bytes

    Owned-byte wrapper for pdf_ascii85_encode_view.

    pdf_ascii85_encode_view

    source
    fn pdf_ascii85_encode_view(data : BytesView) -> Bytes

    Encode bytes using PDF ASCII85Decode syntax.

    Four zero bytes are compressed as z, partial final groups are shortened, and the result ends with ~>.

    pdf_ascii_hex_decode

    source
    fn pdf_ascii_hex_decode(data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_ascii_hex_decode_view.

    pdf_ascii_hex_decode_view

    source
    fn pdf_ascii_hex_decode_view(data : BytesView) -> Bytes raise 
    PdfError

    Decode PDF ASCIIHexDecode data.

    Whitespace is ignored and a trailing odd nibble is padded with zero when the > marker is reached. Invalid hex digits raise PdfError::InvalidHexEscape.

    pdf_ascii_hex_encode

    source
    fn pdf_ascii_hex_encode(data : Bytes) -> Bytes

    Owned-byte wrapper for pdf_ascii_hex_encode_view.

    pdf_ascii_hex_encode_view

    source
    fn pdf_ascii_hex_encode_view(data : BytesView) -> Bytes

    Encode bytes using PDF ASCIIHexDecode syntax.

    The returned bytes are uppercase hexadecimal pairs followed by the > end-of-data marker.

    pdf_attach_file

    source
    fn pdf_attach_file(document : PdfDocument, filename : String, data : BytesView, keep_version? : Bool, page_number? : Int?, relationship? : String?, description? : String?) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::attach_file.

    pdf_attachment_remove_unsafe_characters

    source
    fn pdf_attachment_remove_unsafe_characters(text : String) -> String raise 
    PdfError

    Remove characters which are unsafe in attachment dump filenames.

    Input and output are Unicode text. This mirrors cpdf's filtering set and intentionally preserves a leading dot, matching the source behavior.

    pdf_black_fills

    source
    fn pdf_black_fills(document : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::black_fills.

    pdf_black_fills_ops

    source
    fn pdf_black_fills_ops(colour : PdfContentColour, ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Rewrite fill colour operators to colour.

    pdf_black_lines

    source
    fn pdf_black_lines(document : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::black_lines.

    pdf_black_lines_ops

    source
    fn pdf_black_lines_ops(colour : PdfContentColour, ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Rewrite stroke colour operators to colour.

    pdf_black_text

    source
    fn pdf_black_text(document : PdfDocument, page_numbers : ArrayView[Int], colour : PdfContentColour) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::black_text.

    pdf_black_text_ops

    source
    fn pdf_black_text_ops(colour : PdfContentColour, ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Rewrite text content so text is painted with colour.

    Colour and graphics-state operators inside text blocks are moved after the text block, while non-text drawing operators inside the text block are copied after ET, matching cpdftweak.ml's blacktext_ops.

    pdf_blank_document

    source
    fn pdf_blank_document(width : Double, height : Double, page_count : Int) -> PdfDocument raise 
    PdfError

    Create a blank document from page dimensions in PDF points.

    pdf_blank_document_paper

    source
    fn pdf_blank_document_paper(paper : 
    PaperSize    , page_count : Int) -> PdfDocument raise 
    PdfError

    Create a blank document from a named paper size.

    pdf_bookmark_black

    source
    let pdf_bookmark_black : PdfBookmarkColour

    Default black bookmark colour.

    pdf_bookmark_name_of_spec

    source
    fn pdf_bookmark_name_of_spec(encoding : PdfMetadataEncoding, bookmarks : ArrayView[PdfBookmark], document : PdfDocument, split_level : Int, spec : String, sequence : Int, filename : String, start_page : Int, end_page : Int) -> String raise 
    PdfError

    Compatibility wrapper for PdfDocument::bookmark_name_of_spec.

    pdf_bookmarks_open_to_level

    source
    fn pdf_bookmarks_open_to_level(level : Int, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::bookmarks_open_to_level.

    pdf_build_name_tree

    source
    fn pdf_build_name_tree(is_number : Bool, document : PdfDocument, entries : ArrayView[(Bytes, PdfObject)]) -> PdfObject raise 
    PdfError

    Build either a name tree or a number tree from byte-keyed entries.

    When is_number is false, this delegates to build_name_tree. When it is true, keys must be signed 32-bit decimal ASCII and are converted to integers before building a number tree; invalid keys raise PdfError::NumberExpected.

    pdf_byte_of_int

    source
    fn pdf_byte_of_int(value : Int) -> Byte raise 
    PdfError

    Converts an integer to a byte.

    Raises PdfError::InvalidByte when value is outside 0..=255.

    pdf_bytes_concat_views

    source
    fn pdf_bytes_concat_views(parts : ArrayView[BytesView]) -> Bytes

    Concatenates byte views into one owned PDF byte sequence.

    pdf_bytes_copy

    source
    fn pdf_bytes_copy(values : BytesView) -> Bytes

    Copies a byte view into owned PDF bytes using indexed construction.

    This is useful when the input may alias data that will be mutated elsewhere.

    pdf_bytes_get

    source
    fn pdf_bytes_get(bytes : Bytes, index : Int) -> Byte?

    Returns the byte at index, or None when the index is out of bounds.

    pdf_bytes_length

    source
    fn pdf_bytes_length(bytes : Bytes) -> Int

    Returns the length of a PDF byte sequence.

    pdf_bytes_make

    source
    fn pdf_bytes_make(length : Int, value? : Int) -> Bytes raise 
    PdfError

    Creates owned PDF bytes of length filled with value.

    The default value is zero. Raises PdfError::InvalidReadLength for negative lengths and PdfError::InvalidByte for values outside 0..=255.

    pdf_bytes_map_int

    source
    fn pdf_bytes_map_int(bytes : BytesView, f : (Int) -> Int) -> Bytes raise 
    PdfError

    Maps every byte through an integer transformation and returns owned bytes.

    The callback receives each input byte as an Int. Raises PdfError::InvalidByte if a mapped value is outside 0..=255.

    pdf_bytes_of_array_view

    source
    fn pdf_bytes_of_array_view(values : ArrayView[Byte]) -> Bytes

    Copies an array view of bytes into owned PDF bytes.

    pdf_bytes_of_date

    source

    Formats a PDF date as an owned PDF byte string.

    Raises @core.PdfError::BadDate if any field is outside the representable PDF date ranges.

    pdf_bytes_of_int_array

    source
    fn pdf_bytes_of_int_array(values : ArrayView[Int]) -> Bytes raise 
    PdfError

    Converts integer byte values to owned PDF bytes.

    Raises PdfError::InvalidByte if any value is outside 0..=255.

    pdf_bytes_of_int_arrays

    source
    fn pdf_bytes_of_int_arrays(values : ArrayView[ArrayView[Int]]) -> Bytes raise 
    PdfError

    Flattens arrays of integer byte values into owned PDF bytes.

    Raises PdfError::InvalidByte if any value is outside 0..=255.

    pdf_bytes_of_view

    source
    fn pdf_bytes_of_view(values : BytesView) -> Bytes

    Copies a byte view into owned PDF bytes.

    pdf_bytes_to_array

    source
    fn pdf_bytes_to_array(bytes : Bytes) -> Array[Byte]

    Copies PDF bytes into a resizable Array[Byte].

    pdf_bytes_to_fixed_array

    source
    fn pdf_bytes_to_fixed_array(bytes : Bytes) -> FixedArray[Byte]

    Copies PDF bytes into a fixed-size byte array.

    pdf_calculate_position

    source
    fn pdf_calculate_position(ignore_distance : Bool, text_width : Double, bounds : PdfRectangle, position : PdfPosition) -> PdfCalculatedPosition

    Calculate the absolute placement for text of text_width in bounds.

    When ignore_distance is true, edge-distance values in the position are treated as zero, matching cpdf's calculate_position behavior.

    pdf_ccitt_encode

    source
    fn pdf_ccitt_encode(columns : Int, rows : Int, data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_ccitt_encode_view.

    pdf_ccitt_encode_view

    source
    fn pdf_ccitt_encode_view(columns : Int, rows : Int, data : BytesView) -> Bytes raise 
    PdfError

    Encode 1-bit image data as CCITT Group 3 one-dimensional fax data.

    pdf_ccitt_g4_encode

    source
    fn pdf_ccitt_g4_encode(columns : Int, rows : Int, data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_ccitt_g4_encode_view.

    pdf_ccitt_g4_encode_view

    source
    fn pdf_ccitt_g4_encode_view(columns : Int, rows : Int, data : BytesView) -> Bytes raise 
    PdfError

    Encode 1-bit image data as CCITT Group 4 fax data.

    pdf_center_to_fit_pages

    source
    fn pdf_center_to_fit_pages(document : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::center_to_fit_pages.

    pdf_change_bookmark

    source
    fn pdf_change_bookmark(changes : ArrayView[(Int, Int)], bookmark : PdfBookmark) -> PdfBookmark

    Renumber page-object targets in one bookmark.

    changes contains (old_object_number, new_object_number) pairs. Targets without a matching page-object number are preserved.

    pdf_change_boxes

    source
    fn pdf_change_boxes(document : PdfDocument, page : PdfPage, transform : (Double, Double, Double, Double) -> (Double, Double, Double, Double)) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::change_boxes.

    pdf_change_pages

    source
    fn pdf_change_pages(change_references : Bool, document : PdfDocument, pages : ArrayView[PdfPage], matrices? : ArrayView[(Int, 
    TransformMatrix    )], changes? : ArrayView[(Int, Int)]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::change_pages.

    pdf_charcode_extractor_of_font

    source
    fn pdf_charcode_extractor_of_font(document : PdfDocument, font : PdfObject, debug? : Bool) -> ((Int) -> Int?) raise 
    PdfError

    Read a font dictionary and build a pure Unicode-to-charcode closure.

    debug is accepted for CamlPDF API compatibility; this implementation preserves pure lookup behavior and does not write missing-glyph diagnostics.

    pdf_charcode_extractor_of_font_real

    source
    fn pdf_charcode_extractor_of_font_real(font : PdfFont, debug? : Bool) -> ((Int) -> Int?)

    Build a pure reverse lookup closure for an already parsed font.

    The returned closure maps one Unicode codepoint to the first matching PDF character code when the font can represent it. debug is accepted for CamlPDF API compatibility; this implementation does not write diagnostics.

    pdf_check_injectible

    source
    fn pdf_check_injectible(text : String) -> Unit raise 
    PdfError

    Check that a path-like string is safe to pass through shell-style contexts.

    This ports cpdf's injectible-character guard, but reports a checked PdfError::InsecurePathName instead of terminating the process.

    pdf_chop

    source
    fn pdf_chop(document : PdfDocument, x : Int, y : Int, columns : Bool, btt : Bool, rtl : Bool, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::chop.

    pdf_chop_hv

    source
    fn pdf_chop_hv(document : PdfDocument, is_h : Bool, line : Double, columns : Bool, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::chop_hv.

    pdf_clear_progress_output

    source
    fn pdf_clear_progress_output() -> Unit

    pdf_clip_contour

    source
    fn pdf_clip_contour(hole : Bool, vertices : ArrayView[PdfClipVertex]) -> PdfClipContour

    Build a cpdf/GPC polygon contour, copying the input vertex view.

    pdf_clip_make_polygon

    source
    fn pdf_clip_make_polygon(holes : ArrayView[Bool], vertex_arrays : ArrayView[Array[PdfClipVertex]]) -> PdfClipPolygon raise 
    PdfError

    Build a cpdf/GPC polygon from parallel hole flags and vertex arrays.

    Raises PdfError::BadNumberArgument when the inputs have different lengths.

    pdf_clip_null_polygon

    source
    fn pdf_clip_null_polygon() -> PdfClipPolygon

    Return the cpdf null GPC polygon.

    pdf_clip_polygon

    source
    fn pdf_clip_polygon(contours : ArrayView[PdfClipContour]) -> PdfClipPolygon

    Build a cpdf/GPC polygon, copying the input contours and their vertices.

    pdf_clip_polygon_clip

    source
    fn pdf_clip_polygon_clip(operation : PdfClipOperation, subject : PdfClipPolygon, clip : PdfClipPolygon) -> PdfClipPolygon raise 
    PdfError

    Clip subject by clip using cpdf's GPC-backed polygon operation.

    This native-target wrapper preserves cpdf's operation-code mapping and raises PdfError::BadNumberArgument when the native GPC bridge rejects the encoded polygon payload.

    pdf_clip_polygon_of_box

    source
    fn pdf_clip_polygon_of_box(xmin : Double, xmax : Double, ymin : Double, ymax : Double) -> PdfClipPolygon

    Build the cpdf/GPC rectangle polygon for [xmin, xmax] x [ymin, ymax].

    pdf_clip_vertex

    source
    fn pdf_clip_vertex(x : Double, y : Double) -> PdfClipVertex

    Build a cpdf/GPC polygon vertex.

    pdf_codepoint_of_pdfdocencoding_byte

    source
    fn pdf_codepoint_of_pdfdocencoding_byte(value : Int) -> Int raise 
    PdfError

    Decode one PDFDocEncoding byte to a Unicode codepoint.

    Undefined byte values raise PdfError::InvalidPDFDocEncoding.

    pdf_codepoints_of_pdfdocencoding

    source
    fn pdf_codepoints_of_pdfdocencoding(bytes : BytesView) -> Array[Int] raise 
    PdfError

    Decode a PDFDocEncoding byte string to Unicode codepoints.

    pdf_codepoints_of_pdfdocstring

    source
    fn pdf_codepoints_of_pdfdocstring(bytes : BytesView) -> Array[Int] raise 
    PdfError

    Decode a PDF string to Unicode codepoints.

    BOM-prefixed strings are treated as UTF-16BE. Other byte strings are decoded as PDFDocEncoding.

    pdf_codepoints_of_text

    source
    fn pdf_codepoints_of_text(extractor : PdfTextExtractor, text : BytesView) -> Array[Int] raise 
    PdfError

    Compatibility wrapper for PdfTextExtractor::codepoints_of_text.

    pdf_codepoints_of_utf16be

    source
    fn pdf_codepoints_of_utf16be(bytes : BytesView) -> Array[Int] raise 
    PdfError

    Decode UTF-16BE bytes into Unicode scalar values.

    The input should not include the leading FE FF BOM; callers that receive a PDF Unicode string normally pass bytes[2:]. Odd lengths, lone surrogates, and malformed pairs raise PdfError::InvalidUTF16BE.

    pdf_codepoints_of_utf8

    source
    fn pdf_codepoints_of_utf8(bytes : BytesView) -> Array[Int] raise 
    PdfError

    Decode UTF-8 bytes into Unicode scalar values.

    Overlong encodings, invalid continuation bytes, truncated sequences, and surrogate or out-of-range scalar values raise PdfError::InvalidUTF8 or PdfError::InvalidUnicodeCodepoint.

    pdf_colour_space_components

    source
    fn pdf_colour_space_components(document : PdfDocument, resources : PdfObject, object : PdfObject) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::colour_space_components.

    pdf_colour_space_content_json

    source
    fn pdf_colour_space_content_json(space : PdfColourSpace) -> Json

    Compatibility wrapper for PdfColourSpace::content_json.

    pdf_colour_space_of_device_name

    source
    fn pdf_colour_space_of_device_name(name : 
    PdfName    ) -> PdfColourSpace?

    Parse a built-in PDF device colour-space name.

    Accepts the standard names /DeviceGray, /DeviceRGB, /DeviceCMYK, and /Pattern, together with the abbreviated resource names /G, /RGB, and /CMYK.

    pdf_colour_space_of_object

    source
    fn pdf_colour_space_of_object(object : PdfObject) -> PdfColourSpace?

    Parse a simple colour-space object without consulting resources.

    This recognizes device colour-space names, singleton arrays, and pattern-with-base arrays. Use PdfDocument::read_colour_space when resource lookup, calibrated spaces, ICC profiles, or indexed spaces are needed.

    pdf_combine_pages

    source
    fn pdf_combine_pages(under : PdfDocument, overlay : PdfDocument, fast? : Bool, scale_to_fit? : Bool, overlay_is_under? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::combine_pages.

    pdf_composition

    source
    fn pdf_composition(document : PdfDocument, file_size : Int) -> Array[PdfCompositionEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::composition.

    pdf_contains_javascript

    source
    fn pdf_contains_javascript(document : PdfDocument) -> Bool

    Compatibility wrapper for PdfDocument::contains_javascript.

    pdf_content_add_artifacts

    source
    fn pdf_content_add_artifacts(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Mark unmarked content operations as PDF/UA artifacts.

    This ports cpdftype.ml's add_artifacts pass. Existing marked-content sections entered with BDC are preserved as real content; unmarked runs are wrapped in /Artifact BMC ... EMC. Back-channel /BeginArtifact and /EndArtifact markers are converted to ordinary artifact marked content.

    pdf_content_apply_clipping_op

    source
    fn pdf_content_apply_clipping_op(partial_path : PdfContentPartialPath, clipping_path : ArrayView[PdfPath], op : PdfContentOp) -> PdfContentClippingOpResult

    Compatibility wrapper for PdfContentPartialPath::content_apply_clipping_op.

    pdf_content_apply_core_op

    source
    fn pdf_content_apply_core_op(state : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Compatibility wrapper for PdfContentOperatorState::content_apply_core_op.

    pdf_content_apply_extgstate_alpha_op

    source
    fn pdf_content_apply_extgstate_alpha_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_alpha_op.

    pdf_content_apply_extgstate_compositing_op

    source
    fn pdf_content_apply_extgstate_compositing_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_compositing_op.

    pdf_content_apply_extgstate_dash_op

    source
    fn pdf_content_apply_extgstate_dash_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_extgstate_dash_op.

    pdf_content_apply_extgstate_font_op

    source
    fn pdf_content_apply_extgstate_font_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_extgstate_font_op.

    pdf_content_apply_extgstate_graphics_parameter_op

    source
    fn pdf_content_apply_extgstate_graphics_parameter_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_graphics_parameter_op.

    pdf_content_apply_extgstate_halftone_op

    source
    fn pdf_content_apply_extgstate_halftone_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_halftone_op.

    pdf_content_apply_extgstate_overprint_op

    source
    fn pdf_content_apply_extgstate_overprint_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_overprint_op.

    pdf_content_apply_extgstate_rendering_op

    source
    fn pdf_content_apply_extgstate_rendering_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_rendering_op.

    pdf_content_apply_extgstate_resource_op

    source
    fn pdf_content_apply_extgstate_resource_op(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, name : 
    PdfName    ) -> PdfContentOperatorState raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_extgstate_resource_op.

    pdf_content_apply_extgstate_text_op

    source
    fn pdf_content_apply_extgstate_text_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_text_op.

    pdf_content_apply_extgstate_transfer_op

    source
    fn pdf_content_apply_extgstate_transfer_op(document : PdfDocument, state : PdfContentOperatorState, extgstate : PdfObject) -> PdfContentOperatorState

    Compatibility wrapper for PdfDocument::content_apply_extgstate_transfer_op.

    pdf_content_apply_font_resource_op

    source
    fn pdf_content_apply_font_resource_op(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, font_name : 
    PdfName    , font_size : Double) -> PdfContentOperatorState raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_font_resource_op.

    pdf_content_apply_graphics_parameter_op

    source
    fn pdf_content_apply_graphics_parameter_op(state : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Compatibility wrapper for PdfContentOperatorState::content_apply_graphics_parameter_op.

    pdf_content_apply_graphics_state_op

    source
    fn pdf_content_apply_graphics_state_op(state : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Compatibility wrapper for PdfContentOperatorState::content_apply_graphics_state_op.

    pdf_content_apply_marked_content_op

    source
    fn pdf_content_apply_marked_content_op(state : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Compatibility wrapper for PdfContentOperatorState::content_apply_marked_content_op.

    pdf_content_apply_path_op

    source
    fn pdf_content_apply_path_op(partial_path : PdfContentPartialPath, op : PdfContentOp) -> PdfContentPathOpResult

    Compatibility wrapper for PdfContentPartialPath::content_apply_path_op.

    pdf_content_apply_path_state_op

    source
    fn pdf_content_apply_path_state_op(state : PdfContentPathState, op : PdfContentOp) -> PdfContentPathState

    Compatibility wrapper for PdfContentPathState::content_apply_path_state_op.

    pdf_content_apply_resource_op

    source
    fn pdf_content_apply_resource_op(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, op : PdfContentOp) -> PdfContentOperatorResourceResult raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_resource_op.

    pdf_content_apply_text_op

    source

    Compatibility wrapper for PdfContentTextState::content_apply_text_op.

    pdf_content_apply_text_resource_op

    source
    fn pdf_content_apply_text_resource_op(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, op : PdfContentOp) -> PdfContentOperatorTextResult raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_apply_text_resource_op.

    pdf_content_apply_text_show_op

    source

    Compatibility wrapper for PdfContentOperatorState::content_apply_text_show_op.

    pdf_content_apply_text_state_op

    source
    fn pdf_content_apply_text_state_op(state : PdfContentTextState, op : PdfContentOp) -> PdfContentTextState

    Compatibility wrapper for PdfContentTextState::content_apply_text_state_op.

    pdf_content_apply_type3_metrics_op

    source
    fn pdf_content_apply_type3_metrics_op(state : PdfContentOperatorState, op : PdfContentOp) -> PdfContentOperatorState

    Compatibility wrapper for PdfContentOperatorState::content_apply_type3_metrics_op.

    pdf_content_begin_artifact

    source
    fn pdf_content_begin_artifact() -> PdfContentOp

    Return the marked-content operation that begins a PDF/UA artifact.

    pdf_content_black

    source
    let pdf_content_black : PdfContentColour

    The default black content colour.

    pdf_content_bounding_box_content_json

    source
    fn pdf_content_bounding_box_content_json(bbox : PdfContentBoundingBox) -> Json

    Compatibility wrapper for PdfContentBoundingBox::content_json.

    pdf_content_bytes_of_charcode

    source
    fn pdf_content_bytes_of_charcode(font : PdfFont, charcode : Int) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfFont::content_bytes_of_charcode.

    pdf_content_bytes_of_op

    source
    fn pdf_content_bytes_of_op(op : PdfContentOp) -> Bytes raise 
    PdfError

    Serialize one content operator to PDF content-stream bytes.

    pdf_content_bytes_of_ops

    source
    fn pdf_content_bytes_of_ops(ops : ArrayView[PdfContentOp]) -> Bytes raise 
    PdfError

    Serialize content operators to PDF content-stream bytes.

    Operators are separated with whitespace. Op_Unknown bytes are emitted as captured. Inline images with no filter are Flate-encoded and written with inline /F /Fl and /L metadata; inline images with existing filters keep their supplied encoded data and decode parameters.

    pdf_content_charcodes_of_bytes

    source
    fn pdf_content_charcodes_of_bytes(bytes : BytesView, font : PdfFont) -> Array[Int]

    Compatibility wrapper for PdfFont::content_charcodes_of_bytes.

    pdf_content_clipping_state_content_json

    source
    fn pdf_content_clipping_state_content_json(state : PdfContentClippingState) -> Json

    Compatibility wrapper for PdfContentClippingState::content_json.

    pdf_content_clipping_state_of_paths

    source
    fn pdf_content_clipping_state_of_paths(clipping_path : ArrayView[PdfPath]) -> PdfContentClippingState

    Return a clipping-only content state from the current clipping path stack.

    pdf_content_colour_values_content_json

    source
    fn pdf_content_colour_values_content_json(values : PdfContentColourValues) -> Json

    Compatibility wrapper for PdfContentColourValues::content_json.

    pdf_content_concat_stream_views

    source
    fn pdf_content_concat_stream_views(streams : ArrayView[BytesView]) -> Bytes

    Concatenate already-decoded content stream views with a single space between them.

    pdf_content_concat_streams

    source
    fn pdf_content_concat_streams(streams : ArrayView[Bytes]) -> Bytes

    Concatenate already-decoded content streams with a single space between them.

    pdf_content_dash_pattern_content_json

    source
    fn pdf_content_dash_pattern_content_json(pattern : PdfContentDashPattern) -> Json

    Compatibility wrapper for PdfContentDashPattern::content_json.

    pdf_content_end_artifact

    source
    fn pdf_content_end_artifact() -> PdfContentOp

    Return the marked-content operation that ends the current PDF/UA artifact.

    pdf_content_entries_of_ops

    source
    fn pdf_content_entries_of_ops(document : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Array[PdfContentJsonEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_entries_of_ops.

    pdf_content_entries_of_ops_recursive

    source
    fn pdf_content_entries_of_ops_recursive(document : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Array[PdfContentJsonEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_entries_of_ops_recursive.

    pdf_content_entries_of_page

    source
    fn pdf_content_entries_of_page(document : PdfDocument, page : PdfPage) -> Array[PdfContentJsonEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_entries_of_page.

    pdf_content_extra_metrics

    source
    fn pdf_content_extra_metrics(font : PdfFont) -> (Double, Double)

    Compatibility wrapper for PdfFont::content_extra_metrics.

    pdf_content_filter

    source
    fn pdf_content_filter(document : PdfDocument, predicate : (PdfContentJsonEntry) -> Bool, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_filter.

    pdf_content_form_xobject_enter_state

    source
    fn pdf_content_form_xobject_enter_state(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, name : 
    PdfName    ) -> PdfContentOperatorState? raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_form_xobject_enter_state.

    pdf_content_form_xobject_ops

    source
    fn pdf_content_form_xobject_ops(document : PdfDocument, resources : PdfObject, name : 
    PdfName    ) -> Array[PdfContentOp]? raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_form_xobject_ops.

    pdf_content_form_xobject_resources

    source
    fn pdf_content_form_xobject_resources(document : PdfDocument, resources : PdfObject, name : 
    PdfName    ) -> PdfObject? raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_form_xobject_resources.

    pdf_content_glyph_state_content_json

    source
    fn pdf_content_glyph_state_content_json(state : PdfContentGlyphState) -> Json

    Compatibility wrapper for PdfContentGlyphState::content_json.

    pdf_content_glyph_state_of_text_state

    source
    fn pdf_content_glyph_state_of_text_state(state : PdfContentTextState, clipping_path : ArrayView[PdfPath]) -> PdfContentGlyphState

    Compatibility wrapper for PdfContentTextState::content_glyph_state.

    pdf_content_image_entry

    source

    Compatibility wrapper for PdfContentOperatorState::content_image_entry.

    pdf_content_image_entry_from_resources

    source
    fn pdf_content_image_entry_from_resources(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, name : 
    PdfName    ) -> PdfContentJsonEntry? raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_image_entry_from_resources.

    pdf_content_initial_clipping_path

    source
    fn pdf_content_initial_clipping_path(minx : Double, miny : Double, maxx : Double, maxy : Double) -> Array[PdfPath]

    Return cpdfcontent's initial page-boundary clipping path.

    pdf_content_initial_clipping_state

    source
    fn pdf_content_initial_clipping_state(minx : Double, miny : Double, maxx : Double, maxy : Double) -> PdfContentClippingState

    Return cpdfcontent's initial clipping-only state for a page boundary.

    pdf_content_initial_drawn_path

    source
    fn pdf_content_initial_drawn_path() -> PdfDrawnPath

    Return cpdfcontent's initial drawn-path placeholder.

    pdf_content_initial_glyph_state

    source
    fn pdf_content_initial_glyph_state(minx : Double, miny : Double, maxx : Double, maxy : Double) -> PdfContentGlyphState

    Return cpdfcontent's initial glyph state fields for a page boundary.

    pdf_content_initial_operator_state

    source
    fn pdf_content_initial_operator_state(minx : Double, miny : Double, maxx : Double, maxy : Double) -> PdfContentOperatorState

    Return cpdfcontent's initial operator state for a page boundary.

    pdf_content_initial_path_state

    source
    fn pdf_content_initial_path_state(minx : Double, miny : Double, maxx : Double, maxy : Double) -> PdfContentPathState

    Return cpdfcontent's initial path drawing state for a page boundary.

    pdf_content_initial_text_state

    source
    fn pdf_content_initial_text_state() -> PdfContentTextState

    Return cpdfcontent's initial text state.

    pdf_content_inline_image_entry

    source
    fn pdf_content_inline_image_entry(state : PdfContentOperatorState) -> PdfContentJsonEntry

    Compatibility wrapper for PdfContentOperatorState::content_inline_image_entry.

    pdf_content_is_vertical

    source
    fn pdf_content_is_vertical(font : PdfFont) -> Bool

    Compatibility wrapper for PdfFont::content_is_vertical.

    pdf_content_json_entries_content_json

    source
    fn pdf_content_json_entries_content_json(entries : ArrayView[PdfContentJsonEntry]) -> Json

    Return cpdfcontent's JSON shape for a content-list entry array.

    pdf_content_json_entry_content_json

    source
    fn pdf_content_json_entry_content_json(entry : PdfContentJsonEntry) -> Json

    Compatibility wrapper for PdfContentJsonEntry::content_json.

    pdf_content_json_of_ops

    source
    fn pdf_content_json_of_ops(document : PdfDocument, mediabox : PdfRectangle, resources : PdfObject, ops : ArrayView[PdfContentOp]) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_json_of_ops.

    pdf_content_json_of_page

    source
    fn pdf_content_json_of_page(document : PdfDocument, page : PdfPage) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::content_json_of_page.

    pdf_content_no_partial_path

    source
    fn pdf_content_no_partial_path() -> PdfContentPartialPath

    pdf_content_object_content_json

    source
    fn pdf_content_object_content_json(object : PdfContentObject) -> Json

    Compatibility wrapper for PdfContentObject::content_json.

    pdf_content_path_entry

    source
    fn pdf_content_path_entry(state : PdfContentOperatorState, stroking : Bool) -> PdfContentJsonEntry?

    Compatibility wrapper for PdfContentOperatorState::content_path_entry.

    pdf_content_path_state_content_json

    source
    fn pdf_content_path_state_content_json(state : PdfContentPathState) -> Json

    Compatibility wrapper for PdfContentPathState::content_json.

    pdf_content_path_state_with_clipping_path

    source
    fn pdf_content_path_state_with_clipping_path(state : PdfContentPathState, clipping_path : ArrayView[PdfPath]) -> PdfContentPathState

    Compatibility wrapper for PdfContentPathState::content_with_clipping_path.

    pdf_content_read_pattern

    source

    pdf_content_read_tiling_pattern

    source
    fn pdf_content_read_tiling_pattern(_pattern : PdfObject) -> PdfContentPattern

    pdf_content_shading_entry

    source
    fn pdf_content_shading_entry(state : PdfContentOperatorState, name : 
    PdfName    , shading_bbox : PdfRectangle?) -> PdfContentJsonEntry?

    Compatibility wrapper for PdfContentOperatorState::content_shading_entry.

    pdf_content_shading_entry_from_resources

    source
    fn pdf_content_shading_entry_from_resources(document : PdfDocument, state : PdfContentOperatorState, resources : PdfObject, name : 
    PdfName    ) -> PdfContentJsonEntry?

    Compatibility wrapper for PdfDocument::content_shading_entry_from_resources.

    pdf_content_state_content_json

    source
    fn pdf_content_state_content_json(state : PdfContentState) -> Json

    Compatibility wrapper for PdfContentState::content_json.

    pdf_content_stream_of_ops

    source
    fn pdf_content_stream_of_ops(ops : ArrayView[PdfContentOp]) -> PdfObject raise 
    PdfError

    Build an uncompressed PDF stream object from content operators.

    The returned stream dictionary contains /Length for the serialized byte length and no outer stream filter.

    pdf_content_text_glyph_entry

    source

    Compatibility wrapper for PdfContentOperatorState::content_text_glyph_entry.

    pdf_content_text_layout_of_bytes

    source
    fn pdf_content_text_layout_of_bytes(font : PdfFont, text : BytesView, layout : PdfContentTextLayout) -> PdfContentTextLayoutResult

    Compatibility wrapper for PdfFont::content_text_layout_of_bytes.

    pdf_content_text_layout_of_tj_array

    source
    fn pdf_content_text_layout_of_tj_array(font : PdfFont, elements : ArrayView[PdfObject], layout : PdfContentTextLayout) -> PdfContentTextLayoutResult

    Compatibility wrapper for PdfFont::content_text_layout_of_tj_array.

    pdf_content_width_of_charcode

    source
    fn pdf_content_width_of_charcode(font : PdfFont, charcode : Int) -> (Double, Double, Double)

    Compatibility wrapper for PdfFont::content_width_of_charcode.

    pdf_copy_annotations

    source
    fn pdf_copy_annotations(page_numbers : ArrayView[Int], source : PdfDocument, target : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::copy_annotations_from.

    pdf_copy_font

    source
    fn pdf_copy_font(source : PdfDocument, font_name : String, font_page : Int, page_numbers : ArrayView[Int], target : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::copy_font_from.

    pdf_copy_id

    source
    fn pdf_copy_id(keep_version : Bool, copy_from : PdfDocument, copy_to : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::copy_id_from.

    pdf_copy_page_box

    source
    fn pdf_copy_page_box(document : PdfDocument, page_numbers : ArrayView[Int], from_box : 
    PdfName    , to_box : 
    PdfName    , mediabox_if_missing? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::copy_page_box.

    pdf_create_metadata

    source
    fn pdf_create_metadata(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::create_metadata.

    pdf_crop_pdf

    source
    fn pdf_crop_pdf(document : PdfDocument, page_numbers : ArrayView[Int], boxes : ArrayView[(Double, Double, Double, Double)], box_name? : 
    PdfName    ) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::crop_pages.

    pdf_css_colour_value

    source
    fn pdf_css_colour_value(name : String) -> Int?

    Look up a CSS color by name using cpdf's lowercase color table.

    pdf_css_colours

    source
    fn pdf_css_colours() -> Array[(String, Int)]

    Return the cpdf CSS color table as lowercase names paired with RGB integers.

    pdf_current_time

    source

    Return the current local time on the native target.

    pdf_date_of_bytes

    source

    Parses a PDF date from owned PDF bytes.

    pdf_date_of_object

    source

    Extracts and parses a PDF date from a PdfString object.

    Raises PdfError::BadDate if the object is not a string or if the date payload is malformed.

    pdf_date_of_string

    source

    Parses a PDF date from an ASCII string.

    Raises @core.PdfError::BadDate for malformed or out-of-range dates.

    pdf_date_of_view

    source

    Parses a PDF date from a byte view.

    Both strings with and without the D: prefix are accepted. Missing optional date fields use the PDF defaults described on PdfDate. Raises @core.PdfError::BadDate for malformed or out-of-range dates.

    pdf_debug_objects

    source
    fn pdf_debug_objects(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::debug_objects.

    pdf_decode_filter_bytes

    source
    fn pdf_decode_filter_bytes(filter : 
    PdfName    , data : Bytes) -> Bytes raise 
    PdfError

    Decode owned bytes with a single PDF filter name.

    Identity and Flate paths avoid an extra copy where possible.

    pdf_decode_filter_view

    source
    fn pdf_decode_filter_view(filter : 
    PdfName    , data : BytesView) -> Bytes raise 
    PdfError

    Decode bytes with a single PDF filter name.

    Recognizes long and abbreviated filter names. /Crypt is treated as an identity filter at this byte-dispatch layer; unsupported filters raise PdfError::FilterNotSupported.

    pdf_decode_predictor

    source
    fn pdf_decode_predictor(predictor : Int, colors : Int, bits_per_component : Int, columns : Int, data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_decode_predictor_view.

    Predictor 1 returns the original owned bytes unchanged.

    pdf_decode_predictor_view

    source
    fn pdf_decode_predictor_view(predictor : Int, colors : Int, bits_per_component : Int, columns : Int, data : BytesView) -> Bytes raise 
    PdfError

    Decode data after applying a PDF predictor.

    Predictor 1 is identity, 2 is TIFF horizontal differencing, and 10..15 are PNG predictors. Invalid image geometry or unsupported predictors raise PdfError.

    pdf_decode_stream

    source
    fn pdf_decode_stream(object : PdfObject) -> PdfObject raise 
    PdfError

    Decode all supported filter stages from a direct stream object.

    pdf_decode_stream_onestage

    source
    fn pdf_decode_stream_onestage(object : PdfObject) -> PdfObject raise 
    PdfError

    Decode exactly one filter stage from a stream object.

    The first filter and matching decode parameters are removed from the stream dictionary, and /Length is refreshed. Non-stream objects raise PdfError::ParseStreamExpected.

    pdf_default_version

    source
    let pdf_default_version : PdfVersion

    Fallback version used when a PDF header cannot be found.

    pdf_determine_subformats

    source
    fn pdf_determine_subformats(document : PdfDocument) -> Array[String] raise 
    PdfError

    Compatibility wrapper for PdfDocument::determine_subformats.

    pdf_deterministic_aes_iv_provider_from_seed

    source
    fn pdf_deterministic_aes_iv_provider_from_seed(seed : BytesView) -> ((Int, Int, Int) -> Bytes raise 
    PdfError    )

    Build a deterministic AES IV provider from a seed.

    The returned callback derives 16-byte IVs from the seed, object number, generation, and per-object IV index. It is intended for reproducible tests and fixtures; production encryption should use a cryptographically secure random provider.

    pdf_deterministic_aesv3_random_provider_from_seed

    source
    fn pdf_deterministic_aesv3_random_provider_from_seed(seed : BytesView) -> ((
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    )

    Build a deterministic AESV3 random-field provider from a seed.

    The provider derives field-specific bytes for file keys, salts, and permissions padding. It is useful for stable test fixtures, not for production encryption.

    pdf_dict_entry_values

    source
    fn pdf_dict_entry_values(document : PdfDocument, key : 
    PdfName    ) -> Array[PdfObject]

    Compatibility wrapper for PdfDocument::dict_entry_values.

    pdf_dictionary

    source

    Construct a PDF dictionary from a read-only view of name/value entries.

    Entry order is preserved exactly as supplied. Duplicate keys are not normalized by this constructor; lookup helpers return the first matching entry.

    pdf_document_empty

    source
    fn pdf_document_empty() -> PdfDocument

    Construct an empty PDF document with CamlPDF-compatible defaults.

    The default version is 1.0, the root object number is 0, the trailer is an empty dictionary, and revision_read starts at 1.

    pdf_document_of_json

    source
    fn pdf_document_of_json(json : Json) -> PdfDocument raise 
    PdfError

    Convert a CPDFJSON top-level array into an in-memory PDF document.

    This ports cpdf's pdf_of_json document-input path. Object -1 supplies CPDFJSON parameters, object 0 supplies the trailer dictionary, positive object numbers populate the document object table, and other negative object numbers are ignored. /CPDFJSONstreamdataincluded false is rejected because the stream bytes needed for reconstruction are not present.

    pdf_document_of_parsed_indirect_objects

    source
    fn pdf_document_of_parsed_indirect_objects(objects : ArrayView[PdfParsedIndirectObject], version? : PdfVersion) -> PdfDocument

    Build a document from already parsed indirect objects.

    Objects are loaded at their existing object numbers and generations without recording mutation events. The document version defaults to pdf_default_version.

    pdf_draft

    source
    fn pdf_draft(only_remove : 
    PdfName    ?, boxes : Bool, page_numbers : ArrayView[Int], document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::draft.

    pdf_draw

    source
    fn pdf_draw(document : PdfDocument, page_numbers : ArrayView[Int], drawops : ArrayView[PdfDrawOp], struct_tree? : Bool, fast? : Bool, underneath? : Bool, filename? : String, bates? : Int, bates_pad? : Int?, time? : PdfStrftimeTime?, add_artifacts? : Bool, role_map? : String) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::draw.

    pdf_draw_colour_of_string

    source
    fn pdf_draw_colour_of_string(text : String) -> PdfDrawColour

    Parse a cpdf draw colour, returning PdfDrawNoCol on malformed input.

    pdf_draw_control

    source
    fn pdf_draw_control() -> PdfDrawControl

    Compatibility wrapper for pdf_draw_control_new.

    pdf_draw_control_new

    source
    fn pdf_draw_control_new() -> PdfDrawControl

    Create a fresh cpdf draw-control state with an empty main frame.

    pdf_draw_render_state_new

    source
    fn pdf_draw_render_state_new() -> PdfDrawRenderState

    pdf_draw_special_text_context

    source
    fn pdf_draw_special_text_context(time : PdfStrftimeTime, replacement_values : PdfAddTextReplacementValues) -> PdfDrawSpecialTextContext

    Build a special-text context from explicit replacement values.

    pdf_draw_special_text_context_for_document

    source
    fn pdf_draw_special_text_context_for_document(document : PdfDocument, page_number : Int, filename? : String, bates? : Int, bates_pad? : Int?, time? : PdfStrftimeTime?) -> PdfDrawSpecialTextContext raise 
    PdfError

    Compatibility wrapper for PdfDocument::draw_special_text_context.

    pdf_drawn_path_content_json

    source
    fn pdf_drawn_path_content_json(path : PdfDrawnPath) -> Json

    Compatibility wrapper for PdfDrawnPath::content_json.

    pdf_drawop_to_content_ops

    source
    fn pdf_drawop_to_content_ops(op : PdfDrawOp) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDrawOp::to_content_ops.

    pdf_drawop_to_content_ops_with_context

    source
    fn pdf_drawop_to_content_ops_with_context(state : PdfDrawRenderState, context : PdfDrawSpecialTextContext, op : PdfDrawOp) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDrawOp::to_content_ops_with_context.

    pdf_drawop_to_content_ops_with_document

    source
    fn pdf_drawop_to_content_ops_with_document(state : PdfDrawRenderState, document : PdfDocument, op : PdfDrawOp) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDrawOp::to_content_ops_with_document.

    pdf_drawop_to_content_ops_with_document_context

    source
    fn pdf_drawop_to_content_ops_with_document_context(state : PdfDrawRenderState, document : PdfDocument, context : PdfDrawSpecialTextContext, op : PdfDrawOp) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDrawOp::to_content_ops_with_document_context.

    pdf_drawop_to_content_ops_with_state

    source
    fn pdf_drawop_to_content_ops_with_state(state : PdfDrawRenderState, op : PdfDrawOp) -> Array[PdfContentOp] raise 
    PdfError

    Compatibility wrapper for PdfDrawOp::to_content_ops_with_state.

    pdf_drawops_to_content_ops

    source
    fn pdf_drawops_to_content_ops(ops : ArrayView[PdfDrawOp]) -> Array[PdfContentOp] raise 
    PdfError

    Convert a sequence of cpdf draw operations to flat PDF content operators.

    pdf_drawops_to_content_ops_with_context

    source
    fn pdf_drawops_to_content_ops_with_context(state : PdfDrawRenderState, context : PdfDrawSpecialTextContext, ops : ArrayView[PdfDrawOp]) -> Array[PdfContentOp] raise 
    PdfError

    Convert a sequence of cpdf draw operations using state and special-text data.

    pdf_drawops_to_content_ops_with_document

    source
    fn pdf_drawops_to_content_ops_with_document(state : PdfDrawRenderState, document : PdfDocument, ops : ArrayView[PdfDrawOp]) -> Array[PdfContentOp] raise 
    PdfError

    Convert a sequence of cpdf draw operations using resource state and a document for indirect object allocation.

    pdf_drawops_to_content_ops_with_document_context

    source
    fn pdf_drawops_to_content_ops_with_document_context(state : PdfDrawRenderState, document : PdfDocument, context : PdfDrawSpecialTextContext, ops : ArrayView[PdfDrawOp]) -> Array[PdfContentOp] raise 
    PdfError

    Convert a sequence of cpdf draw operations using document resources and special-text data.

    pdf_drawops_to_content_ops_with_state

    source
    fn pdf_drawops_to_content_ops_with_state(state : PdfDrawRenderState, ops : ArrayView[PdfDrawOp]) -> Array[PdfContentOp] raise 
    PdfError

    Convert a sequence of cpdf draw operations using resource allocation state.

    pdf_encode_filter_bytes

    source
    fn pdf_encode_filter_bytes(filter : 
    PdfName    , data : Bytes) -> Bytes raise 
    PdfError

    Encode owned bytes with a single PDF filter name.

    pdf_encode_filter_bytes_with_flate_level

    source
    fn pdf_encode_filter_bytes_with_flate_level(filter : 
    PdfName    , data : Bytes, flate_level : Int) -> Bytes raise 
    PdfError

    Encode owned bytes with a single PDF filter name and explicit Flate level.

    pdf_encode_filter_view

    source
    fn pdf_encode_filter_view(filter : 
    PdfName    , data : BytesView) -> Bytes raise 
    PdfError

    Encode bytes with a single PDF filter name.

    pdf_encode_filter_view_with_flate_level

    source
    fn pdf_encode_filter_view_with_flate_level(filter : 
    PdfName    , data : BytesView, flate_level : Int) -> Bytes raise 
    PdfError

    Encode bytes with a single PDF filter name and explicit Flate level.

    flate_level follows the zlib range accepted by the Flate encoder.

    pdf_encode_predictor

    source
    fn pdf_encode_predictor(predictor : Int, colors : Int, bits_per_component : Int, columns : Int, data : Bytes) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_encode_predictor_view.

    Predictor 1 returns the original owned bytes unchanged.

    pdf_encode_predictor_view

    source
    fn pdf_encode_predictor_view(predictor : Int, colors : Int, bits_per_component : Int, columns : Int, data : BytesView) -> Bytes raise 
    PdfError

    Encode data with a PDF predictor.

    Predictor 1 is identity, 2 is TIFF horizontal differencing, 10..14 use fixed PNG row filters, and 15 chooses the lowest-scoring PNG filter per row.

    pdf_encode_stream_with_encoding

    source
    fn pdf_encode_stream_with_encoding(encoding : PdfStreamEncoding, object : PdfObject, only_if_smaller? : Bool, predictor? : PdfStreamPredictor?, predictor_columns? : Int, flate_level? : Int?) -> PdfObject raise 
    PdfError

    Encode a stream using a typed encoding description.

    CCITT encodings write fax /DecodeParms; other encodings may optionally apply a predictor before the filter. CCITT does not accept predictors.

    pdf_encode_stream_with_filter

    source
    fn pdf_encode_stream_with_filter(filter : 
    PdfName    , object : PdfObject, only_if_smaller? : Bool, flate_level? : Int?) -> PdfObject raise 
    PdfError

    Encode a stream object with one filter.

    The new filter is prepended to existing filters and /Length is refreshed. When only_if_smaller is true, the original stream is returned if encoded data is not smaller than the original stream data.

    pdf_encode_stream_with_filter_and_predictor

    source
    fn pdf_encode_stream_with_filter_and_predictor(filter : 
    PdfName    , predictor : Int, colors : Int, bits_per_component : Int, columns : Int, object : PdfObject, only_if_smaller? : Bool, flate_level? : Int?) -> PdfObject raise 
    PdfError

    Encode a stream after first applying predictor encoding.

    /DecodeParms are added for the predictor, the filter is prepended, and /Length is refreshed. only_if_smaller compares encoded data against the original stream data.

    pdf_encoding_of_name

    source
    fn pdf_encoding_of_name(name : 
    PdfName    ) -> PdfEncoding?

    Recognize a built-in simple-font encoding name.

    pdf_endpage

    source
    fn pdf_endpage(document : PdfDocument) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::endpage.

    pdf_endpage_fast

    source
    fn pdf_endpage_fast(document : PdfDocument) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::endpage_fast.

    pdf_error

    source
    fn pdf_error(message : String) -> Unit raise 
    PdfError

    Raise a cpdf-style soft error.

    This mirrors Cpdferror.error, which raises SoftError.

    pdf_eval_function

    source
    fn pdf_eval_function(function : PdfFunction, inputs : ArrayView[Double]) -> Array[Double] raise 
    PdfError

    Compatibility wrapper for PdfFunction::eval.

    pdf_extract_fontfile_bytes

    source
    fn pdf_extract_fontfile_bytes(document : PdfDocument, page_number : Int, font_name : String) -> Bytes? raise 
    PdfError

    Compatibility wrapper for PdfDocument::extract_fontfile_bytes.

    pdf_find_object

    source
    fn pdf_find_object(document : PdfDocument, spec : String) -> PdfObject raise 
    PdfError

    Compatibility wrapper for PdfDocument::find_object_by_spec.

    pdf_flate_decode

    source
    fn pdf_flate_decode(data : Bytes) -> Bytes raise 
    PdfError

    Decode a zlib-wrapped Flate stream from owned bytes.

    On the native target this uses zlib FFI with a pure MoonBit fallback.

    pdf_flate_decode_view

    source
    fn pdf_flate_decode_view(data : BytesView) -> Bytes raise 
    PdfError

    Decode a zlib-wrapped Flate stream from a borrowed byte view.

    On the native target this tries zlib FFI first and falls back to the pure MoonBit decoder if the native call fails. Invalid compressed data raises @core.PdfError::InvalidFlateData.

    pdf_flate_encode

    source
    fn pdf_flate_encode(data : Bytes) -> Bytes

    Encode owned bytes with the default compression level.

    On the native target this tries zlib at level 6 and falls back to the pure MoonBit encoder if the native call fails.

    pdf_flate_encode_view

    source
    fn pdf_flate_encode_view(data : BytesView) -> Bytes

    Encode borrowed bytes with the default compression level.

    On the native target this tries zlib at level 6 and falls back to the pure MoonBit encoder if the native call fails.

    pdf_flate_encode_view_with_level

    source
    fn pdf_flate_encode_view_with_level(data : BytesView, level : Int) -> Bytes raise 
    PdfError

    Encode borrowed bytes as a zlib-wrapped Flate stream.

    level must be in the zlib range 0..9; invalid levels raise @core.PdfError::InvalidFlateData. On the native target this tries the zlib FFI first and falls back to the pure MoonBit encoder if the native call fails.

    pdf_flate_encode_with_level

    source
    fn pdf_flate_encode_with_level(data : Bytes, level : Int) -> Bytes raise 
    PdfError

    Encode owned bytes as a zlib-wrapped Flate stream.

    level must be in the zlib range 0..9; invalid levels raise @core.PdfError::InvalidFlateData. On the native target this uses zlib FFI with a pure MoonBit fallback.

    pdf_font_from_name

    source
    fn pdf_font_from_name(document : PdfDocument, font_name : String, page_number : Int) -> PdfObject raise 
    PdfError

    Compatibility wrapper for PdfDocument::font_from_name.

    pdf_font_table

    source
    fn pdf_font_table(document : PdfDocument, font_name : String, page_number : Int) -> Array[PdfFontTableEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::font_table.

    pdf_font_table_text

    source
    fn pdf_font_table_text(document : PdfDocument, font_name : String, page_number : Int) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::font_table_text.

    pdf_fontpack_collate_runs

    source
    fn pdf_fontpack_collate_runs(runs : ArrayView[(Int, Int, PdfFont)]) -> Array[Array[(Int, Int, PdfFont)]]

    Collate consecutive (charcode, font_index, font) runs by font index.

    pdf_fontpack_get_char

    source
    fn pdf_fontpack_get_char(pack : PdfFontPack, codepoint : Int) -> (Int, Int, PdfFont)?

    Compatibility wrapper for PdfFontPack::get_char.

    pdf_fontpack_of_standard_font

    source
    fn pdf_fontpack_of_standard_font(font : PdfFont) -> PdfFontPack raise 
    PdfError

    Build a font pack for an already parsed standard font.

    Duplicate Unicode mappings follow OCaml Hashtbl.add/find behavior by resolving to the last character code inserted by the 0..255 scan.

    pdf_fonts_json

    source
    fn pdf_fonts_json(document : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::fonts_json.

    pdf_fonts_json_blob

    source
    fn pdf_fonts_json_blob(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::fonts_json_blob.

    pdf_format_real

    source
    fn pdf_format_real(value : Double) -> Bytes raise 
    PdfError

    Compatibility alias for pdf_write_real.

    pdf_generate_id

    source
    fn pdf_generate_id(path : String, get_time : () -> Double) -> PdfObject

    Generates a PDF trailer /ID array from a path and caller-supplied time source.

    The digest construction follows CamlPDF's path-plus-time behavior. When CAMLPDF_REPRODUCIBLE_IDS=true, the seed is fixed so tests and reproducible builds can produce stable IDs.

    pdf_get_annotations

    source
    fn pdf_get_annotations(encoding : PdfMetadataEncoding, document : PdfDocument) -> Array[(Int, Bytes)] raise 
    PdfError

    Compatibility wrapper for PdfDocument::get_annotations.

    pdf_get_annotations_json

    source
    fn pdf_get_annotations_json(page_numbers : ArrayView[Int], document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::annotations_json_blob.

    pdf_get_bookmarks_json

    source
    fn pdf_get_bookmarks_json(json_preserve_actions : Bool, document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::bookmarks_json_blob.

    pdf_get_catalog_item

    source
    fn pdf_get_catalog_item(key : 
    PdfName    , document : PdfDocument) -> String

    Compatibility wrapper for PdfDocument::catalog_item.

    pdf_get_dict_entries

    source
    fn pdf_get_dict_entries(document : PdfDocument, key : 
    PdfName    , utf8? : Bool) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::dict_entries_json.

    pdf_get_image_24bpp

    source
    fn pdf_get_image_24bpp(document : PdfDocument, resources : PdfObject, image : PdfObject) -> PdfImage raise 
    PdfError

    Compatibility wrapper for PdfDocument::get_image_24bpp.

    pdf_get_info_utf8

    source
    fn pdf_get_info_utf8(document : PdfDocument, key : 
    PdfName    ) -> String

    Compatibility wrapper for PdfDocument::info_utf8.

    pdf_get_jpeg_data

    source
    fn pdf_get_jpeg_data(input : ByteCursor) -> Bytes raise 
    PdfError

    Reads JPEG data from a cursor through the EOI marker.

    This is the standalone form of ByteCursor::read_jpeg_data.

    pdf_get_mark_info_item

    source
    fn pdf_get_mark_info_item(key : 
    PdfName    , document : PdfDocument) -> Bool

    Compatibility wrapper for PdfDocument::mark_info_item.

    pdf_get_metadata

    source
    fn pdf_get_metadata(document : PdfDocument) -> Bytes? raise 
    PdfError

    Compatibility wrapper for PdfDocument::metadata.

    pdf_get_open_action

    source
    fn pdf_get_open_action(document : PdfDocument) -> PdfObject raise 
    PdfError

    Compatibility wrapper for PdfDocument::open_action.

    pdf_get_open_action_json_blob

    source
    fn pdf_get_open_action_json_blob(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::open_action_json_blob.

    pdf_get_open_action_string

    source
    fn pdf_get_open_action_string(document : PdfDocument) -> String raise 
    PdfError

    Compatibility wrapper for PdfDocument::open_action_string.

    pdf_get_viewer_pref_item

    source
    fn pdf_get_viewer_pref_item(key : 
    PdfName    , document : PdfDocument) -> String

    Compatibility wrapper for PdfDocument::viewer_preference_item.

    pdf_get_xmp_info

    source
    fn pdf_get_xmp_info(document : PdfDocument, key : 
    PdfName    ) -> String

    Compatibility wrapper for PdfDocument::xmp_info.

    pdf_glyphnames_of_text

    source
    fn pdf_glyphnames_of_text(extractor : PdfTextExtractor, text : BytesView) -> Array[
    PdfName    ] raise 
    PdfError

    Compatibility wrapper for PdfTextExtractor::glyphnames_of_text.

    pdf_hard_box

    source
    fn pdf_hard_box(document : PdfDocument, page_numbers : ArrayView[Int], box_name : 
    PdfName    , mediabox_if_missing? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::hard_box.

    pdf_hard_error

    source
    fn pdf_hard_error(message : String) -> Unit raise 
    PdfError

    Raise a cpdf-style hard error.

    pdf_hasbox

    source
    fn pdf_hasbox(document : PdfDocument, page_number : Int, box_name : 
    PdfName    ) -> Bool raise 
    PdfError

    Compatibility wrapper for PdfDocument::has_page_box.

    pdf_hflip_pdf

    source
    fn pdf_hflip_pdf(document : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::flip_pages_horizontally.

    pdf_image_bpc

    source
    fn pdf_image_bpc(document : PdfDocument, image : PdfObject) -> PdfObject?

    Compatibility wrapper for PdfDocument::bpc.

    pdf_image_colspace

    source
    fn pdf_image_colspace(document : PdfDocument, image : PdfObject, resources : PdfObject) -> PdfColourSpace raise 
    PdfError

    Compatibility wrapper for PdfDocument::colspace.

    pdf_image_document_of_jbig2_data

    source
    fn pdf_image_document_of_jbig2_data(data : BytesView, global? : BytesView?, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Build a single-page PDF document from JBIG2 data.

    pdf_image_document_of_jpeg2000_data

    source
    fn pdf_image_document_of_jpeg2000_data(data : BytesView, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Build a single-page PDF document from JPEG2000 data.

    pdf_image_document_of_jpeg_data

    source
    fn pdf_image_document_of_jpeg_data(data : BytesView, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Build a single-page PDF document from JPEG data.

    pdf_image_document_of_object

    source
    fn pdf_image_document_of_object(image : PdfObject, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Build a single-page PDF document that draws image at its natural size.

    pdf_image_document_of_png_data

    source
    fn pdf_image_document_of_png_data(data : BytesView, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Build a single-page PDF document from PNG data.

    pdf_image_images

    source
    fn pdf_image_images(inline : Bool, document : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::images_json.

    pdf_image_images_json_blob

    source
    fn pdf_image_images_json_blob(inline : Bool, document : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::images_json_blob.

    pdf_image_object_of_jbig2_data

    source
    fn pdf_image_object_of_jbig2_data(data : BytesView, global? : BytesView?) -> (PdfObject, Array[(Int, PdfObject)]) raise 
    PdfError

    Build a PDF image XObject for JBIG2 data.

    When global is supplied, the returned extra object list contains the /JBIG2Globals stream at object number 10000, matching cpdf's standalone obj_of_jbig2_data contract.

    pdf_image_object_of_jpeg2000_data

    source
    fn pdf_image_object_of_jpeg2000_data(data : BytesView) -> PdfObject raise 
    PdfError

    Build a PDF image XObject for JPEG2000 data.

    pdf_image_object_of_jpeg_data

    source
    fn pdf_image_object_of_jpeg_data(data : BytesView) -> PdfObject raise 
    PdfError

    Build a PDF image XObject for JPEG data.

    pdf_image_object_of_png_data

    source
    fn pdf_image_object_of_png_data(document : PdfDocument, data : BytesView) -> PdfObject raise 
    PdfError

    Build a PDF image XObject for PNG data using document for any alpha mask object that must be added.

    pdf_image_resolution

    source
    fn pdf_image_resolution(inline : Bool, document : PdfDocument, page_numbers : ArrayView[Int], dpi : Double) -> Array[(Int, String, Int, Int, Double, Double, Int)] raise 
    PdfError

    Compatibility wrapper for PdfDocument::image_resolution.

    pdf_image_resolution_json

    source
    fn pdf_image_resolution_json(inline : Bool, document : PdfDocument, page_numbers : ArrayView[Int], dpi : Double) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::image_resolution_json.

    pdf_image_resolution_json_blob

    source
    fn pdf_image_resolution_json_blob(inline : Bool, document : PdfDocument, page_numbers : ArrayView[Int], dpi : Double) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::image_resolution_json_blob.

    pdf_impose

    source
    fn pdf_impose(document : PdfDocument, x : Double, y : Double, fit? : Bool, columns? : Bool, rtl? : Bool, btt? : Bool, center? : Bool, margin? : Double, spacing? : Double, line_width? : Double, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::impose.

    pdf_int_array_of_bytes

    source
    fn pdf_int_array_of_bytes(bytes : BytesView) -> Array[Int]

    Converts bytes to an array of integer byte values.

    pdf_invert_page_range

    source
    fn pdf_invert_page_range(end_page : Int, range : ArrayView[Int]) -> Array[Int]

    pdf_is_delimiter_byte

    source
    fn pdf_is_delimiter_byte(value : Int) -> Bool

    Return whether a byte is a PDF token delimiter.

    Delimiters are parentheses, slash, angle brackets, square brackets, braces, and percent.

    pdf_is_identity_h

    source
    fn pdf_is_identity_h(font : PdfFont) -> Bool

    Compatibility wrapper for PdfFont::is_identity_h.

    pdf_is_linearized

    source
    fn pdf_is_linearized(data : BytesView) -> Bool

    Return whether the input appears to be a linearized PDF.

    The check reads the first indirect object after the header and looks for a numeric /Linearized entry. Parse failures are treated as false.

    pdf_is_newline_byte

    source
    fn pdf_is_newline_byte(value : Int) -> Bool

    Return whether a byte is a PDF line break byte.

    pdf_is_not_whitespace_byte

    source
    fn pdf_is_not_whitespace_byte(value : Int) -> Bool

    Return whether a byte is not PDF white space.

    pdf_is_unicode_string

    source
    fn pdf_is_unicode_string(bytes : BytesView) -> Bool

    Test whether a PDF string starts with the UTF-16BE byte-order mark.

    PDF "Unicode strings" are byte strings beginning with FE FF; the input is intentionally a BytesView rather than a MoonBit String.

    pdf_is_whitespace_byte

    source
    fn pdf_is_whitespace_byte(value : Int) -> Bool

    Return whether a byte is PDF white space.

    Recognized values are NUL, horizontal tab, line feed, form feed, carriage return, and space.

    pdf_is_whitespace_or_delimiter_byte

    source
    fn pdf_is_whitespace_or_delimiter_byte(value : Int) -> Bool

    Return whether a byte terminates a regular PDF token.

    pdf_is_xfa

    source
    fn pdf_is_xfa(document : PdfDocument) -> Bool

    Compatibility wrapper for PdfDocument::is_xfa.

    pdf_iter_pages

    source
    fn pdf_iter_pages(document : PdfDocument, page_numbers : ArrayView[Int], process : (Int, PdfPage) -> Unit raise 
    PdfError    ) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::iter_pages.

    pdf_jpeg2000_dimensions

    source
    fn pdf_jpeg2000_dimensions(data : Bytes) -> (Int, Int) raise 
    PdfError

    Return the width and height of a JPEG2000 JP2/JPX byte stream.

    pdf_jpeg2000_dimensions_view

    source
    fn pdf_jpeg2000_dimensions_view(data : BytesView) -> (Int, Int) raise 
    PdfError

    Return the width and height of a JPEG2000 JP2/JPX byte stream.

    The scan follows cpdf's byte-by-byte search for the ihdr image header box.

    pdf_jpeg_dimensions

    source
    fn pdf_jpeg_dimensions(data : Bytes) -> (Int, Int) raise 
    PdfError

    Return the width and height of a baseline JFIF/Exif JPEG byte stream.

    pdf_jpeg_dimensions_view

    source
    fn pdf_jpeg_dimensions_view(data : BytesView) -> (Int, Int) raise 
    PdfError

    Return the width and height of a baseline JFIF/Exif JPEG byte stream.

    This matches cpdf's parser: the image must start with SOI plus APP0/APP1 JFIF or Exif metadata, and dimensions are read from the first SOF0 block. Progressive JPEGs and JPEGs without SOF0 raise PdfError::JPEGDimensionsExpected.

    pdf_json_of_document

    source
    fn pdf_json_of_document(document : PdfDocument, utf8? : Bool, parse_content? : Bool, clean_strings? : Bool, no_stream_data? : Bool, decompress_streams? : Bool) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::json_of_document.

    pdf_json_of_object

    source
    fn pdf_json_of_object(document : PdfDocument, object : PdfObject, utf8? : Bool, clean_strings? : Bool, no_stream_data? : Bool, parse_content? : Bool) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::json_of_object.

    pdf_language

    source
    fn pdf_language(document : PdfDocument) -> Bytes?

    Compatibility wrapper for PdfDocument::language.

    pdf_lex_bytes

    source
    fn pdf_lex_bytes(data : Bytes) -> Array[PdfLexeme] raise 
    PdfError

    Lex all tokens from owned PDF bytes.

    pdf_lex_single_view

    source
    fn pdf_lex_single_view(data : BytesView) -> PdfLexeme raise 
    PdfError

    Lex a single token from a borrowed byte view.

    pdf_lex_view

    source
    fn pdf_lex_view(data : BytesView) -> Array[PdfLexeme] raise 
    PdfError

    Lex all tokens from a borrowed byte view.

    pdf_lexeme_debug_name

    source
    fn pdf_lexeme_debug_name(lexeme : PdfLexeme) -> String

    Return the constructor name of a lexeme for diagnostics and snapshots.

    pdf_list_annotations

    source
    fn pdf_list_annotations(page_numbers : ArrayView[Int], encoding : PdfMetadataEncoding, document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::list_annotations.

    pdf_list_attached_files

    source
    fn pdf_list_attached_files(document : PdfDocument) -> Array[PdfAttachment] raise 
    PdfError

    Compatibility wrapper for PdfDocument::list_attached_files.

    pdf_list_bookmarks

    source
    fn pdf_list_bookmarks(json : Bool, json_preserve_actions : Bool, encoding : PdfMetadataEncoding, page_numbers : ArrayView[Int], document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::list_bookmarks.

    pdf_list_fonts

    source
    fn pdf_list_fonts(document : PdfDocument, page_numbers : ArrayView[Int]) -> Array[PdfFontListEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::list_fonts.

    pdf_list_fonts_text

    source
    fn pdf_list_fonts_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::list_fonts_text.

    pdf_list_spot_colours

    source
    fn pdf_list_spot_colours(document : PdfDocument) -> Array[
    PdfName    ]

    Compatibility wrapper for PdfDocument::list_spot_colours.

    pdf_lzw_decode

    source
    fn pdf_lzw_decode(data : Bytes, early_change? : Int) -> Bytes raise 
    PdfError

    Owned-byte wrapper for pdf_lzw_decode_view.

    pdf_lzw_decode_view

    source
    fn pdf_lzw_decode_view(data : BytesView, early_change? : Int) -> Bytes raise 
    PdfError

    Decode PDF LZW data from a byte view.

    early_change controls when code width grows; PDF streams default to 1. Malformed codes or bitstream errors raise PdfError::InvalidLZWData.

    pdf_make_font

    source

    Build a simple Type 1 font dictionary for a base font and named encoding.

    Only encodings with a direct PDF name can be written this way; custom or implicit encodings raise PdfError::EncodingWriteUnsupported.

    pdf_make_hex_pdf_string

    source
    fn pdf_make_hex_pdf_string(bytes : BytesView) -> Bytes

    Compatibility alias for pdf_write_hex_string.

    pdf_make_pdf_string

    source
    fn pdf_make_pdf_string(bytes : BytesView) -> Bytes

    Compatibility alias for pdf_write_literal_string.

    pdf_map_pages

    source
    fn[T] pdf_map_pages(document : PdfDocument, page_numbers : ArrayView[Int], process : (Int, PdfPage) -> T raise 
    PdfError    ) -> Array[T] raise 
    PdfError

    Compatibility wrapper for PdfDocument::map_pages.

    pdf_mark_all_as_artifact

    source
    fn pdf_mark_all_as_artifact(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::mark_all_as_artifact.

    pdf_merge_documents

    source
    fn pdf_merge_documents(documents : ArrayView[PdfDocument], ranges : ArrayView[Array[Int]], retain_numbering? : Bool, retain_bookmarks? : Bool, retain_optional_content? : Bool, retain_acroforms? : Bool, retain_named_destinations? : Bool, retain_name_dictionary? : Bool, retain_structure_tree? : Bool, add_toplevel_document? : Bool, retain_info? : Bool, retain_catalog_entries? : Bool, remove_duplicate_fonts? : Bool) -> PdfDocument raise 
    PdfError

    Merges selected page ranges from multiple documents into one document.

    Each entry in ranges belongs to the document at the same index and uses one-based page numbers. The retain flags control whether numbering, bookmarks, optional-content data, AcroForms, named destinations, name dictionary entries, structure trees, info dictionaries, and catalog entries are copied into the output. Raises PdfError::PageTreeExpected when the document and range lists do not align.

    pdf_merge_name_trees_no_clash

    source
    fn pdf_merge_name_trees_no_clash(document : PdfDocument, trees : ArrayView[PdfObject]) -> PdfObject

    Compatibility wrapper for PdfDocument::merge_name_trees_no_clash.

    pdf_merge_number_trees_no_clash

    source
    fn pdf_merge_number_trees_no_clash(document : PdfDocument, trees : ArrayView[PdfObject]) -> PdfObject

    Compatibility wrapper for PdfDocument::merge_number_trees_no_clash.

    pdf_merge_pdfs

    source
    fn pdf_merge_pdfs(retain_numbering : Bool, remove_duplicate_fonts : Bool, names : ArrayView[String], documents : ArrayView[PdfDocument], ranges : ArrayView[Array[Int]], process_struct_trees? : Bool, add_toplevel_document? : Bool) -> PdfDocument raise 
    PdfError

    CamlPDF-shaped convenience wrapper for merging PDFs.

    names must have the same length as documents; it is retained for API compatibility with CamlPDF's merge entry point. Structure-tree processing and optional top-level /Document wrapping are controlled by the optional flags.

    pdf_merge_structure_trees

    source
    fn pdf_merge_structure_trees(document : PdfDocument, documents : ArrayView[PdfDocument], add_toplevel_document? : Bool) -> Int? raise 
    PdfError

    Merge structure tree roots from source documents into a target document.

    Returns the resulting structure-tree root object number, or None when no source document has a structure tree. When multiple roots are merged, parent trees and root metadata are combined in document; add_toplevel_document wraps merged children in a PDF 2.0 top-level /Document structure element.

    pdf_metadata_adobe_namespace

    source
    let pdf_metadata_adobe_namespace : String

    pdf_metadata_dc_namespace

    source
    let pdf_metadata_dc_namespace : String

    pdf_metadata_encode_output

    source
    fn pdf_metadata_encode_output(encoding : PdfMetadataEncoding, bytes : BytesView) -> Bytes raise 
    PdfError

    Encode a PDF string for metadata/reporting output.

    pdf_metadata_pdfaid_namespace

    source
    let pdf_metadata_pdfaid_namespace : String

    pdf_metadata_pdfe_namespace

    source
    let pdf_metadata_pdfe_namespace : String

    pdf_metadata_pdfuaid_namespace

    source
    let pdf_metadata_pdfuaid_namespace : String

    pdf_metadata_pdfvtid_namespace

    source
    let pdf_metadata_pdfvtid_namespace : String

    pdf_metadata_pdfxid_namespace

    source
    let pdf_metadata_pdfxid_namespace : String

    pdf_metadata_rdf_namespace

    source
    let pdf_metadata_rdf_namespace : String

    pdf_metadata_xmp_namespace

    source
    let pdf_metadata_xmp_namespace : String

    pdf_minimum_valid_pdf

    source
    fn pdf_minimum_valid_pdf() -> PdfDocument raise 
    PdfError

    Build the smallest useful PDF document: one blank A4 page and a catalog.

    pdf_missing_fonts

    source
    fn pdf_missing_fonts(document : PdfDocument, page_numbers : ArrayView[Int]) -> Array[PdfMissingFontEntry] raise 
    PdfError

    Compatibility wrapper for PdfDocument::missing_fonts.

    pdf_missing_fonts_text

    source
    fn pdf_missing_fonts_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::missing_fonts_text.

    pdf_name_of_bytes

    source
    fn pdf_name_of_bytes(bytes : Bytes) -> 
    PdfName

    Wraps owned bytes as a PDF name without copying.

    The bytes are expected to be the name payload without the leading slash.

    pdf_name_of_colour_space

    source
    fn pdf_name_of_colour_space(space : PdfColourSpace) -> 
    PdfName    ?

    Compatibility wrapper for PdfColourSpace::name.

    pdf_name_of_view

    source
    fn pdf_name_of_view(bytes : BytesView) -> 
    PdfName

    Copies a byte view and wraps it as a PDF name.

    The bytes are expected to be the name payload without the leading slash.

    pdf_no_more

    source
    let pdf_no_more : Int

    Sentinel returned by legacy byte-reading helpers when the cursor is past the end of input.

    Newer APIs usually return Byte?, but this value preserves the CamlPDF-style integer cursor contract used by parser code.

    pdf_object_entry

    source
    fn pdf_object_entry(data : PdfObjectData, generation? : Int) -> PdfObjectEntry

    Construct an object-table entry.

    The generation defaults to 0, matching newly created PDF objects.

    pdf_object_map_empty

    source
    fn pdf_object_map_empty() -> PdfObjectMap

    Construct an empty object-number map.

    pdf_object_of_colour_space

    source
    fn pdf_object_of_colour_space(space : PdfColourSpace) -> PdfObject?

    Convert a parsed colour space back into a PDF object.

    Returns None when the colour space cannot be serialized losslessly, such as an indexed table with invalid component values or a base colour space that itself cannot be represented.

    pdf_object_of_date

    source

    Formats a PDF date as a PdfString object.

    Raises PdfError::BadDate if any field is outside the representable PDF date ranges.

    pdf_object_of_destination

    source
    fn pdf_object_of_destination(destination : PdfDestination) -> PdfObject

    Converts a normalized destination back to a PDF object.

    pdf_object_of_function

    source
    fn pdf_object_of_function(document : PdfDocument, function : PdfFunction) -> PdfObject

    Compatibility wrapper for PdfDocument::pdf_object_of_function.

    pdf_object_of_json

    source
    fn pdf_object_of_json(json : Json) -> PdfObject raise 
    PdfError

    Convert a single CPDFJSON object to a PDF object.

    This ports the ordinary object side of cpdf's object_of_json: primitive JSON values, CPDFJSON integer/real/name/string wrappers, dictionaries, arrays, indirect references, streams with embedded string data, and streams with parsed content-operation arrays are supported.

    pdf_object_of_matrix

    source

    Convert a transformation matrix into its six-number PDF array form.

    pdf_objects_empty

    source
    fn pdf_objects_empty() -> PdfObjects

    Construct an empty document object table.

    The next allocated object number will be 1; the mutation log starts empty.

    pdf_objects_of_entries

    source
    fn pdf_objects_of_entries(entries : ArrayView[(Int, PdfObjectEntry)]) -> PdfObjects

    Build a document object table from explicit numbered entries.

    Entries are installed without recording alteration events. The maximum object number is derived from the supplied numbers.

    pdf_ocg_coalesce

    source
    fn pdf_ocg_coalesce(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_coalesce.

    pdf_ocg_default_config

    source
    fn pdf_ocg_default_config() -> PdfOcgConfig

    Return the PDF default optional-content configuration used when none is set.

    The default has base state OcgOn, /Intent /View, no explicit on/off lists, no order, no radio-button groups, and no locked groups.

    pdf_ocg_get_list

    source
    fn pdf_ocg_get_list(document : PdfDocument) -> Array[Bytes] raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_get_list.

    pdf_ocg_list_json

    source
    fn pdf_ocg_list_json(document : PdfDocument) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_list_json.

    pdf_ocg_list_json_blob

    source
    fn pdf_ocg_list_json_blob(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_list_json_blob.

    pdf_ocg_order_all

    source
    fn pdf_ocg_order_all(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_order_all.

    pdf_ocg_read_json

    source
    fn pdf_ocg_read_json(json : Json) -> PdfOptionalContent? raise 
    PdfError

    Parse cpdf's optional-content group JSON representation.

    pdf_ocg_rename

    source
    fn pdf_ocg_rename(old_name : Bytes, new_name : Bytes, document : PdfDocument) -> PdfDocument

    Compatibility wrapper for PdfDocument::ocg_rename.

    pdf_ocg_replace_json

    source
    fn pdf_ocg_replace_json(json : Json, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::ocg_replace_json.

    pdf_of_pages

    source
    fn pdf_of_pages(document : PdfDocument, page_numbers : ArrayView[Int], retain_numbering? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::pdf_of_pages.

    pdf_optional_content_merge

    source
    fn pdf_optional_content_merge(documents : ArrayView[PdfDocument]) -> PdfOptionalContent? raise 
    PdfError

    Merge optional-content metadata from already-renumbered documents.

    Documents without optional content are skipped. Indirect object numbers are copied as-is into the merged result, so callers must renumber source documents before merging when object numbers may collide.

    pdf_output_info_json_blob

    source
    fn pdf_output_info_json_blob(document : PdfDocument, encoding? : PdfMetadataEncoding, unit? : 
    PdfUnit    ) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::info_json_blob.

    pdf_output_page_info_json_blob

    source
    fn pdf_output_page_info_json_blob(document : PdfDocument, page_numbers : ArrayView[Int], unit? : 
    PdfUnit    ) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_info_json_blob.

    pdf_output_page_info_text

    source
    fn pdf_output_page_info_text(document : PdfDocument, page_numbers : ArrayView[Int], unit? : 
    PdfUnit    ) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_info_text.

    pdf_output_xmp_info_json_blob

    source
    fn pdf_output_xmp_info_json_blob(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::xmp_info_json_blob.

    pdf_p_of_permissions

    source
    fn pdf_p_of_permissions(permissions : ArrayView[
    PdfPermission    ]) -> Int

    Convert denied permissions to a PDF /P permission mask.

    The input is a ban list. Required reserved bits are set according to the PDF standard-security-handler convention.

    pdf_pad_after

    source
    fn pdf_pad_after(document : PdfDocument, page_numbers : ArrayView[Int], pad_with? : PdfDocument?) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::pad_after.

    pdf_pad_before

    source
    fn pdf_pad_before(document : PdfDocument, page_numbers : ArrayView[Int], pad_with? : PdfDocument?) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::pad_before.

    pdf_pad_to_multiple

    source
    fn pdf_pad_to_multiple(document : PdfDocument, multiple : Int) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::pad_to_multiple.

    pdf_page_blank

    source

    Build a blank page for a named paper size.

    pdf_page_content_json

    source
    fn pdf_page_content_json(document : PdfDocument, page_numbers : ArrayView[Int]) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_content_json.

    pdf_page_custom

    source
    fn pdf_page_custom(rectangle : PdfObject) -> PdfPage

    Build a blank page using an explicit PDF rectangle object as /MediaBox.

    pdf_page_info_json

    source
    fn pdf_page_info_json(document : PdfDocument, page_numbers : ArrayView[Int], unit? : 
    PdfUnit    ) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_info_json.

    pdf_page_int_of_rotation

    source
    fn pdf_page_int_of_rotation(rotation : PdfPageRotation) -> Int

    Convert a normalized page rotation to the integer stored in /Rotate.

    pdf_page_label_add_label

    source
    fn pdf_page_label_add_label(end_page : Int, labels : ArrayView[PdfPageLabel], label : PdfPageLabel, range_end_page : Int) -> Array[PdfPageLabel]

    Insert or replace a label range over a page interval.

    Existing ranges after range_end_page are preserved, and a continuation range is inserted when needed so later labels keep their previous numbering.

    pdf_page_label_basic

    source
    let pdf_page_label_basic : PdfPageLabel

    Default decimal page-label range starting at page 1 with value 1.

    pdf_page_label_coalesce

    source
    fn pdf_page_label_coalesce(labels : ArrayView[PdfPageLabel]) -> Array[PdfPageLabel]

    Collapse adjacent page-label ranges that produce the same numbering stream.

    Ranges are merged only when their style, prefix, and start_page -start_value offset are identical, so visible labels for every page remain unchanged.

    pdf_page_label_complete

    source
    fn pdf_page_label_complete(labels : ArrayView[PdfPageLabel]) -> Array[PdfPageLabel]

    Ensure a label list has an initial range covering page 1.

    Empty lists or lists that start after page 1 receive pdf_page_label_basic.

    pdf_page_label_merge

    source
    fn pdf_page_label_merge(pdfs : ArrayView[PdfDocument], ranges : ArrayView[Array[Int]]) -> Array[PdfPageLabel] raise 
    PdfError

    Merge page labels for selected pages from several source documents.

    ranges contains 1-based source page numbers for each document. The merged result preserves the visible labels from those source pages at their new concatenated positions and coalesces adjacent equivalent ranges.

    Raises if the document and range arrays have different lengths, or if a source document's page-label tree cannot be read.

    pdf_page_label_of_page_number

    source
    fn pdf_page_label_of_page_number(page_number : Int, labels : ArrayView[PdfPageLabel]) -> PdfPageLabel?

    Find the active page-label range for a 1-based page number.

    The input ranges are expected in document order. Returns None when the document has no page-label ranges.

    pdf_page_label_of_single

    source
    fn pdf_page_label_of_single(page_number : Int, label : PdfPageLabel) -> PdfPageLabel

    Return the effective page-label range for one concrete page.

    The returned range keeps the style and prefix, but normalizes start_page and start_value to the numeric value displayed on page_number.

    pdf_page_label_style_of_string

    source
    fn pdf_page_label_style_of_string(text : String) -> PdfPageLabelStyle raise 
    PdfError

    Parse a debug-style page-label style name.

    Unknown names raise PdfError::PageLabelStyleExpected.

    pdf_page_label_text_of_page_number

    source
    fn pdf_page_label_text_of_page_number(page_number : Int, labels : ArrayView[PdfPageLabel]) -> Bytes?

    Render the visible label text for a 1-based page number.

    Returns None when there are no label ranges. Label prefixes are returned as raw PDF bytes, preserving the encoding stored in the PDF string.

    pdf_page_label_text_of_single

    source
    fn pdf_page_label_text_of_single(page_number : Int, label : PdfPageLabel) -> Bytes

    Render the visible label text for one page within a label range.

    The optional prefix bytes are copied first. The numeric suffix is calculated from the range's 1-based start_page and start_value, then formatted with the range style.

    pdf_page_object_number

    source
    fn pdf_page_object_number(document : PdfDocument, page_number : Int) -> Int? raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_object_number.

    pdf_page_process_stub

    source
    fn[A, B, C] pdf_page_process_stub(process : (A, B) -> C raise, number : A, page : B) -> (C, A, 
    TransformMatrix    ) raise

    Adapter for callbacks that process page-like values and return identity geometry.

    This preserves the CamlPDF callback shape by returning the callback result, original number, and identity transform matrix.

    pdf_page_protect

    source
    fn pdf_page_protect(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Return balancing graphics-state operators for an existing operator list.

    If the list contains more q saves than Q restores, matching restores are returned. Otherwise the result is empty.

    pdf_page_rectangle_of_paper

    source
    fn pdf_page_rectangle_of_paper(paper : 
    PaperSize    ) -> PdfObject

    Build a PDF rectangle object for a named paper size.

    The rectangle is [0 0 width height] in points.

    pdf_page_reference_numbers

    source
    fn pdf_page_reference_numbers(document : PdfDocument) -> Array[Int] raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_reference_numbers.

    pdf_page_rotation_of_int

    source
    fn pdf_page_rotation_of_int(value : Int) -> PdfPageRotation raise 
    PdfError

    Convert a PDF /Rotate integer to a normalized rotation.

    Multiples equivalent to 0, 90, 180, and 270 degrees are accepted. Other values raise PdfError::PageRotationExpected.

    pdf_pagenumber_of_target

    source
    fn pdf_pagenumber_of_target(document : PdfDocument, destination : PdfDestination) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::page_number_of_target.

    pdf_pages_of_pagetree

    source
    fn pdf_pages_of_pagetree(document : PdfDocument) -> Array[PdfPage] raise 
    PdfError

    Compatibility wrapper for PdfDocument::pages_of_pagetree.

    pdf_parse_bookmark_json

    source
    fn pdf_parse_bookmark_json(verify : Bool, json : Json, document : PdfDocument) -> Array[PdfBookmark] raise 
    PdfError

    Compatibility wrapper for PdfDocument::parse_bookmark_json.

    pdf_parse_bookmark_text

    source
    fn pdf_parse_bookmark_text(verify : Bool, data : BytesView, document : PdfDocument) -> Array[PdfBookmark] raise 
    PdfError

    Compatibility wrapper for PdfDocument::parse_bookmark_text.

    pdf_parse_cmap

    source
    fn pdf_parse_cmap(document : PdfDocument, cmap : PdfObject) -> PdfParsedCMap raise 
    PdfError

    Compatibility wrapper for PdfDocument::parse_cmap.

    pdf_parse_cmap_data

    source
    fn pdf_parse_cmap_data(data : BytesView) -> PdfParsedCMap

    Parse raw CMap or ToUnicode bytes into mapping tables and metadata.

    The parser accepts common CMap sections such as code-space ranges, bfchar/bfrange, CID ranges, notdef ranges, /UseCMap, /WMode, and CID-system metadata. Unrecognized or malformed sections are skipped rather than causing a document-level failure.

    pdf_parse_content_colour

    source
    fn pdf_parse_content_colour(text : String) -> PdfContentColour raise 
    PdfError

    Parse a cpdf draw/add-text colour argument.

    CSS colour names are converted to RGB values in the range 0.0..1.0. Numeric arguments follow cpdf's arity convention: one number is gray, three numbers are RGB, and four numbers are CMYK.

    pdf_parse_content_ops_from_bytes

    source
    fn pdf_parse_content_ops_from_bytes(data : Bytes) -> Array[PdfContentOp] raise 
    PdfError

    Parse standalone content bytes without document or resource context.

    This is suitable for ordinary operators and inline images that can be read from explicit length or filter markers. Use the document methods when stream decoding or resource-based inline-image sizing is required.

    pdf_parse_content_ops_from_view

    source
    fn pdf_parse_content_ops_from_view(data : BytesView) -> Array[PdfContentOp] raise 
    PdfError

    Parse a standalone content byte view without document or resource context.

    pdf_parse_coordinate

    source
    fn pdf_parse_coordinate(document : PdfDocument, text : String) -> 
    Point2     raise 
    PdfError

    pdf_parse_coordinate_rectangle

    source
    fn pdf_parse_coordinate_rectangle(document : PdfDocument, text : String) -> PdfCoordRectangle raise 
    PdfError

    pdf_parse_coordinate_rectangles

    source
    fn pdf_parse_coordinate_rectangles(document : PdfDocument, text : String) -> Array[PdfCoordRectangle] raise 
    PdfError

    pdf_parse_coordinates

    source
    fn pdf_parse_coordinates(document : PdfDocument, text : String) -> Array[
    Point2    ] raise 
    PdfError

    pdf_parse_draw_colour

    source
    fn pdf_parse_draw_colour(text : String) -> PdfDrawColour raise 
    PdfError

    Parse a cpdf draw-control colour argument.

    This ports cpdfdrawcontrol.ml's parse_colour/col_of_string path while preserving the draw-layer NoCol sentinel separately from content colours.

    pdf_parse_flate_unicode_data

    source
    fn pdf_parse_flate_unicode_data(source : BytesView) -> Array[PdfUnicodeDataEntry] raise 
    PdfError

    Decode cpdf's flate-compressed UnicodeData source bytes, then parse rows.

    pdf_parse_function

    source
    fn pdf_parse_function(document : PdfDocument, function_object : PdfObject) -> PdfFunction raise 
    PdfError

    Compatibility wrapper for PdfDocument::parse_function.

    pdf_parse_indirect_object_from_bytes

    source
    fn pdf_parse_indirect_object_from_bytes(data : Bytes) -> PdfParsedIndirectObject raise 
    PdfError

    Parses one indirect object from owned PDF bytes.

    pdf_parse_indirect_object_from_view

    source
    fn pdf_parse_indirect_object_from_view(data : BytesView) -> PdfParsedIndirectObject raise 
    PdfError

    Parses one indirect object from a byte view.

    pdf_parse_indirect_object_lexemes

    source
    fn pdf_parse_indirect_object_lexemes(lexemes : ArrayView[PdfLexeme]) -> PdfParsedIndirectObject raise 
    PdfError

    Parses one indirect object from lexemes.

    Raises PdfError::ParseIndirectObjectExpected if the input does not start with an indirect object header.

    pdf_parse_indirect_objects

    source

    Parses every complete indirect object from a lexeme sequence.

    Raises PdfError::ParseIndirectObjectExpected when an expected indirect object header is malformed.

    pdf_parse_lexemes

    source

    Parses all top-level PDF objects from lexemes.

    Comments are skipped. Arrays and dictionaries are parsed recursively, and indirect-reference triples are collapsed into PdfIndirect objects.

    pdf_parse_object_from_bytes

    source
    fn pdf_parse_object_from_bytes(data : Bytes) -> PdfObject raise 
    PdfError

    Lexes and parses exactly one PDF object from owned PDF bytes.

    pdf_parse_object_from_view

    source
    fn pdf_parse_object_from_view(data : BytesView) -> PdfObject raise 
    PdfError

    Lexes and parses exactly one PDF object from a byte view.

    pdf_parse_pagespec

    source
    fn pdf_parse_pagespec(document : PdfDocument, spec : String) -> Array[Int] raise 
    PdfError

    pdf_parse_pagespec_for_count

    source
    fn pdf_parse_pagespec_for_count(end_page : Int, spec : String) -> Array[Int] raise 
    PdfError

    pdf_parse_pagespec_without_pdf

    source
    fn pdf_parse_pagespec_without_pdf(spec : String) -> Array[Int] raise 
    PdfError

    pdf_parse_single_lexeme_object

    source
    fn pdf_parse_single_lexeme_object(lexemes : ArrayView[PdfLexeme]) -> PdfObject raise 
    PdfError

    Parses exactly one top-level PDF object from lexemes.

    Raises PdfError::ParseSingleObjectExpected if the input contains zero or more than one object.

    pdf_parse_single_number

    source
    fn pdf_parse_single_number(document : PdfDocument, text : String) -> Double raise 
    PdfError

    pdf_parse_stream_object_from_bytes

    source
    fn pdf_parse_stream_object_from_bytes(data : Bytes) -> PdfParsedIndirectObject raise 
    PdfError

    Parse a single indirect stream object from owned bytes.

    The input should contain one indirect-object header, a stream dictionary, stream data, endstream, and endobj.

    pdf_parse_stream_object_from_view

    source
    fn pdf_parse_stream_object_from_view(data : BytesView) -> PdfParsedIndirectObject raise 
    PdfError

    Parse a single indirect stream object from a borrowed byte view.

    Malformed /Length values are recovered by scanning to endstream when possible, matching the stream recovery used by the primitive reader.

    pdf_parse_unicode_data

    source
    fn pdf_parse_unicode_data(source : BytesView) -> Array[PdfUnicodeDataEntry] raise 
    PdfError

    Parse UnicodeData.txt bytes into cpdf-compatible rows.

    pdf_parse_units_string

    source
    fn pdf_parse_units_string(document : PdfDocument, page : PdfPage, text : String) -> Array[Double] raise 
    PdfError

    pdf_path_bounds

    source
    fn pdf_path_bounds(path : PdfPath) -> PdfRectangle

    Compatibility wrapper for PdfPath::bounds.

    pdf_path_content_bounding_box

    source
    fn pdf_path_content_bounding_box(path : PdfPath, ctm : 
    TransformMatrix    , line_width : Double, stroking : Bool) -> PdfContentBoundingBox?

    Compatibility wrapper for PdfPath::content_bounding_box.

    pdf_path_segment_bounds

    source
    fn pdf_path_segment_bounds(segment : PdfPathSegment) -> PdfRectangle

    Compatibility wrapper for PdfPathSegment::bounds.

    pdf_path_segment_content_json

    source
    fn pdf_path_segment_content_json(segment : PdfPathSegment) -> Json

    Compatibility wrapper for PdfPathSegment::content_json.

    pdf_path_segment_transform

    source

    Compatibility wrapper for PdfPathSegment::transform.

    pdf_path_subpath_content_json

    source
    fn pdf_path_subpath_content_json(subpath : PdfPathSubpath) -> Json

    Compatibility wrapper for PdfPathSubpath::content_json.

    pdf_path_transform

    source

    Compatibility wrapper for PdfPath::transform.

    pdf_pdfdocencoding_byte_of_codepoint

    source
    fn pdf_pdfdocencoding_byte_of_codepoint(codepoint : Int) -> Byte?

    Return the PDFDocEncoding byte for a Unicode codepoint, if representable.

    The lookup preserves CamlPDF compatibility for the fi ligature by mapping U+FB01 to byte 0x93.

    pdf_pdfdocencoding_of_codepoints

    source
    fn pdf_pdfdocencoding_of_codepoints(codepoints : ArrayView[Int]) -> Bytes?

    Encode codepoints as PDFDocEncoding when every scalar is representable.

    Returns None instead of falling back to UTF-16BE; use pdf_pdfdocstring_of_codepoints for the PDF string policy fallback.

    pdf_pdfdocstring_of_codepoints

    source
    fn pdf_pdfdocstring_of_codepoints(codepoints : ArrayView[Int]) -> Bytes raise 
    PdfError

    Encode codepoints as a PDF string.

    PDFDocEncoding is used when all codepoints are representable; otherwise the result is a BOM-prefixed UTF-16BE string.

    pdf_pdfdocstring_of_utf8

    source
    fn pdf_pdfdocstring_of_utf8(bytes : BytesView) -> Bytes raise 
    PdfError

    Convert UTF-8 bytes to the compact PDF string representation.

    The result uses PDFDocEncoding when possible and UTF-16BE otherwise.

    pdf_permissions_of_p

    source
    fn pdf_permissions_of_p(mask : Int) -> Array[
    PdfPermission    ]

    Decode a PDF /P permission mask to denied permissions.

    The returned array is a ban list ordered from later permission bits down to basic print/edit/copy permissions.

    pdf_portfolio

    source
    fn pdf_portfolio(document : PdfDocument, entries : ArrayView[PdfPortfolioEntry], mod_date? : Bytes?) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::portfolio.

    pdf_portfolio_entry

    source
    fn pdf_portfolio_entry(filename : String, data : BytesView, relationship? : String?, description? : String?) -> PdfPortfolioEntry

    Construct a portfolio entry, copying the supplied data view.

    pdf_postpend_operators

    source
    fn pdf_postpend_operators(document : PdfDocument, operators : ArrayView[PdfContentOp], page : PdfPage, fast? : Bool) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::postpend_operators.

    pdf_prepend_operators

    source
    fn pdf_prepend_operators(document : PdfDocument, operators : ArrayView[PdfContentOp], page : PdfPage, fast? : Bool) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::prepend_operators.

    pdf_presentation

    source
    fn pdf_presentation(range : ArrayView[Int], transition : String?, delay : Double?, horizontal : Bool, inward : Bool, direction : Int, effect_duration : Double, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::presentation.

    pdf_print_dict_entry

    source
    fn pdf_print_dict_entry(document : PdfDocument, key : 
    PdfName    ) -> Array[Bytes] raise 
    PdfError

    Compatibility wrapper for PdfDocument::dict_entry_rendered_values.

    pdf_print_function

    source
    fn pdf_print_function(function : PdfFunction) -> Unit

    Print the function's diagnostic representation to standard output.

    pdf_print_tree_to_string

    source
    fn[T] pdf_print_tree_to_string(value : T, get_name : (T) -> String, get_children : (T) -> Array[T], line_prefix? : String) -> String

    Render a tree to a string using cpdf's line-drawing layout.

    get_name returns the label for a node, and get_children returns its children in display order. line_prefix is prepended to every rendered line.

    pdf_process_pages

    source

    Compatibility wrapper for PdfDocument::process_pages.

    pdf_progress

    source
    fn pdf_progress() -> Bool

    pdf_progress_done

    source
    fn pdf_progress_done() -> Unit

    pdf_progress_endpage

    source
    fn pdf_progress_endpage() -> Unit

    pdf_progress_line

    source
    fn pdf_progress_line(text : String) -> Unit

    pdf_progress_line_no_end

    source
    fn pdf_progress_line_no_end(text : String) -> Unit

    pdf_progress_output

    source
    fn pdf_progress_output() -> String

    pdf_progress_page

    source
    fn pdf_progress_page(page : Int) -> Unit

    pdf_read_afm

    source
    fn pdf_read_afm(data : BytesView) -> PdfAfmData raise 
    PdfError

    Parses Adobe Font Metrics data from bytes.

    The parser extracts top-level headers, character widths, name-width pairs, and kerning pairs. Raises PdfError::AfmExpected or PdfError::NumberExpected for malformed metric sections.

    pdf_read_bookmarks

    source
    fn pdf_read_bookmarks(document : PdfDocument, preserve_actions? : Bool) -> Array[PdfBookmark] raise 
    PdfError

    Compatibility wrapper for PdfDocument::read_bookmarks.

    pdf_read_classic_document_from_bytes

    source
    fn pdf_read_classic_document_from_bytes(data : Bytes) -> PdfDocument raise 
    PdfError

    Read a classic-xref PDF from owned bytes.

    pdf_read_classic_document_from_view

    source
    fn pdf_read_classic_document_from_view(data : BytesView) -> PdfDocument raise 
    PdfError

    Read a PDF using classic xref metadata.

    This strict reader follows startxref, xref tables/streams, and trailer /Prev links, loads referenced objects, resolves object streams, and records document metadata. It does not use reconstruction fallback.

    pdf_read_classic_document_revision_from_bytes

    source
    fn pdf_read_classic_document_revision_from_bytes(data : Bytes, revision : Int) -> PdfDocument raise 
    PdfError

    Read one classic-xref document revision from owned bytes.

    pdf_read_classic_document_revision_from_view

    source
    fn pdf_read_classic_document_revision_from_view(data : BytesView, revision : Int) -> PdfDocument raise 
    PdfError

    Read one classic-xref document revision.

    Revision 1 is the newest revision; larger revision numbers select older revisions by following trailer /Prev links. Invalid or unavailable revisions raise PdfError::BadRevision.

    pdf_read_colour_space

    source
    fn pdf_read_colour_space(document : PdfDocument, resources : PdfObject, object : PdfObject) -> PdfColourSpace? raise 
    PdfError

    Compatibility wrapper for PdfDocument::read_colour_space.

    pdf_read_destination

    source
    fn pdf_read_destination(document : PdfDocument, object : PdfObject, shallow? : Bool) -> PdfDestination raise 
    PdfError

    Reads and normalizes a PDF destination object.

    This is the standalone form of PdfDocument::read_destination.

    pdf_read_document_from_bytes

    source
    fn pdf_read_document_from_bytes(data : Bytes) -> PdfDocument raise 
    PdfError

    Read a PDF document from owned PDF bytes.

    pdf_read_document_from_bytes_with_passwords

    source
    fn pdf_read_document_from_bytes_with_passwords(data : Bytes, user_password? : BytesView?, owner_password? : BytesView?) -> PdfDecryptionResult? raise 
    PdfError

    Read and decrypt a PDF document from owned PDF bytes.

    pdf_read_document_from_view

    source
    fn pdf_read_document_from_view(data : BytesView) -> PdfDocument raise 
    PdfError

    Read a PDF document from a borrowed byte view.

    This is the high-level non-password reader. It first tries the strict classic xref reader and probes the page tree; for selected structural errors it falls back to reconstruction by scanning indirect objects.

    pdf_read_document_from_view_with_passwords

    source
    fn pdf_read_document_from_view_with_passwords(data : BytesView, user_password? : BytesView?, owner_password? : BytesView?) -> PdfDecryptionResult? raise 
    PdfError

    Read and decrypt a PDF document using optional passwords.

    This is the high-level password-aware reader. It uses the same reconstruction fallback policy as pdf_read_document_from_view before attempting decryption. Unencrypted documents return a copied document inside Some(...).

    pdf_read_document_revision_from_bytes

    source
    fn pdf_read_document_revision_from_bytes(data : Bytes, revision : Int) -> PdfDocument raise 
    PdfError

    Read one document revision from owned PDF bytes.

    pdf_read_document_revision_from_bytes_with_passwords

    source
    fn pdf_read_document_revision_from_bytes_with_passwords(data : Bytes, revision : Int, user_password? : BytesView?, owner_password? : BytesView?) -> PdfDecryptionResult? raise 
    PdfError

    Read and decrypt one PDF revision from owned bytes.

    pdf_read_document_revision_from_view

    source
    fn pdf_read_document_revision_from_view(data : BytesView, revision : Int) -> PdfDocument raise 
    PdfError

    Read one document revision from a borrowed byte view.

    Revision selection uses strict classic-xref parsing and does not use the reconstruction fallback used by pdf_read_document_from_view.

    pdf_read_document_revision_from_view_with_passwords

    source
    fn pdf_read_document_revision_from_view_with_passwords(data : BytesView, revision : Int, user_password? : BytesView?, owner_password? : BytesView?) -> PdfDecryptionResult? raise 
    PdfError

    Read and decrypt one PDF revision using optional passwords.

    Revision 1 is the newest revision. The returned value is None when the document is encrypted and neither supplied password can decrypt it; otherwise it contains the decrypted document and permission information.

    pdf_read_font

    source
    fn pdf_read_font(document : PdfDocument, font : PdfObject) -> PdfFont raise 
    PdfError

    Compatibility wrapper for PdfDocument::read_font.

    pdf_read_header_from_bytes

    source
    fn pdf_read_header_from_bytes(data : Bytes) -> PdfVersion raise 
    PdfError

    Read a PDF header version from owned PDF bytes.

    pdf_read_header_from_view

    source
    fn pdf_read_header_from_view(data : BytesView) -> PdfVersion raise 
    PdfError

    Read a PDF header version from a borrowed byte view.

    pdf_read_name_tree

    source
    fn pdf_read_name_tree(document : PdfDocument, tree : PdfObject) -> Array[(Bytes, PdfObject)]

    Compatibility wrapper for PdfDocument::read_name_tree.

    pdf_read_number_tree

    source
    fn pdf_read_number_tree(document : PdfDocument, tree : PdfObject) -> Array[(Bytes, PdfObject)]

    Compatibility wrapper that returns number-tree keys as decimal ASCII bytes.

    This mirrors APIs that represent both name and number tree keys as PdfBytes; each integer key is encoded with Int::to_string.

    pdf_read_ocg

    source

    Compatibility wrapper for PdfDocument::read_optional_content_groups.

    pdf_read_page_labels

    source
    fn pdf_read_page_labels(document : PdfDocument) -> Array[PdfPageLabel] raise 
    PdfError

    Compatibility wrapper for PdfDocument::read_page_labels.

    pdf_read_png

    source
    fn pdf_read_png(data : Bytes) -> PdfPNG raise 
    PdfError

    Read a non-palette, non-interlaced PNG from owned bytes.

    pdf_read_png_view

    source
    fn pdf_read_png_view(data : BytesView) -> PdfPNG raise 
    PdfError

    Read a non-palette, non-interlaced PNG from a byte view.

    pdf_read_primitive_document_from_bytes

    source
    fn pdf_read_primitive_document_from_bytes(data : Bytes) -> PdfDocument raise 
    PdfError

    Parse a primitive document from owned PDF bytes.

    pdf_read_primitive_document_from_view

    source
    fn pdf_read_primitive_document_from_view(data : BytesView) -> PdfDocument raise 
    PdfError

    Parse indirect objects by scanning the byte stream without xref tables.

    This primitive reader is useful for fixtures and damaged files. It reads the header, then scans indirect object syntax and stream bodies in sequence; it does not interpret trailer/xref metadata or decrypt the document.

    pdf_rectify_boxes

    source
    fn pdf_rectify_boxes(document : PdfDocument, page : PdfPage, fast? : Bool) -> PdfPage raise 
    PdfError

    Compatibility wrapper for PdfDocument::rectify_boxes.

    pdf_recurse_array

    source
    fn pdf_recurse_array(transform : (PdfObject) -> PdfObject, values : ArrayView[PdfObject]) -> PdfObject

    Apply a one-level transformation to array elements.

    This helper does not recursively traverse nested dictionaries or arrays by itself; callers provide a transform that decides how each child object is rewritten.

    pdf_recurse_dict

    source
    fn pdf_recurse_dict(transform : (PdfObject) -> PdfObject, entries : ArrayView[(
    PdfName    , PdfObject)], preserve_order? : Bool) -> PdfObject

    Apply a one-level transformation to dictionary values.

    By default the resulting dictionary entries are reversed to match the historical CamlPDF construction order. Pass preserve_order=true when the incoming order must be retained.

    pdf_redact

    source
    fn pdf_redact(document : PdfDocument, path : ArrayView[(Double, Double)], page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::redact_path.

    pdf_redact_pages

    source
    fn pdf_redact_pages(document : PdfDocument, page_numbers : ArrayView[Int], process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::redact_pages.

    pdf_remove_added_text

    source
    fn pdf_remove_added_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_added_text.

    pdf_remove_added_text_ops

    source
    fn pdf_remove_added_text_ops(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Remove content marked as /CPDFSTAMP, matching cpdf's add-text cleanup.

    Nested /CPDFSTAMP ... EMC sections are skipped as a unit. If a stamp block is unterminated, all following operators are dropped, matching the OCaml recursive removal behavior.

    pdf_remove_all_metadata

    source
    fn pdf_remove_all_metadata(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_all_metadata.

    pdf_remove_all_text

    source
    fn pdf_remove_all_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_all_text.

    pdf_remove_all_text_ops

    source
    fn pdf_remove_all_text_ops(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Remove text-showing operators while preserving text positioning/state ops.

    pdf_remove_annotations

    source
    fn pdf_remove_annotations(page_numbers : ArrayView[Int], document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_annotations.

    pdf_remove_art_pdf

    source
    fn pdf_remove_art_pdf(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_art.

    pdf_remove_attached_files

    source
    fn pdf_remove_attached_files(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_attached_files.

    pdf_remove_bleed_pdf

    source
    fn pdf_remove_bleed_pdf(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_bleed.

    pdf_remove_bookmarks

    source
    fn pdf_remove_bookmarks(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_bookmarks.

    pdf_remove_clipping

    source
    fn pdf_remove_clipping(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_clipping.

    pdf_remove_clipping_ops

    source
    fn pdf_remove_clipping_ops(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Remove clipping-path setup sequences from parsed content operators.

    This ports cpdftweak.ml's remove_clipping_ops: only the exact W n sequence is rewritten, becoming just n.

    pdf_remove_cropping_pdf

    source
    fn pdf_remove_cropping_pdf(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_cropping.

    pdf_remove_dict_entry

    source
    fn pdf_remove_dict_entry(document : PdfDocument, key : 
    PdfName    , search? : PdfObject?) -> Unit

    Compatibility wrapper for PdfDocument::remove_dict_entry_everywhere.

    pdf_remove_duplicate_fonts

    source
    fn pdf_remove_duplicate_fonts(document : PdfDocument) -> Unit

    Removes duplicate embedded font streams from a document.

    This is the standalone form of PdfDocument::remove_duplicate_fonts.

    pdf_remove_fonts

    source
    fn pdf_remove_fonts(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_embedded_fonts.

    pdf_remove_javascript

    source
    fn pdf_remove_javascript(document : PdfDocument) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_javascript.

    pdf_remove_metadata

    source
    fn pdf_remove_metadata(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_metadata.

    pdf_remove_object_by_spec

    source
    fn pdf_remove_object_by_spec(document : PdfDocument, spec : String) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_object_by_spec.

    pdf_remove_ocg

    source
    fn pdf_remove_ocg(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_optional_content_groups.

    pdf_remove_page_box

    source
    fn pdf_remove_page_box(document : PdfDocument, page_numbers : ArrayView[Int], box_name : 
    PdfName    ) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_page_box.

    pdf_remove_page_labels

    source
    fn pdf_remove_page_labels(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_page_labels.

    pdf_remove_struct_tree

    source
    fn pdf_remove_struct_tree(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_struct_tree.

    pdf_remove_trim_pdf

    source
    fn pdf_remove_trim_pdf(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_trim.

    pdf_renumber_documents

    source
    fn pdf_renumber_documents(documents : ArrayView[PdfDocument]) -> Array[PdfDocument] raise 
    PdfError

    Return copies of documents renumbered into one non-overlapping sequence.

    The first document starts at object number 1; each following document starts after the previous document's object count. This is primarily used before merging documents that may have colliding object numbers.

    pdf_renumber_pages

    source
    fn pdf_renumber_pages(document : PdfDocument, pages : ArrayView[PdfPage]) -> Array[PdfPage] raise 
    PdfError

    Compatibility wrapper for PdfDocument::renumber_pages.

    pdf_renumber_parent_trees

    source
    fn pdf_renumber_parent_trees(documents : ArrayView[PdfDocument]) -> Unit raise 
    PdfError

    Renumber structure parent-tree keys across documents before merging.

    The documents are mutated in place. Parent-tree keys are reassigned to a single increasing sequence, and structure parent references inside each document are updated to match the rebuilt number trees.

    pdf_replace_dict_entry

    source
    fn pdf_replace_dict_entry(document : PdfDocument, key : 
    PdfName    , value : PdfObject, search? : PdfObject?) -> Unit

    Compatibility wrapper for PdfDocument::replace_dict_entry_everywhere.

    pdf_replace_object_by_spec

    source
    fn pdf_replace_object_by_spec(document : PdfDocument, spec : String, value : PdfObject) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::replace_object_by_spec.

    pdf_replace_stream_by_spec

    source
    fn pdf_replace_stream_by_spec(document : PdfDocument, spec : String, data : BytesView) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::replace_stream_by_spec.

    pdf_restrict_angle

    source
    fn pdf_restrict_angle(step : Double, angle : Double) -> Double

    Restrict an angle to the closest multiple of step, modulo 2 * pi.

    pdf_reveal_hidden_text

    source
    fn pdf_reveal_hidden_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::reveal_hidden_text.

    pdf_reveal_hidden_text_ops

    source
    fn pdf_reveal_hidden_text_ops(ops : ArrayView[PdfContentOp]) -> Array[PdfContentOp]

    Remove text rendering-mode operators so hidden text is rendered normally.

    pdf_reverse_table_of_encoding

    source
    fn pdf_reverse_table_of_encoding(encoding : PdfEncoding) -> Array[(
    PdfName    , Int)]

    Compatibility wrapper for PdfEncoding::reverse_table.

    pdf_revisions_from_bytes

    source
    fn pdf_revisions_from_bytes(data : Bytes) -> Int raise 
    PdfError

    Count document revisions from owned PDF bytes.

    pdf_revisions_from_view

    source
    fn pdf_revisions_from_view(data : BytesView) -> Int raise 
    PdfError

    Count document revisions by following xref /Prev links.

    Revision 1 is the newest revision referenced by startxref; larger numbers walk backward through older revisions. Linearized hint-table revisions are excluded from the returned count.

    pdf_rotate_contents

    source
    fn pdf_rotate_contents(document : PdfDocument, rotation : Double, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::rotate_contents.

    pdf_rotate_pages

    source
    fn pdf_rotate_pages(document : PdfDocument, rotation : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::rotate_pages.

    pdf_rotate_pages_by

    source
    fn pdf_rotate_pages_by(document : PdfDocument, rotation : Int, page_numbers : ArrayView[Int]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::rotate_pages_by.

    pdf_run_length_decode

    source
    fn pdf_run_length_decode(data : Bytes) -> Bytes

    Owned-byte wrapper for pdf_run_length_decode_view.

    pdf_run_length_decode_view

    source
    fn pdf_run_length_decode_view(data : BytesView) -> Bytes

    Decode PDF RunLengthDecode data.

    Decoding stops at the 128 end marker or end of input. Truncated trailing runs are decoded as far as bytes are available, matching the tolerant reader behavior used by CamlPDF.

    pdf_run_length_encode

    source
    fn pdf_run_length_encode(data : Bytes) -> Bytes

    Owned-byte wrapper for pdf_run_length_encode_view.

    pdf_run_length_encode_view

    source
    fn pdf_run_length_encode_view(data : BytesView) -> Bytes

    Encode bytes with PDF RunLengthDecode syntax.

    Literal runs and repeated-byte runs are emitted with the standard 128 end-of-data marker.

    pdf_scale_contents

    source
    fn pdf_scale_contents(document : PdfDocument, page_numbers : ArrayView[Int], position : PdfPosition, scale : Double, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::scale_contents.

    pdf_scale_pages

    source
    fn pdf_scale_pages(document : PdfDocument, page_numbers : ArrayView[Int], scales : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::scale_pages.

    pdf_scale_to_fit_pages

    source
    fn pdf_scale_to_fit_pages(document : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], position? : PdfPosition, input_scale? : Double, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::scale_to_fit_pages.

    pdf_scale_to_fit_rotate_pages

    source
    fn pdf_scale_to_fit_rotate_pages(document : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], rotation : Int, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::scale_to_fit_rotate_pages.

    pdf_secure_random_bytes

    source
    fn pdf_secure_random_bytes(length : Int) -> Bytes raise 
    PdfError

    Return cryptographically secure random bytes on the native target.

    The native stub uses the platform RNG (BCryptGenRandom on Windows and /dev/urandom on Unix-like systems). Negative lengths raise PdfError::InvalidReadLength; RNG failures raise PdfError::RandomBytesUnavailable.

    pdf_set_annotations_json

    source
    fn pdf_set_annotations_json(json : Json, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_annotations_json.

    pdf_set_box

    source
    fn pdf_set_box(document : PdfDocument, page_numbers : ArrayView[Int], box_name : 
    PdfName    , min_x : Double, max_x : Double, min_y : Double, max_y : Double) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_page_box.

    pdf_set_language

    source
    fn pdf_set_language(document : PdfDocument, language : BytesView) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_language.

    pdf_set_mediaboxes

    source
    fn pdf_set_mediaboxes(document : PdfDocument, page_numbers : ArrayView[Int], boxes : ArrayView[(Double, Double, Double, Double)]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_mediaboxes.

    pdf_set_metadata_date

    source
    fn pdf_set_metadata_date(document : PdfDocument, date : String) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_metadata_date.

    pdf_set_metadata_from_bytes

    source
    fn pdf_set_metadata_from_bytes(keep_version : Bool, data : BytesView, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_metadata_from_bytes.

    pdf_set_non_full_screen_page_mode

    source
    fn pdf_set_non_full_screen_page_mode(document : PdfDocument, mode : String) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_non_full_screen_page_mode.

    pdf_set_open_action

    source
    fn pdf_set_open_action(document : PdfDocument, fit : Bool, page_number : Int, destination? : PdfObject?) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_open_action.

    pdf_set_page_layout

    source
    fn pdf_set_page_layout(document : PdfDocument, layout : String) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_page_layout.

    pdf_set_page_mode

    source
    fn pdf_set_page_mode(document : PdfDocument, mode : String) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_page_mode.

    pdf_set_pdf_info

    source
    fn pdf_set_pdf_info(key : 
    PdfName    , value : PdfObject, version : Int, document : PdfDocument, keep_version? : Bool, xmp_also? : Bool, xmp_just_set? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_info_entry.

    pdf_set_progress

    source
    fn pdf_set_progress(enabled : Bool) -> Unit

    pdf_set_version

    source
    fn pdf_set_version(minor : Int, document : PdfDocument) -> Unit

    Compatibility wrapper for cpdf's minor-version setter.

    pdf_set_viewer_preference

    source
    fn pdf_set_viewer_preference(key : 
    PdfName    , value : PdfObject, version : Int, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::set_viewer_preference.

    pdf_shape_circle

    source
    fn pdf_shape_circle(center_x : Double, center_y : Double, radius : Double) -> PdfPath

    Build a cpdf-style circular path from four Bezier quarter arcs.

    pdf_shape_kappa

    source
    let pdf_shape_kappa : Double

    Bezier control-line factor used by cpdf for circular arcs.

    pdf_shape_rectangle

    source
    fn pdf_shape_rectangle(x : Double, y : Double, width : Double, height : Double) -> PdfPath

    Build a cpdf-style rectangle path from a top-left point, width, and height.

    pdf_shift_boxes

    source
    fn pdf_shift_boxes(document : PdfDocument, page_numbers : ArrayView[Int], offsets : ArrayView[(Double, Double)]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::shift_boxes.

    pdf_shift_pages

    source
    fn pdf_shift_pages(document : PdfDocument, page_numbers : ArrayView[Int], offsets : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::shift_pages.

    pdf_shortest_unused_prefix

    source
    fn pdf_shortest_unused_prefix(document : PdfDocument) -> String

    Compatibility wrapper for PdfDocument::shortest_unused_prefix.

    pdf_show_annotation_bounding_boxes

    source
    fn pdf_show_annotation_bounding_boxes(document : PdfDocument, page_numbers : ArrayView[Int], light? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::show_annotation_bounding_boxes.

    pdf_show_bounding_boxes

    source
    fn pdf_show_bounding_boxes(document : PdfDocument, page_numbers : ArrayView[Int], shape? : PdfRectangle?, light? : Bool, fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::show_bounding_boxes.

    pdf_show_boxes

    source
    fn pdf_show_boxes(document : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::show_page_boxes.

    pdf_show_composition_json_blob

    source
    fn pdf_show_composition_json_blob(file_size : Int, document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::composition_json_blob.

    pdf_simplify_utf16be

    source
    fn pdf_simplify_utf16be(bytes : BytesView) -> Bytes raise 
    PdfError

    Re-encode a UTF-16BE PDF string using PDFDocEncoding when possible.

    Non-Unicode input is returned as an owned copy. Malformed UTF-16BE raises PdfError::InvalidUTF16BE.

    pdf_size_attached_files

    source
    fn pdf_size_attached_files(document : PdfDocument) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::size_attached_files.

    pdf_soft_error

    source
    fn pdf_soft_error(message : String) -> Unit raise 
    PdfError

    Raise a cpdf-style soft error.

    pdf_stamp

    source
    fn pdf_stamp(document : PdfDocument, page_numbers : ArrayView[Int], overlay : PdfDocument, relative_to_box? : 
    PdfName    , position? : PdfPosition, topline? : Bool, midline? : Bool, fast? : Bool, scale_to_fit? : Bool, is_over? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::stamp_pages.

    pdf_stamp_as_xobject

    source

    Compatibility wrapper for PdfDocument::stamp_as_xobject.

    pdf_standard14_afm_data

    source
    fn pdf_standard14_afm_data(font : PdfStandardFont) -> PdfAfmData

    Returns the Adobe Font Metrics data for a standard font.

    pdf_standard14_baseline_adjustment

    source
    fn pdf_standard14_baseline_adjustment(font : PdfStandardFont) -> Int

    Returns the baseline adjustment used by CamlPDF for this standard font.

    pdf_standard14_flags_of_standard_font

    source
    fn pdf_standard14_flags_of_standard_font(font : PdfStandardFont) -> Int

    Returns the PDF font descriptor flags for this standard font.

    pdf_standard14_stemv_of_standard_font

    source
    fn pdf_standard14_stemv_of_standard_font(font : PdfStandardFont) -> Int

    Returns the /StemV value used when writing this standard font.

    pdf_standard14_text_width

    source
    fn pdf_standard14_text_width(font : PdfStandardFont, encoding : PdfEncoding, text : BytesView, kern? : Bool) -> Int

    Computes the width of byte-encoded text in standard-font glyph units.

    When kern is true, AFM kerning pairs are included between adjacent character codes.

    pdf_standard14_textwidth

    source
    fn pdf_standard14_textwidth(kern : Bool, encoding : PdfEncoding, font : PdfStandardFont, text : BytesView) -> Int

    CamlPDF-shaped wrapper for standard-14 text width calculation.

    pdf_standard_font_of_name

    source
    fn pdf_standard_font_of_name(name : String) -> PdfStandardFont?

    Recognize a standard 14 font from an ASCII PDF font name.

    name is expected to include the leading slash, for example "/Helvetica". Common Microsoft aliases such as /Arial and /TimesNewRoman are accepted for CamlPDF compatibility.

    pdf_standard_font_of_pdf_name

    source
    fn pdf_standard_font_of_pdf_name(name : 
    PdfName    ) -> PdfStandardFont?

    Recognize a standard 14 font from a byte-oriented PDF name.

    This is the allocation-light variant used while parsing font dictionaries. It accepts the canonical PDF names and the same common aliases as pdf_standard_font_of_name.

    pdf_standard_font_substitute_filenames

    source
    fn pdf_standard_font_substitute_filenames(font : PdfStandardFont) -> Array[String]

    Return cpdf's substitute font file candidates for a Standard 14 font.

    This is the pure table from cpdfembed.ml's load_substitute; callers that need bytes can resolve these filenames relative to their own filesystem boundary.

    pdf_standard_font_substitute_font_name

    source
    fn pdf_standard_font_substitute_font_name(font : PdfStandardFont) -> String

    Return cpdf's substitute font name for a Standard 14 font.

    pdf_stream

    source
    fn pdf_stream(dictionary : PdfObject, data : PdfStreamData) -> PdfObject

    Construct a PDF stream object from a dictionary object and stream data.

    The dictionary is stored as supplied. It is normally a PdfDictionary, but malformed inputs can carry other objects and will be reported by helpers that require dictionary metadata.

    pdf_stretch_pages

    source
    fn pdf_stretch_pages(document : PdfDocument, page_numbers : ArrayView[Int], sizes : ArrayView[(Double, Double)], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::stretch_pages.

    pdf_strftime

    source
    fn pdf_strftime(text : String, time? : PdfStrftimeTime?) -> String raise 
    PdfError

    Format text using cpdf's strftime subset.

    When time is omitted, the native local time is used.

    pdf_strftime_dummy_time

    source
    fn pdf_strftime_dummy_time() -> PdfStrftimeTime

    Dummy cpdf strftime time value.

    pdf_strftime_with_time

    source
    fn pdf_strftime_with_time(time : PdfStrftimeTime, text : String) -> String

    Format text using cpdf's C-style strftime subset and an explicit time.

    This follows the OCaml implementation's replacement order and field semantics, including zero-based %j and the absence of a %s replacement.

    pdf_string_of_bookmark

    source
    fn pdf_string_of_bookmark(bookmark : PdfBookmark) -> Bytes raise 
    PdfError

    Format a bookmark as a diagnostic byte string.

    The output includes level, title bytes, destination object, and open state; it is intended for debugging rather than PDF serialization.

    pdf_string_of_calculator

    source
    fn pdf_string_of_calculator(ops : ArrayView[PdfCalculatorOp]) -> String

    Format calculator operations as a brace-delimited diagnostic program.

    pdf_string_of_colour_space

    source
    fn pdf_string_of_colour_space(space : PdfColourSpace) -> String

    Compatibility wrapper for PdfColourSpace::debug_name.

    pdf_string_of_content_op

    source
    fn pdf_string_of_content_op(op : PdfContentOp) -> Bytes raise 
    PdfError

    Compatibility wrapper for pdf_content_bytes_of_op.

    The name follows CamlPDF, where strings were byte sequences; this function returns PdfBytes.

    pdf_string_of_content_ops

    source
    fn pdf_string_of_content_ops(ops : ArrayView[PdfContentOp]) -> Bytes raise 
    PdfError

    Compatibility wrapper for pdf_content_bytes_of_ops.

    The name follows CamlPDF, where strings were byte sequences; this function returns PdfBytes.

    pdf_string_of_date

    source

    Formats a PDF date as an ASCII string in PDF date syntax.

    Raises @core.PdfError::BadDate if any field is outside the representable PDF date ranges.

    pdf_string_of_drawop

    source
    fn pdf_string_of_drawop(op : PdfDrawOp) -> String

    Compatibility wrapper for PdfDrawOp::debug_name.

    pdf_string_of_drawops

    source
    fn pdf_string_of_drawops(ops : ArrayView[PdfDrawOp]) -> String

    Return cpdf's space-prefixed diagnostic string for a list of draw ops.

    pdf_string_of_font

    source
    fn pdf_string_of_font(font : PdfFont) -> String

    Compatibility wrapper for PdfFont::debug_name.

    pdf_string_of_function

    source
    fn pdf_string_of_function(function : PdfFunction) -> String

    Compatibility wrapper for PdfFunction::debug_string.

    pdf_string_of_int_array

    source
    fn pdf_string_of_int_array(values : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility alias for converting one integer byte array to PDF bytes.

    pdf_string_of_int_arrays

    source
    fn pdf_string_of_int_arrays(values : ArrayView[ArrayView[Int]]) -> Bytes raise 
    PdfError

    Compatibility alias for pdf_bytes_of_int_arrays.

    CamlPDF models many byte strings as integer lists; this helper preserves that shape for callers ported from OCaml.

    pdf_string_of_lexeme

    source
    fn pdf_string_of_lexeme(lexeme : PdfLexeme) -> String

    Return CamlPDF-style debug text for a single lexeme.

    Only numbers, strings, names, and null get value-specific rendering; other token kinds are rendered as GenLexNone.

    pdf_string_of_lexemes

    source
    fn pdf_string_of_lexemes(lexemes : ArrayView[PdfLexeme]) -> String

    Return CamlPDF-style debug text for a sequence of lexemes.

    Each lexeme is placed on its own line with a leading space.

    pdf_string_of_page_label

    source
    fn pdf_string_of_page_label(label : PdfPageLabel) -> Bytes

    Format a page-label range as a diagnostic byte string.

    pdf_string_of_pagespec

    source
    fn pdf_string_of_pagespec(document : PdfDocument, pages : ArrayView[Int]) -> String raise 
    PdfError

    pdf_string_of_pagespec_for_count

    source
    fn pdf_string_of_pagespec_for_count(end_page : Int, pages : ArrayView[Int]) -> String

    pdf_string_of_pdf

    source
    fn pdf_string_of_pdf(object : PdfObject) -> Bytes raise 
    PdfError

    Compatibility alias for pdf_write_object.

    pdf_string_of_pdf_including_data

    source
    fn pdf_string_of_pdf_including_data(object : PdfObject) -> Bytes raise 
    PdfError

    Compatibility alias for pdf_write_object.

    Stream data is included because PdfStreamObject serialization writes the stream dictionary, stream marker, bytes, and endstream marker.

    pdf_string_of_position

    source
    fn pdf_string_of_position(position : PdfPosition) -> String

    Return the cpdf debug spelling for a position keyword.

    pdf_string_of_standard_font

    source
    fn pdf_string_of_standard_font(font : PdfStandardFont) -> String

    Compatibility wrapper for PdfStandardFont::name.

    pdf_string_of_type

    source
    fn pdf_string_of_type(elements : ArrayView[PdfTypeElement]) -> Bytes

    Render a cpdftype element stream using CamlPDF's leading-newline format.

    pdf_string_of_type_element

    source
    fn pdf_string_of_type_element(element : PdfTypeElement) -> Bytes

    Render one cpdftype element using the CamlPDF debug spelling.

    pdf_table_of_encoding

    source
    fn pdf_table_of_encoding(encoding : PdfEncoding) -> Array[(Int, 
    PdfName    )]

    Compatibility wrapper for PdfEncoding::table.

    pdf_target_of_pagenumber

    source
    fn pdf_target_of_pagenumber(document : PdfDocument, page_number : Int) -> PdfDestination raise 
    PdfError

    Compatibility wrapper for PdfDocument::target_of_page_number.

    pdf_test_extract_text

    source
    fn pdf_test_extract_text(document : PdfDocument, page_numbers : ArrayView[Int]) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::test_extract_text.

    pdf_text_extractor_of_font

    source
    fn pdf_text_extractor_of_font(document : PdfDocument, font : PdfObject) -> PdfTextExtractor raise 
    PdfError

    Compatibility wrapper for PdfDocument::text_extractor_of_font.

    pdf_text_extractor_of_font_real

    source
    fn pdf_text_extractor_of_font_real(font : PdfFont) -> PdfTextExtractor

    Compatibility wrapper for PdfFont::text_extractor.

    pdf_texttopdf_of_utf8_with_newlines

    source
    fn pdf_texttopdf_of_utf8_with_newlines(fontpack : PdfFontPack, font_size : Double, text : BytesView) -> Array[PdfTypeElement] raise 
    PdfError

    Convert UTF-8 text into cpdftype instructions using a font pack.

    Newlines become PdfTypeNewLine, carriage returns are ignored, and representable Unicode codepoints are emitted as one-byte PDF charcodes.

    pdf_texttopdf_tag_paragraphs

    source
    fn pdf_texttopdf_tag_paragraphs(elements : ArrayView[PdfTypeElement]) -> Array[PdfTypeElement]

    Add paragraph tags around a cpdftype stream.

    This mirrors cpdftexttopdf.ml: a blank line closes the current paragraph, preserves both line breaks, and starts a new paragraph with tag number zero.

    pdf_texttopdf_typeset

    source
    fn pdf_texttopdf_typeset(fontpack : PdfFontPack, font_size : Double, paper : 
    PaperSize    , text : BytesView, process_struct_tree? : Bool, subformat? : PdfUASubformat?, title? : String?) -> PdfDocument raise 
    PdfError

    Typeset UTF-8 text into a standalone PDF document using an existing font pack.

    When process_struct_tree is set, paragraph tags are added and a /StructTreeRoot with page-level parent-tree entries is installed.

    pdf_thin_lines

    source
    fn pdf_thin_lines(document : PdfDocument, page_numbers : ArrayView[Int], width : Double) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::thin_lines.

    pdf_thin_lines_ops

    source
    fn pdf_thin_lines_ops(document : PdfDocument, resources : PdfObject, ops : ArrayView[PdfContentOp], width : Double) -> Array[PdfContentOp] raise 
    PdfError

    Rewrite line widths to honor the cpdf thin-lines threshold.

    Positive width is a minimum width. Negative width uses its absolute value as a maximum width, matching cpdftweak.ml.

    pdf_toc_add_bookmark

    source
    fn pdf_toc_add_bookmark(document : PdfDocument, title : BytesView) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_add_bookmark.

    pdf_toc_bookmark_text

    source
    fn pdf_toc_bookmark_text(title : BytesView) -> Bytes raise 
    PdfError

    Convert a TOC title to the PDFDocString stored in the generated bookmark.

    Literal \n byte pairs are converted to line-feed bytes before PDFDocString encoding, matching cpdftoc's real_newline helper.

    pdf_toc_insert_pages

    source
    fn pdf_toc_insert_pages(document : PdfDocument, toc_pages : ArrayView[PdfPage], labels : ArrayView[PdfPageLabel]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_insert_pages.

    pdf_toc_make_dots

    source
    fn pdf_toc_make_dots(space : Double, fontpack : PdfFontPack, font_size : Double) -> Array[PdfTypeElement] raise 
    PdfError

    Build cpdftoc's dot-leader run for an available horizontal space.

    pdf_toc_of_pdfdocencoding

    source
    fn pdf_toc_of_pdfdocencoding(fontpack : PdfFontPack, font_size : Double, text : BytesView) -> Array[PdfTypeElement] raise 
    PdfError

    Convert PDFDocEncoding/PDFDocString bytes into the font/text runs used by cpdftoc.

    pdf_toc_of_utf8

    source
    fn pdf_toc_of_utf8(fontpack : PdfFontPack, font_size : Double, text : BytesView) -> Array[PdfTypeElement] raise 
    PdfError

    Convert UTF-8 text into the font/text runs used by cpdftoc.

    Unrepresentable codepoints are skipped, matching cpdf's option_map(Cpdfembed.get_char fontpack) behavior. Unlike the text-to-PDF paragraph helper, this function treats input as a single run and does not interpret newline characters.

    pdf_toc_shift_page_labels

    source
    fn pdf_toc_shift_page_labels(toc_page_count : Int, labels : ArrayView[PdfPageLabel]) -> Array[PdfPageLabel]

    Shift existing page-label ranges after prepended TOC pages.

    cpdftoc writes a no-label range for the inserted TOC pages, then preserves existing labels by moving their start pages forward by the TOC page count.

    pdf_toc_shorten_text

    source
    fn pdf_toc_shorten_text(fontpack : PdfFontPack, font_size : Double, max_width : Double, runs : ArrayView[PdfTypeElement]) -> Array[PdfTypeElement] raise 
    PdfError

    Shorten the final text run to fit max_width, appending ... if shortened.

    This intentionally mirrors cpdf's narrow helper: only the final Font/Text pair is trimmed and measured.

    pdf_toc_split_title

    source
    fn pdf_toc_split_title(title : BytesView) -> Array[Bytes]

    Split a TOC title on the literal byte sequence \n.

    This mirrors cpdftoc.ml's split_toc_title, which splits before UTF-8 conversion and preserves leading, trailing, and adjacent empty title lines.

    pdf_toc_title_real_newlines

    source
    fn pdf_toc_title_real_newlines(title : BytesView) -> Bytes

    Replace literal \n byte pairs in a TOC title with real line-feed bytes.

    pdf_toc_type_elements

    source
    fn pdf_toc_type_elements(document : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, dotleader : Bool, process_struct_tree : Bool, labels : ArrayView[PdfPageLabel], bookmarks : ArrayView[PdfBookmark], page_width : Double, margin : Double) -> Array[PdfTypeElement] raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_type_elements.

    pdf_toc_typeset_pages

    source
    fn pdf_toc_typeset_pages(document : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, dotleader : Bool, process_struct_tree : Bool, labels : ArrayView[PdfPageLabel], bookmarks : ArrayView[PdfBookmark]) -> PdfTypeTypesetResult raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_typeset_pages.

    pdf_toc_used_codepoints

    source
    fn pdf_toc_used_codepoints(document : PdfDocument, labels : ArrayView[PdfPageLabel], title : BytesView, bookmarks : ArrayView[PdfBookmark]) -> Array[Int] raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_used_codepoints.

    pdf_toc_width_of_runs

    source
    fn pdf_toc_width_of_runs(runs : ArrayView[PdfTypeElement]) -> Double raise 
    PdfError

    Return the total width of cpdftoc's alternating Font/Text run list.

    pdf_toc_with_fontpack

    source
    fn pdf_toc_with_fontpack(document : PdfDocument, fontpack : PdfFontPack, font_size : Double, title : BytesView, bookmark? : Bool, dotleader? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_with_fontpack.

    pdf_toc_with_source

    source
    fn pdf_toc_with_source(document : PdfDocument, source : PdfTocFontSource, font_size : Double, title : BytesView, bookmark? : Bool, dotleader? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::toc_with_source.

    pdf_transform_annotations

    source

    Compatibility wrapper for PdfDocument::transform_annotations.

    pdf_transform_bookmark

    source

    Compatibility wrapper for PdfDocument::transform_bookmark.

    pdf_transform_destination

    source

    Applies a page transform matrix to destination coordinates.

    This is the standalone form of PdfDocument::transform_destination.

    pdf_trim_marks

    source
    fn pdf_trim_marks(document : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::trim_marks.

    pdf_trim_structure_tree

    source
    fn pdf_trim_structure_tree(document : PdfDocument, page_numbers : ArrayView[Int]) -> Unit raise 
    PdfError

    Compatibility wrapper for PdfDocument::trim_structure_tree.

    pdf_truetype_cmaps

    source
    fn pdf_truetype_cmaps(data : BytesView) -> Array[(Int, Int)]

    Return the TrueType cmap platform and encoding IDs.

    This ports Cpdftruetype.cmaps, which is used as a PDF/UA verification helper. The source function catches parse failures and returns the records collected before the failure; this function likewise ignores malformed or incomplete parts of the font after complete cmap records have been read.

    pdf_twoup

    source
    fn pdf_twoup(document : PdfDocument, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::twoup.

    pdf_twoup_stack

    source
    fn pdf_twoup_stack(document : PdfDocument, fast? : Bool, process_struct_tree? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::twoup_stack.

    pdf_type_font_widths

    source
    fn pdf_type_font_widths(font : PdfFont, font_size : Double) -> Array[Double] raise 
    PdfError

    Build a cpdftype-style width table for one-byte PDF text charcodes.

    Widths are returned in user units for the requested font size. This ports the standalone cpdftype.ml font_widths behavior for standard fonts and simple fonts with explicit metrics. CID fonts and simple fonts without metrics raise PdfError::FontWidthExpected.

    pdf_type_layout

    source
    fn pdf_type_layout(lmargin : Double, rmargin : Double, paper : 
    PaperSize    , elements : ArrayView[PdfTypeElement]) -> Array[PdfTypeElement] raise 
    PdfError

    Lay out cpdftype elements into wrapped lines for the requested paper width.

    The rmargin parameter is accepted for parity with CamlPDF but intentionally ignored: the source computes the maximum x position as page_width - lmargin.

    pdf_type_paginate

    source
    fn pdf_type_paginate(tmargin : Double, bmargin : Double, paper : 
    PaperSize    , elements : ArrayView[PdfTypeElement]) -> Array[PdfTypeElement]

    Insert page breaks into a laid-out cpdftype stream.

    Active structure tags are closed before an inserted PdfTypeNewPage and reopened immediately after it, matching CamlPDF's pagination helper.

    pdf_type_split_text

    source
    fn pdf_type_split_text(space_left : Double, widths : ArrayView[Double], text : BytesView) -> (Bytes, Bool, Bytes) raise 
    PdfError

    Split one byte-encoded text run so at least one word is emitted.

    This follows CamlPDF's cpdftype.ml behavior: words are split only on ASCII space, the first word is kept even when it exceeds space_left, and a space separator is retained after every non-final word in the emitted prefix.

    pdf_type_typeset

    source
    fn pdf_type_typeset(document : PdfDocument, process_struct_tree : Bool, lmargin : Double, rmargin : Double, tmargin : Double, bmargin : Double, paper : 
    PaperSize    , elements : ArrayView[PdfTypeElement]) -> PdfTypeTypesetResult raise 
    PdfError

    Compatibility wrapper for PdfDocument::pdf_type_typeset.

    pdf_type_width_of_bytes

    source
    fn pdf_type_width_of_bytes(widths : ArrayView[Double], text : BytesView) -> Double raise 
    PdfError

    Sum a cpdftype width table for byte-encoded text.

    Each input byte is used directly as a charcode index. A width table shorter than the largest charcode raises PdfError::FontWidthExpected.

    pdf_ua_create_pdfua1

    source
    fn pdf_ua_create_pdfua1(title : String, paper : 
    PaperSize    , page_count : Int) -> PdfDocument raise 
    PdfError

    Create a blank PDF/UA-1 document with the given title and page size.

    pdf_ua_create_pdfua2

    source
    fn pdf_ua_create_pdfua2(title : String, paper : 
    PaperSize    , page_count : Int) -> PdfDocument raise 
    PdfError

    Create a blank PDF/UA-2 document with the given title and page size.

    pdf_ua_extract_struct_tree

    source
    fn pdf_ua_extract_struct_tree(document : PdfDocument) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::extract_struct_tree.

    pdf_ua_extract_struct_tree_json_blob

    source
    fn pdf_ua_extract_struct_tree_json_blob(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::struct_tree_json_blob.

    pdf_ua_mark

    source

    Compatibility wrapper for PdfDocument::mark_pdfua1.

    pdf_ua_mark2

    source
    fn pdf_ua_mark2(year : Int, document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::mark_pdfua2.

    pdf_ua_print_struct_tree

    source
    fn pdf_ua_print_struct_tree(document : PdfDocument) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::struct_tree_text.

    pdf_ua_remove_mark

    source
    fn pdf_ua_remove_mark(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::remove_pdfua_mark.

    pdf_ua_replace_struct_tree

    source
    fn pdf_ua_replace_struct_tree(document : PdfDocument, json : Json) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::replace_struct_tree.

    pdf_ua_subformat_of_string

    source
    fn pdf_ua_subformat_of_string(text : String) -> PdfUASubformat raise 
    PdfError

    Parse CamlPDF's PDF/UA subformat spelling.

    pdf_ua_test_matterhorn_json

    source
    fn pdf_ua_test_matterhorn_json(document : PdfDocument, test_name : String) -> Json raise 
    PdfError

    Compatibility wrapper for PdfDocument::test_matterhorn_json.

    pdf_ua_test_matterhorn_print

    source
    fn pdf_ua_test_matterhorn_print(document : PdfDocument, test_name : String) -> Bytes raise 
    PdfError

    Compatibility wrapper for PdfDocument::test_matterhorn_text.

    pdf_unicode_data

    source

    Return cpdf's parsed UnicodeData table, decoded and parsed on demand.

    pdf_unicode_data_source

    source
    fn pdf_unicode_data_source() -> Bytes raise 
    PdfError

    Return cpdf's compressed UnicodeData source bytes.

    pdf_upright_pages

    source
    fn pdf_upright_pages(document : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::upright_pages.

    pdf_utf16be_of_codepoints

    source
    fn pdf_utf16be_of_codepoints(codepoints : ArrayView[Int]) -> Bytes raise 
    PdfError

    Encode Unicode scalar values as a PDF UTF-16BE string with BOM.

    Invalid scalar values, including surrogate codepoints, raise PdfError::InvalidUnicodeCodepoint.

    pdf_utf8_of_codepoints

    source
    fn pdf_utf8_of_codepoints(codepoints : ArrayView[Int]) -> Bytes raise 
    PdfError

    Encode Unicode scalar values as UTF-8 bytes.

    Invalid scalar values, including surrogate codepoints, raise PdfError::InvalidUnicodeCodepoint.

    pdf_utf8_of_pdfdocstring

    source
    fn pdf_utf8_of_pdfdocstring(bytes : BytesView) -> Bytes raise 
    PdfError

    Convert a PDF string byte sequence to UTF-8 bytes.

    pdf_vflip_pdf

    source
    fn pdf_vflip_pdf(document : PdfDocument, page_numbers : ArrayView[Int], fast? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::flip_pages_vertically.

    pdf_write_colour_space

    source
    fn pdf_write_colour_space(document : PdfDocument, space : PdfColourSpace) -> PdfObject

    Compatibility wrapper for PdfDocument::write_colour_space.

    pdf_write_document

    source
    fn pdf_write_document(document : PdfDocument) -> Bytes raise 
    PdfError

    Serialize a complete document with a classic xref table.

    pdf_write_document_incremental_update

    source
    fn pdf_write_document_incremental_update(original : Bytes, document : PdfDocument) -> Bytes raise 
    PdfError

    Append a classic incremental update to original PDF bytes.

    Only objects marked as changed in document are written. The previous startxref position is read from original and emitted as /Prev.

    pdf_write_document_incremental_update_with_compressed_xref_stream

    source
    fn pdf_write_document_incremental_update_with_compressed_xref_stream(original : Bytes, document : PdfDocument) -> Bytes raise 
    PdfError

    Append an incremental update using a Flate-compressed xref stream.

    pdf_write_document_incremental_update_with_generated_id

    source
    fn pdf_write_document_incremental_update_with_generated_id(original : Bytes, document : PdfDocument, path : String, mode? : PdfWriteMode) -> Bytes raise 
    PdfError

    Append an incremental update after generating a current trailer ID.

    The generated ID is based on path and current document state and is applied to a copy of the document before writing.

    pdf_write_document_incremental_update_with_mode

    source
    fn pdf_write_document_incremental_update_with_mode(original : Bytes, document : PdfDocument, mode : PdfWriteMode) -> Bytes raise 
    PdfError

    Append an incremental update using the selected xref representation.

    pdf_write_document_incremental_update_with_xref_stream

    source
    fn pdf_write_document_incremental_update_with_xref_stream(original : Bytes, document : PdfDocument) -> Bytes raise 
    PdfError

    Append an incremental update using an uncompressed xref stream.

    pdf_write_document_options

    source
    fn pdf_write_document_options(document : PdfDocument, encryption? : PdfWriteEncryption?, update_from? : Bytes?, make_id? : Bool, id_path? : String, mode? : PdfWriteMode, file_id? : BytesView, aes_iv_provider? : (Int, Int, Int) -> Bytes raise 
    PdfError    ?, aesv3_random_provider? : (
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    ?) -> Bytes raise 
    PdfError

    One-call writer with optional encryption, IDs, incremental update, and mode.

    The input document is copied before IDs or encryption are applied. update_from selects incremental output. make_id controls generated trailer IDs for unencrypted writes; encrypted writes always use the provided file_id or generate one through the encryption helper. AES modes require the corresponding IV and random providers.

    pdf_write_document_with_compressed_xref_stream

    source
    fn pdf_write_document_with_compressed_xref_stream(document : PdfDocument) -> Bytes raise 
    PdfError

    Serialize a complete document with a Flate-compressed xref stream.

    pdf_write_document_with_generated_id

    source
    fn pdf_write_document_with_generated_id(document : PdfDocument, path : String, mode? : PdfWriteMode) -> Bytes raise 
    PdfError

    Serialize a complete document after generating a current trailer ID.

    The source document is copied before its ID is generated.

    pdf_write_document_with_mode

    source
    fn pdf_write_document_with_mode(document : PdfDocument, mode : PdfWriteMode) -> Bytes raise 
    PdfError

    Serialize a complete document using the selected xref representation.

    pdf_write_document_with_xref_stream

    source
    fn pdf_write_document_with_xref_stream(document : PdfDocument) -> Bytes raise 
    PdfError

    Serialize a complete document with an uncompressed xref stream.

    The output header is at least PDF 1.5, because xref streams require that version.

    pdf_write_encrypted_128bit_document

    source
    fn pdf_write_encrypted_128bit_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with 128-bit ARC4 revision 3 and serialize in the selected mode.

    pdf_write_encrypted_128bit_r4_document

    source
    fn pdf_write_encrypted_128bit_r4_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with revision-4 ARC4 crypt filters and serialize.

    encrypt_metadata=false follows the PDF revision-4 no-metadata behavior.

    pdf_write_encrypted_40bit_document

    source
    fn pdf_write_encrypted_40bit_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with 40-bit ARC4 and serialize in the selected write mode.

    pdf_write_encrypted_aesv2_document

    source
    fn pdf_write_encrypted_aesv2_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt and serialize a document with AESV2 using native randomness.

    The encrypted document is written with the requested write mode. Supplying a file_id controls the trailer ID used for key derivation; IVs remain random.

    pdf_write_encrypted_aesv2_document_with_iv_provider

    source
    fn pdf_write_encrypted_aesv2_document_with_iv_provider(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with AESV2 and serialize.

    iv_provider supplies IVs by object number, generation, and per-object index. This allows deterministic fixtures or secure caller-provided IVs.

    pdf_write_encrypted_aesv3_document

    source
    fn pdf_write_encrypted_aesv3_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], iso? : Bool, encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt and serialize a document with AESV3/AES-256 using native randomness.

    Set iso=true for the ISO/PDF 2.0 hash variant. The requested write mode is applied after encryption.

    pdf_write_encrypted_aesv3_document_with_providers

    source
    fn pdf_write_encrypted_aesv3_document_with_providers(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], random_provider : (
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    , iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , iso? : Bool, encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with AESV3/AES-256 and serialize.

    random_provider supplies file keys, salts, and permissions padding; iv_provider supplies object-data IVs. iso=true selects the ISO/PDF 2.0 AESV3 hash variant.

    pdf_write_encrypted_aesv3_iso_document

    source
    fn pdf_write_encrypted_aesv3_iso_document(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt and serialize a document with the ISO AESV3/AES-256 variant.

    pdf_write_encrypted_aesv3_iso_document_with_providers

    source
    fn pdf_write_encrypted_aesv3_iso_document_with_providers(document : PdfDocument, user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ], random_provider : (
    PdfAesV3RandomField    , Int) -> Bytes raise 
    PdfError    , iv_provider : (Int, Int, Int) -> Bytes raise 
    PdfError    , encrypt_metadata? : Bool, mode? : PdfWriteMode, file_id? : BytesView) -> Bytes raise 
    PdfError

    Encrypt with the ISO AESV3/AES-256 variant and serialize.

    pdf_write_encryption

    source
    fn pdf_write_encryption(encryption_method : 
    PdfEncryptionMethod    , user_password : BytesView, owner_password : BytesView, denied_permissions : ArrayView[
    PdfPermission    ]) -> PdfWriteEncryption

    Build owned encryption options for the writer options API.

    pdf_write_font

    source
    fn pdf_write_font(document : PdfDocument, font : PdfFont, objnum? : Int?) -> Int raise 
    PdfError

    Compatibility wrapper for PdfDocument::write_font.

    pdf_write_hex_string

    source
    fn pdf_write_hex_string(bytes : BytesView) -> Bytes

    Serialize bytes as a lowercase hexadecimal PDF string.

    pdf_write_indirect_object

    source
    fn pdf_write_indirect_object(object : PdfParsedIndirectObject) -> Bytes raise 
    PdfError

    Serialize one indirect object including obj and endobj wrappers.

    pdf_write_literal_string

    source
    fn pdf_write_literal_string(bytes : BytesView) -> Bytes

    Serialize bytes as a PDF literal string.

    Delimiters, backslashes, common controls, and non-printable bytes are escaped according to PDF literal-string syntax.

    pdf_write_name

    source
    fn pdf_write_name(name : 
    PdfName    ) -> Bytes

    Serialize a PDF name object with required delimiter and hex escaping.

    The returned bytes include the leading slash.

    pdf_write_object

    source
    fn pdf_write_object(object : PdfObject) -> Bytes raise 
    PdfError

    Serialize a direct PDF object.

    Stream lengths are refreshed from the current stream data while writing.

    pdf_write_ocg

    source
    fn pdf_write_ocg(document : PdfDocument, optional_content : PdfOptionalContent) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::write_optional_content_groups.

    pdf_write_page_labels

    source
    fn pdf_write_page_labels(document : PdfDocument, labels : ArrayView[PdfPageLabel]) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::write_page_labels.

    pdf_write_real

    source
    fn pdf_write_real(value : Double) -> Bytes raise 
    PdfError

    Format a PDF real number as bytes.

    Scientific notation is expanded to PDF-compatible decimal form where possible. Non-finite or unparsable numeric text raises PdfError.

    point2

    source
    fn point2(x : Double, y : Double) -> 
    Point2

    Creates a two-dimensional point.

    recompress_pdf

    source
    fn recompress_pdf(document : PdfDocument) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::recompress.

    squeeze

    source
    fn squeeze(document : PdfDocument, page_data? : Bool) -> PdfDocument raise 
    PdfError

    Compatibility wrapper for PdfDocument::squeeze.

    stream_to_get

    source
    fn stream_to_get(input : ByteCursor, position : Int, length : Int) -> ToGet

    Construct a deferred stream-data descriptor without encryption.

    The returned value references input and reads length bytes starting at position when materialized.

    transform_append

    source

    Concatenates two transform operation lists.

    The after operations are placed before the before operations to preserve the same ordering used by CamlPDF transform lists.

    transform_apply

    source

    Compatibility alias for applying a transform operation list to a point.

    transform_apply_matrix

    source

    Applies a matrix to a point.

    transform_apply_ops

    source

    Applies a transform operation list to a point.

    transform_compose_op

    source

    Adds one operation to the front of an operation list, merging with the first operation when the two adjacent operations are compatible.

    Compatible adjacent translations, scales about the same origin, rotations about the same origin, and shears about the same origin are combined to keep operation lists compact.

    transform_decompose

    source

    Decomposes a matrix into scale, aspect, rotation, shear, and translation.

    transform_identity

    source

    Returns an empty transform operation list, representing identity.

    transform_identity_matrix

    source

    The identity affine transform matrix.

    transform_matrix_compose

    source

    Composes two matrices so before is applied first and after second.

    transform_matrix_invert

    source

    Returns the inverse of a matrix.

    Raises PdfError::MatrixNotInvertable when the matrix cannot be inverted.

    transform_matrix_of_op

    source

    Lowers one high-level transform operation to a matrix.

    transform_matrix_of_ops

    source

    Lowers an operation list to one composed matrix.

    transform_matrix_of_transform

    source

    Compatibility alias for lowering a transform operation list to a matrix.

    transform_recompose

    source

    Recomposes a matrix from decomposed transform components.

    transform_recompose_components

    source
    fn transform_recompose_components(scale : Double, aspect : Double, rotation : Double, shear : Double, translate_x : Double, translate_y : Double) -> 
    TransformMatrix

    Recomposes a matrix from individual decomposition fields.

    transform_rotate

    source

    Creates a rotation matrix around origin.

    angle is measured in radians.

    transform_scale

    source

    Creates a scale matrix around origin.

    transform_shear_x

    source

    Creates an X-shear matrix around origin.

    transform_shear_y

    source

    Creates a Y-shear matrix around origin.

    transform_string_of_matrix

    source
    fn transform_string_of_matrix(matrix : 
    TransformMatrix    ) -> String

    Formats a matrix as its six comma-separated operands.

    transform_string_of_op

    source
    fn transform_string_of_op(op : 
    TransformOp    ) -> String

    Formats one transform operation in CamlPDF-compatible debug text.

    transform_string_of_ops

    source
    fn transform_string_of_ops(ops : ArrayView[
    TransformOp    ]) -> String

    Formats a transform operation list in display order.

    CamlPDF prints the most recently composed operation first, so this walks the input list in reverse.

    transform_string_of_transform

    source
    fn transform_string_of_transform(ops : ArrayView[
    TransformOp    ]) -> String

    Compatibility alias for formatting a transform operation list.

    transform_translate

    source
    fn transform_translate(tx : Double, ty : Double) -> 
    TransformMatrix

    Creates a translation matrix.

    unit_centimetres

    source
    fn unit_centimetres(value : Double, unit : 
    PdfUnit    ) -> Double

    Converts a value from unit to centimetres.

    The PdfPoint path preserves CamlPDF's historical conversion constant for compatibility with existing output.

    unit_inches

    source
    fn unit_inches(value : Double, unit : 
    PdfUnit    ) -> Double

    Converts a value from unit to inches.

    unit_millimetres

    source
    fn unit_millimetres(value : Double, unit : 
    PdfUnit    ) -> Double

    Converts a value from unit to millimetres.

    unit_points

    source
    fn unit_points(value : Double, unit : 
    PdfUnit    ) -> Double

    Converts a value from unit to PDF points.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io