@emailens/engine 0.2.0 → 0.3.0

package/dist/index.js

@@ -3909,11 +3909,836 @@ function extractCode(response) {
   }
   return response.trim();
 }
+
+// src/spam-scorer.ts
+import * as cheerio4 from "cheerio";
+var SPAM_TRIGGER_PHRASES = [
+  "act now",
+  "limited time",
+  "click here",
+  "buy now",
+  "order now",
+  "don't miss",
+  "don't delete",
+  "urgent",
+  "congratulations",
+  "you've been selected",
+  "you've won",
+  "winner",
+  "free gift",
+  "risk free",
+  "no obligation",
+  "no cost",
+  "no fees",
+  "100% free",
+  "100% satisfied",
+  "double your money",
+  "earn extra cash",
+  "make money",
+  "cash bonus",
+  "as seen on",
+  "incredible deal",
+  "lowest price",
+  "once in a lifetime",
+  "special promotion",
+  "this isn't spam",
+  "what are you waiting for",
+  "apply now",
+  "sign up free",
+  "cancel anytime",
+  "no strings attached",
+  "no questions asked"
+];
+var URL_SHORTENERS = [
+  "bit.ly",
+  "tinyurl.com",
+  "t.co",
+  "goo.gl",
+  "ow.ly",
+  "is.gd",
+  "buff.ly",
+  "rebrand.ly",
+  "bl.ink",
+  "short.io",
+  "cutt.ly",
+  "rb.gy"
+];
+var WEIGHTS = {
+  "caps-ratio": 15,
+  "excessive-punctuation": 10,
+  "spam-phrases": 5,
+  "missing-unsubscribe": 15,
+  "hidden-text": 20,
+  "url-shortener": 10,
+  "image-only": 20,
+  "high-image-ratio": 10,
+  "deceptive-link": 15,
+  "all-caps-subject": 10
+};
+function extractVisibleText($) {
+  const clone = $.root().clone();
+  clone.find("script, style, head").remove();
+  return clone.text().replace(/\s+/g, " ").trim();
+}
+function checkCapsRatio(text) {
+  const words = text.split(/\s+/).filter((w) => w.length >= 3);
+  if (words.length < 5) return null;
+  const capsWords = words.filter((w) => w === w.toUpperCase() && /[A-Z]/.test(w));
+  const ratio = capsWords.length / words.length;
+  if (ratio > 0.2) {
+    return {
+      rule: "caps-ratio",
+      severity: "warning",
+      message: `${Math.round(ratio * 100)}% of words are ALL CAPS \u2014 spam filters flag excessive capitalization.`,
+      detail: `Found ${capsWords.length} of ${words.length} words in all caps.`
+    };
+  }
+  return null;
+}
+function checkExcessivePunctuation(text) {
+  const exclamations = (text.match(/!/g) || []).length;
+  const dollars = (text.match(/\$/g) || []).length;
+  const total = exclamations + dollars;
+  if (total > 5) {
+    return {
+      rule: "excessive-punctuation",
+      severity: "warning",
+      message: `Excessive special characters detected (${exclamations} "!", ${dollars} "$") \u2014 common spam trigger.`
+    };
+  }
+  return null;
+}
+function checkSpamPhrases(text) {
+  const lower = text.toLowerCase();
+  const found = [];
+  for (const phrase of SPAM_TRIGGER_PHRASES) {
+    if (lower.includes(phrase)) {
+      found.push({
+        rule: "spam-phrases",
+        severity: "info",
+        message: `Contains spam trigger phrase: "${phrase}"`
+      });
+    }
+  }
+  return found;
+}
+function checkUnsubscribe($) {
+  let hasUnsubscribe = false;
+  $("a").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().toLowerCase();
+    if (text.includes("unsubscribe") || href.toLowerCase().includes("unsubscribe") || text.includes("opt out") || text.includes("opt-out") || href.toLowerCase().includes("opt-out") || href.toLowerCase().includes("optout")) {
+      hasUnsubscribe = true;
+    }
+  });
+  if (!hasUnsubscribe) {
+    return {
+      rule: "missing-unsubscribe",
+      severity: "error",
+      message: "No unsubscribe link found \u2014 required by CAN-SPAM and GDPR. Most spam filters penalize this.",
+      detail: 'Add an <a> link with "unsubscribe" text or href.'
+    };
+  }
+  return null;
+}
+function checkHiddenText($) {
+  let found = false;
+  let detail = "";
+  $("[style]").each((_, el) => {
+    const style = ($(el).attr("style") || "").toLowerCase();
+    const text = $(el).text().trim();
+    if (!text) return;
+    if (/font-size\s*:\s*0(?:px|em|rem|pt)?(?:\s|;|$)/.test(style)) {
+      found = true;
+      detail = "font-size:0 on element with text content";
+      return false;
+    }
+    if (/visibility\s*:\s*hidden/.test(style)) {
+      found = true;
+      detail = "visibility:hidden on element with text content";
+      return false;
+    }
+    if (/display\s*:\s*none/.test(style)) {
+      found = true;
+      detail = "display:none on element with text content";
+      return false;
+    }
+  });
+  if (found) {
+    return {
+      rule: "hidden-text",
+      severity: "error",
+      message: "Hidden text detected \u2014 major spam filter red flag.",
+      detail
+    };
+  }
+  return null;
+}
+function checkUrlShorteners($) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  $("a[href]").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    for (const shortener of URL_SHORTENERS) {
+      if (href.includes(shortener) && !seen.has(shortener)) {
+        seen.add(shortener);
+        issues.push({
+          rule: "url-shortener",
+          severity: "warning",
+          message: `URL shortener detected (${shortener}) \u2014 spam filters distrust shortened links.`,
+          detail: href
+        });
+      }
+    }
+  });
+  return issues;
+}
+function checkImageToTextRatio($) {
+  const text = extractVisibleText($);
+  const images = $("img").length;
+  if (images === 0) return null;
+  if (text.length < 50 && images > 0) {
+    return {
+      rule: "image-only",
+      severity: "error",
+      message: `Image-heavy email with almost no text (${text.length} chars, ${images} images) \u2014 likely to be flagged as spam or clipped.`
+    };
+  }
+  const ratio = images / (text.length / 100);
+  if (ratio > 0.5 && images > 3) {
+    return {
+      rule: "high-image-ratio",
+      severity: "warning",
+      message: `High image-to-text ratio (${images} images for ${text.length} chars of text) \u2014 consider adding more text content.`
+    };
+  }
+  return null;
+}
+function checkDeceptiveLinks($) {
+  const issues = [];
+  $("a[href]").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().trim();
+    if (/^https?:\/\/\S+/i.test(text) || /^www\.\S+/i.test(text)) {
+      try {
+        const textDomain = new URL(
+          text.startsWith("www.") ? `https://${text}` : text
+        ).hostname.replace(/^www\./, "");
+        const hrefDomain = new URL(href).hostname.replace(/^www\./, "");
+        if (textDomain !== hrefDomain) {
+          issues.push({
+            rule: "deceptive-link",
+            severity: "error",
+            message: `Link text shows "${textDomain}" but links to "${hrefDomain}" \u2014 phishing red flag.`,
+            detail: `Text: ${text}
+Href: ${href}`
+          });
+        }
+      } catch (e) {
+      }
+    }
+  });
+  return issues;
+}
+function checkAllCapsTitle($) {
+  const title = $("title").text().trim();
+  if (title.length > 5 && title === title.toUpperCase() && /[A-Z]/.test(title)) {
+    return {
+      rule: "all-caps-subject",
+      severity: "warning",
+      message: "Email title/subject is ALL CAPS \u2014 common spam indicator."
+    };
+  }
+  return null;
+}
+function analyzeSpam(html) {
+  if (!html || !html.trim()) {
+    return { score: 100, level: "low", issues: [] };
+  }
+  const $ = cheerio4.load(html);
+  const text = extractVisibleText($);
+  const issues = [];
+  const capsIssue = checkCapsRatio(text);
+  if (capsIssue) issues.push(capsIssue);
+  const punctIssue = checkExcessivePunctuation(text);
+  if (punctIssue) issues.push(punctIssue);
+  issues.push(...checkSpamPhrases(text));
+  const unsubIssue = checkUnsubscribe($);
+  if (unsubIssue) issues.push(unsubIssue);
+  const hiddenIssue = checkHiddenText($);
+  if (hiddenIssue) issues.push(hiddenIssue);
+  issues.push(...checkUrlShorteners($));
+  const imageRatioIssue = checkImageToTextRatio($);
+  if (imageRatioIssue) issues.push(imageRatioIssue);
+  issues.push(...checkDeceptiveLinks($));
+  const capsTitle = checkAllCapsTitle($);
+  if (capsTitle) issues.push(capsTitle);
+  let penalty = 0;
+  const seenRules = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const count = (seenRules.get(issue.rule) || 0) + 1;
+    seenRules.set(issue.rule, count);
+    const weight = WEIGHTS[issue.rule] || 5;
+    if (issue.rule === "spam-phrases") {
+      if (count <= 5) penalty += weight;
+    } else if (issue.rule === "url-shortener" || issue.rule === "deceptive-link") {
+      if (count <= 2) penalty += weight;
+    } else {
+      penalty += weight;
+    }
+  }
+  const score = Math.max(0, Math.min(100, 100 - penalty));
+  const level = score >= 70 ? "low" : score >= 40 ? "medium" : "high";
+  return { score, level, issues };
+}
+
+// src/link-validator.ts
+import * as cheerio5 from "cheerio";
+var GENERIC_LINK_TEXT = /* @__PURE__ */ new Set([
+  "click here",
+  "here",
+  "read more",
+  "learn more",
+  "more",
+  "link",
+  "this link",
+  "click",
+  "tap here",
+  "this"
+]);
+function classifyHref(href) {
+  if (!href || !href.trim()) return "empty";
+  const h = href.trim().toLowerCase();
+  if (h.startsWith("https://")) return "https";
+  if (h.startsWith("http://")) return "http";
+  if (h.startsWith("mailto:")) return "mailto";
+  if (h.startsWith("tel:")) return "tel";
+  if (h.startsWith("#")) return "anchor";
+  if (h.startsWith("javascript:")) return "javascript";
+  if (h.startsWith("//")) return "protocol-relative";
+  return "other";
+}
+function isPlaceholderHref(href) {
+  const h = href.trim().toLowerCase();
+  return h === "#" || h === "" || h === "javascript:void(0)" || h === "javascript:;";
+}
+function validateLinks(html) {
+  if (!html || !html.trim()) {
+    return {
+      totalLinks: 0,
+      issues: [],
+      breakdown: { https: 0, http: 0, mailto: 0, tel: 0, anchor: 0, other: 0 }
+    };
+  }
+  const $ = cheerio5.load(html);
+  const issues = [];
+  const breakdown = { https: 0, http: 0, mailto: 0, tel: 0, anchor: 0, other: 0 };
+  const links = $("a");
+  const totalLinks = links.length;
+  if (totalLinks === 0) {
+    issues.push({
+      severity: "info",
+      rule: "no-links",
+      message: "Email contains no links"
+    });
+    return { totalLinks: 0, issues, breakdown };
+  }
+  links.each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().trim();
+    const category = classifyHref(href);
+    switch (category) {
+      case "https":
+        breakdown.https++;
+        break;
+      case "http":
+        breakdown.http++;
+        break;
+      case "mailto":
+        breakdown.mailto++;
+        break;
+      case "tel":
+        breakdown.tel++;
+        break;
+      case "anchor":
+        breakdown.anchor++;
+        break;
+      default:
+        breakdown.other++;
+        break;
+    }
+    if (!href || !href.trim()) {
+      issues.push({
+        severity: "error",
+        rule: "empty-href",
+        message: "Link has no href attribute",
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (category === "javascript" && !isPlaceholderHref(href)) {
+      issues.push({
+        severity: "error",
+        rule: "javascript-href",
+        message: "Link uses javascript: protocol",
+        href: href.slice(0, 100),
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (isPlaceholderHref(href)) {
+      issues.push({
+        severity: "warning",
+        rule: "placeholder-href",
+        message: "Link has a placeholder href (# or javascript:void)",
+        href,
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (category === "http") {
+      issues.push({
+        severity: "warning",
+        rule: "insecure-link",
+        message: "Link uses HTTP instead of HTTPS",
+        href: href.slice(0, 120),
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+    if (text && GENERIC_LINK_TEXT.has(text.toLowerCase())) {
+      issues.push({
+        severity: "warning",
+        rule: "generic-link-text",
+        message: `Link text "${text}" is vague \u2014 use descriptive text for accessibility and engagement`,
+        href: href.slice(0, 120),
+        text
+      });
+    }
+    if (!text && !$(el).attr("aria-label") && !$(el).find("img[alt]").length) {
+      issues.push({
+        severity: "error",
+        rule: "empty-link-text",
+        message: "Link has no visible text or aria-label",
+        href: href.slice(0, 120)
+      });
+    }
+    if (category === "mailto" && href.trim().toLowerCase() === "mailto:") {
+      issues.push({
+        severity: "error",
+        rule: "empty-mailto",
+        message: "mailto: link has no email address",
+        href,
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+    if (href.length > 2e3) {
+      issues.push({
+        severity: "info",
+        rule: "long-url",
+        message: "URL exceeds 2000 characters \u2014 may be truncated by some email clients",
+        href: href.slice(0, 120) + "...",
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+  });
+  return { totalLinks, issues, breakdown };
+}
+
+// src/accessibility-checker.ts
+import * as cheerio6 from "cheerio";
+var GENERIC_LINK_TEXT2 = /* @__PURE__ */ new Set([
+  "click here",
+  "here",
+  "read more",
+  "learn more",
+  "more",
+  "link",
+  "this link",
+  "click",
+  "tap here",
+  "this"
+]);
+function describeElement($, el) {
+  var _a;
+  const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) || "unknown";
+  const src = $(el).attr("src");
+  const href = $(el).attr("href");
+  if (src) return `<${tag} src="${src.slice(0, 60)}${src.length > 60 ? "..." : ""}">`;
+  if (href) return `<${tag} href="${href.slice(0, 60)}${href.length > 60 ? "..." : ""}">`;
+  const text = $(el).text().trim().slice(0, 40);
+  if (text) return `<${tag}>${text}${$(el).text().trim().length > 40 ? "..." : ""}</${tag}>`;
+  return `<${tag}>`;
+}
+function checkLangAttribute($) {
+  const lang = $("html").attr("lang");
+  if (!lang || !lang.trim()) {
+    return {
+      severity: "error",
+      rule: "missing-lang",
+      message: "Missing lang attribute on <html> element",
+      details: 'Screen readers use the lang attribute to determine pronunciation. Add lang="en" (or appropriate language code).'
+    };
+  }
+  return null;
+}
+function checkTitle($) {
+  const title = $("title").text().trim();
+  if (!title) {
+    return {
+      severity: "warning",
+      rule: "missing-title",
+      message: "Missing or empty <title> element",
+      details: "The <title> helps screen readers identify the email content."
+    };
+  }
+  return null;
+}
+function checkImageAlt($) {
+  const issues = [];
+  $("img").each((_, el) => {
+    const alt = $(el).attr("alt");
+    const src = $(el).attr("src") || "";
+    const role = $(el).attr("role");
+    if (role === "presentation" || role === "none") return;
+    if (alt === void 0) {
+      issues.push({
+        severity: "error",
+        rule: "img-missing-alt",
+        message: "Image missing alt attribute",
+        element: describeElement($, el),
+        details: 'Every image must have an alt attribute. Use alt="" for decorative images.'
+      });
+    } else if (alt.trim() === "") {
+      const isLikelyContent = !src.includes("spacer") && !src.includes("pixel") && !src.includes("tracking") && !src.includes("1x1") && !src.includes("transparent");
+      if (isLikelyContent && ($(el).attr("width") || "0") !== "1") {
+        issues.push({
+          severity: "info",
+          rule: "img-empty-alt",
+          message: "Image has empty alt text \u2014 verify it is decorative",
+          element: describeElement($, el),
+          details: "Empty alt is correct for decorative images, but content images need descriptive alt text."
+        });
+      }
+    } else if (/\.(png|jpg|jpeg|gif|svg|webp|bmp)$/i.test(alt)) {
+      issues.push({
+        severity: "error",
+        rule: "img-filename-alt",
+        message: "Image alt text is a filename, not a description",
+        element: describeElement($, el),
+        details: `Alt "${alt}" should describe the image content, not the file name.`
+      });
+    }
+  });
+  return issues;
+}
+function checkLinkAccessibility($) {
+  const issues = [];
+  $("a").each((_, el) => {
+    const text = $(el).text().trim().toLowerCase();
+    const ariaLabel = $(el).attr("aria-label");
+    const title = $(el).attr("title");
+    const imgAlt = $(el).find("img").attr("alt");
+    if (!text && !ariaLabel && !title && !imgAlt) {
+      issues.push({
+        severity: "error",
+        rule: "link-no-accessible-name",
+        message: "Link has no accessible name",
+        element: describeElement($, el),
+        details: "Links need visible text, aria-label, or an image with alt text."
+      });
+      return;
+    }
+    if (text && GENERIC_LINK_TEXT2.has(text) && !ariaLabel) {
+      issues.push({
+        severity: "warning",
+        rule: "link-generic-text",
+        message: `Link text "${$(el).text().trim()}" is not descriptive`,
+        element: describeElement($, el),
+        details: "Screen readers often list links out of context. Use text that describes the destination."
+      });
+    }
+  });
+  return issues;
+}
+function checkTableAccessibility($) {
+  const issues = [];
+  $("table").each((_, el) => {
+    const role = $(el).attr("role");
+    const hasHeaders = $(el).find("th").length > 0;
+    const looksLikeLayout = !hasHeaders;
+    if (looksLikeLayout && role !== "presentation" && role !== "none") {
+      const nestedTables = $(el).find("table").length;
+      if (nestedTables > 0 || $(el).find("td").length > 2) {
+        issues.push({
+          severity: "info",
+          rule: "table-missing-role",
+          message: 'Layout table missing role="presentation"',
+          element: `<table> with ${$(el).find("td").length} cells`,
+          details: `Add role="presentation" to tables used for layout so screen readers don't announce them as data tables.`
+        });
+      }
+    }
+  });
+  return issues;
+}
+function checkColorContrast($) {
+  const issues = [];
+  let smallTextCount = 0;
+  $("[style]").each((_, el) => {
+    const style = $(el).attr("style") || "";
+    const fontSizeMatch = style.match(/font-size\s*:\s*(\d+(?:\.\d+)?)(px|pt)/i);
+    if (fontSizeMatch) {
+      const size = parseFloat(fontSizeMatch[1]);
+      const unit = fontSizeMatch[2].toLowerCase();
+      const pxSize = unit === "pt" ? size * 1.333 : size;
+      if (pxSize < 10 && pxSize > 0) {
+        smallTextCount++;
+        if (smallTextCount <= 3) {
+          issues.push({
+            severity: "warning",
+            rule: "small-text",
+            message: `Very small text (${fontSizeMatch[0].trim()})`,
+            element: describeElement($, el),
+            details: "Text smaller than 10px is difficult to read, especially on mobile devices."
+          });
+        }
+      }
+    }
+  });
+  if (smallTextCount > 3) {
+    issues.push({
+      severity: "warning",
+      rule: "small-text-multiple",
+      message: `${smallTextCount} elements with text smaller than 10px`,
+      details: "Consider using a minimum font size of 12-14px for readability."
+    });
+  }
+  return issues;
+}
+function checkSemanticStructure($) {
+  const issues = [];
+  const headings = [];
+  $("h1, h2, h3, h4, h5, h6").each((_, el) => {
+    const level = parseInt(el.tagName.replace(/h/i, ""), 10);
+    headings.push({ level, text: $(el).text().trim().slice(0, 60) });
+  });
+  for (let i = 1; i < headings.length; i++) {
+    const gap = headings[i].level - headings[i - 1].level;
+    if (gap > 1) {
+      issues.push({
+        severity: "info",
+        rule: "heading-skip",
+        message: `Heading level skipped: h${headings[i - 1].level} to h${headings[i].level}`,
+        details: "Skipped heading levels can confuse screen readers. Use sequential heading levels."
+      });
+      break;
+    }
+  }
+  return issues;
+}
+function checkAccessibility(html) {
+  if (!html || !html.trim()) {
+    return { score: 100, issues: [] };
+  }
+  const $ = cheerio6.load(html);
+  const issues = [];
+  const langIssue = checkLangAttribute($);
+  if (langIssue) issues.push(langIssue);
+  const titleIssue = checkTitle($);
+  if (titleIssue) issues.push(titleIssue);
+  issues.push(...checkImageAlt($));
+  issues.push(...checkLinkAccessibility($));
+  issues.push(...checkTableAccessibility($));
+  issues.push(...checkColorContrast($));
+  issues.push(...checkSemanticStructure($));
+  let penalty = 0;
+  for (const issue of issues) {
+    switch (issue.severity) {
+      case "error":
+        penalty += 12;
+        break;
+      case "warning":
+        penalty += 6;
+        break;
+      case "info":
+        penalty += 2;
+        break;
+    }
+  }
+  const score = Math.max(0, 100 - penalty);
+  return { score, issues };
+}
+
+// src/image-analyzer.ts
+import * as cheerio7 from "cheerio";
+var DATA_URI_WARN_BYTES = 100 * 1024;
+var TOTAL_DATA_URI_WARN_BYTES = 500 * 1024;
+var HIGH_IMAGE_COUNT = 10;
+function estimateBase64Bytes(dataUri) {
+  const commaIdx = dataUri.indexOf(",");
+  if (commaIdx === -1) return 0;
+  const payload = dataUri.slice(commaIdx + 1);
+  return Math.floor(payload.length * 3 / 4);
+}
+function isTrackingPixel(el) {
+  const width = el.attr("width");
+  const height = el.attr("height");
+  const style = (el.attr("style") || "").toLowerCase();
+  if (width === "1" && height === "1") return true;
+  if (width === "0" || height === "0") return true;
+  if (style.includes("display:none") || style.includes("display: none") || style.includes("visibility:hidden") || style.includes("visibility: hidden")) {
+    return true;
+  }
+  if (/width\s*:\s*1px/.test(style) && /height\s*:\s*1px/.test(style)) {
+    return true;
+  }
+  return false;
+}
+function truncateSrc(src, max = 60) {
+  if (src.startsWith("data:")) {
+    const semi = src.indexOf(";");
+    return semi > 0 ? src.slice(0, semi + 1) + "base64,..." : "data:...";
+  }
+  return src.length > max ? src.slice(0, max - 3) + "..." : src;
+}
+function analyzeImages(html) {
+  if (!html || !html.trim()) {
+    return { total: 0, totalDataUriBytes: 0, issues: [], images: [] };
+  }
+  const $ = cheerio7.load(html);
+  const issues = [];
+  const images = [];
+  let totalDataUriBytes = 0;
+  $("img").each((_, el) => {
+    var _a, _b, _c;
+    const img = $(el);
+    const src = img.attr("src") || "";
+    const alt = (_a = img.attr("alt")) != null ? _a : null;
+    const width = (_b = img.attr("width")) != null ? _b : null;
+    const height = (_c = img.attr("height")) != null ? _c : null;
+    const style = (img.attr("style") || "").toLowerCase();
+    const imgIssues = [];
+    const tracking = isTrackingPixel(img);
+    let dataUriBytes = 0;
+    if (src.startsWith("data:")) {
+      dataUriBytes = estimateBase64Bytes(src);
+      totalDataUriBytes += dataUriBytes;
+    }
+    if (tracking) {
+      images.push({
+        src: truncateSrc(src),
+        alt,
+        width,
+        height,
+        isTrackingPixel: true,
+        dataUriBytes,
+        issues: ["tracking-pixel"]
+      });
+      return;
+    }
+    if (!width && !height) {
+      const hasStyleWidth = /width\s*:/.test(style);
+      const hasStyleHeight = /height\s*:/.test(style);
+      if (!hasStyleWidth && !hasStyleHeight) {
+        imgIssues.push("missing-dimensions");
+        issues.push({
+          rule: "missing-dimensions",
+          severity: "warning",
+          message: "Image missing width/height attributes \u2014 causes layout shifts and Outlook rendering issues.",
+          src: truncateSrc(src)
+        });
+      }
+    }
+    if (dataUriBytes > DATA_URI_WARN_BYTES) {
+      const kb = Math.round(dataUriBytes / 1024);
+      imgIssues.push("large-data-uri");
+      issues.push({
+        rule: "large-data-uri",
+        severity: "warning",
+        message: `Data URI is ${kb}KB \u2014 consider hosting the image externally to reduce email size.`,
+        src: truncateSrc(src)
+      });
+    }
+    if (alt === null) {
+      imgIssues.push("missing-alt");
+      issues.push({
+        rule: "missing-alt",
+        severity: "warning",
+        message: "Image missing alt attribute \u2014 hurts deliverability and accessibility.",
+        src: truncateSrc(src)
+      });
+    }
+    if (src.toLowerCase().endsWith(".webp") || src.includes("image/webp")) {
+      imgIssues.push("webp-format");
+      issues.push({
+        rule: "webp-format",
+        severity: "info",
+        message: "WebP format detected \u2014 not supported by all email clients. Consider PNG or JPEG.",
+        src: truncateSrc(src)
+      });
+    }
+    if (src.toLowerCase().endsWith(".svg") || src.includes("image/svg")) {
+      imgIssues.push("svg-format");
+      issues.push({
+        rule: "svg-format",
+        severity: "info",
+        message: "SVG format detected \u2014 not supported by most email clients. Use PNG instead.",
+        src: truncateSrc(src)
+      });
+    }
+    if (!style.includes("display:block") && !style.includes("display: block")) {
+      imgIssues.push("missing-display-block");
+      issues.push({
+        rule: "missing-display-block",
+        severity: "info",
+        message: "Image without display:block \u2014 may cause unwanted gaps in Outlook.",
+        src: truncateSrc(src)
+      });
+    }
+    images.push({
+      src: truncateSrc(src),
+      alt,
+      width,
+      height,
+      isTrackingPixel: false,
+      dataUriBytes,
+      issues: imgIssues
+    });
+  });
+  const nonTrackingImages = images.filter((i) => !i.isTrackingPixel);
+  if (nonTrackingImages.length > HIGH_IMAGE_COUNT) {
+    issues.push({
+      rule: "high-image-count",
+      severity: "info",
+      message: `Email contains ${nonTrackingImages.length} images \u2014 heavy emails may be clipped or load slowly.`
+    });
+  }
+  const trackingPixels = images.filter((i) => i.isTrackingPixel);
+  if (trackingPixels.length > 0) {
+    issues.push({
+      rule: "tracking-pixel",
+      severity: "info",
+      message: `${trackingPixels.length} tracking pixel${trackingPixels.length > 1 ? "s" : ""} detected.`
+    });
+  }
+  if (totalDataUriBytes > TOTAL_DATA_URI_WARN_BYTES) {
+    const kb = Math.round(totalDataUriBytes / 1024);
+    issues.push({
+      rule: "total-data-uri-size",
+      severity: "warning",
+      message: `Total data URI size is ${kb}KB \u2014 consider hosting images externally to reduce email size.`
+    });
+  }
+  return { total: images.length, totalDataUriBytes, issues, images };
+}
 export {
   AI_FIX_SYSTEM_PROMPT,
   EMAIL_CLIENTS,
   STRUCTURAL_FIX_PROPERTIES,
   analyzeEmail,
+  analyzeImages,
+  analyzeSpam,
+  checkAccessibility,
   diffResults,
   estimateAiFixTokens,
   generateAiFix,
@@ -3925,6 +4750,7 @@ export {
   heuristicTokenCount,
   simulateDarkMode,
   transformForAllClients,
-  transformForClient
+  transformForClient,
+  validateLinks
 };
 //# sourceMappingURL=index.js.map