pdf-oxide-wasm 0.3.37 → 0.3.38

package/README.md

@@ -167,7 +167,7 @@ const pngBytes = doc.extractImageBytes(0);
 
 ```javascript
 doc.setTitle("Quarterly Report");
-doc.setAuthor("Finance Team");
+doc.setAuthor("Example Author");
 doc.setPageRotation(0, 90);
 doc.cropMargins(36, 36, 36, 36);
 doc.eraseRegion(0, 50, 50, 200, 100);

package/bundler/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/{pdf_oxide.d.ts → bundler/pdf_oxide.d.ts}

@@ -25,28 +25,6 @@ export class ArtifactStyle {
     constructor();
 }
 
-/**
- * Chroma subsampling format
- */
-export enum ChromaSampling {
-    /**
-     * Both vertically and horizontally subsampled.
-     */
-    Cs420 = 0,
-    /**
-     * Horizontally subsampled.
-     */
-    Cs422 = 1,
-    /**
-     * Not subsampled.
-     */
-    Cs444 = 2,
-    /**
-     * Monochrome.
-     */
-    Cs400 = 3,
-}
-
 /**
  * A header or footer artifact definition.
  */
@@ -79,6 +57,218 @@ export class WasmArtifact {
     withStyle(style: ArtifactStyle): WasmArtifact;
 }
 
+/**
+ * X.509 certificate parsed from a raw DER blob. Mirrors the C#,
+ * Node, Python, and Go `Certificate` surfaces — `subject` / `issuer`
+ * / `serial` / `validity` / `isValid` getters only.
+ */
+export class WasmCertificate {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Load a certificate from a DER-encoded X.509 blob. Throws if
+     * the DER doesn't parse.
+     */
+    static load(data: Uint8Array): WasmCertificate;
+    /**
+     * Whether the certificate is currently within its validity
+     * window. Does NOT verify chain, trust-root, or revocation.
+     */
+    readonly isValid: boolean;
+    /**
+     * Issuer distinguished name.
+     */
+    readonly issuer: string;
+    /**
+     * Serial number as a hex string (no `0x` prefix).
+     */
+    readonly serial: string;
+    /**
+     * Subject distinguished name.
+     */
+    readonly subject: string;
+    /**
+     * Validity window as `[notBefore, notAfter]` Unix epoch seconds.
+     * JavaScript: `new Date(notBefore * 1000)` for a Date.
+     */
+    readonly validity: BigInt64Array;
+}
+
+/**
+ * WASM wrapper for [`crate::writer::DocumentBuilder`]. Fluent API for
+ * programmatic multi-page PDF construction with embedded fonts and
+ * annotations.
+ *
+ * The terminal methods (`build`, `toBytesEncrypted`) **consume** the
+ * builder; subsequent calls throw `Error: DocumentBuilder already
+ * consumed`.
+ */
+export class WasmDocumentBuilder {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Start a new A4 page. Returns a `FluentPageBuilder` that must be
+     * committed with `.done()` before calling another page method or a
+     * terminal (`build`, etc.).
+     */
+    a4Page(): WasmFluentPageBuilder;
+    /**
+     * Set document author.
+     */
+    author(author: string): void;
+    /**
+     * Build the PDF and return it as a `Uint8Array`. **Consumes** the
+     * builder.
+     */
+    build(): Uint8Array;
+    /**
+     * Commit a completed `FluentPageBuilder` back to this builder.
+     * Takes the place of the Rust `page.done()` re-parenting.
+     *
+     * JS users typically don't call this directly — the ergonomic
+     * pattern is `builder.a4Page();` for each page, then
+     * `builder.commitPage(page)` once ops are queued. For more fluent
+     * code, see the `FluentPageBuilder.done(builder)` helper which
+     * delegates to this method.
+     */
+    commitPage(page: WasmFluentPageBuilder): void;
+    /**
+     * Set the creator application name recorded in the PDF.
+     */
+    creator(creator: string): void;
+    /**
+     * Set document keywords (comma-separated per PDF convention).
+     */
+    keywords(keywords: string): void;
+    /**
+     * Start a new US Letter page.
+     */
+    letterPage(): WasmFluentPageBuilder;
+    /**
+     * Create a new empty document builder. Equivalent to the Rust
+     * [`crate::writer::DocumentBuilder::new`] — every other method
+     * chains off the instance returned here.
+     */
+    constructor();
+    /**
+     * Start a new page with custom dimensions in PDF points
+     * (72 pt = 1 inch).
+     */
+    page(width: number, height: number): WasmFluentPageBuilder;
+    /**
+     * Register a TTF / OTF font the pages can reference by name.
+     * **Consumes** `font` — reusing the `WasmEmbeddedFont` throws.
+     */
+    registerEmbeddedFont(name: string, font: WasmEmbeddedFont): void;
+    /**
+     * Set document subject.
+     */
+    subject(subject: string): void;
+    /**
+     * Set document title.
+     */
+    title(title: string): void;
+    /**
+     * Build the PDF with AES-256 encryption and return it as a
+     * `Uint8Array`. Granted permissions default to all. **Consumes**
+     * the builder.
+     */
+    toBytesEncrypted(user_password: string, owner_password: string): Uint8Array;
+}
+
+/**
+ * Embedded TTF/OTF font usable by `WasmDocumentBuilder`. Single-use: once
+ * passed to `registerEmbeddedFont`, the underlying Rust `EmbeddedFont` is
+ * moved into the builder and this handle becomes empty.
+ */
+export class WasmEmbeddedFont {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Load an embedded font from raw TTF/OTF bytes. Pass `name` to
+     * override the PostScript name baked into the font file.
+     */
+    static fromBytes(data: Uint8Array, name?: string | null): WasmEmbeddedFont;
+    /**
+     * The font's PostScript name (or the override). Empty once consumed.
+     */
+    readonly name: string;
+}
+
+/**
+ * Per-page fluent builder. Buffers operations until `done(builder)` is
+ * called, which commits them to the parent `WasmDocumentBuilder`. Each
+ * instance is single-use — `done()` twice throws.
+ */
+export class WasmFluentPageBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    at(x: number, y: number): void;
+    checkbox(name: string, x: number, y: number, w: number, h: number, checked: boolean): void;
+    /**
+     * Add a dropdown combo-box.
+     */
+    comboBox(name: string, x: number, y: number, w: number, h: number, options: string[], selected?: string | null): void;
+    /**
+     * Convenience: commit this page's buffered ops to `builder`. Same
+     * as `builder.commitPage(this)` but lets JS users keep the
+     * chain-like flow:
+     *
+     * ```javascript
+     * const page = builder.a4Page();
+     * page.at(72, 720); page.text("Hi");
+     * page.done(builder);
+     * ```
+     */
+    done(builder: WasmDocumentBuilder): void;
+    /**
+     * Draw a filled rectangle. RGB channels in 0.0-1.0.
+     */
+    filledRect(x: number, y: number, w: number, h: number, r: number, g: number, b: number): void;
+    font(name: string, size: number): void;
+    freeText(x: number, y: number, w: number, h: number, text: string): void;
+    heading(level: number, text: string): void;
+    highlight(r: number, g: number, b: number): void;
+    horizontalRule(): void;
+    /**
+     * Draw a line from (x1, y1) to (x2, y2) with 1pt black stroke.
+     */
+    line(x1: number, y1: number, x2: number, y2: number): void;
+    linkNamed(destination: string): void;
+    linkPage(page: number): void;
+    linkUrl(url: string): void;
+    paragraph(text: string): void;
+    /**
+     * Add a clickable push button with a visible caption.
+     */
+    pushButton(name: string, x: number, y: number, w: number, h: number, caption: string): void;
+    /**
+     * Add a radio-button group. `values`, `xs`, `ys`, `ws`, `hs` are
+     * parallel arrays of length N describing each option's export
+     * value and rectangle. `selected` picks the initial value.
+     */
+    radioGroup(name: string, values: string[], xs: Float32Array, ys: Float32Array, ws: Float32Array, hs: Float32Array, selected?: string | null): void;
+    /**
+     * Draw a stroked rectangle outline (1pt black).
+     */
+    rect(x: number, y: number, w: number, h: number): void;
+    space(points: number): void;
+    squiggly(r: number, g: number, b: number): void;
+    stamp(name: string): void;
+    stickyNote(text: string): void;
+    stickyNoteAt(x: number, y: number, text: string): void;
+    strikeout(r: number, g: number, b: number): void;
+    text(text: string): void;
+    textField(name: string, x: number, y: number, w: number, h: number, default_value?: string | null): void;
+    underline(r: number, g: number, b: number): void;
+    watermark(text: string): void;
+    watermarkConfidential(): void;
+    watermarkDraft(): void;
+}
+
 /**
  * A footer definition.
  */
@@ -203,6 +393,21 @@ export class WasmPdf {
      * @param author - Optional document author
      */
     static fromHtml(content: string, title?: string | null, author?: string | null): WasmPdf;
+    /**
+     * Render `html` with `css` applied, embedding `font_bytes` for the
+     * body text. The font must cover every codepoint used by `html` or
+     * unknown glyphs fall back to `.notdef`. See
+     * [`Self::from_html_css_with_fonts`] for a multi-font cascade.
+     */
+    static fromHtmlCss(html: string, css: string, font_bytes: Uint8Array): WasmPdf;
+    /**
+     * Render `html` + `css` with a multi-font cascade. `families` and
+     * `fonts` are parallel arrays: `families[i]` names the CSS
+     * `font-family` that resolves to `fonts[i]` bytes. The first entry
+     * is the default used whenever a CSS `font-family` doesn't match a
+     * registered family.
+     */
+    static fromHtmlCssWithFonts(html: string, css: string, families: string[], fonts: Uint8Array[]): WasmPdf;
     /**
      * Create a PDF from image bytes (PNG, JPEG, etc.).
      *
@@ -530,6 +735,13 @@ export class WasmPdfDocument {
      * @returns Number of pages merged
      */
     mergeFrom(data: Uint8Array): number;
+    /**
+     * Move a page within the document. Zero-based; `from_index` and
+     * `to_index` refer to positions **before** the move, matching the
+     * Python (`PyPdfDocument.move_page`) / Go (`DocumentEditor.MovePage`) /
+     * C# contracts.
+     */
+    movePage(from_index: number, to_index: number): void;
     /**
      * Load a PDF document from raw bytes.
      *
@@ -681,6 +893,17 @@ export class WasmPdfDocument {
      * Set the document title.
      */
     setTitle(title: string): void;
+    /**
+     * Count existing PDF signatures. Returns 0 when the document has
+     * no AcroForm or no signed signature fields.
+     */
+    signatureCount(): number;
+    /**
+     * Enumerate existing PDF signatures. Each entry is a
+     * `WasmSignature` (inspection-only) mirroring the C# and Python
+     * Signature surfaces.
+     */
+    signatures(): WasmSignature[];
     /**
      * Convert a single page to HTML.
      *
@@ -793,6 +1016,119 @@ export class WasmPdfPageRegion {
     extractWords(): any;
 }
 
+/**
+ * A single existing PDF signature surfaced by
+ * `WasmPdfDocument.signatures()`. `verify()` runs the RSA-PKCS#1 v1.5
+ * signer-attributes check; `verifyDetached()` adds the
+ * `messageDigest` content-hash check. RSA-PSS / ECDSA signers still
+ * throw an `UnsupportedFeature`-mapped JS error.
+ */
+export class WasmSignature {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Run the RFC 5652 §5.4 signer-attributes crypto check. Today
+     * this covers RSA-PKCS#1 v1.5 over SHA-1/256/384/512 — the
+     * padding used by essentially every PDF signature.
+     *
+     * A `true` return proves the signer held the private key matching
+     * the embedded certificate and that the signed-attribute bundle
+     * is authentic. It does **not** verify the `messageDigest`
+     * attribute against the document's byte-range content hash —
+     * call `verifyDetached()` for that end-to-end check.
+     *
+     * Throws for RSA-PSS, ECDSA, unknown digest OIDs, or signatures
+     * without signed_attrs.
+     */
+    verify(): boolean;
+    /**
+     * End-to-end detached-signature verification. Runs both the
+     * signer-attributes RSA-PKCS#1 v1.5 crypto check AND the RFC 5652
+     * §11.2 `messageDigest` check against the segment of `pdfData`
+     * this signature covers (extracted via `/ByteRange`).
+     *
+     * `pdfData` must be the full PDF file. A `true` result proves
+     * both the signer is authentic and that the document's byte-range
+     * content has not been altered since signing. `false` means one
+     * of the two checks failed (wrong key or tampered content).
+     *
+     * Throws for RSA-PSS, ECDSA, unknown digest OIDs, or CMS blobs
+     * missing `signed_attrs` / `messageDigest`.
+     */
+    verifyDetached(pdf_data: Uint8Array): boolean;
+    /**
+     * `/ContactInfo` entry from the signature dictionary, if present.
+     */
+    readonly contactInfo: string | undefined;
+    /**
+     * True iff `/ByteRange` is a 4-element array covering the whole
+     * document (i.e. the signature protects every byte of the file).
+     */
+    readonly coversWholeDocument: boolean;
+    /**
+     * `/Location` entry from the signature dictionary, if present.
+     */
+    readonly location: string | undefined;
+    /**
+     * `/Reason` entry from the signature dictionary, if present.
+     */
+    readonly reason: string | undefined;
+    /**
+     * `/Name` entry from the signature dictionary, if present.
+     */
+    readonly signerName: string | undefined;
+    /**
+     * Unix epoch (seconds). `None` if the `/M` entry is missing or
+     * unparseable.
+     */
+    readonly signingTime: bigint | undefined;
+}
+
+/**
+ * RFC 3161 timestamp parsed from a DER TimeStampToken or bare
+ * TSTInfo. Mirrors the C#, Go, and Python `Timestamp` surfaces.
+ */
+export class WasmTimestamp {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Parse a DER blob that may be either a full TimeStampToken or
+     * the bare TSTInfo SEQUENCE.
+     */
+    static parse(data: Uint8Array): WasmTimestamp;
+    /**
+     * Cryptographic verify — not yet implemented.
+     */
+    verify(): boolean;
+    /**
+     * Hash algorithm enum value (1=SHA1, 2=SHA256, 3=SHA384,
+     * 4=SHA512, 0=unknown).
+     */
+    readonly hashAlgorithm: number;
+    /**
+     * Raw message-imprint hash bytes.
+     */
+    readonly messageImprint: Uint8Array;
+    /**
+     * TSA policy OID in dotted-decimal form.
+     */
+    readonly policyOid: string;
+    /**
+     * Serial number as a hex string (no `0x` prefix).
+     */
+    readonly serial: string;
+    /**
+     * Generation time as Unix epoch seconds.
+     */
+    readonly time: bigint;
+    /**
+     * TSA name from the token (may be empty).
+     */
+    readonly tsaName: string;
+}
+
 /**
  * Disable all pdf_oxide log output — convenience wrapper for
  * `setLogLevel("off")`.

package/bundler/pdf_oxide.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./pdf_oxide.d.ts" */
+import * as wasm from "./pdf_oxide_bg.wasm";
+import { __wbg_set_wasm } from "./pdf_oxide_bg.js";
+
+__wbg_set_wasm(wasm);
+
+export {
+    ArtifactStyle, WasmArtifact, WasmCertificate, WasmDocumentBuilder, WasmEmbeddedFont, WasmFluentPageBuilder, WasmFooter, WasmHeader, WasmOcrConfig, WasmOcrEngine, WasmPageTemplate, WasmPdf, WasmPdfDocument, WasmPdfPageRegion, WasmSignature, WasmTimestamp, disableLogging, setLogLevel
+} from "./pdf_oxide_bg.js";