pdf-lite 1.7.0 → 1.7.2

package/dist/acroform/appearance/pdf-graphics.d.ts

@@ -1,5 +1,15 @@
 import type { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
 import { PdfFont } from '../../fonts/pdf-font.js';
+/**
+ * Resource names of font variants to use when rendering styled markdown segments.
+ * When a variant is provided, the appearance stream switches fonts instead of
+ * simulating bold/italic via stroke width or matrix shear.
+ */
+export interface FontVariantNames {
+    bold?: string;
+    italic?: string;
+    boldItalic?: string;
+}
 /**
  * Lightweight builder for PDF content streams.
  * Chains PDF operators via a fluent API and emits the final stream with build().
@@ -9,9 +19,11 @@ export declare class PdfGraphics {
     private lines;
     private resolvedFonts?;
     private defaultAppearance?;
+    private fontVariantNames?;
     constructor(options?: {
         resolvedFonts?: Map<string, PdfFont>;
         defaultAppearance?: PdfDefaultAppearance;
+        fontVariantNames?: FontVariantNames;
     });
     save(): this;
     restore(): this;
@@ -33,6 +45,39 @@ export declare class PdfGraphics {
     fill(): this;
     stroke(): this;
     closePath(): this;
+    static readonly ITALIC_SHEAR = 0.267;
+    static readonly BOLD_STROKE_RATIO = 0.04;
+    /**
+     * Re-attributes styled segments to wrapped lines by tracking character
+     * positions in the flat plain-text. One whitespace character is consumed
+     * at each line boundary (space from word-wrap or newline from paragraph).
+     */
+    private static splitSegmentsToLines;
+    /**
+     * Returns the resource name of the best-matching font variant for the given
+     * bold/italic flags, or undefined if no variant fonts are configured.
+     */
+    private resolveVariantFontName;
+    /**
+     * Measures text width using a specific font from resolvedFonts by resource
+     * name, falling back to measureTextWidth (regular font) if not found.
+     */
+    measureTextWidthWithFont(text: string, fontName: string | undefined, fontSize: number): number;
+    /**
+     * Emits styled text segments into the current BT…ET block.
+     * Returns an array of rects for any strikethrough segments so the caller
+     * can draw the lines after closing the text object.
+     */
+    private showSegments;
+    /**
+     * Parses a markdown string, renders the styled segments inside a BT…ET
+     * block, then draws strikethrough lines (if any) as path operations after
+     * the text object. Pass `multiline` to wrap across multiple lines.
+     */
+    showMarkdown(markdown: string, isUnicode: boolean, reverseEncodingMap: Map<string, number> | undefined, x: number, y: number, fontSize: number, multiline?: {
+        availableWidth: number;
+        lineHeight: number;
+    }): this;
     build(): string;
     private get currentFont();
     /**
@@ -41,6 +86,8 @@ export declare class PdfGraphics {
     measureTextWidth(text: string, fontSize?: number): number;
     /**
      * Wrap text to fit within the specified width, breaking at word boundaries.
+     * When a bold font variant is configured, uses its metrics conservatively
+     * to prevent bold glyphs from overflowing field bounds.
      */
     wrapTextToLines(text: string, maxWidth: number, fontSize?: number): string[];
     /**

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

@@ -1,5 +1,6 @@
 import { encodePdfText } from '../../utils/encodePdfText.js';
 import { PdfFont } from '../../fonts/pdf-font.js';
+import { parseMarkdownSegments, } from '../../utils/parse-markdown-segments.js';
 /**
  * Lightweight builder for PDF content streams.
  * Chains PDF operators via a fluent API and emits the final stream with build().
@@ -9,9 +10,11 @@ export class PdfGraphics {
     lines = [];
     resolvedFonts;
     defaultAppearance;
+    fontVariantNames;
     constructor(options) {
         this.resolvedFonts = options?.resolvedFonts;
         this.defaultAppearance = options?.defaultAppearance;
+        this.fontVariantNames = options?.fontVariantNames;
     }
     save() {
         this.lines.push('q');
@@ -94,6 +97,197 @@ export class PdfGraphics {
         this.lines.push('h');
         return this;
     }
+    // Italic shear: ≈ tan(15°), applied as the c component of the Tm matrix.
+    static ITALIC_SHEAR = 0.267;
+    // Bold stroke width as a fraction of font size (0.04 × 12pt = 0.48pt stroke).
+    static BOLD_STROKE_RATIO = 0.04;
+    /**
+     * Re-attributes styled segments to wrapped lines by tracking character
+     * positions in the flat plain-text. One whitespace character is consumed
+     * at each line boundary (space from word-wrap or newline from paragraph).
+     */
+    static splitSegmentsToLines(segments, lines) {
+        const chars = [];
+        for (const seg of segments) {
+            for (const char of seg.text) {
+                chars.push({
+                    char,
+                    bold: seg.bold,
+                    italic: seg.italic,
+                    strikethrough: seg.strikethrough,
+                });
+            }
+        }
+        const result = [];
+        let pos = 0;
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            if (lineIdx > 0 && pos < chars.length) {
+                const c = chars[pos].char;
+                if (c === ' ' || c === '\n' || c === '\r')
+                    pos++;
+            }
+            const lineSegs = [];
+            let curText = '';
+            let curBold = false;
+            let curItalic = false;
+            let curStrikethrough = false;
+            const lineLen = lines[lineIdx].replace(/\r/g, '').length;
+            for (let j = 0; j < lineLen && pos < chars.length; j++, pos++) {
+                const { char, bold, italic, strikethrough } = chars[pos];
+                if (curText === '') {
+                    curText = char;
+                    curBold = bold;
+                    curItalic = italic;
+                    curStrikethrough = strikethrough;
+                }
+                else if (bold !== curBold ||
+                    italic !== curItalic ||
+                    strikethrough !== curStrikethrough) {
+                    lineSegs.push({
+                        text: curText,
+                        bold: curBold,
+                        italic: curItalic,
+                        strikethrough: curStrikethrough,
+                    });
+                    curText = char;
+                    curBold = bold;
+                    curItalic = italic;
+                    curStrikethrough = strikethrough;
+                }
+                else {
+                    curText += char;
+                }
+            }
+            if (curText)
+                lineSegs.push({
+                    text: curText,
+                    bold: curBold,
+                    italic: curItalic,
+                    strikethrough: curStrikethrough,
+                });
+            result.push(lineSegs);
+        }
+        return result;
+    }
+    /**
+     * Returns the resource name of the best-matching font variant for the given
+     * bold/italic flags, or undefined if no variant fonts are configured.
+     */
+    resolveVariantFontName(bold, italic) {
+        if (bold && italic && this.fontVariantNames?.boldItalic)
+            return this.fontVariantNames.boldItalic;
+        if (bold && this.fontVariantNames?.bold)
+            return this.fontVariantNames.bold;
+        if (italic && this.fontVariantNames?.italic)
+            return this.fontVariantNames.italic;
+        return undefined;
+    }
+    /**
+     * Measures text width using a specific font from resolvedFonts by resource
+     * name, falling back to measureTextWidth (regular font) if not found.
+     */
+    measureTextWidthWithFont(text, fontName, fontSize) {
+        if (!fontName)
+            return this.measureTextWidth(text, fontSize);
+        const font = this.resolvedFonts?.get(fontName);
+        if (!font)
+            return this.measureTextWidth(text, fontSize);
+        let width = 0;
+        for (const char of text) {
+            const w = font.getCharacterWidth(char.charCodeAt(0), fontSize);
+            width += w !== null ? w : fontSize * 0.6;
+        }
+        return width;
+    }
+    /**
+     * Emits styled text segments into the current BT…ET block.
+     * Returns an array of rects for any strikethrough segments so the caller
+     * can draw the lines after closing the text object.
+     */
+    showSegments(lineSegs, isUnicode, reverseEncodingMap, startX, startY, fontSize) {
+        const regularFontName = this.defaultAppearance.fontName;
+        let x = startX;
+        const strikethroughRects = [];
+        for (const seg of lineSegs) {
+            const variantName = this.resolveVariantFontName(seg.bold, seg.italic);
+            if (variantName) {
+                // True font variant — switch font, no simulation needed
+                const variantFont = this.resolvedFonts?.get(variantName);
+                const segIsUnicode = variantFont?.isUnicode ?? isUnicode;
+                const segEncMap = variantFont?.reverseEncodingMap ?? reverseEncodingMap;
+                this.raw(`1 0 0 1 ${x.toFixed(3)} ${startY.toFixed(3)} Tm`);
+                this.raw(`/${variantName} ${fontSize} Tf`);
+                this.raw(`0 Tr`);
+                this.showText(seg.text, segIsUnicode, segEncMap);
+                const segWidth = this.measureTextWidthWithFont(seg.text, variantName, fontSize);
+                if (seg.strikethrough) {
+                    strikethroughRects.push({ x, y: startY, width: segWidth });
+                }
+                x += segWidth;
+            }
+            else {
+                // Fallback simulation (no variant font provided)
+                // Always restore regular font in case a variant was active
+                this.raw(`/${regularFontName} ${fontSize} Tf`);
+                const shear = seg.italic ? PdfGraphics.ITALIC_SHEAR : 0;
+                this.raw(`1 0 ${shear} 1 ${x.toFixed(3)} ${startY.toFixed(3)} Tm`);
+                if (seg.bold) {
+                    const sw = (fontSize * PdfGraphics.BOLD_STROKE_RATIO).toFixed(3);
+                    this.raw(`${sw} w 2 Tr`);
+                }
+                else {
+                    this.raw(`0 Tr`);
+                }
+                this.showText(seg.text, isUnicode, reverseEncodingMap);
+                const segWidth = this.measureTextWidth(seg.text, fontSize);
+                if (seg.strikethrough) {
+                    strikethroughRects.push({ x, y: startY, width: segWidth });
+                }
+                x += segWidth;
+            }
+        }
+        // Restore regular font and fill-only rendering mode
+        this.raw(`/${regularFontName} ${fontSize} Tf`);
+        this.raw(`0 Tr`);
+        return strikethroughRects;
+    }
+    /**
+     * Parses a markdown string, renders the styled segments inside a BT…ET
+     * block, then draws strikethrough lines (if any) as path operations after
+     * the text object. Pass `multiline` to wrap across multiple lines.
+     */
+    showMarkdown(markdown, isUnicode, reverseEncodingMap, x, y, fontSize, multiline) {
+        const segments = parseMarkdownSegments(markdown);
+        const allStrikethroughRects = [];
+        this.beginText();
+        if (multiline) {
+            const plainText = segments.map((s) => s.text).join('');
+            const lines = this.wrapTextToLines(plainText, multiline.availableWidth);
+            const styledLines = PdfGraphics.splitSegmentsToLines(segments, lines);
+            for (let i = 0; i < styledLines.length; i++) {
+                const rects = this.showSegments(styledLines[i], isUnicode, reverseEncodingMap, x, y - i * multiline.lineHeight, fontSize);
+                allStrikethroughRects.push(...rects);
+            }
+        }
+        else {
+            const rects = this.showSegments(segments, isUnicode, reverseEncodingMap, x, y, fontSize);
+            allStrikethroughRects.push(...rects);
+        }
+        this.endText();
+        // Draw strikethrough lines outside the text object
+        if (allStrikethroughRects.length > 0) {
+            const lineY = fontSize * 0.35;
+            const lineWidth = Math.max(0.5, fontSize * 0.06);
+            this.raw(`q`);
+            this.raw(`${lineWidth.toFixed(3)} w`);
+            for (const rect of allStrikethroughRects) {
+                const sy = (rect.y + lineY).toFixed(3);
+                this.raw(`${rect.x.toFixed(3)} ${sy} m ${(rect.x + rect.width).toFixed(3)} ${sy} l S`);
+            }
+            this.raw(`Q`);
+        }
+        return this;
+    }
     build() {
         return this.lines.join('\n') + '\n';
     }
@@ -142,16 +336,23 @@ export class PdfGraphics {
     }
     /**
      * Wrap text to fit within the specified width, breaking at word boundaries.
+     * When a bold font variant is configured, uses its metrics conservatively
+     * to prevent bold glyphs from overflowing field bounds.
      */
     wrapTextToLines(text, maxWidth, fontSize) {
         if (!this.currentFont) {
             throw new Error('No font set - call setDefaultAppearance() first');
         }
+        const boldFontName = this.fontVariantNames?.bold;
+        const size = fontSize ?? this.currentFont.size;
+        const measure = (t) => boldFontName
+            ? this.measureTextWidthWithFont(t, boldFontName, size)
+            : this.measureTextWidth(t, fontSize);
         // Handle explicit line breaks first
         const paragraphs = text.split('\n');
         const wrappedLines = [];
         for (const paragraph of paragraphs) {
-            if (this.measureTextWidth(paragraph, fontSize) <= maxWidth) {
+            if (measure(paragraph) <= maxWidth) {
                 wrappedLines.push(paragraph);
                 continue;
             }
@@ -160,7 +361,7 @@ export class PdfGraphics {
             let currentLine = '';
             for (const word of words) {
                 const testLine = currentLine ? `${currentLine} ${word}` : word;
-                if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+                if (measure(testLine) <= maxWidth) {
                     currentLine = testLine;
                 }
                 else {
@@ -189,6 +390,7 @@ export class PdfGraphics {
         if (!this.currentFont) {
             throw new Error('No font set - call setDefaultAppearance() first');
         }
+        const boldFontName = this.fontVariantNames?.bold;
         const startSize = this.currentFont.size;
         const minSize = 0.5;
         const fits = (size) => {
@@ -199,7 +401,10 @@ export class PdfGraphics {
                 return lines.length * size * lineHeight <= maxHeight;
             }
             // Single-line mode: text must fit within maxWidth.
-            return this.measureTextWidth(text, size) <= maxWidth;
+            return boldFontName
+                ? this.measureTextWidthWithFont(text, boldFontName, size) <=
+                    maxWidth
+                : this.measureTextWidth(text, size) <= maxWidth;
         };
         if (fits(startSize))
             return startSize;
@@ -218,11 +423,16 @@ export class PdfGraphics {
         return lo;
     }
     breakLongWord(word, maxWidth, fontSize) {
+        const boldFontName = this.fontVariantNames?.bold;
+        const size = fontSize ?? this.currentFont?.size ?? 12;
+        const measure = (t) => boldFontName
+            ? this.measureTextWidthWithFont(t, boldFontName, size)
+            : this.measureTextWidth(t, fontSize);
         const lines = [];
         let currentLine = '';
         for (const char of word) {
             const testLine = currentLine + char;
-            if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+            if (measure(testLine) <= maxWidth) {
                 currentLine = testLine;
             }
             else {

package/dist/acroform/appearance/pdf-text-appearance-stream.d.ts

@@ -2,6 +2,7 @@ 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';
+import { type FontVariantNames } from './pdf-graphics.js';
 /**
  * Appearance stream for text fields (single-line, multiline, comb).
  * Enhanced with word wrapping and automatic font scaling.
@@ -18,5 +19,7 @@ export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
         resolvedFonts?: Map<string, PdfFont>;
         isUnicode?: boolean;
         reverseEncodingMap?: Map<string, number>;
+        markdown?: string;
+        fontVariantNames?: FontVariantNames;
     });
 }

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

@@ -21,6 +21,7 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
         // Create graphics with font context for text measurement
         const g = new PdfGraphics({
             resolvedFonts: ctx.resolvedFonts,
+            fontVariantNames: ctx.fontVariantNames,
         });
         g.beginMarkedContent();
         g.save();
@@ -43,8 +44,7 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
             // shrink further if text overflows the width.
             finalFontSize = Math.min(DEFAULT_FONT_SIZE, availableHeight);
             g.setDefaultAppearance(new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp));
-            const textWidth = g.measureTextWidth(value);
-            if (textWidth > availableWidth) {
+            if (g.measureTextWidth(value) > availableWidth) {
                 finalFontSize = g.calculateFittingFontSize(value, availableWidth);
             }
             finalFontSize = Math.max(finalFontSize, 0.5);
@@ -100,29 +100,41 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
             lines = g.wrapTextToLines(value, availableWidth);
             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);
+            if (ctx.markdown) {
+                g.showMarkdown(ctx.markdown, isUnicode, reverseEncodingMap, padding, startY, finalFontSize, {
+                    availableWidth,
+                    lineHeight: renderLineHeight,
+                });
+            }
+            else {
+                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();
             }
-            g.endText();
         }
         else {
             // Single line — for non-auto-size, shrink if text overflows
             if (!autoSize) {
-                const textWidth = g.measureTextWidth(value);
-                if (textWidth > availableWidth) {
+                if (g.measureTextWidth(value) > availableWidth) {
                     finalFontSize = g.calculateFittingFontSize(value, availableWidth);
                     g.setDefaultAppearance(new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp));
                 }
             }
             const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
-            g.beginText();
-            g.moveTo(padding, textY);
-            g.showText(value, isUnicode, reverseEncodingMap);
-            g.endText();
+            if (ctx.markdown) {
+                g.showMarkdown(ctx.markdown, isUnicode, reverseEncodingMap, padding, textY, finalFontSize);
+            }
+            else {
+                g.beginText();
+                g.moveTo(padding, textY);
+                g.showText(value, isUnicode, reverseEncodingMap);
+                g.endText();
+            }
         }
         g.restore();
         g.endMarkedContent();

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

@@ -4,6 +4,7 @@ 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 { PdfFont } from '../../fonts/pdf-font.js';
+import type { FontFamily } from '../../fonts/font-family.js';
 import { PdfStream } from '../../core/objects/pdf-stream.js';
 import { PdfWidgetAnnotation } from '../../annotations/pdf-widget-annotation.js';
 import type { PdfFieldType } from './types.js';
@@ -19,6 +20,9 @@ import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
  */
 export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     defaultGenerateAppearance: boolean;
+    /** Raw markdown string set by markdownValue; cleared by setRawValue. */
+    protected _markdownValue?: string;
+    private _fontFamily?;
     /** @internal */
     _form?: PdfAcroForm;
     constructor(other?: PdfIndirectObject | {
@@ -41,6 +45,12 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
      * Returns undefined if neither source provides the font.
      */
     buildFontResources(fontName: string): PdfDictionary | undefined;
+    /**
+     * Like buildFontResources but includes multiple font names (regular +
+     * variant fonts) in a single Resources/Font dictionary. Falls through to
+     * buildFontResources when only one name is provided.
+     */
+    buildAllFontResources(fontNames: string[]): PdfDictionary | undefined;
     get fieldType(): PdfFieldType | null;
     set fieldType(type: PdfFieldType | null);
     get name(): string;
@@ -52,12 +62,28 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     set onState(state: string);
     get value(): string;
     protected setRawValue(val: string | PdfString): void;
+    updateAppearance(cache?: Set<PdfIndirectObject>): void;
     set value(val: string | PdfString);
+    get markdownValue(): string | undefined;
+    set markdownValue(val: string);
     get fontSize(): number | null;
     set fontSize(size: number);
     get fontName(): string | null;
     set fontName(fontName: string);
     set font(font: PdfFont | null);
+    private _embedFontInDR;
+    get fontFamily(): FontFamily | null;
+    set fontFamily(family: FontFamily | null);
+    get fontVariantNames(): {
+        bold?: string;
+        italic?: string;
+        boldItalic?: string;
+    };
+    protected get resolvedVariantFonts(): {
+        bold?: PdfFont;
+        italic?: PdfFont;
+        boldItalic?: PdfFont;
+    };
     get flags(): PdfFormFieldFlags;
     set flags(v: PdfFormFieldFlags);
     get readOnly(): boolean;

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

@@ -14,6 +14,7 @@ import { PdfFieldType as PdfFieldTypeConst } from './types.js';
 import { PdfFormFieldFlags } from './pdf-form-field-flags.js';
 import { PdfFieldActions } from '../js/pdf-field-actions.js';
 import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
+import { parseMarkdownSegments } from '../../utils/parse-markdown-segments.js';
 /**
  * Abstract base form field class. Extends PdfWidgetAnnotation with form-specific properties:
  * FT, V, DA, Ff, T (name), field hierarchy (parent/children/siblings).
@@ -21,6 +22,9 @@ import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
  */
 export class PdfFormField extends PdfWidgetAnnotation {
     defaultGenerateAppearance = true;
+    /** Raw markdown string set by markdownValue; cleared by setRawValue. */
+    _markdownValue;
+    _fontFamily;
     /** @internal */
     _form;
     constructor(other) {
@@ -79,11 +83,19 @@ export class PdfFormField extends PdfWidgetAnnotation {
         const page = this.page;
         if (page) {
             const annots = page.annotations;
-            const ref = this.reference;
-            const key = ref.key;
-            const alreadyPresent = annots.items.some((r) => r instanceof PdfObjectReference && r.key === key);
+            const widget = this;
+            const alreadyPresent = annots.items.some((r) => {
+                if (!(r instanceof PdfObjectReference))
+                    return false;
+                try {
+                    return r.resolve() === widget;
+                }
+                catch {
+                    return false;
+                }
+            });
             if (!alreadyPresent) {
-                annots.items.push(ref);
+                annots.items.push(this.reference);
             }
         }
     }
@@ -107,7 +119,7 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
     }
     get siblings() {
-        return this.parent?.children ?? [];
+        return (this.parent?.children ?? []).filter((sib) => sib !== this);
     }
     get font() {
         const fontName = this.fontName;
@@ -180,6 +192,39 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         return undefined;
     }
+    /**
+     * Like buildFontResources but includes multiple font names (regular +
+     * variant fonts) in a single Resources/Font dictionary. Falls through to
+     * buildFontResources when only one name is provided.
+     */
+    buildAllFontResources(fontNames) {
+        if (fontNames.length <= 1)
+            return this.buildFontResources(fontNames[0]);
+        const dr = this.defaultResources;
+        const fontRaw = dr?.get('Font');
+        let drFontDict;
+        if (fontRaw instanceof PdfObjectReference) {
+            const resolved = fontRaw.resolve()?.content;
+            if (resolved instanceof PdfDictionary)
+                drFontDict = resolved;
+        }
+        else if (fontRaw instanceof PdfDictionary) {
+            drFontDict = fontRaw;
+        }
+        const resFontDict = new PdfDictionary();
+        for (const name of fontNames) {
+            if (drFontDict?.get(name)) {
+                resFontDict.set(name, drFontDict.get(name));
+            }
+        }
+        if (resFontDict.keys().length > 0) {
+            const resources = new PdfDictionary();
+            resources.set('Font', resFontDict);
+            return resources;
+        }
+        // Fallback to single-font path for the primary font name
+        return this.buildFontResources(fontNames[0]);
+    }
     get fieldType() {
         const ft = PdfFormField.getFieldType(this);
         switch (ft) {
@@ -266,6 +311,7 @@ export class PdfFormField extends PdfWidgetAnnotation {
         return '';
     }
     setRawValue(val) {
+        this._markdownValue = undefined;
         const targets = [this];
         const parent = this.parent;
         if (parent?.fieldType) {
@@ -282,35 +328,52 @@ export class PdfFormField extends PdfWidgetAnnotation {
                 target.content.set('V', pdfVal);
             }
         }
-        if (isEmpty) {
-            this._form?.xfa?.datasets?.updateField(this.name, '');
+        for (const child of this.children) {
+            if (child.content.has('V')) {
+                child.content.delete('V');
+            }
         }
+        this._form?.xfa?.datasets?.updateField(this.name, this.value);
+        this.updateAppearance();
+    }
+    updateAppearance(cache = new Set()) {
+        if (cache.has(this))
+            return;
+        cache.add(this);
         if (this.defaultGenerateAppearance) {
             this.generateAppearance();
         }
         for (const sibling of this.siblings) {
-            if (sibling !== this && sibling.defaultGenerateAppearance) {
-                sibling.generateAppearance();
-            }
+            sibling.updateAppearance(cache);
         }
         // Separated field/widget structure: field has no Rect but its Kids
         // are widget annotations that do. Clear stale V entries on children
         // so they inherit the parent's value, then generate appearances.
         for (const child of this.children) {
-            if (child.content.has('V')) {
-                child.content.delete('V');
-            }
-            if (child.defaultGenerateAppearance) {
-                if (this._form)
-                    child.form = this._form;
-                child.generateAppearance();
-            }
+            if (this._form)
+                child.form = this._form;
+            child.updateAppearance(cache);
         }
-        this._form?.xfa?.datasets?.updateField(this.name, this.value);
     }
     set value(val) {
         this.setRawValue(val);
     }
+    get markdownValue() {
+        return this._markdownValue ?? this.parent?._markdownValue;
+    }
+    set markdownValue(val) {
+        const plainText = parseMarkdownSegments(val)
+            .map((s) => s.text)
+            .join('');
+        // Store plain text as V without triggering appearance generation yet
+        const saved = this.defaultGenerateAppearance;
+        this.defaultGenerateAppearance = false;
+        this.setRawValue(plainText);
+        this.defaultGenerateAppearance = saved;
+        // setRawValue cleared _markdownValue; store the markdown string now
+        this._markdownValue = val;
+        this.updateAppearance();
+    }
     get fontSize() {
         const da = this.defaultAppearance || '';
         const parsed = PdfDefaultAppearance.parse(da);
@@ -352,6 +415,8 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         const resourceName = font.resourceName;
         const currentSize = this.fontSize ?? 12;
+        this._embedFontInDR(font);
+        // Update the DA string to use the font
         const da = this.defaultAppearance || '';
         if (!da) {
             this.content.set('DA', new PdfDefaultAppearance(resourceName, currentSize, '0 g'));
@@ -363,6 +428,62 @@ export class PdfFormField extends PdfWidgetAnnotation {
             this.content.set('DA', parsed);
         }
     }
+    _embedFontInDR(font) {
+        const resourceName = font.resourceName;
+        // Add font to field's default resources
+        const dr = this.content.get('DR') || new PdfDictionary();
+        let fontDict = dr.get('Font');
+        if (!fontDict) {
+            fontDict = new PdfDictionary();
+            dr.set('Font', fontDict);
+        }
+        fontDict.set(resourceName, font.reference);
+        this.content.set('DR', dr);
+        // Also add to form's default resources if available
+        if (this._form) {
+            const formDr = this._form.defaultResources ||
+                new PdfDictionary();
+            let formFontDict = formDr.get('Font');
+            if (!formFontDict) {
+                formFontDict = new PdfDictionary();
+                formDr.set('Font', formFontDict);
+            }
+            formFontDict.set(resourceName, font.reference);
+            this._form.defaultResources = formDr;
+        }
+    }
+    get fontFamily() {
+        return this._fontFamily ?? null;
+    }
+    set fontFamily(family) {
+        if (family === null) {
+            this._fontFamily = undefined;
+            return;
+        }
+        this._fontFamily = family;
+        // Setting regular via the existing setter keeps DA string in sync
+        this.font = family.regular;
+        if (family.bold)
+            this._embedFontInDR(family.bold);
+        if (family.italic)
+            this._embedFontInDR(family.italic);
+        if (family.boldItalic)
+            this._embedFontInDR(family.boldItalic);
+    }
+    get fontVariantNames() {
+        return {
+            bold: this._fontFamily?.bold?.resourceName,
+            italic: this._fontFamily?.italic?.resourceName,
+            boldItalic: this._fontFamily?.boldItalic?.resourceName,
+        };
+    }
+    get resolvedVariantFonts() {
+        return {
+            bold: this._fontFamily?.bold,
+            italic: this._fontFamily?.italic,
+            boldItalic: this._fontFamily?.boldItalic,
+        };
+    }
     get flags() {
         const flags = new PdfFormFieldFlags(this.content.get('Ff') ?? this.parent?.content.get('Ff') ?? 0);
         flags.onChange(() => {

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

@@ -21,7 +21,24 @@ export class PdfTextFormField extends PdfFormField {
         if (!parsed)
             return false;
         const font = this.font;
-        const fontResources = this.buildFontResources(parsed.fontName);
+        const variantNames = this.fontVariantNames;
+        const variantFonts = this.resolvedVariantFonts;
+        const allFontNames = [
+            parsed.fontName,
+            variantNames.bold,
+            variantNames.italic,
+            variantNames.boldItalic,
+        ].filter((n) => !!n);
+        const fontResources = this.buildAllFontResources(allFontNames);
+        const resolvedFonts = new Map();
+        if (font)
+            resolvedFonts.set(parsed.fontName, font);
+        if (variantFonts.bold)
+            resolvedFonts.set(variantNames.bold, variantFonts.bold);
+        if (variantFonts.italic)
+            resolvedFonts.set(variantNames.italic, variantFonts.italic);
+        if (variantFonts.boldItalic)
+            resolvedFonts.set(variantNames.boldItalic, variantFonts.boldItalic);
         const isUnicode = font?.isUnicode ?? false;
         const reverseEncodingMap = font?.reverseEncodingMap;
         this.appearanceStream = new PdfTextAppearanceStream({
@@ -32,8 +49,11 @@ export class PdfTextFormField extends PdfFormField {
             comb: this.comb,
             maxLen: this.maxLen,
             fontResources,
+            resolvedFonts,
             isUnicode,
             reverseEncodingMap,
+            markdown: this.markdownValue,
+            fontVariantNames: variantNames,
         });
         if (options?.makeReadOnly) {
             this.readOnly = true;

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

@@ -119,11 +119,21 @@ export class PdfAcroForm extends PdfIndirectObject {
         const page = field.page;
         if (!page)
             return;
-        const ref = field.reference;
-        const key = ref.key;
-        const alreadyPresent = page.annotations.items.some((r) => r instanceof PdfObjectReference && r.key === key);
+        const annots = page.annotations;
+        // Unregistered fields all share key "-1/0", so compare by object
+        // identity (via resolve()) rather than by key.
+        const alreadyPresent = annots.items.some((r) => {
+            if (!(r instanceof PdfObjectReference))
+                return false;
+            try {
+                return r.resolve() === field;
+            }
+            catch {
+                return false;
+            }
+        });
         if (!alreadyPresent) {
-            page.annotations.items.push(ref);
+            annots.items.push(field.reference);
         }
     }
     set fields(newFields) {

package/dist/fonts/font-family.d.ts

@@ -0,0 +1,12 @@
+import type { PdfFont } from './pdf-font.js';
+/**
+ * A group of font variants for a single typeface family.
+ * Set on a form field via `field.fontFamily` to enable true bold/italic
+ * rendering in markdown appearance streams rather than stroke simulation.
+ */
+export interface FontFamily {
+    regular: PdfFont;
+    bold?: PdfFont;
+    italic?: PdfFont;
+    boldItalic?: PdfFont;
+}

package/dist/fonts/font-family.js

@@ -0,0 +1 @@
+export {};

package/dist/fonts/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './pdf-font.js';
+export * from './font-family.js';
 export * from './parsers/index.js';

package/dist/fonts/index.js

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './pdf-font.js';
+export * from './font-family.js';
 export * from './parsers/index.js';

package/dist/fonts/parsers/otf-parser.d.ts

@@ -41,10 +41,10 @@ export declare class OtfParser implements FontParser {
     private parseOS2;
     private parsePost;
     private parseName;
-    private parseCmap;
+    parseCmap(): Map<number, number>;
     private parseCmapFormat4;
     private parseCmapFormat12;
-    private parseHmtx;
+    parseHmtx(): Map<number, number>;
     private parseMaxp;
     private estimateStemV;
 }

package/dist/fonts/parsers/ttf-parser.d.ts

@@ -33,10 +33,10 @@ export declare class TtfParser implements FontParser {
     private parseOS2;
     private parsePost;
     private parseName;
-    private parseCmap;
+    parseCmap(): Map<number, number>;
     private parseCmapFormat4;
     private parseCmapFormat12;
-    private parseHmtx;
+    parseHmtx(): Map<number, number>;
     private parseMaxp;
     private estimateStemV;
 }

package/dist/fonts/parsers/woff-parser.d.ts

@@ -24,6 +24,8 @@ export declare class WoffParser implements FontParser {
      * Gets character widths for a range of characters.
      */
     getCharWidths(firstChar: number, lastChar: number): number[];
+    parseCmap(): Map<number, number>;
+    parseHmtx(): Map<number, number>;
     private decompressWoff;
 }
 /**

package/dist/fonts/parsers/woff-parser.js

@@ -35,6 +35,12 @@ export class WoffParser {
     getCharWidths(firstChar, lastChar) {
         return this.ttfParser.getCharWidths(firstChar, lastChar);
     }
+    parseCmap() {
+        return this.ttfParser.parseCmap();
+    }
+    parseHmtx() {
+        return this.ttfParser.parseHmtx();
+    }
     decompressWoff(woffData) {
         const data = new DataView(woffData.buffer, woffData.byteOffset, woffData.byteLength);
         // Verify WOFF signature

package/dist/fonts/pdf-font.js

@@ -213,6 +213,27 @@ export class PdfFont extends PdfIndirectObject {
      * @returns The raw character width or null if not found
      */
     getRawCharacterWidth(charCode) {
+        // For Type0 fonts, check CID widths in descriptor
+        if (this.isUnicode && this._descriptor) {
+            const unicodeDesc = this._descriptor;
+            if (unicodeDesc.cidWidths) {
+                // Find width for this CID (which equals Unicode code point for Identity-H)
+                for (const entry of unicodeDesc.cidWidths) {
+                    if ('width' in entry && entry.cid === charCode) {
+                        return entry.width;
+                    }
+                    else if ('widths' in entry) {
+                        const offset = charCode - entry.startCid;
+                        if (offset >= 0 && offset < entry.widths.length) {
+                            return entry.widths[offset];
+                        }
+                    }
+                }
+                // Not found, use default width
+                return unicodeDesc.defaultWidth ?? 1000;
+            }
+        }
+        // For Type1/TrueType fonts, use simple widths array
         if (this.widths === undefined || this.firstChar === undefined) {
             return null;
         }
@@ -285,8 +306,7 @@ export class PdfFont extends PdfIndirectObject {
      * @returns A PdfFont instance ready to be written to the PDF
      */
     static fromBytes(data) {
-        const parser = parseFont(data);
-        return PdfFont.fromParser(parser);
+        return PdfFont.fromFile(data);
     }
     /**
      * Creates a PdfFont from a FontParser instance.
@@ -582,8 +602,37 @@ export class PdfFont extends PdfIndirectObject {
         if (descriptor.cidWidths && descriptor.cidWidths.length > 0) {
             cidFontDict.set('W', PdfFont.buildCIDWidthArray(descriptor.cidWidths));
         }
-        // CIDToGIDMap
-        cidFontDict.set('CIDToGIDMap', new PdfName(descriptor.cidToGidMap ?? 'Identity'));
+        // CIDToGIDMap - Generate binary stream if unicodeMappings provided
+        if (unicodeMappings && unicodeMappings.size > 0) {
+            // Create a binary CIDToGIDMap stream
+            // For Identity-H encoding, CID = Unicode value
+            // We need to map each CID to its GID
+            const maxCid = Math.max(...Array.from(unicodeMappings.keys()));
+            const cidToGidData = new Uint8Array((maxCid + 1) * 2);
+            // Initialize all mappings to 0 (missing glyph)
+            for (let i = 0; i < cidToGidData.length; i++) {
+                cidToGidData[i] = 0;
+            }
+            // Fill in the mappings
+            for (const [unicode, glyphId] of unicodeMappings.entries()) {
+                const offset = unicode * 2;
+                // Big-endian 16-bit glyph ID
+                cidToGidData[offset] = (glyphId >> 8) & 0xff;
+                cidToGidData[offset + 1] = glyphId & 0xff;
+            }
+            const cidToGidStream = new PdfStream({
+                header: new PdfDictionary(),
+                original: cidToGidData,
+            });
+            cidToGidStream.addFilter('FlateDecode');
+            const cidToGidObject = new PdfIndirectObject({
+                content: cidToGidStream,
+            });
+            cidFontDict.set('CIDToGIDMap', cidToGidObject.reference);
+        }
+        else {
+            cidFontDict.set('CIDToGIDMap', new PdfName(descriptor.cidToGidMap ?? 'Identity'));
+        }
         const cidFontObject = new PdfIndirectObject({
             content: cidFontDict,
         });
@@ -611,21 +660,58 @@ export class PdfFont extends PdfIndirectObject {
     static fromFile(fontData, options) {
         // Parse the font to extract metadata
         const parser = parseFont(fontData);
+        // Check if CFF-based OTF (not supported)
+        if (parser instanceof OtfParser && parser.isCFFBased()) {
+            throw new Error('CFF-based OTF fonts are not supported yet');
+        }
         const info = parser.getFontInfo();
         // Auto-generate font name from metadata if not provided
         const fontName = options?.fontName ?? info.postScriptName ?? info.fullName;
         // Get the appropriate descriptor based on unicode option
         const descriptor = parser.getFontDescriptor(fontName);
+        // Auto-detect if Unicode font is needed if not explicitly specified
+        let useUnicode = options?.unicode;
+        if (useUnicode === undefined) {
+            // Check if font has glyphs beyond WinAnsiEncoding range (0-255)
+            const cmap = parser.parseCmap();
+            useUnicode = Array.from(cmap.keys()).some((unicode) => unicode > 0xff);
+        }
         // Embed using the appropriate method and return PdfFont
-        if (options?.unicode) {
+        if (useUnicode) {
+            // Auto-extract cmap if not provided
+            const unicodeMappings = options?.unicodeMappings ?? parser.parseCmap();
+            // Extract glyph widths for Unicode characters
+            const hmtx = parser.parseHmtx();
+            const unitsPerEm = info.unitsPerEm;
+            const cidWidths = [];
+            // Build CID widths array from cmap + hmtx
+            for (const [unicode, glyphId] of unicodeMappings.entries()) {
+                const glyphWidth = hmtx.get(glyphId) ?? 0;
+                // Scale to 1000-unit em square
+                const scaledWidth = Math.round((glyphWidth * 1000) / unitsPerEm);
+                cidWidths.push({ cid: unicode, width: scaledWidth });
+            }
+            // Compute average width for default
+            const avgWidth = cidWidths.length > 0
+                ? Math.round(cidWidths.reduce((sum, entry) => {
+                    if ('width' in entry) {
+                        return sum + entry.width;
+                    }
+                    else {
+                        // Average the widths in the range
+                        const rangeSum = entry.widths.reduce((a, b) => a + b, 0);
+                        return sum + rangeSum / entry.widths.length;
+                    }
+                }, 0) / cidWidths.length)
+                : 1000;
             // For Unicode fonts, we need a UnicodeFontDescriptor
-            // Create one by extending the base descriptor
             const unicodeDescriptor = {
                 ...descriptor,
-                defaultWidth: 1000,
+                defaultWidth: avgWidth,
+                cidWidths,
                 cidToGidMap: 'Identity',
             };
-            return PdfFont.fromType0Data(fontData, fontName, unicodeDescriptor, options.unicodeMappings);
+            return PdfFont.fromType0Data(fontData, fontName, unicodeDescriptor, unicodeMappings);
         }
         else {
             // Use standard TrueType embedding

package/dist/fonts/types.d.ts

@@ -8,6 +8,16 @@ export interface FontParser {
     getFontDescriptor(fontName?: string): FontDescriptor;
     getCharWidths(firstChar: number, lastChar: number): number[];
     getFontData(): ByteArray;
+    /**
+     * Parses the font's cmap table to extract Unicode to glyph ID mappings.
+     * @returns A map from Unicode code points to glyph IDs
+     */
+    parseCmap(): Map<number, number>;
+    /**
+     * Parses the font's hmtx table to extract glyph advance widths.
+     * @returns A map from glyph IDs to advance widths (in font units)
+     */
+    parseHmtx(): Map<number, number>;
 }
 /**
  * Parsed TrueType font information.

package/dist/utils/parse-markdown-segments.d.ts

@@ -0,0 +1,13 @@
+export type StyledSegment = {
+    text: string;
+    bold: boolean;
+    italic: boolean;
+    strikethrough: boolean;
+};
+/**
+ * Parses a markdown string with **bold**, __bold__, *italic*, ***bold+italic***,
+ * and ~~strikethrough~~ syntax into an array of styled text segments.
+ *
+ * Unrecognized or unmatched markers are emitted as plain text.
+ */
+export declare function parseMarkdownSegments(text: string): StyledSegment[];

package/dist/utils/parse-markdown-segments.js

@@ -0,0 +1,71 @@
+/**
+ * Parses a markdown string with **bold**, __bold__, *italic*, ***bold+italic***,
+ * and ~~strikethrough~~ syntax into an array of styled text segments.
+ *
+ * Unrecognized or unmatched markers are emitted as plain text.
+ */
+export function parseMarkdownSegments(text) {
+    const segments = [];
+    // Match longest tokens first: ***…***, **…**, __…__, ~~…~~, *…*, _…_
+    const re = /\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|__(.+?)__|~~(.+?)~~|\*(.+?)\*|_(.+?)_|([^*_~]+|[*_~])/gs;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        if (match[1] !== undefined) {
+            segments.push({
+                text: match[1],
+                bold: true,
+                italic: true,
+                strikethrough: false,
+            });
+        }
+        else if (match[2] !== undefined) {
+            segments.push({
+                text: match[2],
+                bold: true,
+                italic: false,
+                strikethrough: false,
+            });
+        }
+        else if (match[3] !== undefined) {
+            segments.push({
+                text: match[3],
+                bold: true,
+                italic: false,
+                strikethrough: false,
+            });
+        }
+        else if (match[4] !== undefined) {
+            segments.push({
+                text: match[4],
+                bold: false,
+                italic: false,
+                strikethrough: true,
+            });
+        }
+        else if (match[5] !== undefined) {
+            segments.push({
+                text: match[5],
+                bold: false,
+                italic: true,
+                strikethrough: false,
+            });
+        }
+        else if (match[6] !== undefined) {
+            segments.push({
+                text: match[6],
+                bold: false,
+                italic: true,
+                strikethrough: false,
+            });
+        }
+        else if (match[7] !== undefined && match[7].length > 0) {
+            segments.push({
+                text: match[7],
+                bold: false,
+                italic: false,
+                strikethrough: false,
+            });
+        }
+    }
+    return segments;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-lite",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "main": "dist/index.js",
   "type": "module",
   "exports": {