pdf-lite 1.3.3 → 1.5.0

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

@@ -0,0 +1,11 @@
+import { PdfDocument } from '../../pdf/pdf-document.js';
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfXfaData } from './pdf-xfa-data.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export declare class PdfXfaForm extends PdfArray {
+    datasets: PdfXfaData | null;
+    static fromDocument(document: PdfDocument): Promise<PdfXfaForm | null>;
+}

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

@@ -0,0 +1,56 @@
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfXfaData } from './pdf-xfa-data.js';
+/**
+ * Typed wrapper around the XFA name/stream-ref array.
+ * Holds eagerly-loaded references to component streams like datasets.
+ */
+export class PdfXfaForm extends PdfArray {
+    datasets = null;
+    static async fromDocument(document) {
+        const catalog = document.root;
+        const acroFormRef = catalog.content.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        let acroFormDict;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await document.readObject(acroFormRef);
+            if (!acroFormObject)
+                return null;
+            acroFormDict = acroFormObject.content.as(PdfDictionary);
+        }
+        else if (acroFormRef instanceof PdfDictionary) {
+            acroFormDict = acroFormRef;
+        }
+        else {
+            return null;
+        }
+        const xfaArray = acroFormDict.get('XFA');
+        if (!(xfaArray instanceof PdfArray))
+            return null;
+        const form = new PdfXfaForm(xfaArray.items.slice());
+        // Find the datasets reference in the name/ref pairs
+        const items = xfaArray.items;
+        for (let i = 0; i < items.length - 1; i += 2) {
+            const name = items[i];
+            const ref = items[i + 1];
+            if (name instanceof PdfString &&
+                name.value === 'datasets' &&
+                ref instanceof PdfObjectReference) {
+                const datasetObject = (await document.readObject({
+                    objectNumber: ref.objectNumber,
+                    generationNumber: ref.generationNumber,
+                    allowUnindexed: true,
+                }))?.as((PdfIndirectObject));
+                if (datasetObject) {
+                    form.datasets = new PdfXfaData(datasetObject);
+                }
+                break;
+            }
+        }
+        return form;
+    }
+}

package/dist/annotations/index.d.ts

@@ -0,0 +1,4 @@
+export { PdfAnnotation, type PdfAppearanceStreamDictionary, } from './pdf-annotation.js';
+export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';
+export { PdfAnnotationWriter } from './pdf-annotation-writer.js';

package/dist/annotations/index.js

@@ -0,0 +1,4 @@
+export { PdfAnnotation, } from './pdf-annotation.js';
+export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';
+export { PdfAnnotationWriter } from './pdf-annotation-writer.js';

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

@@ -0,0 +1,24 @@
+import { PdfNumber } from '../core/objects/pdf-number.js';
+/**
+ * Provides annotation flag (F field) accessors for PDF annotations.
+ * These are generic to all annotation types per the PDF spec.
+ */
+export declare class PdfAnnotationFlags extends PdfNumber {
+    constructor(value?: number);
+    get annotationFlags(): number;
+    set annotationFlags(flags: number);
+    get invisible(): boolean;
+    set invisible(value: boolean);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get print(): boolean;
+    set print(value: boolean);
+    get noZoom(): boolean;
+    set noZoom(value: boolean);
+    get noRotate(): boolean;
+    set noRotate(value: boolean);
+    get noView(): boolean;
+    set noView(value: boolean);
+    get locked(): boolean;
+    set locked(value: boolean);
+}

package/dist/annotations/pdf-annotation-flags.js

@@ -0,0 +1,93 @@
+import { PdfNumber } from '../core/objects/pdf-number.js';
+/**
+ * Provides annotation flag (F field) accessors for PDF annotations.
+ * These are generic to all annotation types per the PDF spec.
+ */
+export class PdfAnnotationFlags extends PdfNumber {
+    constructor(value = 0) {
+        super(value);
+    }
+    get annotationFlags() {
+        return this.value;
+    }
+    set annotationFlags(flags) {
+        this.value = flags;
+    }
+    get invisible() {
+        return (this.annotationFlags & 1) !== 0;
+    }
+    set invisible(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 1;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~1;
+        }
+    }
+    get hidden() {
+        return (this.annotationFlags & 2) !== 0;
+    }
+    set hidden(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 2;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~2;
+        }
+    }
+    get print() {
+        return (this.annotationFlags & 4) !== 0;
+    }
+    set print(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 4;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~4;
+        }
+    }
+    get noZoom() {
+        return (this.annotationFlags & 8) !== 0;
+    }
+    set noZoom(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 8;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~8;
+        }
+    }
+    get noRotate() {
+        return (this.annotationFlags & 16) !== 0;
+    }
+    set noRotate(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 16;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~16;
+        }
+    }
+    get noView() {
+        return (this.annotationFlags & 32) !== 0;
+    }
+    set noView(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 32;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~32;
+        }
+    }
+    get locked() {
+        return (this.annotationFlags & 128) !== 0;
+    }
+    set locked(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 128;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~128;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+/**
+ * Manages page Annots arrays during AcroForm write operations.
+ */
+export declare class PdfAnnotationWriter {
+    static getPageAnnotsArray(document: PdfDocument, pageDict: PdfDictionary): Promise<{
+        annotsArray: PdfArray<PdfObjectReference>;
+        isIndirect: boolean;
+        objectNumber?: number;
+        generationNumber?: number;
+    }>;
+    static addFieldsToAnnots(annotsArray: PdfArray<PdfObjectReference>, fieldRefs: PdfObjectReference[]): void;
+    static updatePageAnnotations(document: PdfDocument, fieldsByPage: Map<string, {
+        pageRef: PdfObjectReference;
+        fieldRefs: PdfObjectReference[];
+    }>): Promise<void>;
+}

package/dist/annotations/pdf-annotation-writer.js

@@ -0,0 +1,76 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+/**
+ * Manages page Annots arrays during AcroForm write operations.
+ */
+export class PdfAnnotationWriter {
+    static async getPageAnnotsArray(document, pageDict) {
+        const annotsRef = pageDict.get('Annots');
+        if (annotsRef instanceof PdfObjectReference) {
+            const annotsObj = await document.readObject({
+                objectNumber: annotsRef.objectNumber,
+                generationNumber: annotsRef.generationNumber,
+            });
+            return {
+                annotsArray: annotsObj.content
+                    .as((PdfArray))
+                    .clone(),
+                isIndirect: true,
+                objectNumber: annotsRef.objectNumber,
+                generationNumber: annotsRef.generationNumber,
+            };
+        }
+        else if (annotsRef instanceof PdfArray) {
+            return {
+                annotsArray: annotsRef.as((PdfArray)).clone(),
+                isIndirect: false,
+            };
+        }
+        else {
+            const newArray = new PdfArray();
+            pageDict.set('Annots', newArray);
+            return {
+                annotsArray: newArray,
+                isIndirect: false,
+            };
+        }
+    }
+    static addFieldsToAnnots(annotsArray, fieldRefs) {
+        for (const fieldRef of fieldRefs) {
+            const exists = annotsArray.items.some((ref) => ref.equals(fieldRef));
+            if (!exists) {
+                annotsArray.push(fieldRef);
+            }
+        }
+    }
+    static async updatePageAnnotations(document, fieldsByPage) {
+        for (const { pageRef, fieldRefs } of fieldsByPage.values()) {
+            const pageObj = await document.readObject({
+                objectNumber: pageRef.objectNumber,
+                generationNumber: pageRef.generationNumber,
+            });
+            if (!pageObj)
+                continue;
+            const pageDict = pageObj.content.as(PdfDictionary).clone();
+            const annotsInfo = await PdfAnnotationWriter.getPageAnnotsArray(document, pageDict);
+            PdfAnnotationWriter.addFieldsToAnnots(annotsInfo.annotsArray, fieldRefs);
+            if (annotsInfo.isIndirect &&
+                annotsInfo.objectNumber !== undefined) {
+                const annotsIndirect = new PdfIndirectObject({
+                    objectNumber: annotsInfo.objectNumber,
+                    generationNumber: annotsInfo.generationNumber,
+                    content: annotsInfo.annotsArray,
+                });
+                document.add(annotsIndirect);
+            }
+            const pageIndirect = new PdfIndirectObject({
+                objectNumber: pageRef.objectNumber,
+                generationNumber: pageRef.generationNumber,
+                content: pageDict,
+            });
+            document.add(pageIndirect);
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+export type PdfAppearanceStreamDictionary = PdfDictionary<{
+    N: PdfObjectReference | PdfDictionary;
+    R?: PdfObjectReference | PdfDictionary;
+    D?: PdfObjectReference | PdfDictionary;
+}>;
+/**
+ * Base class for all PDF annotations.
+ */
+export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
+    Type: PdfName;
+    Subtype: PdfName;
+    AS: PdfName;
+    Ff: PdfNumber;
+    FT: PdfName;
+    T: PdfString;
+    DV: PdfString | PdfName;
+    V: PdfString | PdfName;
+    DA: PdfString;
+    Opt: PdfArray<PdfString | PdfArray<PdfString>>;
+    MaxLen: PdfNumber;
+    Q: PdfNumber;
+    Kids: PdfArray<PdfObjectReference>;
+    Rect: PdfArray<PdfNumber>;
+    F: PdfNumber;
+    AP?: PdfAppearanceStreamDictionary;
+    P?: PdfObjectReference;
+}>> {
+    private _annotationFlags;
+    constructor(options?: {
+        other?: PdfIndirectObject;
+    });
+    get rect(): [number, number, number, number] | null;
+    set rect(rect: [number, number, number, number] | null);
+    get annotationFlags(): number;
+    set annotationFlags(flags: number);
+    get invisible(): boolean;
+    set invisible(value: boolean);
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get print(): boolean;
+    set print(value: boolean);
+    get noZoom(): boolean;
+    set noZoom(value: boolean);
+    get noRotate(): boolean;
+    set noRotate(value: boolean);
+    get noView(): boolean;
+    set noView(value: boolean);
+    get locked(): boolean;
+    set locked(value: boolean);
+    get appearanceStreamDict(): PdfAppearanceStreamDictionary | null;
+    set appearanceStreamDict(dict: PdfAppearanceStreamDictionary | null);
+    get parentRef(): PdfObjectReference | null;
+    set parentRef(ref: PdfObjectReference | null);
+}

package/dist/annotations/pdf-annotation.js

@@ -0,0 +1,106 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfAnnotationFlags } from './pdf-annotation-flags.js';
+/**
+ * Base class for all PDF annotations.
+ */
+export class PdfAnnotation extends PdfIndirectObject {
+    _annotationFlags;
+    constructor(options) {
+        super(options?.other ??
+            new PdfIndirectObject({ content: new PdfDictionary() }));
+        const flagValue = this.content.get('F')?.as(PdfNumber)?.value ?? 0;
+        this._annotationFlags = new PdfAnnotationFlags(flagValue);
+        this.content.set('F', this._annotationFlags);
+    }
+    get rect() {
+        const rectArray = this.content.get('Rect')?.as((PdfArray));
+        if (!rectArray)
+            return null;
+        return rectArray.items.map((num) => num.value);
+    }
+    set rect(rect) {
+        if (rect === null) {
+            this.content.delete('Rect');
+            return;
+        }
+        const rectArray = new PdfArray(rect.map((num) => new PdfNumber(num)));
+        this.content.set('Rect', rectArray);
+    }
+    get annotationFlags() {
+        return this._annotationFlags.annotationFlags;
+    }
+    set annotationFlags(flags) {
+        this._annotationFlags.annotationFlags = flags;
+    }
+    get invisible() {
+        return this._annotationFlags.invisible;
+    }
+    set invisible(value) {
+        this._annotationFlags.invisible = value;
+    }
+    get hidden() {
+        return this._annotationFlags.hidden;
+    }
+    set hidden(value) {
+        this._annotationFlags.hidden = value;
+    }
+    get print() {
+        return this._annotationFlags.print;
+    }
+    set print(value) {
+        this._annotationFlags.print = value;
+    }
+    get noZoom() {
+        return this._annotationFlags.noZoom;
+    }
+    set noZoom(value) {
+        this._annotationFlags.noZoom = value;
+    }
+    get noRotate() {
+        return this._annotationFlags.noRotate;
+    }
+    set noRotate(value) {
+        this._annotationFlags.noRotate = value;
+    }
+    get noView() {
+        return this._annotationFlags.noView;
+    }
+    set noView(value) {
+        this._annotationFlags.noView = value;
+    }
+    get locked() {
+        return this._annotationFlags.locked;
+    }
+    set locked(value) {
+        this._annotationFlags.locked = value;
+    }
+    get appearanceStreamDict() {
+        const apDict = this.content.get('AP')?.as(PdfDictionary);
+        if (!apDict)
+            return null;
+        return apDict;
+    }
+    set appearanceStreamDict(dict) {
+        if (dict === null) {
+            this.content.delete('AP');
+            return;
+        }
+        this.content.set('AP', dict);
+    }
+    get parentRef() {
+        const ref = this.content.get('P')?.as(PdfObjectReference);
+        return ref ?? null;
+    }
+    set parentRef(ref) {
+        if (ref === null) {
+            this.content.delete('P');
+        }
+        else {
+            this.content.set('P', ref);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfAnnotation } from './pdf-annotation.js';
+/**
+ * Widget annotation subtype. Extends PdfAnnotation with widget-specific
+ * properties: isWidget (Type/Subtype) and AS (appearance state).
+ */
+export declare class PdfWidgetAnnotation extends PdfAnnotation {
+    constructor(options?: {
+        other?: PdfIndirectObject;
+    });
+    get isWidget(): boolean;
+    set isWidget(isWidget: boolean);
+    get appearanceState(): string | null;
+    set appearanceState(state: string | null);
+}

package/dist/annotations/pdf-widget-annotation.js

@@ -0,0 +1,37 @@
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfAnnotation } from './pdf-annotation.js';
+/**
+ * Widget annotation subtype. Extends PdfAnnotation with widget-specific
+ * properties: isWidget (Type/Subtype) and AS (appearance state).
+ */
+export class PdfWidgetAnnotation extends PdfAnnotation {
+    constructor(options) {
+        super(options);
+    }
+    get isWidget() {
+        const type = this.content.get('Type')?.as(PdfName)?.value;
+        const subtype = this.content.get('Subtype')?.as(PdfName)?.value;
+        return type === 'Annot' && subtype === 'Widget';
+    }
+    set isWidget(isWidget) {
+        if (isWidget) {
+            this.content.set('Type', new PdfName('Annot'));
+            this.content.set('Subtype', new PdfName('Widget'));
+        }
+        else {
+            this.content.delete('Type');
+            this.content.delete('Subtype');
+        }
+    }
+    get appearanceState() {
+        return this.content.get('AS')?.as(PdfName)?.value ?? null;
+    }
+    set appearanceState(state) {
+        if (state === null) {
+            this.content.delete('AS');
+        }
+        else {
+            this.content.set('AS', new PdfName(state));
+        }
+    }
+}

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

@@ -7,7 +7,7 @@ export declare class PdfArray<T extends PdfObject = PdfObject> extends PdfObject
     get length(): number;
     push(item: T): void;
     protected tokenize(): import("../index.js").PdfToken[];
-    clone(): this;
+    cloneImpl(): this;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;
 }

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

@@ -33,8 +33,9 @@ export class PdfArray extends PdfObject {
             new PdfEndArrayToken(),
         ];
     }
-    clone() {
-        return new PdfArray(this.items.map((x) => x.clone()));
+    cloneImpl() {
+        const cloned = new PdfArray(this.items.map((x) => x.clone()));
+        return cloned;
     }
     isModified() {
         return (super.isModified() || this.items.some((item) => item.isModified()));

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

@@ -4,5 +4,5 @@ export declare class PdfBoolean extends PdfObject {
     value: boolean;
     constructor(value: boolean);
     protected tokenize(): PdfBooleanToken[];
-    clone(): this;
+    cloneImpl(): this;
 }

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

@@ -9,7 +9,8 @@ export class PdfBoolean extends PdfObject {
     tokenize() {
         return [new PdfBooleanToken(this.value)];
     }
-    clone() {
-        return new PdfBoolean(this.value);
+    cloneImpl() {
+        const cloned = new PdfBoolean(this.value);
+        return cloned;
     }
 }

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

@@ -14,5 +14,5 @@ export declare class PdfComment extends PdfObject {
     isEOFComment(): boolean;
     static versionComment(version: string): PdfComment;
     protected tokenize(): PdfCommentToken[];
-    clone(): this;
+    cloneImpl(): this;
 }

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

@@ -33,7 +33,7 @@ export class PdfComment extends PdfObject {
     tokenize() {
         return [new PdfCommentToken(this.raw)];
     }
-    clone() {
+    cloneImpl() {
         return new PdfComment(new Uint8Array(this.raw));
     }
 }

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

@@ -22,7 +22,7 @@ export declare class PdfDictionary<T extends PdfDictionaryEntries = PdfDictionar
     entries(): IterableIterator<[string, PdfObject | undefined]>;
     protected tokenize(): PdfToken[];
     copyFrom(other: PdfDictionary<any>): void;
-    clone(): this;
+    cloneImpl(): this;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;
 }

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

@@ -136,12 +136,13 @@ export class PdfDictionary extends PdfObject {
         }
         this.modified = true;
     }
-    clone() {
+    cloneImpl() {
         const clonedEntries = new Map();
         for (const [key, value] of this.#entries) {
             clonedEntries.set(key.clone(), value ? value.clone() : undefined);
         }
-        return new PdfDictionary(clonedEntries);
+        const cloned = new PdfDictionary(clonedEntries);
+        return cloned;
     }
     isModified() {
         return (super.isModified() ||

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

@@ -20,5 +20,5 @@ export declare class PdfHexadecimal extends PdfObject {
     toHexBytes(): ByteArray;
     toHexString(): string;
     protected tokenize(): PdfHexadecimalToken[];
-    clone(): this;
+    cloneImpl(): this;
 }

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

@@ -54,9 +54,10 @@ export class PdfHexadecimal extends PdfObject {
     tokenize() {
         return [new PdfHexadecimalToken(this.raw, this._originalBytes)];
     }
-    clone() {
-        return new PdfHexadecimal(new Uint8Array(this.raw), 'hex', this._originalBytes
+    cloneImpl() {
+        const cloned = new PdfHexadecimal(new Uint8Array(this.raw), 'hex', this._originalBytes
             ? new Uint8Array(this._originalBytes)
             : undefined);
+        return cloned;
     }
 }

package/dist/core/objects/pdf-indirect-object.d.ts

@@ -22,7 +22,7 @@ export declare class PdfIndirectObject<T extends PdfObject = PdfObject> extends
     matchesReference(ref?: PdfObjectReference): boolean;
     protected tokenize(): import("../index.js").PdfToken[];
     copyFrom(other: PdfIndirectObject): void;
-    clone(): this;
+    cloneImpl(): this;
     order(): number;
     isModified(): boolean;
     setImmutable(immutable?: boolean): void;

package/dist/core/objects/pdf-indirect-object.js

@@ -94,7 +94,7 @@ export class PdfIndirectObject extends PdfObjectReference {
         this.offset = other.offset.clone();
         this.modified = true;
     }
-    clone() {
+    cloneImpl() {
         return new PdfIndirectObject({
             objectNumber: this.objectNumber,
             generationNumber: this.generationNumber,

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

@@ -4,7 +4,7 @@ export declare class PdfName<T extends string = string> extends PdfObject {
     value: T;
     constructor(value: T);
     protected tokenize(): PdfNameToken[];
-    clone(): this;
+    cloneImpl(): this;
     /**
      * Escapes a PDF name according to PDF specification.
      * PDF names can't contain spaces or certain special chars except # for escaping.

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

@@ -9,8 +9,9 @@ export class PdfName extends PdfObject {
     tokenize() {
         return [new PdfNameToken(PdfName.escapeName(this.value))];
     }
-    clone() {
-        return new PdfName(this.value);
+    cloneImpl() {
+        const cloned = new PdfName(this.value);
+        return cloned;
     }
     /**
      * Escapes a PDF name according to PDF specification.