@postalsys/email-content 0.0.1

package/dist/match/history.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Stage 5: matching blocks against messages that already existed.
+ *
+ * This is the strongest evidence the pipeline can have. Every other signal is an inference from
+ * markup or wording: an attribution line suggests a quote follows, a blockquote suggests its
+ * contents are old. A match against the actual parent message is not an inference. The text
+ * demonstrably existed before this message was written, so it cannot be something the sender just
+ * wrote.
+ *
+ * In the working corpus 90.9 percent of replies resolve their In-Reply-To to a message that is also
+ * present, which makes this unusually available here. It remains strictly optional: extraction
+ * works with no history at all, and history only ever adds evidence.
+ *
+ * The matcher is deliberately conservative in one direction. A match can promote a block to
+ * REPLY_HISTORY, which hides it, so short blocks are never matched, and a high containment
+ * threshold is required. A non match never demotes anything.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHistoryDocument = buildHistoryDocument;
+exports.buildHistoryDocumentFromContent = buildHistoryDocumentFromContent;
+exports.matchBlocks = matchBlocks;
+exports.matchedIndices = matchedIndices;
+const parse_1 = require("../mime/parse");
+const text_1 = require("../canonical/text");
+const html_1 = require("../canonical/html");
+const shingle_1 = require("./shingle");
+const normalize_1 = require("./normalize");
+/**
+ * Build a searchable document from a raw earlier message.
+ *
+ * Both representations are folded into one text projection. Which representation the earlier
+ * message used has nothing to do with which one the reply quoted from, and clients routinely quote
+ * the HTML of a message into the plain text of a reply.
+ */
+async function buildHistoryDocument(raw, id, isParent) {
+    const buffer = typeof raw === 'string' ? Buffer.from(raw) : raw;
+    const message = await (0, parse_1.parseMessage)(buffer);
+    const parts = [];
+    for (const part of message.parts) {
+        if (!part.decoded || part.disposition === 'attachment') {
+            continue;
+        }
+        if (part.contentType === 'text/plain') {
+            parts.push((0, text_1.canonicaliseText)(part.decoded.text).text);
+        }
+        else if (part.contentType === 'text/html') {
+            parts.push((0, html_1.stripTagsToText)(part.decoded.text));
+        }
+    }
+    const normalised = (0, normalize_1.normaliseForMatch)(parts.join('\n'));
+    return { id, normalised, index: (0, shingle_1.buildShingleIndex)(normalised), isParent };
+}
+/**
+ * Build a searchable document from already parsed content.
+ *
+ * The counterpart to buildHistoryDocument for callers that never had a raw message. Both
+ * representations are folded together for the same reason: which one the earlier message used has
+ * nothing to do with which one the reply quoted from.
+ */
+function buildHistoryDocumentFromContent(text, html, id, isParent) {
+    const parts = [];
+    if (text) {
+        parts.push((0, text_1.canonicaliseText)(text).text);
+    }
+    if (html) {
+        parts.push((0, html_1.stripTagsToText)(html));
+    }
+    const normalised = (0, normalize_1.normaliseForMatch)(parts.join('\n'));
+    return { id, normalised, index: (0, shingle_1.buildShingleIndex)(normalised), isParent };
+}
+/**
+ * Match blocks against known history.
+ *
+ * Returns one match per block at most, preferring the direct parent over older ancestors, and
+ * higher containment over lower.
+ */
+function matchBlocks(blocks, history) {
+    if (!history.length) {
+        return [];
+    }
+    const matches = [];
+    for (const block of blocks) {
+        const normalised = (0, normalize_1.normaliseForMatch)(block.content);
+        if (!normalised) {
+            continue;
+        }
+        const index = (0, shingle_1.buildShingleIndex)(normalised);
+        if (!(0, shingle_1.isMatchable)(index)) {
+            // Too short to judge. "Thanks" appearing in the parent proves nothing about this block.
+            continue;
+        }
+        let best = null;
+        for (const document of history) {
+            // Tier one: the normalised text appears verbatim in the earlier message.
+            const exact = document.normalised.includes(normalised);
+            const score = exact ? 1 : (0, shingle_1.containment)(index, document.index).containment;
+            if (score < shingle_1.CONTAINMENT_THRESHOLD) {
+                continue;
+            }
+            const candidate = {
+                blockIndex: block.index,
+                documentId: document.id,
+                isParent: document.isParent,
+                containment: score,
+                exact
+            };
+            if (!best || betterMatch(candidate, best)) {
+                best = candidate;
+            }
+        }
+        if (best) {
+            matches.push(best);
+        }
+    }
+    return matches;
+}
+function betterMatch(candidate, current) {
+    if (candidate.isParent !== current.isParent) {
+        return candidate.isParent;
+    }
+    return candidate.containment > current.containment;
+}
+/** Convenience view for the classifier, which only needs to know which indices matched. */
+function matchedIndices(matches) {
+    return new Set(matches.map(match => match.blockIndex));
+}
+//# sourceMappingURL=history.js.map

package/dist/match/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sourceRoot":"","sources":["../../src/match/history.ts"],"names":[],"mappings":"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"}

package/dist/match/normalize.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Normalisation for history matching.
+ *
+ * The same sentence, quoted by a mail client, is rarely byte identical to the original. It has been
+ * re-wrapped, prefixed with ">", had its entities decoded or re-encoded, had non-breaking spaces
+ * substituted, had smart quotes swapped for straight ones, and may have been transcoded through a
+ * legacy charset and back.
+ *
+ * Matching therefore happens on a normalised projection: aggressive enough to survive all of that,
+ * conservative enough that two genuinely different sentences do not collide. Note the asymmetry in
+ * consequences here is the opposite of the rest of the pipeline: a false match causes content to be
+ * hidden, so this normalisation deliberately stops short of stemming, case folding of proper nouns,
+ * or anything else that would let distinct text collapse together.
+ */
+/**
+ * Normalise text for comparison.
+ *
+ * Quote prefixes are stripped, whitespace is collapsed to single spaces, punctuation variants are
+ * folded, and the result is lowercased. Line structure is deliberately discarded, because re-wrapping
+ * is the single most common transformation a quoted message undergoes.
+ */
+export declare function normaliseForMatch(text: string): string;
+/** Word tokens used for shingling and alignment. */
+export declare function tokenise(normalised: string): string[];
+/**
+ * Minimum tokens before a block is worth matching at all.
+ *
+ * Short blocks match by coincidence. "Thanks", "Yes", "Best regards" and "OK" appear in almost
+ * every thread, so a match on them says nothing about whether this particular text was quoted. Nine
+ * tokens is roughly a full sentence.
+ */
+export declare const MIN_MATCH_TOKENS = 9;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/match/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/match/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAaH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYtD;AAED,oDAAoD;AACpD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAErD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC"}

package/dist/match/normalize.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Normalisation for history matching.
+ *
+ * The same sentence, quoted by a mail client, is rarely byte identical to the original. It has been
+ * re-wrapped, prefixed with ">", had its entities decoded or re-encoded, had non-breaking spaces
+ * substituted, had smart quotes swapped for straight ones, and may have been transcoded through a
+ * legacy charset and back.
+ *
+ * Matching therefore happens on a normalised projection: aggressive enough to survive all of that,
+ * conservative enough that two genuinely different sentences do not collide. Note the asymmetry in
+ * consequences here is the opposite of the rest of the pipeline: a false match causes content to be
+ * hidden, so this normalisation deliberately stops short of stemming, case folding of proper nouns,
+ * or anything else that would let distinct text collapse together.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_MATCH_TOKENS = void 0;
+exports.normaliseForMatch = normaliseForMatch;
+exports.tokenise = tokenise;
+/** Punctuation and whitespace variants that clients substitute freely. */
+const REPLACEMENTS = [
+    [/[\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]/g, ' '], // exotic spaces
+    [/[\u200b-\u200d\ufeff\u00ad]/g, ''], // zero width and soft hyphens
+    [/[‘’‚‛′‵]/g, "'"], // single quotes
+    [/[“”„‟″‶]/g, '"'], // double quotes
+    [/[‐-―−]/g, '-'], // dashes
+    [/[…]/g, '...'],
+    [/[•·⁃]/g, '*'] // bullets
+];
+/**
+ * Normalise text for comparison.
+ *
+ * Quote prefixes are stripped, whitespace is collapsed to single spaces, punctuation variants are
+ * folded, and the result is lowercased. Line structure is deliberately discarded, because re-wrapping
+ * is the single most common transformation a quoted message undergoes.
+ */
+function normaliseForMatch(text) {
+    let out = text;
+    try {
+        out = out.normalize('NFC');
+    }
+    catch {
+        // Unnormalisable input still compares usefully.
+    }
+    out = out.replace(/^[ \t]{0,3}(?:>[ \t]?)+/gm, '');
+    for (const [pattern, replacement] of REPLACEMENTS) {
+        out = out.replace(pattern, replacement);
+    }
+    return out.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+/** Word tokens used for shingling and alignment. */
+function tokenise(normalised) {
+    return normalised.split(/[^\p{L}\p{N}]+/u).filter(token => token.length > 0);
+}
+/**
+ * Minimum tokens before a block is worth matching at all.
+ *
+ * Short blocks match by coincidence. "Thanks", "Yes", "Best regards" and "OK" appear in almost
+ * every thread, so a match on them says nothing about whether this particular text was quoted. Nine
+ * tokens is roughly a full sentence.
+ */
+exports.MIN_MATCH_TOKENS = 9;
+//# sourceMappingURL=normalize.js.map

package/dist/match/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../../src/match/normalize.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAoBH,8CAYC;AAGD,4BAEC;AAnCD,0EAA0E;AAC1E,MAAM,YAAY,GAAgC;IAC9C,CAAC,gDAAgD,EAAE,GAAG,CAAC,EAAE,gBAAgB;IACzE,CAAC,8BAA8B,EAAE,EAAE,CAAC,EAAE,8BAA8B;IACpE,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,gBAAgB;IACpC,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,gBAAgB;IACpC,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE,SAAS;IAC3B,CAAC,MAAM,EAAE,KAAK,CAAC;IACf,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,UAAU;CAC7B,CAAC;AAEF;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,IAAY;IAC1C,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,IAAI,CAAC;QACD,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACL,gDAAgD;IACpD,CAAC;IACD,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,2BAA2B,EAAE,EAAE,CAAC,CAAC;IACnD,KAAK,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,YAAY,EAAE,CAAC;QAChD,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AACzD,CAAC;AAED,oDAAoD;AACpD,SAAgB,QAAQ,CAAC,UAAkB;IACvC,OAAO,UAAU,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;GAMG;AACU,QAAA,gBAAgB,GAAG,CAAC,CAAC"}

package/dist/match/shingle.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Token shingle matching with rolling hashes.
+ *
+ * Stage 5's middle tier. Exact normalised comparison catches text that was quoted verbatim;
+ * shingles catch text that was quoted with an edit, a truncation, or an interleaved insertion,
+ * which clients and people both do.
+ *
+ * A shingle is a window of consecutive tokens. Two texts sharing most of their shingles share most
+ * of their content regardless of where it moved to. The hash is rolling, so building the index for
+ * a parent message costs one pass over its tokens.
+ */
+/** Tokens per shingle. Long enough to be specific, short enough to survive small edits. */
+export declare const SHINGLE_SIZE = 5;
+export interface ShingleIndex {
+    hashes: Set<number>;
+    tokenCount: number;
+}
+/**
+ * Build a shingle index over normalised text.
+ *
+ * The rolling hash is a simple polynomial over per token 32 bit hashes. Collisions are possible and
+ * harmless at this scale: a collision inflates a similarity score slightly, and the containment
+ * threshold plus the corroboration rules downstream absorb that.
+ */
+export declare function buildShingleIndex(normalised: string): ShingleIndex;
+export interface ContainmentResult {
+    /** Share of the block's shingles that also appear in the reference. */
+    containment: number;
+    /** Shingles compared. Zero means the block was too short to judge. */
+    shingles: number;
+}
+/**
+ * How much of `block` is contained in `reference`.
+ *
+ * Containment rather than Jaccard similarity, deliberately: a quoted paragraph is a small part of a
+ * large parent message, so symmetric similarity would be near zero for a perfect quote. What
+ * matters is whether everything in this block already existed.
+ */
+export declare function containment(block: ShingleIndex, reference: ShingleIndex): ContainmentResult;
+/** Containment at or above this counts as a match, once the block is long enough to judge. */
+export declare const CONTAINMENT_THRESHOLD = 0.8;
+/** True when a block is long enough for a containment score to mean anything. */
+export declare function isMatchable(index: ShingleIndex): boolean;
+//# sourceMappingURL=shingle.d.ts.map

package/dist/match/shingle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shingle.d.ts","sourceRoot":"","sources":["../../src/match/shingle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,2FAA2F;AAC3F,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAclE;AAYD,MAAM,WAAW,iBAAiB;IAC9B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,GAAG,iBAAiB,CAW3F;AAED,8FAA8F;AAC9F,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAExD"}

package/dist/match/shingle.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Token shingle matching with rolling hashes.
+ *
+ * Stage 5's middle tier. Exact normalised comparison catches text that was quoted verbatim;
+ * shingles catch text that was quoted with an edit, a truncation, or an interleaved insertion,
+ * which clients and people both do.
+ *
+ * A shingle is a window of consecutive tokens. Two texts sharing most of their shingles share most
+ * of their content regardless of where it moved to. The hash is rolling, so building the index for
+ * a parent message costs one pass over its tokens.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTAINMENT_THRESHOLD = exports.SHINGLE_SIZE = void 0;
+exports.buildShingleIndex = buildShingleIndex;
+exports.containment = containment;
+exports.isMatchable = isMatchable;
+const hash_1 = require("../util/hash");
+const normalize_1 = require("./normalize");
+/** Tokens per shingle. Long enough to be specific, short enough to survive small edits. */
+exports.SHINGLE_SIZE = 5;
+/**
+ * Build a shingle index over normalised text.
+ *
+ * The rolling hash is a simple polynomial over per token 32 bit hashes. Collisions are possible and
+ * harmless at this scale: a collision inflates a similarity score slightly, and the containment
+ * threshold plus the corroboration rules downstream absorb that.
+ */
+function buildShingleIndex(normalised) {
+    const tokens = (0, normalize_1.tokenise)(normalised);
+    const hashes = new Set();
+    if (tokens.length < exports.SHINGLE_SIZE) {
+        // Short text is indexed as a single shingle so it can still match exactly.
+        if (tokens.length > 0) {
+            hashes.add(hashTokens(tokens, 0, tokens.length));
+        }
+        return { hashes, tokenCount: tokens.length };
+    }
+    for (let i = 0; i + exports.SHINGLE_SIZE <= tokens.length; i++) {
+        hashes.add(hashTokens(tokens, i, exports.SHINGLE_SIZE));
+    }
+    return { hashes, tokenCount: tokens.length };
+}
+function hashTokens(tokens, start, length) {
+    let hash = 0x811c9dc5;
+    for (let i = start; i < start + length; i++) {
+        const token = tokens[i];
+        hash = (Math.imul(hash, 31) + (0, hash_1.fnv1a32)(token)) >>> 0;
+        hash = (hash ^ (0, hash_1.fnv1a32b)(token)) >>> 0;
+    }
+    return hash >>> 0;
+}
+/**
+ * How much of `block` is contained in `reference`.
+ *
+ * Containment rather than Jaccard similarity, deliberately: a quoted paragraph is a small part of a
+ * large parent message, so symmetric similarity would be near zero for a perfect quote. What
+ * matters is whether everything in this block already existed.
+ */
+function containment(block, reference) {
+    if (block.hashes.size === 0) {
+        return { containment: 0, shingles: 0 };
+    }
+    let hits = 0;
+    for (const hash of block.hashes) {
+        if (reference.hashes.has(hash)) {
+            hits++;
+        }
+    }
+    return { containment: hits / block.hashes.size, shingles: block.hashes.size };
+}
+/** Containment at or above this counts as a match, once the block is long enough to judge. */
+exports.CONTAINMENT_THRESHOLD = 0.8;
+/** True when a block is long enough for a containment score to mean anything. */
+function isMatchable(index) {
+    return index.tokenCount >= normalize_1.MIN_MATCH_TOKENS;
+}
+//# sourceMappingURL=shingle.js.map

package/dist/match/shingle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shingle.js","sourceRoot":"","sources":["../../src/match/shingle.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAoBH,8CAcC;AA0BD,kCAWC;AAMD,kCAEC;AA7ED,uCAAiD;AACjD,2CAAyD;AAEzD,2FAA2F;AAC9E,QAAA,YAAY,GAAG,CAAC,CAAC;AAO9B;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,UAAkB;IAChD,MAAM,MAAM,GAAG,IAAA,oBAAQ,EAAC,UAAU,CAAC,CAAC;IACpC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,IAAI,MAAM,CAAC,MAAM,GAAG,oBAAY,EAAE,CAAC;QAC/B,2EAA2E;QAC3E,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACrD,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;IACjD,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,oBAAY,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrD,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,oBAAY,CAAC,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AACjD,CAAC;AAED,SAAS,UAAU,CAAC,MAAyB,EAAE,KAAa,EAAE,MAAc;IACxE,IAAI,IAAI,GAAG,UAAU,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAW,CAAC;QAClC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAA,cAAO,EAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;QACpD,IAAI,GAAG,CAAC,IAAI,GAAG,IAAA,eAAQ,EAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,CAAC;AACtB,CAAC;AASD;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,KAAmB,EAAE,SAAuB;IACpE,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,WAAW,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;IAC3C,CAAC;IACD,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QAC9B,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,IAAI,EAAE,CAAC;QACX,CAAC;IACL,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;AAClF,CAAC;AAED,8FAA8F;AACjF,QAAA,qBAAqB,GAAG,GAAG,CAAC;AAEzC,iFAAiF;AACjF,SAAgB,WAAW,CAAC,KAAmB;IAC3C,OAAO,KAAK,CAAC,UAAU,IAAI,4BAAgB,CAAC;AAChD,CAAC"}

package/dist/mime/charset.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Charset decoding with an explicit, recorded fallback chain.
+ *
+ * Measured on the working corpus: about 14 percent of text parts declare something other than
+ * utf-8, including iso-8859-1, iso-8859-15, windows-1257, windows-1252 and iso-2022-jp. A silent
+ * fallback would corrupt those messages without anyone noticing, so every downgrade is reported
+ * back to the caller.
+ *
+ * Chain:
+ *   1. Normalise the declared label through libmime (handles aliases such as "unicode-1-1-utf-8").
+ *   2. Node's built in TextDecoder, which covers the WHATWG encoding set including the legacy
+ *      single byte and CJK encodings.
+ *   3. libmime's iconv-lite backed decoder, which covers labels TextDecoder rejects (utf-7 and a
+ *      long tail of aliases).
+ *   4. windows-1252, which cannot fail, flagged as a downgrade.
+ */
+export interface CharsetDecodeResult {
+    text: string;
+    charsetUsed: string;
+    replacementChars: number;
+    /** True when the declared charset could not be honoured. */
+    fellBack: boolean;
+}
+/** Normalise a raw charset label. Returns null when the label is empty or meaningless. */
+export declare function normaliseCharset(label: string | null | undefined): string | null;
+/**
+ * Decode a byte buffer using the declared charset, falling back predictably.
+ *
+ * @param buf raw bytes, already transfer decoded
+ * @param declared charset label from the Content-Type header, or null when absent
+ */
+export declare function decodeCharset(buf: Buffer, declared: string | null): CharsetDecodeResult;
+//# sourceMappingURL=charset.d.ts.map

package/dist/mime/charset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charset.d.ts","sourceRoot":"","sources":["../../src/mime/charset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAaH,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAgBhF;AA6BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,mBAAmB,CAyCvF"}

package/dist/mime/charset.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Charset decoding with an explicit, recorded fallback chain.
+ *
+ * Measured on the working corpus: about 14 percent of text parts declare something other than
+ * utf-8, including iso-8859-1, iso-8859-15, windows-1257, windows-1252 and iso-2022-jp. A silent
+ * fallback would corrupt those messages without anyone noticing, so every downgrade is reported
+ * back to the caller.
+ *
+ * Chain:
+ *   1. Normalise the declared label through libmime (handles aliases such as "unicode-1-1-utf-8").
+ *   2. Node's built in TextDecoder, which covers the WHATWG encoding set including the legacy
+ *      single byte and CJK encodings.
+ *   3. libmime's iconv-lite backed decoder, which covers labels TextDecoder rejects (utf-7 and a
+ *      long tail of aliases).
+ *   4. windows-1252, which cannot fail, flagged as a downgrade.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normaliseCharset = normaliseCharset;
+exports.decodeCharset = decodeCharset;
+const charset_1 = __importDefault(require("libmime/lib/charset"));
+const REPLACEMENT = '�';
+/**
+ * A utf-8 decode that produces more than this share of replacement characters is treated as a
+ * mislabelled single byte encoding rather than as damaged utf-8. Chosen so that a single bad byte
+ * in a long message does not trigger a switch, while genuinely mislabelled Latin-1 text does.
+ */
+const MOJIBAKE_RATIO = 0.02;
+/** Normalise a raw charset label. Returns null when the label is empty or meaningless. */
+function normaliseCharset(label) {
+    if (!label) {
+        return null;
+    }
+    const trimmed = label
+        .trim()
+        .replace(/^["']|["']$/g, '')
+        .toLowerCase();
+    if (!trimmed || trimmed === 'unknown' || trimmed === 'x-unknown' || trimmed === 'none') {
+        return null;
+    }
+    try {
+        return String(charset_1.default.normalizeCharset(trimmed) || trimmed).toLowerCase();
+    }
+    catch {
+        return trimmed;
+    }
+}
+function countReplacements(text) {
+    let count = 0;
+    let index = text.indexOf(REPLACEMENT);
+    while (index !== -1) {
+        count++;
+        index = text.indexOf(REPLACEMENT, index + 1);
+    }
+    return count;
+}
+function tryTextDecoder(buf, label) {
+    try {
+        return new TextDecoder(label, { fatal: false }).decode(buf);
+    }
+    catch {
+        return null;
+    }
+}
+function tryIconv(buf, label) {
+    try {
+        const decoded = charset_1.default.decode(buf, label);
+        return typeof decoded === 'string' ? decoded : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Decode a byte buffer using the declared charset, falling back predictably.
+ *
+ * @param buf raw bytes, already transfer decoded
+ * @param declared charset label from the Content-Type header, or null when absent
+ */
+function decodeCharset(buf, declared) {
+    if (buf.length === 0) {
+        return { text: '', charsetUsed: normaliseCharset(declared) || 'utf-8', replacementChars: 0, fellBack: false };
+    }
+    const normalised = normaliseCharset(declared);
+    // RFC 2045 says us-ascii when absent. Decoding as utf-8 is a strict superset for valid ascii
+    // and recovers undeclared utf-8, which is far more common in practice than strict ascii.
+    const label = normalised || 'utf-8';
+    let text = tryTextDecoder(buf, label);
+    let charsetUsed = label;
+    let fellBack = false;
+    if (text === null) {
+        text = tryIconv(buf, label);
+        fellBack = text !== null;
+    }
+    if (text === null) {
+        text = tryTextDecoder(buf, 'windows-1252') ?? buf.toString('latin1');
+        charsetUsed = 'windows-1252';
+        fellBack = true;
+    }
+    let replacementChars = countReplacements(text);
+    // Mislabelled single byte content declared as utf-8 is common. Only switch when the damage is
+    // widespread, so that one stray byte in an otherwise valid utf-8 message is left alone.
+    const looksLikeUtf8Label = label === 'utf-8' || label === 'utf8' || !normalised;
+    if (replacementChars > 0 && looksLikeUtf8Label && replacementChars / Math.max(text.length, 1) > MOJIBAKE_RATIO) {
+        const retry = tryTextDecoder(buf, 'windows-1252');
+        if (retry !== null) {
+            text = retry;
+            charsetUsed = 'windows-1252';
+            fellBack = true;
+            replacementChars = countReplacements(text);
+        }
+    }
+    return { text, charsetUsed, replacementChars, fellBack };
+}
+//# sourceMappingURL=charset.js.map

package/dist/mime/charset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charset.js","sourceRoot":"","sources":["../../src/mime/charset.ts"],"names":[],"mappings":"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"}

package/dist/mime/headers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Header extraction helpers.
+ *
+ * Nothing in the pipeline may depend on a header being present. Every accessor returns null rather
+ * than throwing, and every decode is wrapped so that a malformed encoded word cannot abort a parse.
+ */
+import { type HeaderEntry, type MessageHeaders } from './model';
+/** Decode MIME encoded words, falling back to the raw value on any failure. */
+export declare function decodeWordsSafe(value: string): string;
+/** Parse a structured header value such as Content-Type into a value plus parameters. */
+export declare function parseHeaderValueSafe(value: string): {
+    value: string;
+    params: Record<string, string>;
+};
+/**
+ * Convert mailsplit's raw header lines into normalised entries.
+ *
+ * mailsplit returns `{ key, line }` where `line` still contains the field name and any folded
+ * continuations joined with CRLF. Lines with no colon at all are kept with an empty key so that
+ * malformed input is still visible to diagnostics.
+ */
+export declare function toHeaderEntries(list: readonly {
+    key: string;
+    line: string;
+}[]): HeaderEntry[];
+/** Strip angle brackets and surrounding whitespace from a Message-ID style value. */
+export declare function normaliseMessageId(value: string | null): string | null;
+/** Extract every angle bracketed id from a References style header. */
+export declare function parseReferences(value: string | null): string[];
+/** Collect the headers the analysis pipeline uses. All fields are optional by design. */
+export declare function extractMessageHeaders(entries: readonly HeaderEntry[]): MessageHeaders;
+//# sourceMappingURL=headers.d.ts.map

package/dist/mime/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/mime/headers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAEhE,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED,yFAAyF;AACzF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAOrG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,WAAW,EAAE,CAY7F;AAqBD,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAOtE;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAa9D;AAUD,yFAAyF;AACzF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,cAAc,CAoBrF"}