pdfmake 0.3.0-beta.10 → 0.3.0-beta.12

package/eslint.config.mjs

@@ -1,52 +1,52 @@
-import jsdoc from "eslint-plugin-jsdoc";
-import globals from "globals";
-import js from "@eslint/js";
-
-export default [
-	{
-		ignores: ["src/3rd-party/svg-to-pdfkit/*"],
-	},
-
-	js.configs.recommended,
-
-	{
-		plugins: {
-			jsdoc,
-		},
-
-		languageOptions: {
-			globals: {
-				...globals.browser,
-				...globals.node,
-				...globals.mocha,
-			},
-
-			ecmaVersion: 9,
-			sourceType: "module",
-		},
-
-		rules: {
-			semi: 2,
-			"no-throw-literal": 2,
-			"no-prototype-builtins": 0,
-			"jsdoc/check-examples": 0,
-			"jsdoc/check-param-names": 1,
-			"jsdoc/check-tag-names": 1,
-			"jsdoc/check-types": 1,
-			"jsdoc/no-undefined-types": 1,
-			"jsdoc/require-description": 0,
-			"jsdoc/require-description-complete-sentence": 0,
-			"jsdoc/require-example": 0,
-			"jsdoc/require-hyphen-before-param-description": 0,
-			"jsdoc/require-param": 1,
-			"jsdoc/require-param-description": 0,
-			"jsdoc/require-param-name": 1,
-			"jsdoc/require-param-type": 1,
-			"jsdoc/require-returns": 1,
-			"jsdoc/require-returns-check": 1,
-			"jsdoc/require-returns-description": 0,
-			"jsdoc/require-returns-type": 1,
-			"jsdoc/valid-types": 1,
-		},
-	}
-];
+import jsdoc from "eslint-plugin-jsdoc";
+import globals from "globals";
+import js from "@eslint/js";
+
+export default [
+	{
+		ignores: ["src/3rd-party/svg-to-pdfkit/*"],
+	},
+
+	js.configs.recommended,
+
+	{
+		plugins: {
+			jsdoc,
+		},
+
+		languageOptions: {
+			globals: {
+				...globals.browser,
+				...globals.node,
+				...globals.mocha,
+			},
+
+			ecmaVersion: 9,
+			sourceType: "module",
+		},
+
+		rules: {
+			semi: 2,
+			"no-throw-literal": 2,
+			"no-prototype-builtins": 0,
+			"jsdoc/check-examples": 0,
+			"jsdoc/check-param-names": 1,
+			"jsdoc/check-tag-names": 1,
+			"jsdoc/check-types": 1,
+			"jsdoc/no-undefined-types": 1,
+			"jsdoc/require-description": 0,
+			"jsdoc/require-description-complete-sentence": 0,
+			"jsdoc/require-example": 0,
+			"jsdoc/require-hyphen-before-param-description": 0,
+			"jsdoc/require-param": 1,
+			"jsdoc/require-param-description": 0,
+			"jsdoc/require-param-name": 1,
+			"jsdoc/require-param-type": 1,
+			"jsdoc/require-returns": 1,
+			"jsdoc/require-returns-check": 1,
+			"jsdoc/require-returns-description": 0,
+			"jsdoc/require-returns-type": 1,
+			"jsdoc/valid-types": 1,
+		},
+	}
+];

package/js/DocumentContext.js

@@ -21,13 +21,14 @@ class DocumentContext extends _events.EventEmitter {
     this.backgroundLength = [];
     this.addPage(pageSize);
   }
-  beginColumnGroup(marginXTopParent) {
+  beginColumnGroup(marginXTopParent, bottomByPage = {}) {
     this.snapshots.push({
       x: this.x,
       y: this.y,
       availableHeight: this.availableHeight,
       availableWidth: this.availableWidth,
       page: this.page,
+      bottomByPage: bottomByPage ? bottomByPage : {},
       bottomMost: {
         x: this.x,
         y: this.y,
@@ -42,6 +43,15 @@ class DocumentContext extends _events.EventEmitter {
       this.marginXTopParent = marginXTopParent;
     }
   }
+  updateBottomByPage() {
+    const lastSnapshot = this.snapshots[this.snapshots.length - 1];
+    const lastPage = this.page;
+    let previousBottom = -Number.MIN_VALUE;
+    if (lastSnapshot.bottomByPage[lastPage]) {
+      previousBottom = lastSnapshot.bottomByPage[lastPage];
+    }
+    lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y);
+  }
   resetMarginXTopParent() {
     this.marginXTopParent = null;
   }
@@ -102,6 +112,7 @@ class DocumentContext extends _events.EventEmitter {
       this.availableHeight -= y - saved.bottomMost.y;
     }
     this.lastColumnWidth = saved.lastColumnWidth;
+    return saved.bottomByPage;
   }
   addMargin(left, right) {
     this.x += left;

package/js/ElementWriter.js

@@ -204,9 +204,12 @@ class ElementWriter extends _events.EventEmitter {
       });
     }
   }
-  addVector(vector, ignoreContextX, ignoreContextY, index) {
+  addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
     let context = this.context();
     let page = context.getCurrentPage();
+    if ((0, _variableType.isNumber)(forcePage)) {
+      page = context.pages[forcePage];
+    }
     let position = this.getCurrentPositionOnPage();
     if (page) {
       (0, _tools.offsetVector)(vector, ignoreContextX ? 0 : context.x, ignoreContextY ? 0 : context.y);

package/js/LayoutBuilder.js

@@ -472,7 +472,16 @@ class LayoutBuilder {
       return gaps;
     }
   }
-  findStartingSpanCell(arr, i) {
+
+  /**
+  * Searches for a cell in the same row that starts a rowspan and is positioned immediately before the current cell.
+  * Alternatively, it finds a cell where the colspan initiating the rowspan extends to the cell just before the current one.
+  *
+  * @param {Array<object>} arr - An array representing cells in a row.
+  * @param {number} i - The index of the current cell to search backward from.
+  * @returns {object|null} The starting cell of the rowspan if found; otherwise, `null`.
+  */
+  _findStartingRowSpanCell(arr, i) {
     let requiredColspan = 1;
     for (let index = i - 1; index >= 0; index--) {
       if (!arr[index]._span) {
@@ -486,6 +495,140 @@ class LayoutBuilder {
     }
     return null;
   }
+
+  /**
+  * Retrieves a page break description for a specified page from a list of page breaks.
+  *
+  * @param {Array<object>} pageBreaks - An array of page break descriptions, each containing `prevPage` properties.
+  * @param {number} page - The page number to find the associated page break for.
+  * @returns {object|undefined} The page break description object for the specified page if found; otherwise, `undefined`.
+  */
+  _getPageBreak(pageBreaks, page) {
+    return pageBreaks.find(desc => desc.prevPage === page);
+  }
+  _getPageBreakListBySpan(tableNode, page, rowIndex) {
+    if (!tableNode || !tableNode._breaksBySpan) {
+      return null;
+    }
+    const breaksList = tableNode._breaksBySpan.filter(desc => desc.prevPage === page && rowIndex <= desc.rowIndexOfSpanEnd);
+    let y = Number.MAX_VALUE,
+      prevY = Number.MIN_VALUE;
+    breaksList.forEach(b => {
+      prevY = Math.max(b.prevY, prevY);
+      y = Math.min(b.y, y);
+    });
+    return {
+      prevPage: page,
+      prevY: prevY,
+      y: y
+    };
+  }
+  _findSameRowPageBreakByRowSpanData(breaksBySpan, page, rowIndex) {
+    if (!breaksBySpan) {
+      return null;
+    }
+    return breaksBySpan.find(desc => desc.prevPage === page && rowIndex === desc.rowIndexOfSpanEnd);
+  }
+  _updatePageBreaksData(pageBreaks, tableNode, rowIndex) {
+    Object.keys(tableNode._bottomByPage).forEach(p => {
+      const page = Number(p);
+      const pageBreak = this._getPageBreak(pageBreaks, page);
+      if (pageBreak) {
+        pageBreak.prevY = Math.max(pageBreak.prevY, tableNode._bottomByPage[page]);
+      }
+      if (tableNode._breaksBySpan && tableNode._breaksBySpan.length > 0) {
+        const breaksBySpanList = tableNode._breaksBySpan.filter(pb => pb.prevPage === page && rowIndex <= pb.rowIndexOfSpanEnd);
+        if (breaksBySpanList && breaksBySpanList.length > 0) {
+          breaksBySpanList.forEach(b => {
+            b.prevY = Math.max(b.prevY, tableNode._bottomByPage[page]);
+          });
+        }
+      }
+    });
+  }
+
+  /**
+  * Resolves the Y-coordinates for a target object by comparing two break points.
+  *
+  * @param {object} break1 - The first break point with `prevY` and `y` properties.
+  * @param {object} break2 - The second break point with `prevY` and `y` properties.
+  * @param {object} target - The target object to be updated with resolved Y-coordinates.
+  * @property {number} target.prevY - Updated to the maximum `prevY` value between `break1` and `break2`.
+  * @property {number} target.y - Updated to the minimum `y` value between `break1` and `break2`.
+  */
+  _resolveBreakY(break1, break2, target) {
+    target.prevY = Math.max(break1.prevY, break2.prevY);
+    target.y = Math.min(break1.y, break2.y);
+  }
+  _storePageBreakData(data, startsRowSpan, pageBreaks, tableNode) {
+    if (!startsRowSpan) {
+      let pageDesc = this._getPageBreak(pageBreaks, data.prevPage);
+      let pageDescBySpan = this._getPageBreakListBySpan(tableNode, data.prevPage, data.rowIndex);
+      if (!pageDesc) {
+        pageDesc = {
+          ...data
+        };
+        pageBreaks.push(pageDesc);
+      }
+      if (pageDescBySpan) {
+        this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc);
+      }
+      this._resolveBreakY(pageDesc, data, pageDesc);
+    } else {
+      const breaksBySpan = tableNode && tableNode._breaksBySpan || null;
+      let pageDescBySpan = this._findSameRowPageBreakByRowSpanData(breaksBySpan, data.prevPage, data.rowIndex);
+      if (!pageDescBySpan) {
+        pageDescBySpan = {
+          ...data,
+          rowIndexOfSpanEnd: data.rowIndex + data.rowSpan - 1
+        };
+        if (!tableNode._breaksBySpan) {
+          tableNode._breaksBySpan = [];
+        }
+        tableNode._breaksBySpan.push(pageDescBySpan);
+      }
+      pageDescBySpan.prevY = Math.max(pageDescBySpan.prevY, data.prevY);
+      pageDescBySpan.y = Math.min(pageDescBySpan.y, data.y);
+      let pageDesc = this._getPageBreak(pageBreaks, data.prevPage);
+      if (pageDesc) {
+        this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc);
+      }
+    }
+  }
+  /**
+  * Calculates the left offset for a column based on the specified gap values.
+  *
+  * @param {number} i - The index of the column for which the offset is being calculated.
+  * @param {Array<number>} gaps - An array of gap values for each column.
+  * @returns {number} The left offset for the column. Returns `gaps[i]` if it exists, otherwise `0`.
+  */
+  _colLeftOffset(i, gaps) {
+    if (gaps && gaps.length > i) {
+      return gaps[i];
+    }
+    return 0;
+  }
+
+  /**
+  * Retrieves the ending cell for a row span in case it exists in a specified table column.
+  *
+  * @param {Array<Array<object>>} tableBody - The table body, represented as a 2D array of cell objects.
+  * @param {number} rowIndex - The index of the starting row for the row span.
+  * @param {object} column - The column object containing row span information.
+  * @param {number} columnIndex - The index of the column within the row.
+  * @returns {object|null} The cell at the end of the row span if it exists; otherwise, `null`.
+  * @throws {Error} If the row span extends beyond the total row count.
+  */
+  _getRowSpanEndingCell(tableBody, rowIndex, column, columnIndex) {
+    if (column.rowSpan && column.rowSpan > 1) {
+      let endingRow = rowIndex + column.rowSpan - 1;
+      if (endingRow >= tableBody.length) {
+        throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`);
+      }
+      return tableBody[endingRow][columnIndex];
+    }
+    return null;
+  }
   processRow({
     marginX = [0, 0],
     dontBreakRows = false,
@@ -493,108 +636,94 @@ class LayoutBuilder {
     cells,
     widths,
     gaps,
+    tableNode,
     tableBody,
     rowIndex,
     height
   }) {
-    const updatePageBreakData = (page, prevY) => {
-      let pageDesc;
-      // Find page break data for this row and page
-      for (let i = 0, l = pageBreaks.length; i < l; i++) {
-        let desc = pageBreaks[i];
-        if (desc.prevPage === page) {
-          pageDesc = desc;
-          break;
-        }
-      }
-      // If row has page break in this page, update prevY
-      if (pageDesc) {
-        pageDesc.prevY = Math.max(pageDesc.prevY, prevY);
-      }
-    };
-    const storePageBreakData = data => {
-      let pageDesc;
-      for (let i = 0, l = pageBreaks.length; i < l; i++) {
-        let desc = pageBreaks[i];
-        if (desc.prevPage === data.prevPage) {
-          pageDesc = desc;
-          break;
-        }
-      }
-      if (!pageDesc) {
-        pageDesc = data;
-        pageBreaks.push(pageDesc);
-      }
-      pageDesc.prevY = Math.max(pageDesc.prevY, data.prevY);
-      pageDesc.y = Math.min(pageDesc.y, data.y);
-    };
     const isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1;
     let pageBreaks = [];
+    let pageBreaksByRowSpan = [];
     let positions = [];
     let willBreakByHeight = false;
-    this.writer.addListener('pageChanged', storePageBreakData);
+    widths = widths || cells;
 
     // Check if row should break by height
     if (!isUnbreakableRow && height > this.writer.context().availableHeight) {
       willBreakByHeight = true;
     }
-    widths = widths || cells;
+
     // Use the marginX if we are in a top level table/column (not nested)
     const marginXParent = this.nestedLevel === 1 ? marginX : null;
-    this.writer.context().beginColumnGroup(marginXParent);
+    const _bottomByPage = tableNode ? tableNode._bottomByPage : null;
+    this.writer.context().beginColumnGroup(marginXParent, _bottomByPage);
     for (let i = 0, l = cells.length; i < l; i++) {
-      let column = cells[i];
+      let cell = cells[i];
+
+      // Page change handler
+      const storePageBreakClosure = data => {
+        const startsRowSpan = cell.rowSpan && cell.rowSpan > 1;
+        if (startsRowSpan) {
+          data.rowSpan = cell.rowSpan;
+        }
+        data.rowIndex = rowIndex;
+        this._storePageBreakData(data, startsRowSpan, pageBreaks, tableNode);
+      };
+      this.writer.addListener('pageChanged', storePageBreakClosure);
       let width = widths[i]._calcWidth;
-      let leftOffset = colLeftOffset(i);
-      if (column.colSpan && column.colSpan > 1) {
-        for (let j = 1; j < column.colSpan; j++) {
+      let leftOffset = this._colLeftOffset(i, gaps);
+      // Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
+      let startingSpanCell = this._findStartingRowSpanCell(cells, i);
+      if (cell.colSpan && cell.colSpan > 1) {
+        for (let j = 1; j < cell.colSpan; j++) {
           width += widths[++i]._calcWidth + gaps[i];
         }
       }
 
       // if rowspan starts in this cell, we retrieve the last cell affected by the rowspan
-      const endingCell = getEndingCell(column, i);
-      if (endingCell) {
+      const rowSpanEndingCell = this._getRowSpanEndingCell(tableBody, rowIndex, cell, i);
+      if (rowSpanEndingCell) {
         // We store a reference of the ending cell in the first cell of the rowspan
-        column._endingCell = endingCell;
-        column._endingCell._startingRowSpanY = column._startingRowSpanY;
+        cell._endingCell = rowSpanEndingCell;
+        cell._endingCell._startingRowSpanY = cell._startingRowSpanY;
       }
 
-      // Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after
-      let startingSpanCell = this.findStartingSpanCell(cells, i);
-      let endingSpanCell = null;
+      // If we are after a cell that started a rowspan
+      let endOfRowSpanCell = null;
       if (startingSpanCell && startingSpanCell._endingCell) {
         // Reference to the last cell of the rowspan
-        endingSpanCell = startingSpanCell._endingCell;
+        endOfRowSpanCell = startingSpanCell._endingCell;
         // Store if we are in an unbreakable block when we save the context and the originalX
         if (this.writer.transactionLevel > 0) {
-          endingSpanCell._isUnbreakableContext = true;
-          endingSpanCell._originalXOffset = this.writer.originalX;
+          endOfRowSpanCell._isUnbreakableContext = true;
+          endOfRowSpanCell._originalXOffset = this.writer.originalX;
         }
       }
 
       // We pass the endingSpanCell reference to store the context just after processing rowspan cell
-      this.writer.context().beginColumn(width, leftOffset, endingSpanCell);
-      if (!column._span) {
-        this.processNode(column);
-        addAll(positions, column.positions);
-      } else if (column._columnEndingContext) {
+      this.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell);
+      if (!cell._span) {
+        this.processNode(cell);
+        this.writer.context().updateBottomByPage();
+        addAll(positions, cell.positions);
+      } else if (cell._columnEndingContext) {
         let discountY = 0;
         if (dontBreakRows) {
           // Calculate how many points we have to discount to Y when dontBreakRows and rowSpan are combined
           const ctxBeforeRowSpanLastRow = this.writer.contextStack[this.writer.contextStack.length - 1];
-          discountY = ctxBeforeRowSpanLastRow.y - column._startingRowSpanY;
+          discountY = ctxBeforeRowSpanLastRow.y - cell._startingRowSpanY;
         }
         let originalXOffset = 0;
         // If context was saved from an unbreakable block and we are not in an unbreakable block anymore
         // We have to sum the originalX (X before starting unbreakable block) to X
-        if (column._isUnbreakableContext && !this.writer.transactionLevel) {
-          originalXOffset = column._originalXOffset;
+        if (cell._isUnbreakableContext && !this.writer.transactionLevel) {
+          originalXOffset = cell._originalXOffset;
         }
         // row-span ending
         // Recover the context after processing the rowspanned cell
-        this.writer.context().markEnding(column, originalXOffset, discountY);
+        this.writer.context().markEnding(cell, originalXOffset, discountY);
       }
+      this.writer.removeListener('pageChanged', storePageBreakClosure);
     }
 
     // Check if last cell is part of a span
@@ -607,7 +736,7 @@ class LayoutBuilder {
         // Previous column cell is part of a span
       } else if (lastColumn._span === true) {
         // We get the cell that started the span where we set a reference to the ending cell
-        const startingSpanCell = this.findStartingSpanCell(cells, cells.length);
+        const startingSpanCell = this._findStartingRowSpanCell(cells, cells.length);
         if (startingSpanCell) {
           // Context will be stored here (ending cell)
           endingSpanCell = startingSpanCell._endingCell;
@@ -620,36 +749,22 @@ class LayoutBuilder {
       }
     }
 
-    // If there are page breaks in this row, update data with prevY of last cell
-    updatePageBreakData(this.writer.context().page, this.writer.context().y);
-
     // If content did not break page, check if we should break by height
-    if (!isUnbreakableRow && pageBreaks.length === 0 && willBreakByHeight) {
+    if (willBreakByHeight && !isUnbreakableRow && pageBreaks.length === 0) {
       this.writer.context().moveDown(this.writer.context().availableHeight);
       this.writer.moveToNextPage();
     }
-    this.writer.context().completeColumnGroup(height, endingSpanCell);
-    this.writer.removeListener('pageChanged', storePageBreakData);
+    const bottomByPage = this.writer.context().completeColumnGroup(height, endingSpanCell);
+    if (tableNode) {
+      tableNode._bottomByPage = bottomByPage;
+      // If there are page breaks in this row, update data with prevY of last cell
+      this._updatePageBreaksData(pageBreaks, tableNode, rowIndex);
+    }
     return {
+      pageBreaksBySpan: pageBreaksByRowSpan,
       pageBreaks: pageBreaks,
       positions: positions
     };
-    function colLeftOffset(i) {
-      if (gaps && gaps.length > i) {
-        return gaps[i];
-      }
-      return 0;
-    }
-    function getEndingCell(column, columnIndex) {
-      if (column.rowSpan && column.rowSpan > 1) {
-        let endingRow = rowIndex + column.rowSpan - 1;
-        if (endingRow >= tableBody.length) {
-          throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`);
-        }
-        return tableBody[endingRow][columnIndex];
-      }
-      return null;
-    }
   }
 
   // lists
@@ -715,6 +830,7 @@ class LayoutBuilder {
       if (height === 'auto') {
         height = undefined;
       }
+      const pageBeforeProcessing = this.writer.context().page;
       let result = this.processRow({
         marginX: tableNode._margin ? [tableNode._margin[0], tableNode._margin[2]] : [0, 0],
         dontBreakRows: processor.dontBreakRows,
@@ -723,10 +839,19 @@ class LayoutBuilder {
         widths: tableNode.table.widths,
         gaps: tableNode._offsets.offsets,
         tableBody: tableNode.table.body,
+        tableNode,
         rowIndex: i,
         height
       });
       addAll(tableNode.positions, result.positions);
+      if (!result.pageBreaks || result.pageBreaks.length === 0) {
+        const breaksBySpan = tableNode && tableNode._breaksBySpan || null;
+        const breakBySpanData = this._findSameRowPageBreakByRowSpanData(breaksBySpan, pageBeforeProcessing, i);
+        if (breakBySpanData) {
+          const finalBreakBySpanData = this._getPageBreakListBySpan(tableNode, breakBySpanData.prevPage, i);
+          result.pageBreaks.push(finalBreakBySpanData);
+        }
+      }
       processor.endRow(i, this.writer, result.pageBreaks);
     }
     processor.endTable(this.writer);

package/js/PageElementWriter.js

@@ -36,8 +36,8 @@ class PageElementWriter extends _ElementWriter.default {
   addAttachment(attachment, index) {
     return this._fitOnPage(() => super.addAttachment(attachment, index));
   }
-  addVector(vector, ignoreContextX, ignoreContextY, index) {
-    return super.addVector(vector, ignoreContextX, ignoreContextY, index);
+  addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) {
+    return super.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage);
   }
   beginClip(width, height) {
     return super.beginClip(width, height);

package/js/Printer.js

@@ -50,6 +50,9 @@ class PdfPrinter {
       this.resolveUrls(docDefinition).then(() => {
         try {
           docDefinition.version = docDefinition.version || '1.3';
+          docDefinition.subset = docDefinition.subset || undefined;
+          docDefinition.tagged = typeof docDefinition.tagged === 'boolean' ? docDefinition.tagged : false;
+          docDefinition.displayTitle = typeof docDefinition.displayTitle === 'boolean' ? docDefinition.displayTitle : false;
           docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true;
           docDefinition.images = docDefinition.images || {};
           docDefinition.attachments = docDefinition.attachments || {};
@@ -59,6 +62,9 @@ class PdfPrinter {
           let pdfOptions = {
             size: [pageSize.width, pageSize.height],
             pdfVersion: docDefinition.version,
+            subset: docDefinition.subset,
+            tagged: docDefinition.tagged,
+            displayTitle: docDefinition.displayTitle,
             compress: docDefinition.compress,
             userPassword: docDefinition.userPassword,
             ownerPassword: docDefinition.ownerPassword,

package/js/Renderer.js

@@ -329,6 +329,23 @@ class Renderer {
       return fontFile;
     };
     (0, _svgToPdfkit.default)(this.pdfDocument, svg.svg, svg.x, svg.y, options);
+    if (svg.link) {
+      this.pdfDocument.link(svg.x, svg.y, svg._width, svg._height, svg.link);
+    }
+    if (svg.linkToPage) {
+      this.pdfDocument.ref({
+        Type: 'Action',
+        S: 'GoTo',
+        D: [svg.linkToPage, 0, 0]
+      }).end();
+      this.pdfDocument.annotate(svg.x, svg.y, svg._width, svg._height, {
+        Subtype: 'Link',
+        Dest: [svg.linkToPage - 1, 'XYZ', null, null, null]
+      });
+    }
+    if (svg.linkToDestination) {
+      this.pdfDocument.goTo(svg.x, svg.y, svg._width, svg._height, svg.linkToDestination);
+    }
   }
   renderAttachment(attachment) {
     const file = this.pdfDocument.provideAttachment(attachment.attachment);