@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-ARRGOEFX.mjs

@@ -0,0 +1,585 @@
+import { resolveBackgroundColor, DARK_MODE_COLORS, LIGHT_MODE_COLORS } from './chunk-NKUYIWAP.mjs';
+import { calculateLuminanceFromRGB } from './chunk-QS76E3TD.mjs';
+import { resolveSwatchGradientStops } from './chunk-O2X6FF45.mjs';
+import { parseColorToRGB } from './chunk-SSLTFJ3U.mjs';
+
+// src/utils/export/svg-styles.ts
+function inlineComputedStyles(element, rootStyles) {
+  if (element.nodeType !== Node.ELEMENT_NODE) return;
+  const tagName = element.tagName.toLowerCase();
+  if (["path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "text", "tspan", "g"].includes(tagName)) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) return;
+    const computed = view.getComputedStyle(element);
+    const svgEl = element;
+    const fillAttr = svgEl.getAttribute("fill");
+    if (fillAttr === "currentColor") {
+      svgEl.style.fill = rootStyles.textColor;
+    } else {
+      const fill = computed.fill;
+      if (fill && fill !== "none") {
+        svgEl.style.fill = fill;
+      }
+    }
+    const isText = tagName === "text" || tagName === "tspan";
+    if (isText && rootStyles.dropTextHalo) {
+      svgEl.style.stroke = "none";
+    } else {
+      const stroke = computed.stroke;
+      if (stroke && stroke !== "none") {
+        svgEl.style.stroke = stroke;
+      }
+    }
+    const strokeWidth = computed.strokeWidth;
+    if (strokeWidth && strokeWidth !== "0" && strokeWidth !== "0px") {
+      svgEl.style.strokeWidth = strokeWidth;
+    }
+    const opacity = computed.opacity;
+    if (opacity && opacity !== "1") {
+      svgEl.style.opacity = opacity;
+    }
+  }
+  if (["text", "tspan"].includes(tagName)) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) return;
+    const computed = view.getComputedStyle(element);
+    const textEl = element;
+    const fontFamily = computed.fontFamily || rootStyles.fontFamily;
+    if (fontFamily) {
+      textEl.style.fontFamily = fontFamily;
+    }
+    const fontSize = computed.fontSize;
+    if (fontSize) {
+      textEl.style.fontSize = fontSize;
+    }
+    const fontWeight = computed.fontWeight;
+    if (fontWeight && fontWeight !== "normal" && fontWeight !== "400") {
+      textEl.style.fontWeight = fontWeight;
+    }
+    const textAnchor = textEl.getAttribute("text-anchor");
+    if (textAnchor) {
+      textEl.style.textAnchor = textAnchor;
+    }
+    const dominantBaseline = textEl.getAttribute("dominant-baseline");
+    if (dominantBaseline) {
+      textEl.style.dominantBaseline = dominantBaseline;
+    }
+    const fillRgb = parseColorToRGB(computed.fill);
+    if (fillRgb) {
+      const textLum = calculateLuminanceFromRGB(fillRgb.r, fillRgb.g, fillRgb.b);
+      const isLightText = textLum > 0.78;
+      const lowContrastWithBg = Math.abs(textLum - rootStyles.bgLuminance) < 0.25;
+      if (!isLightText && lowContrastWithBg) {
+        textEl.setAttribute("fill", rootStyles.textColor);
+        textEl.style.fill = rootStyles.textColor;
+      }
+    }
+  }
+  for (const child of element.children) {
+    inlineComputedStyles(child, rootStyles);
+  }
+}
+function isColorDark(color) {
+  const rgb = parseColorToRGB(color);
+  if (rgb) {
+    const luminance = calculateLuminanceFromRGB(rgb.r, rgb.g, rgb.b);
+    return luminance < 0.5;
+  }
+  return false;
+}
+function getTextColorForBackground(backgroundColor) {
+  if (backgroundColor === "transparent") {
+    return LIGHT_MODE_COLORS.text;
+  }
+  return isColorDark(backgroundColor) ? DARK_MODE_COLORS.text : LIGHT_MODE_COLORS.text;
+}
+function prepareSvgForExport(svg, width, height, backgroundColor, dropTextHalo = false) {
+  const clonedSvg = svg.cloneNode(true);
+  const view = svg.ownerDocument.defaultView;
+  const rootComputed = view ? view.getComputedStyle(svg) : { fontFamily: "", color: ""};
+  let textColor;
+  let bgLuminance;
+  if (backgroundColor === "transparent") {
+    const rootRgb = parseColorToRGB(rootComputed.color);
+    const isDarkMode = rootRgb ? calculateLuminanceFromRGB(rootRgb.r, rootRgb.g, rootRgb.b) > 0.5 : false;
+    textColor = isDarkMode ? DARK_MODE_COLORS.text : LIGHT_MODE_COLORS.text;
+    bgLuminance = isDarkMode ? 0 : 1;
+  } else {
+    textColor = getTextColorForBackground(backgroundColor);
+    const bgRgb = parseColorToRGB(backgroundColor);
+    bgLuminance = bgRgb ? calculateLuminanceFromRGB(bgRgb.r, bgRgb.g, bgRgb.b) : 1;
+  }
+  const rootStyles = {
+    fontFamily: rootComputed.fontFamily || "system-ui, -apple-system, sans-serif",
+    textColor,
+    dropTextHalo,
+    bgLuminance
+  };
+  clonedSvg.setAttribute("width", String(width));
+  clonedSvg.setAttribute("height", String(height));
+  if (backgroundColor !== "transparent") {
+    const bgRect = svg.ownerDocument.createElementNS("http://www.w3.org/2000/svg", "rect");
+    bgRect.setAttribute("width", "100%");
+    bgRect.setAttribute("height", "100%");
+    bgRect.setAttribute("fill", backgroundColor);
+    clonedSvg.insertBefore(bgRect, clonedSvg.firstChild);
+  }
+  clonedSvg.style.position = "absolute";
+  clonedSvg.style.left = "-9999px";
+  clonedSvg.style.top = "-9999px";
+  svg.ownerDocument.body.appendChild(clonedSvg);
+  inlineComputedStyles(clonedSvg, rootStyles);
+  svg.ownerDocument.body.removeChild(clonedSvg);
+  clonedSvg.style.position = "";
+  clonedSvg.style.left = "";
+  clonedSvg.style.top = "";
+  return clonedSvg;
+}
+
+// src/utils/export/dom.ts
+function downloadFile(url, filename) {
+  if (typeof document === "undefined") return;
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+}
+function getSvgElement(container) {
+  const svgs = Array.from(container.querySelectorAll("svg"));
+  return svgs.find((s) => s.getAttribute("aria-hidden") !== "true" && (typeof s.closest !== "function" || s.closest("button") === null)) ?? null;
+}
+function getCanvasElements(container) {
+  return Array.from(container.querySelectorAll("canvas"));
+}
+function createExportCanvas(width, height, scale, backgroundColor) {
+  if (typeof document === "undefined") throw new Error("createExportCanvas requires a browser environment");
+  const canvas = document.createElement("canvas");
+  canvas.width = width * scale;
+  canvas.height = height * scale;
+  const ctx = canvas.getContext("2d");
+  if (ctx && backgroundColor !== "transparent") {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+  }
+  return canvas;
+}
+async function renderSvgToCanvas(svg, canvas, width, height, backgroundColor, dropTextHalo = false) {
+  return new Promise((resolve, reject) => {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      reject(new Error("Could not get canvas context"));
+      return;
+    }
+    const preparedSvg = prepareSvgForExport(svg, width, height, backgroundColor, dropTextHalo);
+    const serializer = new XMLSerializer();
+    const svgString = serializer.serializeToString(preparedSvg);
+    const blob = new Blob([svgString], { type: "image/svg+xml;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const img = new Image();
+    img.onload = () => {
+      ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+      URL.revokeObjectURL(url);
+      resolve();
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("Failed to load SVG image for export"));
+    };
+    img.src = url;
+  });
+}
+function copyCanvasToExport(sourceCanvas, exportCanvas) {
+  const ctx = exportCanvas.getContext("2d");
+  if (!ctx) return;
+  ctx.drawImage(sourceCanvas, 0, 0, exportCanvas.width, exportCanvas.height);
+}
+
+// src/utils/export/overlays.ts
+function parseSwatchGradient(el) {
+  const raw = el.dataset?.chartGradient;
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && Array.isArray(parsed.stops) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function drawElementToCanvas(el, ctx, containerRect, scale) {
+  const rect = el.getBoundingClientRect();
+  const x = (rect.left - containerRect.left) * scale;
+  const y = (rect.top - containerRect.top) * scale;
+  const w = rect.width * scale;
+  const h = rect.height * scale;
+  if (w <= 0 || h <= 0) return;
+  const view = el.ownerDocument.defaultView;
+  if (!view) return;
+  const styles = view.getComputedStyle(el);
+  if (styles.visibility === "hidden" || styles.display === "none") return;
+  const opacity = parseFloat(styles.opacity);
+  ctx.save();
+  if (opacity < 1) {
+    ctx.globalAlpha = ctx.globalAlpha * opacity;
+  }
+  const gradientDef = parseSwatchGradient(el);
+  const gradientStops = gradientDef ? resolveSwatchGradientStops(gradientDef) : [];
+  const bg = styles.backgroundColor;
+  const hasBg = !!bg && bg !== "rgba(0, 0, 0, 0)" && bg !== "transparent";
+  if (gradientStops.length > 0 || hasBg) {
+    let fill = bg;
+    if (gradientStops.length > 0) {
+      let grad;
+      if (gradientDef.radialGradient) {
+        const cx = x + w / 2;
+        const cy = y + h / 2;
+        grad = ctx.createRadialGradient(cx, cy, 0, cx, cy, Math.max(w, h) / 2);
+      } else {
+        grad = ctx.createLinearGradient(x, y, x, y + h);
+      }
+      for (const s of gradientStops) {
+        grad.addColorStop(Math.min(1, Math.max(0, s.offset)), s.color);
+      }
+      fill = grad;
+    }
+    ctx.fillStyle = fill;
+    const br = parseFloat(styles.borderRadius) * scale;
+    if (br > 0 && typeof ctx.roundRect === "function") {
+      ctx.beginPath();
+      ctx.roundRect(x, y, w, h, br);
+      ctx.fill();
+    } else {
+      ctx.fillRect(x, y, w, h);
+    }
+  }
+  if (el.childElementCount === 0) {
+    const text = (el.textContent || "").trim();
+    if (text) {
+      const fontSize = parseFloat(styles.fontSize) * scale;
+      const paddingLeft = parseFloat(styles.paddingLeft) * scale;
+      const paddingRight = parseFloat(styles.paddingRight) * scale;
+      const fontStyle = styles.fontStyle !== "normal" ? `${styles.fontStyle} ` : "";
+      ctx.font = `${fontStyle}${styles.fontWeight} ${fontSize}px ${styles.fontFamily}`;
+      ctx.fillStyle = styles.color;
+      ctx.textBaseline = "middle";
+      const textAlign = styles.textAlign;
+      ctx.textAlign = textAlign || "left";
+      let textX;
+      switch (textAlign) {
+        case "center":
+          textX = x + w / 2;
+          break;
+        case "right":
+        case "end":
+          textX = x + w - paddingRight;
+          break;
+        default:
+          textX = x + paddingLeft;
+      }
+      ctx.fillText(text, textX, y + h / 2);
+    }
+  }
+  ctx.restore();
+  for (const child of el.children) {
+    drawElementToCanvas(child, ctx, containerRect, scale);
+  }
+}
+function drawHtmlOverlaysToCanvas(container, ctx, scale) {
+  const containerRect = container.getBoundingClientRect();
+  for (const selector of [".chart-title", ".chart-caption", ".chart-legend"]) {
+    const el = container.querySelector(selector);
+    if (el) {
+      drawElementToCanvas(el, ctx, containerRect, scale);
+    }
+  }
+}
+function generateSvgElementMarkup(el, containerRect, defs, idRef) {
+  const rect = el.getBoundingClientRect();
+  const x = rect.left - containerRect.left;
+  const y = rect.top - containerRect.top;
+  const w = rect.width;
+  const h = rect.height;
+  if (w <= 0 || h <= 0) return "";
+  const view = el.ownerDocument.defaultView;
+  if (!view) return "";
+  const styles = view.getComputedStyle(el);
+  if (styles.visibility === "hidden" || styles.display === "none") return "";
+  const opacity = parseFloat(styles.opacity);
+  const opacityAttr = opacity < 1 ? ` opacity="${opacity}"` : "";
+  let result = "";
+  const gradientDef = parseSwatchGradient(el);
+  const gradientStops = gradientDef ? resolveSwatchGradientStops(gradientDef) : [];
+  const bg = styles.backgroundColor;
+  const br = parseFloat(styles.borderRadius);
+  const rxAttr = br > 0 ? ` rx="${br}"` : "";
+  if (gradientStops.length > 0) {
+    const gradId = `p-chart-export-grad-${idRef.v++}`;
+    const stopEls = gradientStops.map((s) => `<stop offset="${Math.round(s.offset * 100)}%" stop-color="${s.color}"/>`).join("");
+    defs.push(gradientDef.radialGradient ? `<radialGradient id="${gradId}" cx="50%" cy="50%" r="50%">${stopEls}</radialGradient>` : `<linearGradient id="${gradId}" x1="0" y1="0" x2="0" y2="1">${stopEls}</linearGradient>`);
+    result += `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="url(#${gradId})"${rxAttr}${opacityAttr}/>`;
+  } else if (bg && bg !== "rgba(0, 0, 0, 0)" && bg !== "transparent") {
+    result += `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="${bg}"${rxAttr}${opacityAttr}/>`;
+  }
+  if (el.childElementCount === 0) {
+    const text = (el.textContent || "").trim();
+    if (text) {
+      const fontSize = parseFloat(styles.fontSize);
+      const paddingLeft = parseFloat(styles.paddingLeft);
+      const paddingRight = parseFloat(styles.paddingRight);
+      const textAlign = styles.textAlign;
+      let textX;
+      let anchor;
+      const inLegend = typeof el.closest === "function" && el.closest(".chart-legend") !== null;
+      if (inLegend) {
+        textX = x + paddingLeft;
+        anchor = "start";
+      } else {
+        switch (textAlign) {
+          case "center":
+            textX = x + w / 2;
+            anchor = "middle";
+            break;
+          case "right":
+          case "end":
+            textX = x + w - paddingRight;
+            anchor = "end";
+            break;
+          default:
+            textX = x + paddingLeft;
+            anchor = "start";
+        }
+      }
+      const fontStyle = styles.fontStyle !== "normal" ? ` font-style="${styles.fontStyle}"` : "";
+      result += `<text x="${textX}" y="${y + h / 2}" dy="0.32em" font-size="${fontSize}" font-weight="${styles.fontWeight}"${fontStyle} font-family="${escapeXml(styles.fontFamily)}" fill="${styles.color}" text-anchor="${anchor}"${opacityAttr}>` + escapeXml(text) + `</text>`;
+    }
+  }
+  for (const child of el.children) {
+    result += generateSvgElementMarkup(child, containerRect, defs, idRef);
+  }
+  return result;
+}
+function generateHtmlOverlaySvgMarkup(container) {
+  const containerRect = container.getBoundingClientRect();
+  const defs = [];
+  const idRef = { v: 0 };
+  let markup = "";
+  for (const selector of [".chart-title", ".chart-caption", ".chart-legend"]) {
+    const el = container.querySelector(selector);
+    if (el) {
+      markup += generateSvgElementMarkup(el, containerRect, defs, idRef);
+    }
+  }
+  if (!markup) return "";
+  const defsBlock = defs.length > 0 ? `<defs>${defs.join("")}</defs>` : "";
+  return `<g class="chart-html-overlays">${defsBlock}${markup}</g>`;
+}
+
+// src/utils/export/pdf.ts
+function base64ToUint8Array(base64) {
+  const binaryStr = atob(base64);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(bytes) {
+  let binaryStr = "";
+  const chunkSize = 8192;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binaryStr += String.fromCharCode(...chunk);
+  }
+  return btoa(binaryStr);
+}
+function buildPdfWithJpeg(jpegBytes, imagePxWidth, imagePxHeight, pageWidthPt, pageHeightPt) {
+  const enc = new TextEncoder();
+  const parts = [];
+  const offsets = [];
+  let pos = 0;
+  const push = (str) => {
+    const bytes = enc.encode(str);
+    parts.push(bytes);
+    pos += bytes.length;
+  };
+  const pushRaw = (bytes) => {
+    parts.push(bytes);
+    pos += bytes.length;
+  };
+  push("%PDF-1.4\n");
+  offsets[1] = pos;
+  push("1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
+  offsets[2] = pos;
+  push("2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
+  offsets[3] = pos;
+  push(`3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${pageWidthPt} ${pageHeightPt}] /Contents 4 0 R /Resources << /XObject << /img 5 0 R >> >> >>
+endobj
+`);
+  const contentStr = `q ${pageWidthPt} 0 0 ${pageHeightPt} 0 0 cm /img Do Q
+`;
+  const contentBytes = enc.encode(contentStr);
+  offsets[4] = pos;
+  push(`4 0 obj
+<< /Length ${contentBytes.length} >>
+stream
+`);
+  pushRaw(contentBytes);
+  push("\nendstream\nendobj\n");
+  offsets[5] = pos;
+  push(`5 0 obj
+<< /Type /XObject /Subtype /Image /Width ${imagePxWidth} /Height ${imagePxHeight} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${jpegBytes.length} >>
+stream
+`);
+  pushRaw(jpegBytes);
+  push("\nendstream\nendobj\n");
+  const xrefOffset = pos;
+  push("xref\n");
+  push("0 6\n");
+  push("0000000000 65535 f \n");
+  for (let i = 1; i <= 5; i++) {
+    push(offsets[i].toString().padStart(10, "0") + " 00000 n \n");
+  }
+  push(`trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+${xrefOffset}
+%%EOF
+`);
+  const total = parts.reduce((sum, p) => sum + p.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+
+// src/utils/export/create-exporter.ts
+function createChartExporter(container, width, height, renderer) {
+  const toImage = async (options = {}) => {
+    const { format = "png", filename = "chart", quality = 0.92, scale = 2, backgroundColor = "auto", download = true } = options;
+    const resolvedBg = resolveBackgroundColor(container, backgroundColor);
+    let dataUrl;
+    let finalFilename;
+    if (format === "svg") {
+      const svg = renderer === "svg" ? getSvgElement(container) : null;
+      finalFilename = `${filename}.svg`;
+      let svgString;
+      if (svg) {
+        const preparedSvg = prepareSvgForExport(svg, width, height, resolvedBg, true);
+        const serializer = new XMLSerializer();
+        svgString = serializer.serializeToString(preparedSvg);
+      } else {
+        const canvases = getCanvasElements(container);
+        if (canvases.length === 0) {
+          throw new Error("No SVG or canvas element found in chart container.");
+        }
+        const compositeCanvas = createExportCanvas(width, height, 1, resolvedBg);
+        const compositeCtx = compositeCanvas.getContext("2d");
+        for (const c of canvases) {
+          compositeCtx.drawImage(c, 0, 0, compositeCanvas.width, compositeCanvas.height);
+        }
+        const pngDataUrl = compositeCanvas.toDataURL("image/png");
+        const bgRect = resolvedBg !== "transparent" ? `<rect width="100%" height="100%" fill="${resolvedBg}"/>` : "";
+        svgString = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}">` + bgRect + `<image href="${pngDataUrl}" width="${width}" height="${height}"/></svg>`;
+      }
+      const svgOverlayMarkup = generateHtmlOverlaySvgMarkup(container);
+      if (svgOverlayMarkup) {
+        const closeIdx = svgString.lastIndexOf("</svg>");
+        if (closeIdx !== -1) {
+          svgString = svgString.substring(0, closeIdx) + svgOverlayMarkup + "</svg>";
+        }
+      }
+      dataUrl = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(svgString);
+      if (download) {
+        const blob = new Blob([svgString], { type: "image/svg+xml" });
+        const url = URL.createObjectURL(blob);
+        downloadFile(url, finalFilename);
+        URL.revokeObjectURL(url);
+      }
+    } else if (format === "pdf") {
+      const exportCanvas = createExportCanvas(width, height, scale, resolvedBg);
+      if (renderer === "svg") {
+        const svg = getSvgElement(container);
+        if (svg) {
+          await renderSvgToCanvas(svg, exportCanvas, width, height, resolvedBg, true);
+        }
+      } else {
+        for (const c of getCanvasElements(container)) {
+          copyCanvasToExport(c, exportCanvas);
+        }
+      }
+      const pdfOverlayCtx = exportCanvas.getContext("2d");
+      if (pdfOverlayCtx) {
+        drawHtmlOverlaysToCanvas(container, pdfOverlayCtx, scale);
+      }
+      const jpegDataUrl = exportCanvas.toDataURL("image/jpeg", quality);
+      const jpegBase64 = jpegDataUrl.replace(/^data:image\/jpeg;base64,/, "");
+      const jpegBytes = base64ToUint8Array(jpegBase64);
+      const pageWidthPt = Math.round(width * 0.75);
+      const pageHeightPt = Math.round(height * 0.75);
+      const pdfBytes = buildPdfWithJpeg(jpegBytes, exportCanvas.width, exportCanvas.height, pageWidthPt, pageHeightPt);
+      dataUrl = `data:application/pdf;base64,${uint8ArrayToBase64(pdfBytes)}`;
+      finalFilename = `${filename}.pdf`;
+      if (download) {
+        const blobUrl = URL.createObjectURL(new Blob([pdfBytes.buffer], { type: "application/pdf" }));
+        downloadFile(blobUrl, finalFilename);
+        URL.revokeObjectURL(blobUrl);
+      }
+    } else {
+      const exportCanvas = createExportCanvas(width, height, scale, resolvedBg);
+      if (renderer === "svg") {
+        const svg = getSvgElement(container);
+        if (svg) {
+          await renderSvgToCanvas(svg, exportCanvas, width, height, resolvedBg, true);
+        }
+      } else {
+        for (const c of getCanvasElements(container)) {
+          copyCanvasToExport(c, exportCanvas);
+        }
+      }
+      const rasterOverlayCtx = exportCanvas.getContext("2d");
+      if (rasterOverlayCtx) {
+        drawHtmlOverlaysToCanvas(container, rasterOverlayCtx, scale);
+      }
+      const mimeType = format === "jpeg" ? "image/jpeg" : "image/png";
+      dataUrl = exportCanvas.toDataURL(mimeType, quality);
+      finalFilename = `${filename}.${format}`;
+      if (download) {
+        downloadFile(dataUrl, finalFilename);
+      }
+    }
+    return { dataUrl, filename: finalFilename, format };
+  };
+  const toDataURL = async (format = "png") => {
+    const result = await toImage({ format, download: false });
+    return result.dataUrl;
+  };
+  const toBlob = async (format = "png") => {
+    const result = await toImage({ format, download: false });
+    if (format === "svg") {
+      const svgContent = decodeURIComponent(result.dataUrl.replace("data:image/svg+xml;charset=utf-8,", ""));
+      return new Blob([svgContent], { type: "image/svg+xml" });
+    }
+    if (format === "pdf") {
+      const base64 = result.dataUrl.replace("data:application/pdf;base64,", "");
+      const bytes = base64ToUint8Array(base64);
+      return new Blob([bytes.buffer], { type: "application/pdf" });
+    }
+    const response = await fetch(result.dataUrl);
+    return response.blob();
+  };
+  return {
+    toImage,
+    toDataURL,
+    toBlob
+  };
+}
+
+export { createChartExporter };