@lee-jisoo/n8n-nodes-mediafx 1.6.0 → 1.6.2

package/dist/nodes/MediaFX/operations/addSubtitle.js

@@ -0,0 +1,202 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAddSubtitle = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+/**
+ * Escape special characters in file path for FFmpeg subtitles filter.
+ */
+function escapeSubtitlePath(filePath) {
+    return filePath
+        .replace(/\\/g, '\\\\\\\\')
+        .replace(/:/g, '\\:')
+        .replace(/\[/g, '\\[')
+        .replace(/\]/g, '\\]')
+        .replace(/'/g, "\\'");
+}
+/**
+ * Convert color to ASS format (&HAABBGGRR)
+ * @param color - CSS color (hex #RRGGBB or named color)
+ * @param opacity - Opacity 0-1 (0=transparent, 1=solid)
+ */
+function colorToASS(color, opacity = 1) {
+    let r = 'FF', g = 'FF', b = 'FF';
+    if (color && color.startsWith('#') && color.length === 7) {
+        r = color.substring(1, 3);
+        g = color.substring(3, 5);
+        b = color.substring(5, 7);
+    }
+    else {
+        const namedColors = {
+            white: 'FFFFFF',
+            black: '000000',
+            red: 'FF0000',
+            green: '00FF00',
+            blue: '0000FF',
+            yellow: 'FFFF00',
+            cyan: '00FFFF',
+            magenta: 'FF00FF',
+            orange: 'FFA500',
+        };
+        const hex = namedColors[color.toLowerCase()] || 'FFFFFF';
+        r = hex.substring(0, 2);
+        g = hex.substring(2, 4);
+        b = hex.substring(4, 6);
+    }
+    // ASS format: &HAABBGGRR (AA = alpha, 00=solid, FF=transparent)
+    const alpha = Math.round((1 - opacity) * 255).toString(16).padStart(2, '0').toUpperCase();
+    return `&H${alpha}${b}${g}${r}`.toUpperCase();
+}
+/**
+ * Get ASS alignment number (numpad style)
+ */
+function getASSAlignment(horizontalAlign, verticalAlign) {
+    var _a, _b;
+    const alignMap = {
+        top: { left: 7, center: 8, right: 9 },
+        middle: { left: 4, center: 5, right: 6 },
+        bottom: { left: 1, center: 2, right: 3 },
+    };
+    return (_b = (_a = alignMap[verticalAlign]) === null || _a === void 0 ? void 0 : _a[horizontalAlign]) !== null && _b !== void 0 ? _b : 2;
+}
+/**
+ * Parse SRT file and convert to ASS format
+ */
+function convertSRTtoASS(srtContent, fontName, fontSize, primaryColor, outlineColor, outlineWidth, backgroundColor, backgroundOpacity, enableBackground, alignment, marginV) {
+    // ASS Header
+    const borderStyle = enableBackground ? 4 : 1; // 4=box, 1=outline+shadow
+    const backColor = colorToASS(backgroundColor, backgroundOpacity);
+    const assHeader = `[Script Info]
+Title: Converted from SRT
+ScriptType: v4.00+
+PlayResX: 1920
+PlayResY: 1080
+WrapStyle: 0
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,${fontName},${fontSize},${primaryColor},${primaryColor},${outlineColor},${backColor},0,0,0,0,100,100,0,0,${borderStyle},${outlineWidth},0,${alignment},20,20,${marginV},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+    // Parse SRT content
+    const srtBlocks = srtContent.trim().split(/\n\s*\n/);
+    const dialogueLines = [];
+    for (const block of srtBlocks) {
+        const lines = block.trim().split('\n');
+        if (lines.length < 3)
+            continue;
+        // Parse timestamp line (format: 00:00:00,000 --> 00:00:00,000)
+        const timestampLine = lines[1];
+        const timestampMatch = timestampLine.match(/(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})/);
+        if (!timestampMatch)
+            continue;
+        const startTime = `${timestampMatch[1]}:${timestampMatch[2]}:${timestampMatch[3]}.${timestampMatch[4].substring(0, 2)}`;
+        const endTime = `${timestampMatch[5]}:${timestampMatch[6]}:${timestampMatch[7]}.${timestampMatch[8].substring(0, 2)}`;
+        // Get text (lines 3+)
+        const text = lines.slice(2).join('\\N').replace(/\r/g, '');
+        dialogueLines.push(`Dialogue: 0,${startTime},${endTime},Default,,0,0,0,,${text}`);
+    }
+    return assHeader + dialogueLines.join('\n');
+}
+/**
+ * Check if file is ASS/SSA format
+ */
+function isASSFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.ass' || ext === '.ssa';
+}
+async function executeAddSubtitle(video, subtitleFile, style, itemIndex) {
+    var _a, _b, _c, _d;
+    const outputPath = (0, utils_1.getTempFile)(path.extname(video));
+    // 1. Get Font
+    const allFonts = (0, utils_1.getAvailableFonts)();
+    const fontKey = style.fontKey || 'noto-sans-kr';
+    const font = allFonts[fontKey];
+    if (!font || !font.path) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    }
+    const fontName = font.name || 'Sans';
+    const fontSize = style.size || 48;
+    const fontColor = style.color || 'white';
+    const outlineWidth = (_a = style.outlineWidth) !== null && _a !== void 0 ? _a : 1;
+    const outlineColor = style.outlineColor || 'black';
+    const enableBackground = (_b = style.enableBackground) !== null && _b !== void 0 ? _b : false;
+    const backgroundColor = style.backgroundColor || 'black';
+    const backgroundOpacity = (_c = style.backgroundOpacity) !== null && _c !== void 0 ? _c : 0.5;
+    // 2. Get alignment
+    const positionType = style.positionType || 'alignment';
+    let horizontalAlign = 'center';
+    let verticalAlign = 'bottom';
+    let marginV = 20;
+    if (positionType === 'alignment') {
+        horizontalAlign = style.horizontalAlign || 'center';
+        verticalAlign = style.verticalAlign || 'bottom';
+        marginV = (_d = style.paddingY) !== null && _d !== void 0 ? _d : 20;
+    }
+    const alignment = getASSAlignment(horizontalAlign, verticalAlign);
+    // 3. Prepare subtitle file
+    let finalSubtitlePath = subtitleFile;
+    let tempAssFile = null;
+    if (isASSFile(subtitleFile)) {
+        // ASS file: use directly (ignore style options)
+        finalSubtitlePath = subtitleFile;
+    }
+    else {
+        // SRT file: convert to ASS with styles
+        const srtContent = await fs.readFile(subtitleFile, 'utf-8');
+        const assContent = convertSRTtoASS(srtContent, fontName, fontSize, colorToASS(fontColor, 1), colorToASS(outlineColor, 1), outlineWidth, backgroundColor, backgroundOpacity, enableBackground, alignment, marginV);
+        tempAssFile = (0, utils_1.getTempFile)('.ass');
+        await fs.writeFile(tempAssFile, assContent, 'utf-8');
+        finalSubtitlePath = tempAssFile;
+    }
+    // 4. Build FFmpeg command
+    const escapedPath = escapeSubtitlePath(finalSubtitlePath);
+    const subtitlesFilter = `subtitles='${escapedPath}'`;
+    const command = ffmpeg(video)
+        .videoFilters([subtitlesFilter])
+        .audioCodec('copy')
+        .save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adding subtitles to video. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+    finally {
+        // Clean up temp ASS file
+        if (tempAssFile) {
+            await fs.remove(tempAssFile).catch(() => { });
+        }
+    }
+}
+exports.executeAddSubtitle = executeAddSubtitle;

package/dist/nodes/MediaFX/operations/addText.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export declare function executeAddText(this: IExecuteFunctions, video: string, text: string, options: IDataObject, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/addText.js

@@ -0,0 +1,108 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAddText = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY) {
+    let x;
+    let y;
+    // Set X position based on horizontal alignment
+    switch (horizontalAlign) {
+        case 'left':
+            x = `${paddingX}`;
+            break;
+        case 'right':
+            x = `w-text_w-${paddingX}`;
+            break;
+        case 'center':
+        default:
+            x = '(w-text_w)/2';
+            break;
+    }
+    // Set Y position based on vertical alignment
+    switch (verticalAlign) {
+        case 'top':
+            y = `${paddingY}`;
+            break;
+        case 'bottom':
+            y = `h-th-${paddingY}`;
+            break;
+        case 'middle':
+        default:
+            y = '(h-text_h)/2';
+            break;
+    }
+    return { x, y };
+}
+async function executeAddText(video, text, options, itemIndex) {
+    var _a, _b, _c, _d;
+    const allFonts = (0, utils_1.getAvailableFonts)();
+    const fontKey = options.fontKey || 'noto-sans-kr';
+    const font = allFonts[fontKey];
+    if (!font || !font.path) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Selected font key '${fontKey}' is not valid or its file path is missing.`, { itemIndex });
+    }
+    const fontPath = font.path;
+    // Set default values for text options
+    const fontSize = options.size || 48;
+    const fontColor = options.color || 'white';
+    const startTime = options.startTime || 0;
+    const endTime = options.endTime || 5;
+    // Handle position based on position type
+    let positionX;
+    let positionY;
+    const positionType = options.positionType || 'alignment';
+    if (positionType === 'alignment') {
+        const horizontalAlign = options.horizontalAlign || 'center';
+        const verticalAlign = options.verticalAlign || 'bottom';
+        const paddingX = (_b = (_a = options.paddingX) !== null && _a !== void 0 ? _a : options.padding) !== null && _b !== void 0 ? _b : 20;
+        const paddingY = (_d = (_c = options.paddingY) !== null && _c !== void 0 ? _c : options.padding) !== null && _d !== void 0 ? _d : 20;
+        const position = getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY);
+        positionX = position.x;
+        positionY = position.y;
+    }
+    else {
+        // Custom position
+        positionX = options.x || '(w-text_w)/2';
+        positionY = options.y || 'h-th-10';
+    }
+    const outputPath = (0, utils_1.getTempFile)(path.extname(video));
+    const drawtext = `drawtext=fontfile=${fontPath}:text='${text.replace(/'/g, `''`)}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}:enable='between(t,${startTime},${endTime})'`;
+    const command = ffmpeg(video).videoFilters(drawtext).audioCodec('copy').save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adding text to video. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeAddText = executeAddText;

package/dist/nodes/MediaFX/operations/extractAudio.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeExtractAudio(this: IExecuteFunctions, input: string, format: string, codec: string, bitrate: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/extractAudio.js

@@ -0,0 +1,57 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeExtractAudio = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+async function executeExtractAudio(input, format, codec, bitrate, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${format}`);
+    let finalCodec = codec;
+    // If stream copy ('copy') is selected for a format that requires a specific
+    // codec (like mp3), we must override it to prevent an FFmpeg error.
+    if (finalCodec === 'copy' && format === 'mp3') {
+        // Cannot stream copy a non-mp3 stream (e.g., aac) into an mp3 container.
+        // Default to a high-quality mp3 encoder.
+        finalCodec = 'libmp3lame';
+    }
+    const command = ffmpeg(input)
+        .output(outputPath)
+        .noVideo()
+        .audioCodec(finalCodec)
+        .audioBitrate(bitrate)
+        .outputOptions('-map', '0:a:0'); // Select first audio stream
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error extracting audio. Please ensure the source video contains an audio track. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeExtractAudio = executeExtractAudio;

package/dist/nodes/MediaFX/operations/imageToVideo.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeImageToVideo(this: IExecuteFunctions, imagePath: string, duration: number, videoSize: {
+    width?: number;
+    height?: number;
+}, outputFormat: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/imageToVideo.js

@@ -0,0 +1,65 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeImageToVideo = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = __importStar(require("fs-extra"));
+async function executeImageToVideo(imagePath, duration, videoSize, outputFormat, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    const command = ffmpeg()
+        .input(imagePath)
+        .loop(duration)
+        // Add a silent audio track for compatibility
+        .input('anullsrc')
+        .inputFormat('lavfi')
+        // Use libx264 codec for broad compatibility
+        .videoCodec('libx264')
+        // Set pixel format
+        .outputOptions('-pix_fmt', 'yuv420p')
+        .audioCodec('aac')
+        .outputOptions('-shortest'); // End when the shortest input ends.
+    if (videoSize.width && videoSize.height) {
+        // Many codecs require even dimensions, but we'll let the user decide.
+        // For more robustness, we could add validation or rounding logic here.
+        command.videoFilters(`scale=${videoSize.width}:${videoSize.height}`);
+    }
+    else {
+        // Default behavior: ensure even dimensions for compatibility
+        command.videoFilters('scale=trunc(iw/2)*2:trunc(ih/2)*2');
+    }
+    command.save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error converting image to video. Please ensure the source image is valid. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeImageToVideo = executeImageToVideo;

package/dist/nodes/MediaFX/operations/index.d.ts

@@ -0,0 +1,13 @@
+export * from './merge';
+export * from './trim';
+export * from './speed';
+export * from './mixAudio';
+export * from './addSubtitle';
+export * from './addText';
+export * from './extractAudio';
+export * from './separateAudio';
+export * from './multiVideoTransition';
+export * from './singleVideoFade';
+export * from './imageToVideo';
+export * from './stampImage';
+export * from './overlayVideo';

package/dist/nodes/MediaFX/operations/index.js

@@ -0,0 +1,29 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./merge"), exports);
+__exportStar(require("./trim"), exports);
+__exportStar(require("./speed"), exports);
+__exportStar(require("./mixAudio"), exports);
+__exportStar(require("./addSubtitle"), exports);
+__exportStar(require("./addText"), exports);
+__exportStar(require("./extractAudio"), exports);
+__exportStar(require("./separateAudio"), exports);
+__exportStar(require("./multiVideoTransition"), exports);
+__exportStar(require("./singleVideoFade"), exports);
+__exportStar(require("./imageToVideo"), exports);
+__exportStar(require("./stampImage"), exports);
+__exportStar(require("./overlayVideo"), exports);

package/dist/nodes/MediaFX/operations/merge.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeMerge(this: IExecuteFunctions, inputs: string[], outputFormat: string, itemIndex: number): Promise<string>;

package/dist/nodes/MediaFX/operations/merge.js

@@ -0,0 +1,121 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMerge = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = __importStar(require("fs-extra"));
+const utils_1 = require("../utils");
+async function normalizeVideo(inputPath, refInfo) {
+    const normalizedPath = (0, utils_1.getTempFile)('.ts');
+    const mainCleanup = () => fs.remove(normalizedPath);
+    let silentAudioCleanup = null;
+    const hasAudio = await (0, utils_1.fileHasAudio)(inputPath);
+    const command = ffmpeg(inputPath);
+    if (!hasAudio) {
+        const duration = await (0, utils_1.getDuration)(inputPath);
+        const { filePath: silentAudioPath, cleanup } = await (0, utils_1.createSilentAudio)(duration);
+        command.addInput(silentAudioPath);
+        silentAudioCleanup = cleanup;
+    }
+    const targetWidth = refInfo.width;
+    const targetHeight = refInfo.height;
+    const targetSar = (refInfo.sample_aspect_ratio && refInfo.sample_aspect_ratio !== 'N/A') ? refInfo.sample_aspect_ratio : '1:1';
+    const targetFrameRate = refInfo.r_frame_rate || '30';
+    const targetPixFmt = 'yuv420p';
+    const videoFilter = `[0:v]scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:-1:-1:color=black,setsar=${targetSar},format=${targetPixFmt},fps=${targetFrameRate},setpts=PTS-STARTPTS[v_out]`;
+    const audioFilter = hasAudio
+        ? `[0:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,asetpts=PTS-STARTPTS[a_out]`
+        : `[1:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,asetpts=PTS-STARTPTS[a_out]`;
+    command
+        .complexFilter([videoFilter, audioFilter])
+        .outputOptions(['-map', '[v_out]', '-map', '[a_out]'])
+        .videoCodec('libx264')
+        .audioCodec('aac')
+        .save(normalizedPath);
+    await (0, utils_1.runFfmpeg)(command);
+    const combinedCleanup = async () => {
+        await mainCleanup();
+        if (silentAudioCleanup) {
+            await silentAudioCleanup();
+        }
+    };
+    return { normalizedPath, cleanup: combinedCleanup };
+}
+async function executeMerge(inputs, outputFormat, itemIndex) {
+    // Verify FFmpeg is available before proceeding
+    try {
+        (0, utils_1.verifyFfmpegAvailability)();
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `FFmpeg is not available: ${error.message}`, { itemIndex });
+    }
+    if (inputs.length < 1) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Merge operation requires at least one source.', {
+            itemIndex,
+        });
+    }
+    const intermediateFiles = [];
+    let outputPath = null;
+    const finalCleanup = async () => {
+        for (const file of intermediateFiles) {
+            await file.cleanup();
+        }
+    };
+    try {
+        const videoInfos = await Promise.all(inputs.map(utils_1.getVideoStreamInfo));
+        const refInfo = videoInfos.find((info) => info !== undefined);
+        if (!refInfo || !refInfo.width || !refInfo.height) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Could not determine reference video properties for merging. At least one input must be a valid video.', { itemIndex });
+        }
+        // 1. Normalization Stage
+        for (const inputPath of inputs) {
+            const { normalizedPath, cleanup } = await normalizeVideo.call(this, inputPath, refInfo);
+            intermediateFiles.push({ path: normalizedPath, cleanup });
+        }
+        // 2. Merging Stage - Using the concat protocol for stability
+        outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+        const normalizedPaths = intermediateFiles.map((f) => f.path);
+        const concatString = `concat:${normalizedPaths.join('|')}`;
+        const command = ffmpeg()
+            .input(concatString)
+            .outputOptions('-c', 'copy')
+            .save(outputPath);
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        if (outputPath) {
+            await fs.remove(outputPath).catch(() => { });
+        }
+        await finalCleanup();
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error merging videos. Please ensure all source videos are valid. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+    finally {
+        await finalCleanup();
+    }
+}
+exports.executeMerge = executeMerge;

package/dist/nodes/MediaFX/operations/mixAudio.d.ts

@@ -0,0 +1,2 @@
+import { IDataObject, IExecuteFunctions } from 'n8n-workflow';
+export declare function executeMixAudio(this: IExecuteFunctions, videoPath: string, audioPath: string, videoVolume: number, audioVolume: number, matchLength: 'shortest' | 'longest' | 'first', advancedMixing: IDataObject, itemIndex: number): Promise<string>;