@opendata-ai/openchart-vanilla 8.0.0-rc.8 → 8.0.0

package/dist/chunk-T32UHMZA.js

@@ -0,0 +1,282 @@
+import {
+  injectThemeStyleBlock
+} from "./chunk-RM5XS6NR.js";
+
+// src/export.ts
+function getSVGDimensions(svg) {
+  const w = parseFloat(svg.getAttribute("width") || "");
+  const h = parseFloat(svg.getAttribute("height") || "");
+  if (w && h) return { width: w, height: h };
+  const vb = svg.getAttribute("viewBox");
+  if (vb) {
+    const parts = vb.split(/[\s,]+/).map(Number);
+    if (parts.length >= 4 && parts[2] && parts[3]) {
+      return { width: parts[2], height: parts[3] };
+    }
+  }
+  return { width: 600, height: 400 };
+}
+function ensureSVGDimensions(svgString, width, height) {
+  if (/^<svg[^>]*\swidth\s*=/.test(svgString)) return svgString;
+  return svgString.replace(/^(<svg)/, `$1 width="${width}" height="${height}"`);
+}
+function collectUsedFonts(svgElement) {
+  const fonts = /* @__PURE__ */ new Map();
+  const textElements = svgElement.querySelectorAll("text");
+  for (const el of textElements) {
+    const family = el.getAttribute("font-family");
+    const weight = el.getAttribute("font-weight") || "400";
+    if (family) {
+      const primary = family.split(",")[0].trim().replace(/["']/g, "");
+      if (!fonts.has(primary)) fonts.set(primary, /* @__PURE__ */ new Set());
+      fonts.get(primary).add(String(weight));
+    }
+  }
+  return fonts;
+}
+function findFontFaceRules(usedFonts) {
+  const results = [];
+  try {
+    for (const sheet of document.styleSheets) {
+      let rules;
+      try {
+        rules = sheet.cssRules;
+      } catch {
+        continue;
+      }
+      for (const rule of rules) {
+        if (!(rule instanceof CSSFontFaceRule)) continue;
+        const familyRaw = rule.style.getPropertyValue("font-family").replace(/["']/g, "").trim();
+        const weight = rule.style.getPropertyValue("font-weight") || "400";
+        const style = rule.style.getPropertyValue("font-style") || "normal";
+        const src = rule.style.getPropertyValue("src");
+        const weights = usedFonts.get(familyRaw);
+        if (!weights) continue;
+        const weightMatch = weights.has(weight) || weight.includes(" ");
+        if (!weightMatch) continue;
+        const woff2Match = src.match(/url\(["']?([^"')]+\.woff2[^"')]*?)["']?\)/);
+        if (woff2Match) {
+          results.push({
+            family: familyRaw,
+            weight,
+            style,
+            url: woff2Match[1],
+            format: "woff2"
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+async function fetchFontsAsBase64(fontRules) {
+  const results = [];
+  const fetches = fontRules.map(async (rule) => {
+    try {
+      const response = await fetch(rule.url);
+      if (!response.ok) return;
+      const buffer = await response.arrayBuffer();
+      const base64 = arrayBufferToBase64(buffer);
+      results.push({
+        family: rule.family,
+        weight: rule.weight,
+        style: rule.style,
+        base64,
+        format: rule.format
+      });
+    } catch {
+    }
+  });
+  await Promise.all(fetches);
+  return results;
+}
+function arrayBufferToBase64(buffer) {
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function injectFontsIntoSVG(svgElement, fonts) {
+  if (fonts.length === 0) return;
+  const cssRules = fonts.map(
+    (f) => `@font-face { font-family: '${f.family}'; font-weight: ${f.weight}; font-style: ${f.style}; src: url(data:font/${f.format};base64,${f.base64}) format('${f.format}'); }`
+  ).join("\n");
+  const ns = "http://www.w3.org/2000/svg";
+  let defs = svgElement.querySelector("defs");
+  if (!defs) {
+    defs = document.createElementNS(ns, "defs");
+    svgElement.insertBefore(defs, svgElement.firstChild);
+  }
+  const styleEl = document.createElementNS(ns, "style");
+  styleEl.textContent = cssRules;
+  defs.insertBefore(styleEl, defs.firstChild);
+}
+async function embedFonts(svgElement) {
+  const usedFonts = collectUsedFonts(svgElement);
+  if (usedFonts.size === 0) return;
+  const fontRules = findFontFaceRules(usedFonts);
+  if (fontRules.length === 0) return;
+  const fontData = await fetchFontsAsBase64(fontRules);
+  injectFontsIntoSVG(svgElement, fontData);
+}
+function getSVGBackgroundColor(svgElement, fallback) {
+  const firstRect = svgElement.querySelector("rect");
+  const fill = firstRect?.getAttribute("fill");
+  if (!fill || fill === "none" || fill === "transparent") return fallback ?? "#ffffff";
+  return fill;
+}
+function exportSVG(svgElement) {
+  if (!svgElement.getAttribute("xmlns")) {
+    svgElement.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  }
+  const serializer = new XMLSerializer();
+  return serializer.serializeToString(svgElement);
+}
+async function exportSVGWithFonts(svgElement, options) {
+  const clone = svgElement.cloneNode(true);
+  const shouldEmbed = options?.embedFonts ?? true;
+  injectThemeStyleBlock(clone, options?.theme);
+  if (shouldEmbed) {
+    await embedFonts(clone);
+  }
+  return exportSVG(clone);
+}
+var p3Supported;
+function supportsDisplayP3() {
+  if (p3Supported !== void 0) return p3Supported;
+  try {
+    const probe = document.createElement("canvas");
+    const ctx = probe.getContext("2d", { colorSpace: "display-p3" });
+    p3Supported = !!ctx && ctx.getContextAttributes?.().colorSpace === "display-p3";
+  } catch {
+    p3Supported = false;
+  }
+  return p3Supported;
+}
+function getExportContext(canvas) {
+  const ctx = supportsDisplayP3() ? canvas.getContext("2d", { colorSpace: "display-p3" }) : canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Canvas 2D context not available");
+  }
+  return ctx;
+}
+function rasterizeSVGToCanvas(svgString, width, height, dpi, prepare) {
+  if (!width || !height) {
+    throw new Error(`SVG has zero dimensions (width=${width}, height=${height})`);
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = width * dpi;
+  canvas.height = height * dpi;
+  const ctx = getExportContext(canvas);
+  prepare?.(ctx, canvas);
+  ctx.scale(dpi, dpi);
+  const img = new Image();
+  const blob = new Blob([svgString], { type: "image/svg+xml;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  return new Promise((resolve, reject) => {
+    img.onload = () => {
+      ctx.drawImage(img, 0, 0, width, height);
+      URL.revokeObjectURL(url);
+      resolve(canvas);
+    };
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(
+        new Error(
+          `Failed to load SVG as image (width=${width}, height=${height}, svgLength=${svgString.length})`
+        )
+      );
+    };
+    img.src = url;
+  });
+}
+async function prepareRasterSVG(svgElement, shouldEmbed, theme) {
+  const { width, height } = getSVGDimensions(svgElement);
+  const clone = svgElement.cloneNode(true);
+  injectThemeStyleBlock(clone, theme);
+  if (shouldEmbed) {
+    await embedFonts(clone);
+  }
+  const svgString = ensureSVGDimensions(exportSVG(clone), width, height);
+  return { svgString, width, height };
+}
+async function exportPNG(svgElement, options) {
+  const dpi = options?.dpi ?? 2;
+  const shouldEmbed = options?.embedFonts ?? true;
+  const { svgString, width, height } = await prepareRasterSVG(
+    svgElement,
+    shouldEmbed,
+    options?.theme
+  );
+  const canvas = await rasterizeSVGToCanvas(svgString, width, height, dpi);
+  return new Promise((resolve, reject) => {
+    canvas.toBlob((result) => {
+      if (result) {
+        resolve(result);
+      } else {
+        reject(new Error("Canvas toBlob returned null"));
+      }
+    }, "image/png");
+  });
+}
+async function exportJPG(svgElement, options) {
+  const dpi = options?.dpi ?? 2;
+  const quality = options?.quality ?? 0.92;
+  const shouldEmbed = options?.embedFonts ?? true;
+  const backgroundColor = getSVGBackgroundColor(svgElement);
+  const { svgString, width, height } = await prepareRasterSVG(
+    svgElement,
+    shouldEmbed,
+    options?.theme
+  );
+  const canvas = await rasterizeSVGToCanvas(svgString, width, height, dpi, (ctx, cv) => {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, cv.width, cv.height);
+  });
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (result) => {
+        if (result) {
+          resolve(result);
+        } else {
+          reject(new Error("Canvas toBlob returned null"));
+        }
+      },
+      "image/jpeg",
+      quality
+    );
+  });
+}
+function exportCSV(data) {
+  if (data.length === 0) return "";
+  const headers = Object.keys(data[0]);
+  const rows = [headers.map(csvEscape).join(",")];
+  for (const row of data) {
+    const values = headers.map((h) => csvEscape(String(row[h] ?? "")));
+    rows.push(values.join(","));
+  }
+  return rows.join("\n");
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+export {
+  getSVGDimensions,
+  ensureSVGDimensions,
+  embedFonts,
+  getSVGBackgroundColor,
+  exportSVG,
+  exportSVGWithFonts,
+  rasterizeSVGToCanvas,
+  exportPNG,
+  exportJPG,
+  exportCSV
+};
+//# sourceMappingURL=chunk-T32UHMZA.js.map

package/dist/chunk-T32UHMZA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/export.ts"],"sourcesContent":["/**\n * Export utilities: serialize charts to SVG, PNG, JPG, or CSV.\n *\n * - SVG: serializes the rendered DOM element via XMLSerializer\n * - SVG with fonts: async version that embeds @font-face data URIs\n * - PNG: renders SVG to canvas, then extracts as Blob\n * - JPG: same as PNG but with JPEG compression and background fill\n * - CSV: converts a data array to comma-separated text\n */\n\nimport type { ResolvedTheme } from '@opendata-ai/openchart-core';\nimport { injectThemeStyleBlock } from './theme-style-block';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface SVGExportOptions {\n  /** Embed fonts as base64 data URIs in the SVG. Defaults to true. */\n  embedFonts?: boolean;\n  /**\n   * Resolved theme to inline as a `<style>` block, so class-based fills (metric\n   * cells, brand watermark dot, legend text, endpoint labels) survive\n   * serialization away from the page stylesheet. Omit to skip — a chart whose\n   * chrome is all inline-filled exports fine without it.\n   */\n  theme?: ResolvedTheme;\n}\n\nexport interface PNGExportOptions extends SVGExportOptions {\n  /** DPI scaling factor. Defaults to 2 for retina-quality output. */\n  dpi?: number;\n}\n\nexport interface JPGExportOptions extends PNGExportOptions {\n  /** JPEG quality from 0 to 1. Defaults to 0.92. */\n  quality?: number;\n}\n\ninterface FontFaceData {\n  family: string;\n  weight: string;\n  style: string;\n  base64: string;\n  format: string;\n}\n\n// ---------------------------------------------------------------------------\n// Dimension parsing\n// ---------------------------------------------------------------------------\n\n/**\n * Extract dimensions from an SVG element, trying width/height attributes\n * first, then falling back to viewBox.\n */\nexport function getSVGDimensions(svg: SVGElement): { width: number; height: number } {\n  const w = parseFloat(svg.getAttribute('width') || '');\n  const h = parseFloat(svg.getAttribute('height') || '');\n  if (w && h) return { width: w, height: h };\n\n  const vb = svg.getAttribute('viewBox');\n  if (vb) {\n    const parts = vb.split(/[\\s,]+/).map(Number);\n    if (parts.length >= 4 && parts[2] && parts[3]) {\n      return { width: parts[2], height: parts[3] };\n    }\n  }\n\n  return { width: 600, height: 400 };\n}\n\n/**\n * Ensure an SVG string has explicit width/height attributes.\n *\n * When an SVG only has a viewBox (no width/height), browsers loading it as\n * an Image blob may use 300x150 as the intrinsic size instead of the viewBox\n * dimensions. This causes clipping at non-1x DPI scaling. Injecting explicit\n * width/height into the root <svg> tag fixes the intrinsic size.\n */\nexport function ensureSVGDimensions(svgString: string, width: number, height: number): string {\n  // If the <svg> already has a width attribute, leave it alone\n  if (/^<svg[^>]*\\swidth\\s*=/.test(svgString)) return svgString;\n  // Inject width and height right after <svg\n  return svgString.replace(/^(<svg)/, `$1 width=\"${width}\" height=\"${height}\"`);\n}\n\n// ---------------------------------------------------------------------------\n// Font embedding\n// ---------------------------------------------------------------------------\n\n/**\n * Collect unique font-family + font-weight combos from all <text> elements.\n */\nfunction collectUsedFonts(svgElement: SVGElement): Map<string, Set<string>> {\n  const fonts = new Map<string, Set<string>>();\n  const textElements = svgElement.querySelectorAll('text');\n\n  for (const el of textElements) {\n    const family = el.getAttribute('font-family');\n    const weight = el.getAttribute('font-weight') || '400';\n    if (family) {\n      // Take the first font in the stack (e.g., \"Inter, sans-serif\" → \"Inter\")\n      const primary = family.split(',')[0].trim().replace(/[\"']/g, '');\n      if (!fonts.has(primary)) fonts.set(primary, new Set());\n      fonts.get(primary)!.add(String(weight));\n    }\n  }\n\n  return fonts;\n}\n\n/**\n * Find @font-face rules in document stylesheets that match the requested fonts.\n * Returns the src URLs for .woff2 files.\n */\nfunction findFontFaceRules(\n  usedFonts: Map<string, Set<string>>,\n): Array<{ family: string; weight: string; style: string; url: string; format: string }> {\n  const results: Array<{\n    family: string;\n    weight: string;\n    style: string;\n    url: string;\n    format: string;\n  }> = [];\n\n  try {\n    for (const sheet of document.styleSheets) {\n      let rules: CSSRuleList;\n      try {\n        rules = sheet.cssRules;\n      } catch {\n        // Cross-origin stylesheet, skip\n        continue;\n      }\n\n      for (const rule of rules) {\n        if (!(rule instanceof CSSFontFaceRule)) continue;\n\n        const familyRaw = rule.style.getPropertyValue('font-family').replace(/[\"']/g, '').trim();\n        const weight = rule.style.getPropertyValue('font-weight') || '400';\n        const style = rule.style.getPropertyValue('font-style') || 'normal';\n        const src = rule.style.getPropertyValue('src');\n\n        const weights = usedFonts.get(familyRaw);\n        if (!weights) continue;\n\n        // Check if this weight is used (handle ranges like \"100 900\")\n        const weightMatch = weights.has(weight) || weight.includes(' ');\n        if (!weightMatch) continue;\n\n        // Extract woff2 URL from src descriptor\n        const woff2Match = src.match(/url\\([\"']?([^\"')]+\\.woff2[^\"')]*?)[\"']?\\)/);\n        if (woff2Match) {\n          results.push({\n            family: familyRaw,\n            weight,\n            style,\n            url: woff2Match[1],\n            format: 'woff2',\n          });\n        }\n      }\n    }\n  } catch {\n    // Stylesheet access failed entirely, return empty\n  }\n\n  return results;\n}\n\n/**\n * Fetch font files and convert to base64 data URIs.\n */\nasync function fetchFontsAsBase64(\n  fontRules: Array<{ family: string; weight: string; style: string; url: string; format: string }>,\n): Promise<FontFaceData[]> {\n  const results: FontFaceData[] = [];\n\n  const fetches = fontRules.map(async (rule) => {\n    try {\n      const response = await fetch(rule.url);\n      if (!response.ok) return;\n      const buffer = await response.arrayBuffer();\n      const base64 = arrayBufferToBase64(buffer);\n      results.push({\n        family: rule.family,\n        weight: rule.weight,\n        style: rule.style,\n        base64,\n        format: rule.format,\n      });\n    } catch {\n      // Font fetch failed (CORS, network, etc.) - skip this font\n    }\n  });\n\n  await Promise.all(fetches);\n  return results;\n}\n\nfunction arrayBufferToBase64(buffer: ArrayBuffer): string {\n  let binary = '';\n  const bytes = new Uint8Array(buffer);\n  for (let i = 0; i < bytes.byteLength; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n/**\n * Inject @font-face rules with base64 data URIs into the SVG's <defs>.\n */\nfunction injectFontsIntoSVG(svgElement: SVGElement, fonts: FontFaceData[]): void {\n  if (fonts.length === 0) return;\n\n  const cssRules = fonts\n    .map(\n      (f) =>\n        `@font-face { font-family: '${f.family}'; font-weight: ${f.weight}; font-style: ${f.style}; src: url(data:font/${f.format};base64,${f.base64}) format('${f.format}'); }`,\n    )\n    .join('\\n');\n\n  const ns = 'http://www.w3.org/2000/svg';\n  let defs = svgElement.querySelector('defs');\n  if (!defs) {\n    defs = document.createElementNS(ns, 'defs');\n    svgElement.insertBefore(defs, svgElement.firstChild);\n  }\n\n  const styleEl = document.createElementNS(ns, 'style');\n  styleEl.textContent = cssRules;\n  defs.insertBefore(styleEl, defs.firstChild);\n}\n\n/**\n * Embed fonts into an SVG element by finding matching @font-face rules\n * in the page's stylesheets, fetching the font files, and injecting\n * them as base64 data URIs.\n *\n * Modifies the SVG element in place. Call this before serialization.\n * If font fetching fails for any font, that font is silently skipped\n * and the export proceeds with system font fallback for that face.\n */\nexport async function embedFonts(svgElement: SVGElement): Promise<void> {\n  const usedFonts = collectUsedFonts(svgElement);\n  if (usedFonts.size === 0) return;\n\n  const fontRules = findFontFaceRules(usedFonts);\n  if (fontRules.length === 0) return;\n\n  const fontData = await fetchFontsAsBase64(fontRules);\n  injectFontsIntoSVG(svgElement, fontData);\n}\n\n// ---------------------------------------------------------------------------\n// SVG background color\n// ---------------------------------------------------------------------------\n\n/**\n * Read the chart's background color from its first rect element. Falls back to\n * `fallback` (white when omitted) when the chart has no opaque background,\n * which matters for formats that can't carry alpha (JPEG, GIF).\n *\n * Pass the resolved theme's `colors.background` as `fallback` when the caller\n * has one: canvas mark mode suppresses the SVG background rect (the canvas\n * paints it), so without it a dark chart would flood-fill white.\n */\nexport function getSVGBackgroundColor(svgElement: SVGElement, fallback?: string): string {\n  const firstRect = svgElement.querySelector('rect');\n  const fill = firstRect?.getAttribute('fill');\n  if (!fill || fill === 'none' || fill === 'transparent') return fallback ?? '#ffffff';\n  return fill;\n}\n\n// ---------------------------------------------------------------------------\n// SVG export\n// ---------------------------------------------------------------------------\n\n/**\n * Serialize an SVG element to an XML string.\n *\n * @param svgElement - The rendered SVG element to serialize.\n * @returns The SVG markup as a string.\n */\nexport function exportSVG(svgElement: SVGElement): string {\n  if (!svgElement.getAttribute('xmlns')) {\n    svgElement.setAttribute('xmlns', 'http://www.w3.org/2000/svg');\n  }\n  const serializer = new XMLSerializer();\n  return serializer.serializeToString(svgElement);\n}\n\n/**\n * Serialize an SVG element with embedded fonts to an XML string.\n *\n * Collects font-family declarations from the SVG's text elements,\n * finds matching @font-face rules in the page's stylesheets, fetches\n * the font files, and embeds them as base64 data URIs. The resulting\n * SVG is self-contained and renders correctly without external fonts.\n *\n * @param svgElement - The rendered SVG element to serialize.\n * @param options - Export options.\n * @returns A Promise resolving to the SVG markup as a string.\n */\nexport async function exportSVGWithFonts(\n  svgElement: SVGElement,\n  options?: SVGExportOptions,\n): Promise<string> {\n  const clone = svgElement.cloneNode(true) as SVGElement;\n  const shouldEmbed = options?.embedFonts ?? true;\n  injectThemeStyleBlock(clone, options?.theme);\n  if (shouldEmbed) {\n    await embedFonts(clone);\n  }\n  return exportSVG(clone);\n}\n\n// ---------------------------------------------------------------------------\n// Raster export (PNG / JPG)\n// ---------------------------------------------------------------------------\n\n/**\n * Cache the one-time probe for Display P3 canvas support. Rendering raster\n * exports into a display-p3 canvas makes toBlob embed a wide-gamut color profile\n * (verified: an sRGB PNG has no iCCP chunk; a display-p3 PNG does — and JPEG\n * upgrades from an sRGB to a P3 profile), so the export matches the on-screen\n * chart instead of reading as an untagged/sRGB image that looks washed out on\n * P3 displays.\n */\nlet p3Supported: boolean | undefined;\n\nfunction supportsDisplayP3(): boolean {\n  if (p3Supported !== undefined) return p3Supported;\n  try {\n    const probe = document.createElement('canvas');\n    const ctx = probe.getContext('2d', { colorSpace: 'display-p3' }) as\n      | (CanvasRenderingContext2D & { getContextAttributes?: () => { colorSpace?: string } })\n      | null;\n    p3Supported = !!ctx && ctx.getContextAttributes?.().colorSpace === 'display-p3';\n  } catch {\n    p3Supported = false;\n  }\n  return p3Supported;\n}\n\n/**\n * Create a 2D context in the widest color space the runtime supports. A\n * display-p3 canvas is what makes toBlob embed the profile. Callers that read\n * pixels back for a non-color-managed sink (GIF quantization) must NOT rely on\n * this — they must read back in sRGB explicitly.\n */\nfunction getExportContext(canvas: HTMLCanvasElement): CanvasRenderingContext2D {\n  const ctx = supportsDisplayP3()\n    ? canvas.getContext('2d', { colorSpace: 'display-p3' })\n    : canvas.getContext('2d');\n  if (!ctx) {\n    throw new Error('Canvas 2D context not available');\n  }\n  return ctx;\n}\n\n/**\n * Draw a serialized SVG string onto a canvas at DPI scaling.\n *\n * Shared by PNG/JPG export and per-frame GIF rendering: loads the SVG string\n * as an Image via an object URL, draws it into a `width*dpi × height*dpi`\n * canvas, and hands the canvas back once painted. The caller decides how to\n * read the result (toBlob for PNG/JPG, getImageData for GIF frames).\n *\n * An optional `prepare` hook runs before drawing the image, used by JPG export\n * to fill an opaque background so transparency doesn't render as black.\n *\n * @param svgString - Serialized SVG markup (should already carry width/height).\n * @param width - Logical width in CSS pixels.\n * @param height - Logical height in CSS pixels.\n * @param dpi - Device pixel ratio scaling factor.\n * @param prepare - Optional pre-draw hook receiving the scaled 2D context.\n * @returns A Promise resolving to the painted canvas.\n */\nexport function rasterizeSVGToCanvas(\n  svgString: string,\n  width: number,\n  height: number,\n  dpi: number,\n  prepare?: (ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void,\n): Promise<HTMLCanvasElement> {\n  if (!width || !height) {\n    throw new Error(`SVG has zero dimensions (width=${width}, height=${height})`);\n  }\n\n  const canvas = document.createElement('canvas');\n  canvas.width = width * dpi;\n  canvas.height = height * dpi;\n\n  const ctx = getExportContext(canvas);\n\n  prepare?.(ctx, canvas);\n  ctx.scale(dpi, dpi);\n\n  const img = new Image();\n  const blob = new Blob([svgString], { type: 'image/svg+xml;charset=utf-8' });\n  const url = URL.createObjectURL(blob);\n\n  return new Promise<HTMLCanvasElement>((resolve, reject) => {\n    img.onload = () => {\n      ctx.drawImage(img, 0, 0, width, height);\n      URL.revokeObjectURL(url);\n      resolve(canvas);\n    };\n\n    img.onerror = () => {\n      URL.revokeObjectURL(url);\n      reject(\n        new Error(\n          `Failed to load SVG as image (width=${width}, height=${height}, svgLength=${svgString.length})`,\n        ),\n      );\n    };\n\n    img.src = url;\n  });\n}\n\n/**\n * Serialize an SVG element (optionally embedding fonts) into a canvas-ready\n * string with explicit width/height. Shared by the raster exporters.\n */\nasync function prepareRasterSVG(\n  svgElement: SVGElement,\n  shouldEmbed: boolean,\n  theme?: ResolvedTheme,\n): Promise<{ svgString: string; width: number; height: number }> {\n  const { width, height } = getSVGDimensions(svgElement);\n  const clone = svgElement.cloneNode(true) as SVGElement;\n  // Inline the theme style block so class-based fills survive the detach from\n  // the page stylesheet. No-op when theme is undefined.\n  injectThemeStyleBlock(clone, theme);\n  if (shouldEmbed) {\n    await embedFonts(clone);\n  }\n  const svgString = ensureSVGDimensions(exportSVG(clone), width, height);\n  return { svgString, width, height };\n}\n\n/**\n * Render an SVG element to a PNG Blob via a canvas.\n *\n * Embeds fonts by default so the exported image matches on-screen rendering.\n * Set `embedFonts: false` to skip font embedding for faster exports.\n *\n * @param svgElement - The rendered SVG element.\n * @param options - Optional DPI scaling and font embedding.\n * @returns A Promise resolving to the PNG Blob.\n */\nexport async function exportPNG(svgElement: SVGElement, options?: PNGExportOptions): Promise<Blob> {\n  const dpi = options?.dpi ?? 2;\n  const shouldEmbed = options?.embedFonts ?? true;\n  const { svgString, width, height } = await prepareRasterSVG(\n    svgElement,\n    shouldEmbed,\n    options?.theme,\n  );\n  const canvas = await rasterizeSVGToCanvas(svgString, width, height, dpi);\n\n  return new Promise<Blob>((resolve, reject) => {\n    canvas.toBlob((result) => {\n      if (result) {\n        resolve(result);\n      } else {\n        reject(new Error('Canvas toBlob returned null'));\n      }\n    }, 'image/png');\n  });\n}\n\n/**\n * Render an SVG element to a JPEG Blob via a canvas.\n *\n * Same pipeline as exportPNG but outputs JPEG with configurable quality.\n * The canvas is filled with the chart's background color before drawing\n * to avoid transparent backgrounds rendering as black in JPEG format.\n *\n * @param svgElement - The rendered SVG element.\n * @param options - Optional DPI scaling, JPEG quality, and font embedding.\n * @returns A Promise resolving to the JPEG Blob.\n */\nexport async function exportJPG(svgElement: SVGElement, options?: JPGExportOptions): Promise<Blob> {\n  const dpi = options?.dpi ?? 2;\n  const quality = options?.quality ?? 0.92;\n  const shouldEmbed = options?.embedFonts ?? true;\n  const backgroundColor = getSVGBackgroundColor(svgElement);\n  const { svgString, width, height } = await prepareRasterSVG(\n    svgElement,\n    shouldEmbed,\n    options?.theme,\n  );\n\n  // Fill an opaque background before drawing so transparency doesn't render\n  // as black in the JPEG. Runs before ctx.scale, so use the raw canvas size.\n  const canvas = await rasterizeSVGToCanvas(svgString, width, height, dpi, (ctx, cv) => {\n    ctx.fillStyle = backgroundColor;\n    ctx.fillRect(0, 0, cv.width, cv.height);\n  });\n\n  return new Promise<Blob>((resolve, reject) => {\n    canvas.toBlob(\n      (result) => {\n        if (result) {\n          resolve(result);\n        } else {\n          reject(new Error('Canvas toBlob returned null'));\n        }\n      },\n      'image/jpeg',\n      quality,\n    );\n  });\n}\n\n// ---------------------------------------------------------------------------\n// CSV export\n// ---------------------------------------------------------------------------\n\n/**\n * Convert an array of data objects to a CSV string.\n *\n * Uses the keys from the first row as column headers.\n * Values are quoted if they contain commas, quotes, or newlines.\n *\n * @param data - Array of row objects.\n * @returns CSV-formatted string.\n */\nexport function exportCSV(data: Record<string, unknown>[]): string {\n  if (data.length === 0) return '';\n\n  const headers = Object.keys(data[0]);\n  const rows = [headers.map(csvEscape).join(',')];\n\n  for (const row of data) {\n    const values = headers.map((h) => csvEscape(String(row[h] ?? '')));\n    rows.push(values.join(','));\n  }\n\n  return rows.join('\\n');\n}\n\nfunction csvEscape(value: string): string {\n  if (value.includes(',') || value.includes('\"') || value.includes('\\n') || value.includes('\\r')) {\n    return `\"${value.replace(/\"/g, '\"\"')}\"`;\n  }\n  return value;\n}\n"],"mappings":";;;;;AAuDO,SAAS,iBAAiB,KAAoD;AACnF,QAAM,IAAI,WAAW,IAAI,aAAa,OAAO,KAAK,EAAE;AACpD,QAAM,IAAI,WAAW,IAAI,aAAa,QAAQ,KAAK,EAAE;AACrD,MAAI,KAAK,EAAG,QAAO,EAAE,OAAO,GAAG,QAAQ,EAAE;AAEzC,QAAM,KAAK,IAAI,aAAa,SAAS;AACrC,MAAI,IAAI;AACN,UAAM,QAAQ,GAAG,MAAM,QAAQ,EAAE,IAAI,MAAM;AAC3C,QAAI,MAAM,UAAU,KAAK,MAAM,CAAC,KAAK,MAAM,CAAC,GAAG;AAC7C,aAAO,EAAE,OAAO,MAAM,CAAC,GAAG,QAAQ,MAAM,CAAC,EAAE;AAAA,IAC7C;AAAA,EACF;AAEA,SAAO,EAAE,OAAO,KAAK,QAAQ,IAAI;AACnC;AAUO,SAAS,oBAAoB,WAAmB,OAAe,QAAwB;AAE5F,MAAI,wBAAwB,KAAK,SAAS,EAAG,QAAO;AAEpD,SAAO,UAAU,QAAQ,WAAW,aAAa,KAAK,aAAa,MAAM,GAAG;AAC9E;AASA,SAAS,iBAAiB,YAAkD;AAC1E,QAAM,QAAQ,oBAAI,IAAyB;AAC3C,QAAM,eAAe,WAAW,iBAAiB,MAAM;AAEvD,aAAW,MAAM,cAAc;AAC7B,UAAM,SAAS,GAAG,aAAa,aAAa;AAC5C,UAAM,SAAS,GAAG,aAAa,aAAa,KAAK;AACjD,QAAI,QAAQ;AAEV,YAAM,UAAU,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,SAAS,EAAE;AAC/D,UAAI,CAAC,MAAM,IAAI,OAAO,EAAG,OAAM,IAAI,SAAS,oBAAI,IAAI,CAAC;AACrD,YAAM,IAAI,OAAO,EAAG,IAAI,OAAO,MAAM,CAAC;AAAA,IACxC;AAAA,EACF;AAEA,SAAO;AACT;AAMA,SAAS,kBACP,WACuF;AACvF,QAAM,UAMD,CAAC;AAEN,MAAI;AACF,eAAW,SAAS,SAAS,aAAa;AACxC,UAAI;AACJ,UAAI;AACF,gBAAQ,MAAM;AAAA,MAChB,QAAQ;AAEN;AAAA,MACF;AAEA,iBAAW,QAAQ,OAAO;AACxB,YAAI,EAAE,gBAAgB,iBAAkB;AAExC,cAAM,YAAY,KAAK,MAAM,iBAAiB,aAAa,EAAE,QAAQ,SAAS,EAAE,EAAE,KAAK;AACvF,cAAM,SAAS,KAAK,MAAM,iBAAiB,aAAa,KAAK;AAC7D,cAAM,QAAQ,KAAK,MAAM,iBAAiB,YAAY,KAAK;AAC3D,cAAM,MAAM,KAAK,MAAM,iBAAiB,KAAK;AAE7C,cAAM,UAAU,UAAU,IAAI,SAAS;AACvC,YAAI,CAAC,QAAS;AAGd,cAAM,cAAc,QAAQ,IAAI,MAAM,KAAK,OAAO,SAAS,GAAG;AAC9D,YAAI,CAAC,YAAa;AAGlB,cAAM,aAAa,IAAI,MAAM,2CAA2C;AACxE,YAAI,YAAY;AACd,kBAAQ,KAAK;AAAA,YACX,QAAQ;AAAA,YACR;AAAA,YACA;AAAA,YACA,KAAK,WAAW,CAAC;AAAA,YACjB,QAAQ;AAAA,UACV,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AAEA,SAAO;AACT;AAKA,eAAe,mBACb,WACyB;AACzB,QAAM,UAA0B,CAAC;AAEjC,QAAM,UAAU,UAAU,IAAI,OAAO,SAAS;AAC5C,QAAI;AACF,YAAM,WAAW,MAAM,MAAM,KAAK,GAAG;AACrC,UAAI,CAAC,SAAS,GAAI;AAClB,YAAM,SAAS,MAAM,SAAS,YAAY;AAC1C,YAAM,SAAS,oBAAoB,MAAM;AACzC,cAAQ,KAAK;AAAA,QACX,QAAQ,KAAK;AAAA,QACb,QAAQ,KAAK;AAAA,QACb,OAAO,KAAK;AAAA,QACZ;AAAA,QACA,QAAQ,KAAK;AAAA,MACf,CAAC;AAAA,IACH,QAAQ;AAAA,IAER;AAAA,EACF,CAAC;AAED,QAAM,QAAQ,IAAI,OAAO;AACzB,SAAO;AACT;AAEA,SAAS,oBAAoB,QAA6B;AACxD,MAAI,SAAS;AACb,QAAM,QAAQ,IAAI,WAAW,MAAM;AACnC,WAAS,IAAI,GAAG,IAAI,MAAM,YAAY,KAAK;AACzC,cAAU,OAAO,aAAa,MAAM,CAAC,CAAC;AAAA,EACxC;AACA,SAAO,KAAK,MAAM;AACpB;AAKA,SAAS,mBAAmB,YAAwB,OAA6B;AAC/E,MAAI,MAAM,WAAW,EAAG;AAExB,QAAM,WAAW,MACd;AAAA,IACC,CAAC,MACC,8BAA8B,EAAE,MAAM,mBAAmB,EAAE,MAAM,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,EAAE,MAAM,aAAa,EAAE,MAAM;AAAA,EACrK,EACC,KAAK,IAAI;AAEZ,QAAM,KAAK;AACX,MAAI,OAAO,WAAW,cAAc,MAAM;AAC1C,MAAI,CAAC,MAAM;AACT,WAAO,SAAS,gBAAgB,IAAI,MAAM;AAC1C,eAAW,aAAa,MAAM,WAAW,UAAU;AAAA,EACrD;AAEA,QAAM,UAAU,SAAS,gBAAgB,IAAI,OAAO;AACpD,UAAQ,cAAc;AACtB,OAAK,aAAa,SAAS,KAAK,UAAU;AAC5C;AAWA,eAAsB,WAAW,YAAuC;AACtE,QAAM,YAAY,iBAAiB,UAAU;AAC7C,MAAI,UAAU,SAAS,EAAG;AAE1B,QAAM,YAAY,kBAAkB,SAAS;AAC7C,MAAI,UAAU,WAAW,EAAG;AAE5B,QAAM,WAAW,MAAM,mBAAmB,SAAS;AACnD,qBAAmB,YAAY,QAAQ;AACzC;AAeO,SAAS,sBAAsB,YAAwB,UAA2B;AACvF,QAAM,YAAY,WAAW,cAAc,MAAM;AACjD,QAAM,OAAO,WAAW,aAAa,MAAM;AAC3C,MAAI,CAAC,QAAQ,SAAS,UAAU,SAAS,cAAe,QAAO,YAAY;AAC3E,SAAO;AACT;AAYO,SAAS,UAAU,YAAgC;AACxD,MAAI,CAAC,WAAW,aAAa,OAAO,GAAG;AACrC,eAAW,aAAa,SAAS,4BAA4B;AAAA,EAC/D;AACA,QAAM,aAAa,IAAI,cAAc;AACrC,SAAO,WAAW,kBAAkB,UAAU;AAChD;AAcA,eAAsB,mBACpB,YACA,SACiB;AACjB,QAAM,QAAQ,WAAW,UAAU,IAAI;AACvC,QAAM,cAAc,SAAS,cAAc;AAC3C,wBAAsB,OAAO,SAAS,KAAK;AAC3C,MAAI,aAAa;AACf,UAAM,WAAW,KAAK;AAAA,EACxB;AACA,SAAO,UAAU,KAAK;AACxB;AAcA,IAAI;AAEJ,SAAS,oBAA6B;AACpC,MAAI,gBAAgB,OAAW,QAAO;AACtC,MAAI;AACF,UAAM,QAAQ,SAAS,cAAc,QAAQ;AAC7C,UAAM,MAAM,MAAM,WAAW,MAAM,EAAE,YAAY,aAAa,CAAC;AAG/D,kBAAc,CAAC,CAAC,OAAO,IAAI,uBAAuB,EAAE,eAAe;AAAA,EACrE,QAAQ;AACN,kBAAc;AAAA,EAChB;AACA,SAAO;AACT;AAQA,SAAS,iBAAiB,QAAqD;AAC7E,QAAM,MAAM,kBAAkB,IAC1B,OAAO,WAAW,MAAM,EAAE,YAAY,aAAa,CAAC,IACpD,OAAO,WAAW,IAAI;AAC1B,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,SAAO;AACT;AAoBO,SAAS,qBACd,WACA,OACA,QACA,KACA,SAC4B;AAC5B,MAAI,CAAC,SAAS,CAAC,QAAQ;AACrB,UAAM,IAAI,MAAM,kCAAkC,KAAK,YAAY,MAAM,GAAG;AAAA,EAC9E;AAEA,QAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,SAAO,QAAQ,QAAQ;AACvB,SAAO,SAAS,SAAS;AAEzB,QAAM,MAAM,iBAAiB,MAAM;AAEnC,YAAU,KAAK,MAAM;AACrB,MAAI,MAAM,KAAK,GAAG;AAElB,QAAM,MAAM,IAAI,MAAM;AACtB,QAAM,OAAO,IAAI,KAAK,CAAC,SAAS,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAC1E,QAAM,MAAM,IAAI,gBAAgB,IAAI;AAEpC,SAAO,IAAI,QAA2B,CAAC,SAAS,WAAW;AACzD,QAAI,SAAS,MAAM;AACjB,UAAI,UAAU,KAAK,GAAG,GAAG,OAAO,MAAM;AACtC,UAAI,gBAAgB,GAAG;AACvB,cAAQ,MAAM;AAAA,IAChB;AAEA,QAAI,UAAU,MAAM;AAClB,UAAI,gBAAgB,GAAG;AACvB;AAAA,QACE,IAAI;AAAA,UACF,sCAAsC,KAAK,YAAY,MAAM,eAAe,UAAU,MAAM;AAAA,QAC9F;AAAA,MACF;AAAA,IACF;AAEA,QAAI,MAAM;AAAA,EACZ,CAAC;AACH;AAMA,eAAe,iBACb,YACA,aACA,OAC+D;AAC/D,QAAM,EAAE,OAAO,OAAO,IAAI,iBAAiB,UAAU;AACrD,QAAM,QAAQ,WAAW,UAAU,IAAI;AAGvC,wBAAsB,OAAO,KAAK;AAClC,MAAI,aAAa;AACf,UAAM,WAAW,KAAK;AAAA,EACxB;AACA,QAAM,YAAY,oBAAoB,UAAU,KAAK,GAAG,OAAO,MAAM;AACrE,SAAO,EAAE,WAAW,OAAO,OAAO;AACpC;AAYA,eAAsB,UAAU,YAAwB,SAA2C;AACjG,QAAM,MAAM,SAAS,OAAO;AAC5B,QAAM,cAAc,SAAS,cAAc;AAC3C,QAAM,EAAE,WAAW,OAAO,OAAO,IAAI,MAAM;AAAA,IACzC;AAAA,IACA;AAAA,IACA,SAAS;AAAA,EACX;AACA,QAAM,SAAS,MAAM,qBAAqB,WAAW,OAAO,QAAQ,GAAG;AAEvE,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,WAAO,OAAO,CAAC,WAAW;AACxB,UAAI,QAAQ;AACV,gBAAQ,MAAM;AAAA,MAChB,OAAO;AACL,eAAO,IAAI,MAAM,6BAA6B,CAAC;AAAA,MACjD;AAAA,IACF,GAAG,WAAW;AAAA,EAChB,CAAC;AACH;AAaA,eAAsB,UAAU,YAAwB,SAA2C;AACjG,QAAM,MAAM,SAAS,OAAO;AAC5B,QAAM,UAAU,SAAS,WAAW;AACpC,QAAM,cAAc,SAAS,cAAc;AAC3C,QAAM,kBAAkB,sBAAsB,UAAU;AACxD,QAAM,EAAE,WAAW,OAAO,OAAO,IAAI,MAAM;AAAA,IACzC;AAAA,IACA;AAAA,IACA,SAAS;AAAA,EACX;AAIA,QAAM,SAAS,MAAM,qBAAqB,WAAW,OAAO,QAAQ,KAAK,CAAC,KAAK,OAAO;AACpF,QAAI,YAAY;AAChB,QAAI,SAAS,GAAG,GAAG,GAAG,OAAO,GAAG,MAAM;AAAA,EACxC,CAAC;AAED,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,WAAO;AAAA,MACL,CAAC,WAAW;AACV,YAAI,QAAQ;AACV,kBAAQ,MAAM;AAAA,QAChB,OAAO;AACL,iBAAO,IAAI,MAAM,6BAA6B,CAAC;AAAA,QACjD;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAeO,SAAS,UAAU,MAAyC;AACjE,MAAI,KAAK,WAAW,EAAG,QAAO;AAE9B,QAAM,UAAU,OAAO,KAAK,KAAK,CAAC,CAAC;AACnC,QAAM,OAAO,CAAC,QAAQ,IAAI,SAAS,EAAE,KAAK,GAAG,CAAC;AAE9C,aAAW,OAAO,MAAM;AACtB,UAAM,SAAS,QAAQ,IAAI,CAAC,MAAM,UAAU,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;AACjE,SAAK,KAAK,OAAO,KAAK,GAAG,CAAC;AAAA,EAC5B;AAEA,SAAO,KAAK,KAAK,IAAI;AACvB;AAEA,SAAS,UAAU,OAAuB;AACxC,MAAI,MAAM,SAAS,GAAG,KAAK,MAAM,SAAS,GAAG,KAAK,MAAM,SAAS,IAAI,KAAK,MAAM,SAAS,IAAI,GAAG;AAC9F,WAAO,IAAI,MAAM,QAAQ,MAAM,IAAI,CAAC;AAAA,EACtC;AACA,SAAO;AACT;","names":[]}

package/dist/export-gif.d.ts

@@ -0,0 +1,113 @@
+import { ResolvedTheme, AnimationEase, ResolvedAnimation } from '@opendata-ai/openchart-core';
+
+/**
+ * Animated GIF export.
+ *
+ * Unlike PNG/JPG (single static frame), GIF export must reproduce the chart's
+ * entrance animation across many frames. OpenChart entrance animations are pure
+ * CSS keyframes that mutate `clip-path`/`opacity`/`transform` in *computed*
+ * style, which `XMLSerializer` does not capture — so serializing the live,
+ * mid-animation SVG yields the base markup on every frame (a static GIF).
+ *
+ * This module sidesteps that by *synthesizing* frames deterministically: it
+ * takes the settled, final-state SVG plus the resolved animation config,
+ * computes each animated element's value at time `t` in JS, stamps
+ * `clip-path`/`opacity` as INLINE attributes on a clone (inline values DO
+ * serialize), rasterizes that clone, and encodes each frame with gifenc.
+ *
+ * This mirrors the entrance keyframes in `packages/core/src/styles/*.css`:
+ * bars clip bottom-up / left-right, line/area clip left-right, arcs and points
+ * fade. Only the entrance is reproduced; the on-screen CSS animation is
+ * untouched. `gifenc` is an optional peer dependency, loaded dynamically.
+ */
+
+interface GIFExportOptions {
+    /** Frames per second to capture. Defaults to 25. */
+    fps?: number;
+    /** DPI scaling factor, matching PNG export. Defaults to 2. */
+    dpi?: number;
+    /**
+     * Loop behavior. Defaults to play-once (hold the final frame):
+     * - `false` / omitted: play once, then hold the final frame
+     * - `true`: loop forever
+     * - a number: loop that many times, then hold
+     */
+    loop?: boolean | number;
+    /**
+     * Explicit capture duration in ms. Defaults to the resolved animation total
+     * (enter duration + last element's stagger delay + a small tail).
+     */
+    durationMs?: number;
+    /** Embed fonts as base64 data URIs so text matches on-screen. Defaults to true. */
+    embedFonts?: boolean;
+    /**
+     * Opaque background fill. GIF can't carry partial alpha, so a transparent
+     * chart would composite onto black. Defaults to the chart's own background
+     * color (or white if the chart is transparent).
+     */
+    backgroundColor?: string;
+    /**
+     * Resolved theme to inline as a `<style>` block so class-based fills (metric
+     * cells, brand watermark dot, legend text) survive serialization. Omit to skip.
+     */
+    theme?: ResolvedTheme;
+}
+/** Which visual property an element's entrance keyframe animates. */
+type AnimationKind = 'bar-vertical' | 'bar-horizontal' | 'line-area' | 'fade';
+interface AnimatedTarget {
+    /** The element in the CLONE that receives per-frame inline styles. */
+    el: SVGElement;
+    kind: AnimationKind;
+    /** Start offset in ms (stagger * mark index). */
+    startMs: number;
+    /** Duration of this element's own animation in ms. */
+    durationMs: number;
+}
+/**
+ * Sample points of the `--oc-ease-smooth` token (see tokens.css). CSS
+ * `linear()` interpolates piecewise-linearly between evenly-spaced samples, so
+ * we reproduce it exactly rather than approximating with a cubic-bezier.
+ */
+declare const EASE_SMOOTH_SAMPLES: number[];
+/** Piecewise-linear evaluation of a CSS linear() sample array at t in [0,1]. */
+declare function evalLinearSamples(samples: number[], t: number): number;
+/**
+ * Classify an animated element (identified by `data-animation-index`) into the
+ * keyframe it plays, and return the element that should receive inline styles.
+ * Returns null only when a bar group has no shape child to clip. Unrecognized
+ * mark types (map/tilemap/table/text) fall back to a plain opacity fade rather
+ * than a hard pop-in — see the generic case at the end.
+ */
+declare function classifyTarget(groupOrEl: SVGElement): {
+    el: SVGElement;
+    kind: AnimationKind;
+} | null;
+/**
+ * Distinguish "the optional gifenc peer isn't installed" from a real error
+ * thrown while loading it. Node/bundlers use ERR_MODULE_NOT_FOUND /
+ * MODULE_NOT_FOUND / "Cannot find module" for the former.
+ */
+declare function isModuleNotFound(err: unknown): boolean;
+/**
+ * Map the `loop` option to gifenc's `repeat` value:
+ * `true` → 0 (loop forever), a number → that count, otherwise → -1 (play once,
+ * hold the final frame — the default and the common editorial case).
+ */
+declare function resolveRepeat(loop: boolean | number | undefined): number;
+/**
+ * Apply the interpolated entrance state for a target at absolute time `nowMs`,
+ * writing inline `clip-path`/`opacity` so it survives serialization.
+ */
+declare function applyFrameState(target: AnimatedTarget, nowMs: number, easeKind: AnimationEase): void;
+/**
+ * Render a chart's entrance animation to an animated GIF Blob.
+ *
+ * @param svgElement - The settled, fully-rendered chart SVG (animation complete).
+ * @param animation - The chart's resolved animation config (for exact timing).
+ *   When undefined, timing falls back to sensible defaults.
+ * @param options - fps, dpi, loop, duration, font-embedding overrides.
+ * @returns A Promise resolving to the GIF Blob.
+ */
+declare function exportGIF(svgElement: SVGElement, animation: ResolvedAnimation | undefined, options?: GIFExportOptions): Promise<Blob>;
+
+export { type AnimatedTarget, type AnimationKind, EASE_SMOOTH_SAMPLES, type GIFExportOptions, applyFrameState, classifyTarget, evalLinearSamples, exportGIF, isModuleNotFound, resolveRepeat };

package/dist/export-gif.js

@@ -0,0 +1,21 @@
+import {
+  EASE_SMOOTH_SAMPLES,
+  applyFrameState,
+  classifyTarget,
+  evalLinearSamples,
+  exportGIF,
+  isModuleNotFound,
+  resolveRepeat
+} from "./chunk-DCODCLWI.js";
+import "./chunk-T32UHMZA.js";
+import "./chunk-RM5XS6NR.js";
+export {
+  EASE_SMOOTH_SAMPLES,
+  applyFrameState,
+  classifyTarget,
+  evalLinearSamples,
+  exportGIF,
+  isModuleNotFound,
+  resolveRepeat
+};
+//# sourceMappingURL=export-gif.js.map

package/dist/export-gif.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}