satoru-render 0.0.22 → 0.0.23

package/dist/workers-dummy.d.ts

@@ -0,0 +1,9 @@
+export type { SatoruWorker } from "./child-workers.js";
+import { type RenderOptions } from "./index.js";
+export type { RenderOptions };
+export declare const render: (_params: RenderOptions) => Promise<string | Uint8Array<ArrayBufferLike>>;
+export declare const setLimit: (_limit: number) => void;
+export declare const close: () => void;
+export declare const waitAll: () => Promise<void>;
+export declare const waitReady: (_retryTime?: number) => Promise<void>;
+export declare const launchWorker: () => Promise<void>;

package/dist/workers-dummy.js

@@ -0,0 +1,8 @@
+export const render = (_params) => {
+    return undefined;
+};
+export const setLimit = (_limit) => { };
+export const close = () => { };
+export const waitAll = () => Promise.resolve();
+export const waitReady = (_retryTime) => Promise.resolve();
+export const launchWorker = () => Promise.resolve();

package/dist/workers-parent.js

@@ -0,0 +1,682 @@
+//#region ../../node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/esm/common.js
+const FUNCTION_PLACEHOLDER = "__worker_lib_function__";
+const isPlaceholder = (v) => v && typeof v === "object" && "__worker_lib_function__" in v;
+const isPlainObject = (v) => {
+	return v && typeof v === "object" && Object.prototype.toString.call(v) === "[object Object]" && !(v instanceof Uint8Array) && !(v instanceof ArrayBuffer) && !ArrayBuffer.isView(v);
+};
+const getTransferables = (v, result = []) => {
+	if (v instanceof ArrayBuffer) result.push(v);
+	else if (ArrayBuffer.isView(v)) result.push(v.buffer);
+	else if (Array.isArray(v)) for (const item of v) getTransferables(item, result);
+	else if (v && typeof v === "object") for (const key in v) getTransferables(v[key], result);
+	return result;
+};
+const createRegistry = () => {
+	const callbacks = /* @__PURE__ */ new Map();
+	const callbackProxies = /* @__PURE__ */ new Map();
+	const registerCallback = (requestId, fn) => {
+		const id = `${requestId}:${Math.random().toString(36).slice(2)}`;
+		callbacks.set(id, fn);
+		return id;
+	};
+	const clearCallbacks = (requestId) => {
+		for (const key of callbacks.keys()) if (key.startsWith(`${requestId}:`)) callbacks.delete(key);
+		for (const key of callbackProxies.keys()) if (key.startsWith(`${requestId}:`)) callbackProxies.delete(key);
+	};
+	const transformArgs = (requestId, args) => {
+		if (typeof args === "function") return { [FUNCTION_PLACEHOLDER]: registerCallback(requestId, args) };
+		if (ArrayBuffer.isView(args) || args instanceof ArrayBuffer) return args;
+		if (Array.isArray(args)) return args.map((v) => transformArgs(requestId, v));
+		if (isPlainObject(args)) {
+			const result = {};
+			for (const key in args) result[key] = transformArgs(requestId, args[key]);
+			return result;
+		}
+		return args;
+	};
+	const resolveArgs = (requestId, args, createProxy) => {
+		if (isPlaceholder(args)) return createProxy(args[FUNCTION_PLACEHOLDER]);
+		if (Array.isArray(args)) return args.map((v) => resolveArgs(requestId, v, createProxy));
+		if (isPlainObject(args)) {
+			const result = {};
+			for (const key in args) result[key] = resolveArgs(requestId, args[key], createProxy);
+			return result;
+		}
+		return args;
+	};
+	return {
+		callbacks,
+		callbackProxies,
+		registerCallback,
+		clearCallbacks,
+		transformArgs,
+		resolveArgs
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/esm/pool.js
+let requestIdCounter = 0;
+const exec = (worker, name, registry, ...args) => {
+	const requestId = requestIdCounter++;
+	const { callbacks, callbackProxies, clearCallbacks, transformArgs, resolveArgs } = registry;
+	return new Promise((resolve, reject) => {
+		const createProxy = (callbackId) => {
+			const key = `${requestId}:${callbackId}`;
+			if (callbackProxies.has(key)) return callbackProxies.get(key);
+			const proxy = (...proxyArgs) => {
+				const callId = Math.random().toString(36).slice(2);
+				return new Promise((res) => {
+					const handler = (data) => {
+						if (data.type === "callback_result" && data.payload.id === callId) {
+							worker.removeEventListener("message", handler);
+							res(resolveArgs(requestId, data.payload.result, createProxy));
+						}
+					};
+					worker.addEventListener("message", handler);
+					const transformedProxyArgs = transformArgs(requestId, proxyArgs);
+					worker.postMessage({
+						type: "callback_call",
+						payload: {
+							id: requestId,
+							callbackId,
+							args: transformedProxyArgs,
+							callId
+						}
+					}, getTransferables(transformedProxyArgs));
+				});
+			};
+			callbackProxies.set(key, proxy);
+			return proxy;
+		};
+		const messageHandler = async (data) => {
+			if (!data || typeof data !== "object") return;
+			const payload = data.payload;
+			if (payload?.id !== requestId) return;
+			if (data.type === "result") {
+				worker.removeEventListener("message", messageHandler);
+				const result = resolveArgs(requestId, payload.result, createProxy);
+				clearCallbacks(requestId);
+				resolve(result);
+			} else if (data.type === "error") {
+				worker.removeEventListener("message", messageHandler);
+				clearCallbacks(requestId);
+				reject(payload.error);
+			} else if (data.type === "callback_call") {
+				const { callbackId, args: callArgs, callId } = payload;
+				const fn = callbacks.get(callbackId);
+				if (fn) try {
+					const transformedResult = transformArgs(requestId, await fn(...resolveArgs(requestId, callArgs, createProxy)));
+					worker.postMessage({
+						type: "callback_result",
+						payload: {
+							id: callId,
+							result: transformedResult
+						}
+					}, getTransferables(transformedResult));
+				} catch (e) {
+					console.error("[worker-lib] Callback execution failed:", e);
+				}
+			}
+		};
+		worker.addEventListener("message", messageHandler);
+		const transformedArgs = transformArgs(requestId, args);
+		worker.postMessage({
+			type: "function",
+			payload: {
+				id: requestId,
+				name,
+				args: transformedArgs
+			}
+		}, getTransferables(transformedArgs));
+	});
+};
+const createWorkerPool = (builder, limit = 4) => {
+	let workers = Array(limit).fill(void 0).map(() => ({}));
+	const emptyWaits = [];
+	let isEmptyWait = false;
+	const registry = createRegistry();
+	const getResolver = async () => {
+		while (true) {
+			const target = workers.find(({ resultResolver }) => !resultResolver);
+			if (target) {
+				target.resultResolver = Promise.withResolvers();
+				if (!target.worker) target.worker = await builder();
+				return target;
+			}
+			await Promise.race(workers.map(({ resultResolver }) => resultResolver?.promise));
+		}
+	};
+	const execute = async (name, ...value) => {
+		const target = await getResolver();
+		const { resultResolver } = target;
+		if (!resultResolver) throw new Error("Unexpected error");
+		exec(target.worker, name, registry, ...value).then(resultResolver.resolve).catch(resultResolver.reject).finally(() => {
+			target.resultResolver = void 0;
+		});
+		return resultResolver.promise;
+	};
+	const launchWorker = async () => {
+		return Promise.all(workers.map(async (target) => {
+			if (!target.worker) target.worker = await builder();
+		}));
+	};
+	const waitAll = async () => {
+		while (workers.find(({ resultResolver }) => resultResolver)) await Promise.all(workers.flatMap(({ resultResolver }) => resultResolver ? [resultResolver.promise] : []));
+	};
+	const waitReady = async (retryTime = 1) => {
+		const p = Promise.withResolvers();
+		emptyWaits.push(p);
+		(async () => {
+			if (!isEmptyWait) {
+				isEmptyWait = true;
+				do {
+					const actives = workers.flatMap(({ resultResolver }) => resultResolver ? [resultResolver.promise] : []);
+					if (workers.length === actives.length) await Promise.race(actives);
+					emptyWaits.shift()?.resolve();
+					if (retryTime) await new Promise((r) => setTimeout(r, retryTime));
+					else await Promise.resolve();
+				} while (emptyWaits.length);
+				isEmptyWait = false;
+			}
+		})();
+		return p.promise;
+	};
+	const close = () => {
+		for (const target of workers) {
+			target.worker?.terminate();
+			target.worker = void 0;
+			target.resultResolver = void 0;
+		}
+	};
+	const setLimit = (newLimit) => {
+		workers.forEach((w) => w.worker?.terminate());
+		workers = Array(newLimit).fill(void 0).map(() => ({}));
+	};
+	return {
+		execute,
+		waitAll,
+		waitReady,
+		close,
+		setLimit,
+		launchWorker
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/worker-lib@2.2.0/node_modules/worker-lib/dist/esm/index.js
+const w = Worker;
+const wrapWorker = (worker) => ({
+	postMessage: (message, transfer) => worker.postMessage(message, transfer),
+	addEventListener: (type, listener) => {
+		const handler = (e) => {
+			if (e instanceof MessageEvent) listener(e.data);
+		};
+		listener._handler = handler;
+		worker.addEventListener(type, handler);
+	},
+	removeEventListener: (type, listener) => {
+		const handler = listener._handler;
+		worker.removeEventListener(type, handler);
+	},
+	terminate: () => worker.terminate()
+});
+const init = (worker) => {
+	return new Promise((resolve) => {
+		const handler = (e) => {
+			if (e.data === "ready") {
+				worker.removeEventListener("message", handler);
+				resolve(worker);
+			}
+		};
+		worker.addEventListener("message", handler);
+	});
+};
+const createWorker = (builder, limit = 4) => {
+	return createWorkerPool(async () => {
+		const result = builder();
+		const worker = result instanceof Worker ? result : new Worker(result);
+		await init(worker);
+		return wrapWorker(worker);
+	}, limit);
+};
+//#endregion
+//#region src/log-level.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["None"] = 0] = "None";
+	LogLevel[LogLevel["Error"] = 1] = "Error";
+	LogLevel[LogLevel["Warning"] = 2] = "Warning";
+	LogLevel[LogLevel["Info"] = 3] = "Info";
+	LogLevel[LogLevel["Debug"] = 4] = "Debug";
+	return LogLevel;
+}({});
+//#endregion
+//#region src/core.ts
+const DEFAULT_FONT_MAP = {
+	"sans-serif": "https://fonts.googleapis.com/css2?family=Noto+Sans+JP",
+	serif: "https://fonts.googleapis.com/css2?family=Noto+Serif+JP",
+	monospace: "https://fonts.googleapis.com/css2?family=M+PLUS+1+Code",
+	cursive: "https://fonts.googleapis.com/css2?family=Yuji+Syuku",
+	fantasy: "https://fonts.googleapis.com/css2?family=Reggae+One",
+	emoji: "https://cdn.jsdelivr.net/npm/@fontsource/noto-color-emoji/files/noto-color-emoji-emoji-400-normal.woff2",
+	"Noto Color Emoji": "https://cdn.jsdelivr.net/npm/@fontsource/noto-color-emoji/files/noto-color-emoji-emoji-400-normal.woff2"
+};
+async function resolveGoogleFonts(resource, userAgent) {
+	if (!resource.url.startsWith("provider:google-fonts")) return null;
+	const urlObj = new URL(resource.url);
+	const family = urlObj.searchParams.get("family");
+	if (!family) return null;
+	const weight = urlObj.searchParams.get("weight") || "400";
+	const italic = urlObj.searchParams.get("italic") === "1";
+	const text = urlObj.searchParams.get("text") || resource.characters;
+	let targetFamily = family;
+	let forceNormalStyle = false;
+	if (targetFamily.includes("Noto Sans JP") || targetFamily.includes("Noto Serif JP") || targetFamily.includes("CJK")) forceNormalStyle = true;
+	const useItalic = italic && !forceNormalStyle;
+	let googleFontUrl = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(targetFamily)}:ital,wght@${useItalic ? "1" : "0"},${weight}&display=swap`;
+	if (text) {
+		if (text.length < 800) googleFontUrl += `&text=${encodeURIComponent(text)}`;
+	}
+	const headers = {};
+	if (userAgent) headers["User-Agent"] = userAgent;
+	try {
+		const resp = await fetch(googleFontUrl, { headers });
+		if (!resp.ok) return null;
+		const buf = await resp.arrayBuffer();
+		return new Uint8Array(buf);
+	} catch {
+		return null;
+	}
+}
+var SatoruBase = class {
+	factory;
+	modPromise;
+	currentFontMap = DEFAULT_FONT_MAP;
+	constructor(factory) {
+		this.factory = factory;
+	}
+	async getModule() {
+		if (!this.modPromise) this.modPromise = (async () => {
+			let currentLogLevel = LogLevel.None;
+			let currentUserOnLog;
+			const mod = await this.factory({
+				onLog: (level, message) => {
+					if (currentLogLevel !== LogLevel.None && level <= currentLogLevel && currentUserOnLog) currentUserOnLog(level, message);
+				},
+				print: (text) => {
+					if (currentLogLevel !== LogLevel.None && LogLevel.Info <= currentLogLevel && currentUserOnLog) currentUserOnLog(LogLevel.Info, text);
+				},
+				printErr: (text) => {
+					if (currentLogLevel !== LogLevel.None && LogLevel.Error <= currentLogLevel && currentUserOnLog) currentUserOnLog(LogLevel.Error, text);
+				}
+			});
+			mod.logLevel = LogLevel.None;
+			const originalSetLogLevel = mod.set_log_level;
+			mod.set_log_level = (level) => {
+				currentLogLevel = level;
+				originalSetLogLevel(level);
+			};
+			let internalOnLog = mod.onLog;
+			Object.defineProperty(mod, "onLog", {
+				get: () => internalOnLog,
+				set: (val) => {
+					internalOnLog = val;
+					currentUserOnLog = val;
+				}
+			});
+			let internalLogLevel = mod.logLevel;
+			Object.defineProperty(mod, "logLevel", {
+				get: () => internalLogLevel,
+				set: (val) => {
+					internalLogLevel = val;
+					currentLogLevel = val;
+				}
+			});
+			return mod;
+		})();
+		return this.modPromise;
+	}
+	async initDocument(options) {
+		const mod = await this.getModule();
+		const inst = mod.create_instance();
+		mod.init_document(inst, options.html, options.width, options.height ?? 0);
+		return inst;
+	}
+	async layoutDocument(inst, width) {
+		(await this.getModule()).layout_document(inst, width);
+	}
+	async renderFromState(inst, options) {
+		const mod = await this.getModule();
+		const format = {
+			svg: 0,
+			png: 1,
+			webp: 2,
+			pdf: 3
+		}[options.format ?? "svg"] ?? 0;
+		const result = mod.render_from_state(inst, options.width, options.height ?? 0, format, options.textToPaths ?? true);
+		if (!result) {
+			if (options.format === "svg") return "";
+			return new Uint8Array();
+		}
+		if (options.format === "svg") return new TextDecoder().decode(result);
+		return new Uint8Array(result);
+	}
+	async destroyInstance(inst) {
+		(await this.getModule()).destroy_instance(inst);
+	}
+	async loadFallbackFont(data) {
+		const mod = await this.getModule();
+		const inst = mod.create_instance();
+		try {
+			mod.load_fallback_font(inst, data);
+		} finally {
+			mod.destroy_instance(inst);
+		}
+	}
+	async render(options) {
+		let { format = "svg", value, url, baseUrl } = options;
+		if (format === "pdf" && Array.isArray(value) && value.length > 1) {
+			const pagePdfs = [];
+			const SatoruClass = this.constructor;
+			for (const html of value) {
+				const pagePdf = await (await SatoruClass.create()).render({
+					...options,
+					value: html,
+					format: "pdf"
+				});
+				pagePdfs.push(pagePdf);
+			}
+			const mod = await this.getModule();
+			const instancePtr = mod.create_instance();
+			try {
+				const result = mod.merge_pdfs(instancePtr, pagePdfs);
+				if (!result) return new Uint8Array();
+				return new Uint8Array(result.slice());
+			} finally {
+				mod.destroy_instance(instancePtr);
+			}
+		}
+		const mod = await this.getModule();
+		const { width, height = 0, fonts, images, css, logLevel, onLog } = options;
+		if (!options.userAgent) options.userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+		if (url && !value) {
+			if (!baseUrl) baseUrl = url;
+			value = await this.fetchHtml(url, options.userAgent);
+		}
+		if (!value) throw new Error("Either 'value' or 'url' must be provided.");
+		const prevLogLevel = mod.logLevel;
+		const prevOnLog = mod.onLog;
+		const prevFontMap = this.currentFontMap;
+		mod.logLevel = logLevel ?? LogLevel.None;
+		mod.set_log_level(mod.logLevel);
+		mod.onLog = onLog;
+		this.currentFontMap = options.fontMap ?? DEFAULT_FONT_MAP;
+		const instancePtr = mod.create_instance();
+		mod.set_font_map(instancePtr, this.currentFontMap);
+		try {
+			if (fonts) for (const f of fonts) mod.load_font(instancePtr, f.name, f.data);
+			if (options.fallbackFonts) for (const data of options.fallbackFonts) mod.load_fallback_font(instancePtr, data);
+			if (images) for (const img of images) mod.load_image(instancePtr, img.name, img.url, img.width ?? 0, img.height ?? 0);
+			if (css) mod.scan_css(instancePtr, css);
+			const defaultResolver = (r) => this.resolveDefaultResource(r, baseUrl, options.userAgent);
+			const resolver = options.resolveResource ? async (r) => {
+				return await options.resolveResource(r, defaultResolver);
+			} : defaultResolver;
+			const inputHtmls = Array.isArray(value) ? value : [value];
+			const processedHtmls = [];
+			const resolvedResources = /* @__PURE__ */ new Set();
+			for (const rawHtml of inputHtmls) {
+				let processedHtml = rawHtml;
+				for (let i = 0; i < 10; i++) {
+					mod.collect_resources(instancePtr, processedHtml, width, height);
+					const json = mod.get_pending_resources(instancePtr);
+					if (!json) break;
+					const pending = JSON.parse(json).filter((r) => {
+						const key = `${r.type}:${r.url}:${r.characters ?? ""}`;
+						return !resolvedResources.has(key);
+					});
+					if (pending.length === 0) break;
+					await Promise.all(pending.map(async (r) => {
+						try {
+							if (r.url.startsWith("data:")) return;
+							const key = `${r.type}:${r.url}:${r.characters ?? ""}`;
+							resolvedResources.add(key);
+							const data = await resolver({ ...r });
+							if (data && (data instanceof Uint8Array || ArrayBuffer.isView(data))) {
+								const uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+								if (r.type === "image" && typeof createImageBitmap !== "undefined" && typeof OffscreenCanvas !== "undefined") try {
+									const blob = new Blob([uint8.buffer]);
+									const bitmap = await createImageBitmap(blob);
+									const ctx = new OffscreenCanvas(bitmap.width, bitmap.height).getContext("2d");
+									if (ctx) {
+										ctx.drawImage(bitmap, 0, 0);
+										const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+										mod.load_image_pixels(instancePtr, r.url, bitmap.width, bitmap.height, new Uint8Array(imageData.data.buffer), r.url);
+										return;
+									}
+								} catch (e) {}
+								let typeInt = 1;
+								if (r.type === "image") typeInt = 2;
+								if (r.type === "css") typeInt = 3;
+								mod.add_resource(instancePtr, r.url, typeInt, uint8);
+							}
+						} catch (e) {
+							console.warn(`Failed to resolve resource: ${r.url}`, e);
+						}
+					}));
+				}
+				const resolvedUrls = /* @__PURE__ */ new Set();
+				resolvedResources.forEach((key) => {
+					const parts = key.split(":");
+					if (parts.length >= 2) resolvedUrls.add(parts.slice(1, -1).join(":"));
+				});
+				resolvedUrls.forEach((url) => {
+					const escapedUrl = url.replace(/[.*+?^${}()|[\]]/g, "\\$&");
+					const linkRegex = new RegExp(`<link[^>]*href\\s*=\\s*(["']?)${escapedUrl}\\1[^>]*>`, "gi");
+					processedHtml = processedHtml.replace(linkRegex, "");
+				});
+				processedHtmls.push(processedHtml);
+			}
+			const result = mod.render(instancePtr, processedHtmls, width, height, {
+				svg: 0,
+				png: 1,
+				webp: 2,
+				pdf: 3
+			}[format] ?? 0, options.textToPaths ?? true);
+			if (!result) {
+				if (format === "svg") return "";
+				return new Uint8Array();
+			}
+			if (format === "svg") return new TextDecoder().decode(result);
+			return new Uint8Array(result.slice());
+		} finally {
+			mod.destroy_instance(instancePtr);
+			mod.logLevel = prevLogLevel;
+			mod.onLog = prevOnLog;
+			this.currentFontMap = prevFontMap;
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+var Satoru = class Satoru extends SatoruBase {
+	static async create(createSatoruModuleFunc) {
+		return new Satoru(createSatoruModuleFunc);
+	}
+	/**
+	* Captures an HTMLElement and returns an HTMLCanvasElement.
+	* Similar to html2canvas.
+	*/
+	async capture(element, options = {}) {
+		const rect = element.getBoundingClientRect();
+		const width = options.width ?? Math.ceil(rect.width);
+		const height = options.height ?? Math.ceil(rect.height);
+		const serializedHtml = this.serializeElement(element);
+		const pngData = await this.render({
+			...options,
+			value: serializedHtml,
+			width,
+			height,
+			format: "png"
+		});
+		return this.pngToCanvas(pngData, width, height);
+	}
+	serializeElement(element) {
+		const clone = element.cloneNode(true);
+		const absoluteUrl = (url) => {
+			if (!url || url.startsWith("data:") || url.startsWith("blob:")) return url;
+			const a = document.createElement("a");
+			a.href = url;
+			return a.href;
+		};
+		const applyStyles = (src, dest) => {
+			const computed = window.getComputedStyle(src);
+			const styleArr = [];
+			for (let i = 0; i < computed.length; i++) {
+				const prop = computed[i];
+				let value = computed.getPropertyValue(prop);
+				if (value.includes("url(")) value = value.replace(/url\(['"]?([^'"]+)['"]?\)/g, (match, url) => {
+					return `url("${absoluteUrl(url)}")`;
+				});
+				styleArr.push(`${prop}:${value}`);
+			}
+			dest.setAttribute("style", styleArr.join(";"));
+			const handlePseudo = (pseudoType) => {
+				const style = window.getComputedStyle(src, pseudoType);
+				const content = style.getPropertyValue("content");
+				if (!content || content === "none" || content === "normal") return;
+				const pseudoEl = document.createElement("span");
+				const pseudoStyles = [];
+				for (let i = 0; i < style.length; i++) {
+					const prop = style[i];
+					pseudoStyles.push(`${prop}:${style.getPropertyValue(prop)}`);
+				}
+				pseudoEl.setAttribute("style", pseudoStyles.join(";"));
+				if (content.startsWith("\"") && content.endsWith("\"")) pseudoEl.innerText = content.slice(1, -1);
+				if (pseudoType === "::before") dest.prepend(pseudoEl);
+				else dest.append(pseudoEl);
+			};
+			handlePseudo("::before");
+			handlePseudo("::after");
+			if (typeof HTMLCanvasElement !== "undefined" && src instanceof HTMLCanvasElement) {
+				const img = document.createElement("img");
+				img.src = src.toDataURL();
+				img.setAttribute("style", dest.getAttribute("style") || "");
+				dest.replaceWith(img);
+			} else if (typeof HTMLImageElement !== "undefined" && src instanceof HTMLImageElement) dest.setAttribute("src", absoluteUrl(src.src));
+			else if (typeof HTMLInputElement !== "undefined" && src instanceof HTMLInputElement) if (src.type === "checkbox" || src.type === "radio") {
+				if (src.checked) dest.setAttribute("checked", "");
+			} else dest.setAttribute("value", src.value);
+			else if (typeof HTMLTextAreaElement !== "undefined" && src instanceof HTMLTextAreaElement) dest.innerText = src.value;
+			else if (typeof HTMLSelectElement !== "undefined" && src instanceof HTMLSelectElement) {
+				const index = src.selectedIndex;
+				const clonedSelect = dest;
+				if (clonedSelect.options[index]) clonedSelect.options[index].setAttribute("selected", "");
+			}
+			for (let i = 0; i < src.children.length; i++) {
+				const srcChild = src.children[i];
+				const destChild = dest.children[i];
+				if (srcChild && destChild) applyStyles(srcChild, destChild);
+			}
+		};
+		applyStyles(element, clone);
+		return `<!DOCTYPE html><html><body style="margin:0;padding:0;overflow:hidden;background:transparent;">${clone.outerHTML}</body></html>`;
+	}
+	async pngToCanvas(data, width, height) {
+		const blob = new Blob([data], { type: "image/png" });
+		const url = URL.createObjectURL(blob);
+		try {
+			const img = new Image();
+			img.crossOrigin = "anonymous";
+			await new Promise((resolve, reject) => {
+				img.onload = resolve;
+				img.onerror = reject;
+				img.src = url;
+			});
+			const canvas = document.createElement("canvas");
+			canvas.width = width;
+			canvas.height = height;
+			const ctx = canvas.getContext("2d");
+			if (ctx) ctx.drawImage(img, 0, 0);
+			return canvas;
+		} finally {
+			URL.revokeObjectURL(url);
+		}
+	}
+	async render(options) {
+		if (options.value) {
+			const values = Array.isArray(options.value) ? options.value : [options.value];
+			const processedValues = [];
+			let hasElement = false;
+			for (const val of values) if (typeof HTMLElement !== "undefined" && val instanceof HTMLElement) {
+				processedValues.push(this.serializeElement(val));
+				hasElement = true;
+			} else processedValues.push(val);
+			if (hasElement) options = {
+				...options,
+				value: Array.isArray(options.value) ? processedValues : processedValues[0]
+			};
+		}
+		return super.render(options);
+	}
+	static async defaultResourceResolver(resource, baseUrl, userAgent) {
+		try {
+			if (resource.url.startsWith("provider:google-fonts")) return resolveGoogleFonts(resource, userAgent);
+			const isAbsolute = /^[a-z][a-z0-9+.-]*:/i.test(resource.url);
+			let finalUrl = null;
+			if (isAbsolute) finalUrl = resource.url;
+			else if (baseUrl && /^[a-z][a-z0-9+.-]*:/i.test(baseUrl)) finalUrl = new URL(resource.url, baseUrl).href;
+			if (!finalUrl) return null;
+			const headers = {};
+			if (userAgent) headers["User-Agent"] = userAgent;
+			const resp = await fetch(finalUrl, { headers });
+			if (!resp.ok) return null;
+			const buf = await resp.arrayBuffer();
+			return new Uint8Array(buf);
+		} catch (e) {
+			console.warn(`[Satoru] Failed to resolve resource: ${resource.url}`, e);
+			return null;
+		}
+	}
+	resolveDefaultResource(resource, baseUrl, userAgent) {
+		return Satoru.defaultResourceResolver(resource, baseUrl, userAgent);
+	}
+	async fetchHtml(url, userAgent) {
+		const headers = {};
+		if (userAgent) headers["User-Agent"] = userAgent;
+		const resp = await fetch(url, { headers });
+		if (!resp.ok) throw new Error(`Failed to fetch HTML from URL: ${url} (${resp.status})`);
+		return await resp.text();
+	}
+};
+//#endregion
+//#region src/workers.ts
+/**
+* Create a Satoru worker proxy using worker-lib.
+* @param params Initialization parameters
+* @param params.worker Optional: Path to the worker file, a URL, or a factory function.
+*                      Defaults to the bundled workers.js in the same directory.
+* @param params.maxParallel Maximum number of parallel workers
+*/
+const createSatoruWorker = (params) => {
+	const { worker, maxParallel = 4 } = params ?? {};
+	const factory = () => {
+		let w$1;
+		if (worker) w$1 = typeof worker === "function" ? worker() : worker;
+		else {
+			const workerUrl = typeof window !== "undefined" ? new URL("./web-workers.js", import.meta.url) : new URL("./child-workers.js", import.meta.url);
+			if (typeof w !== "undefined") w$1 = new w(workerUrl, { type: "module" });
+		}
+		if (!w$1) throw new Error("Worker is not supported in this environment.");
+		return w$1;
+	};
+	const workerInstance = createWorker(factory, maxParallel);
+	return new Proxy(workerInstance, { get(target, prop, receiver) {
+		if (prop === "render") return async (options) => {
+			return await target.execute("render", options);
+		};
+		if (prop in target) return Reflect.get(target, prop, receiver);
+		return (...args) => target.execute(prop, ...args);
+	} });
+};
+const { close, render, launchWorker, setLimit, waitAll, waitReady } = createSatoruWorker({ maxParallel: 1 });
+//#endregion
+export { DEFAULT_FONT_MAP, LogLevel, Satoru, SatoruBase, close, createSatoruWorker, launchWorker, render, resolveGoogleFonts, setLimit, waitAll, waitReady };