email-origin-chain 1.0.0

package/dist/detectors/outlook-empty-header-detector.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutlookEmptyHeaderDetector = void 0;
+const cleaner_1 = require("../utils/cleaner");
+/**
+ * Detector for Outlook forwards where the "Envoyé:" (Sent) header is present but empty.
+ * Example of failing block:
+ * ________________________________
+ * De: Florian M.
+ * Envoyé:
+ * À: Flo M.
+ * Objet: RE: ...
+ */
+class OutlookEmptyHeaderDetector {
+    constructor() {
+        this.name = 'outlook_empty_header';
+        this.priority = 50; // Fallback for corrupted headers (after specifics, before generic Crisp)
+        // Regex to capture the header block:
+        // 1. Optional Separator (mostly underscores)
+        // 2. De: ... (From)
+        // 3. Envoyé: ... (Date) - Allow to be empty
+        // 4. À: ... (To)
+        // 5. Objet: ... (Subject)
+        this.HEADER_PATTERN = /^(?:_{30,}[ \t]*)?[\r\n]*De\s*:[ \t]*([^\r\n]+)\r?\nEnvoy(?:[é|e]|=[E|e]9)(?:[ \t]*:[ \t]*|\s*=\s*E9\s*:[ \t]*)(.*)\r?\n(?:[ÀA]|\=[C|c]0)\s*:[ \t]*([^\r\n]+)\r?\nObjet\s*:[ \t]*([^\r\n]+)/im;
+    }
+    detect(text) {
+        // 1. Expert Normalization
+        const normalized = cleaner_1.Cleaner.normalize(text);
+        const match = this.HEADER_PATTERN.exec(normalized);
+        if (match) {
+            const fullMatch = match[0];
+            const fromLine = match[1].trim();
+            const dateLine = match[2].trim();
+            const toLine = match[3].trim();
+            const subjectLine = match[4].trim();
+            const matchIndex = normalized.indexOf(fullMatch);
+            const message = normalized.substring(0, matchIndex).trim();
+            // 2. Expert Body Extraction
+            const lines = normalized.split('\n');
+            // Find line index of the end of the header match
+            const textUntilEnd = normalized.substring(0, matchIndex + fullMatch.length);
+            const lastHeaderLineIndex = textUntilEnd.split('\n').length - 1;
+            const bodyContent = cleaner_1.Cleaner.extractBody(lines, lastHeaderLineIndex);
+            // If the block started with a quote, we must strip quotes
+            const finalBody = fullMatch.trim().startsWith('>') ? cleaner_1.Cleaner.stripQuotes(bodyContent) : bodyContent;
+            if (fromLine.length > 0) {
+                return {
+                    found: true,
+                    detector: this.name,
+                    confidence: 'high',
+                    message: message || undefined,
+                    email: {
+                        from: fromLine,
+                        subject: subjectLine,
+                        date: dateLine || undefined,
+                        body: finalBody
+                    }
+                };
+            }
+        }
+        return { found: false, confidence: 'low' };
+    }
+}
+exports.OutlookEmptyHeaderDetector = OutlookEmptyHeaderDetector;

package/dist/detectors/outlook-fr-detector.d.ts

@@ -0,0 +1,10 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Detector for French Outlook format (and variations)
+ * Handles "De: / Envoyé: / À: / Objet:" in any order
+ */
+export declare class OutlookFRDetector implements ForwardDetector {
+    readonly name = "outlook_fr";
+    readonly priority = -30;
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/outlook-fr-detector.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutlookFRDetector = void 0;
+const cleaner_1 = require("../utils/cleaner");
+/**
+ * Detector for French Outlook format (and variations)
+ * Handles "De: / Envoyé: / À: / Objet:" in any order
+ */
+class OutlookFRDetector {
+    constructor() {
+        this.name = 'outlook_fr';
+        this.priority = -30; // Specific detector - High Priority (Override)
+    }
+    detect(text) {
+        // 1. Expert Normalization
+        const normalized = cleaner_1.Cleaner.normalize(text);
+        const lines = normalized.split('\n');
+        // Safe patterns: must be start of line
+        const dePattern = /^[ \t]*De\s*:/i;
+        const objetPattern = /^[ \t]*Objet\s*:/i;
+        const envoyePattern = /^[ \t]*Envoy(?:é|=E9|e)?\s*:/i;
+        const aPattern = /^[ \t]*(?:À|A|=C0)\s*:/i;
+        const datePattern = /^[ \t]*Date\s*:/i;
+        // Find the FIRST potential header as an anchor
+        let anchorIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (dePattern.test(line) || objetPattern.test(line)) {
+                anchorIndex = i;
+                break;
+            }
+        }
+        if (anchorIndex === -1)
+            return { found: false, confidence: 'low' };
+        // Look in a window around the anchor (usually headers are clustered within 10 lines)
+        // CRITICAL: The window must stop if we hit an empty line (end of headers)
+        let searchWindow = [];
+        const windowLimit = 15;
+        const searchStart = Math.max(0, anchorIndex - 2);
+        for (let i = searchStart; i < Math.min(lines.length, anchorIndex + windowLimit); i++) {
+            if (i > anchorIndex && lines[i].trim() === '')
+                break;
+            searchWindow.push(lines[i]);
+        }
+        const findInWindow = (pattern) => {
+            for (let i = 0; i < searchWindow.length; i++) {
+                if (pattern.test(searchWindow[i])) {
+                    return { index: searchStart + i, line: searchWindow[i] };
+                }
+            }
+            return null;
+        };
+        const de = findInWindow(dePattern);
+        const objet = findInWindow(objetPattern);
+        // Required headers for confidence
+        if (!de || !objet) {
+            // console.log('OutlookFRDetector: Required headers missing in window');
+            return { found: false, confidence: 'low' };
+        }
+        const envoye = findInWindow(envoyePattern);
+        const date = findInWindow(datePattern);
+        const a = findInWindow(aPattern);
+        const foundHeaders = [de, objet];
+        if (envoye)
+            foundHeaders.push(envoye);
+        if (date)
+            foundHeaders.push(date);
+        if (a)
+            foundHeaders.push(a);
+        const firstHeaderIndex = Math.min(...foundHeaders.map(h => h.index));
+        const lastHeaderIndex = Math.max(...foundHeaders.map(h => h.index));
+        // 2. Expert Body Extraction
+        const bodyContent = cleaner_1.Cleaner.extractBody(lines, lastHeaderIndex);
+        const finalBody = lines[firstHeaderIndex].startsWith('>') ? cleaner_1.Cleaner.stripQuotes(bodyContent) : bodyContent;
+        // 3. Extract metadata
+        const extractValue = (line) => {
+            const colonIdx = line.indexOf(':');
+            return colonIdx !== -1 ? line.substring(colonIdx + 1).trim() : '';
+        };
+        const subject = extractValue(objet.line);
+        const dateRaw = envoye ? extractValue(envoye.line) : (date ? extractValue(date.line) : undefined);
+        const deValue = extractValue(de.line);
+        // Simple name/email split for 'De:'
+        const deMatch = deValue.match(/(.+?)(?:\s*[<\[](.+?)[>\]])?\s*$/);
+        const fromName = deMatch ? deMatch[1].trim().replace(/["']/g, '') : deValue;
+        const fromEmail = deMatch && deMatch[2] ? deMatch[2].trim() : (fromName.includes('@') ? fromName : '');
+        // 4. Message (preceding text)
+        let messageEnd = firstHeaderIndex;
+        if (messageEnd > 0) {
+            for (let i = 1; i <= 5; i++) {
+                const prevLineIdx = firstHeaderIndex - i;
+                if (prevLineIdx < 0)
+                    break;
+                const prevLine = lines[prevLineIdx].trim();
+                if (prevLine.match(/^-{2,}.*-{2,}$/) || prevLine.match(/^_{3,}$/)) {
+                    messageEnd = prevLineIdx;
+                    break;
+                }
+                if (prevLine === '')
+                    continue;
+                break;
+            }
+        }
+        return {
+            found: true,
+            email: {
+                from: fromEmail.includes('@')
+                    ? { name: fromName !== fromEmail ? fromName : '', address: fromEmail }
+                    : { name: fromName, address: fromName },
+                subject,
+                date: dateRaw,
+                body: finalBody
+            },
+            message: messageEnd > 0 ? lines.slice(0, messageEnd).join('\n').trim() : undefined,
+            confidence: 'high'
+        };
+    }
+}
+exports.OutlookFRDetector = OutlookFRDetector;

package/dist/detectors/outlook-reverse-fr-detector.d.ts

@@ -0,0 +1,13 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Detector for Outlook forwards (French) where "Envoyé:" comes BEFORE "De:".
+ */
+export declare class OutlookReverseFrDetector implements ForwardDetector {
+    readonly name = "outlook_reverse_fr";
+    readonly priority = -20;
+    private readonly ENVOYE_PATTERN;
+    private readonly DE_PATTERN;
+    private readonly A_PATTERN;
+    private readonly OBJET_PATTERN;
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/outlook-reverse-fr-detector.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutlookReverseFrDetector = void 0;
+const cleaner_1 = require("../utils/cleaner");
+/**
+ * Detector for Outlook forwards (French) where "Envoyé:" comes BEFORE "De:".
+ */
+class OutlookReverseFrDetector {
+    constructor() {
+        this.name = 'outlook_reverse_fr';
+        this.priority = -20; // Specific detector - High Priority (Override)
+        // Regex patterns for field detection
+        this.ENVOYE_PATTERN = /^[ \t]*Envoy(?:é|=E9|e)?\s*:\s*(.*?)\s*$/m;
+        this.DE_PATTERN = /^[ \t]*De\s*:/i;
+        this.A_PATTERN = /^[ \t]*(?:À|A|=C0)\s*:/i;
+        this.OBJET_PATTERN = /^[ \t]*Objet\s*:/i;
+    }
+    detect(text) {
+        // 1. Expert Normalization
+        const normalized = cleaner_1.Cleaner.normalize(text);
+        const lines = normalized.split('\n');
+        // Find "Envoyé:" as an anchor
+        const envoyeMatch = this.ENVOYE_PATTERN.exec(normalized);
+        if (!envoyeMatch)
+            return { found: false, confidence: 'low' };
+        const envoyeIdx = envoyeMatch.index;
+        // Search in a window after "Envoyé:" for "De:"
+        // Combined with a window-stop at empty line
+        const windowLimit = 15;
+        const textUntilEnvoye = normalized.substring(0, envoyeIdx);
+        const envoyeLineIndex = textUntilEnvoye.split('\n').length - 1;
+        let searchWindow = [];
+        for (let i = envoyeLineIndex; i < Math.min(lines.length, envoyeLineIndex + windowLimit); i++) {
+            if (i > envoyeLineIndex && lines[i].trim() === '')
+                break;
+            searchWindow.push(lines[i]);
+        }
+        const findInWindow = (pattern) => {
+            for (let i = 0; i < searchWindow.length; i++) {
+                if (pattern.test(searchWindow[i])) {
+                    return { index: envoyeLineIndex + i, line: searchWindow[i] };
+                }
+            }
+            return null;
+        };
+        const de = findInWindow(this.DE_PATTERN);
+        if (!de)
+            return { found: false, confidence: 'low' };
+        const a = findInWindow(this.A_PATTERN);
+        const objet = findInWindow(this.OBJET_PATTERN);
+        const foundHeaders = [{ index: envoyeLineIndex, line: envoyeMatch[0] }, de];
+        if (a)
+            foundHeaders.push(a);
+        if (objet)
+            foundHeaders.push(objet);
+        const firstHeaderIndex = Math.min(...foundHeaders.map(h => h.index));
+        const lastHeaderIndex = Math.max(...foundHeaders.map(h => h.index));
+        // 2. Expert Body Extraction
+        const bodyContent = cleaner_1.Cleaner.extractBody(lines, lastHeaderIndex);
+        const finalBody = lines[firstHeaderIndex].startsWith('>') ? cleaner_1.Cleaner.stripQuotes(bodyContent) : bodyContent;
+        // 3. Metadata
+        const extractValue = (line) => {
+            const colonIdx = line.indexOf(':');
+            return colonIdx !== -1 ? line.substring(colonIdx + 1).trim() : '';
+        };
+        const deValue = extractValue(de.line);
+        const deMatch = deValue.match(/(.+?)(?:\s*[<\[](.+?)[>\]])?\s*$/);
+        const fromName = deMatch ? deMatch[1].trim().replace(/["']/g, '') : deValue;
+        const fromEmail = deMatch && deMatch[2] ? deMatch[2].trim() : (fromName.includes('@') ? fromName : '');
+        return {
+            found: true,
+            detector: this.name,
+            confidence: 'high',
+            message: firstHeaderIndex > 0 ? lines.slice(0, firstHeaderIndex).join('\n').trim() : undefined,
+            email: {
+                from: fromEmail.includes('@')
+                    ? { name: fromName !== fromEmail ? fromName : '', address: fromEmail }
+                    : { name: fromName, address: fromName },
+                subject: objet ? extractValue(objet.line) : '',
+                date: extractValue(envoyeMatch[0]),
+                body: finalBody
+            }
+        };
+    }
+}
+exports.OutlookReverseFrDetector = OutlookReverseFrDetector;

package/dist/detectors/registry.d.ts

@@ -0,0 +1,25 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Registry for managing forward detection plugins
+ * Detectors are tried in priority order (lower number = higher priority)
+ */
+export declare class DetectorRegistry {
+    private detectors;
+    constructor(customDetectors?: ForwardDetector[]);
+    /**
+     * Register a new detector
+     * @param detector The detector to register
+     */
+    register(detector: ForwardDetector): void;
+    /**
+     * Attempt to detect a forward using all registered detectors
+     * Detectors are tried in priority order until one succeeds
+     * @param text The text to analyze
+     * @returns Detection result from the first successful detector
+     */
+    detect(text: string): DetectionResult;
+    /**
+     * Get all registered detector names in priority order
+     */
+    getDetectorNames(): string[];
+}

package/dist/detectors/registry.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectorRegistry = void 0;
+const crisp_detector_1 = require("./crisp-detector");
+const outlook_fr_detector_1 = require("./outlook-fr-detector");
+const new_outlook_detector_1 = require("./new-outlook-detector");
+const outlook_empty_header_detector_1 = require("./outlook-empty-header-detector");
+const outlook_reverse_fr_detector_1 = require("./outlook-reverse-fr-detector");
+const reply_detector_1 = require("./reply-detector");
+/**
+ * Registry for managing forward detection plugins
+ * Detectors are tried in priority order (lower number = higher priority)
+ */
+class DetectorRegistry {
+    constructor(customDetectors = []) {
+        this.detectors = [];
+        // Register all detectors (priority determines order)
+        this.register(new crisp_detector_1.CrispDetector()); // priority: 0 (highest - universal library)
+        this.register(new outlook_empty_header_detector_1.OutlookEmptyHeaderDetector()); // priority: 5 (handle empty headers)
+        this.register(new outlook_reverse_fr_detector_1.OutlookReverseFrDetector()); // priority: 6 (handle reversed FR headers)
+        this.register(new reply_detector_1.ReplyDetector()); // priority: 7 (handle standard replies)
+        this.register(new outlook_fr_detector_1.OutlookFRDetector()); // priority: 10 (fallback for FR formats)
+        this.register(new new_outlook_detector_1.NewOutlookDetector()); // priority: 10 (fallback for new Outlook)
+        // Register custom detectors
+        customDetectors.forEach(detector => this.register(detector));
+    }
+    /**
+     * Register a new detector
+     * @param detector The detector to register
+     */
+    register(detector) {
+        this.detectors.push(detector);
+        // Sort by priority (lower number = higher priority)
+        this.detectors.sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Attempt to detect a forward using all registered detectors
+     * Detectors are tried in priority order until one succeeds
+     * @param text The text to analyze
+     * @returns Detection result from the first successful detector
+     */
+    detect(text) {
+        let bestResult = null;
+        let bestIndex = Infinity;
+        for (const detector of this.detectors) {
+            const result = detector.detect(text);
+            if (result.found) {
+                // Check if the result is actually useful (has an email address)
+                const hasValidEmail = result.email && ((typeof result.email.from === 'string' && result.email.from.trim().length > 0) ||
+                    (typeof result.email.from === 'object' && (result.email.from.address?.trim() || result.email.from.name?.trim())));
+                if (hasValidEmail) {
+                    // Calculate the position of the match based on the length of the preceding message
+                    // We assume result.message is the text BEFORE the forward.
+                    const matchIndex = result.message ? result.message.length : 0;
+                    // If this match is earlier in the text, it's a better candidate for the "next" forward
+                    // If matches start at the same position, fallback to priority (order in this.detectors)
+                    if (matchIndex < bestIndex) {
+                        bestIndex = matchIndex;
+                        result.detector = detector.name;
+                        bestResult = result;
+                    }
+                }
+            }
+        }
+        if (bestResult) {
+            return bestResult;
+        }
+        // No detector found a forward
+        return {
+            found: false,
+            confidence: 'low'
+        };
+    }
+    /**
+     * Get all registered detector names in priority order
+     */
+    getDetectorNames() {
+        return this.detectors.map(d => d.name);
+    }
+}
+exports.DetectorRegistry = DetectorRegistry;

package/dist/detectors/reply-detector.d.ts

@@ -0,0 +1,11 @@
+import { ForwardDetector, DetectionResult } from './types';
+/**
+ * Reply detector - matches "On [date], [user] wrote:" and its localized variations
+ * These are common in reply headers (Apple Mail, Outlook, etc.)
+ */
+export declare class ReplyDetector implements ForwardDetector {
+    readonly name = "reply";
+    readonly priority = 150;
+    private patterns;
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/reply-detector.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplyDetector = void 0;
+const cleaner_1 = require("../utils/cleaner");
+/**
+ * Reply detector - matches "On [date], [user] wrote:" and its localized variations
+ * These are common in reply headers (Apple Mail, Outlook, etc.)
+ */
+class ReplyDetector {
+    constructor() {
+        this.name = 'reply';
+        this.priority = 150;
+        // Localized patterns based on email-forward-parser's separator_with_information
+        this.patterns = [
+            /^\s*>?\s*Dne\s+(?<date>.+)\,\s+(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+napsal\(a\)\s*:/mi,
+            /^\s*>?\s*D.\s+(?<date>.+)\s+skrev\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]? ?: ?/mi,
+            /^\s*>?\s*Am\s+(?<date>.+)\s+schrieb\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]? ?: ?/mi,
+            /^\s*>?\s*On\s+(?<date>.+)\,\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+wrote ?: ?/mi,
+            /^\s*>?\s*On\s+(?<date>.+)\s+at\s+(?<time>.+)\,\s+(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+wrote ?: ?/mi,
+            /^\s*>?\s*On\s+(?<date>.+)\,\s+(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+wrote ?: ?/mi,
+            /^\s*>?\s*On\s+(?<date>.+)\s+(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+wrote ?: ?/mi,
+            /^\s*>?\s*El\s+(?<date>.+)\,\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+escribió ?: ?/mi,
+            /^\s*>?\s*Le\s+(?<date>.+)\,\s+[«"]?(?<from_name>.+)[»"]?\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+a écrit ?: ?/mi,
+            /^\s*>?\s*(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+kirjoitti\s+(?<date>.+) ?: ?/mi,
+            /^\s*>?\s*(?<date>.+)\s+időpontban\s+(?<from_name>.+)\s*[\[|<|(]?(?<from_address>.+)?[\]|>|)]?\s+ezt írta ?: ?/mi,
+            /^\s*>?\s*Il giorno\s+(?<date>.+)\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+ha scritto ?: ?/mi,
+            /^\s*>?\s*Op\s+(?<date>.+)\s+heeft\s+(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+geschreven ?: ?/mi,
+            /^\s*>?\s*(?<from_name>.+)\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+skrev følgende den\s+(?<date>.+) ?: ?/mi,
+            /^\s*>?\s*Dnia\s+(?<date>.+)\s+[„"]?(?<from_name>.+)[”"]?\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+napisał ?: ?/mi,
+            /^\s*>?\s*Em\s+(?<date>.+)\,\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+escreveu ?: ?/mi,
+            /^\s*>?\s*(?<date>.+)\s+пользователь\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+написал ?: ?/mi,
+            /^\s*>?\s*(?<date>.+)\s+používateľ\s+(?<from_name>.+)\s*\([\[|<]?(?<from_address>.+)?[\]|>]\)?\s+napísal ?: ?/mi,
+            /^\s*>?\s*Den\s+(?<date>.+)\s+skrev\s+"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\s+följande ?: ?/mi,
+            /^\s*>?\s*"(?<from_name>.+)"\s*[\[|<]?(?<from_address>.+)?[\]|>]?\,\s+(?<date>.+)\s+tarihinde şunu yazdı ?: ?/mi
+        ];
+    }
+    detect(text) {
+        // 1. Expert Normalization
+        const normalized = cleaner_1.Cleaner.normalize(text);
+        const lines = normalized.split('\n');
+        // Search in the first 30 lines
+        for (let i = 0; i < Math.min(lines.length, 30); i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const nextLine = (i + 1 < lines.length) ? lines[i + 1].trim() : '';
+            const combinedLine = `${line} ${nextLine}`.trim();
+            for (const pattern of this.patterns) {
+                let match = line.match(pattern);
+                let isMultiLine = false;
+                if (!match) {
+                    match = combinedLine.match(pattern);
+                    isMultiLine = !!match;
+                }
+                if (match && match.groups) {
+                    const { from_name, from_address, date, time } = match.groups;
+                    const fullDate = time ? `${date} ${time}` : date;
+                    const lastHeaderIndex = isMultiLine ? i + 1 : i;
+                    // 2. Expert Body Extraction
+                    const bodyContent = cleaner_1.Cleaner.extractBody(lines, lastHeaderIndex);
+                    const finalBody = line.startsWith('>') ? cleaner_1.Cleaner.stripQuotes(bodyContent) : bodyContent;
+                    return {
+                        found: true,
+                        detector: this.name,
+                        email: {
+                            from: {
+                                name: from_name?.trim() || '',
+                                address: from_address?.trim() || ''
+                            },
+                            date: fullDate?.trim(),
+                            body: finalBody
+                        },
+                        message: i > 0 ? lines.slice(0, i).join('\n').trim() : undefined,
+                        confidence: 'medium'
+                    };
+                }
+            }
+        }
+        return { found: false, confidence: 'low' };
+    }
+}
+exports.ReplyDetector = ReplyDetector;

package/dist/detectors/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Result of a forward detection attempt
+ */
+export interface DetectionResult {
+    /** Whether a forward was detected */
+    found: boolean;
+    /** Extracted email data if found */
+    email?: {
+        from: string | {
+            name: string;
+            address: string;
+        };
+        subject?: string;
+        date?: string;
+        body?: string;
+    };
+    /** Exclusive content before the forward separator */
+    message?: string;
+    /** Identifier of the successful detector */
+    detector?: string;
+    /** Confidence level of the detection */
+    confidence: 'high' | 'medium' | 'low';
+}
+/**
+ * Interface for forward detection plugins
+ */
+export interface ForwardDetector {
+    /** Unique identifier for this detector */
+    readonly name: string;
+    /** Priority (lower number = higher priority, Crisp = 0) */
+    readonly priority: number;
+    /**
+     * Attempt to detect a forwarded email in the given text
+     * @param text The text to analyze
+     * @returns Detection result with email data if found
+     */
+    detect(text: string): DetectionResult;
+}

package/dist/detectors/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Options, ResultObject } from './types';
+/**
+ * Main entry point: Extract the deepest forwarded email using hybrid strategy
+ */
+export declare function extractDeepestHybrid(raw: string, options?: Options): Promise<ResultObject>;
+export * from './types';