pdf-lite 1.3.2 → 1.4.0

package/dist/acroform/fields/PdfTextFormField.js

@@ -0,0 +1,52 @@
+import { PdfFormField } from './PdfFormField.js';
+import { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
+import { PdfTextAppearanceStream } from '../appearance/PdfTextAppearanceStream.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+/**
+ * Text form field subtype.
+ */
+export class PdfTextFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Tx', PdfTextFormField, {
+            fallback: true,
+        });
+    }
+    generateAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const da = this.defaultAppearance;
+        if (!da)
+            return false;
+        const parsed = PdfDefaultAppearance.parse(da);
+        if (!parsed)
+            return false;
+        let fontResources;
+        const drFontValue = this.form?.defaultResources?.get('Font');
+        const drFonts = drFontValue instanceof PdfDictionary ? drFontValue : undefined;
+        if (drFonts) {
+            fontResources = new PdfDictionary();
+            fontResources.set('Font', drFonts);
+        }
+        this._appearanceStream = new PdfTextAppearanceStream({
+            rect: rect,
+            value: this.value,
+            da: parsed,
+            multiline: this.multiline,
+            comb: this.comb,
+            maxLen: this.maxLen,
+            fontResources,
+        });
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            if (!this.print)
+                this.print = true;
+            this.noZoom = true;
+        }
+        else {
+            if (!this.print)
+                this.print = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/index.d.ts

@@ -0,0 +1,8 @@
+export { PdfFormField, PdfAcroFormField } from './PdfFormField.js';
+export { PdfFormFieldFlags } from './PdfFormFieldFlags.js';
+export { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
+export { PdfTextFormField } from './PdfTextFormField.js';
+export { PdfButtonFormField } from './PdfButtonFormField.js';
+export { PdfChoiceFormField } from './PdfChoiceFormField.js';
+export { PdfSignatureFormField } from './PdfSignatureFormField.js';
+export { PdfFieldType, type FormContext } from './types.js';

package/dist/acroform/fields/index.js

@@ -0,0 +1,8 @@
+export { PdfFormField, PdfAcroFormField } from './PdfFormField.js';
+export { PdfFormFieldFlags } from './PdfFormFieldFlags.js';
+export { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
+export { PdfTextFormField } from './PdfTextFormField.js';
+export { PdfButtonFormField } from './PdfButtonFormField.js';
+export { PdfChoiceFormField } from './PdfChoiceFormField.js';
+export { PdfSignatureFormField } from './PdfSignatureFormField.js';
+export { PdfFieldType } from './types.js';

package/dist/acroform/fields/types.d.ts

@@ -0,0 +1,21 @@
+import type { PdfDefaultResourcesDictionary } from '../acroform.js';
+/**
+ * Field types for AcroForm fields
+ */
+export declare const PdfFieldType: {
+    readonly Text: "Tx";
+    readonly Button: "Btn";
+    readonly Choice: "Ch";
+    readonly Signature: "Sig";
+};
+export type PdfFieldType = keyof typeof PdfFieldType;
+/**
+ * Interface that PdfAcroForm implements, used by PdfFormField to avoid circular imports.
+ * Uses generic field type to avoid circular dependency.
+ */
+export interface FormContext<TField = any> {
+    defaultResources: PdfDefaultResourcesDictionary | null;
+    defaultAppearance: string | null;
+    fontEncodingMaps: Map<string, Map<number, string>>;
+    fields: TField[];
+}

package/dist/acroform/fields/types.js

@@ -0,0 +1,9 @@
+/**
+ * Field types for AcroForm fields
+ */
+export const PdfFieldType = {
+    Text: 'Tx',
+    Button: 'Btn',
+    Choice: 'Ch',
+    Signature: 'Sig',
+};

package/dist/acroform/index.d.ts

@@ -1,2 +1,6 @@
 export * from './manager.js';
-export * from './acroform.js';
+export * from './PdfAcroForm.js';
+export * from './fields/index.js';
+export * from './appearance/index.js';
+export * from './xfa/index.js';
+export { PdfFontEncodingCache } from './PdfFontEncodingCache.js';

package/dist/acroform/index.js

@@ -1,2 +1,6 @@
 export * from './manager.js';
-export * from './acroform.js';
+export * from './PdfAcroForm.js';
+export * from './fields/index.js';
+export * from './appearance/index.js';
+export * from './xfa/index.js';
+export { PdfFontEncodingCache } from './PdfFontEncodingCache.js';

package/dist/acroform/manager.d.ts

@@ -1,12 +1,19 @@
 import { PdfDocument } from '../pdf/pdf-document.js';
 import { PdfAcroForm } from './acroform.js';
+import { PdfXfaForm } from './xfa/PdfXfaForm.js';
 /**
  * Manages AcroForm fields in PDF documents.
  * Provides methods to read and write form field values.
  */
 export declare class PdfAcroFormManager {
     private document;
+    private _xfa;
     constructor(document: PdfDocument);
+    /**
+     * Gets the XFA form wrapper, loading it lazily on first access.
+     * @returns The PdfXfaForm or null if no XFA forms exist
+     */
+    getXfa(): Promise<PdfXfaForm | null>;
     /**
      * Checks if the document contains AcroForm fields.
      * @returns True if the document has AcroForm fields, false otherwise

package/dist/acroform/manager.js

@@ -1,13 +1,25 @@
 import { PdfAcroForm } from './acroform.js';
+import { PdfXfaForm } from './xfa/PdfXfaForm.js';
 /**
  * Manages AcroForm fields in PDF documents.
  * Provides methods to read and write form field values.
  */
 export class PdfAcroFormManager {
     document;
+    _xfa = undefined;
     constructor(document) {
         this.document = document;
     }
+    /**
+     * Gets the XFA form wrapper, loading it lazily on first access.
+     * @returns The PdfXfaForm or null if no XFA forms exist
+     */
+    async getXfa() {
+        if (this._xfa === undefined) {
+            this._xfa = await PdfXfaForm.fromDocument(this.document);
+        }
+        return this._xfa;
+    }
     /**
      * Checks if the document contains AcroForm fields.
      * @returns True if the document has AcroForm fields, false otherwise

package/dist/acroform/xfa/PdfXfaData.d.ts

@@ -0,0 +1,20 @@
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+export interface XfaFieldData {
+    name: string;
+    value: string;
+}
+/**
+ * Wraps an XFA datasets stream as a typed PDF indirect object.
+ * Provides methods to read/write XML and update individual field values.
+ */
+export declare class PdfXfaData extends PdfIndirectObject<PdfStream> {
+    constructor(stream: PdfIndirectObject<PdfStream>);
+    readXml(): string;
+    writeXml(xml: string): void;
+    updateField(name: string, value: string): void;
+    updateFields(fields: XfaFieldData[]): void;
+    getFieldValue(name: string): string | null;
+    private static updateFieldValue;
+    private static escapeRegex;
+}

package/dist/acroform/xfa/PdfXfaData.js

@@ -0,0 +1,68 @@
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+/**
+ * Wraps an XFA datasets stream as a typed PDF indirect object.
+ * Provides methods to read/write XML and update individual field values.
+ */
+export class PdfXfaData extends PdfIndirectObject {
+    constructor(stream) {
+        super(stream);
+    }
+    readXml() {
+        const decompressed = this.content.decode();
+        return new TextDecoder().decode(decompressed);
+    }
+    writeXml(xml) {
+        this.content = PdfStream.fromString(xml);
+    }
+    updateField(name, value) {
+        let xml = this.readXml();
+        xml = PdfXfaData.updateFieldValue(xml, name, value);
+        this.writeXml(xml);
+    }
+    updateFields(fields) {
+        if (fields.length === 0)
+            return;
+        let xml = this.readXml();
+        for (const { name, value } of fields) {
+            xml = PdfXfaData.updateFieldValue(xml, name, value);
+        }
+        this.writeXml(xml);
+    }
+    getFieldValue(name) {
+        const xml = this.readXml();
+        const segments = name.split('.');
+        const leafSegment = segments[segments.length - 1];
+        const leafName = leafSegment.replace(/\[\d+\]$/, '');
+        if (leafName.startsWith('#'))
+            return null;
+        const contentRegex = new RegExp(`<${PdfXfaData.escapeRegex(leafName)}(?:\\s[^>]*)?>([\\s\\S]*?)</${PdfXfaData.escapeRegex(leafName)}\\s*>`);
+        const match = xml.match(contentRegex);
+        return match ? match[1] : null;
+    }
+    static updateFieldValue(xml, fieldName, value) {
+        const segments = fieldName.split('.');
+        const leafSegment = segments[segments.length - 1];
+        const leafName = leafSegment.replace(/\[\d+\]$/, '');
+        if (leafName.startsWith('#'))
+            return xml;
+        const escapedValue = value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+        const selfClosingRegex = new RegExp(`<${PdfXfaData.escapeRegex(leafName)}\\s*/>`);
+        if (selfClosingRegex.test(xml)) {
+            return xml.replace(selfClosingRegex, `<${leafName}>${escapedValue}</${leafName}>`);
+        }
+        const contentRegex = new RegExp(`(<${PdfXfaData.escapeRegex(leafName)}(?:\\s[^>]*)?>)[\\s\\S]*?(</${PdfXfaData.escapeRegex(leafName)}\\s*>)`);
+        if (contentRegex.test(xml)) {
+            return xml.replace(contentRegex, `$1${escapedValue}$2`);
+        }
+        return xml;
+    }
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}

package/dist/acroform/xfa/PdfXfaForm.d.ts

@@ -0,0 +1,12 @@
+import { PdfDocument } from '../../pdf/pdf-document.js';
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfXfaData } from './PdfXfaData.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export declare class PdfXfaForm extends PdfArray {
+    datasets: PdfXfaData | null;
+    static fromDocument(document: PdfDocument): Promise<PdfXfaForm | null>;
+    write(document: PdfDocument): void;
+}

package/dist/acroform/xfa/PdfXfaForm.js

@@ -0,0 +1,64 @@
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfXfaData } from './PdfXfaData.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export class PdfXfaForm extends PdfArray {
+    datasets = null;
+    static async fromDocument(document) {
+        const catalog = document.root;
+        const acroFormRef = catalog.content.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        let acroFormDict;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await document.readObject({
+                objectNumber: acroFormRef.objectNumber,
+                generationNumber: acroFormRef.generationNumber,
+            });
+            if (!acroFormObject)
+                return null;
+            acroFormDict = acroFormObject.content.as(PdfDictionary);
+        }
+        else if (acroFormRef instanceof PdfDictionary) {
+            acroFormDict = acroFormRef;
+        }
+        else {
+            return null;
+        }
+        const xfaArray = acroFormDict.get('XFA');
+        if (!(xfaArray instanceof PdfArray))
+            return null;
+        const form = new PdfXfaForm(xfaArray.items.slice());
+        // Find the datasets reference in the name/ref pairs
+        const items = xfaArray.items;
+        for (let i = 0; i < items.length - 1; i += 2) {
+            const name = items[i];
+            const ref = items[i + 1];
+            if (name instanceof PdfString &&
+                name.value === 'datasets' &&
+                ref instanceof PdfObjectReference) {
+                const datasetObject = (await document.readObject({
+                    objectNumber: ref.objectNumber,
+                    generationNumber: ref.generationNumber,
+                    allowUnindexed: true,
+                }))?.as((PdfIndirectObject));
+                if (datasetObject) {
+                    form.datasets = new PdfXfaData(datasetObject);
+                }
+                break;
+            }
+        }
+        return form;
+    }
+    write(document) {
+        if (this.datasets?.isModified()) {
+            document.add(this.datasets);
+        }
+    }
+}

package/dist/acroform/xfa/index.d.ts

@@ -0,0 +1,3 @@
+export { PdfXfaForm } from './PdfXfaForm.js';
+export { PdfXfaData } from './PdfXfaData.js';
+export type { XfaFieldData } from './PdfXfaData.js';

package/dist/acroform/xfa/index.js

@@ -0,0 +1,2 @@
+export { PdfXfaForm } from './PdfXfaForm.js';
+export { PdfXfaData } from './PdfXfaData.js';

package/dist/annotations/PdfAnnotation.d.ts

@@ -0,0 +1,40 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+export type PdfAppearanceStreamDictionary = PdfDictionary<{
+    N: PdfObjectReference | PdfDictionary;
+    R?: PdfObjectReference | PdfDictionary;
+    D?: PdfObjectReference | PdfDictionary;
+}>;
+/**
+ * Base class for all PDF annotations.
+ * Owns: Rect, annotation flags (F), AP (appearance streams), P (page reference).
+ */
+export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary> {
+    private _annotationFlags;
+    constructor(options?: {
+        other?: PdfIndirectObject;
+    });
+    get rect(): number[] | null;
+    set rect(rect: number[] | null);
+    get annotationFlags(): number;
+    set annotationFlags(flags: number);
+    get invisible(): boolean;
+    set invisible(value: boolean);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get print(): boolean;
+    set print(value: boolean);
+    get noZoom(): boolean;
+    set noZoom(value: boolean);
+    get noRotate(): boolean;
+    set noRotate(value: boolean);
+    get noView(): boolean;
+    set noView(value: boolean);
+    get locked(): boolean;
+    set locked(value: boolean);
+    get appearanceStreamDict(): PdfAppearanceStreamDictionary | null;
+    set appearanceStreamDict(dict: PdfAppearanceStreamDictionary | null);
+    get parentRef(): PdfObjectReference | null;
+    set parentRef(ref: PdfObjectReference | null);
+}

package/dist/annotations/PdfAnnotation.js

@@ -0,0 +1,105 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfAnnotationFlags } from './PdfAnnotationFlags.js';
+/**
+ * Base class for all PDF annotations.
+ * Owns: Rect, annotation flags (F), AP (appearance streams), P (page reference).
+ */
+export class PdfAnnotation extends PdfIndirectObject {
+    _annotationFlags;
+    constructor(options) {
+        super(options?.other ??
+            new PdfIndirectObject({ content: new PdfDictionary() }));
+        this._annotationFlags = new PdfAnnotationFlags(this.content);
+    }
+    get rect() {
+        const rectArray = this.content.get('Rect')?.as((PdfArray));
+        if (!rectArray)
+            return null;
+        return rectArray.items.map((num) => num.value);
+    }
+    set rect(rect) {
+        if (rect === null) {
+            this.content.delete('Rect');
+            return;
+        }
+        const rectArray = new PdfArray(rect.map((num) => new PdfNumber(num)));
+        this.content.set('Rect', rectArray);
+    }
+    get annotationFlags() {
+        return this._annotationFlags.annotationFlags;
+    }
+    set annotationFlags(flags) {
+        this._annotationFlags.annotationFlags = flags;
+    }
+    get invisible() {
+        return this._annotationFlags.invisible;
+    }
+    set invisible(value) {
+        this._annotationFlags.invisible = value;
+    }
+    get hidden() {
+        return this._annotationFlags.hidden;
+    }
+    set hidden(value) {
+        this._annotationFlags.hidden = value;
+    }
+    get print() {
+        return this._annotationFlags.print;
+    }
+    set print(value) {
+        this._annotationFlags.print = value;
+    }
+    get noZoom() {
+        return this._annotationFlags.noZoom;
+    }
+    set noZoom(value) {
+        this._annotationFlags.noZoom = value;
+    }
+    get noRotate() {
+        return this._annotationFlags.noRotate;
+    }
+    set noRotate(value) {
+        this._annotationFlags.noRotate = value;
+    }
+    get noView() {
+        return this._annotationFlags.noView;
+    }
+    set noView(value) {
+        this._annotationFlags.noView = value;
+    }
+    get locked() {
+        return this._annotationFlags.locked;
+    }
+    set locked(value) {
+        this._annotationFlags.locked = value;
+    }
+    get appearanceStreamDict() {
+        const apDict = this.content.get('AP')?.as(PdfDictionary);
+        if (!apDict)
+            return null;
+        return apDict;
+    }
+    set appearanceStreamDict(dict) {
+        if (dict === null) {
+            this.content.delete('AP');
+            return;
+        }
+        this.content.set('AP', dict);
+    }
+    get parentRef() {
+        const ref = this.content.get('P')?.as(PdfObjectReference);
+        return ref ?? null;
+    }
+    set parentRef(ref) {
+        if (ref === null) {
+            this.content.delete('P');
+        }
+        else {
+            this.content.set('P', ref);
+        }
+    }
+}

package/dist/annotations/PdfAnnotationFlags.d.ts

@@ -0,0 +1,25 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+/**
+ * Provides annotation flag (F field) accessors for PDF annotations.
+ * These are generic to all annotation types per the PDF spec.
+ */
+export declare class PdfAnnotationFlags {
+    readonly dict: PdfDictionary;
+    constructor(dict: PdfDictionary);
+    get annotationFlags(): number;
+    set annotationFlags(flags: number);
+    get invisible(): boolean;
+    set invisible(value: boolean);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get print(): boolean;
+    set print(value: boolean);
+    get noZoom(): boolean;
+    set noZoom(value: boolean);
+    get noRotate(): boolean;
+    set noRotate(value: boolean);
+    get noView(): boolean;
+    set noView(value: boolean);
+    get locked(): boolean;
+    set locked(value: boolean);
+}

package/dist/annotations/PdfAnnotationFlags.js

@@ -0,0 +1,94 @@
+import { PdfNumber } from '../core/objects/pdf-number.js';
+/**
+ * Provides annotation flag (F field) accessors for PDF annotations.
+ * These are generic to all annotation types per the PDF spec.
+ */
+export class PdfAnnotationFlags {
+    dict;
+    constructor(dict) {
+        this.dict = dict;
+    }
+    get annotationFlags() {
+        return this.dict.get('F')?.as(PdfNumber)?.value ?? 0;
+    }
+    set annotationFlags(flags) {
+        this.dict.set('F', new PdfNumber(flags));
+    }
+    get invisible() {
+        return (this.annotationFlags & 1) !== 0;
+    }
+    set invisible(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 1;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~1;
+        }
+    }
+    get hidden() {
+        return (this.annotationFlags & 2) !== 0;
+    }
+    set hidden(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 2;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~2;
+        }
+    }
+    get print() {
+        return (this.annotationFlags & 4) !== 0;
+    }
+    set print(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 4;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~4;
+        }
+    }
+    get noZoom() {
+        return (this.annotationFlags & 8) !== 0;
+    }
+    set noZoom(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 8;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~8;
+        }
+    }
+    get noRotate() {
+        return (this.annotationFlags & 16) !== 0;
+    }
+    set noRotate(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 16;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~16;
+        }
+    }
+    get noView() {
+        return (this.annotationFlags & 32) !== 0;
+    }
+    set noView(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 32;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~32;
+        }
+    }
+    get locked() {
+        return (this.annotationFlags & 128) !== 0;
+    }
+    set locked(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 128;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~128;
+        }
+    }
+}

package/dist/annotations/PdfAnnotationWriter.d.ts

@@ -0,0 +1,20 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+/**
+ * Manages page Annots arrays during AcroForm write operations.
+ */
+export declare class PdfAnnotationWriter {
+    static getPageAnnotsArray(document: PdfDocument, pageDict: PdfDictionary): Promise<{
+        annotsArray: PdfArray<PdfObjectReference>;
+        isIndirect: boolean;
+        objectNumber?: number;
+        generationNumber?: number;
+    }>;
+    static addFieldsToAnnots(annotsArray: PdfArray<PdfObjectReference>, fieldRefs: PdfObjectReference[]): void;
+    static updatePageAnnotations(document: PdfDocument, fieldsByPage: Map<string, {
+        pageRef: PdfObjectReference;
+        fieldRefs: PdfObjectReference[];
+    }>): Promise<void>;
+}