n8n-nodes-pdf-writer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ArchitWeb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# n8n-nodes-pdf-writer
+
+A custom n8n community node with two operations:
+- **Write Text** – write text at specific **X/Y coordinates** on any PDF page
+- **Merge PDFs** – merge specific pages from multiple PDF files into one
+
+This node was designed to fill a necessary gap,
+and we've decided to make it available for anyone who needs this functionality in n8n.
+
+---
+
+## Features
+
+- ✅ Write text at precise X/Y coordinates on any page
+- ✅ Label each text entry for easy identification
+- ✅ Multiple text entries per execution
+- ✅ Target a specific page or **all pages** at once
+- ✅ Y-origin toggle: measure from **top** or **bottom** of the page
+- ✅ Choose from 7 built-in fonts (Helvetica, Times, Courier families)
+- ✅ Set font size, color (hex), rotation, and opacity
+- ✅ Merge multiple PDFs into one — all pages or **select specific pages per file**
+- ✅ Page selection supports ranges and lists (e.g. `1,3,5-8`)
+- ✅ Works with binary PDF data from any n8n node
+
+---
+
+## Installation
+
+In the n8n UI: **Settings → Community Nodes → Install** → enter `n8n-nodes-pdf-writer`
+
+Then restart n8n.
+
+---
+
+## Operations
+
+### Write Text
+
+Writes one or more text entries at specified X/Y positions on a PDF.
+
+| Parameter | Description |
+|---|---|
+| **Input PDF Field** | Binary field name holding the source PDF (default: `data`) |
+| **Output Field Name** | Binary field name to write the result to (default: `data`) |
+
+#### Text Entry fields
+
+| Field | Description |
+|---|---|
+| **Label** | A name to identify this entry (e.g. "Header", "Footer", "Stamp") |
+| **Text** | The text string to draw |
+| **Page** | Page number (1-based). Set to `0` to apply to all pages |
+| **X Position** | Points from the left edge |
+| **Y Position** | Points from the selected Y origin |
+| **Y Origin** | `From Bottom` (PDF default) or `From Top` (more intuitive) |
+| **Font Size** | Size in points |
+| **Font** | Helvetica, Helvetica Bold, Times Roman, Courier, etc. |
+| **Color (Hex)** | Text color, e.g. `#FF0000` for red |
+| **Rotation** | Degrees counter-clockwise |
+| **Opacity** | 0.0 (invisible) → 1.0 (solid) |
+
+---
+
+### Merge PDFs
+
+Takes **all input items** (each carrying a PDF binary) and merges them into a single PDF. You can include all pages or select specific pages from each file.
+
+| Parameter | Description |
+|---|---|
+| **Binary Field** | Binary field name that holds the PDF in each input item (default: `data`) |
+| **Pages Per Item** | `All Pages` or `Select Pages Per Item` |
+| **Pages** | Page selection per item — supports `all`, single pages (`1,3,5`), and ranges (`2-4`). Pages are 1-based. Supports n8n expressions. |
+| **Output Field Name** | Binary field name for the merged PDF output (default: `data`) |
+| **Output File Name** | File name of the merged PDF (default: `merged.pdf`) |
+
+#### Page selection format
+
+| Input | Meaning |
+|---|---|
+| `all` | All pages from this PDF |
+| `1,3,5` | Pages 1, 3 and 5 only |
+| `2-6` | Pages 2 through 6 |
+| `1,3,5-8` | Pages 1, 3 and 5 through 8 |
+
+You can use n8n expressions in the Pages field to select different pages from each item dynamically:
+```
+{{ $itemIndex === 0 ? "1-3" : $itemIndex === 1 ? "2,5" : "all" }}
+```
+
+---
+
+## Coordinate System (Write Text)
+
+PDF coordinates by default start at the **bottom-left corner** (0, 0). A standard A4 page is 595 × 842 points.
+
+```
+(0, 842) ─────────────── (595, 842)   ← Top
+   │                          │
+   │     Y increases ↑        │
+   │                          │
+(0, 0) ──────────────── (595, 0)      ← Bottom (PDF origin)
+```
+
+When **Y Origin = "From Top"** is selected, the node automatically converts for you:  
+`y_pdf = page_height − y_from_top`
+
+**Tip:** A4 = 595 × 842 pt | Letter = 612 × 792 pt | 1 inch = 72 points
+
+---
+
+## Example Workflows
+
+### Write Text
+
+```
+[Read Binary File] → [PDF Text Writer (Write Text)] → [Write Binary File]
+```
+
+1. Use **Read Binary File** (or HTTP Request, etc.) to get a PDF into a binary field
+2. Add a **PDF Text Writer** node, set Operation to **Write Text**
+3. Add text entries with label, content, position and style
+4. The output binary field contains the modified PDF
+
+#### Sample text entry configuration
+```json
+{
+  "label": "Confidential Stamp",
+  "text": "CONFIDENTIAL",
+  "page": 1,
+  "x": 200,
+  "y": 50,
+  "yOrigin": "top",
+  "fontSize": 24,
+  "font": "Helvetica-Bold",
+  "color": "#FF0000",
+  "rotation": 0,
+  "opacity": 0.8
+}
+```
+
+### Merge PDFs
+
+```
+[Item 1: PDF A] ─┐
+[Item 2: PDF B] ─┼─→ [PDF Text Writer (Merge PDFs)] → [Write Binary File]
+[Item 3: PDF C] ─┘
+```
+
+1. Feed multiple items, each with a PDF binary field
+2. Add a **PDF Text Writer** node, set Operation to **Merge PDFs**
+3. Set **Pages Per Item** to `Select Pages Per Item` and configure a Pages expression
+4. The single output item contains the merged PDF
+
+---
+
+## Dependencies
+
+- [`pdf-lib`](https://pdf-lib.js.org/) – Pure JavaScript PDF manipulation
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { PdfWriter } from './nodes/PdfWriter/PdfWriter.node';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfWriter = void 0;
+var PdfWriter_node_1 = require("./nodes/PdfWriter/PdfWriter.node");
+Object.defineProperty(exports, "PdfWriter", { enumerable: true, get: function () { return PdfWriter_node_1.PdfWriter; } });

package/dist/nodes/PdfWriter/PdfWriter.node.d.ts

@@ -0,0 +1,9 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class PdfWriter implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Parse a page selection string like "1,3,5-8" into 0-based page indices.
+     */
+    private static parsePageSelection;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/PdfWriter/PdfWriter.node.js

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfWriter = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const pdf_lib_1 = require("pdf-lib");
+class PdfWriter {
+    constructor() {
+        this.description = {
+            displayName: 'PDF Writer',
+            name: 'PdfWriter',
+            icon: 'file:pdf-writer.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{ $parameter["operation"] === "merge" ? "Merge PDFs" : "Write text on PDF" }}',
+            description: 'Write text on PDF pages or merge specific pages from multiple PDFs',
+            defaults: {
+                name: 'PDF Writer',
+            },
+            inputs: [{ type: 'main' }],
+            outputs: [{ type: 'main' }],
+            properties: [
+                // ─── Operation ────────────────────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    default: 'writeText',
+                    options: [
+                        {
+                            name: 'Write Text',
+                            value: 'writeText',
+                            description: 'Write text at specific X/Y coordinates on a PDF',
+                        },
+                        {
+                            name: 'Merge PDFs',
+                            value: 'merge',
+                            description: 'Merge specific pages from multiple PDF files into one',
+                        },
+                    ],
+                },
+                // ─── Write Text: Input ────────────────────────────────────────────────
+                {
+                    displayName: 'Input PDF Field',
+                    name: 'inputField',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary field that contains the input PDF (e.g. "data")',
+                    displayOptions: {
+                        show: {
+                            operation: ['writeText'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Field Name',
+                    name: 'outputField',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary field to write the modified PDF to',
+                    displayOptions: {
+                        show: {
+                            operation: ['writeText'],
+                        },
+                    },
+                },
+                // ─── Merge: Input ─────────────────────────────────────────────────────
+                {
+                    displayName: 'Binary Field',
+                    name: 'mergeBinaryField',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary field containing the PDF in each input item',
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Pages Per Item',
+                    name: 'mergeMode',
+                    type: 'options',
+                    default: 'all',
+                    options: [
+                        {
+                            name: 'All Pages',
+                            value: 'all',
+                            description: 'Include all pages from each input PDF',
+                        },
+                        {
+                            name: 'Select Pages Per Item',
+                            value: 'select',
+                            description: 'Specify which pages to take from each input item (configured per item via expression)',
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Pages',
+                    name: 'mergePages',
+                    type: 'string',
+                    default: 'all',
+                    description: 'Pages to include from this PDF. Use comma-separated values and ranges: e.g. "1,3,5-8", "2-4", or "all" for all pages. Pages are 1-based.',
+                    placeholder: 'e.g. 1,3,5-8',
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                            mergeMode: ['select'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Field Name',
+                    name: 'mergeOutputField',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary field to write the merged PDF to',
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output File Name',
+                    name: 'mergeFileName',
+                    type: 'string',
+                    default: 'merged.pdf',
+                    description: 'File name for the merged PDF output',
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                // ─── Write Text: Text entries (fixed list) ────────────────────────────
+                {
+                    displayName: 'Text Entries',
+                    displayOptions: {
+                        show: {
+                            operation: ['writeText'],
+                        },
+                    },
+                    name: 'textEntries',
+                    type: 'fixedCollection',
+                    placeholder: 'Add Text Entry',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'entry',
+                            displayName: 'Text Entry',
+                            values: [
+                                {
+                                    displayName: 'Label',
+                                    name: 'label',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'A name to identify this text entry (e.g. "Header", "Footer", "Stamp")',
+                                    placeholder: 'e.g. Header',
+                                },
+                                {
+                                    displayName: 'Text',
+                                    name: 'text',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'The text to write on the PDF',
+                                },
+                                {
+                                    displayName: 'Page',
+                                    name: 'page',
+                                    type: 'number',
+                                    default: 1,
+                                    description: 'Page number to write on (1-based index). Use 0 for all pages.',
+                                    typeOptions: {
+                                        minValue: 0,
+                                    },
+                                },
+                                {
+                                    displayName: 'X Position',
+                                    name: 'x',
+                                    type: 'number',
+                                    default: 50,
+                                    description: 'Horizontal position in points from the left edge of the page',
+                                },
+                                {
+                                    displayName: 'Y Position',
+                                    name: 'y',
+                                    type: 'number',
+                                    default: 50,
+                                    description: 'Vertical position in points from the bottom edge of the page (PDF coordinate system). Use "Y from Top" option to switch.',
+                                },
+                                {
+                                    displayName: 'Y Origin',
+                                    name: 'yOrigin',
+                                    type: 'options',
+                                    default: 'bottom',
+                                    options: [
+                                        {
+                                            name: 'From Bottom (PDF default)',
+                                            value: 'bottom',
+                                        },
+                                        {
+                                            name: 'From Top',
+                                            value: 'top',
+                                        },
+                                    ],
+                                    description: 'Whether Y is measured from the bottom or the top of the page',
+                                },
+                                {
+                                    displayName: 'Font Size',
+                                    name: 'fontSize',
+                                    type: 'number',
+                                    default: 12,
+                                    typeOptions: { minValue: 1 },
+                                },
+                                {
+                                    displayName: 'Font',
+                                    name: 'font',
+                                    type: 'options',
+                                    default: 'Helvetica',
+                                    options: [
+                                        { name: 'Helvetica', value: 'Helvetica' },
+                                        { name: 'Helvetica Bold', value: 'Helvetica-Bold' },
+                                        { name: 'Helvetica Oblique', value: 'Helvetica-Oblique' },
+                                        { name: 'Times Roman', value: 'Times-Roman' },
+                                        { name: 'Times Bold', value: 'Times-Bold' },
+                                        { name: 'Courier', value: 'Courier' },
+                                        { name: 'Courier Bold', value: 'Courier-Bold' },
+                                    ],
+                                },
+                                {
+                                    displayName: 'Color (Hex)',
+                                    name: 'color',
+                                    type: 'color',
+                                    default: '#000000',
+                                    description: 'Text color in hex format',
+                                },
+                                {
+                                    displayName: 'Rotation (degrees)',
+                                    name: 'rotation',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Text rotation in degrees (counter-clockwise)',
+                                },
+                                {
+                                    displayName: 'Opacity',
+                                    name: 'opacity',
+                                    type: 'number',
+                                    default: 1,
+                                    typeOptions: { minValue: 0, maxValue: 1, numberStepSize: 0.1 },
+                                    description: 'Text opacity from 0 (transparent) to 1 (opaque)',
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    /**
+     * Parse a page selection string like "1,3,5-8" into 0-based page indices.
+     */
+    static parsePageSelection(selection, totalPages) {
+        const trimmed = selection.trim().toLowerCase();
+        if (trimmed === 'all' || trimmed === '') {
+            return Array.from({ length: totalPages }, (_, i) => i);
+        }
+        const indices = [];
+        const parts = trimmed.split(',');
+        for (const part of parts) {
+            const rangeParts = part.trim().split('-');
+            if (rangeParts.length === 2) {
+                const start = parseInt(rangeParts[0].trim(), 10);
+                const end = parseInt(rangeParts[1].trim(), 10);
+                if (isNaN(start) || isNaN(end) || start < 1 || end < 1) {
+                    throw new Error(`Invalid page range: "${part.trim()}". Pages must be >= 1.`);
+                }
+                for (let p = Math.min(start, end); p <= Math.max(start, end); p++) {
+                    if (p > totalPages) {
+                        throw new Error(`Page ${p} does not exist. The PDF has ${totalPages} page(s).`);
+                    }
+                    indices.push(p - 1); // convert to 0-based
+                }
+            }
+            else if (rangeParts.length === 1) {
+                const pageNum = parseInt(rangeParts[0].trim(), 10);
+                if (isNaN(pageNum) || pageNum < 1) {
+                    throw new Error(`Invalid page number: "${rangeParts[0].trim()}". Pages must be >= 1.`);
+                }
+                if (pageNum > totalPages) {
+                    throw new Error(`Page ${pageNum} does not exist. The PDF has ${totalPages} page(s).`);
+                }
+                indices.push(pageNum - 1);
+            }
+            else {
+                throw new Error(`Invalid page selection: "${part.trim()}". Use format like "1,3,5-8".`);
+            }
+        }
+        return indices;
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        // ─── Merge PDFs ─────────────────────────────────────────────────────
+        if (operation === 'merge') {
+            try {
+                const mergeBinaryField = this.getNodeParameter('mergeBinaryField', 0);
+                const mergeOutputField = this.getNodeParameter('mergeOutputField', 0);
+                const mergeFileName = this.getNodeParameter('mergeFileName', 0);
+                const mergeMode = this.getNodeParameter('mergeMode', 0);
+                const mergedPdf = await pdf_lib_1.PDFDocument.create();
+                for (let i = 0; i < items.length; i++) {
+                    const binaryData = items[i].binary;
+                    if (!binaryData || !binaryData[mergeBinaryField]) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Item ${i + 1} does not have binary field "${mergeBinaryField}"`, { itemIndex: i });
+                    }
+                    const pdfBuffer = await this.helpers.getBinaryDataBuffer(i, mergeBinaryField);
+                    if (binaryData[mergeBinaryField].mimeType && binaryData[mergeBinaryField].mimeType !== 'application/pdf') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Item ${i + 1} binary field "${mergeBinaryField}" is not a PDF (got "${binaryData[mergeBinaryField].mimeType}").`, { itemIndex: i });
+                    }
+                    const sourcePdf = await pdf_lib_1.PDFDocument.load(pdfBuffer);
+                    const totalPages = sourcePdf.getPageCount();
+                    let pageIndices;
+                    if (mergeMode === 'select') {
+                        const pagesStr = this.getNodeParameter('mergePages', i);
+                        pageIndices = PdfWriter.parsePageSelection(pagesStr, totalPages);
+                    }
+                    else {
+                        pageIndices = sourcePdf.getPageIndices();
+                    }
+                    const copiedPages = await mergedPdf.copyPages(sourcePdf, pageIndices);
+                    for (const page of copiedPages) {
+                        mergedPdf.addPage(page);
+                    }
+                }
+                const mergedBytes = await mergedPdf.save();
+                const mergedBuffer = Buffer.from(mergedBytes);
+                const newBinaryData = await this.helpers.prepareBinaryData(mergedBuffer, mergeFileName || 'merged.pdf', 'application/pdf');
+                returnData.push({
+                    json: {
+                        pdfMerged: true,
+                        inputFiles: items.length,
+                        pageCount: mergedPdf.getPageCount(),
+                    },
+                    binary: {
+                        [mergeOutputField]: newBinaryData,
+                    },
+                    pairedItem: { item: 0 },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: 0 },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+            return [returnData];
+        }
+        // ─── Write Text ─────────────────────────────────────────────────────
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const inputField = this.getNodeParameter('inputField', i);
+                const outputField = this.getNodeParameter('outputField', i);
+                const textEntriesParam = this.getNodeParameter('textEntries', i);
+                const entries = (_a = textEntriesParam.entry) !== null && _a !== void 0 ? _a : [];
+                // Get the binary PDF data
+                const binaryData = this.helpers.assertBinaryData(i, inputField);
+                if (binaryData.mimeType && binaryData.mimeType !== 'application/pdf') {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Binary field "${inputField}" is not a PDF (got "${binaryData.mimeType}").`, { itemIndex: i });
+                }
+                const pdfBuffer = await this.helpers.getBinaryDataBuffer(i, inputField);
+                // Load the PDF
+                const pdfDoc = await pdf_lib_1.PDFDocument.load(pdfBuffer);
+                const pages = pdfDoc.getPages();
+                // Font map
+                const fontMap = {
+                    'Helvetica': pdf_lib_1.StandardFonts.Helvetica,
+                    'Helvetica-Bold': pdf_lib_1.StandardFonts.HelveticaBold,
+                    'Helvetica-Oblique': pdf_lib_1.StandardFonts.HelveticaOblique,
+                    'Times-Roman': pdf_lib_1.StandardFonts.TimesRoman,
+                    'Times-Bold': pdf_lib_1.StandardFonts.TimesRomanBold,
+                    'Courier': pdf_lib_1.StandardFonts.Courier,
+                    'Courier-Bold': pdf_lib_1.StandardFonts.CourierBold,
+                };
+                // Cache for embedded fonts to avoid re-embedding the same font
+                const fontCache = new Map();
+                // Process each text entry
+                for (const entry of entries) {
+                    const targetPageNum = (_b = entry.page) !== null && _b !== void 0 ? _b : 1;
+                    const pagesToWrite = targetPageNum === 0
+                        ? pages
+                        : [pages[targetPageNum - 1]].filter(Boolean);
+                    if (pagesToWrite.length === 0) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Page ${targetPageNum} does not exist. The PDF has ${pages.length} page(s).`, { itemIndex: i });
+                    }
+                    const fontKey = (_c = entry.font) !== null && _c !== void 0 ? _c : 'Helvetica';
+                    if (!fontCache.has(fontKey)) {
+                        fontCache.set(fontKey, await pdfDoc.embedFont((_d = fontMap[fontKey]) !== null && _d !== void 0 ? _d : pdf_lib_1.StandardFonts.Helvetica));
+                    }
+                    const embeddedFont = fontCache.get(fontKey);
+                    // Parse and validate hex color
+                    const rawHex = ((_e = entry.color) !== null && _e !== void 0 ? _e : '#000000').replace('#', '');
+                    if (!/^[0-9a-fA-F]{6}$/.test(rawHex)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid color value: "${entry.color}". Expected a 6-digit hex color (e.g. "#FF0000").`, { itemIndex: i });
+                    }
+                    const r = parseInt(rawHex.substring(0, 2), 16) / 255;
+                    const g = parseInt(rawHex.substring(2, 4), 16) / 255;
+                    const b = parseInt(rawHex.substring(4, 6), 16) / 255;
+                    for (const page of pagesToWrite) {
+                        const { height } = page.getSize();
+                        let yCoord = (_f = entry.y) !== null && _f !== void 0 ? _f : 50;
+                        if (entry.yOrigin === 'top') {
+                            yCoord = height - yCoord;
+                        }
+                        page.drawText((_g = entry.text) !== null && _g !== void 0 ? _g : '', {
+                            x: (_h = entry.x) !== null && _h !== void 0 ? _h : 50,
+                            y: yCoord,
+                            size: (_j = entry.fontSize) !== null && _j !== void 0 ? _j : 12,
+                            font: embeddedFont,
+                            color: (0, pdf_lib_1.rgb)(r, g, b),
+                            rotate: (0, pdf_lib_1.degrees)((_k = entry.rotation) !== null && _k !== void 0 ? _k : 0),
+                            opacity: (_l = entry.opacity) !== null && _l !== void 0 ? _l : 1,
+                        });
+                    }
+                }
+                // Save the modified PDF
+                const modifiedPdfBytes = await pdfDoc.save();
+                const modifiedBuffer = Buffer.from(modifiedPdfBytes);
+                const newBinaryData = await this.helpers.prepareBinaryData(modifiedBuffer, (_m = binaryData.fileName) !== null && _m !== void 0 ? _m : 'output.pdf', 'application/pdf');
+                returnData.push({
+                    json: {
+                        ...items[i].json,
+                        pdfModified: true,
+                        pageCount: pages.length,
+                        textEntriesWritten: entries.length,
+                    },
+                    binary: {
+                        ...((_o = items[i].binary) !== null && _o !== void 0 ? _o : {}),
+                        [outputField]: newBinaryData,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PdfWriter = PdfWriter;

package/dist/nodes/PdfWriter/pdf-writer.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 60 60">
+  <!-- PDF page background -->
+  <rect x="8" y="4" width="36" height="46" rx="3" ry="3" fill="#e74c3c"/>
+  <!-- Folded corner -->
+  <polygon points="32,4 44,16 32,16" fill="#c0392b"/>
+  <!-- White content area -->
+  <rect x="12" y="18" width="28" height="26" rx="1" fill="white" opacity="0.9"/>
+  <!-- Text lines -->
+  <rect x="15" y="22" width="22" height="2.5" rx="1" fill="#e74c3c"/>
+  <rect x="15" y="27" width="18" height="2.5" rx="1" fill="#e74c3c"/>
+  <rect x="15" y="32" width="20" height="2.5" rx="1" fill="#e74c3c"/>
+  <!-- Cursor / pin indicator -->
+  <circle cx="46" cy="46" r="10" fill="#3498db"/>
+  <text x="46" y="50" text-anchor="middle" font-size="12" font-weight="bold" fill="white" font-family="Arial">T</text>
+</svg>

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "n8n-nodes-pdf-writer",
+  "version": "1.0.0",
+  "description": "n8n node to write text at X/Y coordinates on PDF pages and merge multiple PDFs with page selection",
+  "keywords": [
+    "n8n-community-node-package",
+    "pdf",
+    "text",
+    "coordinates",
+    "merge",
+    "pdf-merge"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/architweb/n8n-node-pdf-write",
+  "author": {
+    "name": "ArchitWeb"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/architweb/n8n-node-pdf-write.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && npm run copy-icons",
+    "copy-icons": "node -e \"const fs=require('fs'),p=require('path');const src='nodes/PdfWriter',dst='dist/nodes/PdfWriter';fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.svg')).forEach(f=>fs.copyFileSync(p.join(src,f),p.join(dst,f)))\"",
+    "dev": "tsc --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [],
+    "nodes": [
+      "dist/nodes/PdfWriter/PdfWriter.node.js"
+    ]
+  },
+  "dependencies": {
+    "pdf-lib": "^1.17.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "n8n-workflow": "*",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}