pagyra-js 0.0.1

package/src/html/image-converter.ts

@@ -0,0 +1,200 @@
+// src/html/image-converter.ts
+
+import path from "node:path";
+import { type DomEl, type CssRuleEntry } from "./css/parse-css.js";
+import { LayoutNode } from "../dom/node.js";
+import { ComputedStyle } from "../css/style.js";
+import { computeStyleForElement } from "../css/compute-style.js";
+import { ImageService } from "../image/image-service.js";
+import { ImageStrategy } from "../layout/strategies/image.js";
+import type { ImageInfo } from "../image/types.js";
+import type { UnitParsers } from "../units/units.js";
+import { log } from "../logging/debug.js";
+import { decodeBase64ToUint8Array } from "../utils/base64.js";
+
+// The ConversionContext should be defined where it's used
+export interface ConversionContext {
+  resourceBaseDir: string;
+  assetRootDir: string;
+  units: UnitParsers;
+  rootFontSize: number;
+  environment?: import("../environment/environment.js").Environment;
+}
+
+export function resolveImageSource(src: string, context: ConversionContext): string {
+  const trimmed = src.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (/^data:/i.test(trimmed)) {
+    return trimmed;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol === "file:") {
+      return url.href;
+    }
+    return url.href;
+  } catch {
+    // Not an absolute URL, fall through to filesystem resolution
+  }
+  if (context.environment?.resolveLocal) {
+    return context.environment.resolveLocal(trimmed, context.resourceBaseDir || context.assetRootDir || undefined);
+  }
+  if (trimmed.startsWith("/")) {
+    const resolved = context.assetRootDir ? path.resolve(context.assetRootDir, `.${trimmed}`) : trimmed;
+    log('image-converter', 'debug', "resolveImageSource - resolving absolute path:", { src, trimmed, assetRootDir: context.assetRootDir, resolved });
+    return resolved;
+  }
+  if (path.isAbsolute(trimmed)) {
+    return trimmed;
+  }
+  return context.resourceBaseDir ? path.resolve(context.resourceBaseDir, trimmed) : trimmed;
+}
+
+function isHttpUrl(value: string): boolean {
+  return /^https?:\/\//i.test(value);
+}
+
+function parseHttpUrl(value?: string): URL | null {
+  if (!value) {
+    return null;
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      return url;
+    }
+  } catch {
+    // Ignore parse failures; only interested in HTTP(S) bases.
+  }
+  return null;
+}
+
+function collectAllowedOrigins(context: ConversionContext): URL[] {
+  const origins = new Map<string, URL>();
+  const candidates = [context.assetRootDir, context.resourceBaseDir];
+  for (const candidate of candidates) {
+    const parsed = parseHttpUrl(candidate);
+    if (parsed) {
+      const key = parsed.origin;
+      if (!origins.has(key)) {
+        origins.set(key, parsed);
+      }
+    }
+  }
+  return Array.from(origins.values());
+}
+
+export function canLoadHttpResource(url: string, context: ConversionContext): boolean {
+  if (!isHttpUrl(url)) {
+    return false;
+  }
+  try {
+    const target = new URL(url);
+    if (target.protocol !== "http:" && target.protocol !== "https:") {
+      return false;
+    }
+    const allowed = collectAllowedOrigins(context);
+    return allowed.some((origin) => origin.origin === target.origin);
+  } catch {
+    return false;
+  }
+}
+
+export async function convertImageElement(
+  element: DomEl,
+  cssRules: CssRuleEntry[],
+  parentStyle: ComputedStyle,
+  context: ConversionContext,
+): Promise<LayoutNode> {
+  const style = computeStyleForElement(element, cssRules, parentStyle, context.units, context.rootFontSize);
+  // SVG <image> elements commonly use 'href' or 'xlink:href'; HTML <img> uses 'src'.
+  const rawSrc = element.getAttribute("href") ?? element.getAttribute("xlink:href") ?? element.getAttribute("src") ?? "";
+  const srcAttr = rawSrc?.trim() ?? "";
+
+  const widthAttr = element.getAttribute("width");
+  const heightAttr = element.getAttribute("height");
+  const width = widthAttr ? Number.parseFloat(widthAttr) || undefined : undefined;
+  const height = heightAttr ? Number.parseFloat(heightAttr) || undefined : undefined;
+
+  if (!srcAttr) {
+    const placeholder = new LayoutNode(style, [], { tagName: "img" });
+    placeholder.intrinsicInlineSize = width ?? 100;
+    placeholder.intrinsicBlockSize = height ?? 100;
+    return placeholder;
+  }
+
+  const resolvedSrc = resolveImageSource(srcAttr, context);
+
+  let imageInfo: ImageInfo;
+  try {
+    const imageService = ImageService.getInstance(context.environment);
+    if (isHttpUrl(resolvedSrc) && !canLoadHttpResource(resolvedSrc, context)) {
+      throw new Error(`Remote images are not supported (${resolvedSrc})`);
+    }
+    if (resolvedSrc.startsWith("data:")) {
+      const match = resolvedSrc.match(/^data:image\/(.+);base64,(.+)$/);
+      if (!match) {
+        throw new Error("Invalid data URI");
+      }
+      const bytes = decodeBase64ToUint8Array(match[2]);
+      const copy = bytes.slice();
+      imageInfo = await imageService.decodeImage(copy.buffer, {
+        maxWidth: width,
+        maxHeight: height,
+      });
+    } else {
+      imageInfo = await imageService.loadImage(resolvedSrc, {
+        maxWidth: width,
+        maxHeight: height,
+      });
+    }
+
+    log("render-tree", "debug", "Image loaded successfully", {
+      src: srcAttr,
+      resolvedSrc,
+      width: imageInfo.width,
+      height: imageInfo.height,
+      format: imageInfo.format,
+    });
+  } catch (error) {
+    log("render-tree", "warn", `Failed to load image: ${srcAttr}. Using placeholder.`, {
+      resolvedSrc,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    const placeholder = new LayoutNode(style, [], { tagName: "img" });
+    placeholder.intrinsicInlineSize = width ?? 100;
+    placeholder.intrinsicBlockSize = height ?? 100;
+    return placeholder;
+  }
+
+  const layoutNode = new LayoutNode(style, [], {
+    tagName: "img",
+    customData: {
+      image: {
+        originalSrc: srcAttr,
+        resolvedSrc,
+        info: imageInfo,
+      },
+    },
+  });
+
+  layoutNode.intrinsicInlineSize = imageInfo.width;
+  layoutNode.intrinsicBlockSize = imageInfo.height;
+
+  ImageStrategy.processImage(layoutNode, imageInfo);
+
+  if (width && height) {
+    layoutNode.intrinsicInlineSize = width;
+    layoutNode.intrinsicBlockSize = height;
+  } else if (width) {
+    layoutNode.intrinsicInlineSize = width;
+    layoutNode.intrinsicBlockSize = Math.round((imageInfo.height / imageInfo.width) * width);
+  } else if (height) {
+    layoutNode.intrinsicBlockSize = height;
+    layoutNode.intrinsicInlineSize = Math.round((imageInfo.width / imageInfo.height) * height);
+  }
+
+  return layoutNode;
+}

package/src/html-to-pdf.ts

@@ -0,0 +1,410 @@
+// src/html-to-pdf.ts
+
+import { parseHTML } from "linkedom";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { type FontConfig } from "./types/fonts.js";
+import { configureDebug, log, type LogLevel } from "./logging/debug.js";
+import { parseCss } from "./html/css/parse-css.js";
+import { makeUnitParsers, type UnitCtx, pxToPt } from "./units/units.js";
+import { LayoutNode } from "./dom/node.js";
+import { ComputedStyle } from "./css/style.js";
+import { layoutTree } from "./layout/pipeline/layout-tree.js";
+import { buildRenderTree } from "./pdf/layout-tree-builder.js";
+import { renderPdf } from "./pdf/render.js";
+import { convertDomNode } from "./html/dom-converter.js";
+import { applyPageVerticalMarginsWithHf, offsetRenderTree } from "./render/offset.js";
+import { applyTextLayoutAdjustments } from "./pdf/utils/text-layout-adjuster.js";
+import { setViewportSize } from "./css/apply-declarations.js";
+import { type PageMarginsPx } from "./units/page-utils.js";
+import { computeStyleForElement } from "./css/compute-style.js";
+import type { HeaderFooterHTML } from "./pdf/types.js";
+import { FontEmbedder } from "./pdf/font/embedder.js";
+import { PdfDocument } from "./pdf/primitives/pdf-document.js";
+import { loadBuiltinFontConfig } from "./pdf/font/builtin-fonts.js";
+import { Display } from "./css/enums.js";
+import type { Environment } from "./environment/environment.js";
+import { NodeEnvironment } from "./environment/node-environment.js";
+import { decodeBase64ToUint8Array } from "./utils/base64.js";
+
+export interface RenderHtmlOptions {
+  html: string;
+  css: string;
+  viewportWidth: number;
+  viewportHeight: number;
+  pageWidth: number;
+  pageHeight: number;
+  margins: PageMarginsPx;
+  debug?: boolean;
+  debugLevel?: LogLevel;
+  debugCats?: string[];
+  fontConfig?: FontConfig;
+  resourceBaseDir?: string;
+  assetRootDir?: string;
+  headerFooter?: Partial<HeaderFooterHTML>;
+  /** Environment abstraction (Node/browser). Defaults to Node implementation. */
+  environment?: Environment;
+}
+
+export interface PreparedRender {
+  layoutRoot: LayoutNode;
+  renderTree: ReturnType<typeof buildRenderTree>;
+  pageSize: { widthPt: number; heightPt: number };
+  margins: PageMarginsPx;
+}
+
+export async function renderHtmlToPdf(options: RenderHtmlOptions): Promise<Uint8Array> {
+  const environment = options.environment ?? new NodeEnvironment(options.assetRootDir ?? options.resourceBaseDir);
+  const resolvedFontConfig = options.fontConfig ?? (await loadBuiltinFontConfig(environment));
+  const preparedOptions = resolvedFontConfig ? { ...options, fontConfig: resolvedFontConfig, environment } : { ...options, environment };
+  const prepared = await prepareHtmlRender(preparedOptions);
+  return renderPdf(prepared.renderTree, {
+    pageSize: prepared.pageSize,
+    fontConfig: resolvedFontConfig ?? undefined,
+    margins: prepared.margins,
+    environment,
+  });
+}
+
+export async function prepareHtmlRender(options: RenderHtmlOptions): Promise<PreparedRender> {
+  const { html, css, viewportWidth, viewportHeight, pageWidth, pageHeight, margins, debug = false, debugLevel, debugCats, headerFooter } =
+    options;
+  const normalizedHtml = normalizeHtmlInput(html);
+
+  setViewportSize(viewportWidth, viewportHeight);
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
+  const resourceBaseDir = options.resourceBaseDir ?? options.assetRootDir ?? "";
+  const assetRootDir = options.assetRootDir ?? resourceBaseDir;
+  const environment = options.environment ?? new NodeEnvironment(assetRootDir);
+
+  if (debugLevel || debugCats) {
+    configureDebug({ level: debugLevel ?? (debug ? "debug" : "info"), cats: debugCats });
+  }
+
+  const unitCtx: UnitCtx = { viewport: { width: viewportWidth, height: viewportHeight } };
+  const units = makeUnitParsers(unitCtx);
+
+  log('html-to-pdf', 'debug', `prepareHtmlRender - input html: ${html}`);
+  let { document } = parseHTML(normalizedHtml);
+  if (needsReparse(document)) {
+    document = parseHTML(wrapHtml(html)).document;
+  }
+  log('html-to-pdf', 'debug', `prepareHtmlRender - parsed document body: ${document.body?.innerHTML || 'no body'}`);
+  log('html-to-pdf', 'debug', `prepareHtmlRender - document.documentElement tagName: ${document.documentElement?.tagName}`);
+  log('html-to-pdf', 'debug', `prepareHtmlRender - document.documentElement innerHTML: ${document.documentElement?.innerHTML}`);
+  log('html-to-pdf', 'debug', `prepareHtmlRender - document children count: ${document.childNodes.length}`);
+  for (let i = 0; i < document.childNodes.length; i++) {
+    const child = document.childNodes[i];
+    log('html-to-pdf', 'debug', `prepareHtmlRender - document child ${i}: ${child.nodeType}, ${(child as any).tagName || 'text node'}`);
+  }
+  log("parse", "debug", "DOM parsed", { hasBody: !!document.body });
+
+  let mergedCss = css || "";
+  const styleTags = Array.from(document.querySelectorAll("style"));
+  for (const styleTag of styleTags) {
+    if (styleTag.textContent) mergedCss += "\n" + styleTag.textContent;
+  }
+  const linkTags = Array.from(document.querySelectorAll("link")).filter((link) => (link.getAttribute("rel") || "").toLowerCase() === "stylesheet");
+  for (const linkTag of linkTags) {
+    const href = linkTag.getAttribute("href");
+    if (!href) continue;
+    const cssText = await loadStylesheetFromHref(href, resourceBaseDir, assetRootDir, environment);
+    if (cssText) mergedCss += "\n" + cssText;
+  }
+  const { styleRules: cssRules, fontFaceRules } = parseCss(mergedCss);
+  log("parse", "debug", "CSS rules", { count: cssRules.length, fontFaces: fontFaceRules.length });
+
+  // Determine the root element to process - prefer body, but fall back to documentElement if body is empty
+  let rootElement = document.body;
+  let processChildrenOf = rootElement;
+
+  // If body is empty but documentElement has children (like when HTML is just a fragment),
+  // process the documentElement's children instead
+  if (rootElement && rootElement.childNodes.length === 0) {
+    // Check if documentElement has meaningful children
+    const meaningfulChildren = Array.from(document.documentElement.childNodes).filter(node => {
+      return node.nodeType === node.ELEMENT_NODE && (node as HTMLElement).tagName !== 'HEAD';
+    });
+    if (meaningfulChildren.length > 0) {
+      processChildrenOf = document.documentElement;
+    }
+  } else if (!rootElement) {
+    // If there's no body element, process documentElement children directly
+    processChildrenOf = document.documentElement;
+  }
+
+  const baseParentStyle = new ComputedStyle();
+  const htmlElement = document.documentElement;
+  const documentElementStyle = htmlElement
+    ? computeStyleForElement(htmlElement, cssRules, baseParentStyle, units, baseParentStyle.fontSize)
+    : baseParentStyle;
+  const rootFontSize = documentElementStyle.fontSize;
+
+  let rootStyle: ComputedStyle;
+  if (!processChildrenOf || processChildrenOf === htmlElement) {
+    rootStyle = documentElementStyle;
+  } else {
+    rootStyle = computeStyleForElement(processChildrenOf, cssRules, documentElementStyle, units, rootFontSize);
+  }
+  if (isInlineDisplay(rootStyle.display)) {
+    rootStyle.display = Display.Block;
+  }
+  const rootLayout = new LayoutNode(rootStyle, [], { tagName: processChildrenOf?.tagName?.toLowerCase() });
+
+  const conversionContext = { resourceBaseDir, assetRootDir, units, rootFontSize, environment };
+
+  if (processChildrenOf) {
+    log('html-to-pdf', 'debug', `prepareHtmlRender - processing children of: ${processChildrenOf.tagName}, count: ${processChildrenOf.childNodes.length}`);
+    for (const child of Array.from(processChildrenOf.childNodes)) {
+      log('html-to-pdf', 'debug', `prepareHtmlRender - processing child: ${(child as any).tagName || 'text node'}, type: ${child.nodeType}`);
+      // Skip head and other non-content elements
+      if (child.nodeType === child.ELEMENT_NODE) {
+        const tagName = (child as HTMLElement).tagName.toLowerCase();
+        if (tagName === 'head' || tagName === 'meta' || tagName === 'title' || tagName === 'link' || tagName === 'script') {
+          continue;
+        }
+      }
+      const layoutChild = await convertDomNode(child, cssRules, rootStyle, conversionContext);
+      if (layoutChild) rootLayout.appendChild(layoutChild);
+    }
+  }
+
+  const pdfDoc = new PdfDocument();
+
+  // Process @font-face rules
+  for (const fontFace of fontFaceRules) {
+    const fontFamily = fontFace.declarations['font-family']?.replace(/['"]/g, '');
+    const src = fontFace.declarations['src'];
+    if (fontFamily && src) {
+      const targetUrl = pickFontUrlFromSrc(src);
+      if (targetUrl && options.fontConfig) {
+        const fontData = await loadFontData(targetUrl, resourceBaseDir, assetRootDir, environment);
+        if (fontData) {
+          const weightStr = fontFace.declarations["font-weight"] || "400";
+          const styleStr = fontFace.declarations["font-style"] || "normal";
+          options.fontConfig.fontFaceDefs.push({
+            name: fontFamily,
+            family: fontFamily,
+            src: targetUrl,
+            data: fontData,
+            weight: parseFontWeight(weightStr),
+            style: normalizeFontStyle(styleStr),
+          });
+        }
+      }
+    }
+  }
+
+  // In a browser environment, the font data should be pre-loaded and passed in the fontConfig.
+  if (options.fontConfig) {
+    for (const face of options.fontConfig.fontFaceDefs) {
+      if (!face.data && face.src) {
+        const loaded = await loadFontData(face.src, resourceBaseDir, assetRootDir, environment);
+        if (loaded) {
+          (face as any).data = loaded;
+        }
+      }
+    }
+  }
+  const fontEmbedder = options.fontConfig ? new FontEmbedder(options.fontConfig, pdfDoc) : null;
+  if (fontEmbedder) {
+    await fontEmbedder.initialize();
+  }
+
+  layoutTree(rootLayout, { width: viewportWidth, height: viewportHeight }, fontEmbedder);
+  log("layout", "debug", "Layout complete");
+
+  const renderTree = buildRenderTree(rootLayout, { headerFooter });
+
+  // Global justification pass: fix inline run positions for text-align: justify
+  applyTextLayoutAdjustments(renderTree.root);
+
+  // Get header/footer heights for proper content positioning
+  const headerHeightPx = headerFooter?.maxHeaderHeightPx ?? 0;
+  const footerHeightPx = headerFooter?.maxFooterHeightPx ?? 0;
+
+  // Apply vertical margins with header/footer space reserved
+  // This pushes content below the header and reserves space for the footer
+  applyPageVerticalMarginsWithHf(renderTree.root, {
+    pageHeight,
+    margins,
+    headerHeightPx,
+    footerHeightPx,
+  });
+  offsetRenderTree(renderTree.root, margins.left, 0, debug);
+
+  const pageSize = { widthPt: pxToPt(pageWidth), heightPt: pxToPt(pageHeight) };
+  return { layoutRoot: rootLayout, renderTree, pageSize, margins };
+}
+
+async function loadStylesheetFromHref(href: string, resourceBaseDir: string, assetRootDir: string, environment: Environment): Promise<string> {
+  const trimmed = href.trim();
+  if (!trimmed) return "";
+
+  try {
+    if (/^https?:\/\//i.test(trimmed) || trimmed.startsWith("//")) {
+      const absoluteHref = trimmed.startsWith("//") ? `https:${trimmed}` : trimmed;
+      const response = await fetch(absoluteHref);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const cssText = await response.text();
+      return rewriteCssUrls(cssText, absoluteHref);
+    }
+
+    const cssPath = environment.resolveLocal ? environment.resolveLocal(trimmed, resourceBaseDir) : resolveLocalPath(trimmed, resourceBaseDir, assetRootDir);
+    const cssBuffer = await environment.loader.load(cssPath);
+    const cssText = new TextDecoder("utf-8").decode(cssBuffer);
+    const baseHref = /^https?:\/\//i.test(cssPath) || cssPath.startsWith("file:")
+      ? cssPath
+      : pathToFileURL(cssPath).toString();
+    return rewriteCssUrls(cssText, baseHref);
+  } catch (error) {
+    log("parse", "warn", "Failed to load stylesheet", { href, error: error instanceof Error ? error.message : String(error) });
+    return "";
+  }
+}
+
+function rewriteCssUrls(cssText: string, baseHref: string): string {
+  let base: URL;
+  try {
+    base = new URL(baseHref);
+  } catch {
+    return cssText;
+  }
+
+  const urlRegex = /url\(\s*(['"]?)([^'")]+)\1\s*\)/gi;
+  return cssText.replace(urlRegex, (match, quote: string, rawUrl: string) => {
+    const candidate = (rawUrl || "").trim();
+    if (!candidate || /^data:/i.test(candidate)) return match;
+    if (/^[a-z][a-z0-9+\-.]*:/i.test(candidate)) return match;
+    try {
+      const resolved = new URL(candidate, base).toString();
+      const q = quote || "";
+      return `url(${q}${resolved}${q})`;
+    } catch {
+      return match;
+    }
+  });
+}
+
+function pickFontUrlFromSrc(src: string): string | null {
+  const urlRegex = /url\(\s*(['"]?)([^'")]+)\1\s*\)(?:\s*format\(\s*['"]?([^'")]+)['"]?\s*\))?/gi;
+  let fallback: string | null = null;
+  let preferred: string | null = null;
+  let match: RegExpExecArray | null;
+
+  while ((match = urlRegex.exec(src)) !== null) {
+    const url = match[2];
+    const format = (match[3] || "").toLowerCase();
+    if (!fallback) fallback = url;
+    if (format === "woff2") {
+      preferred = url;
+      break;
+    }
+  }
+
+  return preferred ?? fallback;
+}
+
+function parseFontWeight(weightStr: string): number {
+  const normalized = weightStr.trim().toLowerCase();
+  if (normalized === "bold") return 700;
+  if (normalized === "normal") return 400;
+  const parsed = Number.parseInt(normalized, 10);
+  return Number.isFinite(parsed) ? parsed : 400;
+}
+
+function normalizeFontStyle(styleStr: string): "normal" | "italic" {
+  const normalized = styleStr.trim().toLowerCase();
+  return normalized.includes("italic") || normalized.includes("oblique") ? "italic" : "normal";
+}
+
+function resolveLocalPath(target: string, resourceBaseDir: string, assetRootDir: string): string {
+  let result = target;
+  if (result.startsWith("file://")) {
+    result = fileURLToPath(result);
+  } else if (result.startsWith("/")) {
+    result = path.resolve(assetRootDir, `.${result}`);
+  } else if (!path.isAbsolute(result)) {
+    result = path.resolve(resourceBaseDir, result);
+  }
+  return result;
+}
+
+async function loadFontData(src: string, resourceBaseDir: string, assetRootDir: string, environment: Environment): Promise<ArrayBuffer | null> {
+  const trimmed = src.trim();
+  if (!trimmed) return null;
+  let target = trimmed;
+
+  try {
+    if (target.startsWith("//")) {
+      target = `https:${target}`;
+    }
+
+    if (/^data:/i.test(target)) {
+      const commaIdx = target.indexOf(",");
+      if (commaIdx === -1) {
+        throw new Error("Invalid data URI");
+      }
+      const meta = target.slice(5, commaIdx);
+      if (!/;base64/i.test(meta)) {
+        throw new Error("Only base64-encoded data URIs are supported for fonts");
+      }
+      const data = decodeBase64ToUint8Array(target.slice(commaIdx + 1));
+      const copy = data.slice();
+      return copy.buffer;
+    }
+
+    if (/^https?:\/\//i.test(target)) {
+      const response = await fetch(target);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.arrayBuffer();
+    }
+
+    if (/^file:/i.test(target)) {
+      const localPath = fileURLToPath(target);
+      const fontDataBuffer = await environment.loader.load(localPath);
+      return fontDataBuffer;
+    }
+
+    const resolved = environment.resolveLocal ? environment.resolveLocal(target, resourceBaseDir) : resolveLocalPath(target, resourceBaseDir, assetRootDir);
+    const fontDataBuffer = await environment.loader.load(resolved);
+    return fontDataBuffer;
+  } catch (error) {
+    log("font", "warn", "Failed to load font data", { src, error: error instanceof Error ? error.message : String(error) });
+    return null;
+  }
+}
+
+function isInlineDisplay(display: Display): boolean {
+  return (
+    display === Display.Inline ||
+    display === Display.InlineBlock ||
+    display === Display.InlineFlex ||
+    display === Display.InlineGrid ||
+    display === Display.InlineTable
+  );
+}
+
+function normalizeHtmlInput(html: string): string {
+  const hasHtmlTag = /<\s*html[\s>]/i.test(html);
+  if (hasHtmlTag) {
+    return html;
+  }
+  return wrapHtml(html);
+}
+
+function wrapHtml(html: string): string {
+  return `<!doctype html><html><head></head><body>${html}</body></html>`;
+}
+
+function needsReparse(document: Document): boolean {
+  const docEl = document.documentElement?.tagName;
+  const docIsHtml = docEl?.toUpperCase() === "HTML";
+  if (!docIsHtml) return true;
+  if (!document.body) return true;
+  return false;
+}