smooth-screenshot 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1285 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+
+// src/options.ts
+var DEFAULT_QUALITY = 0.92;
+var DEFAULT_FRAME_BUDGET_MS = 5;
+var DEFAULT_WORKER_COUNT = 2;
+var DEFAULT_FETCH_TIMEOUT_MS = 3e4;
+var DEFAULT_FETCH_RETRIES = 2;
+function resolveWorkerCount(worker) {
+  if (worker === false) return 0;
+  if (worker === true || worker === void 0) return DEFAULT_WORKER_COUNT;
+  return Math.max(0, Math.floor(worker.count));
+}
+function resolveOptions(options, win) {
+  const scale = options.scale ?? options.pixelRatio ?? win.devicePixelRatio ?? 1;
+  return {
+    type: options.type ?? "png",
+    quality: options.quality ?? DEFAULT_QUALITY,
+    scale: scale > 0 ? scale : 1,
+    backgroundColor: options.backgroundColor ?? null,
+    width: options.width ?? null,
+    height: options.height ?? null,
+    crop: options.crop ?? null,
+    signal: options.signal,
+    onProgress: options.onProgress ?? null,
+    frameBudgetMs: options.frameBudgetMs ?? DEFAULT_FRAME_BUDGET_MS,
+    workerCount: resolveWorkerCount(options.worker),
+    maxTileSize: options.maxTileSize ?? 0,
+    filter: options.filter ?? null,
+    fontsSkip: options.fonts?.skip ?? false,
+    fontsPreferWoff2: options.fonts?.preferWoff2 ?? true,
+    fetchRequestInit: options.fetch?.requestInit,
+    fetchPlaceholder: options.fetch?.placeholder ?? null,
+    fetchTimeoutMs: options.fetch?.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS,
+    fetchRetries: options.fetch?.retries ?? DEFAULT_FETCH_RETRIES,
+    onResourceError: options.onResourceError ?? null
+  };
+}
+
+// src/errors.ts
+var SmoothScreenshotError = class _SmoothScreenshotError extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    __publicField(this, "code");
+    this.name = "SmoothScreenshotError";
+    this.code = code;
+    Object.setPrototypeOf(this, _SmoothScreenshotError.prototype);
+  }
+};
+function createAbortError() {
+  return new DOMException("The screenshot was aborted.", "AbortError");
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
+// src/scheduler.ts
+function createScheduler(budgetMs, signal) {
+  let sliceStart = performance.now();
+  const channel = new MessageChannel();
+  const pending = [];
+  channel.port1.onmessage = () => {
+    pending.shift()?.();
+  };
+  function macrotask() {
+    return new Promise((resolve) => {
+      pending.push(resolve);
+      channel.port2.postMessage(void 0);
+    });
+  }
+  function abortGuard() {
+    if (signal?.aborted) throw createAbortError();
+  }
+  const scheduler = {
+    async yieldNow() {
+      await macrotask();
+      sliceStart = performance.now();
+      abortGuard();
+    },
+    async yieldIfNeeded() {
+      if (performance.now() - sliceStart >= budgetMs) {
+        await scheduler.yieldNow();
+      } else {
+        abortGuard();
+      }
+    },
+    reset() {
+      sliceStart = performance.now();
+    }
+  };
+  return scheduler;
+}
+
+// src/worker/source.ts
+var WORKER_SOURCE = `
+self.onmessage = function (e) {
+  var id = e.data.id
+  var url = e.data.url
+  var init = e.data.init
+  fetch(url, init)
+    .then(function (res) {
+      if (!res.ok) throw new Error('HTTP ' + res.status)
+      return res.blob()
+    })
+    .then(function (blob) {
+      var reader = new FileReader()
+      reader.onload = function () { self.postMessage({ id: id, result: reader.result }) }
+      reader.onerror = function () { self.postMessage({ id: id, error: 'read failed' }) }
+      reader.readAsDataURL(blob)
+    })
+    .catch(function (err) {
+      self.postMessage({ id: id, error: String((err && err.message) || err) })
+    })
+}
+`;
+
+// src/worker/pool.ts
+function sanitizeInit(init) {
+  if (!init) return void 0;
+  const headers = init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers;
+  return {
+    method: init.method,
+    headers,
+    credentials: init.credentials,
+    mode: init.mode,
+    cache: init.cache,
+    referrer: init.referrer,
+    integrity: init.integrity
+  };
+}
+function createWorkerPool(count) {
+  if (count <= 0 || typeof Worker === "undefined") return null;
+  let blobUrl;
+  let workers;
+  try {
+    const blob = new Blob([WORKER_SOURCE], { type: "text/javascript" });
+    blobUrl = URL.createObjectURL(blob);
+    workers = Array.from({ length: count }, () => new Worker(blobUrl));
+  } catch {
+    return null;
+  }
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  let roundRobin = 0;
+  let destroyed = false;
+  for (const worker of workers) {
+    worker.onmessage = (event) => {
+      const { id, result, error } = event.data;
+      const request = pending.get(id);
+      if (!request) return;
+      pending.delete(id);
+      if (error !== void 0) request.reject(new Error(error));
+      else request.resolve(result);
+    };
+  }
+  return {
+    fetchAsDataUrl(url, requestInit) {
+      if (destroyed) return Promise.reject(new Error("worker pool destroyed"));
+      const id = nextId++;
+      const worker = workers[roundRobin++ % workers.length];
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        worker.postMessage({ id, url, init: sanitizeInit(requestInit) });
+      });
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      for (const worker of workers) worker.terminate();
+      URL.revokeObjectURL(blobUrl);
+      for (const request of pending.values()) {
+        request.reject(new Error("worker pool destroyed"));
+      }
+      pending.clear();
+    }
+  };
+}
+
+// src/context.ts
+var PHASE_WEIGHTS = {
+  clone: 0.35,
+  embed: 0.3,
+  rasterize: 0.2,
+  encode: 0.15
+};
+var PHASE_ORDER = ["clone", "embed", "rasterize", "encode"];
+function cumulativeWeightBefore(phase) {
+  let sum = 0;
+  for (const candidate of PHASE_ORDER) {
+    if (candidate === phase) break;
+    sum += PHASE_WEIGHTS[candidate];
+  }
+  return sum;
+}
+function createContext(target, options) {
+  const ownerDocument = target.ownerDocument;
+  const ownerWindow = ownerDocument.defaultView ?? window;
+  const scheduler = createScheduler(options.frameBudgetMs, options.signal);
+  const workerPool = createWorkerPool(options.workerCount);
+  const cleanups = [];
+  let destroyed = false;
+  let lastOverall = -1;
+  const context = {
+    options,
+    signal: options.signal,
+    ownerDocument,
+    ownerWindow,
+    scheduler,
+    workerPool,
+    defaultStyleCache: /* @__PURE__ */ new Map(),
+    resourceCache: /* @__PURE__ */ new Map(),
+    fontCache: /* @__PURE__ */ new Map(),
+    sandbox: null,
+    throwIfAborted() {
+      if (options.signal?.aborted) throw createAbortError();
+    },
+    reportPhase(phase, ratio) {
+      if (!options.onProgress) return;
+      const clamped = ratio < 0 ? 0 : ratio > 1 ? 1 : ratio;
+      const overall = cumulativeWeightBefore(phase) + PHASE_WEIGHTS[phase] * clamped;
+      if (overall === lastOverall) return;
+      lastOverall = overall;
+      options.onProgress({ phase, phaseRatio: clamped, overall });
+    },
+    addCleanup(fn) {
+      cleanups.push(fn);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      while (cleanups.length) {
+        const fn = cleanups.pop();
+        try {
+          fn();
+        } catch {
+        }
+      }
+      if (context.sandbox) {
+        context.sandbox.remove();
+        context.sandbox = null;
+      }
+      workerPool?.destroy();
+    }
+  };
+  return context;
+}
+
+// src/clone/default-style.ts
+var XHTML_NS = "http://www.w3.org/1999/xhtml";
+function ensureSandbox(context) {
+  if (context.sandbox?.contentDocument) {
+    return context.sandbox.contentDocument;
+  }
+  const iframe = context.ownerDocument.createElement("iframe");
+  iframe.setAttribute("aria-hidden", "true");
+  iframe.setAttribute("tabindex", "-1");
+  iframe.style.cssText = "position:fixed;left:-9999px;top:0;width:0;height:0;border:0;visibility:hidden;";
+  context.ownerDocument.body.appendChild(iframe);
+  context.sandbox = iframe;
+  const doc = iframe.contentDocument;
+  if (!doc) throw new Error("Unable to create style sandbox.");
+  return doc;
+}
+function getDefaultStyle(context, source) {
+  const namespace = source.namespaceURI ?? XHTML_NS;
+  const key = `${namespace}|${source.localName}`;
+  const cached = context.defaultStyleCache.get(key);
+  if (cached) return cached;
+  const doc = ensureSandbox(context);
+  const sandboxWindow = doc.defaultView;
+  if (!sandboxWindow || !doc.body) {
+    const empty = {};
+    context.defaultStyleCache.set(key, empty);
+    return empty;
+  }
+  const element = namespace === XHTML_NS ? doc.createElement(source.localName) : doc.createElementNS(namespace, source.localName);
+  doc.body.appendChild(element);
+  const computed = sandboxWindow.getComputedStyle(element);
+  const record = {};
+  for (let i = 0; i < computed.length; i++) {
+    const name = computed[i];
+    if (name) record[name] = computed.getPropertyValue(name);
+  }
+  doc.body.removeChild(element);
+  context.defaultStyleCache.set(key, record);
+  return record;
+}
+
+// src/clone/copy-styles.ts
+function copyStyle(source, target, context) {
+  const computed = context.ownerWindow.getComputedStyle(source);
+  const defaults = getDefaultStyle(context, source);
+  const targetStyle = target.style;
+  for (let i = 0; i < computed.length; i++) {
+    const name = computed[i];
+    if (!name) continue;
+    const value = computed.getPropertyValue(name);
+    if (value === "" || defaults[name] === value) continue;
+    targetStyle.setProperty(name, value, computed.getPropertyPriority(name));
+  }
+}
+
+// src/clone/pseudo.ts
+var PSEUDOS = ["::before", "::after"];
+var CLASS_PREFIX = "ss-pseudo-";
+function clonePseudoElements(source, target, state, context) {
+  let className = null;
+  for (const pseudo of PSEUDOS) {
+    const computed = context.ownerWindow.getComputedStyle(source, pseudo);
+    const content = computed.getPropertyValue("content");
+    if (!content || content === "none" || content === "normal") continue;
+    if (!className) {
+      className = `${CLASS_PREFIX}${state.uid++}`;
+      target.classList.add(className);
+    }
+    let body = "";
+    for (let i = 0; i < computed.length; i++) {
+      const name = computed[i];
+      if (!name) continue;
+      const value = computed.getPropertyValue(name);
+      if (value === "") continue;
+      const priority = computed.getPropertyPriority(name);
+      body += `${name}:${value}${priority ? " !important" : ""};`;
+    }
+    state.pseudoRules.push(`.${className}${pseudo}{${body}}`);
+  }
+}
+
+// src/clone/special.ts
+function snapshotCanvas(canvas) {
+  try {
+    return canvas.toDataURL();
+  } catch {
+    return null;
+  }
+}
+function copyInputValue(source, target) {
+  if (source instanceof HTMLTextAreaElement) {
+    target.textContent = source.value;
+    return;
+  }
+  if (source instanceof HTMLInputElement) {
+    const input = target;
+    if (source.type === "checkbox" || source.type === "radio") {
+      if (source.checked) input.setAttribute("checked", "");
+      else input.removeAttribute("checked");
+    } else {
+      input.setAttribute("value", source.value);
+    }
+    return;
+  }
+  if (source instanceof HTMLSelectElement) {
+    target.setAttribute("data-ss-selected", source.value);
+  }
+}
+
+// src/clone/state.ts
+function createCloneState(total) {
+  return { cloned: 0, total: Math.max(1, total), pseudoRules: [], uid: 0 };
+}
+
+// src/clone/clone-node.ts
+var SKIP_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "NOSCRIPT", "TEMPLATE"]);
+var PROGRESS_EVERY = 32;
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+function passesFilter(node, context, isRoot) {
+  if (isRoot || !context.options.filter) return true;
+  if (node.nodeType !== ELEMENT_NODE) return true;
+  return context.options.filter(node);
+}
+async function cloneNode(node, context, state, isRoot) {
+  if (!passesFilter(node, context, isRoot)) return null;
+  if (node.nodeType === TEXT_NODE) {
+    return node.cloneNode(false);
+  }
+  if (node.nodeType !== ELEMENT_NODE) return null;
+  const element = node;
+  if (SKIP_TAGS.has(element.tagName)) return null;
+  await context.scheduler.yieldIfNeeded();
+  state.cloned++;
+  if (state.cloned % PROGRESS_EVERY === 0) {
+    context.reportPhase("clone", state.cloned / state.total);
+  }
+  if (element instanceof HTMLCanvasElement) {
+    const dataUrl = snapshotCanvas(element);
+    if (dataUrl) {
+      const image = context.ownerDocument.createElement("img");
+      image.src = dataUrl;
+      copyStyle(element, image, context);
+      return image;
+    }
+  }
+  const clone = element.cloneNode(false);
+  copyStyle(element, clone, context);
+  clonePseudoElements(element, clone, state, context);
+  copyInputValue(element, clone);
+  for (const child of Array.from(element.childNodes)) {
+    const clonedChild = await cloneNode(child, context, state, false);
+    if (clonedChild) clone.appendChild(clonedChild);
+  }
+  return clone;
+}
+async function cloneTree(target, context) {
+  const total = target.getElementsByTagName("*").length + 1;
+  const state = createCloneState(total);
+  context.scheduler.reset();
+  const clone = await cloneNode(target, context, state, true);
+  context.reportPhase("clone", 1);
+  return { clone, pseudoRules: state.pseudoRules };
+}
+
+// src/util/concurrency.ts
+async function runPool(items, limit, worker) {
+  if (items.length === 0) return;
+  let cursor = 0;
+  const runner = async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      await worker(items[index], index);
+    }
+  };
+  const size = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: size }, runner));
+}
+
+// src/util/css.ts
+var URL_RE = /url\((['"]?)([^'")]+)\1\)/g;
+function extractUrls(cssText) {
+  const urls = [];
+  let match;
+  URL_RE.lastIndex = 0;
+  while ((match = URL_RE.exec(cssText)) !== null) {
+    const url = match[2];
+    if (url && !url.startsWith("data:")) urls.push(url);
+  }
+  return urls;
+}
+function replaceUrl(cssText, from, to) {
+  return cssText.replace(URL_RE, (whole, _quote, url) => {
+    return url === from ? `url("${to}")` : whole;
+  });
+}
+function resolveUrl(url, baseUrl) {
+  if (url.startsWith("data:") || /^[a-z][a-z0-9+.-]*:/i.test(url)) return url;
+  try {
+    return new URL(url, baseUrl).href;
+  } catch {
+    return url;
+  }
+}
+
+// src/util/dataurl.ts
+function blobToDataUrl(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.onerror = () => reject(new Error("Failed to read blob."));
+    reader.readAsDataURL(blob);
+  });
+}
+function isDataUrl(url) {
+  return url.startsWith("data:");
+}
+
+// src/embed/fetch.ts
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(createAbortError());
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(createAbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function mainThreadFetch(url, context) {
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    context.options.fetchTimeoutMs
+  );
+  const onParentAbort = () => controller.abort();
+  context.signal?.addEventListener("abort", onParentAbort, { once: true });
+  try {
+    const response = await fetch(url, {
+      ...context.options.fetchRequestInit,
+      signal: controller.signal
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const blob = await response.blob();
+    return await blobToDataUrl(blob);
+  } finally {
+    clearTimeout(timer);
+    context.signal?.removeEventListener("abort", onParentAbort);
+  }
+}
+async function workerFetch(url, context) {
+  const pool = context.workerPool;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error("timeout")),
+      context.options.fetchTimeoutMs
+    );
+  });
+  try {
+    return await Promise.race([
+      pool.fetchAsDataUrl(url, context.options.fetchRequestInit),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function withRetry(url, context) {
+  const retries = context.options.fetchRetries;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    context.throwIfAborted();
+    try {
+      return context.workerPool ? await workerFetch(url, context) : await mainThreadFetch(url, context);
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      lastError = error;
+      if (attempt < retries) await delay(100 * 2 ** attempt, context.signal);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Resource fetch failed.");
+}
+function fetchResourceAsDataUrl(url, context) {
+  if (isDataUrl(url)) return Promise.resolve(url);
+  const cached = context.resourceCache.get(url);
+  if (cached) return cached;
+  const promise = withRetry(url, context);
+  context.resourceCache.set(url, promise);
+  return promise;
+}
+
+// src/embed/images.ts
+var TRANSPARENT_PIXEL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+function handleFailure(url, error, context) {
+  if (context.options.onResourceError) {
+    context.options.onResourceError(
+      url,
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+  return context.options.fetchPlaceholder ?? TRANSPARENT_PIXEL;
+}
+async function embedImageElement(image, context) {
+  const source = image.currentSrc || image.src;
+  if (!source || source.startsWith("data:")) return;
+  try {
+    image.src = await fetchResourceAsDataUrl(source, context);
+  } catch (error) {
+    if (isAbortError(error)) throw error;
+    image.src = handleFailure(source, error, context);
+  }
+  image.removeAttribute("srcset");
+  image.removeAttribute("loading");
+  image.removeAttribute("crossorigin");
+}
+async function embedBackground(element, context) {
+  let value = element.style.backgroundImage;
+  if (!value || value === "none" || !value.includes("url(")) return;
+  const urls = extractUrls(value);
+  for (const url of urls) {
+    try {
+      const dataUrl = await fetchResourceAsDataUrl(url, context);
+      value = replaceUrl(value, url, dataUrl);
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      value = replaceUrl(value, url, handleFailure(url, error, context));
+    }
+  }
+  element.style.backgroundImage = value;
+}
+
+// src/embed/fonts.ts
+var FONT_FACE_RULE = 5;
+var FONT_FACE_RE = /@font-face\s*{[^}]*}/gi;
+var URL_FORMAT_RE = /url\((['"]?)([^'")]+)\1\)\s*format\((['"]?)([^'")]+)\3\)/gi;
+async function gatherFontFaces(context) {
+  const entries = [];
+  const crossOriginHrefs = [];
+  for (const sheet of Array.from(context.ownerDocument.styleSheets)) {
+    const baseUrl = sheet.href ?? context.ownerDocument.baseURI;
+    let rules = null;
+    try {
+      rules = sheet.cssRules;
+    } catch {
+      rules = null;
+    }
+    if (rules) {
+      for (const rule of Array.from(rules)) {
+        if (rule.type === FONT_FACE_RULE) {
+          entries.push({ cssText: rule.cssText, baseUrl });
+        }
+      }
+    } else if (sheet.href) {
+      crossOriginHrefs.push(sheet.href);
+    }
+  }
+  for (const href of crossOriginHrefs) {
+    context.throwIfAborted();
+    try {
+      const response = await fetch(href, context.options.fetchRequestInit);
+      if (!response.ok) continue;
+      const text = await response.text();
+      for (const match of text.match(FONT_FACE_RE) ?? []) {
+        entries.push({ cssText: match, baseUrl: href });
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function pickPreferredUrl(cssText, urls, preferWoff2) {
+  if (preferWoff2) {
+    URL_FORMAT_RE.lastIndex = 0;
+    let match;
+    while ((match = URL_FORMAT_RE.exec(cssText)) !== null) {
+      if (/woff2/i.test(match[4] ?? "")) return match[2];
+    }
+  }
+  return urls[0];
+}
+async function embedFontFace(entry, context) {
+  const cached = context.fontCache.get(entry.cssText);
+  if (cached !== void 0) return cached;
+  const urls = extractUrls(entry.cssText);
+  let css = entry.cssText;
+  if (urls.length > 0) {
+    const chosen = pickPreferredUrl(entry.cssText, urls, context.options.fontsPreferWoff2);
+    try {
+      const dataUrl = await fetchResourceAsDataUrl(
+        resolveUrl(chosen, entry.baseUrl),
+        context
+      );
+      css = entry.cssText.replace(/src\s*:[^;]+;?/i, `src:url("${dataUrl}");`);
+    } catch {
+    }
+  }
+  context.fontCache.set(entry.cssText, css);
+  return css;
+}
+async function embedWebFonts(context) {
+  if (context.options.fontsSkip) return "";
+  const faces = await gatherFontFaces(context);
+  if (faces.length === 0) return "";
+  const parts = [];
+  await runPool(faces, 4, async (face) => {
+    parts.push(await embedFontFace(face, context));
+    await context.scheduler.yieldIfNeeded();
+  });
+  return parts.join("\n");
+}
+
+// src/embed/embed.ts
+var EMBED_CONCURRENCY = 6;
+function hasBackgroundImage(element) {
+  const value = element.style?.backgroundImage;
+  return Boolean(value) && value !== "none" && value.includes("url(");
+}
+async function embedResources(clone, context) {
+  context.scheduler.reset();
+  const images = Array.from(clone.querySelectorAll("img"));
+  if (clone instanceof HTMLImageElement) images.unshift(clone);
+  const backgrounds = Array.from(
+    clone.querySelectorAll("*")
+  ).filter(hasBackgroundImage);
+  if (hasBackgroundImage(clone)) backgrounds.unshift(clone);
+  const total = images.length + backgrounds.length;
+  let done = 0;
+  const tick = () => {
+    done++;
+    if (total > 0) context.reportPhase("embed", done / total);
+  };
+  const imageTasks = images.map(
+    (image) => async () => {
+      await embedImageElement(image, context);
+      tick();
+      await context.scheduler.yieldIfNeeded();
+    }
+  );
+  const backgroundTasks = backgrounds.map(
+    (element) => async () => {
+      await embedBackground(element, context);
+      tick();
+      await context.scheduler.yieldIfNeeded();
+    }
+  );
+  const tasks = [...imageTasks, ...backgroundTasks];
+  const [fontCss] = await Promise.all([
+    embedWebFonts(context),
+    runPool(tasks, EMBED_CONCURRENCY, (task) => task())
+  ]);
+  context.reportPhase("embed", 1);
+  return fontCss;
+}
+
+// src/serialize/foreign-object-svg.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XHTML_NS2 = "http://www.w3.org/1999/xhtml";
+function buildSvgString(params) {
+  const {
+    clone,
+    doc,
+    fullWidth,
+    fullHeight,
+    pseudoRules,
+    fontCss,
+    backgroundColor,
+    crop
+  } = params;
+  const outW = crop ? crop.width : fullWidth;
+  const outH = crop ? crop.height : fullHeight;
+  const svg = doc.createElementNS(SVG_NS, "svg");
+  svg.setAttribute("xmlns", SVG_NS);
+  svg.setAttribute("width", String(outW));
+  svg.setAttribute("height", String(outH));
+  svg.setAttribute("viewBox", `0 0 ${outW} ${outH}`);
+  if (backgroundColor) {
+    const rect = doc.createElementNS(SVG_NS, "rect");
+    rect.setAttribute("width", "100%");
+    rect.setAttribute("height", "100%");
+    rect.setAttribute("fill", backgroundColor);
+    svg.appendChild(rect);
+  }
+  const foreignObject = doc.createElementNS(SVG_NS, "foreignObject");
+  foreignObject.setAttribute("x", String(crop ? -crop.x : 0));
+  foreignObject.setAttribute("y", String(crop ? -crop.y : 0));
+  foreignObject.setAttribute("width", String(fullWidth));
+  foreignObject.setAttribute("height", String(fullHeight));
+  const container = doc.createElement("div");
+  container.setAttribute("xmlns", XHTML_NS2);
+  if (fontCss || pseudoRules.length > 0) {
+    const style = doc.createElement("style");
+    style.textContent = `${fontCss}
+${pseudoRules.join("")}`;
+    container.appendChild(style);
+  }
+  clone.style.margin = "0";
+  container.appendChild(clone);
+  foreignObject.appendChild(container);
+  svg.appendChild(foreignObject);
+  return new XMLSerializer().serializeToString(svg);
+}
+function svgStringToDataUrl(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+
+// src/raster/svg-to-image.ts
+async function svgToImage(dataUrl, doc) {
+  const view = doc.defaultView ?? window;
+  const image = new view.Image();
+  image.decoding = "sync";
+  image.src = dataUrl;
+  if (typeof image.decode === "function") {
+    await image.decode();
+    return image;
+  }
+  await new Promise((resolve, reject) => {
+    image.onload = () => resolve();
+    image.onerror = () => reject(new Error("Failed to rasterize SVG."));
+  });
+  return image;
+}
+
+// src/raster/tiler.ts
+var DEFAULT_MAX_TILE = 4096;
+var MAX_BAND_BYTES = 8 * 1024 * 1024;
+function createCanvas(doc, width, height) {
+  const canvas = doc.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  return canvas;
+}
+function clampScale(outWidth, outHeight, scale, maxTile) {
+  const limit = Math.min(
+    maxTile / Math.max(1, outWidth),
+    maxTile / Math.max(1, outHeight)
+  );
+  return Math.min(scale, limit);
+}
+function drawSvgToCanvas(svgImage, deviceWidth, deviceHeight, context) {
+  const canvas = createCanvas(context.ownerDocument, deviceWidth, deviceHeight);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("2D context unavailable.");
+  ctx.drawImage(svgImage, 0, 0, deviceWidth, deviceHeight);
+  context.reportPhase("rasterize", 1);
+  return canvas;
+}
+async function* rgbaBands(svgImage, geometry2, maxTile, context) {
+  const { outWidth, outHeight, deviceWidth, deviceHeight } = geometry2;
+  const rx = outWidth / deviceWidth;
+  const ry = outHeight / deviceHeight;
+  const bandRows = Math.max(
+    1,
+    Math.min(maxTile, Math.floor(MAX_BAND_BYTES / (deviceWidth * 4)) || 1)
+  );
+  const tile = createCanvas(
+    context.ownerDocument,
+    Math.min(maxTile, deviceWidth),
+    bandRows
+  );
+  const tileCtx = tile.getContext("2d", { willReadFrequently: true });
+  if (!tileCtx) throw new Error("2D context unavailable.");
+  for (let y = 0; y < deviceHeight; y += bandRows) {
+    const bandHeight = Math.min(bandRows, deviceHeight - y);
+    const band = new Uint8Array(deviceWidth * bandHeight * 4);
+    for (let x = 0; x < deviceWidth; x += maxTile) {
+      const tileWidth = Math.min(maxTile, deviceWidth - x);
+      if (tile.width !== tileWidth || tile.height !== bandHeight) {
+        tile.width = tileWidth;
+        tile.height = bandHeight;
+      }
+      tileCtx.clearRect(0, 0, tileWidth, bandHeight);
+      tileCtx.drawImage(
+        svgImage,
+        x * rx,
+        y * ry,
+        tileWidth * rx,
+        bandHeight * ry,
+        0,
+        0,
+        tileWidth,
+        bandHeight
+      );
+      const pixels = tileCtx.getImageData(0, 0, tileWidth, bandHeight).data;
+      const rowBytes = tileWidth * 4;
+      for (let row = 0; row < bandHeight; row++) {
+        band.set(
+          pixels.subarray(row * rowBytes, (row + 1) * rowBytes),
+          (row * deviceWidth + x) * 4
+        );
+      }
+      await context.scheduler.yieldIfNeeded();
+    }
+    context.reportPhase("rasterize", Math.min(1, (y + bandHeight) / deviceHeight));
+    yield band;
+  }
+}
+
+// src/util/compress.ts
+function mergeChunks(chunks, total) {
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const part of chunks) {
+    merged.set(part, offset);
+    offset += part.length;
+  }
+  return merged;
+}
+function supportsCompressionStream() {
+  return typeof CompressionStream !== "undefined";
+}
+async function deflate(source) {
+  const cs = new CompressionStream("deflate");
+  const writer = cs.writable.getWriter();
+  const pump = (async () => {
+    for await (const part of source) {
+      await writer.write(part);
+    }
+    await writer.close();
+  })();
+  const reader = cs.readable.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    total += value.length;
+  }
+  await pump;
+  return mergeChunks(chunks, total);
+}
+
+// src/encode/png-encoder.ts
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(data, 8);
+  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function ihdr(width, height) {
+  const data = new Uint8Array(13);
+  const view = new DataView(data.buffer);
+  view.setUint32(0, width);
+  view.setUint32(4, height);
+  data[8] = 8;
+  data[9] = 6;
+  return data;
+}
+async function encodePng(width, height, rgbaBands2) {
+  const stride = width * 4;
+  async function* framedScanlines() {
+    for await (const band of rgbaBands2) {
+      const rows = band.length / stride;
+      const framed = new Uint8Array(band.length + rows);
+      for (let r = 0; r < rows; r++) {
+        const dst = r * (stride + 1);
+        framed[dst] = 0;
+        framed.set(band.subarray(r * stride, (r + 1) * stride), dst + 1);
+      }
+      yield framed;
+    }
+  }
+  const idat = await deflate(framedScanlines());
+  return new Blob(
+    [
+      PNG_SIGNATURE,
+      chunk("IHDR", ihdr(width, height)),
+      chunk("IDAT", idat),
+      chunk("IEND", new Uint8Array(0))
+    ],
+    { type: "image/png" }
+  );
+}
+
+// src/encode/pdf.ts
+var encoder = new TextEncoder();
+async function* rgbaToRgb(bands) {
+  for await (const rgba of bands) {
+    const pixels = rgba.length / 4;
+    const rgb = new Uint8Array(pixels * 3);
+    for (let i = 0, j = 0; i < rgba.length; i += 4, j += 3) {
+      const alpha = rgba[i + 3] / 255;
+      const inv = 255 * (1 - alpha);
+      rgb[j] = Math.round(rgba[i] * alpha + inv);
+      rgb[j + 1] = Math.round(rgba[i + 1] * alpha + inv);
+      rgb[j + 2] = Math.round(rgba[i + 2] * alpha + inv);
+    }
+    yield rgb;
+  }
+}
+function fmt(n) {
+  return (Math.round(n * 1e3) / 1e3).toString();
+}
+async function encodePdfFromRgbaBands(bands, pixelWidth, pixelHeight, pointWidth, pointHeight) {
+  const imageData = await deflate(rgbaToRgb(bands));
+  const parts = [];
+  const offsets = new Array(6).fill(0);
+  let offset = 0;
+  const pushBytes = (bytes) => {
+    parts.push(bytes);
+    offset += bytes.length;
+  };
+  const pushText = (text) => pushBytes(encoder.encode(text));
+  const startObject = (n) => {
+    offsets[n] = offset;
+  };
+  pushText("%PDF-1.4\n");
+  pushBytes(new Uint8Array([37, 255, 255, 255, 255, 10]));
+  startObject(1);
+  pushText("1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
+  startObject(2);
+  pushText("2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
+  startObject(3);
+  pushText(
+    `3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${fmt(pointWidth)} ${fmt(
+      pointHeight
+    )}] /Resources << /XObject << /Im0 4 0 R >> >> /Contents 5 0 R >>
+endobj
+`
+  );
+  startObject(4);
+  pushText(
+    `4 0 obj
+<< /Type /XObject /Subtype /Image /Width ${pixelWidth} /Height ${pixelHeight} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /FlateDecode /Length ${imageData.length} >>
+stream
+`
+  );
+  pushBytes(imageData);
+  pushText("\nendstream\nendobj\n");
+  const content = `q
+${fmt(pointWidth)} 0 0 ${fmt(pointHeight)} 0 0 cm
+/Im0 Do
+Q
+`;
+  startObject(5);
+  pushText(
+    `5 0 obj
+<< /Length ${content.length} >>
+stream
+${content}endstream
+endobj
+`
+  );
+  const xrefOffset = offset;
+  let xref = `xref
+0 6
+0000000000 65535 f 
+`;
+  for (let i = 1; i < 6; i++) {
+    xref += `${String(offsets[i]).padStart(10, "0")} 00000 n 
+`;
+  }
+  pushText(xref);
+  pushText(`trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+${xrefOffset}
+%%EOF`);
+  return new Blob(parts, { type: "application/pdf" });
+}
+
+// src/encode/image.ts
+var MIME = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+function canvasToBlob(canvas, type, quality) {
+  return new Promise((resolve, reject) => {
+    try {
+      canvas.toBlob(
+        (blob) => {
+          if (blob) resolve(blob);
+          else reject(new SmoothScreenshotError("ENCODE_FAILED", "toBlob returned null."));
+        },
+        MIME[type],
+        quality
+      );
+    } catch (error) {
+      reject(
+        new SmoothScreenshotError(
+          "TAINTED_CANVAS",
+          "Canvas is tainted by cross-origin content and cannot be exported.",
+          { cause: error }
+        )
+      );
+    }
+  });
+}
+function canvasToDataUrl(canvas, type, quality) {
+  try {
+    return canvas.toDataURL(MIME[type], quality);
+  } catch (error) {
+    throw new SmoothScreenshotError(
+      "TAINTED_CANVAS",
+      "Canvas is tainted by cross-origin content and cannot be exported.",
+      { cause: error }
+    );
+  }
+}
+
+// src/capture.ts
+var CSS_PX_TO_PT = 0.75;
+function assertElement(target) {
+  if (!target || typeof target.getBoundingClientRect !== "function" || !target.ownerDocument) {
+    throw new SmoothScreenshotError(
+      "INVALID_TARGET",
+      "Capture target must be an HTMLElement attached to a document."
+    );
+  }
+}
+async function prepare(target, context, backgroundColor) {
+  context.throwIfAborted();
+  const rect = target.getBoundingClientRect();
+  const fullWidth = context.options.width ?? rect.width;
+  const fullHeight = context.options.height ?? rect.height;
+  if (fullWidth <= 0 || fullHeight <= 0) {
+    throw new SmoothScreenshotError(
+      "EMPTY_TARGET",
+      "Capture target has no rendered size."
+    );
+  }
+  const crop = context.options.crop;
+  const outWidth = crop ? crop.width : fullWidth;
+  const outHeight = crop ? crop.height : fullHeight;
+  const { clone, pseudoRules } = await cloneTree(target, context);
+  const fontCss = await embedResources(clone, context);
+  const svgString = buildSvgString({
+    clone,
+    doc: context.ownerDocument,
+    fullWidth,
+    fullHeight,
+    pseudoRules,
+    fontCss,
+    backgroundColor,
+    crop
+  });
+  return { svgString, fullWidth, fullHeight, outWidth, outHeight };
+}
+function withContext(target, options, backgroundColor, run) {
+  assertElement(target);
+  const ownerWindow = target.ownerDocument.defaultView ?? window;
+  const context = createContext(target, resolveOptions(options, ownerWindow));
+  return prepare(target, context, backgroundColor).then((prepared) => run(context, prepared)).finally(() => context.destroy());
+}
+function geometry(prepared, scale) {
+  return {
+    outWidth: prepared.outWidth,
+    outHeight: prepared.outHeight,
+    deviceWidth: Math.max(1, Math.round(prepared.outWidth * scale)),
+    deviceHeight: Math.max(1, Math.round(prepared.outHeight * scale))
+  };
+}
+function captureSvg(target, options = {}) {
+  return withContext(target, options, options.backgroundColor ?? null, async (context, prepared) => {
+    context.reportPhase("rasterize", 1);
+    context.reportPhase("encode", 1);
+    return svgStringToDataUrl(prepared.svgString);
+  });
+}
+async function renderClampedCanvas(context, prepared) {
+  const maxTile = context.options.maxTileSize || DEFAULT_MAX_TILE;
+  const scale = clampScale(
+    prepared.outWidth,
+    prepared.outHeight,
+    context.options.scale,
+    maxTile
+  );
+  const geo = geometry(prepared, scale);
+  const svgImage = await svgToImage(
+    svgStringToDataUrl(prepared.svgString),
+    context.ownerDocument
+  );
+  return drawSvgToCanvas(svgImage, geo.deviceWidth, geo.deviceHeight, context);
+}
+function captureCanvas(target, options = {}) {
+  return withContext(
+    target,
+    options,
+    options.backgroundColor ?? null,
+    (context, prepared) => renderClampedCanvas(context, prepared)
+  );
+}
+async function encodeImage(context, prepared, type, toResult, toPngBeyondCap) {
+  const maxTile = context.options.maxTileSize || DEFAULT_MAX_TILE;
+  const fullGeo = geometry(prepared, context.options.scale);
+  const exceeds = fullGeo.deviceWidth > maxTile || fullGeo.deviceHeight > maxTile;
+  const svgImage = await svgToImage(
+    svgStringToDataUrl(prepared.svgString),
+    context.ownerDocument
+  );
+  if (type === "png" && exceeds && supportsCompressionStream()) {
+    const blob = await encodePng(
+      fullGeo.deviceWidth,
+      fullGeo.deviceHeight,
+      rgbaBands(svgImage, fullGeo, maxTile, context)
+    );
+    context.reportPhase("encode", 1);
+    return toPngBeyondCap(blob);
+  }
+  let geo = fullGeo;
+  if (exceeds) {
+    const scale = clampScale(
+      prepared.outWidth,
+      prepared.outHeight,
+      context.options.scale,
+      maxTile
+    );
+    geo = geometry(prepared, scale);
+  }
+  const canvas = drawSvgToCanvas(svgImage, geo.deviceWidth, geo.deviceHeight, context);
+  const result = await toResult(canvas);
+  context.reportPhase("encode", 1);
+  return result;
+}
+function captureImageDataUrl(target, options, type) {
+  const backgroundColor = options.backgroundColor ?? (type === "jpeg" ? "#ffffff" : null);
+  return withContext(
+    target,
+    options,
+    backgroundColor,
+    (context, prepared) => encodeImage(
+      context,
+      prepared,
+      type,
+      (canvas) => canvasToDataUrl(canvas, type, context.options.quality),
+      (blob) => new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => resolve(reader.result);
+        reader.onerror = () => reject(new Error("Failed to read PNG blob."));
+        reader.readAsDataURL(blob);
+      })
+    )
+  );
+}
+function captureImageBlob(target, options, type) {
+  const backgroundColor = options.backgroundColor ?? (type === "jpeg" ? "#ffffff" : null);
+  return withContext(
+    target,
+    options,
+    backgroundColor,
+    (context, prepared) => encodeImage(
+      context,
+      prepared,
+      type,
+      (canvas) => canvasToBlob(canvas, type, context.options.quality),
+      (blob) => blob
+    )
+  );
+}
+function capturePdf(target, options = {}) {
+  if (!supportsCompressionStream()) {
+    return Promise.reject(
+      new SmoothScreenshotError(
+        "ENCODE_FAILED",
+        "PDF export requires CompressionStream (Chrome 80+, Firefox 113+, Safari 16.4+)."
+      )
+    );
+  }
+  const backgroundColor = options.backgroundColor ?? "#ffffff";
+  return withContext(target, options, backgroundColor, async (context, prepared) => {
+    const maxTile = context.options.maxTileSize || DEFAULT_MAX_TILE;
+    const geo = geometry(prepared, context.options.scale);
+    const svgImage = await svgToImage(
+      svgStringToDataUrl(prepared.svgString),
+      context.ownerDocument
+    );
+    const blob = await encodePdfFromRgbaBands(
+      rgbaBands(svgImage, geo, maxTile, context),
+      geo.deviceWidth,
+      geo.deviceHeight,
+      prepared.outWidth * CSS_PX_TO_PT,
+      prepared.outHeight * CSS_PX_TO_PT
+    );
+    context.reportPhase("encode", 1);
+    return blob;
+  });
+}
+
+// src/api.ts
+function toPng(target, options = {}) {
+  return captureImageDataUrl(target, options, "png");
+}
+function toJpeg(target, options = {}) {
+  return captureImageDataUrl(target, options, "jpeg");
+}
+function toWebp(target, options = {}) {
+  return captureImageDataUrl(target, options, "webp");
+}
+function toSvg(target, options = {}) {
+  return captureSvg(target, options);
+}
+function toCanvas(target, options = {}) {
+  return captureCanvas(target, options);
+}
+function toPdf(target, options = {}) {
+  return capturePdf(target, options);
+}
+function toBlob(target, options = {}) {
+  return captureImageBlob(target, options, options.type ?? "png");
+}
+
+export { SmoothScreenshotError, toBlob, toCanvas, toJpeg, toPdf, toPng, toSvg, toWebp };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map