@cj-tech-master/excelts 8.0.0 → 8.1.0

package/dist/types/modules/archive/zip/stream.d.ts

@@ -60,6 +60,8 @@ export declare class ZipDeflateFile {
     private _dataQueue;
     private _finalQueued;
     private _pushChain;
+    private _inputBuf;
+    private _inputPos;
     private _syncDeflater;
     private _syncZlibReady;
     readonly name: string;
@@ -159,6 +161,8 @@ export declare class ZipDeflateFile {
      * memory growth when callers push data in a tight synchronous loop.
      */
     push(data: Uint8Array, final?: boolean, callback?: (err?: Error | null) => void): Promise<void>;
+    /** Enqueue an async push through the _pushChain serialization. */
+    private _pushAsync;
     /**
      * Synchronous push path — compresses and emits data without any Promises.
      *

package/dist/types/modules/pdf/core/crypto.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared cryptographic primitives for PDF encryption/decryption.
+ *
+ * Zero-dependency, pure JavaScript implementations of:
+ * - AES (128/256-bit) CBC encrypt and decrypt
+ * - SHA-256
+ * - MD5
+ * - RC4 (for reading legacy PDFs only)
+ *
+ * @see FIPS 197 — AES
+ * @see FIPS 180-4 — SHA-256
+ * @see RFC 1321 — MD5
+ */
+/**
+ * AES-CBC encryption with PKCS#7 padding.
+ * Supports AES-128 (16-byte key) and AES-256 (32-byte key).
+ */
+export declare function aesCbcEncrypt(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * AES-CBC decryption with PKCS#7 padding removal.
+ * Supports AES-128 (16-byte key) and AES-256 (32-byte key).
+ */
+export declare function aesCbcDecrypt(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * AES-CBC decryption WITHOUT PKCS#7 padding removal.
+ * Used for key derivation in V=5 where the output length is known.
+ */
+export declare function aesCbcDecryptRaw(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * AES-CBC encryption WITHOUT PKCS#7 padding.
+ * Used when the plaintext is already block-aligned (e.g., encrypting
+ * the 32-byte file encryption key in V=5).
+ *
+ * @throws if plaintext length is not a multiple of 16.
+ */
+export declare function aesCbcEncryptRaw(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
+/**
+ * AES-ECB encryption of a single 16-byte block (no padding, no IV).
+ * Used for the /Perms value in V=5 encryption.
+ */
+export declare function aesEcbEncrypt(block: Uint8Array, key: Uint8Array): Uint8Array;
+/**
+ * SHA-256 hash function.
+ * @returns 32-byte digest
+ */
+export declare function sha256(input: Uint8Array): Uint8Array;
+/**
+ * MD5 hash function (RFC 1321).
+ * @returns 16-byte digest
+ */
+export declare function md5(input: Uint8Array): Uint8Array;
+/**
+ * RC4 stream cipher.
+ * @deprecated Only used for reading legacy encrypted PDFs. Writer uses AES-256.
+ */
+export declare function rc4(key: Uint8Array, data: Uint8Array): Uint8Array;
+/**
+ * Generate pseudo-random bytes.
+ * Uses Math.random — adequate for PDF IVs but not cryptographically secure.
+ */
+export declare function randomBytes(length: number): Uint8Array;
+/**
+ * Concatenate multiple Uint8Arrays.
+ */
+export declare function concatArrays(...arrays: Uint8Array[]): Uint8Array;

package/dist/types/modules/pdf/core/encryption.d.ts

@@ -1,13 +1,17 @@
 /**
- * PDF encryption support (Standard Security Handler, Revision 3).
+ * PDF encryption support (Standard Security Handler, V=5, R=5).
  *
- * Implements RC4-128 encryption compatible with PDF 1.4.
+ * Implements AES-256 encryption compatible with PDF 2.0 (ISO 32000-2:2020).
  * Supports:
  * - User password (required to open the document)
  * - Owner password (grants full access)
  * - Permission flags (print, copy, modify, etc.)
  *
- * @see PDF Reference 1.7, §3.5 - Encryption
+ * The file encryption key (FEK) is a random 256-bit key.
+ * All streams and strings are encrypted using AES-256-CBC with a random
+ * 16-byte IV prepended to each encrypted value.
+ *
+ * @see ISO 32000-2:2020, §7.6 — Encryption
  */
 /**
  * PDF encryption options.
@@ -43,35 +47,34 @@ export interface PdfPermissions {
     printHighQuality: boolean;
 }
 /**
- * Encryption state used during PDF generation.
+ * Encryption state used during PDF generation (V=5, R=5, AES-256).
  */
 export interface EncryptionState {
-    /** Encryption key (variable length, up to 16 bytes) */
+    /** 32-byte file encryption key */
     encryptionKey: Uint8Array;
-    /** O value (32 bytes) for the Encrypt dictionary */
+    /** 48-byte O value: hash(32) + validation salt(8) + key salt(8) */
     oValue: Uint8Array;
-    /** U value (32 bytes) for the Encrypt dictionary */
+    /** 48-byte U value: hash(32) + validation salt(8) + key salt(8) */
     uValue: Uint8Array;
+    /** 32-byte encrypted owner key (OE) */
+    oeValue: Uint8Array;
+    /** 32-byte encrypted user key (UE) */
+    ueValue: Uint8Array;
+    /** 16-byte encrypted permissions (Perms) */
+    permsValue: Uint8Array;
     /** Permissions integer (P value) */
     permissions: number;
     /** File identifier (16 bytes) */
     fileId: Uint8Array;
 }
 /**
- * Initialize encryption state from the given options.
+ * Initialize encryption state for AES-256 (V=5, R=5).
  */
 export declare function initEncryption(options: PdfEncryptionOptions): EncryptionState;
 /**
- * Encrypt a string or stream for a specific PDF object.
- * Per-object encryption key = MD5(encryptionKey + objectNumber + generation).
- */
-export declare function encryptData(data: Uint8Array, objectNumber: number, generation: number, encryptionKey: Uint8Array): Uint8Array;
-/**
- * RC4 stream cipher implementation.
- */
-export declare function rc4(key: Uint8Array, data: Uint8Array): Uint8Array;
-/**
- * MD5 hash implementation (RFC 1321).
- * Returns 16-byte digest.
+ * Encrypt data for a PDF object using AES-256-CBC.
+ *
+ * For V=5/R=5, the file encryption key is used directly (no per-object key derivation).
+ * A random 16-byte IV is prepended to the ciphertext.
  */
-export declare function md5(input: Uint8Array): Uint8Array;
+export declare function encryptData(data: Uint8Array, _objectNumber: number, _generation: number, encryptionKey: Uint8Array): Uint8Array;

package/dist/types/modules/pdf/core/pdf-writer.d.ts

@@ -1,20 +1,22 @@
 /**
  * PDF file writer.
  *
- * Assembles a complete PDF document from indirect objects.
+ * Assembles a complete PDF 2.0 document from indirect objects.
  * Handles the four sections of a PDF file:
- * 1. Header (%PDF-1.4)
+ * 1. Header (%PDF-2.0)
  * 2. Body (indirect objects)
  * 3. Cross-reference table
  * 4. Trailer (with document catalog reference)
  *
- * @see PDF Reference 1.7, Chapter 3.4 - File Structure
+ * Encryption uses AES-256 (V=5, R=5) per ISO 32000-2:2020.
+ *
+ * @see ISO 32000-2:2020, Chapter 7.5 — File Structure
  */
 import { PdfDict } from "./pdf-object.js";
 import type { PdfContentStream } from "./pdf-stream.js";
 import type { EncryptionState } from "./encryption.js";
 /**
- * Constructs a valid PDF 1.4 file from a set of indirect objects.
+ * Constructs a valid PDF 2.0 file from a set of indirect objects.
  *
  * Usage:
  * 1. Allocate object numbers with allocObject()

package/dist/types/modules/pdf/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * PDF module for excelts.
  *
- * A full-featured, zero-dependency PDF engine.
+ * A full-featured, zero-dependency PDF engine for both writing and reading.
  *
- * @example Standalone:
+ * @example Standalone PDF generation:
  * ```typescript
  * import { pdf } from "excelts/pdf";
  *
@@ -25,13 +25,34 @@
  * const bytes = excelToPdf(workbook);
  * ```
  *
+ * @example Read PDF — extract text, images, and metadata:
+ * ```typescript
+ * import { readPdf } from "excelts/pdf";
+ *
+ * const result = readPdf(pdfBytes);
+ * console.log(result.text);               // All text
+ * console.log(result.pages[0].text);      // Page 1 text
+ * console.log(result.pages[0].images);    // Page 1 images
+ * console.log(result.pages[0].annotations); // Page 1 annotations
+ * console.log(result.metadata.title);     // Document title
+ * console.log(result.formFields);         // Form fields
+ * ```
+ *
  * @module pdf
  */
 /** Standalone PDF generation — accepts plain arrays, sheet objects, or workbooks. */
 export { pdf } from "./pdf.js";
 /** Excel-to-PDF conversion — accepts an Excel Workbook instance. */
 export { excelToPdf } from "./excel-bridge.js";
+/** Read a PDF file and extract text, images, and metadata. */
+export { readPdf } from "./reader/pdf-reader.js";
 export type { PdfCell, PdfRow, PdfColumn, PdfSheet, PdfBook, PdfImage } from "./pdf.js";
 export type { PdfExportOptions, PdfOrientation, PdfPageSize, PdfMargins, PdfColor, PageSizeName } from "./types.js";
 export { PageSizes } from "./types.js";
+export type { ReadPdfOptions, ReadPdfResult, ReadPdfPage } from "./reader/pdf-reader.js";
+export type { PdfMetadata } from "./reader/metadata-reader.js";
+export type { ExtractedImage } from "./reader/image-extractor.js";
+export type { TextLine } from "./reader/text-reconstruction.js";
+export type { PdfAnnotation, PdfRect } from "./reader/annotation-extractor.js";
+export type { PdfFormField, PdfFormFieldType } from "./reader/form-extractor.js";
 export { PdfError, PdfRenderError, PdfFontError, PdfStructureError, isPdfError } from "./errors.js";

package/dist/types/modules/pdf/reader/annotation-extractor.d.ts

@@ -0,0 +1,63 @@
+/**
+ * PDF annotation extractor.
+ *
+ * Extracts annotations from a PDF page's `/Annots` array.
+ * Supports all standard annotation subtypes defined in PDF Reference 1.7, §12.5.
+ *
+ * Common annotation types:
+ * - **Link** — Hyperlinks (URI, GoTo, GoToR)
+ * - **Text** — Sticky notes / comments
+ * - **FreeText** — Inline text annotations
+ * - **Highlight / Underline / StrikeOut / Squiggly** — Text markup
+ * - **Stamp** — Rubber stamp annotations
+ * - **Popup** — Associated popup windows
+ * - **Widget** — Form field widgets (handled separately by form-extractor)
+ *
+ * @see PDF Reference 1.7, §12.5 - Annotations
+ */
+import type { PdfDocument } from "./pdf-document.js";
+import type { PdfDictValue } from "./pdf-parser.js";
+/** Rectangle in PDF coordinate space [x1, y1, x2, y2] */
+export interface PdfRect {
+    /** Left edge (x1) */
+    x1: number;
+    /** Bottom edge (y1) */
+    y1: number;
+    /** Right edge (x2) */
+    x2: number;
+    /** Top edge (y2) */
+    y2: number;
+}
+/** A PDF annotation extracted from a page. */
+export interface PdfAnnotation {
+    /** Annotation subtype (e.g. "Link", "Text", "Highlight", "FreeText", "Stamp") */
+    subtype: string;
+    /** Bounding rectangle in page coordinates (points) */
+    rect: PdfRect;
+    /** Text content (/Contents entry) */
+    contents: string;
+    /** Author / title (/T entry) */
+    author: string;
+    /** Subject (/Subj entry) */
+    subject: string;
+    /** Modification date (/M entry) — raw PDF date string */
+    modifiedDate: string;
+    /** For Link annotations: the destination URI */
+    uri: string;
+    /** For Link annotations: named destination */
+    destination: string;
+    /** Annotation flags (/F entry) */
+    flags: number;
+    /** Color (/C entry) — array of 0-3 values in [0,1] */
+    color: number[];
+}
+/**
+ * Extract annotations from a PDF page.
+ *
+ * Skips Widget annotations (form fields) — those are handled by the form extractor.
+ *
+ * @param pageDict - The page dictionary
+ * @param doc - The PDF document for resolving references
+ * @returns Array of extracted annotations
+ */
+export declare function extractAnnotationsFromPage(pageDict: PdfDictValue, doc: PdfDocument): PdfAnnotation[];

package/dist/types/modules/pdf/reader/cmap-parser.d.ts

@@ -0,0 +1,70 @@
+/**
+ * CMap parser for PDF text extraction.
+ *
+ * Parses /ToUnicode CMap programs to build character code → Unicode mappings.
+ * This is essential for extracting text from PDFs that use CIDFonts or
+ * custom encodings.
+ *
+ * Supports:
+ * - beginbfchar / endbfchar (single character mappings)
+ * - beginbfrange / endbfrange (range mappings, including array form)
+ * - begincodespacerange / endcodespacerange
+ * - Multi-byte character codes (1-4 bytes)
+ * - UTF-16BE encoded target strings (including surrogate pairs)
+ *
+ * @see PDF Reference 1.7, §5.9 - ToUnicode CMaps
+ * @see Adobe Technical Note #5411 - CMap Resources
+ */
+/**
+ * A parsed CMap that maps character codes to Unicode strings.
+ */
+export declare class CMap {
+    private codeSpaceRanges;
+    private bfChars;
+    private bfRanges;
+    /** Number of bytes per character code (detected from codespace ranges) */
+    bytesPerCode: number;
+    constructor();
+    /**
+     * Look up the Unicode string for a character code.
+     * Uses binary search over sorted bfRanges for efficient lookup.
+     */
+    lookup(code: number): string | undefined;
+    /**
+     * Add a code space range.
+     */
+    addCodeSpaceRange(low: number, high: number, bytes: number): void;
+    /**
+     * Add a bfchar mapping.
+     */
+    addBfChar(code: number, unicode: string): void;
+    /**
+     * Add a bfrange mapping.
+     */
+    addBfRange(low: number, high: number, mapping: string | string[]): void;
+    /**
+     * Sort bfRanges by low value for binary search.
+     * Should be called after all ranges have been added.
+     */
+    sortRanges(): void;
+    /**
+     * Determine the code length (in bytes) for a given first byte,
+     * using the codespace ranges. When multiple ranges match (e.g. a 1-byte
+     * range covering 0x00-0xFF and a 2-byte range whose first byte overlaps),
+     * returns the longest match per the PDF spec's greedy matching rule.
+     * Falls back to bytesPerCode if no range matches.
+     */
+    getCodeLength(firstByte: number): number;
+    /**
+     * Check if this CMap has any mappings.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if this CMap has codespace ranges defined.
+     */
+    get hasCodeSpaceRanges(): boolean;
+}
+/**
+ * Parse a CMap program (typically from a /ToUnicode stream).
+ */
+export declare function parseCMap(data: Uint8Array): CMap;

package/dist/types/modules/pdf/reader/content-interpreter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * PDF content stream interpreter for text extraction.
+ *
+ * Implements a full PDF graphics state machine that processes content stream
+ * operators to extract positioned text fragments. These fragments are then
+ * assembled into readable text by the text reconstruction module.
+ *
+ * Supported operator categories:
+ * - Text state: Tf, Tc, Tw, Tz, TL, Ts, Tr
+ * - Text positioning: Td, TD, Tm, T*
+ * - Text showing: Tj, TJ, ', "
+ * - Text objects: BT, ET
+ * - Graphics state: q, Q, cm, gs, i, M, ri, W, W*
+ * - Color: CS, cs, SC, sc, SCN, scn
+ * - Marked content: BDC, BMC, EMC, MP, DP
+ * - Type3 glyph: d0, d1
+ * - Shading: sh
+ * - Inline images: BI/ID/EI
+ * - XObject invocation: Do (for form XObjects containing text)
+ *
+ * @see PDF Reference 1.7, Chapter 5 - Text
+ * @see PDF Reference 1.7, Chapter 4 - Graphics
+ */
+import type { PdfDocument } from "./pdf-document.js";
+import type { PdfDictValue } from "./pdf-parser.js";
+/**
+ * A text fragment extracted from a PDF page.
+ * Contains the text string and its position in page coordinates.
+ */
+export interface TextFragment {
+    /** The extracted text */
+    text: string;
+    /** X position in page coordinates (points, origin = bottom-left) */
+    x: number;
+    /** Y position in page coordinates */
+    y: number;
+    /** Font size in points */
+    fontSize: number;
+    /** Font name */
+    fontName: string;
+    /** Width of the text in points */
+    width: number;
+    /** Character spacing */
+    charSpacing: number;
+    /** Word spacing */
+    wordSpacing: number;
+    /** Horizontal scaling factor (100 = normal) */
+    horizontalScaling: number;
+    /** Whether the text is vertical (WMode=1) */
+    isVertical: boolean;
+    /** Whether the text is right-to-left (Arabic, Hebrew, etc.) */
+    isRtl: boolean;
+}
+/**
+ * Extract text fragments from a page's content stream(s).
+ */
+export declare function extractTextFromPage(pageDict: PdfDictValue, doc: PdfDocument): TextFragment[];

package/dist/types/modules/pdf/reader/font-decoder.d.ts

@@ -0,0 +1,58 @@
+/**
+ * PDF font decoder for text extraction.
+ *
+ * Handles the mapping from character codes in content streams to Unicode
+ * strings. Supports all major PDF font types:
+ *
+ * - Type 1 fonts (standard 14 + custom with /Encoding)
+ * - TrueType fonts (with /Encoding and /ToUnicode)
+ * - Type 0 (CID) composite fonts (with /ToUnicode CMap)
+ * - Type 3 fonts (with /Encoding and /ToUnicode)
+ *
+ * @see PDF Reference 1.7, Chapter 5 - Text
+ * @see PDF Reference 1.7, §5.5 - Character Encoding
+ */
+import type { CMap } from "./cmap-parser.js";
+import type { PdfDocument } from "./pdf-document.js";
+import type { PdfDictValue } from "./pdf-parser.js";
+/**
+ * A resolved font used for text extraction.
+ */
+export interface ResolvedFont {
+    /** Font name */
+    name: string;
+    /** Font subtype: Type1, TrueType, Type0, Type3, CIDFontType0, CIDFontType2, MMType1 */
+    subtype: string;
+    /** ToUnicode CMap (if available) */
+    toUnicode: CMap | null;
+    /** Encoding lookup: char code → unicode string */
+    encoding: Map<number, string>;
+    /** Number of bytes per character code (1 for simple fonts, 1-2 for CID fonts) */
+    bytesPerCode: number;
+    /** Base font name */
+    baseFontName: string;
+    /** Whether this is a symbolic font */
+    isSymbolic: boolean;
+    /** Character widths (code → width in thousandths of text space units) */
+    widths: Map<number, number>;
+    /** Default width */
+    defaultWidth: number;
+    /** Missing width for characters not in widths table */
+    missingWidth: number;
+    /** Whether the font uses Identity-H or Identity-V encoding (codes are Unicode code points) */
+    isIdentityEncoding: boolean;
+    /** Writing mode: 0 = horizontal, 1 = vertical */
+    wmode: number;
+}
+/**
+ * Resolve a PDF font dictionary into a ResolvedFont for text extraction.
+ */
+export declare function resolveFont(fontDict: PdfDictValue, doc: PdfDocument): ResolvedFont;
+/**
+ * Decode character codes to Unicode text using a resolved font.
+ */
+export declare function decodeText(codes: Uint8Array, font: ResolvedFont): string;
+/**
+ * Get the character width for a given code.
+ */
+export declare function getCharWidth(code: number, font: ResolvedFont): number;

package/dist/types/modules/pdf/reader/form-extractor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PDF form field (AcroForm) extractor.
+ *
+ * Extracts interactive form fields from a PDF's `/AcroForm` dictionary.
+ * Supports all standard field types:
+ * - **Text** (`/Tx`) — Text input fields
+ * - **Button** (`/Btn`) — Checkboxes, radio buttons, push buttons
+ * - **Choice** (`/Ch`) — Dropdowns (combo boxes) and list boxes
+ * - **Signature** (`/Sig`) — Digital signature fields
+ *
+ * Handles field hierarchies (parent/child), inherited values, and default appearances.
+ *
+ * @see PDF Reference 1.7, §12.7 - Interactive Forms
+ */
+import type { PdfDocument } from "./pdf-document.js";
+/** Type of form field. */
+export type PdfFormFieldType = "text" | "checkbox" | "radio" | "dropdown" | "listbox" | "button" | "signature" | "unknown";
+/** A single form field extracted from the PDF. */
+export interface PdfFormField {
+    /** Fully qualified field name (e.g. "form1.address.city") */
+    name: string;
+    /** Field type */
+    type: PdfFormFieldType;
+    /** Current value of the field */
+    value: string;
+    /** Default value (/DV entry) */
+    defaultValue: string;
+    /** Whether the field is read-only */
+    readOnly: boolean;
+    /** Whether the field is required */
+    required: boolean;
+    /** For choice fields: the list of available options */
+    options: string[];
+    /** For checkboxes/radio buttons: the export value when checked */
+    exportValue: string;
+    /** Field flags (/Ff entry) — raw bit field */
+    flags: number;
+}
+/**
+ * Extract form fields from a PDF document.
+ *
+ * Reads the `/AcroForm` dictionary from the catalog and recursively
+ * traverses the field tree.
+ *
+ * @param doc - The PDF document
+ * @returns Array of extracted form fields
+ */
+export declare function extractFormFields(doc: PdfDocument): PdfFormField[];

package/dist/types/modules/pdf/reader/image-extractor.d.ts

@@ -0,0 +1,55 @@
+/**
+ * PDF image extraction.
+ *
+ * Extracts images from PDF pages including:
+ * - Inline images (BI/ID/EI operators)
+ * - XObject images (/Subtype /Image)
+ * - Images with various color spaces and filters
+ *
+ * Supported image formats:
+ * - JPEG (DCTDecode) — extracted as-is
+ * - JPEG2000 (JPXDecode) — extracted as-is
+ * - Raw/Flate-compressed pixel data — extracted with metadata
+ * - CCITT fax — extracted as-is
+ *
+ * @see PDF Reference 1.7, §4.8 - Images
+ */
+import type { PdfDocument } from "./pdf-document.js";
+import type { PdfDictValue } from "./pdf-parser.js";
+/**
+ * An extracted image from a PDF page.
+ */
+export interface ExtractedImage {
+    /** Image index within the page (0-based) */
+    index: number;
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Bits per component */
+    bitsPerComponent: number;
+    /** Color space name */
+    colorSpace: string;
+    /** Number of color components (1=gray, 3=RGB, 4=CMYK) */
+    components: number;
+    /**
+     * Image data format:
+     * - "jpeg" — raw JPEG data (can be written directly as .jpg)
+     * - "jpx" — JPEG 2000 data
+     * - "raw" — raw pixel data (RGB/CMYK/Gray, decompressed)
+     * - "ccitt" — CCITT fax compressed data
+     */
+    format: "jpeg" | "jpx" | "raw" | "ccitt" | "jbig2";
+    /** The image data */
+    data: Uint8Array;
+    /** Alpha mask data (if present) — same dimensions, 1 component, 8 bits */
+    alphaMask: Uint8Array | null;
+    /** Filter name from the original stream */
+    filter: string;
+    /** XObject name (if it was a named XObject) */
+    name: string;
+}
+/**
+ * Extract all images from a PDF page.
+ */
+export declare function extractImagesFromPage(pageDict: PdfDictValue, doc: PdfDocument): ExtractedImage[];

package/dist/types/modules/pdf/reader/metadata-reader.d.ts

@@ -0,0 +1,56 @@
+/**
+ * PDF metadata reader.
+ *
+ * Extracts document metadata from:
+ * 1. Info Dictionary (traditional metadata)
+ *    - Title, Author, Subject, Keywords, Creator, Producer
+ *    - CreationDate, ModDate
+ *
+ * 2. XMP Metadata Stream (XML-based, more comprehensive)
+ *    - All of the above plus:
+ *    - Dublin Core metadata, custom properties
+ *
+ * @see PDF Reference 1.7, §10.2 - Metadata
+ * @see XMP Specification Part 1
+ */
+import type { PdfDocument } from "./pdf-document.js";
+/**
+ * PDF document metadata.
+ */
+export interface PdfMetadata {
+    /** Document title */
+    title: string;
+    /** Document author */
+    author: string;
+    /** Document subject */
+    subject: string;
+    /** Document keywords */
+    keywords: string;
+    /** Application that created the original document */
+    creator: string;
+    /** Application that produced the PDF */
+    producer: string;
+    /** Date the document was created */
+    creationDate: Date | null;
+    /** Date the document was last modified */
+    modDate: Date | null;
+    /** PDF version */
+    pdfVersion: string;
+    /** Number of pages */
+    pageCount: number;
+    /** Whether the document is encrypted */
+    encrypted: boolean;
+    /** Page size of the first page (in points) */
+    pageSize: {
+        width: number;
+        height: number;
+    } | null;
+    /** Raw XMP metadata XML (if available) */
+    xmpXml: string | null;
+    /** Additional custom metadata from Info dictionary */
+    custom: Record<string, string>;
+}
+/**
+ * Extract metadata from a PDF document.
+ */
+export declare function extractMetadata(doc: PdfDocument): PdfMetadata;

package/dist/types/modules/pdf/reader/pdf-decrypt.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PDF decryption for reading encrypted PDFs.
+ *
+ * Supports:
+ * - Standard Security Handler (V1/V2/V4/V5, R2/R3/R4/R5)
+ * - RC4 encryption (40-bit and 128-bit)
+ * - AES-128 encryption (PDF 1.6+)
+ * - AES-256 encryption (PDF 2.0, V=5, R=5)
+ *
+ * @see PDF Reference 1.7, §3.5 - Encryption
+ * @see PDF 2.0 (ISO 32000-2), §7.6 - Encryption
+ */
+import type { PdfDocument } from "./pdf-document.js";
+/**
+ * Initialize decryption for a PDF document.
+ * Returns true if decryption was successfully initialized, false if
+ * the password was incorrect.
+ *
+ * @param doc - The PDF document
+ * @param password - User or owner password (empty string for no password)
+ */
+export declare function initDecryption(doc: PdfDocument, password?: string): boolean;
+/**
+ * Check if the document is encrypted.
+ */
+export declare function isEncrypted(doc: PdfDocument): boolean;