@syncfusion/ej2-pdf 1.0.22 → 23.1.36

package/src/pdf/core/pdf-document.js

@@ -0,0 +1,1022 @@
+import { _PdfStream } from './base-stream';
+import { _PdfCrossReference } from './pdf-cross-reference';
+import { _Linearization } from './pdf-parser';
+import { _isWhiteSpace, FormatError, _decode } from './utils';
+import { _PdfCatalog } from './pdf-catalog';
+import { _PdfDictionary, _PdfReference, _isName, _clearPrimitiveCaches } from './pdf-primitives';
+import { PdfPage } from './pdf-page';
+import { Save } from '@syncfusion/ej2-file-utils';
+import { DataFormat, PdfPermissionFlag, PdfTextAlignment } from './enumerator';
+import { PdfForm } from './form/form';
+import { PdfBrush } from './graphics/pdf-graphics';
+import { PdfFontFamily, PdfFontStyle, PdfStandardFont } from './fonts/pdf-standard-font';
+import { PdfStringFormat, PdfVerticalAlignment } from './fonts/pdf-string-format';
+import { _XfdfDocument } from './import-export/xfdf-document';
+import { _JsonDocument } from './import-export/json-document';
+import { _FdfDocument } from './import-export/fdf-document';
+import { PdfBookmarkBase, _PdfNamedDestinationCollection } from './pdf-outline';
+import { _XmlDocument } from './import-export/xml-document';
+import { PdfFileStructure } from './pdf-file-structure';
+/**
+ * Represents a PDF document and can be used to parse an existing PDF document.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data);
+ * // Access first page
+ * let page: PdfPage = document.getPage(0);
+ * // Flatten annotations and form fields
+ * document.flatten = true;
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfDocument = /** @class */ (function () {
+    function PdfDocument(data, password) {
+        this._headerSignature = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
+        this._startXrefSignature = new Uint8Array([0x73, 0x74, 0x61, 0x72, 0x74, 0x78, 0x72, 0x65, 0x66]);
+        this._endObjSignature = new Uint8Array([0x65, 0x6e, 0x64, 0x6f, 0x62, 0x6a]);
+        this._version = '';
+        this._permissions = PdfPermissionFlag.default;
+        this._isEncrypted = false;
+        this._isUserPassword = false;
+        this._hasUserPasswordOnly = false;
+        this._encryptOnlyAttachment = false;
+        this._encryptMetaData = false;
+        this._allowCustomData = false;
+        if (!data) {
+            throw new Error('PDF data cannot be undefined or null');
+        }
+        this._stream = new _PdfStream(typeof data === 'string' ? _decode(data) : data);
+        this._fileStructure = new PdfFileStructure();
+        this._crossReference = new _PdfCrossReference(this, password);
+        this._pages = new Map();
+        this._checkHeader();
+        this._crossReference._setStartXRef(this._startXRef);
+        try {
+            this._parse(false);
+        }
+        catch (e) {
+            if (e.name === 'XRefParseException') {
+                this._parse(true);
+            }
+            else {
+                throw e;
+            }
+        }
+        this._crossReference._version = this._version;
+    }
+    Object.defineProperty(PdfDocument.prototype, "_allowImportCustomData", {
+        get: function () {
+            return this._allowCustomData;
+        },
+        set: function (value) {
+            this._allowCustomData = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "_linearization", {
+        get: function () {
+            if (!this._linear) {
+                var value = void 0;
+                try {
+                    value = new _Linearization(this._stream);
+                }
+                catch (err) { } // eslint-disable-line
+                this._linear = value;
+            }
+            return this._linear;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "_startXRef", {
+        get: function () {
+            var stream = this._stream;
+            var startXRef = 0;
+            if (this._linearization && this._linearization.isValid) {
+                stream.reset();
+                if (this._find(stream, this._endObjSignature)) {
+                    startXRef = stream.position + 6 - stream.start;
+                }
+            }
+            else {
+                var step = 1024;
+                var startXRefLength = this._startXrefSignature.length;
+                var found = false;
+                var position = stream.end;
+                while (!found && position > 0) {
+                    position -= step - startXRefLength;
+                    if (position < 0) {
+                        position = 0;
+                    }
+                    stream.position = position;
+                    found = this._find(stream, this._startXrefSignature, step, true);
+                }
+                if (found) {
+                    stream.skip(9);
+                    var ch = void 0;
+                    do {
+                        ch = stream.getByte();
+                    } while (_isWhiteSpace(ch));
+                    var str = '';
+                    while (ch >= 0x20 && ch <= 0x39) {
+                        str += String.fromCharCode(ch);
+                        ch = stream.getByte();
+                    }
+                    startXRef = parseInt(str, 10);
+                    if (isNaN(startXRef)) {
+                        startXRef = 0;
+                    }
+                }
+            }
+            return startXRef;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "isEncrypted", {
+        /**
+         * Gets a value indicating whether the document is encrypted. (Read Only).
+         *
+         * @returns {boolean} A boolean value indicates whether the document is encrypted.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets a value indicating whether the document is encrypted.
+         * let isEncrypted: boolean = document.isEncrypted;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._isEncrypted;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "isUserPassword", {
+        /**
+         * Gets a value indicating whether the document is decrypted using the user password. (Read only).
+         *
+         * @returns {boolean} A boolean value indicates whether the document is decrypted using the user password.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets a value indicating whether the document is decrypted using the user password
+         * let isUserPassword: boolean = document.isUserPassword;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._isUserPassword;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "pageCount", {
+        /**
+         * Gets the page count (Read only).
+         *
+         * @returns {number} Number of pages
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the page count
+         * let count: number = document.pageCount;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (typeof this._pageCount === 'undefined') {
+                this._pageCount = 0;
+                if (this._linearization && this._linearization.isValid) {
+                    this._pageCount = this._linearization.pageCount;
+                }
+                else {
+                    this._pageCount = this._catalog.pageCount;
+                }
+            }
+            return this._pageCount;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "form", {
+        /**
+         * Gets the PDF form fields included in the document (Read only).
+         *
+         * @returns {PdfForm} Form object
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access loaded form
+         * let form: PdfForm = document.form;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (typeof this._form === 'undefined') {
+                this._form = new PdfForm(this._catalog.acroForm, this._crossReference);
+            }
+            return this._form;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "flatten", {
+        /**
+         * Gets the boolean flag to flatten the annotations and form fields.
+         *
+         * @returns {boolean} Flag to flatten
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the flatten value applied
+         * let flatten: boolean = document.flatten;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._flatten;
+        },
+        /**
+         * Sets the boolean flag to flatten the annotations and form fields.
+         *
+         * @param {boolean} value to flatten
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Flatten PDF annotations and form fields
+         * document.flatten = true;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._flatten = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "permissions", {
+        /**
+         * Gets the permission flag of the PDF document (Read only).
+         *
+         * @returns {PdfPermissionFlag} permission flag. Default value is PdfPermissionFlag.default.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the permission flag
+         * let permission: PdfPermissionFlag = document.permissions;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (this._crossReference) {
+                var flag = this._crossReference._permissionFlags;
+                if (typeof flag !== 'undefined') {
+                    this._permissions = (flag & ~-3904);
+                }
+            }
+            return this._permissions;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "bookmarks", {
+        /**
+         * Gets the bookmarks (Read only).
+         *
+         * @returns {PdfBookmarkBase} Bookmarks.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Get bookmarks
+         * let bookmarks: PdfBookmarkBase = document.bookmarks;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            var catalog = this._catalog;
+            if (catalog && catalog._catalogDictionary.has('Outlines')) {
+                var outlines = catalog._catalogDictionary.get('Outlines');
+                if (outlines) {
+                    this._bookmarkBase = new PdfBookmarkBase(outlines, this._crossReference);
+                    if (outlines.has('First')) {
+                        this._bookmarkBase._reproduceTree();
+                    }
+                }
+            }
+            return this._bookmarkBase;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfDocument.prototype, "fileStructure", {
+        /**
+         * Gets the internal structure of the PDF document.
+         *
+         * @returns {PdfFileStructure} The internal structure of the PDF document.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access the internal file structure of the PDF document
+         * let fileStructure: PdfFileStructure = document.fileStructure;
+         * // Get the cross reference type
+         * let type: PdfCrossReferenceType = fileStructure.crossReferenceType;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._fileStructure;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Gets the `PdfPage` at the specified index.
+     *
+     * @param {number} pageIndex Page index.
+     * @returns {PdfPage} PDF page at the specified index.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfDocument.prototype.getPage = function (pageIndex) {
+        var cachedPage = this._pages.get(pageIndex);
+        if (cachedPage) {
+            return cachedPage;
+        }
+        var _a = this, _catalog = _a._catalog, _linearization = _a._linearization;
+        var promise;
+        if (_linearization && _linearization.isValid && _linearization.pageFirst === pageIndex) {
+            promise = this._getLinearizationPage(pageIndex);
+        }
+        else {
+            promise = _catalog.getPageDictionary(pageIndex);
+        }
+        var page = new PdfPage(this._crossReference, pageIndex, promise.dictionary, promise.reference);
+        this._pages.set(pageIndex, page);
+        return page;
+    };
+    PdfDocument.prototype.save = function (filename) {
+        this._doPostProcess(this._flatten);
+        if (typeof filename === 'string') {
+            Save.save(filename, new Blob([this._crossReference._save()], { type: 'application/pdf' }));
+        }
+        else {
+            return this._crossReference._save();
+        }
+    };
+    /**
+     * Saves the document to the specified output stream and return the stream as Blob.
+     *
+     * @returns {Promise<{ blobData: Blob }>} Saved PDF data as `Blob`.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data);
+     * // Save the document
+     * let data: Promise<{ blobData: Blob }> = document.saveAsBlob();
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfDocument.prototype.saveAsBlob = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            var obj = { blobData: new Blob([_this._crossReference._save()], { type: 'application/pdf' }) };
+            resolve(obj);
+        });
+    };
+    PdfDocument.prototype.exportAnnotations = function (arg1, arg2) {
+        this._doPostProcessOnAnnotations();
+        var helper;
+        var settings;
+        if (arg1 && arg1 instanceof PdfAnnotationExportSettings) {
+            settings = arg1;
+        }
+        else if (arg2 && arg2 instanceof PdfAnnotationExportSettings) {
+            settings = arg2;
+        }
+        if (settings) {
+            if (settings.dataFormat === DataFormat.xfdf) {
+                helper = new _XfdfDocument();
+            }
+            else if (settings.dataFormat === DataFormat.json) {
+                helper = new _JsonDocument();
+            }
+            else if (settings.dataFormat === DataFormat.fdf) {
+                helper = new _FdfDocument();
+            }
+            else {
+                return undefined;
+            }
+            helper.exportAppearance = settings.exportAppearance;
+        }
+        else {
+            helper = new _XfdfDocument();
+        }
+        var result = helper._exportAnnotations(this);
+        if (arg1 && typeof arg1 === 'string') {
+            Save.save(arg1, new Blob([result], { type: 'text/plain' }));
+        }
+        else {
+            return result;
+        }
+    };
+    PdfDocument.prototype.exportFormData = function (arg1, arg2) {
+        this._doPostProcessOnFormFields();
+        var helper;
+        var settings;
+        if (arg1 && arg1 instanceof PdfFormFieldExportSettings) {
+            settings = arg1;
+        }
+        else if (arg2 && arg2 instanceof PdfFormFieldExportSettings) {
+            settings = arg2;
+        }
+        if (settings) {
+            if (settings.dataFormat === DataFormat.xfdf) {
+                helper = new _XfdfDocument(settings.exportName);
+            }
+            else if (settings.dataFormat === DataFormat.json) {
+                helper = new _JsonDocument(settings.exportName);
+            }
+            else if (settings.dataFormat === DataFormat.fdf) {
+                helper = new _FdfDocument(settings.exportName);
+            }
+            else if (settings.dataFormat === DataFormat.xml) {
+                helper = new _XmlDocument(settings.exportName);
+            }
+            else {
+                return undefined;
+            }
+            helper._asPerSpecification = settings.asPerSpecification;
+        }
+        else {
+            helper = new _XfdfDocument();
+            helper._asPerSpecification = false;
+        }
+        if (arg1 && typeof arg1 === 'string') {
+            Save.save(arg1, new Blob([helper._exportFormFields(this)], { type: 'text/plain' }));
+        }
+        else {
+            return helper._exportFormFields(this);
+        }
+    };
+    PdfDocument.prototype.importAnnotations = function (data, dataFormat) {
+        if (dataFormat === DataFormat.xfdf) {
+            var xfdf = new _XfdfDocument();
+            xfdf._importAnnotations(this, (typeof data === 'string') ? _decode(data) : data);
+        }
+        else if (dataFormat === DataFormat.json) {
+            var json = new _JsonDocument();
+            json._importAnnotations(this, (typeof data === 'string') ? _decode(data) : data);
+        }
+        else if (dataFormat === DataFormat.fdf) {
+            var fdf = new _FdfDocument();
+            fdf._importAnnotations(this, (typeof data === 'string') ? _decode(data) : data);
+        }
+    };
+    PdfDocument.prototype.importFormData = function (data, dataFormat) {
+        if (this.form.count > 0) {
+            if (dataFormat === DataFormat.xfdf) {
+                var xfdf = new _XfdfDocument();
+                xfdf._importFormData(this, (typeof data === 'string') ? _decode(data) : data);
+            }
+            else if (dataFormat === DataFormat.json) {
+                var json = new _JsonDocument();
+                json._importFormData(this, (typeof data === 'string') ? _decode(data) : data);
+            }
+            else if (dataFormat === DataFormat.fdf) {
+                var fdf = new _FdfDocument();
+                fdf._importFormData(this, (typeof data === 'string') ? _decode(data) : data);
+            }
+            else if (dataFormat === DataFormat.xml) {
+                var xml = new _XmlDocument();
+                xml._importFormData(this, (typeof data === 'string') ? _decode(data) : data);
+            }
+        }
+    };
+    /**
+     * Disposes the current instance of `PdfDocument` class.
+     *
+     * @returns {void} Nothing.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data);
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfDocument.prototype.destroy = function () {
+        if (this._crossReference) {
+            this._crossReference._destroy();
+            this._crossReference = undefined;
+        }
+        if (this._catalog) {
+            this._catalog._destroy();
+            this._catalog = undefined;
+        }
+        this._endObjSignature = undefined;
+        this._headerSignature = undefined;
+        if (this._pages && this._pages.size > 0) {
+            this._pages.forEach(function (value) {
+                value._destroy();
+            });
+        }
+        this._pages.clear();
+        this._pages = undefined;
+        this._startXrefSignature = undefined;
+        this._stream = undefined;
+        this._form = undefined;
+        _clearPrimitiveCaches();
+    };
+    Object.defineProperty(PdfDocument.prototype, "_destinationCollection", {
+        get: function () {
+            if (this._namedDestinationCollection === null || typeof this._namedDestinationCollection === 'undefined') {
+                if (this._catalog._catalogDictionary.has('Names')) {
+                    var names = this._catalog._catalogDictionary.get('Names');
+                    this._namedDestinationCollection = new _PdfNamedDestinationCollection(names, this._crossReference);
+                }
+                else {
+                    this._namedDestinationCollection = new _PdfNamedDestinationCollection();
+                }
+            }
+            return this._namedDestinationCollection;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PdfDocument.prototype._getLinearizationPage = function (pageIndex) {
+        var _a = this, _catalog = _a._catalog, _linearization = _a._linearization, _crossReference = _a._crossReference;
+        var ref = _PdfReference.get(_linearization.objectNumberFirst, 0);
+        try {
+            var obj = _crossReference._fetch(ref); // eslint-disable-line
+            if (obj instanceof _PdfDictionary) {
+                var type = obj.get('Type');
+                if (_isName(type, 'Page') || (!obj.has('Type') && !obj.has('Kids'))) {
+                    if (!_catalog.pageKidsCountCache.has(ref)) {
+                        _catalog.pageKidsCountCache.put(ref, 1);
+                    }
+                    if (!_catalog.pageIndexCache.has(ref)) {
+                        _catalog.pageIndexCache.put(ref, 0);
+                    }
+                    return { dictionary: obj, reference: ref };
+                }
+            }
+            throw new FormatError('The Linearization dictionary does not point to a valid Page dictionary.');
+        }
+        catch (reason) {
+            return _catalog.getPageDictionary(pageIndex);
+        }
+    };
+    PdfDocument.prototype._checkHeader = function () {
+        var stream = this._stream;
+        stream.reset();
+        if (!this._find(stream, this._headerSignature)) {
+            return;
+        }
+        stream.moveStart();
+        var version = '';
+        var ch = stream.getByte();
+        while (ch > 0x20) {
+            if (version.length >= 12) {
+                break;
+            }
+            version += String.fromCharCode(ch);
+            ch = stream.getByte();
+        }
+        if (!this._version) {
+            this._version = version.substring(5);
+        }
+    };
+    PdfDocument.prototype._parse = function (recoveryMode) {
+        this._crossReference._parse(recoveryMode);
+        this._catalog = new _PdfCatalog(this._crossReference);
+        if (this._catalog.version) {
+            this._version = this._catalog.version;
+        }
+    };
+    PdfDocument.prototype._find = function (stream, signature, limit, backwards) {
+        if (limit === void 0) { limit = 1024; }
+        if (backwards === void 0) { backwards = false; }
+        var signatureLength = signature.length;
+        var scanBytes = stream.peekBytes(limit);
+        var scanLength = scanBytes.length - signatureLength;
+        if (scanLength <= 0) {
+            return false;
+        }
+        if (backwards) {
+            var signatureEnd = signatureLength - 1;
+            var position = scanBytes.length - 1;
+            while (position >= signatureEnd) {
+                var j = 0;
+                while (j < signatureLength && scanBytes[position - j] === signature[signatureEnd - j]) {
+                    j++;
+                }
+                if (j >= signatureLength) {
+                    stream.position += position - signatureEnd;
+                    return true;
+                }
+                position--;
+            }
+        }
+        else {
+            var position = 0;
+            while (position <= scanLength) {
+                var j = 0;
+                while (j < signatureLength && scanBytes[position + j] === signature[j]) { // eslint-disable-line
+                    j++;
+                }
+                if (j >= signatureLength) {
+                    stream.position += position;
+                    return true;
+                }
+                position++;
+            }
+        }
+        return false;
+    };
+    PdfDocument.prototype._doPostProcess = function (isFlatten) {
+        if (isFlatten === void 0) { isFlatten = false; }
+        this._doPostProcessOnFormFields(isFlatten);
+        this._doPostProcessOnAnnotations(isFlatten);
+    };
+    PdfDocument.prototype._doPostProcessOnFormFields = function (isFlatten) {
+        if (isFlatten === void 0) { isFlatten = false; }
+        this.form._doPostProcess(isFlatten);
+        if (isFlatten) {
+            var formObject = this._catalog._catalogDictionary.getRaw('AcroForm');
+            var dictionary = new _PdfDictionary(this._crossReference);
+            dictionary._updated = true;
+            if (formObject instanceof _PdfReference) {
+                this._crossReference._cacheMap.set(formObject, dictionary);
+            }
+            else {
+                this.form._dictionary = dictionary;
+                this._crossReference._allowCatalog = true;
+            }
+            this.form._clear();
+        }
+    };
+    PdfDocument.prototype._doPostProcessOnAnnotations = function (isFlatten) {
+        if (isFlatten === void 0) { isFlatten = false; }
+        for (var i = 0; i < this.pageCount; i++) {
+            var page = this.getPage(i);
+            page.annotations._doPostProcess(isFlatten);
+            if (isFlatten) {
+                if (page._pageDictionary.has('Annots')) {
+                    delete page._pageDictionary._map.Annots;
+                    page._pageDictionary._updated = true;
+                }
+                page.annotations._clear();
+            }
+        }
+    };
+    PdfDocument.prototype._addWatermarkText = function () {
+        if (this.pageCount > 0) {
+            for (var index = 0; index < this._pageCount; index++) {
+                var page = this.getPage(index);
+                if (page) {
+                    try {
+                        var graphics = page.graphics;
+                        graphics.save();
+                        graphics.setTransparency(0.20);
+                        graphics.drawRectangle(0, 0, page.size[0], 33.75, new PdfBrush([255, 255, 255]));
+                        graphics.restore();
+                        graphics.save();
+                        graphics.setTransparency(0.50);
+                        var font = new PdfStandardFont(PdfFontFamily.helvetica, 12, PdfFontStyle.regular);
+                        var format = new PdfStringFormat(PdfTextAlignment.center, PdfVerticalAlignment.middle);
+                        graphics.drawString('Created with a trial version of Syncfusion Essential PDF', font, [0, 0, page.size[0], 33.75], null, new PdfBrush([0, 0, 0]), format);
+                        graphics.restore();
+                    }
+                    catch (e) { } // eslint-disable-line
+                }
+            }
+        }
+    };
+    return PdfDocument;
+}());
+export { PdfDocument };
+/**
+ * Represents annotation export settings.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Sets export data format as JSON type to annotation export settings
+ * let settings: PdfAnnotationExportSettings = new PdfAnnotationExportSettings();
+ * // Set the data format defined in annotation export settings
+ * settings.dataFormat = DataFormat.json;
+ * // Export annotations to JSON format
+ * let json: Uint8Array = document.exportAnnotations(settings);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfAnnotationExportSettings = /** @class */ (function () {
+    function PdfAnnotationExportSettings() {
+        this._format = DataFormat.xfdf;
+        this._exportAppearance = false;
+    }
+    Object.defineProperty(PdfAnnotationExportSettings.prototype, "dataFormat", {
+        /**
+         * Gets the data format defined in annotation export settings.
+         *
+         * @returns {DataFormat} - Returns the data format.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Sets export data format as JSON type to annotation export settings
+         * let settings: PdfAnnotationExportSettings = new PdfAnnotationExportSettings();
+         * // Export annotations to JSON format
+         * let json: Uint8Array = document.exportAnnotations(settings);
+         * // Get the data format defined in annotation export settings
+         * let dataFormat: DataFormat = settings.dataFormat;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._format;
+        },
+        /**
+         * Sets the data format defined in annotation export settings.
+         *
+         * @param {DataFormat} format - Specifies the data format.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Sets export data format as JSON type to annotation export settings
+         * let settings: PdfAnnotationExportSettings = new PdfAnnotationExportSettings();
+         * // Set the data format defined in annotation export settings
+         * settings.dataFormat = DataFormat.json;
+         * // Export annotations to JSON format
+         * let json: Uint8Array = document.exportAnnotations(settings);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (format) {
+            this._format = format;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfAnnotationExportSettings.prototype, "exportAppearance", {
+        /**
+         * Gets the boolean value indicating whether the appearance of a particular object can be exported or not.
+         *
+         * @returns {boolean} - Returns the boolean value.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Sets the annotation export settings with enabled export appearance.
+         * let settings: PdfAnnotationExportSettings = new PdfAnnotationExportSettings();
+         * // Export annotations to XFDF format
+         * let xfdf: Uint8Array = document.exportAnnotations(settings);
+         * // Get the boolean value indicating whether the appearance of a particular object can be exported or not
+         * let appearance: boolean = settings.exportAppearance;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._exportAppearance;
+        },
+        /**
+         * Sets the boolean value indicating whether the appearance of a particular object can be exported or not.
+         *
+         * @param {boolean} value - The boolean value.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Sets the annotation export settings with enabled export appearance.
+         * let settings: PdfAnnotationExportSettings = new PdfAnnotationExportSettings();
+         * // Set the boolean value indicating whether the appearance of a particular object can be exported or not
+         * settings.exportAppearance = true;
+         * // Export annotations to XFDF format
+         * let xfdf: Uint8Array = document.exportAnnotations(settings);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._exportAppearance = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return PdfAnnotationExportSettings;
+}());
+export { PdfAnnotationExportSettings };
+/**
+ * Represents form fields export settings.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data);
+ * // Sets the form field data export settings with output data format.
+ * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+ * // Set the data format defined in form field export settings.
+ * settings.dataFormat = DataFormat.json;
+ * // Export form field to JSON format
+ * let json: Uint8Array = document.exportFormData(settings);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfFormFieldExportSettings = /** @class */ (function () {
+    function PdfFormFieldExportSettings() {
+        this._format = DataFormat.xfdf;
+        this._exportName = '';
+        this._asPerSpecification = true;
+    }
+    Object.defineProperty(PdfFormFieldExportSettings.prototype, "dataFormat", {
+        /**
+         * Gets the data format defined in form field export settings.
+         *
+         * @returns {DataFormat} - Returns the data format.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the form field data export settings with output data format.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Get the data format defined in form field export settings
+         * let dataFormat: DataFormat = settings.dataFormat;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._format;
+        },
+        /**
+         * Sets the data format defined in form field export settings.
+         *
+         * @param {DataFormat} format - Specifies the data format.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the form field data export settings with output data format.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Set the data format defined in form field export settings.
+         * settings.dataFormat = DataFormat.json;
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (format) {
+            this._format = format;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfFormFieldExportSettings.prototype, "exportName", {
+        /**
+         * Gets the export name defined in form field export settings.
+         *
+         * @returns {string} - Returns the string value.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the form field data export settings with export name.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Get the export name defined in form field export settings
+         * let name: boolean = settings.exportName;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._exportName;
+        },
+        /**
+         * Sets the export name defined in form field export settings.
+         *
+         * @param {string} name - Specifies the export name of the form.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the form field data export settings with export name.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Set the export name defined in form field export settings.
+         * settings.exportName = ‘JobApplication’.
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (name) {
+            this._exportName = name;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfFormFieldExportSettings.prototype, "asPerSpecification", {
+        /**
+         * Gets the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         *
+         * @returns {boolean} - Returns the boolean value.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Get the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         * let asPerSpecification: boolean = settings.asPerSpecification;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._asPerSpecification;
+        },
+        /**
+         * Sets the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         *
+         * @param {boolean} value - The boolean value.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data);
+         * // Sets the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         * let settings: PdfFormFieldExportSettings = new PdfFormFieldExportSettings();
+         * // Set the boolean value indicating whether the data in a form field can be exported based on a certain specification.
+         * settings.asPerSpecification = true;
+         * // Export form field to JSON format
+         * let json: Uint8Array = document.exportFormData(settings);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._asPerSpecification = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return PdfFormFieldExportSettings;
+}());
+export { PdfFormFieldExportSettings };