@cj-tech-master/excelts 9.1.0 → 9.2.0

package/dist/types/modules/pdf/builder/pdf-editor.d.ts

@@ -0,0 +1,230 @@
+/**
+ * PDF editor — modify existing PDF documents.
+ *
+ * Supports:
+ * - Adding new pages with free-form content
+ * - Adding text/shapes/images to existing pages (overlay)
+ * - Filling form fields (AcroForm)
+ * - Copying pages from other PDFs (merge)
+ * - Preserving page properties (Rotate, CropBox, etc.) and metadata
+ *
+ * Note: save() rebuilds the PDF from scratch rather than using incremental
+ * updates. This is simpler and more reliable but means object numbers change
+ * and existing digital signatures will be invalidated.
+ *
+ * @example Edit an existing PDF:
+ * ```typescript
+ * import { PdfEditor } from "@cj-tech-master/excelts/pdf";
+ *
+ * const editor = PdfEditor.load(existingPdfBytes);
+ * editor.getPage(0).drawText("APPROVED", { x: 200, y: 400, fontSize: 48, color: { r: 0, g: 0.5, b: 0 } });
+ * editor.setFormField("name", "John Doe");
+ * const result = await editor.save();
+ * ```
+ */
+import type { PdfContentStream } from "../core/pdf-stream.js";
+import type { PdfFormField } from "../reader/form-extractor.js";
+import { PdfPageBuilder } from "./document-builder.js";
+import type { DrawTextOptions, DrawRectOptions, DrawCircleOptions, DrawEllipseOptions, DrawLineOptions, DrawImageOptions, DrawPathOptions, PathOp, PageOptions, AnnotationOptions, FormFieldOptions, PdfSignatureOptions } from "./document-builder.js";
+/** Options for loading a PDF for editing. */
+export interface LoadOptions {
+    /** Password for encrypted PDFs. */
+    password?: string;
+}
+/**
+ * Proxy for an existing page that allows overlaying new content.
+ * New content is drawn on top of existing content via a separate content stream.
+ */
+export declare class PdfEditorPage {
+    /** Page width in points. */
+    get width(): number;
+    /** Page height in points. */
+    get height(): number;
+    /**
+     * Measure the width of a text string in points.
+     */
+    measureText(text: string, options?: {
+        fontSize?: number;
+        fontFamily?: string;
+        bold?: boolean;
+        italic?: boolean;
+    }): number;
+    /**
+     * Draw text on this existing page (overlaid on top).
+     */
+    drawText(text: string, options: DrawTextOptions): this;
+    /**
+     * Draw a rectangle on this existing page.
+     */
+    drawRect(options: DrawRectOptions): this;
+    /**
+     * Draw a circle on this existing page.
+     */
+    drawCircle(options: DrawCircleOptions): this;
+    /**
+     * Draw an ellipse on this existing page.
+     */
+    drawEllipse(options: DrawEllipseOptions): this;
+    /**
+     * Draw a line on this existing page.
+     */
+    drawLine(options: DrawLineOptions): this;
+    /**
+     * Draw an image on this existing page.
+     */
+    drawImage(options: DrawImageOptions): this;
+    /**
+     * Get the raw overlay content stream.
+     */
+    getContentStream(): PdfContentStream;
+    /**
+     * Add an annotation to this existing page (Highlight, Text, FreeText, Stamp, etc.).
+     */
+    addAnnotation(options: AnnotationOptions): this;
+    /**
+     * Add a form field to this existing page.
+     */
+    addFormField(options: FormFieldOptions): this;
+    /**
+     * Draw an SVG path on this existing page.
+     */
+    drawSvgPath(d: string, options?: DrawPathOptions): this;
+    /**
+     * Draw a complex path from a list of path operations.
+     */
+    drawPath(ops: PathOp[], options?: DrawPathOptions): this;
+}
+/**
+ * Editor for modifying existing PDF documents.
+ *
+ * Load an existing PDF, overlay content on existing pages, fill form fields,
+ * add new pages, copy pages from other documents, and save.
+ */
+export declare class PdfEditor {
+    private _doc;
+    private _password;
+    private _pages;
+    private _newPages;
+    private _fontManager;
+    private _formFieldUpdates;
+    private _copiedPages;
+    private _signaturePlaceholder;
+    private constructor();
+    /**
+     * Load a PDF for editing.
+     *
+     * @param data - Raw PDF file bytes
+     * @param options - Load options (e.g., password)
+     * @returns A PdfEditor instance
+     */
+    static load(data: Uint8Array, options?: LoadOptions): PdfEditor;
+    /** Number of existing pages. */
+    get pageCount(): number;
+    /**
+     * Get an existing page for editing (overlaying content).
+     *
+     * @param index - 0-based page index
+     */
+    getPage(index: number): PdfEditorPage;
+    /**
+     * Add a new blank page to the end of the document.
+     */
+    addPage(options?: PageOptions): PdfPageBuilder;
+    /**
+     * Remove a page from the document.
+     *
+     * @param index - 0-based page index (of original pages only)
+     */
+    removePage(index: number): this;
+    /**
+     * Set the rotation of an existing page.
+     *
+     * @param index - 0-based page index (of original pages only)
+     * @param degrees - Rotation in degrees (must be 0, 90, 180, or 270)
+     */
+    rotatePage(index: number, degrees: number): this;
+    /**
+     * Split the document: save each page (or a subset) as a separate PDF.
+     *
+     * @param pageIndices - 0-based page indices to extract. Omit to split all pages.
+     * @returns Array of Uint8Array, one per requested page.
+     */
+    splitPages(pageIndices?: number[]): Promise<Uint8Array[]>;
+    /**
+     * Embed a TrueType font for Unicode/CJK support.
+     */
+    embedFont(fontBytes: Uint8Array): this;
+    /**
+     * Set the value of a form field.
+     * The field is identified by its fully qualified name (e.g., "form.address.city").
+     *
+     * @param fieldName - Fully qualified field name
+     * @param value - New value to set
+     */
+    setFormField(fieldName: string, value: string): this;
+    /**
+     * Set multiple form field values at once.
+     *
+     * @param fields - Object mapping field names to values
+     */
+    setFormFields(fields: Record<string, string>): this;
+    /**
+     * Get current form fields (before any modifications).
+     */
+    getFormFields(): PdfFormField[];
+    /**
+     * Copy pages from another PDF document into this document.
+     *
+     * @param sourcePdf - Raw bytes of the source PDF
+     * @param pageIndices - 0-based page indices to copy. Omit to copy all pages.
+     * @param options - Load options for the source PDF (e.g., password)
+     */
+    copyPagesFrom(sourcePdf: Uint8Array, pageIndices?: number[], options?: LoadOptions): this;
+    /**
+     * Save the modified PDF.
+     *
+     * Rebuilds the PDF from scratch — content streams, resources, and page
+     * properties are deep-cloned into a new document. Original metadata and
+     * XMP streams are preserved. Digital signatures will be invalidated.
+     *
+     * @returns The modified PDF as Uint8Array
+     */
+    save(): Promise<Uint8Array>;
+    /**
+     * Save the modified PDF using incremental update.
+     *
+     * Appends new/modified objects after the original PDF bytes, preserving the
+     * original data byte-for-byte. This is ideal for overlays and form field
+     * updates on existing pages — it preserves digital signatures on unmodified
+     * content and produces smaller output.
+     *
+     * Falls back to {@link save} (full rebuild) if structural changes are
+     * present (new pages, copied pages, or removed pages).
+     *
+     * @returns The modified PDF as Uint8Array
+     */
+    saveIncremental(): Promise<Uint8Array>;
+    /** Page-level keys to preserve when rebuilding page dicts. */
+    private static readonly _PAGE_PRESERVE_KEYS;
+    /**
+     * Sign this PDF with a digital signature.
+     *
+     * Performs a full save with an embedded PKCS#7 signature placeholder,
+     * then fills in the real CMS SignedData.
+     *
+     * @param options - Certificate, private key, and optional signer metadata
+     * @returns The signed PDF as Uint8Array
+     *
+     * @example
+     * ```typescript
+     * const editor = PdfEditor.load(pdfBytes);
+     * const signed = await editor.sign({
+     *   certificate: certDerBytes,
+     *   privateKey: pkcs8DerBytes,
+     *   name: "Jane Doe",
+     *   reason: "Approval"
+     * });
+     * ```
+     */
+    sign(options: PdfSignatureOptions): Promise<Uint8Array>;
+}

package/dist/types/modules/pdf/builder/resource-merger.d.ts

@@ -0,0 +1,41 @@
+/**
+ * PDF resource dictionary merger — structured merging at the parsed object level.
+ *
+ * Instead of manipulating serialized PDF dict strings directly, this module
+ * parses resource dicts into a structured `PdfResourceDict` (nested Maps),
+ * merges them, and serializes back to PDF dict strings.
+ */
+/**
+ * Structured representation of a PDF resource dictionary.
+ *
+ * Outer key: category name (e.g. `Font`, `XObject`, `ExtGState`, `ColorSpace`,
+ * `Pattern`, `Shading`, `Properties`).
+ * Inner key: resource name (e.g. `F1`, `Im1`, `GS0`).
+ * Value: serialized ref or value string (e.g. `3 0 R`, `/DeviceRGB`).
+ *
+ * Categories whose value is not a sub-dict (e.g. `/ProcSet [/PDF /Text]`)
+ * are stored with an empty inner key `""` mapping to the raw value string.
+ */
+export type PdfResourceDict = Map<string, Map<string, string>>;
+/**
+ * Merge two parsed resource dicts. For sub-dict categories, entries are
+ * combined; overlay entries win on name collision. For non-sub-dict categories,
+ * the overlay value replaces the original.
+ */
+export declare function mergeResourceDicts(original: PdfResourceDict, overlay: PdfResourceDict): PdfResourceDict;
+/**
+ * Parse a serialized PDF resource dict string into a structured `PdfResourceDict`.
+ *
+ * Handles top-level entries like:
+ * ```
+ * << /Font << /F1 3 0 R /F2 5 0 R >> /XObject << /Im1 7 0 R >> /ProcSet [/PDF /Text] >>
+ * ```
+ *
+ * Sub-dict categories (`Font`, `XObject`, etc.) are parsed into inner name→value maps.
+ * Other categories are stored with a single entry keyed by `""`.
+ */
+export declare function parseResourceDict(dictStr: string): PdfResourceDict;
+/**
+ * Serialize a structured `PdfResourceDict` back to a PDF dict string.
+ */
+export declare function serializeResourceDict(dict: PdfResourceDict): string;

package/dist/types/modules/pdf/core/digital-signature.d.ts

@@ -0,0 +1,109 @@
+/**
+ * PDF digital signature — verification and creation.
+ *
+ * Implements:
+ * - ASN.1 DER decode/encode (shared codec)
+ * - PKCS#7 / CMS SignedData parse and build
+ * - X.509 certificate public key extraction
+ * - PDF /ByteRange extraction and hash computation
+ * - Signature verification (RSA PKCS#1 v1.5 + SHA-256)
+ * - Signature creation (with ByteRange placeholder/backfill)
+ *
+ * Uses platform-native RSA via `@utils/crypto` (node:crypto on Node,
+ * Web Crypto API in browsers).
+ *
+ * @see RFC 5652 — CMS (Cryptographic Message Syntax)
+ * @see ITU-T X.690 — ASN.1 DER encoding rules
+ * @see ISO 32000-2:2020 §12.8 — Digital Signatures in PDF
+ */
+/** Parsed ASN.1 node. */
+export interface Asn1Node {
+    tag: number;
+    /** Raw bytes of the value (for primitive types). */
+    bytes: Uint8Array;
+    /** Child nodes (for constructed types). */
+    children: Asn1Node[];
+}
+/**
+ * Parse ASN.1 DER data from the root.
+ */
+export declare function asn1Parse(data: Uint8Array): Asn1Node;
+/** Parsed CMS SignedData info for verification. */
+export interface CmsSignedData {
+    /** The signer's certificate (DER). */
+    certificate: Uint8Array;
+    /** The signature value. */
+    signature: Uint8Array;
+    /** The digest algorithm OID. */
+    digestAlgorithmOid: string;
+    /** The signed attributes (DER-encoded SET for hash computation). */
+    signedAttrsRaw: Uint8Array;
+    /** The message digest from signed attributes. */
+    messageDigest: Uint8Array;
+}
+/**
+ * Parse a PKCS#7 / CMS SignedData structure from DER bytes.
+ * Extracts the first signer's info for verification.
+ */
+export declare function parseCmsSignedData(derBytes: Uint8Array): CmsSignedData;
+/** Options for building a CMS SignedData for PDF signing. */
+export interface SignOptions {
+    /** DER-encoded X.509 certificate. */
+    certificate: Uint8Array;
+    /** DER-encoded PKCS#8 private key. */
+    privateKey: Uint8Array;
+    /** The data to sign (the PDF byte ranges). */
+    data: Uint8Array;
+}
+/**
+ * Build a CMS SignedData (PKCS#7) structure for a PDF signature.
+ *
+ * Uses SHA-256 for digest and RSA PKCS#1 v1.5 for signing.
+ * The signature is created over signed attributes that include
+ * the content-type, message-digest, and signing-time.
+ */
+export declare function buildCmsSignedData(options: SignOptions): Promise<Uint8Array>;
+/** Result of verifying a PDF signature. */
+export interface SignatureVerificationResult {
+    /** Whether the signature is cryptographically valid. */
+    valid: boolean;
+    /** Whether the signed byte ranges cover the entire file (no unsigned gaps). */
+    coversWholeFile: boolean;
+    /** Digest algorithm used. */
+    digestAlgorithm: string;
+    /** Reason for failure, if any. */
+    reason?: string;
+}
+/**
+ * Verify a digital signature in a PDF document.
+ *
+ * @param pdfData - The complete PDF file bytes
+ * @param signatureHex - The hex-encoded PKCS#7 signature from the /Contents field
+ * @param byteRange - The /ByteRange array [offset1, length1, offset2, length2]
+ */
+export declare function verifyPdfSignature(pdfData: Uint8Array, signatureHex: string, byteRange: [number, number, number, number]): Promise<SignatureVerificationResult>;
+/**
+ * Create a PDF signature dictionary string with a placeholder /Contents.
+ * Returns the dict string and the placeholder that will be replaced.
+ *
+ * @param signerName - Optional signer name for /Name field
+ * @param reason - Optional reason for /Reason field
+ */
+export declare function buildSignatureDictPlaceholder(options?: {
+    name?: string;
+    reason?: string;
+    location?: string;
+    contactInfo?: string;
+}): {
+    dictString: string;
+    placeholder: string;
+};
+/**
+ * Patch a PDF with a real signature after the /ByteRange placeholder has been written.
+ *
+ * @param pdfBytes - The PDF bytes with placeholder /Contents and /ByteRange
+ * @param certificate - DER-encoded X.509 certificate
+ * @param privateKey - DER-encoded PKCS#8 private key
+ * @returns The signed PDF bytes
+ */
+export declare function signPdf(pdfBytes: Uint8Array, certificate: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;

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

@@ -49,6 +49,13 @@ export declare function pdfDate(date: Date): string;
  */
 export declare class PdfDict {
     private entries;
+    /** When set, toString() returns this raw string. set() appends/replaces entries within it. */
+    private _raw;
+    /**
+     * Create a PdfDict that wraps a pre-serialized dictionary string.
+     * toString() returns the raw string (with any set() overrides applied).
+     */
+    static fromRawString(raw: string): PdfDict;
     /**
      * Set a dictionary entry. The key should NOT include the leading /.
      * The value should be a pre-serialized PDF value string.
@@ -58,6 +65,10 @@ export declare class PdfDict {
      * Conditionally set a dictionary entry.
      */
     setIf(condition: boolean, key: string, value: string): this;
+    /**
+     * Remove a dictionary entry by key.
+     */
+    delete(key: string): this;
     /**
      * Serialize to a PDF dictionary string.
      */

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

@@ -75,6 +75,21 @@ export declare class PdfContentStream {
      * PDF convention: (x, y) is the lower-left corner.
      */
     rect(x: number, y: number, width: number, height: number): this;
+    /**
+     * Append a cubic Bezier curve to the current path.
+     * From current point to (x3, y3), with control points (x1, y1) and (x2, y2).
+     */
+    curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): this;
+    /**
+     * Append a cubic Bezier curve where the first control point is the current point.
+     * From current point to (x3, y3), with control points (current, y1) and (x2, y2).
+     */
+    curveToV(x2: number, y2: number, x3: number, y3: number): this;
+    /**
+     * Append a cubic Bezier curve where the second control point equals (x3, y3).
+     * From current point to (x3, y3), with control point (x1, y1).
+     */
+    curveToY(x1: number, y1: number, x3: number, y3: number): this;
     /**
      * Stroke the current path.
      */
@@ -184,6 +199,23 @@ export declare class PdfContentStream {
      * Draw a stroked line.
      */
     drawLine(x1: number, y1: number, x2: number, y2: number, color: PdfColor, lineWidth: number, dashPattern?: number[]): this;
+    /**
+     * Append an ellipse to the current path using 4 cubic Bezier curves.
+     * (cx, cy) is the center; rx, ry are the radii.
+     *
+     * Uses the standard kappa = 4 * (sqrt(2) - 1) / 3 ≈ 0.5522847 approximation.
+     */
+    ellipse(cx: number, cy: number, rx: number, ry: number): this;
+    /**
+     * Append a circle to the current path.
+     * (cx, cy) is the center; r is the radius.
+     */
+    circle(cx: number, cy: number, r: number): this;
+    /**
+     * Append a rounded rectangle to the current path.
+     * (x, y) is the lower-left corner; r is the corner radius.
+     */
+    roundedRect(x: number, y: number, width: number, height: number, r: number): this;
     /**
      * Get the content stream as a string.
      */

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

@@ -8,6 +8,9 @@
  * 3. Cross-reference table
  * 4. Trailer (with document catalog reference)
  *
+ * Also provides {@link buildIncremental} for appending incremental updates
+ * to an existing PDF without rewriting the original bytes.
+ *
  * Encryption uses AES-256 (V=5, R=5) per ISO 32000-2:2020.
  *
  * @see ISO 32000-2:2020, Chapter 7.5 — File Structure
@@ -29,6 +32,12 @@ export declare class PdfWriter {
     private catalogRef;
     private infoRef;
     private encryption;
+    private pdfVersion;
+    /**
+     * Set the PDF version string (e.g. "1.4", "1.7", "2.0").
+     * Default is "2.0".
+     */
+    setVersion(version: string): void;
     /**
      * Enable encryption for this document.
      */
@@ -47,9 +56,26 @@ export declare class PdfWriter {
     /**
      * Add a stream object (dictionary + binary stream data) to the PDF.
      * The /Length key is automatically added to the dictionary.
+     *
+     * @param objectNumber - Previously allocated object number
+     * @param dict - The stream dictionary
+     * @param data - Stream content (PdfContentStream or raw Uint8Array)
+     * @param options - Optional settings (e.g. `{ compress: false }` to skip zlib)
      */
     addStreamObject(objectNumber: number, dict: PdfDict, stream: PdfContentStream): void;
     addStreamObject(objectNumber: number, dict: PdfDict, data: Uint8Array): void;
+    addStreamObject(objectNumber: number, dict: PdfDict, data: Uint8Array, options: {
+        compress?: boolean;
+    }): void;
+    /**
+     * Return all stored objects for inspection (e.g., incremental update remapping).
+     * Stream objects include their binary data.
+     */
+    getObjects(): Array<{
+        objectNumber: number;
+        content: string;
+        streamData?: Uint8Array;
+    }>;
     /**
      * Set the document catalog object number.
      * This is required and references the root of the document structure.
@@ -77,10 +103,38 @@ export declare class PdfWriter {
     }): number;
     /**
      * Create and add the Catalog dictionary.
+     *
+     * @param pagesRef - Object number of the Pages tree root
+     * @param optionsOrOutlinesRef - Either an outlinesRef number (legacy) or an options object
      */
-    addCatalog(pagesRef: number, outlinesRef?: number): number;
+    addCatalog(pagesRef: number, optionsOrOutlinesRef?: number | {
+        outlinesRef?: number;
+        extraEntries?: Array<[key: string, value: string]>;
+    }): number;
     /**
      * Build the complete PDF file as a Uint8Array.
      */
     build(): Uint8Array;
 }
+/**
+ * Build an incremental update that appends new/modified objects to an
+ * existing PDF without rewriting the original bytes.
+ *
+ * The result is `originalData + "\n" + new objects + xref + trailer + %%EOF`.
+ * The new trailer's `/Prev` points to the original xref offset so that PDF
+ * readers can follow the chain of incremental updates.
+ *
+ * @param originalData - The original, unmodified PDF bytes (preserved byte-for-byte)
+ * @param modifiedObjects - Map of object number → serialized content.
+ *   Values are either a plain string (for non-stream objects) or
+ *   `{ dict, data }` for stream objects.
+ * @param newTrailerEntries - Additional/override entries for the new trailer.
+ *   Keys like `/Root`, `/Info`, `/Encrypt`, `/ID` are preserved from the
+ *   original trailer by default but can be overridden here.
+ *
+ * @see ISO 32000-2:2020, §7.5.6 — Incremental Updates
+ */
+export declare function buildIncremental(originalData: Uint8Array, modifiedObjects: Map<number, string | {
+    dict: PdfDict;
+    data: Uint8Array;
+}>, newTrailerEntries: Map<string, string>): Uint8Array;

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

@@ -0,0 +1,62 @@
+/**
+ * PDF/A-1b compliance utilities.
+ *
+ * Provides XMP metadata stream writing and OutputIntent creation for
+ * PDF/A-1b (ISO 19005-1, Level B) conformance.
+ *
+ * **Limitations:**
+ * - Type1 base fonts (Helvetica, Times-Roman, Courier, etc.) are NOT embedded.
+ *   PDF/A-1b strictly requires all fonts to be embedded. Documents using only
+ *   CIDFonts (embedded TrueType via `embedFont()`) are fully compliant.
+ *   Documents using base Type1 fonts will pass structural validation but may
+ *   fail strict PDF/A font-embedding checks.
+ *
+ * @see ISO 19005-1:2005 — Document management — Electronic document file
+ *      format for long-term preservation — Part 1: Use of PDF 1.4 (PDF/A-1)
+ */
+import type { PdfWriter } from "./pdf-writer.js";
+/**
+ * Minimal sRGB ICC profile (v2.1.0).
+ *
+ * This is a valid ICC profile with the correct header structure, profile
+ * signature, and a minimal tag table. It identifies the color space as RGB
+ * with the sRGB rendering intent. The profile is intentionally minimal
+ * (~128 bytes) — enough to satisfy PDF/A-1b OutputIntent requirements.
+ *
+ * Structure:
+ * - 128-byte header (profile size, preferred CMM, version, device class,
+ *   color space, PCS, creation date, signature, platform, flags, etc.)
+ * - Tag table with 0 tags (profile is header-only for minimal compliance)
+ *
+ * @see ICC.1:2001-04 — File Format for Color Profiles (v2)
+ */
+export declare const sRGB_ICC_PROFILE: Uint8Array;
+/**
+ * Write a PDF/A-1b XMP metadata stream as an indirect object.
+ *
+ * The XMP packet contains:
+ * - `dc:title` — document title
+ * - `dc:creator` — document author
+ * - `xmp:CreatorTool` — creating application
+ * - `pdf:Producer` — PDF producer
+ * - `pdfaid:part` — PDF/A part (1)
+ * - `pdfaid:conformance` — PDF/A conformance level (B)
+ *
+ * @returns The object number of the XMP metadata stream.
+ */
+export declare function writePdfAMetadata(writer: PdfWriter, metadata: {
+    title?: string;
+    author?: string;
+    subject?: string;
+    creator?: string;
+}): number;
+/**
+ * Write a PDF/A-1b OutputIntent with an embedded sRGB ICC profile.
+ *
+ * Creates two objects:
+ * 1. The ICC profile stream
+ * 2. The OutputIntent dictionary referencing the profile
+ *
+ * @returns The object number of the OutputIntent dictionary.
+ */
+export declare function writePdfAOutputIntent(writer: PdfWriter): number;

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

@@ -46,6 +46,12 @@ export { pdf } from "./pdf.js";
 export { excelToPdf } from "./excel-bridge.js";
 /** Read a PDF file and extract text, images, and metadata. */
 export { readPdf } from "./reader/pdf-reader.js";
+/** Build PDFs with free text positioning, vector drawing, and images. */
+export { PdfDocumentBuilder, PdfPageBuilder, parseSvgPath } from "./builder/document-builder.js";
+/** Edit existing PDFs: overlay content, fill forms, copy/merge pages. */
+export { PdfEditor, PdfEditorPage } from "./builder/pdf-editor.js";
+/** Digital signatures — verify and sign PDF documents. */
+export { verifyPdfSignature, signPdf, buildSignatureDictPlaceholder, asn1Parse } from "./core/digital-signature.js";
 export type { PdfCell, PdfRow, PdfColumn, PdfSheet, PdfBook, PdfImage } from "./pdf.js";
 export type { PdfExportOptions, PdfOrientation, PdfPageSize, PdfMargins, PdfColor, PageSizeName, PdfWatermark, PdfTextWatermark, PdfImageWatermark, PdfWatermarkFilter } from "./types.js";
 export { PageSizes } from "./types.js";
@@ -55,4 +61,9 @@ 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 type { PdfBookmark } from "./reader/bookmark-extractor.js";
+export type { PdfTable, PdfTableRow, PdfTableCell } from "./reader/table-extractor.js";
+export type { PageOptions, DrawTextOptions, DrawRectOptions, DrawCircleOptions, DrawEllipseOptions, DrawLineOptions, DrawPathOptions, DrawImageOptions, DocumentMetadata, PathOp, TocOptions, AnnotationType, AnnotationOptions, TextMarkupAnnotationOptions, TextAnnotationOptions, FreeTextAnnotationOptions, StampAnnotationOptions, FormFieldOptions, TextFieldOptions, CheckboxOptions, DropdownOptions, RadioGroupOptions, PdfSignatureOptions } from "./builder/document-builder.js";
+export type { LoadOptions } from "./builder/pdf-editor.js";
+export type { SignatureVerificationResult, CmsSignedData, SignOptions, Asn1Node } from "./core/digital-signature.js";
 export { PdfError, PdfRenderError, PdfFontError, PdfStructureError, isPdfError } from "./errors.js";

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

@@ -0,0 +1,35 @@
+/**
+ * PDF bookmark (outline) extractor.
+ *
+ * Extracts the document outline tree from a PDF's `/Outlines` dictionary.
+ * Each outline item has a title, a target page index, and optional children
+ * forming a hierarchical bookmark tree.
+ *
+ * Supports:
+ * - Direct destinations (`/Dest` as array or named destination)
+ * - Action-based destinations (`/A << /S /GoTo /D ... >>`)
+ * - Nested bookmarks (children via `/First`/`/Last` chains)
+ * - Circular reference protection
+ *
+ * @see PDF Reference 1.7, §12.3 - Document-Level Navigation
+ */
+import type { PdfDocument } from "./pdf-document.js";
+/** A bookmark (outline item) extracted from the PDF. */
+export interface PdfBookmark {
+    /** Bookmark title text */
+    title: string;
+    /** 0-based page index the bookmark points to (-1 if unresolvable) */
+    pageIndex: number;
+    /** Child bookmarks (nested outline items) */
+    children: PdfBookmark[];
+}
+/**
+ * Extract bookmarks (outlines) from a PDF document.
+ *
+ * Reads the `/Outlines` dictionary from the catalog and recursively
+ * traverses the outline tree following `/First` → `/Next` chains.
+ *
+ * @param doc - The PDF document
+ * @returns Array of top-level bookmarks with nested children
+ */
+export declare function extractBookmarks(doc: PdfDocument): PdfBookmark[];