@syncfusion/ej2-pdf 1.0.23 → 23.1.38

package/src/pdf/core/form/form.js

@@ -0,0 +1,782 @@
+import { _PdfDictionary, _PdfName, _PdfReference } from './../pdf-primitives';
+import { PdfField, PdfTextBoxField, PdfButtonField, PdfCheckBoxField, PdfRadioButtonListField, PdfComboBoxField, PdfListBoxField, PdfSignatureField } from './field';
+import { _getInheritableProperty, _getPageIndex } from './../utils';
+import { PdfFormFieldsTabOrder, _FieldFlag, _SignatureFlag } from './../enumerator';
+import { PdfPage } from './../pdf-page';
+/**
+ * Represents a PDF form.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Access the form of the PDF document
+ * let form: PdfForm = document.form;
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfForm = /** @class */ (function () {
+    /**
+     * Represents a loaded from the PDF document.
+     *
+     * @private
+     * @param {_PdfDictionary} dictionary Form dictionary.
+     * @param {_PdfCrossReference} crossReference Cross reference object.
+     */
+    function PdfForm(dictionary, crossReference) {
+        this._hasKids = false;
+        this._setAppearance = false;
+        this._exportEmptyFields = false;
+        this._fieldCollection = [];
+        this._signFlag = _SignatureFlag.none;
+        this._dictionary = dictionary;
+        this._crossReference = crossReference;
+        this._parsedFields = new Map();
+        this._fields = [];
+        this._createFields();
+    }
+    Object.defineProperty(PdfForm.prototype, "count", {
+        /**
+         * Gets the fields count (Read only).
+         *
+         * @returns {number} Fields count.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access loaded form
+         * let form: PdfForm = document.form;
+         * // Gets the fields count
+         * let count: number = form.count;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._fields.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfForm.prototype, "needAppearances", {
+        /**
+         *  Gets a value indicating whether need appearances (Read only).
+         *
+         * @returns {boolean} Need appearances.
+         *
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access loaded form
+         * let form: PdfForm = document.form;
+         * // Gets the boolean flag indicating need appearances
+         * let needAppearances: number = form.needAppearances;
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (this._dictionary.has('NeedAppearances')) {
+                this._needAppearances = this._dictionary.get('NeedAppearances');
+            }
+            return this._needAppearances;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfForm.prototype, "exportEmptyFields", {
+        /**
+         *  Gets a value indicating whether allow to export empty fields or not.
+         *
+         * @returns {boolean} Export empty fields.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access loaded form
+         * let form: PdfForm = document.form;
+         * // Gets a value indicating whether allow to export empty fields or not.
+         * let exportEmptyFields: boolean = form.exportEmptyFields;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._exportEmptyFields;
+        },
+        /**
+         *  Sets a value indicating whether allow to export empty fields or not.
+         *
+         * @param {boolean} value Export empty fields.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Access loaded form
+         * let form: PdfForm = document.form;
+         * // Sets a value indicating whether allow to export empty fields or not.
+         * form.exportEmptyFields = false;
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._exportEmptyFields = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfForm.prototype, "_signatureFlag", {
+        get: function () {
+            return this._signFlag;
+        },
+        set: function (value) {
+            if (value !== this._signFlag) {
+                this._signFlag = value;
+                this._dictionary.update('SigFlags', value);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Gets the `PdfField` at the specified index.
+     *
+     * @param {number} index Field index.
+     * @returns {PdfField} Loaded PDF form field at the specified index.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access the loaded form field
+     * let field: PdfField = document.form.fieldAt(0);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfForm.prototype.fieldAt = function (index) {
+        if (index < 0 || index >= this._fields.length) {
+            throw Error('Index out of range.');
+        }
+        var field;
+        if (this._parsedFields.has(index)) {
+            field = this._parsedFields.get(index);
+        }
+        else {
+            var dictionary = void 0;
+            var ref = this._fields[index]; // eslint-disable-line
+            if (ref && ref instanceof _PdfReference) {
+                dictionary = this._crossReference._fetch(ref);
+            }
+            if (dictionary) {
+                var key = _getInheritableProperty(dictionary, 'FT', false, true, 'Parent');
+                var fieldFlags = 0;
+                var flag = _getInheritableProperty(dictionary, 'Ff', false, true, 'Parent');
+                if (typeof flag !== 'undefined') {
+                    fieldFlags = flag;
+                }
+                if (key) {
+                    switch (key.name.toLowerCase()) {
+                        case 'tx':
+                            field = PdfTextBoxField._load(this, dictionary, this._crossReference, ref);
+                            break;
+                        case 'btn':
+                            if ((fieldFlags & _FieldFlag.pushButton) !== 0) {
+                                field = PdfButtonField._load(this, dictionary, this._crossReference, ref);
+                            }
+                            else if ((fieldFlags & _FieldFlag.radio) !== 0) {
+                                field = PdfRadioButtonListField._load(this, dictionary, this._crossReference, ref);
+                            }
+                            else {
+                                field = PdfCheckBoxField._load(this, dictionary, this._crossReference, ref);
+                            }
+                            break;
+                        case 'ch':
+                            if ((fieldFlags & _FieldFlag.combo) !== 0) {
+                                field = PdfComboBoxField._load(this, dictionary, this._crossReference, ref);
+                            }
+                            else {
+                                field = PdfListBoxField._load(this, dictionary, this._crossReference, ref);
+                            }
+                            break;
+                        case 'sig':
+                            field = PdfSignatureField._load(this, dictionary, this._crossReference, ref);
+                            break;
+                    }
+                }
+                this._parsedFields.set(index, field);
+                if (field && field instanceof PdfField) {
+                    field._annotationIndex = index;
+                }
+            }
+        }
+        return field;
+    };
+    /**
+     * Add a new `PdfField`.
+     *
+     * @param {PdfField} field Field object to add.
+     * @returns {number} Field index.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Add a new form field
+     * let index: number = document.form.add(field);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfForm.prototype.add = function (field) {
+        this._fields.push(field._ref);
+        this._dictionary.update('Fields', this._fields);
+        this._parsedFields.set(this._fields.length - 1, field);
+        field._form = this;
+        this._crossReference._allowCatalog = true;
+        this._crossReference._root._updated = true;
+        if (field._kidsCount > 0) {
+            for (var i = 0; i < field._kidsCount; i++) {
+                var item = field.itemAt(i);
+                var page = item._page;
+                page.annotations._annotations.push(item._ref);
+                page._pageDictionary.set('Annots', page.annotations._annotations);
+                page._pageDictionary._updated = true;
+            }
+        }
+        else if (field._dictionary.has('Subtype') && field._dictionary.get('Subtype').name === 'Widget') {
+            var page = field._page;
+            page.annotations._annotations.push(field._ref);
+            field._page._pageDictionary.set('Annots', field.page.annotations._annotations);
+            field._page._pageDictionary._updated = true;
+        }
+        if (field instanceof PdfSignatureField) {
+            field._form._signatureFlag = _SignatureFlag.signatureExists | _SignatureFlag.appendOnly;
+        }
+        return (this._fields.length - 1);
+    };
+    /**
+     * Remove the specified PDF form field.
+     *
+     * @param {PdfField} field Field object to remove.
+     * @returns {void} Nothing.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access the loaded form field
+     * let field: PdfField = document.form.fieldAt(3);
+     * // Remove the form field
+     * document.form.removeField(field);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfForm.prototype.removeField = function (field) {
+        var index = this._fields.indexOf(field._ref);
+        if (index >= 0) {
+            this.removeFieldAt(index);
+        }
+    };
+    /**
+     * Remove the PDF form field from specified index.
+     *
+     * @param {number} index Field index to remove.
+     * @returns {void} Nothing.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Remove the form field from the specified index
+     * document.form.removeFieldAt(3);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfForm.prototype.removeFieldAt = function (index) {
+        var field = this.fieldAt(index);
+        if (field) {
+            if (field._kidsCount > 0) {
+                for (var i = field._kidsCount - 1; i >= 0; i--) {
+                    var item = field.itemAt(i);
+                    var page = item._getPage();
+                    if (page) {
+                        page._removeAnnotation(item._ref);
+                    }
+                }
+            }
+            else if (field._dictionary.has('Subtype') && field._dictionary.get('Subtype').name === 'Widget') {
+                var page = field.page;
+                if (page) {
+                    page._removeAnnotation(field._ref);
+                }
+            }
+            this._parsedFields.delete(index);
+        }
+        this._fields.splice(index, 1);
+        this._dictionary.set('Fields', this._fields);
+        this._dictionary._updated = true;
+    };
+    /**
+     * Sets the flag to indicate the new appearance creation
+     * If true, appearance will not be created. Default appearance has been considered.
+     * If false, new appearance stream has been created from field values and updated as normal appearance.
+     *
+     * @param {boolean} value Set default appearance.
+     * @returns {void} Nothing.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Set boolean flag to create a new appearance stream for form fields.
+     * document.form.setDefaultAppearance(false);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    PdfForm.prototype.setDefaultAppearance = function (value) {
+        this._setAppearance = !value;
+        this._needAppearances = value;
+        this._dictionary.update('NeedAppearances', value);
+    };
+    PdfForm.prototype.orderFormFields = function (tabOrder) {
+        var _this = this;
+        if (tabOrder === null || typeof tabOrder === 'undefined') {
+            this.orderFormFields(new Map());
+        }
+        else {
+            var tab = void 0;
+            var document_1 = this._crossReference._document;
+            var value = void 0;
+            if (tabOrder && tabOrder instanceof Map) {
+                var setTabOrder = true;
+                if (tabOrder.size > 0) {
+                    this._tabCollection = tabOrder;
+                }
+                else {
+                    setTabOrder = false;
+                    this._tabCollection = tabOrder;
+                }
+                var fieldCollection = new Map();
+                this._fieldCollection = this._getFields();
+                if (this._fieldCollection && this._fieldCollection.length > 0) {
+                    var page = this._fieldCollection[0].page;
+                    if (page && document_1) {
+                        for (var i = 0; i < this._fieldCollection.length; i++) {
+                            var field = this._fieldCollection[Number.parseInt(i.toString(), 10)];
+                            var index = _getPageIndex(document_1, field.page._pageDictionary);
+                            if (fieldCollection.has(index)) {
+                                value = fieldCollection.get(index);
+                                value.push(field);
+                            }
+                            else {
+                                value = [];
+                                value.push(field);
+                                fieldCollection.set(index, value);
+                            }
+                            var page_1 = document_1.getPage(index);
+                            if (!this._tabCollection.has(index)) {
+                                this._tabCollection.set(index, page_1.tabOrder);
+                            }
+                            if (setTabOrder) {
+                                page_1.tabOrder = this._tabCollection.get(index);
+                            }
+                        }
+                        var fieldsCount_1 = 0;
+                        fieldCollection.forEach(function (value, key) {
+                            _this._tabOrder = _this._tabCollection.get(key);
+                            var fields = value;
+                            fields.sort(function (pdfField1, pdfField2) {
+                                return _this._compareFields(pdfField1, pdfField2);
+                            });
+                            for (var j = 0; j < fields.length; j++) {
+                                var fieldIndex = _this._fieldCollection.indexOf(fields[Number.parseInt(j.toString(), 10)]);
+                                if (fieldIndex !== -1 && fieldIndex !== fieldsCount_1 + j) {
+                                    var field = _this._fieldCollection[Number.parseInt(fieldIndex.toString(), 10)];
+                                    _this._fieldCollection.splice(fieldIndex, 1);
+                                    _this._fieldCollection.splice(fieldsCount_1 + j, 0, field);
+                                }
+                            }
+                            fieldsCount_1 += value.length;
+                        });
+                    }
+                }
+            }
+            else {
+                this._tabOrder = tabOrder;
+                tab = this._getOrder(this._tabOrder);
+                this._fieldCollection = this._getFields();
+                this._fieldCollection.sort(function (pdfField1, pdfField2) {
+                    return _this._compareFields(pdfField1, pdfField2);
+                });
+            }
+            this._parsedFields.clear();
+            for (var i = 0; i < this._fieldCollection.length; i++) {
+                this._parsedFields.set(Number.parseInt(i.toString(), 10), this._fieldCollection[Number.parseInt(i.toString(), 10)]);
+                this._fields[Number.parseInt(i.toString(), 10)] = this._fieldCollection[Number.parseInt(i.toString(), 10)]._ref;
+                if (tab) {
+                    this._fieldCollection[Number.parseInt(i.toString(), 10)].page._pageDictionary.update('Tabs', tab);
+                }
+            }
+            this._dictionary.update('Fields', this._fields);
+        }
+    };
+    PdfForm.prototype._createFields = function () {
+        var fields; // eslint-disable-line
+        if (this._dictionary.has('Fields')) {
+            fields = this._dictionary.get('Fields');
+        }
+        var count = 0;
+        var nodes = []; // eslint-disable-line
+        while (typeof fields !== 'undefined' && fields !== null) {
+            for (; count < fields.length; count++) {
+                var ref = fields[count]; // eslint-disable-line
+                var fieldDictionary = void 0;
+                if (ref && ref instanceof _PdfReference) {
+                    fieldDictionary = this._crossReference._fetch(ref);
+                }
+                var fieldKids = void 0;
+                if (fieldDictionary && fieldDictionary.has('Kids')) {
+                    fieldKids = fieldDictionary.get('Kids');
+                    if (typeof fieldKids !== 'undefined' && fieldKids.length > 0) {
+                        for (var i = 0; i < fieldKids.length; i++) {
+                            var reference = fieldKids[Number.parseInt(i.toString(), 10)];
+                            if (reference && reference instanceof _PdfReference) {
+                                var kidsDict = this._crossReference._fetch(reference);
+                                if (typeof kidsDict !== 'undefined' && !kidsDict.has('Parent')) {
+                                    kidsDict.update('Parent', ref);
+                                }
+                            }
+                        }
+                    }
+                }
+                if (typeof fieldKids === 'undefined') {
+                    if (typeof fieldDictionary !== 'undefined') {
+                        if (this._fields.indexOf(ref) === -1) {
+                            this._fields.push(ref);
+                        }
+                    }
+                }
+                else {
+                    var isNode = (!fieldDictionary.has('FT')) || this._isNode(fieldKids);
+                    if (isNode) {
+                        nodes.push({ fields: fields, count: count });
+                        this._hasKids = true;
+                        count = -1;
+                        fields = fieldKids;
+                    }
+                    else {
+                        this._fields.push(ref);
+                    }
+                }
+            }
+            if (nodes.length === 0) {
+                break;
+            }
+            var entry = nodes.pop(); // eslint-disable-line
+            fields = entry.fields;
+            count = entry.count + 1;
+        }
+    };
+    PdfForm.prototype._isNode = function (kids) {
+        var isNode = false;
+        if (typeof kids !== 'undefined' && kids.length > 0) {
+            var entry = kids[0]; // eslint-disable-line
+            var dictionary = void 0;
+            if (typeof entry !== 'undefined' && entry !== null) {
+                if (entry instanceof _PdfDictionary) {
+                    dictionary = entry;
+                }
+                else if (entry instanceof _PdfReference) {
+                    dictionary = this._crossReference._fetch(entry);
+                }
+            }
+            if (typeof dictionary !== 'undefined' && dictionary.has('Subtype')) {
+                var subtype = dictionary.get('Subtype');
+                if (subtype && subtype.name !== 'Widget') {
+                    isNode = true;
+                }
+            }
+        }
+        return isNode;
+    };
+    PdfForm.prototype._parseWidgetReferences = function () {
+        var _this = this;
+        if (typeof this._widgetReferences === 'undefined' && this.count > 0) {
+            this._widgetReferences = [];
+            this._fields.forEach(function (fieldReference) {
+                var dictionary = _this._crossReference._fetch(fieldReference);
+                if (dictionary) {
+                    if (dictionary.has('Kids')) {
+                        var fieldKids = dictionary.get('Kids');
+                        if (fieldKids && fieldKids.length > 0) {
+                            fieldKids.forEach(function (kidReference) {
+                                var kidDictionary;
+                                if (kidReference instanceof _PdfDictionary) {
+                                    kidDictionary = kidReference;
+                                }
+                                else if (kidReference instanceof _PdfReference) {
+                                    kidDictionary = _this._crossReference._fetch(kidReference);
+                                }
+                                if (typeof kidDictionary !== 'undefined' && kidDictionary.has('Subtype')) {
+                                    var subtype = kidDictionary.get('Subtype');
+                                    if (subtype && subtype.name === 'Widget') {
+                                        _this._widgetReferences.push(kidReference);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                    else {
+                        _this._widgetReferences.push(fieldReference);
+                    }
+                }
+            });
+        }
+        return this._widgetReferences;
+    };
+    PdfForm.prototype._doPostProcess = function (isFlatten) {
+        for (var i = this.count - 1; i >= 0; i--) {
+            var field = this.fieldAt(i);
+            if (field) {
+                field._doPostProcess(isFlatten || field.flatten);
+                if (!isFlatten && field.flatten) {
+                    this.removeFieldAt(i);
+                }
+            }
+        }
+    };
+    PdfForm.prototype._getFieldIndex = function (name) {
+        var index = -1;
+        if (this.count > 0) {
+            if (!this._fieldNames) {
+                this._fieldNames = [];
+            }
+            if (!this._indexedFieldNames) {
+                this._indexedFieldNames = [];
+            }
+            if (!this._actualFieldNames) {
+                this._actualFieldNames = [];
+            }
+            if (!this._indexedActualFieldNames) {
+                this._indexedActualFieldNames = [];
+            }
+            for (var i = 0; i < this.count; i++) {
+                var field = this.fieldAt(i);
+                if (field) {
+                    var fieldName = field.name;
+                    if (fieldName) {
+                        this._fieldNames.push(fieldName);
+                        this._indexedFieldNames.push(fieldName.split('[')[0]);
+                    }
+                    var actualName = field.actualName;
+                    if (actualName) {
+                        this._actualFieldNames.push(actualName);
+                        this._indexedActualFieldNames.push(actualName.split('[')[0]);
+                    }
+                }
+            }
+            var nameIndex = this._fieldNames.indexOf(name);
+            if (nameIndex !== -1) {
+                index = nameIndex;
+            }
+            else {
+                nameIndex = this._indexedFieldNames.indexOf(name);
+                if (nameIndex !== -1) {
+                    index = nameIndex;
+                }
+                else {
+                    nameIndex = this._actualFieldNames.indexOf(name);
+                    if (nameIndex !== -1) {
+                        index = nameIndex;
+                    }
+                    else {
+                        nameIndex = this._indexedActualFieldNames.indexOf(name);
+                        if (nameIndex !== -1) {
+                            index = nameIndex;
+                        }
+                    }
+                }
+            }
+        }
+        return index;
+    };
+    PdfForm.prototype._getFields = function () {
+        var fields = [];
+        for (var i = 0; i < this._fields.length; i++) {
+            var field = this.fieldAt(i);
+            if (field && field instanceof PdfField) {
+                fields.push(field);
+            }
+        }
+        return fields;
+    };
+    PdfForm.prototype._getOrder = function (tabOrder) {
+        if (tabOrder !== PdfFormFieldsTabOrder.none) {
+            var tabs = '';
+            if (tabOrder === PdfFormFieldsTabOrder.row) {
+                tabs = 'R';
+            }
+            else if (tabOrder === PdfFormFieldsTabOrder.column) {
+                tabs = 'C';
+            }
+            else if (tabOrder === PdfFormFieldsTabOrder.structure) {
+                tabs = 'S';
+            }
+            return _PdfName.get(tabs);
+        }
+        return null;
+    };
+    PdfForm.prototype._compareFields = function (field1, field2) {
+        var result = 0;
+        var xdiff;
+        var index;
+        var page1 = field1.page;
+        var page2 = field2.page;
+        if (page1 && page1 instanceof PdfPage && page2 && page2 instanceof PdfPage) {
+            var page1Index = page1._pageIndex;
+            var page2Index = page2._pageIndex;
+            var rectangle1 = this._getRectangle(field1._dictionary);
+            var rectangle2 = this._getRectangle(field2._dictionary);
+            if (rectangle1 && rectangle1.length >= 2 && rectangle2 && rectangle2.length >= 2) {
+                var x1 = rectangle1[0];
+                var y1 = rectangle1[1];
+                var x2 = rectangle2[0];
+                var y2 = rectangle2[1];
+                if (typeof x1 === 'number' && typeof x2 === 'number' &&
+                    typeof y1 === 'number' && typeof y2 === 'number') {
+                    index = page1Index - page2Index;
+                    if (this._tabOrder === PdfFormFieldsTabOrder.row) {
+                        xdiff = this._compare(y2, y1);
+                        if (index !== 0) {
+                            result = index;
+                        }
+                        else if (xdiff !== 0) {
+                            result = xdiff;
+                        }
+                        else {
+                            result = this._compare(x1, x2);
+                        }
+                    }
+                    else if (this._tabOrder === PdfFormFieldsTabOrder.column) {
+                        xdiff = this._compare(x1, x2);
+                        if (index !== 0) {
+                            result = index;
+                        }
+                        else if (xdiff !== 0) {
+                            result = xdiff;
+                        }
+                        else {
+                            result = this._compare(y2, y1);
+                        }
+                    }
+                    else if (this._tabOrder === PdfFormFieldsTabOrder.manual ||
+                        this._tabOrder === PdfFormFieldsTabOrder.none || this._tabOrder === PdfFormFieldsTabOrder.structure) {
+                        if (field1 instanceof PdfField && field2 instanceof PdfField) {
+                            var field1Index = field1.tabIndex;
+                            var field2Index = field2.tabIndex;
+                            xdiff = this._compare(field1Index, field2Index);
+                            if (index !== 0) {
+                                result = index;
+                            }
+                            else {
+                                result = xdiff;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    };
+    PdfForm.prototype._getRectangle = function (dictionary) {
+        var _this = this;
+        if (dictionary.has('Rect')) {
+            var rect = dictionary.get('Rect');
+            if (rect) {
+                return rect;
+            }
+        }
+        else {
+            if (dictionary.has('Kids')) {
+                var kidsArray = dictionary.get('Kids');
+                if (kidsArray) {
+                    if (kidsArray.length > 1) {
+                        kidsArray.sort(function (x, y) {
+                            return _this._compareKidsElement(x, y);
+                        });
+                    }
+                    var dictionary_1 = this._crossReference._fetch(kidsArray[0]);
+                    return this._getRectangle(dictionary_1);
+                }
+            }
+        }
+        return null;
+    };
+    PdfForm.prototype._compare = function (x, y) {
+        if (x > y) {
+            return 1;
+        }
+        else if (x < y) {
+            return -1;
+        }
+        else {
+            return 0;
+        }
+    };
+    PdfForm.prototype._compareKidsElement = function (x, y) {
+        var xDictionary = this._crossReference._fetch(x);
+        var yDictionary = this._crossReference._fetch(y);
+        var xRect = this._getRectangle(xDictionary);
+        var yRect = this._getRectangle(yDictionary);
+        if (xRect && xRect.length >= 2 && yRect && yRect.length >= 2) {
+            var x1 = xRect[0];
+            var y1 = xRect[1];
+            var x2 = yRect[0];
+            var y2 = yRect[1];
+            if (typeof x1 === 'number' && typeof x2 === 'number' &&
+                typeof y1 === 'number' && typeof y2 === 'number') {
+                var result = 0;
+                var xdiff = void 0;
+                if (this._tabOrder === PdfFormFieldsTabOrder.row) {
+                    xdiff = this._compare(y2, y1);
+                    if (xdiff !== 0) {
+                        result = xdiff;
+                    }
+                    else {
+                        result = this._compare(x1, x2);
+                    }
+                }
+                else if (this._tabOrder === PdfFormFieldsTabOrder.column) {
+                    xdiff = this._compare(x1, x2);
+                    if (xdiff !== 0) {
+                        result = xdiff;
+                    }
+                    else {
+                        result = this._compare(y2, y1);
+                    }
+                }
+                return result;
+            }
+        }
+        return null;
+    };
+    PdfForm.prototype._clear = function () {
+        this._fields = [];
+        this._parsedFields = new Map();
+    };
+    return PdfForm;
+}());
+export { PdfForm };