@postalsys/email-text-tools 2.4.26 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.6.0](https://github.com/postalsys/email-text-tools/compare/v2.5.0...v2.6.0) (2026-10-21)
+
+
+### Features
+
+* export INLINE_STYLE_BLOCK from the package entry ([36b8c30](https://github.com/postalsys/email-text-tools/commit/36b8c305b3841202ae6d7407e80e0c6189d556a6))
+
+## [2.5.0](https://github.com/postalsys/email-text-tools/compare/v2.4.26...v2.5.0) (2026-10-19)
+
+
+### Features
+
+* migrate to TypeScript with ES module and CommonJS builds ([b709d60](https://github.com/postalsys/email-text-tools/commit/b709d60a6a43cd842ad60da554d9f6859350c9af))
+
 ## [2.4.26](https://github.com/postalsys/email-text-tools/compare/v2.4.25...v2.4.26) (2026-10-19)
 
 

package/README.md

@@ -2,6 +2,18 @@
 
 Email text tools
 
+Ships ES module and CommonJS builds with type declarations, Node.js 20 or newer:
+
+```js
+import { mimeHtml, textToHtml } from '@postalsys/email-text-tools';
+// or
+const { mimeHtml, textToHtml } = require('@postalsys/email-text-tools');
+```
+
+`require()` loads `mimeHtml` (and with it jsdom) only on first access; an ES module import loads it up front.
+
+`INLINE_STYLE_BLOCK` is the `<style>` block `mimeHtml()` prepends to a message that only has a text body (font and the colours of nested quotes), for a caller that converts text with `textToHtml()` itself and wants the same styling. Reading it does not load jsdom.
+
 ## mimeHtml sanitizer policy
 
 `mimeHtml()` sanitizes with DOMPurify and additionally removes:

package/dist/cjs/index.d.ts

@@ -0,0 +1,20 @@
+import textToHtml from './lib/text-to-html.js';
+import htmlToText from './lib/html-to-text.js';
+import inlineHtml from './lib/inline-html.js';
+import inlineText from './lib/inline-text.js';
+import mimeHtml from './lib/mime-html.js';
+import { INLINE_STYLE_BLOCK } from './lib/inline-style.js';
+export type { FormatDateOptions } from './lib/format-date.js';
+export type { InlineAction, MessageAddress, QuotedMessage } from './lib/inline-html.js';
+export type { MimeHtmlAsyncOptions, MimeHtmlMessage } from './lib/mime-html.js';
+export type { WorkerPoolOptions, WorkerPoolStats } from './lib/worker-pool.js';
+export { textToHtml, htmlToText, inlineHtml, inlineText, mimeHtml, INLINE_STYLE_BLOCK };
+declare const textTools: {
+    textToHtml: typeof textToHtml;
+    htmlToText: typeof htmlToText;
+    inlineHtml: typeof inlineHtml;
+    inlineText: typeof inlineText;
+    mimeHtml: typeof mimeHtml;
+    INLINE_STYLE_BLOCK: string;
+};
+export default textTools;

package/dist/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+// The CommonJS entry point, compiled by scripts/build.js into dist/cjs/index.js. index.ts is the
+// ES module entry and the source of the type declarations of both.
+//
+// require() returns the same object as before the TypeScript build: the five helpers as plain
+// enumerable properties, mimeHtml through a getter. 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. INLINE_STYLE_BLOCK was added after them and comes from a leaf module,
+// so reading it does not load jsdom either.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const text_to_html_js_1 = __importDefault(require("./lib/text-to-html.js"));
+const html_to_text_js_1 = __importDefault(require("./lib/html-to-text.js"));
+const inline_html_js_1 = __importDefault(require("./lib/inline-html.js"));
+const inline_text_js_1 = __importDefault(require("./lib/inline-text.js"));
+const inline_style_js_1 = require("./lib/inline-style.js");
+const textTools = { textToHtml: text_to_html_js_1.default, htmlToText: html_to_text_js_1.default, inlineHtml: inline_html_js_1.default, inlineText: inline_text_js_1.default };
+Object.defineProperty(textTools, 'mimeHtml', {
+    enumerable: true,
+    get() {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('./lib/mime-html.js');
+    }
+});
+textTools.INLINE_STYLE_BLOCK = inline_style_js_1.INLINE_STYLE_BLOCK;
+// What TypeScript and Babel generated `import textTools from '...'` code reads, as the
+// declarations promise a default export
+Object.defineProperty(textTools, 'default', { value: textTools, enumerable: false, writable: true, configurable: true });
+module.exports = textTools;

package/dist/cjs/lib/commonjs.cjs

@@ -0,0 +1,17 @@
+"use strict";
+// What an ES module can not do the same way in both builds. This file compiles to
+// commonjs.cjs in dist/cjs and in dist/esm alike, so __dirname is the directory of the
+// build that loaded it and require() is available to both.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLDS = exports.JUICE_WORKER_PATH = void 0;
+// A plain require() keeps the call below in the literal path.join(__dirname, '...') form, the
+// one form @yao-pkg/pkg recognizes when it collects the files a binary needs (a default import
+// compiles to path_1.default.join, which it does not). Without it the worker script is left out
+// of an EmailEngine binary
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const path = require('node:path');
+/** The worker script that runs juice off the main thread, the one of the same build */
+exports.JUICE_WORKER_PATH = path.join(__dirname, 'juice-worker.js');
+/** The top level domain list of the tlds package, which only ships it as index.json */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.TLDS = require('tlds');

package/dist/cjs/lib/commonjs.d.cts

@@ -0,0 +1,4 @@
+/** The worker script that runs juice off the main thread, the one of the same build */
+export declare const JUICE_WORKER_PATH: string;
+/** The top level domain list of the tlds package, which only ships it as index.json */
+export declare const TLDS: string[];

package/dist/cjs/lib/format-date.d.ts

@@ -0,0 +1,15 @@
+export interface FormatDateOptions {
+    /** BCP 47 language tag, defaults to 'en' */
+    locale?: string | undefined;
+    /** IANA time zone, defaults to the local time zone */
+    tz?: string | undefined;
+}
+/**
+ * Formats the date of a quoted message for the reply/forward header, for example
+ * "Sat, Jun 15, 2024, 2:30 PM" in English.
+ *
+ * @param value Date to format
+ * @param options Locale and time zone
+ * @returns Formatted date, or the input as text when it is not a valid date
+ */
+export default function formatDate(value: Date | string | number, options?: FormatDateOptions | null): string;

package/dist/cjs/lib/format-date.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = formatDate;
+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 value Date to format
+ * @param options Locale and time zone
+ * @returns 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 = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/lib/html-guard.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_NESTING_DEPTH = 1000;
+export declare function exceedsNestingDepth(html: string, maxDepth: number): boolean;
+export declare function fallbackText(html: string): string;

package/dist/cjs/lib/html-guard.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_NESTING_DEPTH = void 0;
+exports.exceedsNestingDepth = exceedsNestingDepth;
+exports.fallbackText = fallbackText;
+const he_1 = __importDefault(require("he"));
+// 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; node-html-parser spends cubic time
+// on the elements left open at the end of a document. Deeper input is not parsed at all. Real
+// email nests a few dozen levels.
+exports.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. An end tag closes the
+// nearest open element of its name together with everything opened inside it, and one that names
+// no open element is ignored, as an HTML parser ignores it: counting every end tag down instead
+// let "<b></i>" repeated nest as deep as the input allowed, and 10,000 copies took jsdom ten
+// seconds. Otherwise the estimate 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;
+    const stack = [];
+    const open = new Map();
+    let foreign = 0;
+    let pos = 0;
+    while (pos < html.length) {
+        const tagStart = html.indexOf('<', pos);
+        if (tagStart < 0) {
+            break;
+        }
+        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';
+        if (closing) {
+            if (!open.get(name)) {
+                continue;
+            }
+            let popped;
+            do {
+                // the end tag names an open element, so the stack can not run out before it
+                popped = stack.pop();
+                open.set(popped, open.get(popped) - 1);
+                if (popped === 'svg' || popped === 'math') {
+                    foreign--;
+                }
+            } while (popped !== name);
+            continue;
+        }
+        if (!foreign && NON_NESTING_TAGS.has(name)) {
+            continue;
+        }
+        // a self-closing flag is ignored on HTML elements, only SVG and MathML honor it
+        if ((foreign || isForeignRoot) && html.charAt(tagEnd - 1) === '/') {
+            continue;
+        }
+        if (isForeignRoot) {
+            foreign++;
+        }
+        stack.push(name);
+        open.set(name, (open.get(name) || 0) + 1);
+        if (stack.length > maxDepth) {
+            return true;
+        }
+    }
+    return false;
+}
+// The text of an HTML body for a fallback rendering. The fallback runs when the HTML could not be
+// processed (hostile nesting, a parser or serializer overflow), so it cannot lean on a real HTML
+// parser either: html-to-text gives up on a body nested past its own limit and returned nothing
+// for exactly the input that lands here. One pass over the string: tags become a space, style and
+// script blocks are dropped whole, entities are decoded once
+function fallbackText(html) {
+    const lower = html.toLowerCase();
+    const parts = [];
+    let pos = 0;
+    while (pos < html.length) {
+        const lt = html.indexOf('<', pos);
+        if (lt < 0) {
+            parts.push(html.slice(pos));
+            break;
+        }
+        parts.push(html.slice(pos, lt));
+        const gt = html.indexOf('>', lt + 1);
+        if (gt < 0) {
+            // an unterminated tag runs to the end of the input
+            break;
+        }
+        const name = /^(style|script)(?:[\s/]|$)/.exec(lower.slice(lt + 1, gt));
+        if (name) {
+            const close = lower.indexOf('</' + name[1], gt + 1);
+            const closeEnd = close < 0 ? -1 : html.indexOf('>', close);
+            if (closeEnd < 0) {
+                break;
+            }
+            pos = closeEnd + 1;
+        }
+        else {
+            pos = gt + 1;
+        }
+        parts.push(' ');
+    }
+    return he_1.default.decode(parts.join(''));
+}

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

@@ -0,0 +1 @@
+export default function htmlToText(html: string): string;

package/dist/cjs/lib/html-to-text.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = htmlToText;
+const html_to_text_1 = require("html-to-text");
+// Post-process function to clean up excessive newlines
+function cleanupNewlines(text) {
+    // Replace 3 or more consecutive newlines with just 2
+    // This handles cases where HTML has many nested empty divs
+    return text.replace(/\n{3,}/g, '\n\n');
+}
+const htmlToTextCompiled = (0, html_to_text_1.compile)({
+    wordwrap: 160,
+    selectors: [
+        // Block elements that should preserve line breaks
+        { selector: 'p', options: { leadingLineBreaks: 1, trailingLineBreaks: 1 } },
+        // Divs get minimal breaks - many HTML emails wrap each line in a div
+        { selector: 'div', options: { leadingLineBreaks: 1, trailingLineBreaks: 0 } },
+        { selector: 'pre', options: { leadingLineBreaks: 1, trailingLineBreaks: 1 } },
+        { selector: 'blockquote', options: { leadingLineBreaks: 1, trailingLineBreaks: 1, trimEmptyLines: true } },
+        // Headers should have spacing
+        { selector: 'h1', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        { selector: 'h2', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        { selector: 'h3', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        { selector: 'h4', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        { selector: 'h5', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        { selector: 'h6', options: { leadingLineBreaks: 2, trailingLineBreaks: 1, uppercase: false } },
+        // Line breaks
+        { selector: 'br', options: { leadingLineBreaks: 1, trailingLineBreaks: 0 } },
+        { selector: 'hr', options: { leadingLineBreaks: 1, trailingLineBreaks: 1 } },
+        // Lists should preserve structure
+        { selector: 'ul', options: { leadingLineBreaks: 1, trailingLineBreaks: 1 } },
+        { selector: 'ol', options: { leadingLineBreaks: 1, trailingLineBreaks: 1 } },
+        // Tables
+        { selector: 'table', format: 'dataTable' },
+        // Ignore images
+        { selector: 'img', format: 'skip' }
+    ],
+    // Preserve whitespace better for content
+    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) {
+    return cleanupNewlines(htmlToTextCompiled(html));
+}
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/lib/inline-html.d.ts

@@ -0,0 +1,19 @@
+import type { FormatDateOptions } from './format-date.js';
+/** An address of the quoted message */
+export interface MessageAddress {
+    name?: string | undefined;
+    address?: string | undefined;
+}
+/** The message being replied to or forwarded */
+export interface QuotedMessage {
+    from?: MessageAddress | MessageAddress[] | null | undefined;
+    to?: MessageAddress | MessageAddress[] | null | undefined;
+    cc?: MessageAddress | MessageAddress[] | null | undefined;
+    bcc?: MessageAddress | MessageAddress[] | null | undefined;
+    subject?: string | null | undefined;
+    date?: Date | string | number | null | undefined;
+    html?: string | Buffer | null | undefined;
+    text?: string | null | undefined;
+}
+export type InlineAction = 'reply' | 'forward';
+export default function inlineHtml(action: InlineAction | string, messageContent: string | Buffer | null | undefined, messageData: QuotedMessage, options?: FormatDateOptions | null): string;

package/dist/cjs/lib/inline-html.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = inlineHtml;
+const node_html_parser_1 = __importDefault(require("node-html-parser"));
+const he_1 = __importDefault(require("he"));
+const format_date_js_1 = __importDefault(require("./format-date.js"));
+const text_to_html_js_1 = __importDefault(require("./text-to-html.js"));
+const html_guard_js_1 = require("./html-guard.js");
+// Escaped text in place of a body that is not worth parsing
+function fallbackBody(html) {
+    return `<div style="white-space: pre-wrap;">${he_1.default.encode((0, html_guard_js_1.fallbackText)(html), { useNamedReferences: true })}</div>`;
+}
+function getHtmlBody(input) {
+    const html = ((input && input.toString()) || '').trim();
+    if (!html) {
+        return '';
+    }
+    // node-html-parser spends cubic time removing the elements left open at the end of a document
+    // (16 KB of unclosed <b> tags took ten seconds), so the depth check that guards mimeHtml()
+    // refuses the obvious shapes before parsing. The parse option leaves whatever is still open in
+    // place instead of reparenting it, so a shape the check underestimates (it follows the HTML
+    // parsing rules, node-html-parser ignores more end tags) costs linear time and at worst a stack
+    // overflow in the serializer, caught below
+    if ((0, html_guard_js_1.exceedsNestingDepth)(html, html_guard_js_1.MAX_NESTING_DEPTH)) {
+        return fallbackBody(html);
+    }
+    try {
+        const root = node_html_parser_1.default.parse(html, { parseNoneClosedTags: true });
+        const body = root.querySelector('body') || root.querySelector('html') || root;
+        return (body.innerHTML || '').trim();
+    }
+    catch (_err) {
+        return fallbackBody(html);
+    }
+}
+function formatAddressHtml(addr) {
+    if (!addr || (!addr.name && !addr.address)) {
+        return false;
+    }
+    let parts = [];
+    if (addr.name) {
+        parts.push(he_1.default.encode(addr.name, { useNamedReferences: true }));
+    }
+    if (addr.address) {
+        parts.push(`${he_1.default.encode('<', { useNamedReferences: true })}<a href="mailto:${he_1.default.encode(addr.address, { useNamedReferences: true })}">${he_1.default.encode(addr.address, { useNamedReferences: true })}</a>${he_1.default.encode('>', { useNamedReferences: true })}`);
+    }
+    return parts.join(' ');
+}
+function formatAddressesHtml(input) {
+    const addresses = [].concat(input || []);
+    if (!addresses || !addresses.length) {
+        return false;
+    }
+    let list = [];
+    for (let address of addresses) {
+        let entry = formatAddressHtml(address);
+        if (entry) {
+            list.push(entry);
+        }
+    }
+    if (!list.length) {
+        return false;
+    }
+    return list.join(', ');
+}
+function inlineHtml(action, messageContent, messageData, options) {
+    options = options || {};
+    messageContent = (messageContent || '').toString();
+    let originalBody;
+    if (messageData.text && !messageData.html) {
+        originalBody = (0, text_to_html_js_1.default)(messageData.text);
+    }
+    else {
+        originalBody = getHtmlBody(messageData.html);
+    }
+    if (!originalBody) {
+        return messageContent;
+    }
+    // remove html headers and stuff
+    messageContent = getHtmlBody(messageContent);
+    let headerLines = [];
+    if (messageData.from) {
+        let entry = {
+            title: 'From',
+            content: formatAddressesHtml(messageData.from) || he_1.default.encode('<>', { useNamedReferences: true })
+        };
+        headerLines.push(entry);
+    }
+    if (messageData.subject) {
+        let entry = {
+            title: 'Subject',
+            content: `<b>${he_1.default.encode(messageData.subject, { useNamedReferences: true })}</b>`
+        };
+        headerLines.push(entry);
+    }
+    let dateStr = '';
+    if (messageData.date) {
+        dateStr = (0, format_date_js_1.default)(messageData.date, options);
+        let entry = {
+            title: 'Date',
+            content: he_1.default.encode(dateStr, { useNamedReferences: true })
+        };
+        headerLines.push(entry);
+    }
+    for (let key of ['to', 'cc', 'bcc']) {
+        if (messageData[key]) {
+            let content = formatAddressesHtml(messageData[key]);
+            if (content) {
+                let entry = {
+                    title: key.replace(/^./, c => c.toUpperCase()),
+                    content
+                };
+                headerLines.push(entry);
+            }
+        }
+    }
+    let headers = [];
+    switch (action) {
+        case 'forward':
+            headers.push(`<div>Begin forwarded message:</div><br class="Apple-interchange-newline">`);
+            for (let line of headerLines) {
+                headers.push(`<div style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px;"><span style="font-family: -webkit-system-font, Helvetica Neue, Helvetica, sans-serif; color:rgba(0, 0, 0, 1.0);"><b>${line.title}: </b></span><span style="font-family: -webkit-system-font, Helvetica Neue, Helvetica, sans-serif;">${line.content}<br></span></div>`);
+            }
+            break;
+        case 'reply':
+            headers.push(`<div>On ${he_1.default.encode(dateStr, { useNamedReferences: true })}, ${formatAddressesHtml(messageData.from) || he_1.default.encode('<>', { useNamedReferences: true })} wrote:</div>`);
+            break;
+    }
+    return `<html>
+
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+</head>
+
+<body style="word-wrap: break-word; -webkit-nbsp-mode: space; line-break: after-white-space;">${messageContent}<br>
+    <div><br>
+        <blockquote type="cite" class="ee-block-1">
+${headers.join('\n')}<br>
+            <div>${originalBody}</div>
+        </blockquote>
+    </div>
+</body>
+
+</html>`;
+}
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/lib/inline-style.d.ts

@@ -0,0 +1,2 @@
+/** Base styles mimeHtml() applies to a message that only has a plain text body */
+export declare const INLINE_STYLE_BLOCK = "<style>\n\nbody, td, th, p {\n    font-family: sans-serif;\n    font-size: 12px;\n}\n\nblockquote {\n    border-left-width: 2px;\n    border-left-style: solid;\n    \n    border-left-color: darkblue;\n    color: darkblue;\n\n    margin: 1rem 0;\n    padding-left: 1rem;\n}\n\nblockquote blockquote{\n    border-left-color: royalblue;\n    color: royalblue;\n}\n\nblockquote blockquote blockquote{\n    border-left-color: dodgerblue;\n    color: dodgerblue;\n}\n\nblockquote blockquote blockquote blockquote{\n    border-left-color: darkblue;\n    color: darkblue;\n}\n\n</style>";

package/dist/cjs/lib/inline-style.js

@@ -0,0 +1,42 @@
+"use strict";
+// The default <style> block mimeHtml() prepends when a message has only a text body, so quoted
+// text converted by textToHtml() gets its quote colouring. A leaf module, so the package entry can
+// export it without loading jsdom. Named export only: lib/ modules with a default export are
+// rewritten to return it from require().
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INLINE_STYLE_BLOCK = void 0;
+/** Base styles mimeHtml() applies to a message that only has a plain text body */
+exports.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>`;

package/dist/cjs/lib/inline-text.d.ts

@@ -0,0 +1,3 @@
+import type { FormatDateOptions } from './format-date.js';
+import type { InlineAction, QuotedMessage } from './inline-html.js';
+export default function inlineText(type: InlineAction | string, messageContent: string | Buffer | null | undefined, messageData: QuotedMessage, options?: FormatDateOptions | null): string;