@bendyline/squisq-formats 1.3.1 → 1.4.1

package/src/docx/import.ts

@@ -21,6 +21,7 @@
 
 import type { Doc } from '@bendyline/squisq/schemas';
 import { markdownToDoc } from '@bendyline/squisq/doc';
+import { stringifyMarkdown } from '@bendyline/squisq/markdown';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -49,8 +50,9 @@ import type {
 import { openPackage, getPartXml, getPartBinary, getPartRelationships } from '../ooxml/reader.js';
 import type { OoxmlPackage, Relationship } from '../ooxml/types.js';
 import { NS_WML, NS_R } from '../ooxml/namespaces.js';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
 import type { ContentContainer } from '@bendyline/squisq/storage';
+import { buildContainer } from '../shared/container.js';
+import { extToMime } from '../shared/images.js';
 import {
   HEADING_STYLE_MAP,
   QUOTE_STYLE_IDS,
@@ -140,35 +142,15 @@ export async function docxToContainer(
   const ctx = await buildImportContext(pkg, { ...options, extractImages: true });
 
   const documentXml = await getPartXml(pkg, 'word/document.xml');
-  if (!documentXml) {
-    const container = new MemoryContentContainer();
-    await container.writeDocument('');
-    return container;
-  }
+  if (!documentXml) return buildContainer('', []);
 
   const body = getFirstElement(documentXml, 'body');
-  if (!body) {
-    const container = new MemoryContentContainer();
-    await container.writeDocument('');
-    return container;
-  }
+  if (!body) return buildContainer('', []);
 
   const blocks = await convertBody(body, ctx);
   const markdownDoc: MarkdownDocument = { type: 'document', children: blocks };
 
-  // Serialize to markdown
-  const { stringifyMarkdown } = await import('@bendyline/squisq/markdown');
-  const markdown = stringifyMarkdown(markdownDoc);
-
-  // Build container with markdown + images
-  const container = new MemoryContentContainer();
-  await container.writeDocument(markdown);
-
-  for (const [path, { data: imageData, mimeType }] of ctx.extractedImages) {
-    await container.writeFile(path, new Uint8Array(imageData), mimeType);
-  }
-
-  return container;
+  return buildContainer(stringifyMarkdown(markdownDoc), ctx.extractedImages);
 }
 
 // ============================================
@@ -631,7 +613,7 @@ async function extractImage(el: Element, ctx: ImportContext): Promise<MarkdownIm
   // Determine extension and MIME type
   const dot = target.lastIndexOf('.');
   const ext = dot !== -1 ? target.slice(dot).toLowerCase() : '.png';
-  const mimeType = IMAGE_MIME_MAP[ext] ?? 'application/octet-stream';
+  const mimeType = extToMime(ext);
 
   // Generate a unique image path
   ctx.imageCounter++;
@@ -651,20 +633,6 @@ async function extractImage(el: Element, ctx: ImportContext): Promise<MarkdownIm
   };
 }
 
-const IMAGE_MIME_MAP: Record<string, string> = {
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.gif': 'image/gif',
-  '.bmp': 'image/bmp',
-  '.tiff': 'image/tiff',
-  '.tif': 'image/tiff',
-  '.svg': 'image/svg+xml',
-  '.webp': 'image/webp',
-  '.emf': 'image/emf',
-  '.wmf': 'image/wmf',
-};
-
 /** Recursively find the first descendant element with the given local name. */
 function findDescendant(el: Element, localName: string): Element | null {
   for (const child of Array.from(el.children)) {

package/src/epub/export.ts

@@ -23,7 +23,8 @@
 
 import JSZip from 'jszip';
 import type { Doc, AudioSegment } from '@bendyline/squisq/schemas';
-import { resolveTheme, resolveFontFamily } from '@bendyline/squisq/schemas';
+import { resolveFontFamily } from '@bendyline/squisq/schemas';
+import { resolveThemeForDoc } from '@bendyline/squisq/doc';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -35,8 +36,10 @@ import type {
   MarkdownTableRow,
   MarkdownTableCell,
 } from '@bendyline/squisq/markdown';
+import { readFrontmatterThemeId } from '@bendyline/squisq/markdown';
 import { escapeXml } from '../ooxml/xmlUtils.js';
 import { inferMimeType, extractFilename } from '../html/imageUtils.js';
+import { extractPlainText } from '../shared/text.js';
 
 // ── Public API ────────────────────────────────────────────────────
 
@@ -119,8 +122,9 @@ export async function markdownDocToEpub(
     }
   }
 
-  // Generate theme CSS
-  const css = generateStylesheet(options.themeId);
+  // Generate theme CSS — honor an explicit themeId, else the doc's frontmatter
+  // theme (`squisq-theme` / legacy), mirroring the other export formats.
+  const css = generateStylesheet(options.themeId ?? readFrontmatterThemeId(doc.frontmatter), doc);
 
   // Build the ZIP
   const zip = new JSZip();
@@ -360,28 +364,7 @@ function splitIntoChapters(nodes: MarkdownBlockNode[]): Chapter[] {
 }
 
 function extractHeadingText(heading: MarkdownHeading): string {
-  return heading.children.map(inlineToText).join('');
-}
-
-function inlineToText(node: MarkdownInlineNode): string {
-  switch (node.type) {
-    case 'text':
-      return node.value;
-    case 'emphasis':
-    case 'strong':
-    case 'delete':
-      return node.children.map(inlineToText).join('');
-    case 'inlineCode':
-      return node.value;
-    case 'link':
-      return node.children.map(inlineToText).join('');
-    case 'image':
-      return node.alt ?? '';
-    case 'break':
-      return ' ';
-    default:
-      return '';
-  }
+  return extractPlainText(heading.children);
 }
 
 // ── Image Collection ──────────────────────────────────────────────
@@ -795,10 +778,10 @@ ${navItems}
 
 // ── Stylesheet ────────────────────────────────────────────────────
 
-function generateStylesheet(themeId?: string): string {
+function generateStylesheet(themeId: string | undefined, doc?: MarkdownDocument): string {
   let themeVars = '';
   if (themeId) {
-    const theme = resolveTheme(themeId);
+    const theme = resolveThemeForDoc(doc, themeId);
     themeVars = `
   --epub-bg: ${theme.colors.background};
   --epub-text: ${theme.colors.text};

package/src/html/imageUtils.ts

@@ -5,31 +5,17 @@
  * and inferring MIME types from filenames.
  */
 
-/** Map of file extensions to MIME types */
-const MIME_MAP: Record<string, string> = {
-  jpg: 'image/jpeg',
-  jpeg: 'image/jpeg',
-  png: 'image/png',
-  gif: 'image/gif',
-  webp: 'image/webp',
-  svg: 'image/svg+xml',
-  ico: 'image/x-icon',
-  bmp: 'image/bmp',
-  avif: 'image/avif',
-  mp3: 'audio/mpeg',
-  wav: 'audio/wav',
-  ogg: 'audio/ogg',
-  mp4: 'video/mp4',
-  webm: 'video/webm',
-};
+import { extToMime } from '../shared/images.js';
 
 /**
  * Infer a MIME type from a filename's extension.
  * Returns 'application/octet-stream' for unknown types.
+ *
+ * Thin wrapper over the shared {@link extToMime} map so html export, docx
+ * import, and pptx import all agree on extension → MIME.
  */
 export function inferMimeType(filename: string): string {
-  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
-  return MIME_MAP[ext] ?? 'application/octet-stream';
+  return extToMime(filename.split('.').pop() ?? '');
 }
 
 /**

package/src/html/import.ts

@@ -0,0 +1,297 @@
+/**
+ * HTML Import Module — @bendyline/squisq-formats/html
+ *
+ * Converts an HTML document (or fragment) into a squisq `MarkdownDocument`.
+ * Built on the existing `parseHtmlToNodes` (parse5-backed) + `sanitizeHtmlNodes`
+ * from `@bendyline/squisq/markdown`, so no new dependency is introduced.
+ *
+ * The primary consumer is email: HTML mail bodies are hostile input, so the
+ * parse is sanitized by default (scripts/styles/event handlers/dangerous URLs
+ * stripped) before the tree is walked into markdown nodes.
+ *
+ * Two entry points mirror the docx/pdf importers:
+ *   - `htmlToMarkdownDoc(data, options?)` → `MarkdownDocument`
+ *   - `htmlToMarkdown(html, options?)` → markdown string (convenience for the
+ *     string-in/string-out path email body conversion needs)
+ */
+
+import {
+  type MarkdownBlockNode,
+  type MarkdownDocument,
+  type MarkdownInlineNode,
+  type MarkdownListItem,
+  type MarkdownTableCell,
+  type MarkdownTableRow,
+  type HtmlElement,
+  type HtmlNode,
+  parseHtmlToNodes,
+  sanitizeHtmlNodes,
+  stringifyMarkdown,
+} from '@bendyline/squisq/markdown';
+
+export interface HtmlImportOptions {
+  /**
+   * Strip scripts / styles / event handlers / dangerous URLs before walking
+   * the tree. Default `true` — HTML email is untrusted; only disable for
+   * trusted input where you want raw fidelity.
+   */
+  sanitize?: boolean;
+}
+
+// ── tag classification ──────────────────────────────────────────────
+
+const HEADINGS: Record<string, 1 | 2 | 3 | 4 | 5 | 6> = {
+  h1: 1,
+  h2: 2,
+  h3: 3,
+  h4: 4,
+  h5: 5,
+  h6: 6,
+};
+
+// Containers with no semantic block meaning — unwrap and walk their children.
+const TRANSPARENT_BLOCK = new Set([
+  'div',
+  'section',
+  'article',
+  'header',
+  'footer',
+  'main',
+  'aside',
+  'nav',
+  'figure',
+  'figcaption',
+  'form',
+  'fieldset',
+  'body',
+  'html',
+  'center',
+]);
+
+// Elements that carry no content we want (and whose text must not leak).
+const DROP = new Set(['script', 'style', 'head', 'title', 'noscript', 'template', 'svg']);
+
+const INLINE_STRONG = new Set(['strong', 'b']);
+const INLINE_EM = new Set(['em', 'i']);
+const INLINE_DEL = new Set(['del', 's', 'strike']);
+const INLINE_TRANSPARENT = new Set(['span', 'font', 'abbr', 'mark', 'small', 'sub', 'sup', 'u']);
+
+const isElement = (n: HtmlNode): n is HtmlElement => n.type === 'htmlElement';
+const isText = (n: HtmlNode): n is { type: 'htmlText'; value: string } => n.type === 'htmlText';
+
+const collapseWs = (s: string): string => s.replace(/\s+/g, ' ');
+
+// ── inline conversion ───────────────────────────────────────────────
+
+function inlinesFromNodes(nodes: HtmlNode[]): MarkdownInlineNode[] {
+  const out: MarkdownInlineNode[] = [];
+  for (const node of nodes) {
+    if (isText(node)) {
+      const value = collapseWs(node.value);
+      if (value) out.push({ type: 'text', value });
+      continue;
+    }
+    if (!isElement(node)) continue; // comment
+    const tag = node.tagName.toLowerCase();
+    if (DROP.has(tag)) continue;
+
+    if (tag === 'br') {
+      out.push({ type: 'break' });
+    } else if (INLINE_STRONG.has(tag)) {
+      out.push({ type: 'strong', children: inlinesFromNodes(node.children) });
+    } else if (INLINE_EM.has(tag)) {
+      out.push({ type: 'emphasis', children: inlinesFromNodes(node.children) });
+    } else if (INLINE_DEL.has(tag)) {
+      out.push({ type: 'delete', children: inlinesFromNodes(node.children) });
+    } else if (tag === 'code' || tag === 'kbd' || tag === 'samp' || tag === 'tt') {
+      out.push({ type: 'inlineCode', value: textContent(node) });
+    } else if (tag === 'a') {
+      const url = node.attributes.href ?? '';
+      const children = inlinesFromNodes(node.children);
+      out.push({
+        type: 'link',
+        url,
+        children: children.length > 0 ? children : [{ type: 'text', value: url }],
+      });
+    } else if (tag === 'img') {
+      const url = node.attributes.src ?? '';
+      const alt = node.attributes.alt;
+      if (url) out.push({ type: 'image', url, ...(alt ? { alt } : {}) });
+    } else {
+      // Unknown / transparent inline (span, font, …): flatten children.
+      out.push(...inlinesFromNodes(node.children));
+    }
+  }
+  return out;
+}
+
+/** Flatten an element's descendant text (for code blocks / inline code). */
+function textContent(node: HtmlNode): string {
+  if (isText(node)) return node.value;
+  if (isElement(node)) return node.children.map(textContent).join('');
+  return '';
+}
+
+const onlyWhitespace = (inlines: MarkdownInlineNode[]): boolean =>
+  inlines.every((n) => n.type === 'text' && n.value.trim() === '');
+
+// ── block conversion ────────────────────────────────────────────────
+
+function blocksFromNodes(nodes: HtmlNode[]): MarkdownBlockNode[] {
+  const out: MarkdownBlockNode[] = [];
+  let inlineBuffer: HtmlNode[] = [];
+
+  const flush = () => {
+    if (inlineBuffer.length === 0) return;
+    const inlines = inlinesFromNodes(inlineBuffer);
+    inlineBuffer = [];
+    if (inlines.length > 0 && !onlyWhitespace(inlines)) {
+      out.push({ type: 'paragraph', children: inlines });
+    }
+  };
+
+  for (const node of nodes) {
+    if (isText(node)) {
+      inlineBuffer.push(node);
+      continue;
+    }
+    if (!isElement(node)) continue;
+    const tag = node.tagName.toLowerCase();
+    if (DROP.has(tag)) continue;
+
+    const block = blockForElement(node, tag);
+    if (block === 'inline') {
+      inlineBuffer.push(node);
+    } else if (block) {
+      flush();
+      out.push(...block);
+    }
+  }
+  flush();
+  return out;
+}
+
+/** Returns the block node(s) for a block element, `'inline'` for inline ones. */
+function blockForElement(node: HtmlElement, tag: string): MarkdownBlockNode[] | 'inline' | null {
+  if (tag in HEADINGS) {
+    const children = inlinesFromNodes(node.children);
+    return [{ type: 'heading', depth: HEADINGS[tag]!, children }];
+  }
+  if (tag === 'p') {
+    const children = inlinesFromNodes(node.children);
+    return children.length > 0 && !onlyWhitespace(children)
+      ? [{ type: 'paragraph', children }]
+      : [];
+  }
+  if (tag === 'br') return 'inline';
+  if (tag === 'hr') return [{ type: 'thematicBreak' }];
+  if (tag === 'blockquote') {
+    return [{ type: 'blockquote', children: blocksFromNodes(node.children) }];
+  }
+  if (tag === 'pre') {
+    return [{ type: 'code', value: stripTrailingNewline(textContent(node)) }];
+  }
+  if (tag === 'ul' || tag === 'ol') {
+    return [listFromElement(node, tag === 'ol')];
+  }
+  if (tag === 'table') {
+    const table = tableFromElement(node);
+    return table ? [table] : [];
+  }
+  if (TRANSPARENT_BLOCK.has(tag)) {
+    return blocksFromNodes(node.children);
+  }
+  if (
+    INLINE_STRONG.has(tag) ||
+    INLINE_EM.has(tag) ||
+    INLINE_DEL.has(tag) ||
+    INLINE_TRANSPARENT.has(tag) ||
+    tag === 'a' ||
+    tag === 'img' ||
+    tag === 'code' ||
+    tag === 'kbd' ||
+    tag === 'samp'
+  ) {
+    return 'inline';
+  }
+  // Unknown element: treat as a transparent container so its content survives.
+  return blocksFromNodes(node.children);
+}
+
+function listFromElement(node: HtmlElement, ordered: boolean): MarkdownBlockNode {
+  const items: MarkdownListItem[] = [];
+  for (const child of node.children) {
+    if (isElement(child) && child.tagName.toLowerCase() === 'li') {
+      const blocks = blocksFromNodes(child.children);
+      items.push({ type: 'listItem', children: blocks });
+    }
+  }
+  const startAttr = node.attributes.start;
+  const start = ordered && startAttr ? Number.parseInt(startAttr, 10) : undefined;
+  return {
+    type: 'list',
+    ordered,
+    ...(start !== undefined && Number.isFinite(start) ? { start } : {}),
+    children: items,
+  };
+}
+
+function tableFromElement(node: HtmlElement): MarkdownBlockNode | null {
+  const rows: MarkdownTableRow[] = [];
+  const collectRows = (n: HtmlElement) => {
+    for (const child of n.children) {
+      if (!isElement(child)) continue;
+      const t = child.tagName.toLowerCase();
+      if (t === 'tr') {
+        const cells: MarkdownTableCell[] = [];
+        for (const cell of child.children) {
+          if (
+            isElement(cell) &&
+            (cell.tagName.toLowerCase() === 'td' || cell.tagName.toLowerCase() === 'th')
+          ) {
+            cells.push({ type: 'tableCell', children: inlinesFromNodes(cell.children) });
+          }
+        }
+        if (cells.length > 0) rows.push({ type: 'tableRow', children: cells });
+      } else if (t === 'thead' || t === 'tbody' || t === 'tfoot') {
+        collectRows(child);
+      }
+    }
+  };
+  collectRows(node);
+  if (rows.length === 0) return null;
+  return { type: 'table', children: rows };
+}
+
+const stripTrailingNewline = (s: string): string => s.replace(/\n+$/, '');
+
+// ── public API ──────────────────────────────────────────────────────
+
+function toHtmlString(data: ArrayBuffer | Uint8Array | string): string {
+  if (typeof data === 'string') return data;
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  return new TextDecoder('utf-8').decode(bytes);
+}
+
+/** Parse HTML into a squisq `MarkdownDocument`. */
+export function htmlToMarkdownDocSync(
+  html: string,
+  options: HtmlImportOptions = {},
+): MarkdownDocument {
+  let nodes = parseHtmlToNodes(html);
+  if (options.sanitize !== false) nodes = sanitizeHtmlNodes(nodes);
+  return { type: 'document', children: blocksFromNodes(nodes) };
+}
+
+/** Async, ArrayBuffer-accepting entry mirroring docx/pdf importers. */
+export async function htmlToMarkdownDoc(
+  data: ArrayBuffer | Uint8Array | string,
+  options: HtmlImportOptions = {},
+): Promise<MarkdownDocument> {
+  return htmlToMarkdownDocSync(toHtmlString(data), options);
+}
+
+/** Convenience string→string conversion (used for email HTML bodies). */
+export function htmlToMarkdown(html: string, options: HtmlImportOptions = {}): string {
+  return stringifyMarkdown(htmlToMarkdownDocSync(html, options));
+}

package/src/html/index.ts

@@ -195,3 +195,7 @@ export { markdownDocsToPlainHtmlBundle, collectLinkRefs } from './plainHtmlBundl
 export type { PlainHtmlBundleOptions } from './plainHtmlBundle.js';
 export { markdownDocsToHtmlBundle } from './docsHtmlBundle.js';
 export type { HtmlBundleOptions } from './docsHtmlBundle.js';
+
+// ── Import (HTML → MarkdownDocument) ────────────────────────────────
+export { htmlToMarkdown, htmlToMarkdownDoc, htmlToMarkdownDocSync } from './import.js';
+export type { HtmlImportOptions } from './import.js';

package/src/html/plainHtml.ts

@@ -14,9 +14,18 @@
  * blob URLs (live preview) or data URIs (single-file export).
  */
 
-import type { MarkdownDocument, MarkdownNode, HtmlNode } from '@bendyline/squisq/markdown';
+import {
+  sanitizeHtmlNodes,
+  sanitizeUrl,
+  type HtmlPolicy,
+  type MarkdownDocument,
+  type MarkdownNode,
+  type HtmlNode,
+  readFrontmatterThemeId,
+} from '@bendyline/squisq/markdown';
 import type { Theme } from '@bendyline/squisq/schemas';
-import { resolveFontFamily, buildGoogleFontsUrl, resolveTheme } from '@bendyline/squisq/schemas';
+import { resolveFontFamily, buildGoogleFontsUrl } from '@bendyline/squisq/schemas';
+import { resolveThemeForDoc } from '@bendyline/squisq/doc';
 
 // ── Public Types ───────────────────────────────────────────────────
 
@@ -71,6 +80,11 @@ export interface PlainHtmlExportOptions {
    * option is not provided.
    */
   iconsCss?: string;
+  /**
+   * Raw HTML policy. Defaults to `sanitize`, which removes unsafe tags,
+   * event handlers, and executable URL schemes before emitting HTML.
+   */
+  htmlPolicy?: HtmlPolicy;
 }
 
 /**
@@ -81,6 +95,7 @@ export interface PlainHtmlExportOptions {
 interface RenderCtx {
   images?: Map<string, string>;
   links?: Map<string, string>;
+  htmlPolicy: HtmlPolicy;
 }
 
 // ── Public API ─────────────────────────────────────────────────────
@@ -97,19 +112,20 @@ export function markdownDocToPlainHtml(
   doc: MarkdownDocument,
   options: PlainHtmlExportOptions = {},
 ): string {
-  const { title = 'Document', images, links, themeId, iconsCss } = options;
+  const { title = 'Document', images, links, themeId, iconsCss, htmlPolicy = 'sanitize' } = options;
   // Fall back chain for theme: explicit `theme` → explicit `themeId`
   // option → doc frontmatter `themeId`. Hosts whose export dialog
   // tracks themes by id can pass `themeId` straight through; authored
   // docs with `themeId: warm-earth` in frontmatter get styled
   // automatically when neither is supplied.
-  const theme =
-    options.theme ??
-    (themeId ? resolveTheme(themeId) : undefined) ??
-    (typeof doc.frontmatter?.themeId === 'string'
-      ? resolveTheme(doc.frontmatter.themeId)
-      : undefined);
-  const ctx: RenderCtx = { images, links };
+  // Resolution is doc-scoped via `resolveThemeForDoc`, so an inline
+  // `squisq-custom-themes` id resolves here with no global registration —
+  // and `readFrontmatterThemeId` picks up the editor's canonical
+  // `squisq-theme` key. Stays undefined when nothing selects a theme so
+  // un-themed exports render unstyled (unchanged behavior).
+  const resolveId = themeId ?? readFrontmatterThemeId(doc.frontmatter);
+  const theme = options.theme ?? (resolveId ? resolveThemeForDoc(doc, resolveId) : undefined);
+  const ctx: RenderCtx = { images, links, htmlPolicy };
   const body = renderTopLevel(doc.children, ctx);
   const fontsLink = theme ? renderFontsLink(theme) : '';
   // Resolve how to load FontAwesome — only when the doc actually uses
@@ -258,7 +274,9 @@ interface FeaturedImage {
 
 function renderFeatureImage(img: FeaturedImage, ctx: RenderCtx | undefined): string {
   const resolved = ctx?.images?.get(img.src) ?? img.src;
-  const attrs = [`src="${escapeAttr(resolved)}"`, `alt="${escapeAttr(img.alt)}"`];
+  const safeSrc = sanitizeUrl(resolved, 'media');
+  if (!safeSrc) return '<div class="squisq-feature__media squisq-feature__media--empty"></div>';
+  const attrs = [`src="${escapeAttr(safeSrc)}"`, `alt="${escapeAttr(img.alt)}"`];
   // Emit `width` / `height` attributes only when the source HTML had
   // them. The CSS rules then know to honor those values rather than
   // stretching the image to fill the column.
@@ -604,12 +622,16 @@ function nodeToHtml(node: MarkdownNode | undefined | null, ctx?: RenderCtx): str
     case 'link': {
       const original = node.url ?? '';
       const rewritten = ctx?.links?.get(original) ?? original;
-      return `<a href="${escapeAttr(rewritten)}">${childrenToHtml(node, ctx)}</a>`;
+      const safeHref = sanitizeUrl(rewritten, 'link');
+      if (!safeHref) return childrenToHtml(node, ctx);
+      return `<a href="${escapeAttr(safeHref)}">${childrenToHtml(node, ctx)}</a>`;
     }
     case 'image': {
       const original = node.url ?? '';
       const resolved = ctx?.images?.get(original) ?? original;
-      return `<img src="${escapeAttr(resolved)}" alt="${escapeAttr(node.alt ?? '')}" />`;
+      const safeSrc = sanitizeUrl(resolved, 'media');
+      if (!safeSrc) return escapeHtml(node.alt ?? '');
+      return `<img src="${escapeAttr(safeSrc)}" alt="${escapeAttr(node.alt ?? '')}" />`;
     }
     case 'thematicBreak':
       return '<hr />';
@@ -626,11 +648,12 @@ function nodeToHtml(node: MarkdownNode | undefined | null, ctx?: RenderCtx): str
     }
     case 'htmlBlock':
     case 'htmlInline':
+      if (resolveHtmlPolicy(ctx) === 'strip') return '';
       // Resized images and other authored HTML survive the round-trip
       // as parsed `htmlChildren` — rewriting `<img src>` through the
       // image map keeps the preview consistent with the markdown-image
       // path. Other tags pass through unmodified.
-      return htmlChildrenToHtml(node.htmlChildren, ctx);
+      return htmlChildrenToHtml(resolveHtmlNodes(node.htmlChildren, ctx), ctx);
     default: {
       // Unknown / unhandled node — recurse into children if any so we
       // don't drop content (e.g. directives, footnotes).
@@ -682,18 +705,28 @@ function tableToHtml(
   return parts.join('');
 }
 
+function resolveHtmlPolicy(ctx: RenderCtx | undefined): HtmlPolicy {
+  return ctx?.htmlPolicy ?? 'sanitize';
+}
+
+function resolveHtmlNodes(nodes: HtmlNode[] | undefined, ctx: RenderCtx | undefined): HtmlNode[] {
+  if (!nodes || nodes.length === 0) return [];
+  return resolveHtmlPolicy(ctx) === 'trusted' ? nodes : sanitizeHtmlNodes(nodes);
+}
+
 function htmlChildrenToHtml(nodes: HtmlNode[] | undefined, ctx?: RenderCtx): string {
   if (!nodes || nodes.length === 0) return '';
+  const trusted = resolveHtmlPolicy(ctx) === 'trusted';
   const out: string[] = [];
   for (const node of nodes) {
     if (node.type === 'htmlText') {
       // HtmlText already represents authored HTML — emit verbatim so
       // entity references the user wrote (e.g. `&amp;`) survive.
-      out.push(node.value);
+      out.push(trusted ? node.value : escapeHtml(node.value));
       continue;
     }
     if (node.type === 'htmlComment') {
-      out.push(`<!--${node.value}-->`);
+      if (trusted) out.push(`<!--${node.value}-->`);
       continue;
     }
     // htmlElement
@@ -713,6 +746,23 @@ function htmlChildrenToHtml(nodes: HtmlNode[] | undefined, ctx?: RenderCtx): str
     if ((tag === 'video' || tag === 'audio') && typeof attrs.poster === 'string') {
       attrs.poster = ctx?.images?.get(attrs.poster) ?? attrs.poster;
     }
+    if (!trusted) {
+      if (typeof attrs.src === 'string') {
+        const safeSrc = sanitizeUrl(attrs.src, 'media');
+        if (!safeSrc) delete attrs.src;
+        else attrs.src = safeSrc;
+      }
+      if (typeof attrs.poster === 'string') {
+        const safePoster = sanitizeUrl(attrs.poster, 'media');
+        if (!safePoster) delete attrs.poster;
+        else attrs.poster = safePoster;
+      }
+      if (typeof attrs.href === 'string') {
+        const safeHref = sanitizeUrl(attrs.href, 'link');
+        if (!safeHref) delete attrs.href;
+        else attrs.href = safeHref;
+      }
+    }
     const attrStr = Object.entries(attrs)
       .map(([k, v]) => ` ${k}="${escapeAttr(v)}"`)
       .join('');