pdf-lite 1.4.0 → 1.6.0

package/dist/acroform/fields/{PdfTextFormField.js → pdf-text-form-field.js}

@@ -1,7 +1,6 @@
-import { PdfFormField } from './PdfFormField.js';
-import { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
-import { PdfTextAppearanceStream } from '../appearance/PdfTextAppearanceStream.js';
-import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfDefaultAppearance } from './pdf-default-appearance.js';
+import { PdfTextAppearanceStream } from '../appearance/pdf-text-appearance-stream.js';
 /**
  * Text form field subtype.
  */
@@ -21,14 +20,11 @@ export class PdfTextFormField extends PdfFormField {
         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({
+        const font = this.font;
+        const fontResources = this.buildFontResources(parsed.fontName);
+        const isUnicode = font?.isUnicode ?? false;
+        const reverseEncodingMap = font?.reverseEncodingMap;
+        this.setAppearanceStream(new PdfTextAppearanceStream({
             rect: rect,
             value: this.value,
             da: parsed,
@@ -36,7 +32,9 @@ export class PdfTextFormField extends PdfFormField {
             comb: this.comb,
             maxLen: this.maxLen,
             fontResources,
-        });
+            isUnicode,
+            reverseEncodingMap,
+        }));
         if (options?.makeReadOnly) {
             this.readOnly = true;
             if (!this.print)

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

@@ -1,4 +1,5 @@
-import type { PdfDefaultResourcesDictionary } from '../acroform.js';
+import { PdfDefaultResourcesDictionary } from '../../annotations/pdf-default-resources.js';
+import type { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
 /**
  * Field types for AcroForm fields
  */
@@ -17,5 +18,9 @@ export interface FormContext<TField = any> {
     defaultResources: PdfDefaultResourcesDictionary | null;
     defaultAppearance: string | null;
     fontEncodingMaps: Map<string, Map<number, string>>;
+    /** Object references for all resolved fonts, keyed by resource name. */
+    fontRefs: Map<string, PdfObjectReference>;
     fields: TField[];
+    isFontUnicode: (fontName: string) => boolean;
+    needAppearances: boolean;
 }

package/dist/acroform/index.d.ts

@@ -1,6 +1,4 @@
-export * from './manager.js';
-export * from './PdfAcroForm.js';
+export * from './pdf-acro-form.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,6 +1,4 @@
-export * from './manager.js';
-export * from './PdfAcroForm.js';
+export * from './pdf-acro-form.js';
 export * from './fields/index.js';
 export * from './appearance/index.js';
 export * from './xfa/index.js';
-export { PdfFontEncodingCache } from './PdfFontEncodingCache.js';

package/dist/acroform/pdf-acro-form.d.ts

@@ -0,0 +1,45 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.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 { PdfBoolean } from '../core/objects/pdf-boolean.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfFormField } from './fields/pdf-form-field.js';
+import './fields/pdf-text-form-field.js';
+import './fields/pdf-button-form-field.js';
+import './fields/pdf-choice-form-field.js';
+import './fields/pdf-signature-form-field.js';
+import { PdfDefaultResourcesDictionary } from '../annotations/pdf-default-resources.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+export declare class PdfAcroForm<T extends Record<string, string> = Record<string, string>> extends PdfIndirectObject<PdfDictionary<{
+    Fields: PdfArray<PdfObjectReference> | PdfObjectReference;
+    NeedAppearances?: PdfBoolean;
+    SigFlags?: PdfNumber;
+    CO?: PdfArray<PdfObjectReference>;
+    DR?: PdfDefaultResourcesDictionary;
+    DA?: PdfString;
+    Q?: PdfNumber;
+    XFA?: PdfArray<PdfObjectReference>;
+}>> {
+    constructor(options?: PdfIndirectObject);
+    get needAppearances(): boolean;
+    set needAppearances(value: boolean);
+    get signatureFlags(): number;
+    set signatureFlags(flags: number);
+    get defaultAppearance(): string | null;
+    set defaultAppearance(da: string);
+    get defaultQuadding(): number;
+    set defaultQuadding(q: number);
+    get defaultResources(): PdfDefaultResourcesDictionary | null;
+    set defaultResources(resources: PdfDefaultResourcesDictionary | null);
+    get fields(): ReadonlyArray<PdfFormField>;
+    addField(...fields: PdfFormField[]): void;
+    set fields(newFields: PdfFormField[]);
+    setValues(values: Partial<T>): void;
+    importData(fields: T): void;
+    exportData(): Partial<T>;
+    fontEncodingMaps: Map<string, Map<number, string>>;
+    getFontEncodingMap(fontName: string): Map<number, string> | null;
+    get xfa(): PdfXfaForm | null;
+}

package/dist/acroform/pdf-acro-form.js

@@ -0,0 +1,203 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.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 { PdfBoolean } from '../core/objects/pdf-boolean.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfFormField } from './fields/pdf-form-field.js';
+// Import subclasses to trigger static registration blocks
+import './fields/pdf-text-form-field.js';
+import './fields/pdf-button-form-field.js';
+import './fields/pdf-choice-form-field.js';
+import './fields/pdf-signature-form-field.js';
+import { buildEncodingMap } from '../utils/decodeWithFontEncoding.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+export class PdfAcroForm extends PdfIndirectObject {
+    constructor(options) {
+        super(options ??
+            new PdfIndirectObject({
+                content: new PdfDictionary(),
+            }));
+    }
+    get needAppearances() {
+        return (this.content.get('NeedAppearances')?.as(PdfBoolean)?.value ?? false);
+    }
+    set needAppearances(value) {
+        this.content.set('NeedAppearances', new PdfBoolean(value));
+    }
+    get signatureFlags() {
+        return this.content.get('SigFlags')?.as(PdfNumber)?.value ?? 0;
+    }
+    set signatureFlags(flags) {
+        this.content.set('SigFlags', new PdfNumber(flags));
+    }
+    get defaultAppearance() {
+        return this.content.get('DA')?.as(PdfString)?.value ?? null;
+    }
+    set defaultAppearance(da) {
+        this.content.set('DA', new PdfString(da));
+    }
+    get defaultQuadding() {
+        return this.content.get('Q')?.as(PdfNumber)?.value ?? 0;
+    }
+    set defaultQuadding(q) {
+        this.content.set('Q', new PdfNumber(q));
+    }
+    get defaultResources() {
+        return this.content.get('DR')?.as(PdfDictionary) ?? null;
+    }
+    set defaultResources(resources) {
+        if (resources === null) {
+            this.content.delete('DR');
+        }
+        else {
+            this.content.set('DR', resources);
+        }
+    }
+    get fields() {
+        const result = [];
+        const seen = new Set();
+        const collect = (refs) => {
+            for (const ref of refs) {
+                const key = ref.key;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const resolved = ref.resolve();
+                if (!(resolved?.content instanceof PdfDictionary))
+                    continue;
+                const dict = resolved.content;
+                const tEntry = dict.get('T');
+                const tValue = tEntry instanceof PdfString ? tEntry.value : null;
+                const hasFt = dict.has('FT');
+                if (tValue) {
+                    const field = PdfFormField.create(resolved);
+                    field.form = this;
+                    result.push(field);
+                }
+                // Only recurse into Kids for non-terminal (group) fields — those
+                // without FT. Terminal fields may have Kids that are pure widget
+                // annotations (no T) which would produce duplicate names.
+                if (!hasFt) {
+                    const kids = dict.get('Kids');
+                    if (kids instanceof PdfArray && kids.items.length > 0) {
+                        collect(kids.items);
+                    }
+                }
+            }
+        };
+        const fieldsRaw = this.content.get('Fields');
+        const resolvedFields = fieldsRaw instanceof PdfObjectReference
+            ? fieldsRaw.resolve()?.content
+            : fieldsRaw;
+        collect(resolvedFields instanceof PdfArray
+            ? resolvedFields.items
+            : []);
+        return result;
+    }
+    addField(...fields) {
+        const content = this.content;
+        const fieldsRaw = content.get('Fields');
+        let fieldsArray = fieldsRaw instanceof PdfObjectReference
+            ? fieldsRaw.resolve()?.content
+            : fieldsRaw;
+        if (!fieldsArray) {
+            fieldsArray = new PdfArray();
+            content.set('Fields', fieldsArray);
+        }
+        for (const field of fields) {
+            fieldsArray.items.push(field.reference);
+            // Auto-add to the page's Annots array
+            const page = field.page;
+            if (page) {
+                page.annotations.items.push(field.reference);
+            }
+        }
+    }
+    set fields(newFields) {
+        this.content.set('Fields', PdfArray.refs(newFields));
+    }
+    setValues(values) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name in values && values[name] !== undefined) {
+                field.value = values[name];
+            }
+        }
+    }
+    importData(fields) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name && name in fields) {
+                field.value = fields[name];
+            }
+        }
+    }
+    exportData() {
+        const result = {};
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name) {
+                result[name] = field.value;
+            }
+        }
+        return result;
+    }
+    fontEncodingMaps = new Map();
+    getFontEncodingMap(fontName) {
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
+        }
+        const dr = this.defaultResources;
+        const fontRaw = dr?.get('Font');
+        let fontDict;
+        if (fontRaw instanceof PdfObjectReference) {
+            const resolved = fontRaw.resolve()?.content;
+            if (resolved instanceof PdfDictionary)
+                fontDict = resolved;
+        }
+        else if (fontRaw instanceof PdfDictionary) {
+            fontDict = fontRaw;
+        }
+        if (!fontDict)
+            return null;
+        const fontEntry = fontDict.get(fontName);
+        if (!fontEntry)
+            return null;
+        let fontObj;
+        if (fontEntry instanceof PdfObjectReference) {
+            const resolved = fontEntry.resolve();
+            if (resolved?.content instanceof PdfDictionary) {
+                fontObj = resolved.content;
+            }
+        }
+        else if (fontEntry instanceof PdfDictionary) {
+            fontObj = fontEntry;
+        }
+        if (!fontObj)
+            return null;
+        let encObj = fontObj.get('Encoding');
+        if (encObj instanceof PdfObjectReference) {
+            encObj = encObj.resolve()?.content;
+        }
+        const encDict = encObj instanceof PdfDictionary ? encObj : undefined;
+        const diffs = encDict?.get('Differences')?.as(PdfArray);
+        if (!diffs)
+            return null;
+        const map = buildEncodingMap(diffs);
+        if (map) {
+            this.fontEncodingMaps.set(fontName, map);
+        }
+        return map;
+    }
+    get xfa() {
+        const xfaEntry = this.content.get('XFA');
+        if (!xfaEntry)
+            return null;
+        if (!(xfaEntry instanceof PdfArray)) {
+            return null;
+        }
+        return new PdfXfaForm(xfaEntry);
+    }
+}

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

@@ -1,3 +1,3 @@
-export { PdfXfaForm } from './PdfXfaForm.js';
-export { PdfXfaData } from './PdfXfaData.js';
-export type { XfaFieldData } from './PdfXfaData.js';
+export { PdfXfaForm } from './pdf-xfa-form.js';
+export { PdfXfaData } from './pdf-xfa-data.js';
+export type { XfaFieldData } from './pdf-xfa-data.js';

package/dist/acroform/xfa/index.js

@@ -1,2 +1,2 @@
-export { PdfXfaForm } from './PdfXfaForm.js';
-export { PdfXfaData } from './PdfXfaData.js';
+export { PdfXfaForm } from './pdf-xfa-form.js';
+export { PdfXfaData } from './pdf-xfa-data.js';

package/dist/acroform/xfa/{PdfXfaData.d.ts → pdf-xfa-data.d.ts}

@@ -9,12 +9,13 @@ export interface XfaFieldData {
  * 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;
+    constructor(stream: PdfIndirectObject);
+    get xml(): string;
+    set xml(xml: string);
     updateField(name: string, value: string): void;
     updateFields(fields: XfaFieldData[]): void;
     getFieldValue(name: string): string | null;
+    importData(fields: Record<string, string | undefined>): void;
     private static updateFieldValue;
     private static escapeRegex;
 }

package/dist/acroform/xfa/{PdfXfaData.js → pdf-xfa-data.js}

@@ -1,5 +1,4 @@
 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.
@@ -8,29 +7,26 @@ export class PdfXfaData extends PdfIndirectObject {
     constructor(stream) {
         super(stream);
     }
-    readXml() {
-        const decompressed = this.content.decode();
-        return new TextDecoder().decode(decompressed);
+    get xml() {
+        return this.content.dataAsString;
     }
-    writeXml(xml) {
-        this.content = PdfStream.fromString(xml);
+    set xml(xml) {
+        this.content.dataAsString = xml;
     }
     updateField(name, value) {
-        let xml = this.readXml();
-        xml = PdfXfaData.updateFieldValue(xml, name, value);
-        this.writeXml(xml);
+        this.xml = PdfXfaData.updateFieldValue(this.xml, name, value);
     }
     updateFields(fields) {
         if (fields.length === 0)
             return;
-        let xml = this.readXml();
+        let xml = this.xml;
         for (const { name, value } of fields) {
             xml = PdfXfaData.updateFieldValue(xml, name, value);
         }
-        this.writeXml(xml);
+        this.xml = xml;
     }
     getFieldValue(name) {
-        const xml = this.readXml();
+        const xml = this.xml;
         const segments = name.split('.');
         const leafSegment = segments[segments.length - 1];
         const leafName = leafSegment.replace(/\[\d+\]$/, '');
@@ -40,6 +36,14 @@ export class PdfXfaData extends PdfIndirectObject {
         const match = xml.match(contentRegex);
         return match ? match[1] : null;
     }
+    importData(fields) {
+        for (const field in fields) {
+            const value = fields[field];
+            if (value === undefined)
+                continue;
+            this.updateField(field, value);
+        }
+    }
     static updateFieldValue(xml, fieldName, value) {
         const segments = fieldName.split('.');
         const leafSegment = segments[segments.length - 1];

package/dist/acroform/xfa/pdf-xfa-form.d.ts

@@ -0,0 +1,16 @@
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfXfaData } from './pdf-xfa-data.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export declare class PdfXfaForm {
+    private xfaEntry?;
+    constructor(xfaEntry?: PdfArray<PdfObjectReference>);
+    get components(): {
+        [type: string]: PdfIndirectObject;
+    };
+    get datasets(): PdfXfaData | null;
+}

package/dist/acroform/xfa/pdf-xfa-form.js

@@ -0,0 +1,34 @@
+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 './pdf-xfa-data.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export class PdfXfaForm {
+    xfaEntry;
+    constructor(xfaEntry) {
+        this.xfaEntry = xfaEntry;
+    }
+    get components() {
+        const result = {};
+        const items = this.xfaEntry?.items ?? [];
+        for (let i = 0; i < items.length - 1; i += 2) {
+            const name = items[i];
+            const ref = items[i + 1];
+            if (name instanceof PdfString &&
+                ref instanceof PdfObjectReference) {
+                result[name.value] = ref.resolve().as(PdfIndirectObject);
+            }
+        }
+        return result;
+    }
+    get datasets() {
+        const datasetsRef = this.components['datasets'];
+        if (!datasetsRef) {
+            return null;
+        }
+        return datasetsRef.becomes(PdfXfaData);
+    }
+}

package/dist/annotations/index.d.ts

@@ -1,4 +1,3 @@
-export { PdfAnnotation, type PdfAppearanceStreamDictionary, } from './PdfAnnotation.js';
-export { PdfAnnotationFlags } from './PdfAnnotationFlags.js';
-export { PdfWidgetAnnotation } from './PdfWidgetAnnotation.js';
-export { PdfAnnotationWriter } from './PdfAnnotationWriter.js';
+export { PdfAnnotation, type PdfAppearanceStreamDictionary, } from './pdf-annotation.js';
+export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';

package/dist/annotations/index.js

@@ -1,4 +1,3 @@
-export { PdfAnnotation, } from './PdfAnnotation.js';
-export { PdfAnnotationFlags } from './PdfAnnotationFlags.js';
-export { PdfWidgetAnnotation } from './PdfWidgetAnnotation.js';
-export { PdfAnnotationWriter } from './PdfAnnotationWriter.js';
+export { PdfAnnotation, } from './pdf-annotation.js';
+export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';

package/dist/annotations/{PdfAnnotationFlags.d.ts → pdf-annotation-flags.d.ts}

@@ -1,11 +1,10 @@
-import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+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 declare class PdfAnnotationFlags {
-    readonly dict: PdfDictionary;
-    constructor(dict: PdfDictionary);
+export declare class PdfAnnotationFlags extends PdfNumber {
+    constructor(value?: number);
     get annotationFlags(): number;
     set annotationFlags(flags: number);
     get invisible(): boolean;

package/dist/annotations/{PdfAnnotationFlags.js → pdf-annotation-flags.js}

@@ -3,16 +3,15 @@ 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;
+export class PdfAnnotationFlags extends PdfNumber {
+    constructor(value = 0) {
+        super(value);
     }
     get annotationFlags() {
-        return this.dict.get('F')?.as(PdfNumber)?.value ?? 0;
+        return this.value;
     }
     set annotationFlags(flags) {
-        this.dict.set('F', new PdfNumber(flags));
+        this.value = flags;
     }
     get invisible() {
         return (this.annotationFlags & 1) !== 0;

package/dist/annotations/{PdfAnnotation.d.ts → pdf-annotation.d.ts}

@@ -1,6 +1,11 @@
 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 { PdfName } from '../core/objects/pdf-name.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfPage } from '../pdf/pdf-page.js';
 export type PdfAppearanceStreamDictionary = PdfDictionary<{
     N: PdfObjectReference | PdfDictionary;
     R?: PdfObjectReference | PdfDictionary;
@@ -8,15 +13,35 @@ export type PdfAppearanceStreamDictionary = 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;
+export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
+    Type: PdfName;
+    Subtype: PdfName;
+    AS: PdfName;
+    Ff: PdfNumber;
+    FT: PdfName;
+    T: PdfString;
+    DV: PdfString | PdfName;
+    V: PdfString | PdfName;
+    DA: PdfString;
+    DR: PdfDictionary | PdfObjectReference;
+    Opt: PdfArray<PdfString | PdfArray<PdfString>> | PdfObjectReference;
+    MaxLen: PdfNumber;
+    Q: PdfNumber;
+    Kids: PdfArray<PdfObjectReference>;
+    Rect: PdfArray<PdfNumber>;
+    F: PdfNumber;
+    AP?: PdfAppearanceStreamDictionary;
+    P?: PdfObjectReference;
+    Parent?: PdfObjectReference<PdfPage>;
+}>> {
+    private _annotationFlags?;
+    private get flags_();
     constructor(options?: {
         other?: PdfIndirectObject;
     });
-    get rect(): number[] | null;
-    set rect(rect: number[] | null);
+    get rect(): [number, number, number, number] | null;
+    set rect(rect: [number, number, number, number] | null);
     get annotationFlags(): number;
     set annotationFlags(flags: number);
     get invisible(): boolean;
@@ -37,4 +62,5 @@ export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary> {
     set appearanceStreamDict(dict: PdfAppearanceStreamDictionary | null);
     get parentRef(): PdfObjectReference | null;
     set parentRef(ref: PdfObjectReference | null);
+    get page(): PdfPage | null;
 }