n8n-nodes-docx-filler 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rokodo
+
+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,161 @@
+# n8n-nodes-docx-filler
+
+[![npm version](https://badge.fury.io/js/n8n-nodes-docx-filler.svg)](https://www.npmjs.com/package/n8n-nodes-docx-filler)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+n8n community node to automatically fill DOCX documents (French DC1, DC2, AE administrative forms) with company data.
+
+**Works as AI Agent tool!**
+
+## Features
+
+- Fill DOCX templates with data from source documents
+- Extract company data from filled documents
+- Automatic field detection (SIRET, TVA, email, address, etc.)
+- Checkbox state copying
+- Compatible with n8n AI Agents (`usableAsTool: true`)
+
+## Installation
+
+### Via n8n Community Nodes (Recommended)
+
+1. Go to **Settings > Community Nodes**
+2. Select **Install**
+3. Enter `n8n-nodes-docx-filler`
+4. Click **Install**
+
+### Via npm (self-hosted)
+
+```bash
+npm install n8n-nodes-docx-filler
+```
+
+### Enable AI Agent Tool Usage
+
+Add this environment variable to your n8n instance:
+
+```bash
+N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true
+```
+
+## Operations
+
+### Fill Document
+
+Fills a template document with data extracted from a source document.
+
+| Parameter | Description |
+|-----------|-------------|
+| `sourceDocument` | Document containing company data (binary property or base64) |
+| `templateDocument` | Empty template to fill (binary property or base64) |
+| `outputProperty` | Binary property name for output (default: "data") |
+
+### Extract Data
+
+Extracts company data from a filled document.
+
+| Parameter | Description |
+|-----------|-------------|
+| `document` | Document to analyze (binary property or base64) |
+
+### Analyze
+
+Analyzes document structure for debugging.
+
+| Parameter | Description |
+|-----------|-------------|
+| `document` | Document to analyze |
+
+## Supported Fields
+
+The node automatically recognizes these fields in French administrative documents:
+
+- **SIRET** - Company registration number
+- **TVA Intracommunautaire** - EU VAT number
+- **Email** - Email address
+- **Téléphone** - Phone number
+- **Adresse** - Postal address
+- **Nom commercial** - Commercial name
+- **Forme juridique** - Legal form
+- **Capital social** - Share capital
+- **Code NAF/APE** - Activity code
+
+## Usage with AI Agent
+
+This node is compatible with n8n AI Agents.
+
+**Example agent prompt:**
+```
+You have access to the DOCX Filler tool to fill documents.
+
+Use the "fill" operation with:
+- sourceDocument: the document containing company data
+- templateDocument: the empty form to fill
+
+Execute directly without asking for confirmation.
+```
+
+## Example Workflow
+
+```
+[Read Binary File] → [DOCX Filler (Fill)] → [Write Binary File]
+     (source)                                    (output)
+         ↑
+[Read Binary File]
+    (template)
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/rokodo-io/n8n-nodes-docx-filler.git
+cd n8n-nodes-docx-filler
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Watch mode
+npm run dev
+
+# Create package
+npm pack
+```
+
+## Publishing to npm
+
+```bash
+# Login to npm
+npm login
+
+# Publish
+npm publish
+```
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+
+[MIT](LICENSE)
+
+## Author
+
+**Rokodo** - [contact@rokodo.io](mailto:contact@rokodo.io)
+
+## Links
+
+- [n8n Community Nodes](https://docs.n8n.io/integrations/community-nodes/)
+- [n8n Documentation](https://docs.n8n.io/)
+- [GitHub Repository](https://github.com/rokodo-io/n8n-nodes-docx-filler)
+
+---
+
+Sources:
+- [n8n Custom Node Documentation](https://docs.n8n.io/integrations/creating-nodes/overview/)
+- [Creating Custom Node as AI Tool](https://community.n8n.io/t/creating-a-custom-node-tool/79651)
+- [n8n Community Packages Allow Tool Usage](https://github.com/n8n-io/n8n/issues/12593)

package/dist/DocxFiller/DocxFiller.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class DocxFiller implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/DocxFiller/DocxFiller.node.js

@@ -0,0 +1,467 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocxFiller = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const pizzip_1 = __importDefault(require("pizzip"));
+// Labels spécifiques à rechercher dans les documents DC/AE
+const LABEL_PATTERNS = [
+    ['siret', ['numéro siret', 'n° siret', 'siret']],
+    ['tva_intra', ['tva intracommunautaire', 'identification européen']],
+    ['email', ['adresse électronique', 'courriel', 'e-mail']],
+    ['telephone', ['numéros de téléphone', 'téléphone', 'télécopie']],
+    ['adresse', ['adresse postale', 'siège social']],
+    ['nom_commercial', ['nom commercial', 'dénomination sociale', 'raison sociale']],
+    ['forme_juridique', ['forme juridique', 'statut juridique']],
+    ['capital', ['capital social']],
+    ['code_naf', ['code naf', 'code ape']],
+];
+const CHECKBOX_UNCHECKED = ['☐', '□', '▢'];
+const CHECKBOX_CHECKED = ['☒', '☑', '▣'];
+function normalize(text) {
+    return text.replace(/^[■▪●○•\s▪]+/, '').toLowerCase().trim();
+}
+function hasCheckbox(text) {
+    return [...CHECKBOX_UNCHECKED, ...CHECKBOX_CHECKED].some(c => text.includes(c));
+}
+function isChecked(text) {
+    return CHECKBOX_CHECKED.some(c => text.includes(c));
+}
+function isLabel(text) {
+    return text.startsWith('■') || text.startsWith('[') || text.startsWith('▪');
+}
+function isValue(text) {
+    if (!text)
+        return false;
+    if (isLabel(text))
+        return false;
+    if (text.length > 200)
+        return false;
+    return true;
+}
+function replaceCheckboxState(text, checked) {
+    let result = text;
+    if (checked) {
+        for (const c of CHECKBOX_UNCHECKED) {
+            result = result.split(c).join('☒');
+        }
+    }
+    else {
+        for (const c of CHECKBOX_CHECKED) {
+            result = result.split(c).join('☐');
+        }
+    }
+    return result;
+}
+function extractParagraphs(xml) {
+    const paragraphs = [];
+    // Regex pour extraire le contenu des paragraphes <w:p>...</w:p>
+    const pRegex = /<w:p[^>]*>([\s\S]*?)<\/w:p>/g;
+    let match;
+    while ((match = pRegex.exec(xml)) !== null) {
+        // Extraire tout le texte des <w:t> dans ce paragraphe
+        const pContent = match[1];
+        const textParts = [];
+        const tRegex = /<w:t[^>]*>([^<]*)<\/w:t>/g;
+        let tMatch;
+        while ((tMatch = tRegex.exec(pContent)) !== null) {
+            textParts.push(tMatch[1]);
+        }
+        paragraphs.push(textParts.join(''));
+    }
+    return paragraphs;
+}
+function extractAllFields(paragraphs) {
+    const extracted = new Map();
+    const usedIndices = new Set();
+    for (const [fieldName, patterns] of LABEL_PATTERNS) {
+        if (extracted.has(fieldName))
+            continue;
+        for (let i = 0; i < paragraphs.length; i++) {
+            if (usedIndices.has(i))
+                continue;
+            const textNorm = normalize(paragraphs[i]);
+            const matched = patterns.some(pattern => textNorm.includes(pattern.toLowerCase()));
+            if (matched) {
+                for (let j = i + 1; j < Math.min(i + 5, paragraphs.length); j++) {
+                    if (usedIndices.has(j))
+                        continue;
+                    const valueText = paragraphs[j].trim();
+                    if (isValue(valueText)) {
+                        extracted.set(fieldName, {
+                            value: valueText,
+                            labelIndex: i,
+                            valueIndex: j,
+                        });
+                        usedIndices.add(j);
+                        break;
+                    }
+                    else if (isLabel(valueText)) {
+                        break;
+                    }
+                }
+                usedIndices.add(i);
+                break;
+            }
+        }
+    }
+    return extracted;
+}
+function extractCheckboxes(paragraphs) {
+    const checkboxes = [];
+    for (let i = 0; i < paragraphs.length; i++) {
+        const text = paragraphs[i].trim();
+        if (hasCheckbox(text)) {
+            const signature = text.replace(/[☐☒☑□▢▣]/g, '').trim().toLowerCase().slice(0, 60);
+            checkboxes.push({
+                index: i,
+                text,
+                signature,
+                checked: isChecked(text),
+            });
+        }
+    }
+    return checkboxes;
+}
+function findFillablePositions(paragraphs) {
+    const positions = new Map();
+    const usedIndices = new Set();
+    for (const [fieldName, patterns] of LABEL_PATTERNS) {
+        if (positions.has(fieldName))
+            continue;
+        for (let i = 0; i < paragraphs.length; i++) {
+            if (usedIndices.has(i))
+                continue;
+            const textNorm = normalize(paragraphs[i]);
+            const matched = patterns.some(pattern => textNorm.includes(pattern.toLowerCase()));
+            if (matched) {
+                for (let j = i + 1; j < Math.min(i + 5, paragraphs.length); j++) {
+                    if (usedIndices.has(j))
+                        continue;
+                    const valueText = paragraphs[j].trim();
+                    if (!valueText) {
+                        positions.set(fieldName, {
+                            labelIndex: i,
+                            fillIndex: j,
+                            labelText: paragraphs[i].slice(0, 50),
+                        });
+                        usedIndices.add(j);
+                        break;
+                    }
+                    else if (isLabel(valueText)) {
+                        break;
+                    }
+                }
+                usedIndices.add(i);
+                break;
+            }
+        }
+    }
+    return positions;
+}
+function fillDocumentXml(templateXml, sourceData, templatePositions, sourceCheckboxes, templateCheckboxes) {
+    let xml = templateXml;
+    const filledFields = [];
+    let modifiedCheckboxes = 0;
+    // Remplir les champs texte
+    // On doit remplacer les paragraphes vides par les valeurs
+    const pRegex = /<w:p[^>]*>([\s\S]*?)<\/w:p>/g;
+    const paragraphs = [];
+    let match;
+    while ((match = pRegex.exec(templateXml)) !== null) {
+        paragraphs.push({
+            match: match[0],
+            start: match.index,
+            end: match.index + match[0].length,
+        });
+    }
+    // Pour chaque position à remplir
+    for (const [fieldName, position] of templatePositions) {
+        if (sourceData.has(fieldName)) {
+            const value = sourceData.get(fieldName).value;
+            const pIndex = position.fillIndex;
+            if (pIndex < paragraphs.length) {
+                const p = paragraphs[pIndex];
+                // Créer un nouveau paragraphe avec la valeur
+                // On conserve le style du paragraphe original mais on remplace le contenu
+                const newP = p.match.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(value)}</w:t></w:r>$3`);
+                xml = xml.slice(0, p.start) + newP + xml.slice(p.end);
+                // Ajuster les indices pour les remplacements suivants
+                const diff = newP.length - p.match.length;
+                for (let i = pIndex + 1; i < paragraphs.length; i++) {
+                    paragraphs[i].start += diff;
+                    paragraphs[i].end += diff;
+                }
+                paragraphs[pIndex].match = newP;
+                paragraphs[pIndex].end = paragraphs[pIndex].start + newP.length;
+                filledFields.push(`${fieldName}: ${value}`);
+            }
+        }
+    }
+    // Copier l'état des checkboxes
+    for (const templateCb of templateCheckboxes) {
+        for (const sourceCb of sourceCheckboxes) {
+            if (templateCb.signature === sourceCb.signature) {
+                if (sourceCb.checked !== templateCb.checked) {
+                    const newText = replaceCheckboxState(templateCb.text, sourceCb.checked);
+                    // Remplacer dans le XML
+                    xml = xml.split(escapeXml(templateCb.text)).join(escapeXml(newText));
+                    modifiedCheckboxes++;
+                }
+                break;
+            }
+        }
+    }
+    return { xml, filledFields, modifiedCheckboxes };
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+class DocxFiller {
+    constructor() {
+        this.description = {
+            displayName: 'DOCX Filler',
+            name: 'docxFiller',
+            icon: 'file:docx.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Remplit automatiquement des documents DOCX (DC1, DC2, AE) avec les données entreprise',
+            defaults: {
+                name: 'DOCX Filler',
+            },
+            // @ts-ignore - Required for AI agent tool usage
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Fill Document',
+                            value: 'fill',
+                            description: 'Remplit un template avec les données d\'un document source',
+                            action: 'Fill document',
+                        },
+                        {
+                            name: 'Extract Data',
+                            value: 'extract',
+                            description: 'Extrait les données entreprise d\'un document rempli',
+                            action: 'Extract data',
+                        },
+                        {
+                            name: 'Analyze',
+                            value: 'analyze',
+                            description: 'Analyse la structure d\'un document',
+                            action: 'Analyze document',
+                        },
+                    ],
+                    default: 'fill',
+                },
+                // Fill operation
+                {
+                    displayName: 'Source Document',
+                    name: 'sourceDocument',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['fill'],
+                        },
+                    },
+                    description: 'Document source contenant les données entreprise (binary property name ou base64)',
+                },
+                {
+                    displayName: 'Template Document',
+                    name: 'templateDocument',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['fill'],
+                        },
+                    },
+                    description: 'Document template vide à remplir (binary property name ou base64)',
+                },
+                {
+                    displayName: 'Output Property',
+                    name: 'outputProperty',
+                    type: 'string',
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            operation: ['fill'],
+                        },
+                    },
+                    description: 'Nom de la propriété binary pour le document de sortie',
+                },
+                // Extract operation
+                {
+                    displayName: 'Document',
+                    name: 'document',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['extract', 'analyze'],
+                        },
+                    },
+                    description: 'Document à analyser (binary property name ou base64)',
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'fill') {
+                    const sourceDocParam = this.getNodeParameter('sourceDocument', i);
+                    const templateDocParam = this.getNodeParameter('templateDocument', i);
+                    const outputProperty = this.getNodeParameter('outputProperty', i);
+                    // Charger les documents (depuis binary ou base64)
+                    let sourceBuffer;
+                    let templateBuffer;
+                    // Source document
+                    if (items[i].binary && items[i].binary[sourceDocParam]) {
+                        sourceBuffer = await this.helpers.getBinaryDataBuffer(i, sourceDocParam);
+                    }
+                    else {
+                        // Assume base64
+                        sourceBuffer = Buffer.from(sourceDocParam, 'base64');
+                    }
+                    // Template document
+                    if (items[i].binary && items[i].binary[templateDocParam]) {
+                        templateBuffer = await this.helpers.getBinaryDataBuffer(i, templateDocParam);
+                    }
+                    else {
+                        // Assume base64
+                        templateBuffer = Buffer.from(templateDocParam, 'base64');
+                    }
+                    // Charger les DOCX avec PizZip
+                    const sourceZip = new pizzip_1.default(sourceBuffer);
+                    const templateZip = new pizzip_1.default(templateBuffer);
+                    const sourceXml = ((_a = sourceZip.file('word/document.xml')) === null || _a === void 0 ? void 0 : _a.asText()) || '';
+                    const templateXml = ((_b = templateZip.file('word/document.xml')) === null || _b === void 0 ? void 0 : _b.asText()) || '';
+                    // Extraire les paragraphes
+                    const sourceParagraphs = extractParagraphs(sourceXml);
+                    const templateParagraphs = extractParagraphs(templateXml);
+                    // Extraire les données
+                    const sourceData = extractAllFields(sourceParagraphs);
+                    const sourceCheckboxes = extractCheckboxes(sourceParagraphs);
+                    const templatePositions = findFillablePositions(templateParagraphs);
+                    const templateCheckboxes = extractCheckboxes(templateParagraphs);
+                    // Remplir le document
+                    const { xml: filledXml, filledFields, modifiedCheckboxes } = fillDocumentXml(templateXml, sourceData, templatePositions, sourceCheckboxes, templateCheckboxes);
+                    // Mettre à jour le ZIP
+                    templateZip.file('word/document.xml', filledXml);
+                    const outputBuffer = templateZip.generate({
+                        type: 'nodebuffer',
+                        compression: 'DEFLATE',
+                    });
+                    // Créer le résultat
+                    const binaryData = await this.helpers.prepareBinaryData(outputBuffer, 'document_rempli.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+                    returnData.push({
+                        json: {
+                            success: true,
+                            filledFields,
+                            modifiedCheckboxes,
+                            message: `Document rempli avec ${filledFields.length} champs et ${modifiedCheckboxes} checkboxes`,
+                        },
+                        binary: {
+                            [outputProperty]: binaryData,
+                        },
+                    });
+                }
+                else if (operation === 'extract') {
+                    const documentParam = this.getNodeParameter('document', i);
+                    let docBuffer;
+                    if (items[i].binary && items[i].binary[documentParam]) {
+                        docBuffer = await this.helpers.getBinaryDataBuffer(i, documentParam);
+                    }
+                    else {
+                        docBuffer = Buffer.from(documentParam, 'base64');
+                    }
+                    const zip = new pizzip_1.default(docBuffer);
+                    const xml = ((_c = zip.file('word/document.xml')) === null || _c === void 0 ? void 0 : _c.asText()) || '';
+                    const paragraphs = extractParagraphs(xml);
+                    const data = extractAllFields(paragraphs);
+                    const checkboxes = extractCheckboxes(paragraphs);
+                    const extractedData = {};
+                    for (const [key, value] of data) {
+                        extractedData[key] = value.value;
+                    }
+                    const checkedBoxes = checkboxes.filter(cb => cb.checked);
+                    returnData.push({
+                        json: {
+                            success: true,
+                            data: extractedData,
+                            checkboxes: {
+                                total: checkboxes.length,
+                                checked: checkedBoxes.length,
+                                items: checkedBoxes.map(cb => cb.signature),
+                            },
+                        },
+                    });
+                }
+                else if (operation === 'analyze') {
+                    const documentParam = this.getNodeParameter('document', i);
+                    let docBuffer;
+                    if (items[i].binary && items[i].binary[documentParam]) {
+                        docBuffer = await this.helpers.getBinaryDataBuffer(i, documentParam);
+                    }
+                    else {
+                        docBuffer = Buffer.from(documentParam, 'base64');
+                    }
+                    const zip = new pizzip_1.default(docBuffer);
+                    const xml = ((_d = zip.file('word/document.xml')) === null || _d === void 0 ? void 0 : _d.asText()) || '';
+                    const paragraphs = extractParagraphs(xml);
+                    const positions = findFillablePositions(paragraphs);
+                    returnData.push({
+                        json: {
+                            success: true,
+                            totalParagraphs: paragraphs.length,
+                            fillableFields: Array.from(positions.keys()),
+                            structure: paragraphs.slice(0, 50).map((p, idx) => ({
+                                index: idx,
+                                text: p.slice(0, 100),
+                                hasCheckbox: hasCheckbox(p),
+                            })),
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error.message,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DocxFiller = DocxFiller;

package/dist/DocxFiller/docx.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" width="48" height="48">
+  <path fill="#2196F3" d="M6 6h28l8 8v28c0 1.1-.9 2-2 2H6c-1.1 0-2-.9-2-2V8c0-1.1.9-2 2-2z"/>
+  <path fill="#1565C0" d="M34 6l8 8h-6c-1.1 0-2-.9-2-2V6z"/>
+  <text x="24" y="32" text-anchor="middle" fill="white" font-family="Arial" font-size="10" font-weight="bold">DOCX</text>
+</svg>

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "n8n-nodes-docx-filler",
+  "version": "1.0.0",
+  "description": "n8n node to automatically fill DOCX documents (French DC1, DC2, AE forms) with company data. Works as AI Agent tool.",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "n8n-node",
+    "docx",
+    "document",
+    "fill",
+    "form",
+    "DC1",
+    "DC2",
+    "AE",
+    "french",
+    "company",
+    "ai-tool"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/rokodo-io/n8n-nodes-docx-filler",
+  "author": {
+    "name": "Rokodo",
+    "email": "contact@rokodo.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rokodo-io/n8n-nodes-docx-filler.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rokodo-io/n8n-nodes-docx-filler/issues"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes --write",
+    "lint": "eslint nodes --ext .ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/DocxFiller/DocxFiller.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "pizzip": "^3.1.7",
+    "docxtemplater": "^3.49.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}