pdf-lite 1.4.0 → 1.5.0

package/dist/acroform/{PdfAcroForm.js → pdf-acro-form.js}

@@ -5,19 +5,20 @@ 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 { PdfFontEncodingCache } from './PdfFontEncodingCache.js';
-import { PdfAnnotationWriter } from '../annotations/PdfAnnotationWriter.js';
-import { PdfXfaForm } from './xfa/PdfXfaForm.js';
-import { PdfFormField } from './fields/PdfFormField.js';
+import { PdfFontEncodingCache } from './pdf-font-encoding-cache.js';
+import { PdfAnnotationWriter } from '../annotations/pdf-annotation-writer.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+import { PdfFormField } from './fields/pdf-form-field.js';
 // Import subclasses to trigger static registration blocks
-import './fields/PdfTextFormField.js';
-import './fields/PdfButtonFormField.js';
-import './fields/PdfChoiceFormField.js';
-import './fields/PdfSignatureFormField.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';
 export class PdfAcroForm extends PdfIndirectObject {
     fields;
     _fontEncodingCache;
     document;
+    _xfa; // undefined = not set; null = explicitly no XFA
     constructor(options) {
         super(options?.other ??
             new PdfIndirectObject({
@@ -35,6 +36,12 @@ export class PdfAcroForm extends PdfIndirectObject {
     get fontEncodingMaps() {
         return this.fontEncodingCache.fontEncodingMaps;
     }
+    get fontRefs() {
+        return this.fontEncodingCache.fontRefs;
+    }
+    setXfa(xfa) {
+        this._xfa = xfa;
+    }
     isModified() {
         return this.content.isModified();
     }
@@ -102,6 +109,9 @@ export class PdfAcroForm extends PdfIndirectObject {
     async getFontEncodingMap(fontName) {
         return this.fontEncodingCache.getFontEncodingMap(fontName);
     }
+    isFontUnicode(fontName) {
+        return this.fontEncodingCache.isFontUnicode(fontName);
+    }
     static async fromDocument(document) {
         const catalog = document.root;
         if (!catalog)
@@ -112,10 +122,7 @@ export class PdfAcroForm extends PdfIndirectObject {
         let acroFormDict;
         let acroFormContainer;
         if (acroFormRef instanceof PdfObjectReference) {
-            const acroFormObject = await document.readObject({
-                objectNumber: acroFormRef.objectNumber,
-                generationNumber: acroFormRef.generationNumber,
-            });
+            const acroFormObject = await document.readObject(acroFormRef);
             if (!acroFormObject)
                 return null;
             if (!(acroFormObject.content instanceof PdfDictionary))
@@ -131,8 +138,6 @@ export class PdfAcroForm extends PdfIndirectObject {
             return null;
         }
         const acroForm = new PdfAcroForm({ other: acroFormContainer, document });
-        // Pre-cache font encoding maps for all fonts used in fields
-        await acroForm.cacheAllFontEncodings();
         const fields = new Map();
         const getFields = async (fieldRefs, parent) => {
             for (const fieldRef of fieldRefs) {
@@ -141,10 +146,7 @@ export class PdfAcroForm extends PdfIndirectObject {
                     fields.get(refKey).parent = parent;
                     continue;
                 }
-                const fieldObject = await document.readObject({
-                    objectNumber: fieldRef.objectNumber,
-                    generationNumber: fieldRef.generationNumber,
-                });
+                const fieldObject = await document.readObject(fieldRef);
                 if (!fieldObject)
                     continue;
                 if (!(fieldObject.content instanceof PdfDictionary))
@@ -169,19 +171,14 @@ export class PdfAcroForm extends PdfIndirectObject {
                 .as((PdfArray)).items);
         }
         else if (acroForm.content.get('Fields') instanceof PdfObjectReference) {
-            const fieldsObj = await document.readObject({
-                objectNumber: acroForm.content
-                    .get('Fields')
-                    .as(PdfObjectReference).objectNumber,
-                generationNumber: acroForm.content
-                    .get('Fields')
-                    .as(PdfObjectReference).generationNumber,
-            });
+            const fieldsObj = await document.readObject(acroForm.content.get('Fields').as(PdfObjectReference));
             if (fieldsObj && fieldsObj.content instanceof PdfArray) {
                 fieldsArray.items.push(...fieldsObj.content.as((PdfArray)).items);
             }
         }
         await getFields(fieldsArray.items);
+        // Pre-cache font encoding maps now that this.fields is populated
+        await acroForm.cacheAllFontEncodings();
         // Reset field-level modified flag so only explicitly changed fields are detected
         for (const field of acroForm.fields) {
             field.setModified(false);
@@ -194,11 +191,28 @@ export class PdfAcroForm extends PdfIndirectObject {
     async updatePageAnnotations(document, fieldsByPage) {
         await PdfAnnotationWriter.updatePageAnnotations(document, fieldsByPage);
     }
+    async getXfa(document) {
+        if (this._xfa) {
+            return this._xfa;
+        }
+        const doc = document || this.document;
+        if (!doc) {
+            throw new Error('No document available to load XFA form. Provide a document or ensure this AcroForm is associated with a document.');
+        }
+        this._xfa = await PdfXfaForm.fromDocument(doc);
+        return this._xfa;
+    }
     async write(document) {
+        document ||= this.document;
+        if (!document) {
+            throw new Error('No document associated with this AcroForm');
+        }
         const catalog = document.root;
         const isIncremental = document.isIncremental();
         document.setIncremental(true);
-        const xfaForm = await PdfXfaForm.fromDocument(document);
+        const xfaForm = this._xfa !== undefined
+            ? this._xfa
+            : await PdfXfaForm.fromDocument(document);
         if (xfaForm) {
             // Only send fields whose value was explicitly changed (field.isModified())
             const xfaFields = this.fields
@@ -270,8 +284,8 @@ export class PdfAcroForm extends PdfIndirectObject {
             }
         }
         // XFA datasets stream — PdfXfaData extends PdfIndirectObject<PdfStream>, must stay standalone
-        if (xfaForm) {
-            xfaForm.write(document);
+        if (xfaForm?.datasets?.isModified()) {
+            document.add(xfaForm.datasets);
         }
         await document.commit();
         document.setIncremental(isIncremental);

package/dist/acroform/{PdfFontEncodingCache.d.ts → pdf-font-encoding-cache.d.ts}

@@ -1,11 +1,15 @@
 import { PdfDocument } from '../pdf/pdf-document.js';
 import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
 import type { PdfDefaultResourcesDictionary } from './acroform.js';
 /**
  * Resolves and caches font encoding maps from the form's default resources.
  */
 export declare class PdfFontEncodingCache {
     readonly fontEncodingMaps: Map<string, Map<number, string>>;
+    readonly fontTypes: Map<string, string>;
+    /** Object references for all resolved fonts, keyed by resource name. */
+    readonly fontRefs: Map<string, PdfObjectReference>;
     private document?;
     private defaultResources;
     constructor(document: PdfDocument | undefined, defaultResources: PdfDefaultResourcesDictionary | null);
@@ -13,4 +17,11 @@ export declare class PdfFontEncodingCache {
     cacheAllFontEncodings(fields: Array<{
         content: PdfDictionary;
     }>): Promise<void>;
+    /**
+     * Walks the page-tree (page → parent → … → Pages root), looking for the
+     * font in each node's /Resources/Font dict. Stops as soon as it finds the
+     * font. PDF resource inheritance means any ancestor can supply the font.
+     */
+    private resolveFontFromPage;
+    isFontUnicode(fontName: string): boolean;
 }

package/dist/acroform/pdf-font-encoding-cache.js

@@ -0,0 +1,188 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { buildEncodingMap } from '../utils/decodeWithFontEncoding.js';
+/**
+ * Resolves and caches font encoding maps from the form's default resources.
+ */
+export class PdfFontEncodingCache {
+    fontEncodingMaps = new Map();
+    fontTypes = new Map();
+    /** Object references for all resolved fonts, keyed by resource name. */
+    fontRefs = new Map();
+    document;
+    defaultResources;
+    constructor(document, defaultResources) {
+        this.document = document;
+        this.defaultResources = defaultResources;
+    }
+    async getFontEncodingMap(fontName) {
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
+        }
+        const dr = this.defaultResources;
+        if (!dr)
+            return null;
+        const fontDictEntry = dr.get('Font');
+        const fonts = fontDictEntry instanceof PdfDictionary ? fontDictEntry : null;
+        if (!fonts)
+            return null;
+        const fontEntry = fonts.get(fontName);
+        const fontRef = fontEntry instanceof PdfObjectReference ? fontEntry : null;
+        if (!fontRef)
+            return null;
+        this.fontRefs.set(fontName, fontRef);
+        const fontObj = await this.document?.readObject(fontRef);
+        if (!fontObj)
+            return null;
+        const fontDict = fontObj.content instanceof PdfDictionary ? fontObj.content : null;
+        if (!fontDict)
+            return null;
+        // Cache font subtype (Type0, TrueType, Type1, etc.)
+        const subtypeEntry = fontDict.get('Subtype');
+        const subtype = subtypeEntry instanceof PdfName ? subtypeEntry.value : undefined;
+        if (subtype) {
+            this.fontTypes.set(fontName, subtype);
+        }
+        const encoding = fontDict.get('Encoding');
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document?.readObject(encoding);
+            encodingDict =
+                encodingObj?.content instanceof PdfDictionary
+                    ? encodingObj.content
+                    : null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict)
+            return null;
+        const differences = encodingDict.get('Differences')?.as(PdfArray);
+        if (!differences)
+            return null;
+        const encodingMap = buildEncodingMap(differences);
+        if (!encodingMap)
+            return null;
+        this.fontEncodingMaps.set(fontName, encodingMap);
+        return encodingMap;
+    }
+    async cacheAllFontEncodings(fields) {
+        // Collect font names with an associated page ref for the first field
+        // that uses them (needed to fall back to page resources).
+        const fontPageRefs = new Map();
+        for (const field of fields) {
+            const daEntry = field.content.get('DA');
+            const da = daEntry instanceof PdfString ? daEntry.value : undefined;
+            if (da) {
+                const fontMatch = da.match(/\/(\w+)\s+[\d.]+\s+Tf/);
+                if (fontMatch) {
+                    const fontName = fontMatch[1];
+                    if (!fontPageRefs.has(fontName)) {
+                        const pageEntry = field.content.get('P');
+                        const pageRef = pageEntry instanceof PdfObjectReference
+                            ? pageEntry
+                            : null;
+                        fontPageRefs.set(fontName, pageRef);
+                    }
+                }
+            }
+        }
+        for (const [fontName, pageRef] of fontPageRefs) {
+            await this.getFontEncodingMap(fontName);
+            // If the font was not in the AcroForm DR, try the field's page resources
+            if (!this.fontRefs.has(fontName) && pageRef) {
+                await this.resolveFontFromPage(fontName, pageRef);
+            }
+        }
+    }
+    /**
+     * Walks the page-tree (page → parent → … → Pages root), looking for the
+     * font in each node's /Resources/Font dict. Stops as soon as it finds the
+     * font. PDF resource inheritance means any ancestor can supply the font.
+     */
+    async resolveFontFromPage(fontName, pageRef) {
+        if (!this.document)
+            return;
+        // Walk up the parent chain (max 16 levels to avoid infinite loops)
+        let currentRef = pageRef;
+        for (let depth = 0; depth < 16 && currentRef; depth++) {
+            const nodeObj = await this.document.readObject({
+                objectNumber: currentRef.objectNumber,
+                generationNumber: currentRef.generationNumber,
+            });
+            const nodeDict = nodeObj?.content instanceof PdfDictionary
+                ? nodeObj.content
+                : null;
+            if (!nodeDict)
+                break;
+            // Try Resources.Font in this node
+            const resourcesEntry = nodeDict.get('Resources');
+            const resources = resourcesEntry instanceof PdfDictionary ? resourcesEntry : null;
+            if (resources) {
+                const fontsEntry = resources.get('Font');
+                const fonts = fontsEntry instanceof PdfDictionary ? fontsEntry : null;
+                if (fonts) {
+                    const fontEntry = fonts.get(fontName);
+                    const fontRef = fontEntry instanceof PdfObjectReference
+                        ? fontEntry
+                        : null;
+                    if (fontRef) {
+                        // Found — cache and finish
+                        currentRef = fontRef;
+                        break;
+                    }
+                }
+            }
+            // Walk to parent
+            const parentEntry = nodeDict.get('Parent');
+            currentRef =
+                parentEntry instanceof PdfObjectReference ? parentEntry : null;
+        }
+        const fontRef = currentRef;
+        if (!fontRef)
+            return;
+        this.fontRefs.set(fontName, fontRef);
+        const fontObj = await this.document.readObject({
+            objectNumber: fontRef.objectNumber,
+            generationNumber: fontRef.generationNumber,
+        });
+        const fontDict = fontObj?.content instanceof PdfDictionary ? fontObj.content : null;
+        if (!fontDict)
+            return;
+        const subtypeEntry = fontDict.get('Subtype');
+        const subtype = subtypeEntry instanceof PdfName ? subtypeEntry.value : undefined;
+        if (subtype)
+            this.fontTypes.set(fontName, subtype);
+        // Also resolve encoding map if present
+        const encoding = fontDict.get('Encoding');
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document.readObject({
+                objectNumber: encoding.objectNumber,
+                generationNumber: encoding.generationNumber,
+            });
+            encodingDict =
+                encodingObj?.content instanceof PdfDictionary
+                    ? encodingObj.content
+                    : null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict)
+            return;
+        const differencesEntry = encodingDict.get('Differences');
+        if (!(differencesEntry instanceof PdfArray))
+            return;
+        const encodingMap = buildEncodingMap(differencesEntry);
+        if (encodingMap) {
+            this.fontEncodingMaps.set(fontName, encodingMap);
+        }
+    }
+    isFontUnicode(fontName) {
+        return this.fontTypes.get(fontName) === 'Type0';
+    }
+}

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/{PdfXfaForm.d.ts → pdf-xfa-form.d.ts}

@@ -1,6 +1,6 @@
 import { PdfDocument } from '../../pdf/pdf-document.js';
 import { PdfArray } from '../../core/objects/pdf-array.js';
-import { PdfXfaData } from './PdfXfaData.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.
@@ -8,5 +8,4 @@ import { PdfXfaData } from './PdfXfaData.js';
 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 → pdf-xfa-form.js}

@@ -3,7 +3,7 @@ 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';
+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.
@@ -17,10 +17,7 @@ export class PdfXfaForm extends PdfArray {
             return null;
         let acroFormDict;
         if (acroFormRef instanceof PdfObjectReference) {
-            const acroFormObject = await document.readObject({
-                objectNumber: acroFormRef.objectNumber,
-                generationNumber: acroFormRef.generationNumber,
-            });
+            const acroFormObject = await document.readObject(acroFormRef);
             if (!acroFormObject)
                 return null;
             acroFormDict = acroFormObject.content.as(PdfDictionary);
@@ -56,9 +53,4 @@ export class PdfXfaForm extends PdfArray {
         }
         return form;
     }
-    write(document) {
-        if (this.datasets?.isModified()) {
-            document.add(this.datasets);
-        }
-    }
 }

package/dist/annotations/index.d.ts

@@ -1,4 +1,4 @@
-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';
+export { PdfAnnotationWriter } from './pdf-annotation-writer.js';

package/dist/annotations/index.js

@@ -1,4 +1,4 @@
-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';
+export { PdfAnnotationWriter } from './pdf-annotation-writer.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,10 @@
 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';
 export type PdfAppearanceStreamDictionary = PdfDictionary<{
     N: PdfObjectReference | PdfDictionary;
     R?: PdfObjectReference | PdfDictionary;
@@ -8,15 +12,32 @@ 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> {
+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;
+    Opt: PdfArray<PdfString | PdfArray<PdfString>>;
+    MaxLen: PdfNumber;
+    Q: PdfNumber;
+    Kids: PdfArray<PdfObjectReference>;
+    Rect: PdfArray<PdfNumber>;
+    F: PdfNumber;
+    AP?: PdfAppearanceStreamDictionary;
+    P?: PdfObjectReference;
+}>> {
     private _annotationFlags;
     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;

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

@@ -3,17 +3,18 @@ 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';
+import { PdfAnnotationFlags } from './pdf-annotation-flags.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);
+        const flagValue = this.content.get('F')?.as(PdfNumber)?.value ?? 0;
+        this._annotationFlags = new PdfAnnotationFlags(flagValue);
+        this.content.set('F', this._annotationFlags);
     }
     get rect() {
         const rectArray = this.content.get('Rect')?.as((PdfArray));

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

@@ -1,5 +1,5 @@
 import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
-import { PdfAnnotation } from './PdfAnnotation.js';
+import { PdfAnnotation } from './pdf-annotation.js';
 /**
  * Widget annotation subtype. Extends PdfAnnotation with widget-specific
  * properties: isWidget (Type/Subtype) and AS (appearance state).

package/dist/annotations/{PdfWidgetAnnotation.js → pdf-widget-annotation.js}

@@ -1,5 +1,5 @@
 import { PdfName } from '../core/objects/pdf-name.js';
-import { PdfAnnotation } from './PdfAnnotation.js';
+import { PdfAnnotation } from './pdf-annotation.js';
 /**
  * Widget annotation subtype. Extends PdfAnnotation with widget-specific
  * properties: isWidget (Type/Subtype) and AS (appearance state).

package/dist/core/objects/pdf-stream.d.ts

@@ -20,6 +20,7 @@ export declare class PdfStream<T extends PdfDictionary = PdfDictionary> extends
     set raw(data: ByteArray);
     get originalAsString(): string;
     get rawAsString(): string;
+    set rawAsString(str: string);
     getFilters(): PdfStreamFilterType[];
     addFilter(filterName: PdfStreamFilterType): this;
     setPredictor(predictorParams: {

package/dist/core/objects/pdf-stream.js

@@ -17,6 +17,7 @@ import { bytesToPdfObjects } from '../generators.js';
 import { PdfIndirectObject } from './pdf-indirect-object.js';
 import { PdfXRefTableEntry } from './pdf-xref-table.js';
 import { stringToBytes } from '../../utils/stringToBytes.js';
+import { bytesToString } from '../../utils/bytesToString.js';
 export class PdfStream extends PdfObject {
     header;
     original;
@@ -52,10 +53,13 @@ export class PdfStream extends PdfObject {
         this.header.set('Length', new PdfNumber(data.length));
     }
     get originalAsString() {
-        return new TextDecoder().decode(this.original);
+        return bytesToString(this.original);
     }
     get rawAsString() {
-        return new TextDecoder().decode(this.raw);
+        return bytesToString(this.raw);
+    }
+    set rawAsString(str) {
+        this.raw = stringToBytes(str);
     }
     getFilters() {
         const filters = this.header.get('Filter');

package/dist/core/parser/incremental-parser.d.ts

@@ -1,17 +1,4 @@
 import { Parser } from './parser.js';
-/**
- * Error thrown when the parser needs more input to continue parsing.
- */
-export declare class NoMoreTokensError extends Error {
-}
-/**
- * Error thrown when the end of file has been reached and no more input is available.
- */
-export declare class EofReachedError extends Error {
-}
-export declare class UnexpectedTokenError extends Error {
-    constructor(expected: string, actual: string | null);
-}
 /**
  * Abstract base class for incremental parsers that can process input as it becomes available.
  * Supports buffering, lookahead, and backtracking for complex parsing scenarios.

package/dist/core/parser/incremental-parser.js

@@ -1,22 +1,5 @@
 import { Parser } from './parser.js';
-/**
- * Error thrown when the parser needs more input to continue parsing.
- */
-export class NoMoreTokensError extends Error {
-}
-/**
- * Error thrown when the end of file has been reached and no more input is available.
- */
-export class EofReachedError extends Error {
-}
-/*
- * Error thrown when an unexpected token is encountered during parsing.
- */
-export class UnexpectedTokenError extends Error {
-    constructor(expected, actual) {
-        super(`Unexpected token: expected ${expected}, but got ${actual === null ? 'EOF' : actual}`);
-    }
-}
+import { NoMoreTokensError, EofReachedError } from '../../errors.js';
 /**
  * Abstract base class for incremental parsers that can process input as it becomes available.
  * Supports buffering, lookahead, and backtracking for complex parsing scenarios.

package/dist/core/streams/object-stream.d.ts

@@ -1,6 +1,6 @@
 import { PdfObject } from '../objects/pdf-object.js';
 import { ByteArray } from '../../types.js';
-import { IterableReadableStream } from '../../utils/IterableReadableStream.js';
+import { IterableReadableStream } from '../../utils/iterable-readable-stream.js';
 export declare class PdfObjectStream extends IterableReadableStream<PdfObject> {
     constructor(input: AsyncIterable<ByteArray> | Iterable<ByteArray>);
 }