n8n-nodes-fasttext-language-detector 0.1.0

package/dist/credentials/FastTextModel.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class FastTextModel implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/FastTextModel.credentials.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastTextModel = void 0;
+class FastTextModel {
+    constructor() {
+        this.name = 'fastTextModelApi';
+        this.displayName = 'FastText Model API';
+        this.documentationUrl = 'https://fasttext.cc/docs/en/language-identification.html';
+        this.properties = [
+            {
+                displayName: 'Model Path',
+                name: 'modelPath',
+                type: 'string',
+                default: '',
+                description: 'Absolute path to fastText language identification model (.bin file). Download from https://fasttext.cc/docs/en/language-identification.html.',
+                placeholder: '/path/to/lid.176.bin',
+            },
+        ];
+    }
+}
+exports.FastTextModel = FastTextModel;

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

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

package/dist/nodes/FastTextLanguageDetector/FastTextLanguageDetector.node.js

@@ -0,0 +1,299 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastTextLanguageDetector = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const fastText = __importStar(require("fasttext.js"));
+const fs = __importStar(require("fs"));
+class FastTextLanguageDetector {
+    constructor() {
+        this.description = {
+            displayName: 'FastText Language Detector',
+            name: 'fastTextLanguageDetector',
+            icon: 'file:fasttext.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Detect language of text using fastText',
+            defaults: {
+                name: 'FastText Language Detector',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'fastTextModelApi',
+                    required: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Text Source',
+                    name: 'textSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'From Input Field',
+                            value: 'field',
+                        },
+                        {
+                            name: 'From Expression',
+                            value: 'expression',
+                        },
+                    ],
+                    default: 'field',
+                    description: 'Where to get the text from',
+                },
+                {
+                    displayName: 'Input Field Name',
+                    name: 'inputField',
+                    type: 'string',
+                    default: 'text',
+                    displayOptions: {
+                        show: {
+                            textSource: ['field'],
+                        },
+                    },
+                    description: 'Name of the input field containing text to analyze',
+                },
+                {
+                    displayName: 'Text Expression',
+                    name: 'textExpression',
+                    type: 'string',
+                    default: '={{$json.text}}',
+                    displayOptions: {
+                        show: {
+                            textSource: ['expression'],
+                        },
+                    },
+                    description: 'Expression to get the text (e.g., {{$JSON.text}})',
+                },
+                {
+                    displayName: 'Model Path',
+                    name: 'modelPath',
+                    type: 'string',
+                    default: '',
+                    description: 'Path to fastText language identification model (.bin file). Leave empty to use default or credentials.',
+                    placeholder: '/path/to/lid.176.bin',
+                },
+                {
+                    displayName: 'Confidence Threshold',
+                    name: 'confidenceThreshold',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                    },
+                    default: 0.5,
+                    description: 'Minimum confidence threshold (0-1) for language detection',
+                },
+                {
+                    displayName: 'Return Top K',
+                    name: 'topK',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                        maxValue: 10,
+                    },
+                    default: 1,
+                    description: 'Number of top language predictions to return',
+                },
+                {
+                    displayName: 'Output Field Name',
+                    name: 'outputField',
+                    type: 'string',
+                    default: 'language',
+                    description: 'Name of the output field for detected language',
+                },
+                {
+                    displayName: 'Include Confidence',
+                    name: 'includeConfidence',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to include confidence scores in the output',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const textSource = this.getNodeParameter('textSource', 0);
+        const confidenceThreshold = this.getNodeParameter('confidenceThreshold', 0);
+        const topK = this.getNodeParameter('topK', 0);
+        const outputField = this.getNodeParameter('outputField', 0);
+        const includeConfidence = this.getNodeParameter('includeConfidence', 0);
+        // Загружаем модель один раз для всех элементов
+        let model = null;
+        let modelPath = '';
+        try {
+            // Получаем путь к модели
+            const modelPathParam = this.getNodeParameter('modelPath', 0);
+            if (modelPathParam && modelPathParam.trim() !== '') {
+                modelPath = modelPathParam.trim();
+            }
+            else {
+                try {
+                    const credentials = await this.getCredentials('fastTextModelApi');
+                    if (credentials && credentials.modelPath) {
+                        modelPath = credentials.modelPath;
+                    }
+                }
+                catch (error) {
+                    // Credentials не обязательны
+                }
+                if (!modelPath) {
+                    const defaultModelPath = process.env.FASTTEXT_MODEL_PATH || '';
+                    if (defaultModelPath && fs.existsSync(defaultModelPath)) {
+                        modelPath = defaultModelPath;
+                    }
+                }
+            }
+            if (!modelPath) {
+                throw new n8n_workflow_1.ApplicationError('Model path not specified. Please provide model path in node settings or credentials.', { level: 'error' });
+            }
+            // Проверяем кэш
+            const cachedModel = FastTextLanguageDetector.modelCache.get(modelPath);
+            if (cachedModel) {
+                model = cachedModel;
+            }
+            else {
+                // Проверяем существование файла
+                if (!fs.existsSync(modelPath)) {
+                    throw new n8n_workflow_1.ApplicationError(`Model file not found: ${modelPath}`, { level: 'error' });
+                }
+                // Загружаем модель
+                model = new fastText.Classifier(modelPath);
+                FastTextLanguageDetector.modelCache.set(modelPath, model);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new n8n_workflow_1.ApplicationError(`Failed to initialize model: ${errorMessage}`, { level: 'error' });
+        }
+        // Обрабатываем каждый элемент
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            const item = items[itemIndex];
+            const json = item.json;
+            try {
+                // Получаем текст для анализа
+                let text = '';
+                if (textSource === 'field') {
+                    const inputField = this.getNodeParameter('inputField', itemIndex);
+                    const fieldValue = json[inputField];
+                    if (fieldValue === undefined || fieldValue === null) {
+                        throw new n8n_workflow_1.ApplicationError(`Field "${inputField}" not found in input data`, { level: 'warning' });
+                    }
+                    text = String(fieldValue);
+                }
+                else {
+                    // Для выражений getNodeParameter автоматически обрабатывает выражения типа {{$json.text}}
+                    const textExpressionValue = this.getNodeParameter('textExpression', itemIndex);
+                    // Преобразуем значение в строку
+                    if (textExpressionValue === null || textExpressionValue === undefined) {
+                        text = '';
+                    }
+                    else if (typeof textExpressionValue === 'object') {
+                        text = JSON.stringify(textExpressionValue);
+                    }
+                    else {
+                        text = String(textExpressionValue);
+                    }
+                }
+                if (!text || text.trim() === '') {
+                    throw new n8n_workflow_1.ApplicationError('Text is empty. Please provide text to analyze.', { level: 'warning' });
+                }
+                // Предобработка текста
+                const processedText = text.trim().substring(0, 1000); // Ограничиваем длину
+                // Проверяем, что модель загружена
+                if (!model) {
+                    throw new n8n_workflow_1.ApplicationError('Model not initialized', { level: 'error' });
+                }
+                // Определяем язык
+                const predictions = await model.predict(processedText, topK);
+                // Фильтруем по порогу уверенности
+                const filteredPredictions = predictions.filter((pred) => pred.probability >= confidenceThreshold);
+                if (filteredPredictions.length === 0) {
+                    // Если нет предсказаний выше порога, возвращаем лучшее
+                    const result = {
+                        ...json,
+                        [outputField]: predictions[0]?.label?.replace('__label__', '') || 'unknown',
+                    };
+                    if (includeConfidence) {
+                        result[`${outputField}Confidence`] = predictions[0]?.probability || 0;
+                        result[`${outputField}All`] = predictions.map((p) => ({
+                            language: p.label?.replace('__label__', '') || 'unknown',
+                            confidence: p.probability || 0,
+                        }));
+                    }
+                    returnData.push({ json: result });
+                    continue;
+                }
+                // Формируем результат
+                const topPrediction = filteredPredictions[0];
+                const result = {
+                    ...json,
+                    [outputField]: topPrediction.label?.replace('__label__', '') || 'unknown',
+                };
+                if (includeConfidence) {
+                    result[`${outputField}Confidence`] = topPrediction.probability || 0;
+                    if (topK > 1) {
+                        result[`${outputField}All`] = filteredPredictions.map((p) => ({
+                            language: p.label?.replace('__label__', '') || 'unknown',
+                            confidence: p.probability || 0,
+                        }));
+                    }
+                }
+                returnData.push({ json: result });
+            }
+            catch (error) {
+                if (error instanceof n8n_workflow_1.ApplicationError) {
+                    throw error;
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                returnData.push({
+                    json: {
+                        ...json,
+                        error: errorMessage,
+                        [outputField]: 'error',
+                    },
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.FastTextLanguageDetector = FastTextLanguageDetector;
+FastTextLanguageDetector.modelCache = new Map();

package/dist/nodes/FastTextLanguageDetector/fasttext.svg

@@ -0,0 +1,101 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="1280.000000pt" height="763.000000pt" viewBox="0 0 1280.000000 763.000000"
+ preserveAspectRatio="xMidYMid meet">
+<metadata>
+Created by potrace 1.15, written by Peter Selinger 2001-2017
+</metadata>
+<g transform="translate(0.000000,763.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M2755 6493 c-395 -51 -784 -240 -1160 -563 -128 -110 -368 -359 -384
+-398 -12 -29 -12 -35 2 -50 15 -15 19 -14 42 8 14 13 25 18 25 12 0 -6 -4 -14
+-10 -17 -15 -9 -12 -41 4 -54 28 -24 84 22 202 164 27 33 82 97 121 142 40 45
+73 85 73 88 0 23 -204 -130 -294 -220 l-69 -70 54 65 c77 94 280 294 379 373
+279 224 571 367 890 434 114 25 144 27 345 27 206 0 226 -2 319 -27 158 -42
+338 -142 411 -228 11 -12 -2 -5 -30 18 -90 73 -245 120 -489 148 -197 22 -386
+21 -520 -5 -110 -22 -291 -80 -310 -101 -8 -8 -6 -10 9 -6 199 55 438 89 635
+90 196 2 255 -10 405 -83 100 -49 247 -156 278 -204 l16 -25 -127 -42 c-545
+-180 -955 -439 -1378 -870 -286 -293 -460 -545 -570 -829 -74 -193 -112 -438
+-94 -602 5 -46 7 -91 4 -102 -3 -10 -2 -16 2 -13 5 3 9 -23 10 -56 3 -234 198
+-451 465 -518 120 -30 343 -37 469 -15 326 57 630 230 930 529 466 465 718
+968 760 1518 12 157 -3 394 -28 459 -3 8 -18 69 -33 134 -24 107 -26 122 -13
+142 27 41 64 48 217 41 242 -11 585 -62 947 -143 200 -45 689 -169 730 -186
+l31 -13 -111 -69 c-520 -323 -1035 -848 -1529 -1558 l-102 -148 -90 0 c-103 0
+-218 -21 -304 -56 -145 -59 -286 -170 -325 -256 -25 -54 -26 -113 -4 -122 9
+-4 14 -9 11 -13 -4 -3 -2 -14 4 -24 18 -34 49 -22 108 42 145 158 167 177 222
+193 29 9 76 16 105 16 45 0 56 -4 73 -26 11 -15 18 -31 14 -38 -68 -116 -300
+-450 -441 -636 -236 -310 -517 -616 -720 -784 -409 -336 -852 -499 -1362 -499
+-200 0 -317 16 -467 64 -222 71 -423 207 -522 352 -35 51 -66 118 -54 115 5
+-1 21 2 37 7 19 5 46 2 81 -9 146 -46 280 11 353 149 23 43 27 62 27 141 0 52
+-5 97 -11 105 -6 8 -14 36 -16 62 -14 128 -97 197 -238 197 -66 0 -86 -4 -138
+-31 -109 -54 -198 -179 -223 -314 -6 -33 -12 -127 -13 -210 -1 -140 1 -155 26
+-223 38 -105 83 -176 163 -257 196 -201 481 -307 948 -355 175 -18 509 -8 666
+20 406 72 799 237 1201 505 218 145 339 242 490 395 188 189 341 410 597 863
+132 233 164 276 225 308 71 37 163 17 192 -42 16 -32 15 -33 -20 -98 -107
+-195 -227 -331 -338 -381 -90 -41 -87 -70 6 -70 32 0 38 -3 30 -13 -72 -87 22
+-140 146 -82 163 76 303 227 415 451 81 161 123 193 296 224 292 53 448 176
+452 356 5 180 4 189 -19 226 -29 47 -58 65 -134 84 -77 20 -175 14 -269 -15
+-140 -44 -276 -174 -368 -350 l-43 -84 -65 6 c-111 11 -183 28 -183 44 0 9 41
+86 91 172 200 342 378 609 558 835 212 267 637 656 770 707 103 39 170 45 279
+26 761 -135 1156 -176 1562 -164 296 10 470 36 668 102 214 72 377 181 420
+282 23 54 29 212 11 270 -24 75 -153 158 -321 207 -169 49 -287 61 -598 61
+-296 0 -415 -10 -660 -56 -229 -44 -593 -146 -788 -223 l-64 -25 -211 50
+c-654 154 -1041 239 -1206 264 -358 54 -864 40 -1239 -34 l-143 -28 -34 47
+c-47 64 -167 176 -240 225 -118 77 -300 142 -468 164 -73 10 -365 13 -432 4z
+m5870 -477 c238 -41 416 -119 456 -200 8 -15 4 -13 -13 6 -48 56 -224 116
+-428 144 -58 9 -213 18 -345 21 -354 8 -576 -22 -1016 -137 -266 -70 -376 -93
+-397 -85 -22 9 21 28 190 85 284 95 621 160 958 184 124 9 507 -3 595 -18z
+m-29 -131 c220 -36 407 -117 429 -186 4 -11 11 -16 18 -12 7 3 3 -3 -7 -16
+-49 -55 -244 -121 -417 -142 -314 -36 -919 34 -1443 169 -63 16 -68 19 -53 34
+53 52 472 134 807 158 312 22 512 20 666 -5z m-5019 -21 c-3 -3 -12 -4 -19 -1
+-8 3 -5 6 6 6 11 1 17 -2 13 -5z m-77 -21 c-167 -60 -229 -88 -359 -156 -498
+-262 -952 -663 -1256 -1107 -32 -47 -64 -90 -70 -95 -15 -13 -85 -152 -110
+-218 -10 -26 -20 -45 -22 -43 -6 6 70 184 109 254 112 202 243 368 467 593
+366 366 707 591 1121 740 58 21 112 38 120 38 13 -1 13 -1 0 -6z m330 -112
+c50 -26 75 -69 101 -174 41 -165 25 -517 -31 -712 -84 -291 -261 -616 -501
+-915 -390 -487 -779 -739 -1186 -765 -185 -13 -317 35 -438 159 -120 122 -175
+262 -175 445 0 125 10 212 21 186 6 -13 7 -1 4 30 -3 37 -2 43 4 25 l9 -25 1
+24 c2 42 59 197 110 298 124 246 330 499 609 745 404 355 804 572 1237 671
+134 31 189 33 235 8z m5170 -186 c0 -6 -97 -55 -107 -55 -4 1 17 14 47 30 61
+32 60 32 60 25z m-7336 -1399 c-3 -15 -8 -25 -11 -23 -2 3 -1 17 3 31 3 15 8
+25 11 23 2 -3 1 -17 -3 -31z m-17 -58 c-3 -8 -6 -5 -6 6 -1 11 2 17 5 13 3 -3
+4 -12 1 -19z m-10 -40 c-3 -8 -6 -5 -6 6 -1 11 2 17 5 13 3 -3 4 -12 1 -19z
+m4109 -104 c39 -19 64 -59 64 -101 0 -17 -3 -23 -8 -16 -4 7 -28 15 -52 19
+l-45 7 26 -30 c14 -17 31 -44 38 -62 8 -17 18 -28 23 -25 5 4 3 -7 -6 -24 -39
+-75 -170 -143 -322 -168 -135 -22 -143 -19 -108 46 32 60 155 194 214 235 39
+27 41 30 23 43 -12 9 -40 12 -91 10 -72 -3 -72 -3 -50 15 13 10 46 29 73 43
+61 29 168 33 221 8z m-1521 -353 c-6 -6 -66 -26 -134 -45 -119 -34 -374 -142
+-415 -175 -37 -30 19 42 68 87 97 89 237 136 426 140 40 1 60 -2 55 -7z m1505
+-47 c-25 -25 -66 -57 -92 -70 -103 -52 -249 -71 -281 -36 -15 17 -12 18 74 30
+109 15 228 53 289 92 25 16 47 29 50 29 2 1 -16 -20 -40 -45z m-832 -49 c65
+-7 93 -24 45 -27 -54 -3 -83 2 -115 23 -19 12 -24 18 -13 15 11 -2 48 -8 83
+-11z m-3107 -292 c13 -16 12 -17 -3 -4 -17 13 -22 21 -14 21 2 0 10 -8 17 -17z
+m239 -99 c57 -12 114 -15 235 -12 l160 5 -85 -20 c-57 -14 -123 -21 -200 -21
+-113 -1 -116 0 -190 36 -41 20 -91 51 -110 67 l-35 31 75 -35 c42 -19 109 -42
+150 -51z m-1134 -1570 c103 -47 246 -90 381 -116 105 -20 150 -23 398 -23 247
+0 270 -1 200 -11 -44 -6 -120 -17 -170 -24 -130 -18 -407 -8 -505 19 -143 39
+-221 76 -377 179 -85 55 -117 84 -40 35 23 -14 74 -41 113 -59z"/>
+<path d="M11863 6295 c-404 -109 -1151 -890 -1694 -1770 l-86 -140 -64 -6
+c-35 -4 -126 -7 -201 -8 -125 -1 -138 -3 -148 -20 -5 -11 -10 -22 -10 -25 0
+-3 86 -6 190 -6 181 0 190 -1 179 -18 -6 -10 -42 -32 -79 -49 l-68 -32 24 -46
+23 -47 -26 -52 c-30 -60 -699 -1279 -875 -1595 -450 -807 -584 -1007 -859
+-1278 -349 -345 -685 -520 -1037 -540 -94 -5 -132 -2 -231 17 -66 12 -127 20
+-136 16 -29 -11 -15 -57 25 -81 32 -18 52 -20 220 -20 143 0 204 4 270 19 140
+30 290 84 442 157 79 37 135 63 124 56 -10 -6 -57 -40 -104 -75 -175 -129
+-286 -181 -432 -203 -101 -14 -280 -6 -364 16 -65 18 -108 13 -137 -16 -25
+-25 -9 -62 36 -84 65 -30 262 -13 445 39 170 48 387 116 450 142 325 132 688
+405 1061 801 459 487 798 1019 1444 2273 92 179 179 340 192 358 41 55 98 89
+187 112 109 29 115 33 92 59 -10 10 -16 30 -14 43 l3 23 186 3 c184 2 186 3
+197 26 l10 23 -96 6 c-54 4 -143 7 -200 7 l-102 0 30 34 c17 19 59 49 93 67
+357 189 842 612 1089 949 118 162 188 318 188 417 -1 47 -1 48 -16 23 -10 -17
+-13 -18 -8 -5 50 145 57 175 58 255 1 99 -17 141 -74 171 -42 23 -122 24 -197
+4z m185 -52 c66 -41 46 -179 -49 -345 -166 -285 -665 -812 -1096 -1155 -141
+-113 -167 -130 -156 -107 6 11 27 54 47 96 44 91 267 466 357 600 136 203 300
+408 493 617 89 97 116 135 102 148 -10 10 -112 -20 -146 -44 -59 -41 58 62
+126 112 128 94 250 123 322 78z m-998 -1487 c0 -2 -8 -10 -17 -17 -16 -13 -17
+-12 -4 4 13 16 21 21 21 13z m-106 -90 c-110 -101 -134 -119 -159 -122 -13 -1
+-30 -6 -37 -10 -32 -18 9 14 129 101 70 52 130 94 133 94 2 1 -27 -28 -66 -63z"/>
+</g>
+</svg>

package/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+    nodes: [
+      require('./dist/nodes/FastTextLanguageDetector/FastTextLanguageDetector.node.js'),
+    ],
+    credentials: [
+      require('./dist/credentials/FastTextModel.credentials.js'),
+    ],
+  };

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "n8n-nodes-fasttext-language-detector",
+    "version": "0.1.0",
+    "description": "n8n node for language detection using fastText",
+    "author": {
+        "name": "Your Name",
+        "email": "your.email@example.com"
+    },
+    "license": "MIT",
+    "keywords": [
+      "n8n-community-node-package",
+      "fasttext",
+      "language-detection",
+      "nlp"
+    ],
+    "main": "index.js",
+    "scripts": {
+      "build": "rm -rf dist && tsc && gulp build:icons",
+      "dev": "npm run build && npx n8n",
+      "dev:watch": "tsc --watch",
+      "format": "prettier nodes credentials --write",
+      "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\"",
+      "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\" --fix",
+      "prepublishOnly": "npm run build && npm run lint -s"
+    },
+    "files": [
+      "dist"
+    ],
+    "n8n": {
+      "n8nNodesApiVersion": 1,
+      "credentials": [
+        "dist/credentials/FastTextModel.credentials.js"
+      ],
+      "nodes": [
+        "dist/nodes/FastTextLanguageDetector/FastTextLanguageDetector.node.js"
+      ]
+    },
+    "devDependencies": {
+      "@types/node": "^20.10.0",
+      "@typescript-eslint/parser": "^6.13.0",
+      "@typescript-eslint/eslint-plugin": "^6.13.0",
+      "eslint": "^8.57.1",
+      "eslint-plugin-n8n-nodes-base": "^1.11.0",
+      "gulp": "^4.0.2",
+      "n8n": "*",
+      "n8n-workflow": "*",
+      "prettier": "^3.1.0",
+      "typescript": "^5.3.0"
+    },
+    "dependencies": {
+      "fasttext.js": "^1.1.4"
+    },
+    "peerDependencies": {
+      "n8n-workflow": "*"
+    }
+  }