likec4 1.59.4 → 1.60.0

package/__app__/src/chunks/es.mjs

@@ -1,439 +1,619 @@
 import "./rolldown-runtime.mjs";
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/util.js
-function resolveUrl(e, t) {
-	if (e.match(/^[a-z]+:\/\//i)) return e;
-	if (e.match(/^\/\//)) return window.location.protocol + e;
-	if (e.match(/^[a-z]+:/i)) return e;
-	let n = document.implementation.createHTMLDocument(), r = n.createElement("base"), i = n.createElement("a");
-	return n.head.appendChild(r), n.body.appendChild(i), t && (r.href = t), i.href = e, i.href;
-}
-var e = (() => {
-	let e = 0, random = () => `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4);
-	return () => (e += 1, `u${random()}${e}`);
+function resolveUrl(url, baseUrl) {
+	if (url.match(/^[a-z]+:\/\//i)) return url;
+	if (url.match(/^\/\//)) return window.location.protocol + url;
+	if (url.match(/^[a-z]+:/i)) return url;
+	const doc = document.implementation.createHTMLDocument();
+	const base = doc.createElement("base");
+	const a = doc.createElement("a");
+	doc.head.appendChild(base);
+	doc.body.appendChild(a);
+	if (baseUrl) base.href = baseUrl;
+	a.href = url;
+	return a.href;
+}
+var uuid = (() => {
+	let counter = 0;
+	const random = () => `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4);
+	return () => {
+		counter += 1;
+		return `u${random()}${counter}`;
+	};
 })();
-function toArray(e) {
-	let t = [];
-	for (let n = 0, r = e.length; n < r; n++) t.push(e[n]);
-	return t;
-}
-function px(e, t) {
-	let n = (e.ownerDocument.defaultView || window).getComputedStyle(e).getPropertyValue(t);
-	return n ? parseFloat(n.replace("px", "")) : 0;
-}
-function getNodeWidth(e) {
-	let t = px(e, "border-left-width"), n = px(e, "border-right-width");
-	return e.clientWidth + t + n;
-}
-function getNodeHeight(e) {
-	let t = px(e, "border-top-width"), n = px(e, "border-bottom-width");
-	return e.clientHeight + t + n;
-}
-function getImageSize(e, t = {}) {
+function toArray(arrayLike) {
+	const arr = [];
+	for (let i = 0, l = arrayLike.length; i < l; i++) arr.push(arrayLike[i]);
+	return arr;
+}
+function px(node, styleProperty) {
+	const val = (node.ownerDocument.defaultView || window).getComputedStyle(node).getPropertyValue(styleProperty);
+	return val ? parseFloat(val.replace("px", "")) : 0;
+}
+function getNodeWidth(node) {
+	const leftBorder = px(node, "border-left-width");
+	const rightBorder = px(node, "border-right-width");
+	return node.clientWidth + leftBorder + rightBorder;
+}
+function getNodeHeight(node) {
+	const topBorder = px(node, "border-top-width");
+	const bottomBorder = px(node, "border-bottom-width");
+	return node.clientHeight + topBorder + bottomBorder;
+}
+function getImageSize(targetNode, options = {}) {
 	return {
-		width: t.width || getNodeWidth(e),
-		height: t.height || getNodeHeight(e)
+		width: options.width || getNodeWidth(targetNode),
+		height: options.height || getNodeHeight(targetNode)
 	};
 }
 function getPixelRatio() {
-	let e, t;
+	let ratio;
+	let FINAL_PROCESS;
 	try {
-		t = process;
-	} catch {}
-	let n = t && t.env ? t.env.devicePixelRatio : null;
-	return n && (e = parseInt(n, 10), Number.isNaN(e) && (e = 1)), e || window.devicePixelRatio || 1;
-}
-var t = 16384;
-function checkCanvasDimensions(e) {
-	(e.width > t || e.height > t) && (e.width > t && e.height > t ? e.width > e.height ? (e.height *= t / e.width, e.width = t) : (e.width *= t / e.height, e.height = t) : e.width > t ? (e.height *= t / e.width, e.width = t) : (e.width *= t / e.height, e.height = t));
-}
-function canvasToBlob(e, t = {}) {
-	return e.toBlob ? new Promise((n) => {
-		e.toBlob(n, t.type ? t.type : "image/png", t.quality ? t.quality : 1);
-	}) : new Promise((n) => {
-		let r = window.atob(e.toDataURL(t.type ? t.type : void 0, t.quality ? t.quality : void 0).split(",")[1]), i = r.length, a = new Uint8Array(i);
-		for (let e = 0; e < i; e += 1) a[e] = r.charCodeAt(e);
-		n(new Blob([a], { type: t.type ? t.type : "image/png" }));
-	});
+		FINAL_PROCESS = process;
+	} catch (e) {}
+	const val = FINAL_PROCESS && FINAL_PROCESS.env ? FINAL_PROCESS.env.devicePixelRatio : null;
+	if (val) {
+		ratio = parseInt(val, 10);
+		if (Number.isNaN(ratio)) ratio = 1;
+	}
+	return ratio || window.devicePixelRatio || 1;
+}
+var canvasDimensionLimit = 16384;
+function checkCanvasDimensions(canvas) {
+	if (canvas.width > canvasDimensionLimit || canvas.height > canvasDimensionLimit) {
+		if (canvas.width > canvasDimensionLimit && canvas.height > canvasDimensionLimit) {
+			if (canvas.width > canvas.height) {
+				canvas.height *= canvasDimensionLimit / canvas.width;
+				canvas.width = canvasDimensionLimit;
+			} else {
+				canvas.width *= canvasDimensionLimit / canvas.height;
+				canvas.height = canvasDimensionLimit;
+			}
+		} else if (canvas.width > canvasDimensionLimit) {
+			canvas.height *= canvasDimensionLimit / canvas.width;
+			canvas.width = canvasDimensionLimit;
+		} else {
+			canvas.width *= canvasDimensionLimit / canvas.height;
+			canvas.height = canvasDimensionLimit;
+		}
+	}
 }
-function createImage(e) {
-	return new Promise((t, n) => {
-		let r = new Image();
-		r.decode = () => t(r), r.onload = () => t(r), r.onerror = n, r.crossOrigin = "anonymous", r.decoding = "async", r.src = e;
+function canvasToBlob(canvas, options = {}) {
+	if (canvas.toBlob) return new Promise((resolve) => {
+		canvas.toBlob(resolve, options.type ? options.type : "image/png", options.quality ? options.quality : 1);
+	});
+	return new Promise((resolve) => {
+		const binaryString = window.atob(canvas.toDataURL(options.type ? options.type : void 0, options.quality ? options.quality : void 0).split(",")[1]);
+		const len = binaryString.length;
+		const binaryArray = new Uint8Array(len);
+		for (let i = 0; i < len; i += 1) binaryArray[i] = binaryString.charCodeAt(i);
+		resolve(new Blob([binaryArray], { type: options.type ? options.type : "image/png" }));
 	});
 }
-async function svgToDataURL(e) {
-	return Promise.resolve().then(() => new XMLSerializer().serializeToString(e)).then(encodeURIComponent).then((e) => `data:image/svg+xml;charset=utf-8,${e}`);
-}
-async function nodeToDataURL(e, t, n) {
-	let r = "http://www.w3.org/2000/svg", i = document.createElementNS(r, "svg"), a = document.createElementNS(r, "foreignObject");
-	return i.setAttribute("width", `${t}`), i.setAttribute("height", `${n}`), i.setAttribute("viewBox", `0 0 ${t} ${n}`), a.setAttribute("width", "100%"), a.setAttribute("height", "100%"), a.setAttribute("x", "0"), a.setAttribute("y", "0"), a.setAttribute("externalResourcesRequired", "true"), i.appendChild(a), a.appendChild(e), svgToDataURL(i);
+function createImage(url) {
+	return new Promise((resolve, reject) => {
+		const img = new Image();
+		img.decode = () => resolve(img);
+		img.onload = () => resolve(img);
+		img.onerror = reject;
+		img.crossOrigin = "anonymous";
+		img.decoding = "async";
+		img.src = url;
+	});
 }
-var isInstanceOfElement = (e, t) => {
-	if (e instanceof t) return !0;
-	let n = Object.getPrototypeOf(e);
-	return n === null ? !1 : n.constructor.name === t.name || isInstanceOfElement(n, t);
+async function svgToDataURL(svg) {
+	return Promise.resolve().then(() => new XMLSerializer().serializeToString(svg)).then(encodeURIComponent).then((html) => `data:image/svg+xml;charset=utf-8,${html}`);
+}
+async function nodeToDataURL(node, width, height) {
+	const xmlns = "http://www.w3.org/2000/svg";
+	const svg = document.createElementNS(xmlns, "svg");
+	const foreignObject = document.createElementNS(xmlns, "foreignObject");
+	svg.setAttribute("width", `${width}`);
+	svg.setAttribute("height", `${height}`);
+	svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+	foreignObject.setAttribute("width", "100%");
+	foreignObject.setAttribute("height", "100%");
+	foreignObject.setAttribute("x", "0");
+	foreignObject.setAttribute("y", "0");
+	foreignObject.setAttribute("externalResourcesRequired", "true");
+	svg.appendChild(foreignObject);
+	foreignObject.appendChild(node);
+	return svgToDataURL(svg);
+}
+var isInstanceOfElement = (node, instance) => {
+	if (node instanceof instance) return true;
+	const nodePrototype = Object.getPrototypeOf(node);
+	if (nodePrototype === null) return false;
+	return nodePrototype.constructor.name === instance.name || isInstanceOfElement(nodePrototype, instance);
 };
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/clone-pseudos.js
-function formatCSSText(e) {
-	let t = e.getPropertyValue("content");
-	return `${e.cssText} content: '${t.replace(/'|"/g, "")}';`;
-}
-function formatCSSProperties(e) {
-	return toArray(e).map((t) => `${t}: ${e.getPropertyValue(t)}${e.getPropertyPriority(t) ? " !important" : ""};`).join(" ");
-}
-function getPseudoElementStyle(e, t, n) {
-	let r = `.${e}:${t}`, i = n.cssText ? formatCSSText(n) : formatCSSProperties(n);
-	return document.createTextNode(`${r}{${i}}`);
-}
-function clonePseudoElement(t, n, r) {
-	let i = window.getComputedStyle(t, r), a = i.getPropertyValue("content");
-	if (a === "" || a === "none") return;
-	let o = e();
+function formatCSSText(style) {
+	const content = style.getPropertyValue("content");
+	return `${style.cssText} content: '${content.replace(/'|"/g, "")}';`;
+}
+function formatCSSProperties(style) {
+	return toArray(style).map((name) => {
+		return `${name}: ${style.getPropertyValue(name)}${style.getPropertyPriority(name) ? " !important" : ""};`;
+	}).join(" ");
+}
+function getPseudoElementStyle(className, pseudo, style) {
+	const selector = `.${className}:${pseudo}`;
+	const cssText = style.cssText ? formatCSSText(style) : formatCSSProperties(style);
+	return document.createTextNode(`${selector}{${cssText}}`);
+}
+function clonePseudoElement(nativeNode, clonedNode, pseudo) {
+	const style = window.getComputedStyle(nativeNode, pseudo);
+	const content = style.getPropertyValue("content");
+	if (content === "" || content === "none") return;
+	const className = uuid();
 	try {
-		n.className = `${n.className} ${o}`;
-	} catch {
+		clonedNode.className = `${clonedNode.className} ${className}`;
+	} catch (err) {
 		return;
 	}
-	let s = document.createElement("style");
-	s.appendChild(getPseudoElementStyle(o, r, i)), n.appendChild(s);
+	const styleElement = document.createElement("style");
+	styleElement.appendChild(getPseudoElementStyle(className, pseudo, style));
+	clonedNode.appendChild(styleElement);
 }
-function clonePseudoElements(e, t) {
-	clonePseudoElement(e, t, ":before"), clonePseudoElement(e, t, ":after");
+function clonePseudoElements(nativeNode, clonedNode) {
+	clonePseudoElement(nativeNode, clonedNode, ":before");
+	clonePseudoElement(nativeNode, clonedNode, ":after");
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/mimes.js
-var n = "application/font-woff", r = "image/jpeg", i = {
-	woff: n,
-	woff2: n,
+var WOFF = "application/font-woff";
+var JPEG = "image/jpeg";
+var mimes = {
+	woff: WOFF,
+	woff2: WOFF,
 	ttf: "application/font-truetype",
 	eot: "application/vnd.ms-fontobject",
 	png: "image/png",
-	jpg: r,
-	jpeg: r,
+	jpg: JPEG,
+	jpeg: JPEG,
 	gif: "image/gif",
 	tiff: "image/tiff",
 	svg: "image/svg+xml",
 	webp: "image/webp"
 };
-function getExtension(e) {
-	let t = /\.([^./]*?)$/g.exec(e);
-	return t ? t[1] : "";
+function getExtension(url) {
+	const match = /\.([^./]*?)$/g.exec(url);
+	return match ? match[1] : "";
 }
-function getMimeType(e) {
-	return i[getExtension(e).toLowerCase()] || "";
+function getMimeType(url) {
+	return mimes[getExtension(url).toLowerCase()] || "";
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/dataurl.js
-function getContentFromDataUrl(e) {
-	return e.split(/,/)[1];
-}
-function isDataUrl(e) {
-	return e.search(/^(data:)/) !== -1;
-}
-function makeDataUrl(e, t) {
-	return `data:${t};base64,${e}`;
-}
-async function fetchAsDataURL(e, t, n) {
-	let r = await fetch(e, t);
-	if (r.status === 404) throw Error(`Resource "${r.url}" not found`);
-	let i = await r.blob();
-	return new Promise((e, t) => {
-		let a = new FileReader();
-		a.onerror = t, a.onloadend = () => {
+function getContentFromDataUrl(dataURL) {
+	return dataURL.split(/,/)[1];
+}
+function isDataUrl(url) {
+	return url.search(/^(data:)/) !== -1;
+}
+function makeDataUrl(content, mimeType) {
+	return `data:${mimeType};base64,${content}`;
+}
+async function fetchAsDataURL(url, init, process) {
+	const res = await fetch(url, init);
+	if (res.status === 404) throw new Error(`Resource "${res.url}" not found`);
+	const blob = await res.blob();
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onerror = reject;
+		reader.onloadend = () => {
 			try {
-				e(n({
-					res: r,
-					result: a.result
+				resolve(process({
+					res,
+					result: reader.result
 				}));
-			} catch (e) {
-				t(e);
+			} catch (error) {
+				reject(error);
 			}
-		}, a.readAsDataURL(i);
+		};
+		reader.readAsDataURL(blob);
 	});
 }
-var a = {};
-function getCacheKey(e, t, n) {
-	let r = e.replace(/\?.*/, "");
-	return n && (r = e), /ttf|otf|eot|woff2?/i.test(r) && (r = r.replace(/.*\//, "")), t ? `[${t}]${r}` : r;
-}
-async function resourceToDataURL(e, t, n) {
-	let r = getCacheKey(e, t, n.includeQueryParams);
-	if (a[r] != null) return a[r];
-	n.cacheBust && (e += (/\?/.test(e) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime());
-	let i;
+var cache = {};
+function getCacheKey(url, contentType, includeQueryParams) {
+	let key = url.replace(/\?.*/, "");
+	if (includeQueryParams) key = url;
+	if (/ttf|otf|eot|woff2?/i.test(key)) key = key.replace(/.*\//, "");
+	return contentType ? `[${contentType}]${key}` : key;
+}
+async function resourceToDataURL(resourceUrl, contentType, options) {
+	const cacheKey = getCacheKey(resourceUrl, contentType, options.includeQueryParams);
+	if (cache[cacheKey] != null) return cache[cacheKey];
+	if (options.cacheBust) resourceUrl += (/\?/.test(resourceUrl) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime();
+	let dataURL;
 	try {
-		i = makeDataUrl(await fetchAsDataURL(e, n.fetchRequestInit, ({ res: e, result: n }) => (t ||= e.headers.get("Content-Type") || "", getContentFromDataUrl(n))), t);
-	} catch (t) {
-		i = n.imagePlaceholder || "";
-		let r = `Failed to fetch resource: ${e}`;
-		t && (r = typeof t == "string" ? t : t.message), r && console.warn(r);
+		dataURL = makeDataUrl(await fetchAsDataURL(resourceUrl, options.fetchRequestInit, ({ res, result }) => {
+			if (!contentType) contentType = res.headers.get("Content-Type") || "";
+			return getContentFromDataUrl(result);
+		}), contentType);
+	} catch (error) {
+		dataURL = options.imagePlaceholder || "";
+		let msg = `Failed to fetch resource: ${resourceUrl}`;
+		if (error) msg = typeof error === "string" ? error : error.message;
+		if (msg) console.warn(msg);
 	}
-	return a[r] = i, i;
+	cache[cacheKey] = dataURL;
+	return dataURL;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/clone-node.js
-async function cloneCanvasElement(e) {
-	let t = e.toDataURL();
-	return t === "data:," ? e.cloneNode(!1) : createImage(t);
-}
-async function cloneVideoElement(e, t) {
-	if (e.currentSrc) {
-		let t = document.createElement("canvas"), n = t.getContext("2d");
-		return t.width = e.clientWidth, t.height = e.clientHeight, n?.drawImage(e, 0, 0, t.width, t.height), createImage(t.toDataURL());
+async function cloneCanvasElement(canvas) {
+	const dataURL = canvas.toDataURL();
+	if (dataURL === "data:,") return canvas.cloneNode(false);
+	return createImage(dataURL);
+}
+async function cloneVideoElement(video, options) {
+	if (video.currentSrc) {
+		const canvas = document.createElement("canvas");
+		const ctx = canvas.getContext("2d");
+		canvas.width = video.clientWidth;
+		canvas.height = video.clientHeight;
+		ctx === null || ctx === void 0 || ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+		return createImage(canvas.toDataURL());
 	}
-	let n = e.poster;
-	return createImage(await resourceToDataURL(n, getMimeType(n), t));
+	const poster = video.poster;
+	return createImage(await resourceToDataURL(poster, getMimeType(poster), options));
 }
-async function cloneIFrameElement(e) {
+async function cloneIFrameElement(iframe) {
+	var _a;
 	try {
-		if (e?.contentDocument?.body) return await cloneNode(e.contentDocument.body, {}, !0);
-	} catch {}
-	return e.cloneNode(!1);
-}
-async function cloneSingleNode(e, t) {
-	return isInstanceOfElement(e, HTMLCanvasElement) ? cloneCanvasElement(e) : isInstanceOfElement(e, HTMLVideoElement) ? cloneVideoElement(e, t) : isInstanceOfElement(e, HTMLIFrameElement) ? cloneIFrameElement(e) : e.cloneNode(!1);
-}
-var isSlotElement = (e) => e.tagName != null && e.tagName.toUpperCase() === "SLOT";
-async function cloneChildren(e, t, n) {
-	let r = [];
-	return r = isSlotElement(e) && e.assignedNodes ? toArray(e.assignedNodes()) : isInstanceOfElement(e, HTMLIFrameElement) && e.contentDocument?.body ? toArray(e.contentDocument.body.childNodes) : toArray((e.shadowRoot ?? e).childNodes), r.length === 0 || isInstanceOfElement(e, HTMLVideoElement) || await r.reduce((e, r) => e.then(() => cloneNode(r, n)).then((e) => {
-		e && t.appendChild(e);
-	}), Promise.resolve()), t;
-}
-function cloneCSSStyle(e, t) {
-	let n = t.style;
-	if (!n) return;
-	let r = window.getComputedStyle(e);
-	r.cssText ? (n.cssText = r.cssText, n.transformOrigin = r.transformOrigin) : toArray(r).forEach((i) => {
-		let a = r.getPropertyValue(i);
-		i === "font-size" && a.endsWith("px") && (a = `${Math.floor(parseFloat(a.substring(0, a.length - 2))) - .1}px`), isInstanceOfElement(e, HTMLIFrameElement) && i === "display" && a === "inline" && (a = "block"), i === "d" && t.getAttribute("d") && (a = `path(${t.getAttribute("d")})`), n.setProperty(i, a, r.getPropertyPriority(i));
+		if ((_a = iframe === null || iframe === void 0 ? void 0 : iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.body) return await cloneNode(iframe.contentDocument.body, {}, true);
+	} catch (_b) {}
+	return iframe.cloneNode(false);
+}
+async function cloneSingleNode(node, options) {
+	if (isInstanceOfElement(node, HTMLCanvasElement)) return cloneCanvasElement(node);
+	if (isInstanceOfElement(node, HTMLVideoElement)) return cloneVideoElement(node, options);
+	if (isInstanceOfElement(node, HTMLIFrameElement)) return cloneIFrameElement(node);
+	return node.cloneNode(false);
+}
+var isSlotElement = (node) => node.tagName != null && node.tagName.toUpperCase() === "SLOT";
+async function cloneChildren(nativeNode, clonedNode, options) {
+	var _a;
+	var _b;
+	let children = [];
+	if (isSlotElement(nativeNode) && nativeNode.assignedNodes) children = toArray(nativeNode.assignedNodes());
+	else if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && ((_a = nativeNode.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) children = toArray(nativeNode.contentDocument.body.childNodes);
+	else children = toArray(((_b = nativeNode.shadowRoot) !== null && _b !== void 0 ? _b : nativeNode).childNodes);
+	if (children.length === 0 || isInstanceOfElement(nativeNode, HTMLVideoElement)) return clonedNode;
+	await children.reduce((deferred, child) => deferred.then(() => cloneNode(child, options)).then((clonedChild) => {
+		if (clonedChild) clonedNode.appendChild(clonedChild);
+	}), Promise.resolve());
+	return clonedNode;
+}
+function cloneCSSStyle(nativeNode, clonedNode) {
+	const targetStyle = clonedNode.style;
+	if (!targetStyle) return;
+	const sourceStyle = window.getComputedStyle(nativeNode);
+	if (sourceStyle.cssText) {
+		targetStyle.cssText = sourceStyle.cssText;
+		targetStyle.transformOrigin = sourceStyle.transformOrigin;
+	} else toArray(sourceStyle).forEach((name) => {
+		let value = sourceStyle.getPropertyValue(name);
+		if (name === "font-size" && value.endsWith("px")) value = `${Math.floor(parseFloat(value.substring(0, value.length - 2))) - .1}px`;
+		if (isInstanceOfElement(nativeNode, HTMLIFrameElement) && name === "display" && value === "inline") value = "block";
+		if (name === "d" && clonedNode.getAttribute("d")) value = `path(${clonedNode.getAttribute("d")})`;
+		targetStyle.setProperty(name, value, sourceStyle.getPropertyPriority(name));
 	});
 }
-function cloneInputValue(e, t) {
-	isInstanceOfElement(e, HTMLTextAreaElement) && (t.innerHTML = e.value), isInstanceOfElement(e, HTMLInputElement) && t.setAttribute("value", e.value);
+function cloneInputValue(nativeNode, clonedNode) {
+	if (isInstanceOfElement(nativeNode, HTMLTextAreaElement)) clonedNode.innerHTML = nativeNode.value;
+	if (isInstanceOfElement(nativeNode, HTMLInputElement)) clonedNode.setAttribute("value", nativeNode.value);
 }
-function cloneSelectValue(e, t) {
-	if (isInstanceOfElement(e, HTMLSelectElement)) {
-		let n = t, r = Array.from(n.children).find((t) => e.value === t.getAttribute("value"));
-		r && r.setAttribute("selected", "");
+function cloneSelectValue(nativeNode, clonedNode) {
+	if (isInstanceOfElement(nativeNode, HTMLSelectElement)) {
+		const clonedSelect = clonedNode;
+		const selectedOption = Array.from(clonedSelect.children).find((child) => nativeNode.value === child.getAttribute("value"));
+		if (selectedOption) selectedOption.setAttribute("selected", "");
 	}
 }
-function decorate(e, t) {
-	return isInstanceOfElement(t, Element) && (cloneCSSStyle(e, t), clonePseudoElements(e, t), cloneInputValue(e, t), cloneSelectValue(e, t)), t;
-}
-async function ensureSVGSymbols(e, t) {
-	let n = e.querySelectorAll ? e.querySelectorAll("use") : [];
-	if (n.length === 0) return e;
-	let r = {};
-	for (let i = 0; i < n.length; i++) {
-		let a = n[i].getAttribute("xlink:href");
-		if (a) {
-			let n = e.querySelector(a), i = document.querySelector(a);
-			!n && i && !r[a] && (r[a] = await cloneNode(i, t, !0));
+function decorate(nativeNode, clonedNode) {
+	if (isInstanceOfElement(clonedNode, Element)) {
+		cloneCSSStyle(nativeNode, clonedNode);
+		clonePseudoElements(nativeNode, clonedNode);
+		cloneInputValue(nativeNode, clonedNode);
+		cloneSelectValue(nativeNode, clonedNode);
+	}
+	return clonedNode;
+}
+async function ensureSVGSymbols(clone, options) {
+	const uses = clone.querySelectorAll ? clone.querySelectorAll("use") : [];
+	if (uses.length === 0) return clone;
+	const processedDefs = {};
+	for (let i = 0; i < uses.length; i++) {
+		const id = uses[i].getAttribute("xlink:href");
+		if (id) {
+			const exist = clone.querySelector(id);
+			const definition = document.querySelector(id);
+			if (!exist && definition && !processedDefs[id]) processedDefs[id] = await cloneNode(definition, options, true);
 		}
 	}
-	let i = Object.values(r);
-	if (i.length) {
-		let t = "http://www.w3.org/1999/xhtml", n = document.createElementNS(t, "svg");
-		n.setAttribute("xmlns", t), n.style.position = "absolute", n.style.width = "0", n.style.height = "0", n.style.overflow = "hidden", n.style.display = "none";
-		let r = document.createElementNS(t, "defs");
-		n.appendChild(r);
-		for (let e = 0; e < i.length; e++) r.appendChild(i[e]);
-		e.appendChild(n);
+	const nodes = Object.values(processedDefs);
+	if (nodes.length) {
+		const ns = "http://www.w3.org/1999/xhtml";
+		const svg = document.createElementNS(ns, "svg");
+		svg.setAttribute("xmlns", ns);
+		svg.style.position = "absolute";
+		svg.style.width = "0";
+		svg.style.height = "0";
+		svg.style.overflow = "hidden";
+		svg.style.display = "none";
+		const defs = document.createElementNS(ns, "defs");
+		svg.appendChild(defs);
+		for (let i = 0; i < nodes.length; i++) defs.appendChild(nodes[i]);
+		clone.appendChild(svg);
 	}
-	return e;
+	return clone;
 }
-async function cloneNode(e, t, n) {
-	return !n && t.filter && !t.filter(e) ? null : Promise.resolve(e).then((e) => cloneSingleNode(e, t)).then((n) => cloneChildren(e, n, t)).then((t) => decorate(e, t)).then((e) => ensureSVGSymbols(e, t));
+async function cloneNode(node, options, isRoot) {
+	if (!isRoot && options.filter && !options.filter(node)) return null;
+	return Promise.resolve(node).then((clonedNode) => cloneSingleNode(clonedNode, options)).then((clonedNode) => cloneChildren(node, clonedNode, options)).then((clonedNode) => decorate(node, clonedNode)).then((clonedNode) => ensureSVGSymbols(clonedNode, options));
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/embed-resources.js
-var o = /url\((['"]?)([^'"]+?)\1\)/g, s = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g, c = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
-function toRegex(e) {
-	let t = e.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1");
-	return RegExp(`(url\\(['"]?)(${t})(['"]?\\))`, "g");
-}
-function parseURLs(e) {
-	let t = [];
-	return e.replace(o, (e, n, r) => (t.push(r), e)), t.filter((e) => !isDataUrl(e));
+var URL_REGEX = /url\((['"]?)([^'"]+?)\1\)/g;
+var URL_WITH_FORMAT_REGEX = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g;
+var FONT_SRC_REGEX = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
+function toRegex(url) {
+	const escaped = url.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1");
+	return new RegExp(`(url\\(['"]?)(${escaped})(['"]?\\))`, "g");
+}
+function parseURLs(cssText) {
+	const urls = [];
+	cssText.replace(URL_REGEX, (raw, quotation, url) => {
+		urls.push(url);
+		return raw;
+	});
+	return urls.filter((url) => !isDataUrl(url));
 }
-async function embed(e, t, n, r, i) {
+async function embed(cssText, resourceURL, baseURL, options, getContentFromUrl) {
 	try {
-		let a = n ? resolveUrl(t, n) : t, o = getMimeType(t), s;
-		return s = i ? makeDataUrl(await i(a), o) : await resourceToDataURL(a, o, r), e.replace(toRegex(t), `$1${s}$3`);
-	} catch {}
-	return e;
-}
-function filterPreferredFontFormat(e, { preferredFontFormat: t }) {
-	return t ? e.replace(c, (e) => {
-		for (;;) {
-			let [n, , r] = s.exec(e) || [];
-			if (!r) return "";
-			if (r === t) return `src: ${n};`;
+		const resolvedURL = baseURL ? resolveUrl(resourceURL, baseURL) : resourceURL;
+		const contentType = getMimeType(resourceURL);
+		let dataURL;
+		if (getContentFromUrl) dataURL = makeDataUrl(await getContentFromUrl(resolvedURL), contentType);
+		else dataURL = await resourceToDataURL(resolvedURL, contentType, options);
+		return cssText.replace(toRegex(resourceURL), `$1${dataURL}$3`);
+	} catch (error) {}
+	return cssText;
+}
+function filterPreferredFontFormat(str, { preferredFontFormat }) {
+	return !preferredFontFormat ? str : str.replace(FONT_SRC_REGEX, (match) => {
+		while (true) {
+			const [src, , format] = URL_WITH_FORMAT_REGEX.exec(match) || [];
+			if (!format) return "";
+			if (format === preferredFontFormat) return `src: ${src};`;
 		}
-	}) : e;
+	});
 }
-function shouldEmbed(e) {
-	return e.search(o) !== -1;
+function shouldEmbed(url) {
+	return url.search(URL_REGEX) !== -1;
 }
-async function embedResources(e, t, n) {
-	if (!shouldEmbed(e)) return e;
-	let r = filterPreferredFontFormat(e, n);
-	return parseURLs(r).reduce((e, r) => e.then((e) => embed(e, r, t, n)), Promise.resolve(r));
+async function embedResources(cssText, baseUrl, options) {
+	if (!shouldEmbed(cssText)) return cssText;
+	const filteredCSSText = filterPreferredFontFormat(cssText, options);
+	return parseURLs(filteredCSSText).reduce((deferred, url) => deferred.then((css) => embed(css, url, baseUrl, options)), Promise.resolve(filteredCSSText));
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/embed-images.js
-async function embedProp(e, t, n) {
-	let r = t.style?.getPropertyValue(e);
-	if (r) {
-		let i = await embedResources(r, null, n);
-		return t.style.setProperty(e, i, t.style.getPropertyPriority(e)), !0;
+async function embedProp(propName, node, options) {
+	var _a;
+	const propValue = (_a = node.style) === null || _a === void 0 ? void 0 : _a.getPropertyValue(propName);
+	if (propValue) {
+		const cssString = await embedResources(propValue, null, options);
+		node.style.setProperty(propName, cssString, node.style.getPropertyPriority(propName));
+		return true;
 	}
-	return !1;
-}
-async function embedBackground(e, t) {
-	await embedProp("background", e, t) || await embedProp("background-image", e, t), await embedProp("mask", e, t) || await embedProp("mask-image", e, t);
-}
-async function embedImageNode(e, t) {
-	let n = isInstanceOfElement(e, HTMLImageElement);
-	if ((!n || isDataUrl(e.src)) && (!isInstanceOfElement(e, SVGImageElement) || isDataUrl(e.href.baseVal))) return;
-	let r = n ? e.src : e.href.baseVal, i = await resourceToDataURL(r, getMimeType(r), t);
-	await new Promise((t, r) => {
-		e.onload = t, e.onerror = r;
-		let a = e;
-		a.decode &&= t, a.loading === "lazy" && (a.loading = "eager"), n ? (e.srcset = "", e.src = i) : e.href.baseVal = i;
+	return false;
+}
+async function embedBackground(clonedNode, options) {
+	if (!await embedProp("background", clonedNode, options)) await embedProp("background-image", clonedNode, options);
+	if (!await embedProp("mask", clonedNode, options)) await embedProp("mask-image", clonedNode, options);
+}
+async function embedImageNode(clonedNode, options) {
+	const isImageElement = isInstanceOfElement(clonedNode, HTMLImageElement);
+	if (!(isImageElement && !isDataUrl(clonedNode.src)) && !(isInstanceOfElement(clonedNode, SVGImageElement) && !isDataUrl(clonedNode.href.baseVal))) return;
+	const url = isImageElement ? clonedNode.src : clonedNode.href.baseVal;
+	const dataURL = await resourceToDataURL(url, getMimeType(url), options);
+	await new Promise((resolve, reject) => {
+		clonedNode.onload = resolve;
+		clonedNode.onerror = reject;
+		const image = clonedNode;
+		if (image.decode) image.decode = resolve;
+		if (image.loading === "lazy") image.loading = "eager";
+		if (isImageElement) {
+			clonedNode.srcset = "";
+			clonedNode.src = dataURL;
+		} else clonedNode.href.baseVal = dataURL;
 	});
 }
-async function embedChildren(e, t) {
-	let n = toArray(e.childNodes).map((e) => embedImages(e, t));
-	await Promise.all(n).then(() => e);
+async function embedChildren(clonedNode, options) {
+	const deferreds = toArray(clonedNode.childNodes).map((child) => embedImages(child, options));
+	await Promise.all(deferreds).then(() => clonedNode);
 }
-async function embedImages(e, t) {
-	isInstanceOfElement(e, Element) && (await embedBackground(e, t), await embedImageNode(e, t), await embedChildren(e, t));
+async function embedImages(clonedNode, options) {
+	if (isInstanceOfElement(clonedNode, Element)) {
+		await embedBackground(clonedNode, options);
+		await embedImageNode(clonedNode, options);
+		await embedChildren(clonedNode, options);
+	}
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/apply-style.js
-function applyStyle(e, t) {
-	let { style: n } = e;
-	t.backgroundColor && (n.backgroundColor = t.backgroundColor), t.width && (n.width = `${t.width}px`), t.height && (n.height = `${t.height}px`);
-	let r = t.style;
-	return r != null && Object.keys(r).forEach((e) => {
-		n[e] = r[e];
-	}), e;
+function applyStyle(node, options) {
+	const { style } = node;
+	if (options.backgroundColor) style.backgroundColor = options.backgroundColor;
+	if (options.width) style.width = `${options.width}px`;
+	if (options.height) style.height = `${options.height}px`;
+	const manual = options.style;
+	if (manual != null) Object.keys(manual).forEach((key) => {
+		style[key] = manual[key];
+	});
+	return node;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/embed-webfonts.js
-var l = {};
-async function fetchCSS(e) {
-	let t = l[e];
-	return t ?? (t = {
-		url: e,
-		cssText: await (await fetch(e)).text()
-	}, l[e] = t, t);
-}
-async function embedFonts(e, t) {
-	let n = e.cssText, r = /url\(["']?([^"')]+)["']?\)/g, i = (n.match(/url\([^)]+\)/g) || []).map(async (i) => {
-		let a = i.replace(r, "$1");
-		return a.startsWith("https://") || (a = new URL(a, e.url).href), fetchAsDataURL(a, t.fetchRequestInit, ({ result: e }) => (n = n.replace(i, `url(${e})`), [i, e]));
+var cssFetchCache = {};
+async function fetchCSS(url) {
+	let cache = cssFetchCache[url];
+	if (cache != null) return cache;
+	cache = {
+		url,
+		cssText: await (await fetch(url)).text()
+	};
+	cssFetchCache[url] = cache;
+	return cache;
+}
+async function embedFonts(data, options) {
+	let cssText = data.cssText;
+	const regexUrl = /url\(["']?([^"')]+)["']?\)/g;
+	const loadFonts = (cssText.match(/url\([^)]+\)/g) || []).map(async (loc) => {
+		let url = loc.replace(regexUrl, "$1");
+		if (!url.startsWith("https://")) url = new URL(url, data.url).href;
+		return fetchAsDataURL(url, options.fetchRequestInit, ({ result }) => {
+			cssText = cssText.replace(loc, `url(${result})`);
+			return [loc, result];
+		});
 	});
-	return Promise.all(i).then(() => n);
-}
-function parseCSS(e) {
-	if (e == null) return [];
-	let t = [], n = e.replace(/(\/\*[\s\S]*?\*\/)/gi, ""), r = /* @__PURE__ */ RegExp("((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})", "gi");
-	for (;;) {
-		let e = r.exec(n);
-		if (e === null) break;
-		t.push(e[0]);
+	return Promise.all(loadFonts).then(() => cssText);
+}
+function parseCSS(source) {
+	if (source == null) return [];
+	const result = [];
+	let cssText = source.replace(/(\/\*[\s\S]*?\*\/)/gi, "");
+	const keyframesRegex = /* @__PURE__ */ new RegExp("((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})", "gi");
+	while (true) {
+		const matches = keyframesRegex.exec(cssText);
+		if (matches === null) break;
+		result.push(matches[0]);
 	}
-	n = n.replace(r, "");
-	let i = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi, a = /* @__PURE__ */ RegExp("((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})", "gi");
-	for (;;) {
-		let e = i.exec(n);
-		if (e === null) {
-			if (e = a.exec(n), e === null) break;
-			i.lastIndex = a.lastIndex;
-		} else a.lastIndex = i.lastIndex;
-		t.push(e[0]);
+	cssText = cssText.replace(keyframesRegex, "");
+	const importRegex = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi;
+	const unifiedRegex = /* @__PURE__ */ new RegExp("((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})", "gi");
+	while (true) {
+		let matches = importRegex.exec(cssText);
+		if (matches === null) {
+			matches = unifiedRegex.exec(cssText);
+			if (matches === null) break;
+			else importRegex.lastIndex = unifiedRegex.lastIndex;
+		} else unifiedRegex.lastIndex = importRegex.lastIndex;
+		result.push(matches[0]);
 	}
-	return t;
-}
-async function getCSSRules(e, t) {
-	let n = [], r = [];
-	return e.forEach((n) => {
-		if ("cssRules" in n) try {
-			toArray(n.cssRules || []).forEach((e, i) => {
-				if (e.type === CSSRule.IMPORT_RULE) {
-					let a = i + 1, o = e.href, s = fetchCSS(o).then((e) => embedFonts(e, t)).then((e) => parseCSS(e).forEach((e) => {
+	return result;
+}
+async function getCSSRules(styleSheets, options) {
+	const ret = [];
+	const deferreds = [];
+	styleSheets.forEach((sheet) => {
+		if ("cssRules" in sheet) try {
+			toArray(sheet.cssRules || []).forEach((item, index) => {
+				if (item.type === CSSRule.IMPORT_RULE) {
+					let importIndex = index + 1;
+					const url = item.href;
+					const deferred = fetchCSS(url).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => {
 						try {
-							n.insertRule(e, e.startsWith("@import") ? a += 1 : n.cssRules.length);
-						} catch (t) {
+							sheet.insertRule(rule, rule.startsWith("@import") ? importIndex += 1 : sheet.cssRules.length);
+						} catch (error) {
 							console.error("Error inserting rule from remote css", {
-								rule: e,
-								error: t
+								rule,
+								error
 							});
 						}
 					})).catch((e) => {
 						console.error("Error loading remote css", e.toString());
 					});
-					r.push(s);
+					deferreds.push(deferred);
 				}
 			});
-		} catch (i) {
-			let a = e.find((e) => e.href == null) || document.styleSheets[0];
-			n.href != null && r.push(fetchCSS(n.href).then((e) => embedFonts(e, t)).then((e) => parseCSS(e).forEach((e) => {
-				a.insertRule(e, n.cssRules.length);
-			})).catch((e) => {
-				console.error("Error loading remote stylesheet", e);
-			})), console.error("Error inlining remote css file", i);
+		} catch (e) {
+			const inline = styleSheets.find((a) => a.href == null) || document.styleSheets[0];
+			if (sheet.href != null) deferreds.push(fetchCSS(sheet.href).then((metadata) => embedFonts(metadata, options)).then((cssText) => parseCSS(cssText).forEach((rule) => {
+				inline.insertRule(rule, sheet.cssRules.length);
+			})).catch((err) => {
+				console.error("Error loading remote stylesheet", err);
+			}));
+			console.error("Error inlining remote css file", e);
 		}
-	}), Promise.all(r).then(() => (e.forEach((e) => {
-		if ("cssRules" in e) try {
-			toArray(e.cssRules || []).forEach((e) => {
-				n.push(e);
-			});
-		} catch (t) {
-			console.error(`Error while reading CSS rules from ${e.href}`, t);
-		}
-	}), n));
+	});
+	return Promise.all(deferreds).then(() => {
+		styleSheets.forEach((sheet) => {
+			if ("cssRules" in sheet) try {
+				toArray(sheet.cssRules || []).forEach((item) => {
+					ret.push(item);
+				});
+			} catch (e) {
+				console.error(`Error while reading CSS rules from ${sheet.href}`, e);
+			}
+		});
+		return ret;
+	});
 }
-function getWebFontRules(e) {
-	return e.filter((e) => e.type === CSSRule.FONT_FACE_RULE).filter((e) => shouldEmbed(e.style.getPropertyValue("src")));
+function getWebFontRules(cssRules) {
+	return cssRules.filter((rule) => rule.type === CSSRule.FONT_FACE_RULE).filter((rule) => shouldEmbed(rule.style.getPropertyValue("src")));
 }
-async function parseWebFontRules(e, t) {
-	if (e.ownerDocument == null) throw Error("Provided element is not within a Document");
-	return getWebFontRules(await getCSSRules(toArray(e.ownerDocument.styleSheets), t));
+async function parseWebFontRules(node, options) {
+	if (node.ownerDocument == null) throw new Error("Provided element is not within a Document");
+	return getWebFontRules(await getCSSRules(toArray(node.ownerDocument.styleSheets), options));
 }
-async function getWebFontCSS(e, t) {
-	let n = await parseWebFontRules(e, t);
-	return (await Promise.all(n.map((e) => {
-		let n = e.parentStyleSheet ? e.parentStyleSheet.href : null;
-		return embedResources(e.cssText, n, t);
+async function getWebFontCSS(node, options) {
+	const rules = await parseWebFontRules(node, options);
+	return (await Promise.all(rules.map((rule) => {
+		const baseUrl = rule.parentStyleSheet ? rule.parentStyleSheet.href : null;
+		return embedResources(rule.cssText, baseUrl, options);
 	}))).join("\n");
 }
-async function embedWebFonts(e, t) {
-	let n = t.fontEmbedCSS == null ? t.skipFonts ? null : await getWebFontCSS(e, t) : t.fontEmbedCSS;
-	if (n) {
-		let t = document.createElement("style"), r = document.createTextNode(n);
-		t.appendChild(r), e.firstChild ? e.insertBefore(t, e.firstChild) : e.appendChild(t);
+async function embedWebFonts(clonedNode, options) {
+	const cssText = options.fontEmbedCSS != null ? options.fontEmbedCSS : options.skipFonts ? null : await getWebFontCSS(clonedNode, options);
+	if (cssText) {
+		const styleNode = document.createElement("style");
+		const sytleContent = document.createTextNode(cssText);
+		styleNode.appendChild(sytleContent);
+		if (clonedNode.firstChild) clonedNode.insertBefore(styleNode, clonedNode.firstChild);
+		else clonedNode.appendChild(styleNode);
 	}
 }
 //#endregion
 //#region ../../node_modules/.pnpm/html-to-image@1.11.11/node_modules/html-to-image/es/index.js
-async function toSvg(e, t = {}) {
-	let { width: n, height: r } = getImageSize(e, t), i = await cloneNode(e, t, !0);
-	return await embedWebFonts(i, t), await embedImages(i, t), applyStyle(i, t), await nodeToDataURL(i, n, r);
-}
-async function toCanvas(e, t = {}) {
-	let { width: n, height: r } = getImageSize(e, t), i = await createImage(await toSvg(e, t)), a = document.createElement("canvas"), o = a.getContext("2d"), s = t.pixelRatio || getPixelRatio(), c = t.canvasWidth || n, l = t.canvasHeight || r;
-	return a.width = c * s, a.height = l * s, t.skipAutoScale || checkCanvasDimensions(a), a.style.width = `${c}`, a.style.height = `${l}`, t.backgroundColor && (o.fillStyle = t.backgroundColor, o.fillRect(0, 0, a.width, a.height)), o.drawImage(i, 0, 0, a.width, a.height), a;
+async function toSvg(node, options = {}) {
+	const { width, height } = getImageSize(node, options);
+	const clonedNode = await cloneNode(node, options, true);
+	await embedWebFonts(clonedNode, options);
+	await embedImages(clonedNode, options);
+	applyStyle(clonedNode, options);
+	return await nodeToDataURL(clonedNode, width, height);
+}
+async function toCanvas(node, options = {}) {
+	const { width, height } = getImageSize(node, options);
+	const img = await createImage(await toSvg(node, options));
+	const canvas = document.createElement("canvas");
+	const context = canvas.getContext("2d");
+	const ratio = options.pixelRatio || getPixelRatio();
+	const canvasWidth = options.canvasWidth || width;
+	const canvasHeight = options.canvasHeight || height;
+	canvas.width = canvasWidth * ratio;
+	canvas.height = canvasHeight * ratio;
+	if (!options.skipAutoScale) checkCanvasDimensions(canvas);
+	canvas.style.width = `${canvasWidth}`;
+	canvas.style.height = `${canvasHeight}`;
+	if (options.backgroundColor) {
+		context.fillStyle = options.backgroundColor;
+		context.fillRect(0, 0, canvas.width, canvas.height);
+	}
+	context.drawImage(img, 0, 0, canvas.width, canvas.height);
+	return canvas;
 }
-async function toJpeg(e, t = {}) {
-	return (await toCanvas(e, t)).toDataURL("image/jpeg", t.quality || 1);
+async function toJpeg(node, options = {}) {
+	return (await toCanvas(node, options)).toDataURL("image/jpeg", options.quality || 1);
 }
-async function toBlob(e, t = {}) {
-	return await canvasToBlob(await toCanvas(e, t));
+async function toBlob(node, options = {}) {
+	return await canvasToBlob(await toCanvas(node, options));
 }
 //#endregion
 export { toBlob, toJpeg };