pdf-lite 1.4.0 → 1.6.0

package/dist/acroform/appearance/pdf-graphics.js

@@ -0,0 +1,239 @@
+import { encodePdfText } from '../../utils/encodePdfText.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+/**
+ * Lightweight builder for PDF content streams.
+ * Chains PDF operators via a fluent API and emits the final stream with build().
+ * Enhanced with text measurement capabilities for layout calculations.
+ */
+export class PdfGraphics {
+    lines = [];
+    resolvedFonts;
+    defaultAppearance;
+    constructor(options) {
+        this.resolvedFonts = options?.resolvedFonts;
+        this.defaultAppearance = options?.defaultAppearance;
+    }
+    save() {
+        this.lines.push('q');
+        return this;
+    }
+    restore() {
+        this.lines.push('Q');
+        return this;
+    }
+    beginText() {
+        this.lines.push('BT');
+        return this;
+    }
+    endText() {
+        this.lines.push('ET');
+        return this;
+    }
+    setDefaultAppearance(da) {
+        this.lines.push(da.toString());
+        this.defaultAppearance = da;
+        return this;
+    }
+    moveTo(x, y) {
+        this.lines.push(`${x} ${y} Td`);
+        return this;
+    }
+    showText(text, isUnicode, reverseEncodingMap) {
+        this.lines.push(`${encodePdfText(text, isUnicode, reverseEncodingMap)} Tj`);
+        return this;
+    }
+    showLiteralText(text) {
+        this.lines.push(`(${text}) Tj`);
+        return this;
+    }
+    beginMarkedContent() {
+        this.lines.push('/Tx BMC');
+        return this;
+    }
+    endMarkedContent() {
+        this.lines.push('EMC');
+        return this;
+    }
+    raw(op) {
+        this.lines.push(op);
+        return this;
+    }
+    setFillRGB(r, g, b) {
+        this.lines.push(`${r} ${g} ${b} rg`);
+        return this;
+    }
+    setFillGray(v) {
+        this.lines.push(`${v} g`);
+        return this;
+    }
+    setFont(name, size) {
+        this.lines.push(`/${name} ${size} Tf`);
+        return this;
+    }
+    movePath(x, y) {
+        this.lines.push(`${x} ${y} m`);
+        return this;
+    }
+    lineTo(x, y) {
+        this.lines.push(`${x} ${y} l`);
+        return this;
+    }
+    curveTo(x1, y1, x2, y2, x3, y3) {
+        this.lines.push(`${x1} ${y1} ${x2} ${y2} ${x3} ${y3} c`);
+        return this;
+    }
+    fill() {
+        this.lines.push('f');
+        return this;
+    }
+    stroke() {
+        this.lines.push('S');
+        return this;
+    }
+    closePath() {
+        this.lines.push('h');
+        return this;
+    }
+    build() {
+        return this.lines.join('\n') + '\n';
+    }
+    get currentFont() {
+        if (!this.defaultAppearance) {
+            return null;
+        }
+        const fontName = this.defaultAppearance.fontName;
+        const size = this.defaultAppearance.fontSize;
+        const fontObject = this.resolvedFonts?.get(fontName);
+        return { fontObject, size };
+    }
+    /**
+     * Calculate the width of text using the current font and size.
+     */
+    measureTextWidth(text, fontSize) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        const { fontObject, size: currentSize } = this.currentFont;
+        const size = fontSize ?? currentSize;
+        const fontName = this.defaultAppearance.fontName;
+        const effectiveFontObject = fontObject ?? PdfFont.getStandardFont(fontName);
+        if (effectiveFontObject?.widths &&
+            effectiveFontObject.firstChar !== undefined) {
+            let width = 0;
+            for (const char of text) {
+                const charCode = char.charCodeAt(0);
+                const charWidth = effectiveFontObject.getCharacterWidth(charCode, size);
+                if (charWidth !== null) {
+                    width += charWidth;
+                }
+                else {
+                    width += size * 0.6;
+                }
+            }
+            return width;
+        }
+        // Unknown font — use Helvetica as best-effort approximation
+        let width = 0;
+        for (const char of text) {
+            const charWidth = PdfFont.HELVETICA.getCharacterWidth(char.charCodeAt(0), size);
+            width += charWidth !== null ? charWidth : size * 0.6;
+        }
+        return width;
+    }
+    /**
+     * Wrap text to fit within the specified width, breaking at word boundaries.
+     */
+    wrapTextToLines(text, maxWidth, fontSize) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        // Handle explicit line breaks first
+        const paragraphs = text.split('\n');
+        const wrappedLines = [];
+        for (const paragraph of paragraphs) {
+            if (this.measureTextWidth(paragraph, fontSize) <= maxWidth) {
+                wrappedLines.push(paragraph);
+                continue;
+            }
+            // Word wrapping needed
+            const words = paragraph.split(' ');
+            let currentLine = '';
+            for (const word of words) {
+                const testLine = currentLine ? `${currentLine} ${word}` : word;
+                if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+                    currentLine = testLine;
+                }
+                else {
+                    if (currentLine) {
+                        wrappedLines.push(currentLine);
+                        currentLine = word;
+                    }
+                    else {
+                        // Single word is too long, break it
+                        const brokenLines = this.breakLongWord(word, maxWidth, fontSize);
+                        wrappedLines.push(...brokenLines.slice(0, -1));
+                        currentLine = brokenLines[brokenLines.length - 1];
+                    }
+                }
+            }
+            if (currentLine) {
+                wrappedLines.push(currentLine);
+            }
+        }
+        return wrappedLines;
+    }
+    /**
+     * Calculate the minimum font size needed to fit text within given constraints.
+     */
+    calculateFittingFontSize(text, maxWidth, maxHeight, lineHeight = 1.2) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        const startSize = this.currentFont.size;
+        const minSize = 0.5;
+        const fits = (size) => {
+            if (this.measureTextWidth(text, size) > maxWidth)
+                return false;
+            if (maxHeight !== undefined) {
+                const lines = this.wrapTextToLines(text, maxWidth, size);
+                return lines.length * size * lineHeight <= maxHeight;
+            }
+            return true;
+        };
+        if (fits(startSize))
+            return startSize;
+        if (!fits(minSize))
+            return minSize;
+        // Binary search on 0.5pt grid: lo fits, hi does not
+        let lo = minSize;
+        let hi = startSize;
+        while (hi - lo > 0.5) {
+            const mid = Math.round((lo + hi) / 2 / 0.5) * 0.5;
+            if (fits(mid))
+                lo = mid;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    breakLongWord(word, maxWidth, fontSize) {
+        const lines = [];
+        let currentLine = '';
+        for (const char of word) {
+            const testLine = currentLine + char;
+            if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+                currentLine = testLine;
+            }
+            else {
+                if (currentLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = char;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines.length > 0 ? lines : [word];
+    }
+}

package/dist/acroform/appearance/{PdfTextAppearanceStream.d.ts → pdf-text-appearance-stream.d.ts}

@@ -1,8 +1,10 @@
-import { PdfDefaultAppearance } from '../fields/PdfDefaultAppearance.js';
-import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+import { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
 import type { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import type { PdfFont } from '../../fonts/pdf-font.js';
 /**
  * Appearance stream for text fields (single-line, multiline, comb).
+ * Enhanced with word wrapping and automatic font scaling.
  */
 export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
     constructor(ctx: {
@@ -13,5 +15,8 @@ export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
         comb: boolean;
         maxLen: number | null;
         fontResources?: PdfDictionary;
+        resolvedFonts?: Map<string, PdfFont>;
+        isUnicode?: boolean;
+        reverseEncodingMap?: Map<string, number>;
     });
 }

package/dist/acroform/appearance/pdf-text-appearance-stream.js

@@ -0,0 +1,104 @@
+import { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import { PdfGraphics } from './pdf-graphics.js';
+/**
+ * Appearance stream for text fields (single-line, multiline, comb).
+ * Enhanced with word wrapping and automatic font scaling.
+ */
+export class PdfTextAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx) {
+        const [x1, y1, x2, y2] = ctx.rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        const value = ctx.value;
+        const isUnicode = ctx.isUnicode ?? false;
+        const reverseEncodingMap = ctx.reverseEncodingMap;
+        const padding = 2;
+        const availableWidth = width - 2 * padding;
+        const availableHeight = height - 2 * padding;
+        // Create graphics with font context for text measurement
+        const g = new PdfGraphics({
+            resolvedFonts: ctx.resolvedFonts,
+        });
+        g.beginMarkedContent();
+        g.save();
+        // Set initial font to enable measurement
+        g.setDefaultAppearance(ctx.da);
+        let finalFontSize = ctx.da.fontSize;
+        let lines = [];
+        if (ctx.multiline) {
+            const testLines = g.wrapTextToLines(value, availableWidth);
+            const lineHeight = finalFontSize * 1.2;
+            if (testLines.length * lineHeight > availableHeight) {
+                // Scale font down to fit
+                finalFontSize = g.calculateFittingFontSize(value, availableWidth, availableHeight, 1.2);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+                lines = g.wrapTextToLines(value, availableWidth);
+            }
+            else {
+                lines = testLines;
+            }
+            const renderLineHeight = finalFontSize * 1.2;
+            const startY = height - padding - finalFontSize;
+            g.beginText();
+            g.moveTo(padding, startY);
+            for (let i = 0; i < lines.length; i++) {
+                if (i > 0)
+                    g.moveTo(0, -renderLineHeight);
+                g.showText(lines[i].replace(/\r/g, ''), isUnicode, reverseEncodingMap);
+            }
+            g.endText();
+        }
+        else if (ctx.comb && ctx.maxLen) {
+            const cellWidth = width / ctx.maxLen;
+            const chars = [...value];
+            // Calculate font size to fit the widest character in its cell
+            let maxCharWidth = 0;
+            let widestChar = chars[0] ?? '';
+            for (const char of chars) {
+                const charWidth = g.measureTextWidth(char);
+                if (charWidth > maxCharWidth) {
+                    maxCharWidth = charWidth;
+                    widestChar = char;
+                }
+            }
+            if (maxCharWidth > cellWidth) {
+                finalFontSize = g.calculateFittingFontSize(widestChar, cellWidth);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+            }
+            const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
+            g.beginText();
+            for (let i = 0; i < chars.length && i < ctx.maxLen; i++) {
+                const cellX = cellWidth * i + cellWidth / 2 - finalFontSize * 0.3;
+                g.moveTo(cellX, textY);
+                g.showText(chars[i], isUnicode, reverseEncodingMap);
+                g.moveTo(-cellX, -textY);
+            }
+            g.endText();
+        }
+        else {
+            // Single line text
+            const textWidth = g.measureTextWidth(value);
+            if (textWidth > availableWidth) {
+                finalFontSize = g.calculateFittingFontSize(value, availableWidth);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+            }
+            const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
+            g.beginText();
+            g.moveTo(padding, textY);
+            g.showText(value, isUnicode, reverseEncodingMap);
+            g.endText();
+        }
+        g.restore();
+        g.endMarkedContent();
+        super({
+            width,
+            height,
+            contentStream: g.build(),
+            resources: ctx.fontResources,
+        });
+    }
+}

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

@@ -1,8 +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 { PdfFormField, PdfAcroFormField } from './pdf-form-field.js';
+export { PdfFormFieldFlags } from './pdf-form-field-flags.js';
+export { PdfDefaultAppearance } from './pdf-default-appearance.js';
+export { PdfTextFormField } from './pdf-text-form-field.js';
+export { PdfButtonFormField } from './pdf-button-form-field.js';
+export { PdfChoiceFormField } from './pdf-choice-form-field.js';
+export { PdfSignatureFormField } from './pdf-signature-form-field.js';
 export { PdfFieldType, type FormContext } from './types.js';

package/dist/acroform/fields/index.js

@@ -1,8 +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 { PdfFormField, PdfAcroFormField } from './pdf-form-field.js';
+export { PdfFormFieldFlags } from './pdf-form-field-flags.js';
+export { PdfDefaultAppearance } from './pdf-default-appearance.js';
+export { PdfTextFormField } from './pdf-text-form-field.js';
+export { PdfButtonFormField } from './pdf-button-form-field.js';
+export { PdfChoiceFormField } from './pdf-choice-form-field.js';
+export { PdfSignatureFormField } from './pdf-signature-form-field.js';
 export { PdfFieldType } from './types.js';

package/dist/acroform/fields/pdf-button-form-field.d.ts

@@ -0,0 +1,14 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export declare class PdfButtonFormField extends PdfFormField {
+    set defaultValue(val: string);
+    protected _storeValue(val: string | PdfString, fieldParent: PdfFormField | undefined): boolean;
+    get checked(): boolean;
+    set checked(isChecked: boolean);
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/pdf-button-form-field.js

@@ -0,0 +1,70 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfButtonAppearanceStream } from '../appearance/pdf-button-appearance-stream.js';
+import { PdfName } from '../../core/objects/pdf-name.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export class PdfButtonFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Btn', PdfButtonFormField);
+    }
+    set defaultValue(val) {
+        this.content.set('DV', new PdfName(val));
+    }
+    _storeValue(val, fieldParent) {
+        const strVal = val instanceof PdfString ? val.value : val;
+        if (strVal.trim() === '') {
+            this.content.delete('V');
+            fieldParent?.content.delete('V');
+            this.content.delete('AS');
+            return false;
+        }
+        this.content.set('V', new PdfName(strVal));
+        fieldParent?.content.set('V', new PdfName(strVal));
+        this.content.set('AS', new PdfName(strVal));
+        return true;
+    }
+    get checked() {
+        const v = this.content.get('V') ?? this.parent?.content.get('V');
+        return v instanceof PdfName && v.value === 'Yes';
+    }
+    set checked(isChecked) {
+        const target = this.parent ?? this;
+        if (isChecked) {
+            target.content.set('V', new PdfName('Yes'));
+            this.content.set('AS', new PdfName('Yes'));
+        }
+        else {
+            target.content.set('V', new PdfName('Off'));
+            this.content.set('AS', new PdfName('Off'));
+        }
+    }
+    generateAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const [x1, y1, x2, y2] = rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        // Merge own flags with parent flags so inherited bits (e.g. Radio) are
+        // not lost when a child widget has its own Ff entry (even Ff: 0).
+        const effectiveFlags = this.flags.flags | (this.parent?.flags?.flags ?? 0);
+        const yesAppearance = PdfButtonAppearanceStream.buildYesContent(width, height, effectiveFlags);
+        const noAppearance = new PdfButtonAppearanceStream({
+            width,
+            height,
+            contentStream: '',
+        });
+        this.setAppearanceStream({
+            Yes: yesAppearance,
+            Off: noAppearance,
+        });
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/pdf-choice-form-field.d.ts

@@ -0,0 +1,19 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export declare class PdfChoiceFormField extends PdfFormField {
+    get selectedIndex(): number;
+    get options(): {
+        label: string;
+        value: string;
+    }[];
+    set options(values: {
+        label: string;
+        value: string;
+    }[] | string[] | PdfObjectReference | undefined);
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/pdf-choice-form-field.js

@@ -0,0 +1,112 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfDefaultAppearance } from './pdf-default-appearance.js';
+import { PdfChoiceAppearanceStream } from '../appearance/pdf-choice-appearance-stream.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfIndirectObject } from '../../core/index.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export class PdfChoiceFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Ch', PdfChoiceFormField);
+    }
+    get selectedIndex() {
+        return this.options.findIndex((opt) => opt.value === this.value);
+    }
+    get options() {
+        let opt = this.content.get('Opt') ?? this.parent?.content.get('Opt');
+        if (!opt)
+            return [];
+        if (opt instanceof PdfObjectReference) {
+            opt = opt
+                .resolve()
+                .as((PdfIndirectObject)).content;
+        }
+        if (!(opt instanceof PdfArray))
+            return [];
+        return opt.items.map((item) => {
+            if (item instanceof PdfArray && item.items.length >= 2) {
+                const label = item.items[1] instanceof PdfString
+                    ? item.items[1].value
+                    : '';
+                const value = item.items[0] instanceof PdfString
+                    ? item.items[0].value
+                    : '';
+                return { label, value };
+            }
+            else if (item instanceof PdfString) {
+                return { label: item.value, value: item.value };
+            }
+            else {
+                return { label: '', value: '' };
+            }
+        });
+    }
+    set options(values) {
+        if (values === undefined) {
+            this.content.delete('Opt');
+            return;
+        }
+        if (values instanceof PdfObjectReference) {
+            this.content.set('Opt', values);
+            return;
+        }
+        if (values.length === 0) {
+            this.content.delete('Opt');
+            return;
+        }
+        const optArray = new PdfArray();
+        for (const option of values) {
+            if (typeof option === 'string') {
+                optArray.items.push(new PdfString(option));
+            }
+            else if (option.label === option.value) {
+                optArray.items.push(new PdfString(option.value));
+            }
+            else {
+                const pair = new PdfArray();
+                pair.items.push(new PdfString(option.value));
+                pair.items.push(new PdfString(option.label));
+                optArray.items.push(pair);
+            }
+        }
+        this.content.set('Opt', optArray);
+    }
+    generateAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const da = this.defaultAppearance;
+        if (!da)
+            return false;
+        const value = this.value;
+        if (!value)
+            return false;
+        const parsed = PdfDefaultAppearance.parse(da);
+        if (!parsed)
+            return false;
+        const font = this.font;
+        const fontResources = this.buildFontResources(parsed.fontName);
+        const isUnicode = font?.isUnicode ?? false;
+        const reverseEncodingMap = font?.reverseEncodingMap;
+        this.setAppearanceStream(new PdfChoiceAppearanceStream({
+            rect: rect,
+            value,
+            da: parsed,
+            flags: this.flags,
+            fontResources,
+            isUnicode,
+            reverseEncodingMap,
+            displayOptions: this.options.map((opt) => opt.label),
+            selectedIndex: this.selectedIndex,
+        }));
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/{PdfFormFieldFlags.d.ts → pdf-form-field-flags.d.ts}

@@ -1,14 +1,13 @@
-import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfNumber } from '../../core/objects/pdf-number.js';
 /**
  * Field-specific Ff flag accessors for form fields.
  * These are separate from annotation flags (F field).
+ * Extends PdfNumber so it can be stored directly in a PDF dictionary.
  */
-export declare class PdfFormFieldFlags {
-    dict: PdfDictionary;
-    parentDict?: PdfDictionary;
-    constructor(dict: PdfDictionary, parentDict?: PdfDictionary);
+export declare class PdfFormFieldFlags extends PdfNumber {
+    constructor(value?: number | PdfNumber | PdfFormFieldFlags);
     get flags(): number;
-    set flags(flags: number);
+    set flags(v: number | PdfFormFieldFlags);
     private getFlag;
     private setFlag;
     get readOnly(): boolean;

package/dist/acroform/fields/{PdfFormFieldFlags.js → pdf-form-field-flags.js}

@@ -2,32 +2,26 @@ import { PdfNumber } from '../../core/objects/pdf-number.js';
 /**
  * Field-specific Ff flag accessors for form fields.
  * These are separate from annotation flags (F field).
+ * Extends PdfNumber so it can be stored directly in a PDF dictionary.
  */
-export class PdfFormFieldFlags {
-    dict;
-    parentDict;
-    constructor(dict, parentDict) {
-        this.dict = dict;
-        this.parentDict = parentDict;
+export class PdfFormFieldFlags extends PdfNumber {
+    constructor(value = 0) {
+        super(value);
+        this.preTokens = typeof value === 'number' ? undefined : value.preTokens;
+        this.postTokens =
+            typeof value === 'number' ? undefined : value.postTokens;
     }
     get flags() {
-        return (this.dict.get('Ff')?.as(PdfNumber)?.value ??
-            this.parentDict?.get('Ff')?.as(PdfNumber)?.value ??
-            0);
+        return this.value;
     }
-    set flags(flags) {
-        this.dict.set('Ff', new PdfNumber(flags));
+    set flags(v) {
+        this.value = v instanceof PdfFormFieldFlags ? v.value : v;
     }
     getFlag(bit) {
         return (this.flags & bit) !== 0;
     }
-    setFlag(bit, value) {
-        if (value) {
-            this.flags = this.flags | bit;
-        }
-        else {
-            this.flags = this.flags & ~bit;
-        }
+    setFlag(bit, val) {
+        this.flags = val ? this.flags | bit : this.flags & ~bit;
     }
     get readOnly() {
         return this.getFlag(1);