pdf-lite 1.7.1 → 1.7.2

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

@@ -65,15 +65,14 @@ export declare class PdfGraphics {
     measureTextWidthWithFont(text: string, fontName: string | undefined, fontSize: number): number;
     /**
      * Emits styled text segments into the current BT…ET block.
-     * When font variants are configured, switches fonts mid-stream for true
-     * bold/italic rendering. Falls back to stroke simulation / Tm shear when
-     * no variant fonts are provided (backward compatible).
-     * Each segment is positioned with an absolute Tm so no prior Td is needed.
+     * 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 and renders the styled segments into the current
-     * BT…ET block. Pass `multiline` to wrap across multiple lines.
+     * 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;

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

@@ -110,7 +110,12 @@ export class PdfGraphics {
         const chars = [];
         for (const seg of segments) {
             for (const char of seg.text) {
-                chars.push({ char, bold: seg.bold, italic: seg.italic });
+                chars.push({
+                    char,
+                    bold: seg.bold,
+                    italic: seg.italic,
+                    strikethrough: seg.strikethrough,
+                });
             }
         }
         const result = [];
@@ -125,23 +130,29 @@ export class PdfGraphics {
             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 } = chars[pos];
+                const { char, bold, italic, strikethrough } = chars[pos];
                 if (curText === '') {
                     curText = char;
                     curBold = bold;
                     curItalic = italic;
+                    curStrikethrough = strikethrough;
                 }
-                else if (bold !== curBold || italic !== curItalic) {
+                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;
@@ -152,6 +163,7 @@ export class PdfGraphics {
                     text: curText,
                     bold: curBold,
                     italic: curItalic,
+                    strikethrough: curStrikethrough,
                 });
             result.push(lineSegs);
         }
@@ -189,14 +201,13 @@ export class PdfGraphics {
     }
     /**
      * Emits styled text segments into the current BT…ET block.
-     * When font variants are configured, switches fonts mid-stream for true
-     * bold/italic rendering. Falls back to stroke simulation / Tm shear when
-     * no variant fonts are provided (backward compatible).
-     * Each segment is positioned with an absolute Tm so no prior Td is needed.
+     * 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) {
@@ -208,7 +219,11 @@ export class PdfGraphics {
                 this.raw(`/${variantName} ${fontSize} Tf`);
                 this.raw(`0 Tr`);
                 this.showText(seg.text, segIsUnicode, segEncMap);
-                x += this.measureTextWidthWithFont(seg.text, variantName, fontSize);
+                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)
@@ -224,30 +239,52 @@ export class PdfGraphics {
                     this.raw(`0 Tr`);
                 }
                 this.showText(seg.text, isUnicode, reverseEncodingMap);
-                x += this.measureTextWidth(seg.text, fontSize);
+                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 this;
+        return strikethroughRects;
     }
     /**
-     * Parses a markdown string and renders the styled segments into the current
-     * BT…ET block. Pass `multiline` to wrap across multiple lines.
+     * 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++) {
-                this.showSegments(styledLines[i], isUnicode, reverseEncodingMap, x, y - i * multiline.lineHeight, fontSize);
+                const rects = this.showSegments(styledLines[i], isUnicode, reverseEncodingMap, x, y - i * multiline.lineHeight, fontSize);
+                allStrikethroughRects.push(...rects);
             }
         }
         else {
-            this.showSegments(segments, isUnicode, reverseEncodingMap, x, y, fontSize);
+            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;
     }

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

@@ -100,7 +100,6 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
             lines = g.wrapTextToLines(value, availableWidth);
             const renderLineHeight = finalFontSize * 1.2;
             const startY = height - padding - finalFontSize;
-            g.beginText();
             if (ctx.markdown) {
                 g.showMarkdown(ctx.markdown, isUnicode, reverseEncodingMap, padding, startY, finalFontSize, {
                     availableWidth,
@@ -108,14 +107,15 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
                 });
             }
             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
@@ -126,15 +126,15 @@ export class PdfTextAppearanceStream extends PdfAppearanceStream {
                 }
             }
             const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
-            g.beginText();
             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.endText();
         }
         g.restore();
         g.endMarkedContent();

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

@@ -62,7 +62,9 @@ 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);

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

@@ -83,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);
             }
         }
     }
@@ -111,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;
@@ -320,35 +328,39 @@ 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)
@@ -360,9 +372,7 @@ export class PdfFormField extends PdfWidgetAnnotation {
         this.defaultGenerateAppearance = saved;
         // setRawValue cleared _markdownValue; store the markdown string now
         this._markdownValue = val;
-        if (this.defaultGenerateAppearance) {
-            this.generateAppearance();
-        }
+        this.updateAppearance();
     }
     get fontSize() {
         const da = this.defaultAppearance || '';

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

@@ -52,7 +52,7 @@ export class PdfTextFormField extends PdfFormField {
             resolvedFonts,
             isUnicode,
             reverseEncodingMap,
-            markdown: this._markdownValue,
+            markdown: this.markdownValue,
             fontVariantNames: variantNames,
         });
         if (options?.makeReadOnly) {

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/utils/parse-markdown-segments.d.ts

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

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

@@ -1,26 +1,70 @@
 /**
- * Parses a markdown string with **bold**, *italic*, and ***bold+italic***
- * syntax into an array of styled text segments.
+ * Parses a markdown string with **bold**, __bold__, *italic*, ***bold+italic***,
+ * and ~~strikethrough~~ syntax into an array of styled text segments.
  *
- * Unrecognized or unmatched asterisks are emitted as plain text.
+ * Unrecognized or unmatched markers are emitted as plain text.
  */
 export function parseMarkdownSegments(text) {
     const segments = [];
-    // Match *** before ** before * to handle longest-match first
-    const re = /\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|([^*]+|\*)/gs;
+    // 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 });
+            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 });
+            segments.push({
+                text: match[2],
+                bold: true,
+                italic: false,
+                strikethrough: false,
+            });
         }
         else if (match[3] !== undefined) {
-            segments.push({ text: match[3], bold: false, italic: true });
+            segments.push({
+                text: match[3],
+                bold: true,
+                italic: false,
+                strikethrough: false,
+            });
         }
-        else if (match[4] !== undefined && match[4].length > 0) {
-            segments.push({ text: match[4], bold: false, italic: 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.1",
+  "version": "1.7.2",
   "main": "dist/index.js",
   "type": "module",
   "exports": {