pdf-lite 1.6.1 → 1.6.3

package/dist/acroform/js/pdf-js-builtins.js

@@ -0,0 +1,454 @@
+// ---------------------------------------------------------------------------
+// util.printd — format a Date as a string using Acrobat date tokens
+// ---------------------------------------------------------------------------
+const MONTH_NAMES = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+const MONTH_ABBR = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+];
+const DAY_NAMES = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday',
+];
+const DAY_ABBR = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+function pad(n, len) {
+    return String(n).padStart(len, '0');
+}
+export function printd(fmt, date) {
+    const y = date.getFullYear();
+    const M = date.getMonth(); // 0-based
+    const d = date.getDate();
+    const dow = date.getDay();
+    const H = date.getHours();
+    const m = date.getMinutes();
+    const s = date.getSeconds();
+    const h12 = H % 12 || 12;
+    // Replace tokens longest-first to avoid partial matches
+    return fmt
+        .replace(/yyyy/g, String(y))
+        .replace(/yy/g, pad(y % 100, 2))
+        .replace(/mmmm/g, MONTH_NAMES[M])
+        .replace(/mmm/g, MONTH_ABBR[M])
+        .replace(/mm/g, pad(M + 1, 2))
+        .replace(/(?<![\w])m(?![\w])/g, String(M + 1))
+        .replace(/dddd/g, DAY_NAMES[dow])
+        .replace(/ddd/g, DAY_ABBR[dow])
+        .replace(/dd/g, pad(d, 2))
+        .replace(/(?<![\w])d(?![\w])/g, String(d))
+        .replace(/HH/g, pad(H, 2))
+        .replace(/hh/g, pad(h12, 2))
+        .replace(/(?<![\w])h(?![\w])/g, String(h12))
+        .replace(/MM/g, pad(m, 2))
+        .replace(/ss/g, pad(s, 2))
+        .replace(/tt/g, H < 12 ? 'AM' : 'PM')
+        .replace(/(?<![\w])t(?![\w])/g, H < 12 ? 'am' : 'pm');
+}
+// ---------------------------------------------------------------------------
+// util.scand — parse a date string using an Acrobat format
+// ---------------------------------------------------------------------------
+export function scand(fmt, str) {
+    // Build a regex from the format, capturing groups for each token
+    const tokens = [];
+    let pattern = '';
+    let i = 0;
+    while (i < fmt.length) {
+        let matched = false;
+        for (const tok of [
+            'yyyy',
+            'yy',
+            'mmmm',
+            'mmm',
+            'mm',
+            'm',
+            'dddd',
+            'ddd',
+            'dd',
+            'd',
+            'HH',
+            'hh',
+            'h',
+            'MM',
+            'ss',
+        ]) {
+            if (fmt.substring(i, i + tok.length) === tok) {
+                tokens.push({ token: tok, index: tokens.length });
+                switch (tok) {
+                    case 'yyyy':
+                        pattern += '(\\d{4})';
+                        break;
+                    case 'yy':
+                        pattern += '(\\d{2})';
+                        break;
+                    case 'mmmm':
+                        pattern += '([A-Za-z]+)';
+                        break;
+                    case 'mmm':
+                        pattern += '([A-Za-z]{3})';
+                        break;
+                    case 'mm':
+                        pattern += '(\\d{2})';
+                        break;
+                    case 'm':
+                        pattern += '(\\d{1,2})';
+                        break;
+                    case 'dddd':
+                        pattern += '([A-Za-z]+)';
+                        break;
+                    case 'ddd':
+                        pattern += '([A-Za-z]{3})';
+                        break;
+                    case 'dd':
+                        pattern += '(\\d{2})';
+                        break;
+                    case 'd':
+                        pattern += '(\\d{1,2})';
+                        break;
+                    case 'HH':
+                    case 'hh':
+                        pattern += '(\\d{2})';
+                        break;
+                    case 'h':
+                        pattern += '(\\d{1,2})';
+                        break;
+                    case 'MM':
+                        pattern += '(\\d{2})';
+                        break;
+                    case 'ss':
+                        pattern += '(\\d{2})';
+                        break;
+                }
+                i += tok.length;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            pattern += fmt[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            i++;
+        }
+    }
+    const re = new RegExp('^' + pattern + '$');
+    const match = str.match(re);
+    if (!match)
+        return null;
+    let year = 0, month = 0, day = 1, hours = 0, minutes = 0, seconds = 0;
+    for (const { token, index } of tokens) {
+        const val = match[index + 1];
+        switch (token) {
+            case 'yyyy':
+                year = parseInt(val, 10);
+                break;
+            case 'yy': {
+                const n = parseInt(val, 10);
+                year = n < 50 ? 2000 + n : 1900 + n;
+                break;
+            }
+            case 'mmmm': {
+                const idx = MONTH_NAMES.findIndex((m) => m.toLowerCase() === val.toLowerCase());
+                if (idx >= 0)
+                    month = idx;
+                break;
+            }
+            case 'mmm': {
+                const idx = MONTH_ABBR.findIndex((m) => m.toLowerCase() === val.toLowerCase());
+                if (idx >= 0)
+                    month = idx;
+                break;
+            }
+            case 'mm':
+            case 'm':
+                month = parseInt(val, 10) - 1;
+                break;
+            case 'dd':
+            case 'd':
+                day = parseInt(val, 10);
+                break;
+            case 'HH':
+            case 'hh':
+            case 'h':
+                hours = parseInt(val, 10);
+                break;
+            case 'MM':
+                minutes = parseInt(val, 10);
+                break;
+            case 'ss':
+                seconds = parseInt(val, 10);
+                break;
+            // dddd/ddd are day-of-week names — informational only, ignored
+        }
+    }
+    return new Date(year, month, day, hours, minutes, seconds);
+}
+// ---------------------------------------------------------------------------
+// util.printf — sprintf subset: %d, %f, %s with width/precision/flags
+// ---------------------------------------------------------------------------
+export function printf(fmt, ...args) {
+    let argIdx = 0;
+    return fmt.replace(/%([0 #+-]*)(\d+)?(?:\.(\d+))?([dfsxXo%])/g, (_match, flags, widthStr, precStr, type) => {
+        if (type === '%')
+            return '%';
+        const val = args[argIdx++];
+        const width = widthStr ? parseInt(widthStr, 10) : 0;
+        const prec = precStr !== undefined ? parseInt(precStr, 10) : undefined;
+        const leftAlign = flags.includes('-');
+        const zeroPad = flags.includes('0') && !leftAlign;
+        const plusSign = flags.includes('+');
+        const spaceSign = flags.includes(' ');
+        let result;
+        switch (type) {
+            case 'd': {
+                const n = Math.trunc(Number(val));
+                const sign = n < 0 ? '-' : plusSign ? '+' : spaceSign ? ' ' : '';
+                const digits = String(Math.abs(n));
+                result =
+                    sign +
+                        (zeroPad
+                            ? digits.padStart(Math.max(0, width - sign.length), '0')
+                            : digits);
+                break;
+            }
+            case 'f': {
+                const n = Number(val);
+                const p = prec !== undefined ? prec : 6;
+                const sign = n < 0 ? '-' : plusSign ? '+' : spaceSign ? ' ' : '';
+                const formatted = Math.abs(n).toFixed(p);
+                result =
+                    sign +
+                        (zeroPad
+                            ? formatted.padStart(Math.max(0, width - sign.length), '0')
+                            : formatted);
+                break;
+            }
+            case 'x':
+                result = (Math.trunc(Number(val)) >>> 0).toString(16);
+                break;
+            case 'X':
+                result = (Math.trunc(Number(val)) >>> 0)
+                    .toString(16)
+                    .toUpperCase();
+                break;
+            case 'o':
+                result = (Math.trunc(Number(val)) >>> 0).toString(8);
+                break;
+            case 's':
+            default:
+                result = String(val);
+                if (prec !== undefined)
+                    result = result.slice(0, prec);
+                break;
+        }
+        if (result.length < width) {
+            result = leftAlign
+                ? result.padEnd(width)
+                : result.padStart(width, zeroPad ? '0' : ' ');
+        }
+        return result;
+    });
+}
+// ---------------------------------------------------------------------------
+// util object
+// ---------------------------------------------------------------------------
+export const util = { printd, scand, printf };
+function parseNumericValue(str) {
+    // Strip currency symbols, spaces, commas
+    const cleaned = str.replace(/[^0-9.\-eE]/g, '');
+    const n = parseFloat(cleaned);
+    return isNaN(n) ? 0 : n;
+}
+function formatNumber(value, nDec, sepStyle, negStyle, _currStyle, strCurrency, bCurrencyPrepend) {
+    const absVal = Math.abs(value);
+    const fixed = absVal.toFixed(nDec);
+    // sepStyle: 0 = 1,234.56  1 = 1234.56  2 = 1.234,56  3 = 1234,56
+    let [intPart, decPart] = fixed.split('.');
+    const decSep = sepStyle >= 2 ? ',' : '.';
+    const thousandSep = sepStyle === 0 ? ',' : sepStyle === 2 ? '.' : '';
+    if (thousandSep) {
+        intPart = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSep);
+    }
+    let formatted = decPart !== undefined ? intPart + decSep + decPart : intPart;
+    // Currency
+    if (strCurrency) {
+        if (bCurrencyPrepend) {
+            formatted = strCurrency + formatted;
+        }
+        else {
+            formatted = formatted + strCurrency;
+        }
+    }
+    // Negative style: 0 = -val  1 = red text (we just use -)  2 = (val)  3 = (val) red
+    if (value < 0) {
+        if (negStyle === 0 || negStyle === 1) {
+            formatted = '-' + formatted;
+        }
+        else {
+            formatted = '(' + formatted + ')';
+        }
+    }
+    return formatted;
+}
+export function createBuiltins(event, getFieldValue) {
+    // --- AF functions that close over event ---
+    function AFDate_FormatEx(fmt) {
+        if (!event.value)
+            return;
+        // Try parsing the current value as a date
+        const d = new Date(event.value);
+        if (isNaN(d.getTime()))
+            return;
+        event.value = printd(fmt, d);
+    }
+    function AFDate_KeystrokeEx(fmt) {
+        if (event.willCommit) {
+            if (!event.value)
+                return;
+            const d = scand(fmt, event.value);
+            if (!d) {
+                event.rc = false;
+            }
+        }
+        // On non-commit keystrokes, allow all input
+    }
+    function AFNumber_Format(nDec, sepStyle, negStyle, _currStyle, strCurrency, bCurrencyPrepend) {
+        if (!event.value && event.value !== '0')
+            return;
+        const num = parseNumericValue(event.value);
+        event.value = formatNumber(num, nDec, sepStyle, negStyle, _currStyle, strCurrency, bCurrencyPrepend);
+    }
+    function AFNumber_Keystroke(nDec, _sepStyle, _negStyle, _currStyle, _strCurrency, _bCurrencyPrepend) {
+        if (event.willCommit) {
+            if (!event.value)
+                return;
+            const num = parseFloat(event.value);
+            if (isNaN(num)) {
+                event.rc = false;
+                return;
+            }
+            // Check decimal places
+            const parts = event.value.split('.');
+            if (nDec === 0 && parts.length > 1) {
+                event.rc = false;
+            }
+        }
+    }
+    function AFSimple_Calculate(op, fields) {
+        if (!getFieldValue)
+            return;
+        const values = fields.map((name) => parseNumericValue(getFieldValue(name)));
+        let result;
+        switch (op.toUpperCase()) {
+            case 'SUM':
+                result = values.reduce((a, b) => a + b, 0);
+                break;
+            case 'AVG':
+                result = values.length
+                    ? values.reduce((a, b) => a + b, 0) / values.length
+                    : 0;
+                break;
+            case 'PRD':
+                result = values.reduce((a, b) => a * b, 1);
+                break;
+            case 'MIN':
+                result = values.length ? Math.min(...values) : 0;
+                break;
+            case 'MAX':
+                result = values.length ? Math.max(...values) : 0;
+                break;
+            default:
+                return;
+        }
+        event.value = String(result);
+    }
+    function AFSpecial_Format(psf) {
+        if (!event.value)
+            return;
+        const digits = event.value.replace(/\D/g, '');
+        switch (psf) {
+            case 0: // zip: 12345
+                event.value = digits.slice(0, 5).padEnd(5, '0');
+                break;
+            case 1: // ssn: 123-45-6789
+                event.value =
+                    digits.slice(0, 3) +
+                        '-' +
+                        digits.slice(3, 5) +
+                        '-' +
+                        digits.slice(5, 9);
+                break;
+            case 2: // phone: (123) 456-7890
+                event.value =
+                    '(' +
+                        digits.slice(0, 3) +
+                        ') ' +
+                        digits.slice(3, 6) +
+                        '-' +
+                        digits.slice(6, 10);
+                break;
+            case 3: // zip+4: 12345-6789
+                event.value = digits.slice(0, 5) + '-' + digits.slice(5, 9);
+                break;
+        }
+    }
+    function AFSpecial_Keystroke(psf) {
+        if (!event.willCommit)
+            return;
+        if (!event.value)
+            return;
+        const digits = event.value.replace(/\D/g, '');
+        switch (psf) {
+            case 0: // zip
+                if (digits.length !== 5)
+                    event.rc = false;
+                break;
+            case 1: // ssn
+                if (digits.length !== 9)
+                    event.rc = false;
+                break;
+            case 2: // phone
+                if (digits.length !== 10 && digits.length !== 7)
+                    event.rc = false;
+                break;
+            case 3: // zip+4
+                if (digits.length !== 9)
+                    event.rc = false;
+                break;
+        }
+    }
+    return {
+        util,
+        AFDate_FormatEx,
+        AFDate_KeystrokeEx,
+        AFNumber_Format,
+        AFNumber_Keystroke,
+        AFSimple_Calculate,
+        AFSpecial_Format,
+        AFSpecial_Keystroke,
+    };
+}

package/dist/acroform/js/pdf-js-engine-impl.d.ts

@@ -0,0 +1,18 @@
+import type { PdfJsEngine, PdfJsEvent } from './pdf-js-engine.js';
+export interface PdfJavaScriptEngineOptions {
+    getFieldValue?: (name: string) => string;
+}
+/**
+ * Default JavaScript engine that executes PDF JS actions via `new Function()`.
+ *
+ * **Security note:** This engine runs PDF-sourced JavaScript with access to the
+ * ambient JS environment (e.g. `globalThis`, constructors, network APIs). It is
+ * NOT sandboxed and should only be used with trusted PDF documents. For untrusted
+ * documents, provide your own `PdfJsEngine` implementation that evaluates code
+ * in an isolated context (e.g. Node `vm`, a dedicated realm, or a Web Worker).
+ */
+export declare class PdfJavaScriptEngine implements PdfJsEngine {
+    private _getFieldValue?;
+    constructor(options?: PdfJavaScriptEngineOptions);
+    execute(code: string, event: PdfJsEvent): void;
+}

package/dist/acroform/js/pdf-js-engine-impl.js

@@ -0,0 +1,22 @@
+import { createBuiltins } from './pdf-js-builtins.js';
+/**
+ * Default JavaScript engine that executes PDF JS actions via `new Function()`.
+ *
+ * **Security note:** This engine runs PDF-sourced JavaScript with access to the
+ * ambient JS environment (e.g. `globalThis`, constructors, network APIs). It is
+ * NOT sandboxed and should only be used with trusted PDF documents. For untrusted
+ * documents, provide your own `PdfJsEngine` implementation that evaluates code
+ * in an isolated context (e.g. Node `vm`, a dedicated realm, or a Web Worker).
+ */
+export class PdfJavaScriptEngine {
+    _getFieldValue;
+    constructor(options) {
+        this._getFieldValue = options?.getFieldValue;
+    }
+    execute(code, event) {
+        const builtins = createBuiltins(event, this._getFieldValue);
+        const names = Object.keys(builtins);
+        const fn = new Function('event', 'app', ...names, code);
+        fn(event, Object.freeze({ alert() { } }), ...names.map((k) => builtins[k]));
+    }
+}

package/dist/acroform/js/pdf-js-engine.d.ts

@@ -0,0 +1,10 @@
+export interface PdfJsEvent {
+    fieldName: string;
+    value: string;
+    willCommit?: boolean;
+    rc: boolean;
+    changeEx?: string;
+}
+export interface PdfJsEngine {
+    execute(code: string, event: PdfJsEvent): void;
+}

package/dist/acroform/js/pdf-js-engine.js

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

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

@@ -12,6 +12,7 @@ import './fields/pdf-choice-form-field.js';
 import './fields/pdf-signature-form-field.js';
 import { PdfDefaultResourcesDictionary } from '../annotations/pdf-default-resources.js';
 import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+import type { PdfJsEngine } from './js/pdf-js-engine.js';
 export declare class PdfAcroForm<T extends Record<string, string> = Record<string, string>> extends PdfIndirectObject<PdfDictionary<{
     Fields: PdfArray<PdfObjectReference> | PdfObjectReference;
     NeedAppearances?: PdfBoolean;
@@ -38,7 +39,10 @@ export declare class PdfAcroForm<T extends Record<string, string> = Record<strin
     set fields(newFields: PdfFormField[]);
     setValues(values: Partial<T>): void;
     importData(fields: T): void;
+    private _fireValidate;
+    private _fireCalculate;
     exportData(): Partial<T>;
+    jsEngine?: PdfJsEngine;
     fontEncodingMaps: Map<string, Map<number, string>>;
     getFontEncodingMap(fontName: string): Map<number, string> | null;
     get xfa(): PdfXfaForm | null;

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

@@ -122,15 +122,70 @@ export class PdfAcroForm extends PdfIndirectObject {
         for (const field of this.fields) {
             const name = field.name;
             if (name in values && values[name] !== undefined) {
-                field.value = values[name];
+                const result = this._fireValidate(field, values[name]);
+                if (!result.rc)
+                    continue;
+                field.value = result.value;
             }
         }
+        this._fireCalculate();
     }
     importData(fields) {
         for (const field of this.fields) {
             const name = field.name;
             if (name && name in fields) {
-                field.value = fields[name];
+                const result = this._fireValidate(field, fields[name]);
+                if (!result.rc)
+                    continue;
+                field.value = result.value;
+            }
+        }
+        this._fireCalculate();
+    }
+    _fireValidate(field, value) {
+        const validateAction = field.actions?.validate;
+        if (!validateAction?.code)
+            return { rc: true, value };
+        const event = {
+            fieldName: field.name,
+            value,
+            willCommit: true,
+            rc: true,
+        };
+        validateAction.execute(event);
+        return { rc: event.rc, value: event.value };
+    }
+    _fireCalculate() {
+        const co = this.content.get('CO');
+        if (!(co instanceof PdfArray))
+            return;
+        const allFields = this.fields;
+        const fieldsByObjNum = new Map();
+        for (const field of allFields) {
+            if (field.objectNumber != null) {
+                fieldsByObjNum.set(field.objectNumber, field);
+            }
+        }
+        for (const item of co.items) {
+            if (!(item instanceof PdfObjectReference))
+                continue;
+            const resolved = item.resolve();
+            if (!resolved)
+                continue;
+            const field = fieldsByObjNum.get(resolved.objectNumber);
+            if (!field)
+                continue;
+            const calcAction = field.actions?.calculate;
+            if (!calcAction?.code)
+                continue;
+            const event = {
+                fieldName: field.name,
+                value: field.value,
+                rc: true,
+            };
+            calcAction.execute(event);
+            if (event.rc && event.value !== field.value) {
+                field.value = event.value;
             }
         }
     }
@@ -144,6 +199,7 @@ export class PdfAcroForm extends PdfIndirectObject {
         }
         return result;
     }
+    jsEngine;
     fontEncodingMaps = new Map();
     getFontEncodingMap(fontName) {
         if (this.fontEncodingMaps.has(fontName)) {

package/dist/annotations/pdf-annotation.d.ts

@@ -34,6 +34,26 @@ export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
     AP?: PdfAppearanceStreamDictionary;
     P?: PdfObjectReference;
     Parent?: PdfObjectReference<PdfPage>;
+    A?: PdfDictionary<{
+        Type?: PdfName;
+        S?: PdfName;
+        D?: PdfArray | PdfDictionary;
+        T?: PdfString;
+        F?: PdfNumber;
+        Win?: PdfDictionary;
+        JS?: PdfString;
+    }>;
+    AA?: PdfDictionary<{
+        D?: PdfObjectReference | PdfDictionary;
+        U?: PdfObjectReference | PdfDictionary;
+        Fo?: PdfObjectReference | PdfDictionary;
+        Bl?: PdfObjectReference | PdfDictionary;
+        PO?: PdfObjectReference | PdfDictionary;
+        K?: PdfObjectReference | PdfDictionary;
+        V?: PdfObjectReference | PdfDictionary;
+        C?: PdfObjectReference | PdfDictionary;
+        F?: PdfObjectReference | PdfDictionary;
+    }>;
 }>> {
     private _annotationFlags?;
     private get flags_();

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

@@ -22,6 +22,8 @@ export declare class PdfDictionary<T extends PdfDictionaryEntries = PdfDictionar
     entries(): IterableIterator<[string, PdfObject | undefined]>;
     get isTrailingDelimited(): boolean;
     protected tokenize(): PdfToken[];
+    /** Factory-style type conversion: constructs a new instance passing `this` as the first argument */
+    becomes<U extends PdfDictionary, A extends unknown[]>(cls: new (source: PdfDictionary, ...args: A) => U, ...args: A): U;
     copyFrom(other: PdfDictionary<any>): void;
     cloneImpl(): this;
     setModified(modified?: boolean): void;

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

@@ -131,6 +131,20 @@ export class PdfDictionary extends PdfObject {
             new PdfEndDictionaryToken(),
         ];
     }
+    /** Factory-style type conversion: constructs a new instance passing `this` as the first argument */
+    becomes(cls, ...args) {
+        if (this instanceof cls)
+            return this;
+        const donor = new cls(this, ...args);
+        Object.setPrototypeOf(this, cls.prototype);
+        for (const key of Object.getOwnPropertyNames(donor)) {
+            if (!Object.prototype.hasOwnProperty.call(this, key)) {
+                ;
+                this[key] = donor[key];
+            }
+        }
+        return this;
+    }
     copyFrom(other) {
         for (const [key, value] of other.#entries) {
             this.#entries.set(key, value);

package/package.json

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