@postalsys/email-text-tools 2.4.16 → 2.4.17

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "2.4.16"
+    ".": "2.4.17"
 }

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.4.17](https://github.com/postalsys/email-text-tools/compare/v2.4.16...v2.4.17) (2026-09-28)
+
+
+### Bug Fixes
+
+* linear CSS pre-filter, bounded nesting, Intl dates, lazy jsdom, forms removed by the sanitiser ([9ed33c9](https://github.com/postalsys/email-text-tools/commit/9ed33c90b7b8c286b11bfc522baef75899a07325))
+
 ## [2.4.16](https://github.com/postalsys/email-text-tools/compare/v2.4.15...v2.4.16) (2026-09-07)
 
 

package/README.md

@@ -1,3 +1,15 @@
 # email-text-tools
 
 Email text tools
+
+## mimeHtml sanitizer policy
+
+`mimeHtml()` sanitizes with DOMPurify and additionally removes:
+
+- elements: `title`, `link`, `meta`, `base`, `basefont`, `frame`, `iframe`, `frameset`, `template`, `script`, `noframes`, `noscript`, `object`, `embed`, `dialog`, `canvas`, `audio`, `video`, `applet`, and forms with their controls (`form`, `input`, `button`, `select`, `textarea`; their text content is kept)
+- attributes: `action`, `formaction`, `popover`, `popovertarget`
+- CSS rules whose selector uses `:is()`, `:where()`, `:has()` or a `:not()` containing another pseudo-class, and any `<style>` text beyond 256 KB per message
+
+Input nested more than about 1000 elements deep, or that the parser cannot process, is rendered as escaped plain text instead of throwing.
+
+Reply/forward date headers from `inlineHtml()` and `inlineText()` are formatted with `Intl.DateTimeFormat` (for example `Sat, Jun 15, 2024, 2:30 PM`). An unsupported locale falls back to English and an unknown time zone to UTC. A Node build without full ICU data only has English.

package/index.js

@@ -4,12 +4,19 @@ const textToHtml = require('./lib/text-to-html');
 const htmlToText = require('./lib/html-to-text');
 const inlineHtml = require('./lib/inline-html');
 const inlineText = require('./lib/inline-text');
-const mimeHtml = require('./lib/mime-html');
 
 module.exports = {
     textToHtml,
     htmlToText,
     inlineHtml,
-    inlineText,
-    mimeHtml
+    inlineText
 };
+
+// mimeHtml loads jsdom, which costs tens of megabytes of heap, so it is only loaded on first
+// access and callers that only need the other helpers never pay for it.
+Object.defineProperty(module.exports, 'mimeHtml', {
+    enumerable: true,
+    get() {
+        return require('./lib/mime-html');
+    }
+});

package/lib/format-date.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const DATE_FORMAT = {
+    weekday: 'short',
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit'
+};
+
+// An unsupported locale would silently fall back to the host's default locale, and a Node build
+// with only English ICU data (pkg binaries use small-icu) renders other locales as broken
+// placeholders such as "M09 28, Mon", so anything not actually supported becomes 'en'.
+function resolveLocale(locale) {
+    if (locale) {
+        try {
+            const supported = Intl.DateTimeFormat.supportedLocalesOf([locale]);
+            if (supported.length) {
+                return supported[0];
+            }
+        } catch (_err) {
+            // structurally invalid language tag
+        }
+    }
+    return 'en';
+}
+
+/**
+ * Formats the date of a quoted message for the reply/forward header, for example
+ * "Sat, Jun 15, 2024, 2:30 PM" in English.
+ *
+ * @param {Date|String|Number} value Date to format
+ * @param {Object} [options]
+ * @param {String} [options.locale] BCP 47 language tag, defaults to 'en'
+ * @param {String} [options.tz] IANA time zone, defaults to the local time zone
+ * @returns {String} Formatted date, or the input as text when it is not a valid date
+ */
+function formatDate(value, options) {
+    options = options || {};
+    const date = value instanceof Date ? value : new Date(value);
+    if (isNaN(date.getTime())) {
+        return String(value);
+    }
+
+    const locale = resolveLocale(options.locale);
+    let formatter;
+    try {
+        formatter = new Intl.DateTimeFormat(locale, Object.assign({ timeZone: options.tz || undefined }, DATE_FORMAT));
+    } catch (err) {
+        if (!(err instanceof RangeError)) {
+            throw err;
+        }
+        // an unknown time zone falls back to UTC rather than to whatever zone the host runs in
+        formatter = new Intl.DateTimeFormat(locale, Object.assign({ timeZone: 'UTC' }, DATE_FORMAT));
+    }
+    const formatted = formatter.format(date);
+
+    // ICU puts a narrow no-break space before "PM", which older mail clients show as a box
+    return formatted.replace(/[\u00a0\u202f]/g, ' ');
+}
+
+module.exports = formatDate;

package/lib/html-to-text.js

@@ -42,13 +42,15 @@ const htmlToTextCompiled = compile({
     ],
     hideLinkHrefIfSameAsText: true,
     // Preserve whitespace better for content
-    preserveNewlines: true
+    preserveNewlines: true,
+    // The DOM walk is recursive, so hostile nesting would overflow the stack. Content below this
+    // depth is dropped; real email nests a few dozen levels.
+    limits: { maxDepth: 500, ellipsis: '' }
 });
 
 // Wrapper function that applies post-processing
 function htmlToText(html) {
-    const text = htmlToTextCompiled(html);
-    return cleanupNewlines(text);
+    return cleanupNewlines(htmlToTextCompiled(html));
 }
 
 module.exports = htmlToText;

package/lib/inline-html.js

@@ -2,7 +2,7 @@
 
 const HTMLParser = require('node-html-parser');
 const he = require('he');
-const moment = require('moment-timezone');
+const formatDate = require('./format-date');
 const textToHtml = require('./text-to-html');
 
 function getHtmlBody(html) {
@@ -100,17 +100,7 @@ function inlineHtml(action, messageContent, messageData, options) {
     let dateStr = '';
 
     if (messageData.date) {
-        let dateElm = moment(messageData.date);
-
-        if (options.locale) {
-            dateElm = dateElm.locale(options.locale);
-        }
-
-        if (options.tz) {
-            dateElm = dateElm.tz(options.tz);
-        }
-
-        dateStr = dateElm.format('llll');
+        dateStr = formatDate(messageData.date, options);
 
         let entry = {
             title: 'Date',

package/lib/inline-text.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const moment = require('moment-timezone');
+const formatDate = require('./format-date');
 const htmlToText = require('./html-to-text');
 
 function formatAddressText(addr) {
@@ -79,17 +79,7 @@ function inlineText(type, messageContent, messageData, options) {
     let dateStr = '';
 
     if (messageData.date) {
-        let dateElm = moment(messageData.date);
-
-        if (options.locale) {
-            dateElm = dateElm.locale(options.locale);
-        }
-
-        if (options.tz) {
-            dateElm = dateElm.tz(options.tz);
-        }
-
-        dateStr = dateElm.format('llll');
+        dateStr = formatDate(messageData.date, options);
 
         let entry = {
             title: 'Date',

package/lib/mime-html.js

@@ -11,6 +11,7 @@ const path = require('path');
 const WorkerPool = require('./worker-pool');
 
 const textToHtml = require('./text-to-html');
+const htmlToText = require('./html-to-text');
 
 const FORBID_TAGS = [
     'title',
@@ -31,9 +32,18 @@ const FORBID_TAGS = [
     'canvas',
     'audio',
     'video',
-    'applet'
+    'applet',
+    // forms and their controls have no use in a displayed message and can be styled to phish
+    'form',
+    'input',
+    'button',
+    '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',
@@ -62,9 +72,28 @@ const FORBID_STYLES = [
     'zoom'
 ];
 
+// Matches the style text of any element that could carry one of FORBID_STYLES
+const FORBID_STYLES_HINT = /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) {
+    return value.replace(/\\([0-9a-f]{1,6})[ \t\n\r\f]?|\\(.)/gi, (match, hex, chr) => {
+        if (hex) {
+            let code = parseInt(hex, 16);
+            return code && code <= 0x10ffff ? String.fromCodePoint(code) : '�';
+        }
+        return chr;
+    });
+}
+
 // keep the style at first
 const FORBID_TAGS_ALL = ['style'].concat(FORBID_TAGS);
 
+// 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;
 
@@ -166,105 +195,155 @@ blockquote blockquote blockquote blockquote{
 
 </style>`;
 
-function mimeHtmlSync(message) {
-    let html = message.html;
-    if (!html && message.text) {
-        html = textToHtml(message.text) || '';
-        if (html) {
-            html = INLINE_STYLE_BLOCK + html;
+// 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;
+
+// jsdom builds a tree in time quadratic to its depth (10,000 unclosed <b> tags take about 9 s) and
+// its serializer overflows the stack a few thousand levels down, so deeper input is not parsed at all.
+// Real email nests a few dozen levels.
+const MAX_NESTING_DEPTH = 1000;
+
+// Elements that never stay open in HTML content, either void or closed implicitly by a sibling,
+// so they do not add to the depth an HTML parser ends up with. Inside SVG and MathML they can nest,
+// so there every start tag counts.
+const NON_NESTING_TAGS = new Set(
+    'area,base,br,col,embed,hr,img,input,keygen,link,meta,param,source,track,wbr,p,li,dt,dd,td,th,tr,tbody,thead,tfoot,colgroup,caption,option,optgroup,rt,rp'.split(
+        ','
+    )
+);
+
+// A single linear pass estimating how deep the parsed tree would get. It only ever overestimates
+// (tags inside comments, attribute values and raw text count too), which at worst means an
+// extreme message is shown as plain text.
+function exceedsNestingDepth(html, maxDepth) {
+    const tagName = /[a-z][a-z0-9:-]*/iy;
+    let depth = 0;
+    let foreign = 0;
+    let pos = 0;
+    while (pos < html.length) {
+        const tagStart = html.indexOf('<', pos);
+        if (tagStart < 0) {
+            break;
         }
-    }
-
-    html = (html || '').toString().replace(/^"data:[^"]+"/g, '');
-
-    const window = new JSDOM('').window;
+        const tagEnd = html.indexOf('>', tagStart + 1);
+        if (tagEnd < 0) {
+            break;
+        }
+        // resume right after the first ">", so no tag the parser would see is ever skipped
+        pos = tagEnd + 1;
+
+        const closing = html.charAt(tagStart + 1) === '/';
+        tagName.lastIndex = tagStart + (closing ? 2 : 1);
+        const nameMatch = tagName.exec(html);
+        if (!nameMatch) {
+            continue;
+        }
+        const name = nameMatch[0].toLowerCase();
+        const isForeignRoot = name === 'svg' || name === 'math';
 
-    const DOMPurify = createDOMPurify(window);
+        if (closing) {
+            if (isForeignRoot && foreign > 0) {
+                foreign--;
+            }
+            if (depth > 0 && (foreign || !NON_NESTING_TAGS.has(name))) {
+                depth--;
+            }
+            continue;
+        }
 
-    // first pass, outputs a fixed HTML page
-    html = DOMPurify.sanitize(html, { WHOLE_DOCUMENT: true, FORCE_BODY: false, FORBID_TAGS });
+        if (!foreign && NON_NESTING_TAGS.has(name)) {
+            continue;
+        }
 
-    try {
-        // Pre-process HTML to remove known problematic CSS that causes juice to hang
-        // This is a fallback for the sync version - the async version with timeout is preferred
-        const tempDoc = new JSDOM(html).window.document;
-
-        // Remove any style tags from within body content
-        const bodyStyleTags = tempDoc.body ? tempDoc.body.querySelectorAll('style') : [];
-        bodyStyleTags.forEach(tag => tag.remove());
-
-        // Process remaining style tags to remove known problematic selectors
-        const styleTags = tempDoc.querySelectorAll('style');
-        styleTags.forEach(styleTag => {
-            let cssContent = styleTag.textContent;
-
-            // Remove rules with known problematic pseudo-classes
-            const problematicSelectors = [':is\\(', ':where\\(', ':has\\(', ':not\\(.*:.*\\)'];
-            problematicSelectors.forEach(selector => {
-                const regex = new RegExp(`[^{}]*${selector}[^{}]*\\{[^}]*\\}`, 'gi');
-                cssContent = cssContent.replace(regex, '');
-            });
-
-            styleTag.textContent = cssContent;
-        });
+        // a self-closing flag is ignored on HTML elements, only SVG and MathML honor it
+        if ((foreign || isForeignRoot) && html.charAt(tagEnd - 1) === '/') {
+            continue;
+        }
 
-        html = tempDoc.documentElement.outerHTML;
+        if (isForeignRoot) {
+            foreign++;
+        }
 
-        // Run juice synchronously - risky but backwards compatible
-        html = juice(html);
-    } catch (_err) {
-        // not so important, so we'll ignore if style inlining fails
+        depth++;
+        if (depth > maxDepth) {
+            return true;
+        }
     }
+    return false;
+}
 
-    // second pass, outputs a BODY DOM element
-    const dom = DOMPurify.sanitize(html, {
-        RETURN_DOM: true,
-        WHOLE_DOCUMENT: false,
-        FORCE_BODY: true,
-        FORBID_TAGS: FORBID_TAGS_ALL
-    });
-
-    // mark all links to be opened in a new window
-    for (let elm of dom.querySelectorAll('a')) {
-        elm.setAttribute('target', '_blank');
+// 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) {
+    let text = message.text;
+    if (!text && message.html) {
+        text = htmlToText(message.html.toString());
     }
+    return `<div style="overflow: auto;"><div style="white-space: pre-wrap;">${he.encode((text || '').toString(), { useNamedReferences: true })}</div></div>`;
+}
 
-    dom.style.overflow = 'auto';
-
-    // return <BODY> HTML
-
-    dom.style.removeProperty('width');
-    dom.style.removeProperty('min-width');
-    dom.style.removeProperty('max-width');
-    dom.style.removeProperty('height');
-    dom.style.removeProperty('min-height');
-    dom.style.removeProperty('max-height');
-
-    // remove specific style properties for all DOM nodes
-    let walkDom = node => {
-        if (node.style) {
-            for (let disallowedStyle of FORBID_STYLES) {
-                node.style.removeProperty(disallowedStyle);
+// 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)".
+function hasNotWithPseudo(selector) {
+    // paren depth just inside the open :not(, 0 when there is none. Any colon inside it is a
+    // match, so a nested :not( never needs tracking.
+    let notDepth = 0;
+    let depth = 0;
+    for (let i = 0; i < selector.length; i++) {
+        const c = selector.charAt(i);
+        if (c === ':') {
+            if (notDepth) {
+                return true;
             }
-        }
-
-        if (node.childNodes) {
-            // Convert NodeList to array to avoid infinite loops if DOM changes during iteration
-            const children = Array.from(node.childNodes);
-            for (let childNode of children) {
-                walkDom(childNode);
+            if (selector.substr(i + 1, 4).toLowerCase() === 'not(') {
+                depth++;
+                notDepth = depth;
+                i += 4;
+            }
+        } else if (c === '(') {
+            depth++;
+        } else if (c === ')') {
+            if (depth === notDepth) {
+                notDepth = 0;
+            }
+            if (depth > 0) {
+                depth--;
             }
         }
-    };
-    walkDom(dom);
+    }
+    return false;
+}
 
-    let bodyStyles = (dom.getAttribute('style') || '').toString().trim();
+function isProblematicSelector(selector) {
+    const lower = selector.toLowerCase();
+    return lower.includes(':is(') || lower.includes(':where(') || lower.includes(':has(') || hasNotWithPseudo(selector);
+}
 
-    // embed into a styled container
-    return `<div style="${he.encode(bodyStyles)}">${dom.innerHTML.trim()}</div>`;
+// 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.
+function filterCss(css) {
+    if (!/:(is|where|has|not)\(/i.test(css)) {
+        return css;
+    }
+    const pieces = css.split('}');
+    const output = [];
+    for (let i = 0; i < pieces.length; i++) {
+        const piece = pieces[i];
+        const isLast = i === pieces.length - 1;
+        const ruleStart = isLast ? -1 : piece.lastIndexOf('{');
+        const selectorStart = ruleStart < 0 ? 0 : piece.lastIndexOf('{', ruleStart - 1) + 1;
+        const drop = ruleStart >= 0 && isProblematicSelector(piece.substring(selectorStart, ruleStart));
+        output.push(drop ? piece.substring(0, selectorStart) : isLast ? piece : piece + '}');
+    }
+    return output.join('');
 }
 
-async function mimeHtmlAsync(message, options = {}) {
+// 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) || '';
@@ -275,57 +354,47 @@ async function mimeHtmlAsync(message, options = {}) {
 
     html = (html || '').toString().replace(/^"data:[^"]+"/g, '');
 
-    const window = new JSDOM('').window;
-    const DOMPurify = createDOMPurify(window);
-
-    // first pass, outputs a fixed HTML page
-    html = DOMPurify.sanitize(html, { WHOLE_DOCUMENT: true, FORCE_BODY: false, FORBID_TAGS });
-
-    try {
-        // Pre-process HTML to remove known problematic CSS that causes juice to hang
-        // This is the same filtering as the sync version to avoid unnecessary timeouts
-        const tempDoc = new JSDOM(html).window.document;
-
-        // Remove any style tags from within body content
-        const bodyStyleTags = tempDoc.body ? tempDoc.body.querySelectorAll('style') : [];
-        bodyStyleTags.forEach(tag => tag.remove());
-
-        // Process remaining style tags to remove known problematic selectors
-        const styleTags = tempDoc.querySelectorAll('style');
-        styleTags.forEach(styleTag => {
-            let cssContent = styleTag.textContent;
-
-            // Remove rules with known problematic pseudo-classes
-            const problematicSelectors = [':is\\(', ':where\\(', ':has\\(', ':not\\(.*:.*\\)'];
-            problematicSelectors.forEach(selector => {
-                const regex = new RegExp(`[^{}]*${selector}[^{}]*\\{[^}]*\\}`, 'gi');
-                cssContent = cssContent.replace(regex, '');
-            });
-
-            styleTag.textContent = cssContent;
-        });
-
-        html = tempDoc.documentElement.outerHTML;
-
-        // 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
-        // The HTML is still usable, just without inlined CSS
-        // Note: logErrors option can be used to control error visibility
+    if (exceedsNestingDepth(html, MAX_NESTING_DEPTH)) {
+        throw new Error('HTML is nested too deep to process');
+    }
 
-        if (options.fallbackOnError === false) {
-            throw err;
+    // first pass, returns the <html> element of the fixed HTML page
+    const root = DOMPurify.sanitize(html, { WHOLE_DOCUMENT: true, FORCE_BODY: false, 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;
+    root.querySelectorAll('style').forEach(styleTag => {
+        let cssContent = styleTag.textContent || '';
+        if (cssContent.length > styleBudget) {
+            // cut after the last complete rule, a partial rule would skip the selector filter
+            cssContent = styleBudget > 0 ? cssContent.substring(0, cssContent.lastIndexOf('}', styleBudget - 1) + 1) : '';
         }
-    }
+        styleBudget -= cssContent.length;
+        cssContent = filterCss(cssContent);
+        styleTag.textContent = cssContent;
+        if (cssContent.trim()) {
+            hasStyle = true;
+        }
+    });
+
+    return { html: root.outerHTML, hasStyle };
+}
 
+// Second sanitization pass and post-processing of the juice output.
+function finishHtml(html) {
     // second pass, outputs a BODY DOM element
     const dom = DOMPurify.sanitize(html, {
         RETURN_DOM: true,
         WHOLE_DOCUMENT: false,
         FORCE_BODY: true,
-        FORBID_TAGS: FORBID_TAGS_ALL
+        FORBID_TAGS: FORBID_TAGS_ALL,
+        FORBID_ATTR
     });
 
     // mark all links to be opened in a new window
@@ -343,23 +412,25 @@ async function mimeHtmlAsync(message, options = {}) {
     dom.style.removeProperty('min-height');
     dom.style.removeProperty('max-height');
 
-    // remove specific style properties for all DOM nodes
-    let walkDom = node => {
-        if (node.style) {
+    // 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) {
+            continue;
+        }
+        let styleText = node.getAttribute('style') || '';
+        if (styleText.indexOf('\\') >= 0) {
+            // A browser resolves CSS escapes in property names (p\osition is position) but jsdom's
+            // CSSOM does not, so the check below would miss them. Decode first and write the
+            // decoded text back so the CSSOM sees the same properties the browser will
+            styleText = decodeCssEscapes(styleText);
+            node.setAttribute('style', styleText);
+        }
+        if (FORBID_STYLES_HINT.test(styleText)) {
             for (let disallowedStyle of FORBID_STYLES) {
                 node.style.removeProperty(disallowedStyle);
             }
         }
-
-        if (node.childNodes) {
-            // Convert NodeList to array to avoid infinite loops if DOM changes during iteration
-            const children = Array.from(node.childNodes);
-            for (let childNode of children) {
-                walkDom(childNode);
-            }
-        }
-    };
-    walkDom(dom);
+    }
 
     let bodyStyles = (dom.getAttribute('style') || '').toString().trim();
 
@@ -367,6 +438,65 @@ async function mimeHtmlAsync(message, options = {}) {
     return `<div style="${he.encode(bodyStyles)}">${dom.innerHTML.trim()}</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 => {
+        if (rethrow) {
+            throw err;
+        }
+        return fallbackHtml(message);
+    };
+    try {
+        const result = fn();
+        return result && typeof result.then === 'function' ? result.catch(onError) : result;
+    } catch (err) {
+        return onError(err);
+    }
+}
+
+function mimeHtmlSync(message) {
+    return guarded(
+        () => {
+            let { html, hasStyle } = 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);
+        },
+        message,
+        false
+    );
+}
+
+async function mimeHtmlAsync(message, options = {}) {
+    return guarded(
+        async () => {
+            let { html, hasStyle } = 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);
+        },
+        message,
+        options.fallbackOnError === false
+    );
+}
+
 // Main export - maintains backward compatibility with sync API
 // Architecture:
 // - Both sync and async versions pre-filter known problematic CSS selectors
@@ -382,14 +512,8 @@ function mimeHtml(message) {
 mimeHtml.async = mimeHtmlAsync;
 mimeHtml.sync = mimeHtmlSync;
 
-// Close worker pool when process exits
-if (globalWorkerPool) {
-    process.on('exit', () => {
-        if (globalWorkerPool) {
-            globalWorkerPool.close().catch(() => {});
-        }
-    });
-}
+// Exposed for tests only, not part of the public API
+mimeHtml._internal = { filterCss, hasNotWithPseudo };
 
 // Export function to manually close worker pool
 mimeHtml.closeWorkerPool = async () => {

package/lib/text-to-html.js

@@ -10,6 +10,11 @@ const linkify = linkifyIt()
     .add('git:', 'http:') // Add `git:` protocol as "alias"
     .set({ fuzzyIP: true });
 
+// Quote levels deeper than this are kept as literal "> " text. Every level costs a few stack
+// frames here and a nested <blockquote> later, so hostile input with thousands of leading ">"
+// used to overflow the stack.
+const MAX_QUOTE_DEPTH = 100;
+
 function generateQuotedTree(text) {
     let lines = text.split(/\r?\n/);
 
@@ -29,9 +34,9 @@ function generateQuotedTree(text) {
         return node;
     };
 
-    let walkNode = (curNode, lines) => {
+    let walkNode = (curNode, lines, depth) => {
         for (let line of lines) {
-            if (/^>/.test(line)) {
+            if (depth < MAX_QUOTE_DEPTH && /^>/.test(line)) {
                 if (curNode.type !== 'quote') {
                     curNode = createNode(curNode.parent, 'quote');
                 }
@@ -42,7 +47,7 @@ function generateQuotedTree(text) {
                 let quoteNode = curNode;
 
                 let childNode = createNode(curNode, 'text');
-                walkNode(childNode, quoteNode.lines);
+                walkNode(childNode, quoteNode.lines, depth + 1);
 
                 curNode = createNode(curNode.parent, 'text');
                 curNode.lines.push(line);
@@ -57,12 +62,12 @@ function generateQuotedTree(text) {
             let quoteNode = curNode;
 
             let childNode = createNode(curNode, 'text');
-            walkNode(childNode, quoteNode.lines);
+            walkNode(childNode, quoteNode.lines, depth + 1);
         }
     };
 
     let rootNode = createNode(tree, 'text');
-    walkNode(rootNode, lines);
+    walkNode(rootNode, lines, 0);
 
     return tree;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@postalsys/email-text-tools",
-    "version": "2.4.16",
+    "version": "2.4.17",
     "description": "Email text tools",
     "main": "index.js",
     "scripts": {
@@ -29,18 +29,17 @@
     "homepage": "https://github.com/postalsys/email-text-tools#readme",
     "devDependencies": {
         "@eslint/js": "10.0.1",
-        "eslint": "10.10.0",
+        "eslint": "10.11.0",
         "eslint-config-prettier": "10.1.8",
-        "prettier": "3.9.6"
+        "prettier": "3.9.9"
     },
     "dependencies": {
-        "dompurify": "3.4.15",
+        "dompurify": "3.4.16",
         "he": "1.2.0",
         "html-to-text": "10.0.1",
         "jsdom": "27.0.0",
         "juice": "11.1.1",
         "linkify-it": "5.0.2",
-        "moment-timezone": "0.6.3",
         "node-html-parser": "9.0.4",
         "tlds": "1.261.0"
     }

package/test/comprehensive.test.js

@@ -277,7 +277,8 @@ describe('Comprehensive Test Suite', () => {
     describe('worker pool configuration', () => {
         it('should respect min/max worker settings', async () => {
             const input = {
-                html: '<p>Pool config test</p>'
+                // juice, and with it the pool, only runs when there is a style sheet to inline
+                html: '<style>p { color: red; }</style><p>Pool config test</p>'
             };
 
             // First close any existing pool
@@ -328,7 +329,8 @@ describe('Comprehensive Test Suite', () => {
     describe('memory leak prevention', () => {
         it('should clean up workers after timeout', async () => {
             const input = {
-                html: '<p>Timeout test</p>'
+                // a style sheet, so the juice worker actually runs and times out
+                html: '<style>p { color: red; }</style><p>Timeout test</p>'
             };
 
             try {

package/test/hardening.test.js

@@ -0,0 +1,344 @@
+'use strict';
+
+const { describe, it, after } = require('node:test');
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+
+const mimeHtml = require('../lib/mime-html');
+const textToHtml = require('../lib/text-to-html');
+const htmlToText = require('../lib/html-to-text');
+const inlineHtml = require('../lib/inline-html');
+const inlineText = require('../lib/inline-text');
+const formatDate = require('../lib/format-date');
+
+function timed(fn) {
+    const start = process.hrtime.bigint();
+    const result = fn();
+    return { result, ms: Number(process.hrtime.bigint() - start) / 1e6 };
+}
+
+function headStyle(css) {
+    return `<html><head><style>${css}</style></head><body><p class="x">content</p></body></html>`;
+}
+
+describe('hostile input hardening', () => {
+    after(async () => {
+        await mimeHtml.closeWorkerPool();
+    });
+
+    describe('CSS selector pre-filter', () => {
+        const { filterCss, hasNotWithPseudo } = mimeHtml._internal;
+
+        // The regex pre-filter this replaces took 26 s on 900 bytes of ":not(a:b)" and never
+        // finished on 1.8 KB. Timed directly on large inputs, so the bound is about the filter and
+        // not about jsdom or juice.
+        function assertLinear(fn, unit) {
+            const small = unit.repeat(Math.ceil((256 * 1024) / unit.length));
+            const large = small + small;
+            fn(small); // warm up
+            const a = timed(() => fn(small));
+            const b = timed(() => fn(large));
+            // doubling the input must not blow up the time (loose bound, the old regex was cubic)
+            assert.ok(b.ms < Math.max(a.ms * 6, 200), `${fn.name}: 256 KB ${a.ms} ms vs 512 KB ${b.ms} ms`);
+        }
+
+        // Units that never match, so the whole input is scanned
+        for (const unit of [':not(.a)', ':not(((.a)))', ':nox(a:b)', '(((:', ')))']) {
+            it(`hasNotWithPseudo stays linear on repeated ${JSON.stringify(unit)}`, () => {
+                assert.equal(hasNotWithPseudo(unit), false);
+                assertLinear(hasNotWithPseudo, unit);
+            });
+        }
+
+        for (const unit of ['p:not(.a) { color: red }', 'p:not(a:b){color:red}', 'p:is(.a){}', '{{:not(.a)}', ':not(.a){', '@media x { :where(p) { a: b } }']) {
+            it(`filterCss stays linear on repeated ${JSON.stringify(unit)}`, () => {
+                assertLinear(filterCss, unit);
+            });
+        }
+
+        it('hasNotWithPseudo matches a pseudo-class only inside :not()', () => {
+            assert.equal(hasNotWithPseudo('p:not(a:hover)'), true);
+            assert.equal(hasNotWithPseudo('P:NOT(A:HOVER)'), true);
+            assert.equal(hasNotWithPseudo('p:not(:not(.a))'), true);
+            assert.equal(hasNotWithPseudo('p:not(.y):hover'), false);
+            assert.equal(hasNotWithPseudo('p:not(.y(z)):hover'), false);
+            assert.equal(hasNotWithPseudo('a:hover'), false);
+        });
+
+        it('filterCss returns style text without risky pseudo-classes unchanged', () => {
+            const css = '@media screen { p { color: red } } a:hover { color: blue } p:not(.y) {}';
+            assert.equal(filterCss(css), css);
+        });
+
+        it('mimeHtml stays fast on a hostile selector list', () => {
+            const { result, ms } = timed(() => mimeHtml({ html: headStyle(':not(a:b)'.repeat(512)) }));
+            assert.ok(result.includes('content'));
+            assert.ok(ms < 2500, `took ${ms} ms`);
+        });
+
+        it('drops only the rules with problematic selectors', () => {
+            const css = [
+                'p { color: red; }',
+                'p:is(.x) { font-weight: bold; }',
+                'p:where(.x) { margin: 1px; }',
+                'p:has(b) { padding: 2px; }',
+                'P:NOT(A:HOVER) { text-align: center; }',
+                'p:not(.y):hover { text-decoration: underline; }',
+                'p:not(.y) { font-style: italic; }',
+                '@media screen { p:is(.x) { border: 1px solid; } }'
+            ].join('\n');
+            const result = mimeHtml({ html: headStyle(css) });
+            assert.match(result, /color: red/);
+            assert.match(result, /font-style: italic/);
+            assert.doesNotMatch(result, /font-weight/);
+            assert.doesNotMatch(result, /margin/);
+            assert.doesNotMatch(result, /padding/);
+            assert.doesNotMatch(result, /text-align/);
+            assert.doesNotMatch(result, /border/);
+        });
+
+        it('keeps rules nested in at-rules that use safe selectors', () => {
+            const html = headStyle('@media screen { p:is(.a) { color: red; } } p { color: blue; }');
+            const result = mimeHtml({ html });
+            assert.match(result, /color: blue/);
+        });
+
+        it('caps the amount of style text processed', () => {
+            const filler = '.unused { color: red; }\n'.repeat(Math.ceil((300 * 1024) / 24));
+            const html = headStyle(filler + 'p.x { color: blue; }');
+            const result = mimeHtml({ html });
+            assert.ok(result.includes('content'));
+            assert.doesNotMatch(result, /color: blue/);
+        });
+
+        it('cuts the style text at a rule boundary, so a truncated rule is not inlined unfiltered', () => {
+            // the cap falls inside the last rule, after its declarations but before its closing brace
+            const rule = 'p:is(.x) { color: green; }';
+            const prefixLength = 256 * 1024 - rule.length + 1;
+            const filler = '.unused { color: red; }\n'.repeat(Math.floor(prefixLength / 24));
+            const html = headStyle(filler + ' '.repeat(prefixLength - filler.length) + rule);
+            const result = mimeHtml({ html });
+            assert.ok(result.includes('content'));
+            assert.doesNotMatch(result, /color: green/);
+        });
+    });
+
+    describe('deep nesting', () => {
+        it('textToHtml does not overflow the stack on 5000 quote levels', () => {
+            const result = textToHtml('>'.repeat(5000) + ' deep\nafter');
+            assert.equal((result.match(/<blockquote /g) || []).length, 100);
+            assert.ok(result.includes('deep'));
+            assert.ok(result.includes('after'));
+        });
+
+        it('textToHtml keeps normal nested quotes', () => {
+            const result = textToHtml('>> two\n> one\nnone');
+            assert.ok(result.includes('ee-block-1'));
+            assert.ok(result.includes('ee-block-2'));
+        });
+
+        const FALLBACK_PREFIX = '<div style="overflow: auto;"><div style="white-space: pre-wrap;">';
+
+        it('mimeHtml falls back to escaped text on 4000 nested divs', () => {
+            const html = 'hello &lt;img src=x onerror=alert(1)&gt;' + '<div>'.repeat(4000) + 'deep' + '</div>'.repeat(4000);
+            const { result, ms } = timed(() => mimeHtml({ html }));
+            assert.ok(result.startsWith(FALLBACK_PREFIX));
+            assert.ok(result.includes('hello &lt;img'));
+            assert.doesNotMatch(result, /<img/);
+            // text below the html-to-text depth limit is dropped
+            assert.doesNotMatch(result, /deep/);
+            assert.ok(ms < 10000, `took ${ms} ms`);
+        });
+
+        it('mimeHtml does not spend seconds on 50000 unclosed <b> tags', () => {
+            const { result, ms } = timed(() => mimeHtml({ html: 'shallow' + '<b>'.repeat(50000) + 'bold' }));
+            assert.ok(result.startsWith(FALLBACK_PREFIX));
+            assert.ok(result.includes('shallow'));
+            assert.ok(ms < 15000, `took ${ms} ms`);
+        });
+
+        for (const [label, html] of [
+            ['self-closing HTML tags', '<div/>'.repeat(20000) + 'deep'],
+            ['cells nested in SVG', '<svg>' + '<td>'.repeat(20000) + 'deep'],
+            ['an abruptly closed comment', '<!-->' + '<b>'.repeat(20000) + 'deep-->'],
+            ['style inside SVG', '<svg><style>' + '<b>'.repeat(20000) + 'deep']
+        ]) {
+            it(`mimeHtml depth check is not bypassed by ${label}`, () => {
+                const { result, ms } = timed(() => mimeHtml({ html }));
+                assert.ok(result.startsWith(FALLBACK_PREFIX));
+                assert.ok(ms < 15000, `took ${ms} ms`);
+            });
+        }
+
+        it('mimeHtml keeps long flat content with implicitly closed tags', () => {
+            const html = '<p>para'.repeat(3000) + '<ul>' + '<li>item'.repeat(3000) + '</ul><table>' + '<tr><td>cell'.repeat(3000) + '</table>';
+            const result = mimeHtml({ html });
+            assert.doesNotMatch(result, /white-space: pre-wrap/);
+            assert.ok(result.includes('<li>item</li>'));
+        });
+
+        it('mimeHtml prefers the text part for the fallback', () => {
+            const result = mimeHtml({ html: '<div>'.repeat(4000) + 'html part', text: 'text <part>' });
+            assert.ok(result.includes('text &lt;part&gt;'));
+        });
+
+        it('mimeHtml still renders moderately nested HTML normally', () => {
+            const result = mimeHtml({ html: '<div>'.repeat(200) + 'normal' + '</div>'.repeat(200) });
+            assert.ok(result.includes('<div><div>'));
+            assert.ok(result.includes('normal'));
+        });
+
+        it('mimeHtml handles text with 5000 quote levels', () => {
+            const result = mimeHtml({ text: '>'.repeat(5000) + ' deep' });
+            assert.ok(result.includes('deep'));
+        });
+
+        it('mimeHtml.async falls back instead of rejecting', async () => {
+            const result = await mimeHtml.async({ html: 'async shallow' + '<div>'.repeat(4000) + 'async deep' });
+            assert.ok(result.startsWith(FALLBACK_PREFIX));
+            assert.ok(result.includes('async shallow'));
+        });
+
+        it('mimeHtml.async rejects on hostile nesting with fallbackOnError: false', async () => {
+            await assert.rejects(mimeHtml.async({ html: '<div>'.repeat(4000) + 'x' }, { fallbackOnError: false }), /nested too deep/);
+        });
+
+        it('mimeHtml.async skips the juice worker when there is no style sheet', async () => {
+            await mimeHtml.closeWorkerPool();
+            const result = await mimeHtml.async({ html: '<p style="color: red">no sheet</p>' });
+            assert.ok(result.includes('no sheet'));
+            assert.equal(mimeHtml.getWorkerPoolStats(), null);
+        });
+
+        it('htmlToText does not overflow the stack on deep nesting', () => {
+            for (const tag of ['div', 'b', 'blockquote']) {
+                const html = 'hello &amp; <b>world</b>' + `<${tag}>`.repeat(20000) + 'deep' + `</${tag}>`.repeat(20000) + 'after';
+                const text = htmlToText(html);
+                assert.ok(text.startsWith('hello & world'), text);
+                assert.ok(text.includes('after'), text);
+                // content below the depth limit is dropped
+                assert.ok(!text.includes('deep'), text);
+            }
+        });
+    });
+
+    describe('sanitizer policy', () => {
+        it('removes forms and form controls but keeps their text', () => {
+            const html =
+                '<form action="https://evil.example/collect" method="post"><p>Please log in</p>' +
+                '<input type="password" name="p"><select><option>a</option></select>' +
+                '<textarea>typed</textarea><button formaction="https://evil.example/x">Send</button></form>';
+            const result = mimeHtml({ html });
+            assert.doesNotMatch(result, /<form|<input|<select|<textarea|<button/i);
+            assert.doesNotMatch(result, /evil\.example/);
+            assert.ok(result.includes('Please log in'));
+            assert.ok(result.includes('Send'));
+        });
+
+        it('removes forbidden style properties, including from styles juice inlined', () => {
+            const html =
+                '<html><head><style>p.x { float: left; color: red; }</style></head><body style="position: fixed">' +
+                '<div style="Position: absolute; top: 0">a</div><span style="small: 1; color: blue">b</span><p class="x">c</p></body></html>';
+            const result = mimeHtml({ html });
+            assert.doesNotMatch(result, /position|float/i);
+            assert.ok(result.includes('top: 0'));
+            assert.ok(result.includes('color: red'));
+            assert.ok(result.includes('color: blue'));
+        });
+
+        it('removes popover and form submission attributes', () => {
+            const html = '<div popover id="p">overlay</div><a href="https://example.com/" popovertarget="p" formaction="https://evil.example/">link</a>';
+            const result = mimeHtml({ html });
+            assert.doesNotMatch(result, /popover|formaction/i);
+            assert.ok(result.includes('overlay'));
+            assert.ok(result.includes('href="https://example.com/"'));
+        });
+    });
+
+    describe('reply/forward date header', () => {
+        const date = new Date('2024-06-15T14:30:00Z');
+        const hasLocale = locale => Intl.DateTimeFormat.supportedLocalesOf([locale]).length > 0;
+
+        it('formats in English by default', () => {
+            assert.equal(formatDate(date, { tz: 'UTC' }), 'Sat, Jun 15, 2024, 2:30 PM');
+        });
+
+        it('honors the time zone', () => {
+            assert.equal(formatDate(date, { tz: 'America/New_York' }), 'Sat, Jun 15, 2024, 10:30 AM');
+            assert.equal(formatDate(date, { tz: 'Asia/Tokyo' }), 'Sat, Jun 15, 2024, 11:30 PM');
+        });
+
+        it('honors the locale', t => {
+            if (!hasLocale('de') || !hasLocale('et') || !hasLocale('ja')) {
+                t.skip('Node built without full ICU data');
+                return;
+            }
+            assert.equal(formatDate(date, { locale: 'de', tz: 'Europe/Berlin' }), 'Sa., 15. Juni 2024, 16:30');
+            assert.equal(formatDate(date, { locale: 'et', tz: 'Europe/Tallinn' }), 'L, 15. juuni 2024, 17:30');
+            assert.ok(formatDate(date, { locale: 'ja', tz: 'Asia/Tokyo' }).includes('2024'));
+            assert.ok(formatDate(date, { locale: 'ja', tz: 'Asia/Tokyo' }).includes('23:30'));
+        });
+
+        it('falls back to English on an invalid or unknown locale', () => {
+            assert.equal(formatDate(date, { locale: 'not a locale!!', tz: 'UTC' }), 'Sat, Jun 15, 2024, 2:30 PM');
+            assert.equal(formatDate(date, { locale: 'xx', tz: 'UTC' }), 'Sat, Jun 15, 2024, 2:30 PM');
+        });
+
+        it('falls back to UTC on an unknown time zone', () => {
+            assert.equal(formatDate(date, { tz: 'Not/AZone' }), 'Sat, Jun 15, 2024, 2:30 PM');
+        });
+
+        it('accepts date strings and passes invalid dates through', () => {
+            assert.equal(formatDate('2024-06-15T14:30:00Z', { tz: 'UTC' }), 'Sat, Jun 15, 2024, 2:30 PM');
+            assert.equal(formatDate('Sat, 15 Jun 2024 14:30:00 +0000', { tz: 'UTC' }), 'Sat, Jun 15, 2024, 2:30 PM');
+            assert.equal(formatDate('garbage', {}), 'garbage');
+        });
+
+        it('is used by inlineHtml and inlineText', () => {
+            const data = { date, from: { address: 'a@example.com' }, subject: 'S', html: '<p>Body</p>', text: 'Body' };
+            assert.ok(inlineHtml('forward', '', data, { tz: 'UTC' }).includes('Sat, Jun 15, 2024, 2:30 PM'));
+            assert.ok(inlineText('forward', '', data, { tz: 'UTC' }).includes('Date: Sat, Jun 15, 2024, 2:30 PM'));
+        });
+    });
+
+    describe('lazy loading', () => {
+        it('requiring the package does not load jsdom until mimeHtml is used', () => {
+            // A fresh process, since this test process has already loaded jsdom
+            const script = [
+                "const tools = require('.');",
+                "const loaded = () => Object.keys(require.cache).some(k => k.includes('/node_modules/jsdom/'));",
+                'const before = loaded();',
+                "tools.htmlToText('<p>x</p>');",
+                'const afterText = loaded();',
+                "const out = tools.mimeHtml({ html: '<p>x</p>' });",
+                'console.log(JSON.stringify([before, afterText, loaded(), typeof tools.mimeHtml.async, out]));'
+            ].join('\n');
+            const output = execFileSync(process.execPath, ['-e', script], { cwd: path.join(__dirname, '..') }).toString();
+            const [before, afterText, afterMime, asyncType, out] = JSON.parse(output);
+            assert.equal(before, false);
+            assert.equal(afterText, false);
+            assert.equal(afterMime, true);
+            assert.equal(asyncType, 'function');
+            assert.equal(out, '<div style="overflow: auto;"><p>x</p></div>');
+        });
+
+        it('keeps mimeHtml enumerable and destructurable', () => {
+            const tools = require('..');
+            assert.ok(Object.keys(tools).includes('mimeHtml'));
+            const { mimeHtml: fn } = tools;
+            assert.equal(fn, mimeHtml);
+        });
+    });
+});
+
+describe('forbidden style properties behind CSS escapes', () => {
+    it('strips a position property whose name uses CSS escapes', () => {
+        // a browser reads p\osition and \70 osition as position, jsdom's CSSOM does not
+        const html = '<div style="p\\osition: fixed; color: red; \\70 osition: absolute; float: left">x</div>';
+        const out = mimeHtml({ html });
+        assert.ok(!/position/i.test(out), out);
+        assert.ok(!/float/i.test(out), out);
+        assert.ok(/color:\s*red/i.test(out), out);
+    });
+});

package/test/mime-html-extra.test.js

@@ -24,7 +24,8 @@ describe('mime-html additional coverage', () => {
             // Use timeout: 1 to force pool timeout, triggering fallback to single worker
             // Both may time out, but fallbackOnError defaults to true so processing continues
             const result = await mimeHtml.async(
-                { html: '<p>Fallback test</p>' },
+                // a style sheet, so the juice worker actually runs
+                { html: '<style>p { color: red; }</style><p>Fallback test</p>' },
                 {
                     timeout: 1,
                     useWorkerPool: true

package/test/mime-html.test.js

@@ -174,7 +174,8 @@ describe('mime-html', () => {
 
         it('should use worker pool by default', async () => {
             const input = {
-                html: '<p>Pool test</p>'
+                // juice, and with it the pool, only runs when there is a style sheet to inline
+                html: '<style>p { color: red; }</style><p>Pool test</p>'
             };
 
             const promises = [];
@@ -202,32 +203,6 @@ describe('mime-html', () => {
             assert.ok(result.includes('No pool test'));
         });
 
-        it('should handle problematic CSS with pre-filtering', async () => {
-            const input = {
-                html: `
-                    <html>
-                    <head>
-                        <style>
-                            .test:is(.a, .b) { color: red; }
-                            .item:where(.x) { color: blue; }
-                            .parent:has(.child) { border: 1px solid; }
-                        </style>
-                    </head>
-                    <body>
-                        <p class="test a">Async test</p>
-                    </body>
-                    </html>
-                `
-            };
-
-            const start = Date.now();
-            const result = await mimeHtml.async(input, { timeout: 2000 });
-            const elapsed = Date.now() - start;
-
-            assert.ok(result.includes('Async test'));
-            assert.ok(elapsed < 1000, 'Should complete quickly with pre-filtering');
-        });
-
         it('should handle errors with fallback', async () => {
             const input = {
                 html: '<p>Error test</p>'