@postalsys/email-text-tools 2.4.26 → 2.6.0

package/{lib → dist/esm/lib}/mime-html.js

@@ -1,18 +1,14 @@
-'use strict';
-
-const createDOMPurify = require('dompurify');
-const { JSDOM } = require('jsdom');
+import createDOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
 // Pinned to juice 11.x: juice 12+ is pure ESM (requires Node >=22.12) and breaks pkg builds.
-// The `.default` fallback keeps this working if juice ever ships a CJS-compatible build again.
-const juice = require('juice').default || require('juice');
-const he = require('he');
-const { Worker } = require('worker_threads');
-const path = require('path');
-const WorkerPool = require('./worker-pool');
-const { MAX_NESTING_DEPTH, exceedsNestingDepth, fallbackText } = require('./html-guard');
-
-const textToHtml = require('./text-to-html');
-
+import juice from 'juice';
+import he from 'he';
+import { Worker } from 'node:worker_threads';
+import WorkerPool from './worker-pool.js';
+import { MAX_NESTING_DEPTH, exceedsNestingDepth, fallbackText } from './html-guard.js';
+import { INLINE_STYLE_BLOCK } from './inline-style.js';
+import { JUICE_WORKER_PATH } from './commonjs.cjs';
+import textToHtml from './text-to-html.js';
 const FORBID_TAGS = [
     'title',
     'link',
@@ -40,10 +36,8 @@ const FORBID_TAGS = [
     'select',
     'textarea'
 ];
-
 // form submission targets and popovers, which let sender markup act on or overlay the viewer
 const FORBID_ATTR = ['action', 'formaction', 'popover', 'popovertarget'];
-
 const FORBID_STYLES = [
     'all',
     'position',
@@ -71,16 +65,10 @@ const FORBID_STYLES = [
     'scrollbar-width',
     'zoom'
 ];
-
-// Properties to remove from style attributes: the list, a cheap test for style text that could
-// name one of them, and a test for one of them in declaration position (at the start, or after any
-// character that cannot be part of a longer property name, so "background-position" is not one)
 function styleRule(properties, hint) {
     return { properties, hint, declaration: new RegExp('(?:^|[^a-z0-9-])(?:' + properties.join('|') + ')\\s*:', 'i') };
 }
-
 const FORBID_STYLES_RULE = styleRule(FORBID_STYLES, /position|float|clip|zoom|anim|offset|scrollbar|paint|clear|\ball\b/i);
-
 // Resolves CSS escape sequences (\6F, \o) the way a browser does before it matches a property
 // name, so that a forbidden property cannot hide behind an escaped character
 function decodeCssEscapes(value) {
@@ -92,33 +80,26 @@ function decodeCssEscapes(value) {
         return chr;
     });
 }
-
 // keep the style at first
 const FORBID_TAGS_ALL = ['style'].concat(FORBID_TAGS);
-
 // HTML only. The default profiles admit SVG and MathML too, and the namespace confusion between
 // the three is where most sanitizer bypasses have come from: markup one parser closes inside an
 // <svg> or <mglyph> and another reads as HTML. Mail has no use for either, the major webmail
 // clients strip inline SVG and MathML never reached a mail client, so both go.
 const USE_PROFILES = { html: true };
-
 // A start tag the HTML parser reads as a style element: the name followed by whitespace, "/" or
 // ">". Any other character inside the name makes it some other element, and a "<style" at the
 // very end of the input is dropped by the parser, so markup this does not match has no stylesheet.
 const STYLE_TAG = /<style[\s/>]/i;
-
 // The dimensions of the body. In mail they are page-layout leftovers ("width: 100%; height: 100%",
 // "min-height: 100vh") that would only pad or scroll the box the message is shown in, and they
 // were removed when the body was the outermost element, which consumers may rely on.
 const BODY_STYLES_RULE = styleRule(['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height'], /width|height/i);
-
 // One sanitizer for the module. Every sanitize() call passes its full config, so calls do not
 // leak settings into each other.
 const DOMPurify = createDOMPurify(new JSDOM('').window);
-
 // Global worker pool instance (lazy initialization)
 let globalWorkerPool = null;
-
 function getWorkerPool(options = {}) {
     if (!globalWorkerPool) {
         globalWorkerPool = new WorkerPool({
@@ -130,97 +111,55 @@ function getWorkerPool(options = {}) {
     }
     return globalWorkerPool;
 }
-
 // define styles for plaintext emails
 // Wrapper for juice that runs in a worker thread with timeout protection
 async function juiceWithTimeout(html, options = {}) {
     const timeout = options.timeout || 5000;
     const usePool = options.useWorkerPool !== false; // Default to true
-
     if (usePool) {
         try {
             const pool = getWorkerPool(options);
             return await pool.process(html, { timeout });
-        } catch (err) {
+        }
+        catch (err) {
             // Fall back to single worker if pool fails
             if (options.fallbackOnError === false) {
                 throw err;
             }
         }
     }
-
     // Single worker implementation (fallback or when pool disabled)
     const timeoutMs = timeout;
     return new Promise((resolve, reject) => {
-        const worker = new Worker(path.join(__dirname, 'juice-worker.js'));
+        const worker = new Worker(JUICE_WORKER_PATH);
         let timedOut = false;
-
         const timeout = setTimeout(() => {
             timedOut = true;
-            worker.terminate();
+            void worker.terminate();
             reject(new Error('Juice processing timed out - likely due to unsupported CSS selectors'));
         }, timeoutMs);
-
-        worker.on('message', msg => {
+        worker.on('message', (msg) => {
             clearTimeout(timeout);
-            worker.terminate();
+            void worker.terminate();
             if (msg.success) {
                 resolve(msg.result);
-            } else {
+            }
+            else {
                 reject(new Error(msg.error));
             }
         });
-
-        worker.on('error', err => {
+        worker.on('error', (err) => {
             clearTimeout(timeout);
             if (!timedOut) {
                 reject(err);
             }
         });
-
         worker.postMessage(html);
     });
 }
-
-const INLINE_STYLE_BLOCK = `<style>
-
-body, td, th, p {
-    font-family: sans-serif;
-    font-size: 12px;
-}
-
-blockquote {
-    border-left-width: 2px;
-    border-left-style: solid;
-    
-    border-left-color: darkblue;
-    color: darkblue;
-
-    margin: 1rem 0;
-    padding-left: 1rem;
-}
-
-blockquote blockquote{
-    border-left-color: royalblue;
-    color: royalblue;
-}
-
-blockquote blockquote blockquote{
-    border-left-color: dodgerblue;
-    color: dodgerblue;
-}
-
-blockquote blockquote blockquote blockquote{
-    border-left-color: darkblue;
-    color: darkblue;
-}
-
-</style>`;
-
 // Only this much <style> text is kept per message, the rest is dropped. juice and the selector
 // filter below scale with it, and no legitimate email needs more.
 const MAX_STYLE_TEXT = 256 * 1024;
-
 // juice matches every selector against every element, so its cost is the product of the two
 // counts: 1,000 rules on 10,000 paragraphs took 2.7 s and 10,000 on 10,000 took 25 s, on the
 // calling thread, and the style text cap alone leaves the body unbounded. Each bound sits well
@@ -232,7 +171,6 @@ const MAX_STYLE_TEXT = 256 * 1024;
 const MAX_INLINE_SELECTORS = 5000;
 const MAX_INLINE_ELEMENTS = 50000;
 const MAX_INLINE_WORK = 5000000;
-
 // Selectors juice would match against the document: every selector of every rule at the top level
 // of the style text. A rule nested in an at-rule is not inlined (juice keeps media queries as rules),
 // so it only costs its parse and is not counted. One linear pass
@@ -248,20 +186,22 @@ function countSelectors(css) {
                 commas = 0;
             }
             depth++;
-        } else if (c === '}') {
+        }
+        else if (c === '}') {
             if (depth > 0) {
                 depth--;
             }
             commas = 0;
-        } else if (c === ';' && depth === 0) {
+        }
+        else if (c === ';' && depth === 0) {
             commas = 0;
-        } else if (c === ',' && depth === 0) {
+        }
+        else if (c === ',' && depth === 0) {
             commas++;
         }
     }
     return count;
 }
-
 // Rendered in place of the sanitized HTML when the pipeline cannot process the input at all, for
 // example when a hostile nesting depth overflows the stack of the parser or the serializer.
 function fallbackHtml(message) {
@@ -271,7 +211,6 @@ function fallbackHtml(message) {
     }
     return `<div style="overflow: auto;"><div style="white-space: pre-wrap;">${he.encode((text || '').toString(), { useNamedReferences: true })}</div></div>`;
 }
-
 // True when a :not( argument contains another colon. Such selectors, like :is(), :where() and
 // :has(), can make juice hang. A single pass with a paren counter keeps this linear, the regex
 // it replaces backtracked catastrophically on a few hundred bytes of repeated ":not(a:b)".
@@ -286,14 +225,16 @@ function hasNotWithPseudo(selector) {
             if (notDepth) {
                 return true;
             }
-            if (selector.substr(i + 1, 4).toLowerCase() === 'not(') {
+            if (selector.slice(i + 1, i + 5).toLowerCase() === 'not(') {
                 depth++;
                 notDepth = depth;
                 i += 4;
             }
-        } else if (c === '(') {
+        }
+        else if (c === '(') {
             depth++;
-        } else if (c === ')') {
+        }
+        else if (c === ')') {
             if (depth === notDepth) {
                 notDepth = 0;
             }
@@ -304,12 +245,10 @@ function hasNotWithPseudo(selector) {
     }
     return false;
 }
-
 function isProblematicSelector(selector) {
     const lower = selector.toLowerCase();
     return lower.includes(':is(') || lower.includes(':where(') || lower.includes(':has(') || hasNotWithPseudo(selector);
 }
-
 // Drops every rule whose selector could make juice hang. The text is split into rules on "}" and
 // the selector of each rule is the text between the last two "{" in it, so a rule nested in an
 // at-rule is dropped without its enclosing block.
@@ -329,39 +268,39 @@ function filterCss(css) {
     }
     return output.join('');
 }
-
 // Sanitizes the whole document and strips the CSS juice is known to choke on. Returns the HTML
 // to run juice on and whether any style text is left for juice to inline.
 function prepareHtml(message) {
-    let html = message.html;
-    if (!html && message.text) {
-        html = textToHtml(message.text) || '';
-        if (html) {
-            html = INLINE_STYLE_BLOCK + html;
+    let source = message.html;
+    if (!source && message.text) {
+        source = textToHtml(message.text) || '';
+        if (source) {
+            source = INLINE_STYLE_BLOCK + source;
         }
     }
-
-    html = (html || '').toString().replace(/^"data:[^"]+"/g, '');
-
+    const html = (source || '').toString().replace(/^"data:[^"]+"/g, '');
     if (exceedsNestingDepth(html, MAX_NESTING_DEPTH)) {
         throw new Error('HTML is nested too deep to process');
     }
-
     if (!STYLE_TAG.test(html)) {
         // No style element can come out of this markup, so there is nothing to inline. This pass
         // exists to find and filter the stylesheets before juice sees them, and without one it
         // would only add a parse and a serialization to the pass finishHtml() makes anyway.
         return { html, hasStyle: false, inliningSkipped: false };
     }
-
     // first pass, returns the <html> element of the fixed HTML page
-    const root = DOMPurify.sanitize(html, { WHOLE_DOCUMENT: true, FORCE_BODY: false, USE_PROFILES, FORBID_TAGS, FORBID_ATTR, RETURN_DOM: true });
-
+    const root = DOMPurify.sanitize(html, {
+        WHOLE_DOCUMENT: true,
+        FORCE_BODY: false,
+        USE_PROFILES,
+        FORBID_TAGS,
+        FORBID_ATTR,
+        RETURN_DOM: true
+    });
     // Remove any style tags from within body content
     const body = root.querySelector('body');
     const bodyStyleTags = body ? body.querySelectorAll('style') : [];
     bodyStyleTags.forEach(tag => tag.remove());
-
     // Process remaining style tags to remove known problematic selectors
     let styleBudget = MAX_STYLE_TEXT;
     let hasStyle = false;
@@ -380,7 +319,6 @@ function prepareHtml(message) {
             selectors += countSelectors(cssContent);
         }
     });
-
     let inliningSkipped = false;
     if (hasStyle) {
         const elements = root.getElementsByTagName('*').length;
@@ -389,10 +327,8 @@ function prepareHtml(message) {
             inliningSkipped = true;
         }
     }
-
     return { html: root.outerHTML, hasStyle, inliningSkipped };
 }
-
 // Removes the properties of a style rule from an element the way a browser will read them, by the
 // CSSOM first and then by the attribute text the CSSOM did not parse.
 function removeStyleProperties(node, rule) {
@@ -413,14 +349,15 @@ function removeStyleProperties(node, rule) {
         const parsed = node.style.cssText;
         if (parsed) {
             node.setAttribute('style', parsed);
-        } else {
+        }
+        else {
             node.removeAttribute('style');
         }
-    } else if (!remaining.trim()) {
+    }
+    else if (!remaining.trim()) {
         node.removeAttribute('style');
     }
 }
-
 // The sanitization pass that produces the output (the second one when there was a stylesheet to
 // inline, the only one otherwise) and the post-processing of its result.
 function finishHtml(html, inliningSkipped) {
@@ -433,7 +370,6 @@ function finishHtml(html, inliningSkipped) {
         FORBID_TAGS: FORBID_TAGS_ALL,
         FORBID_ATTR
     });
-
     // Every link opens a new browsing context that gets neither an opener nor a referrer. Browsers
     // imply noopener for target="_blank", but rel="opener" opts back in and the sender writes rel,
     // and an opener can navigate the page the message is shown in. An <area> is a link too.
@@ -441,7 +377,6 @@ function finishHtml(html, inliningSkipped) {
         link.setAttribute('target', '_blank');
         link.setAttribute('rel', 'noopener noreferrer');
     }
-
     // remove specific style properties, touching the CSSOM only where the style text could name one
     for (const node of [dom, ...dom.querySelectorAll('[style]')]) {
         if (!node.style) {
@@ -457,9 +392,7 @@ function finishHtml(html, inliningSkipped) {
         removeStyleProperties(node, FORBID_STYLES_RULE);
     }
     removeStyleProperties(dom, BODY_STYLES_RULE);
-
     const bodyStyles = (dom.getAttribute('style') || '').trim();
-
     // Two wrappers. The outer one is ours alone and clips everything inside it; the inner one is
     // the message body with the styles it came with. While the body's styles sat on the clipping
     // element, a sender could undo the clipping (display: contents or inline, an overflow-x:
@@ -473,11 +406,10 @@ function finishHtml(html, inliningSkipped) {
     const body = bodyStyles ? `<div style="${he.encode(bodyStyles)}">` : '<div>';
     return `<div style="overflow: auto; contain: paint;"${marker}>${body}${dom.innerHTML.trim()}</div></div>`;
 }
-
 // Runs the pipeline and renders the plain text fallback when it fails, for example when a
 // hostile nesting depth overflows the stack of the parser or the serializer.
 function guarded(fn, message, rethrow) {
-    const onError = err => {
+    const onError = (err) => {
         if (rethrow) {
             throw err;
         }
@@ -485,54 +417,46 @@ function guarded(fn, message, rethrow) {
     };
     try {
         const result = fn();
-        return result && typeof result.then === 'function' ? result.catch(onError) : result;
-    } catch (err) {
+        return (typeof result === 'string' ? result : result.catch(onError));
+    }
+    catch (err) {
         return onError(err);
     }
 }
-
 function mimeHtmlSync(message) {
-    return guarded(
-        () => {
-            let { html, hasStyle, inliningSkipped } = prepareHtml(message);
-            if (hasStyle) {
-                try {
-                    // Run juice synchronously - risky but backwards compatible
-                    html = juice(html);
-                } catch (_err) {
-                    // not so important, so we'll ignore if style inlining fails
-                }
+    return guarded(() => {
+        let { html, hasStyle, inliningSkipped } = prepareHtml(message);
+        if (hasStyle) {
+            try {
+                // Run juice synchronously - risky but backwards compatible
+                html = juice(html);
+            }
+            catch (_err) {
+                // not so important, so we'll ignore if style inlining fails
             }
-            return finishHtml(html, inliningSkipped);
-        },
-        message,
-        false
-    );
+        }
+        return finishHtml(html, inliningSkipped);
+    }, message, false);
 }
-
 async function mimeHtmlAsync(message, options = {}) {
-    return guarded(
-        async () => {
-            let { html, hasStyle, inliningSkipped } = prepareHtml(message);
-            if (hasStyle) {
-                try {
-                    // Use worker thread with timeout for juice - provides protection against ANY
-                    // unexpected CSS that might cause hangs (beyond our known problematic selectors)
-                    html = await juiceWithTimeout(html, options);
-                } catch (err) {
-                    // If juice fails or times out, continue without inlining styles
-                    if (options.fallbackOnError === false) {
-                        throw err;
-                    }
+    return guarded(async () => {
+        let { html, hasStyle, inliningSkipped } = prepareHtml(message);
+        if (hasStyle) {
+            try {
+                // Use worker thread with timeout for juice - provides protection against ANY
+                // unexpected CSS that might cause hangs (beyond our known problematic selectors)
+                html = await juiceWithTimeout(html, options);
+            }
+            catch (err) {
+                // If juice fails or times out, continue without inlining styles
+                if (options.fallbackOnError === false) {
+                    throw err;
                 }
             }
-            return finishHtml(html, inliningSkipped);
-        },
-        message,
-        options.fallbackOnError === false
-    );
+        }
+        return finishHtml(html, inliningSkipped);
+    }, message, options.fallbackOnError === false);
 }
-
 // Main export - maintains backward compatibility with sync API
 // Architecture:
 // - Both sync and async versions pre-filter known problematic CSS selectors
@@ -543,14 +467,11 @@ function mimeHtml(message) {
     // Use the sync version for backward compatibility
     return mimeHtmlSync(message);
 }
-
 // Export both versions
 mimeHtml.async = mimeHtmlAsync;
 mimeHtml.sync = mimeHtmlSync;
-
 // Exposed for tests only, not part of the public API
 mimeHtml._internal = { filterCss, hasNotWithPseudo };
-
 // Export function to manually close worker pool
 mimeHtml.closeWorkerPool = async () => {
     if (globalWorkerPool) {
@@ -558,7 +479,6 @@ mimeHtml.closeWorkerPool = async () => {
         globalWorkerPool = null;
     }
 };
-
 // Export function to get worker pool stats
 mimeHtml.getWorkerPoolStats = () => {
     if (globalWorkerPool) {
@@ -566,5 +486,4 @@ mimeHtml.getWorkerPoolStats = () => {
     }
     return null;
 };
-
-module.exports = mimeHtml;
+export default mimeHtml;

package/dist/esm/lib/text-to-html.d.ts

@@ -0,0 +1 @@
+export default function textToHtml(text?: string | Buffer | null): string | undefined;