@aparte/plugin-echarts 0.0.0-stage → 0.29.0

package/dist/core.js

@@ -0,0 +1,974 @@
+import { aparteGlobalConfig, escapeAttr } from "@aparte/core";
+const MAX_DEPTH = 64;
+const MAX_ROWS = 1e3;
+const MAX_COLUMNS = 50;
+const MAX_CELLS = 1e4;
+const PROTO_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const FONT_KEYS = /* @__PURE__ */ new Set(["font", "fontFamily", "fontStyle", "fontWeight", "fontSize"]);
+const SAFE_FONT = /^[\p{L}\p{N}\s,'"._/%-]*$/u;
+const IMAGE_SCHEME = /^\s*image:\/\//i;
+const CSS_URL = /(^|[^\w-])(url|src)\s*\(/i;
+const CSS_ESCAPE = /\\(?:([0-9a-f]{1,6})[ \t\n\r\f]?|([^\n\r\f]))/gi;
+const SAFE_COLOUR = /^\s*(?:[a-z]+|#[0-9a-f]{3,8}|(?:rgba?|hsla?)\(\s*[\d.,%\s/+-]*(?:deg)?[\d.,%\s/+-]*\))\s*$/i;
+const isColourKey = (key) => key === "fill" || key === "stroke" || /(^c|C)olor/.test(key);
+function cssUnescape(s) {
+  return s.replace(CSS_ESCAPE, (_all, hex, other) => {
+    if (other !== void 0) return other;
+    const code = parseInt(hex, 16);
+    return code === 0 || code > 1114111 || code >= 55296 && code <= 57343 ? "�" : String.fromCodePoint(code);
+  });
+}
+const COMPILED_KEYS = /* @__PURE__ */ new Set(["reg"]);
+const HTML_TOOLTIP_KEYS = ["extraCssText", "className", "appendTo", "appendToBody"];
+const HTML_FEATURES = ["saveAsImage", "dataView"];
+const isObject$1 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function sanitizeEChartsOption(option) {
+  if (!isObject$1(option)) return null;
+  const clean = walk(option, "", 0);
+  return isObject$1(clean) ? clean : null;
+}
+function walk(value, key, depth) {
+  if (depth > MAX_DEPTH) return void 0;
+  if (typeof value === "string") {
+    if (IMAGE_SCHEME.test(value) || CSS_URL.test(value) || CSS_URL.test(cssUnescape(value))) return void 0;
+    if (value.includes("\\") && value.includes("(")) return void 0;
+    if (isColourKey(key) && !SAFE_COLOUR.test(value)) return void 0;
+    if (FONT_KEYS.has(key) && !SAFE_FONT.test(value)) return void 0;
+    if (key === "link" || key === "sublink") return void 0;
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const out2 = [];
+    for (const item of value) {
+      const clean = walk(item, key, depth + 1);
+      if (clean !== void 0) out2.push(clean);
+      else if (!isObject$1(item)) out2.push(null);
+    }
+    return out2;
+  }
+  if (!isObject$1(value)) return value;
+  if ("image" in value || "svgElement" in value || value["type"] === "image") return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (PROTO_KEYS.has(k) || COMPILED_KEYS.has(k)) continue;
+    const clean = walk(v, k, depth + 1);
+    if (clean !== void 0) out[k] = clean;
+  }
+  if (key === "tooltip") {
+    out["renderMode"] = "richText";
+    for (const k of HTML_TOOLTIP_KEYS) delete out[k];
+  }
+  if (key === "feature") for (const k of HTML_FEATURES) delete out[k];
+  return out;
+}
+function parseOption(source, open = false) {
+  try {
+    return JSON.parse(source);
+  } catch {
+  }
+  return open ? parsePrefix(source) : void 0;
+}
+function parsePrefix(source) {
+  const stack = [];
+  const cuts = [];
+  const cut = (at) => {
+    cuts.push({ at, closers: stack.slice().reverse().join("") });
+    if (cuts.length > 8) cuts.shift();
+  };
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") {
+      stack.push(ch === "{" ? "}" : "]");
+      cut(i + 1);
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      cut(i + 1);
+    } else if (ch === ",") cut(i);
+  }
+  for (let i = cuts.length - 1; i >= 0; i--) {
+    const { at, closers } = cuts[i];
+    try {
+      return JSON.parse(source.slice(0, at) + closers);
+    } catch {
+    }
+  }
+  return void 0;
+}
+const list = (v) => Array.isArray(v) ? v : v === void 0 ? [] : [v];
+function drawable(option) {
+  const has = (o) => {
+    if (!isObject$1(o)) return false;
+    const series = o["series"];
+    if (Array.isArray(series) ? series.some(isObject$1) : isObject$1(series)) return true;
+    return o["dataset"] !== void 0;
+  };
+  return has(option) || has(option["baseOption"]) || list(option["options"]).some(has);
+}
+function titleOf(option) {
+  const title = list(option["title"])[0];
+  const text = isObject$1(title) ? title["text"] : void 0;
+  return typeof text === "string" && text.trim() ? text.trim() : void 0;
+}
+function cell(v) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) return v.map(cell).join(", ");
+  if (isObject$1(v)) return cell(v["value"]);
+  return "";
+}
+function grid(width, height, headAt, cellAt) {
+  const columns = Math.min(width, MAX_COLUMNS);
+  if (columns <= 0) return null;
+  const rows = Math.max(0, Math.min(height, MAX_ROWS, Math.floor(MAX_CELLS / columns) - 1));
+  const table = {
+    head: Array.from({ length: columns }, (_, c) => headAt(c)),
+    rows: Array.from({ length: rows }, (_, r) => Array.from({ length: columns }, (_2, c) => cellAt(r, c)))
+  };
+  if (columns < width || rows < height) table.cut = true;
+  return table;
+}
+function headerRows(dataset, first) {
+  const option = dataset["sourceHeader"];
+  if (typeof option === "number") return Number.isFinite(option) && option > 0 ? Math.floor(option) : 0;
+  if (typeof option === "boolean") return option ? 1 : 0;
+  let rows;
+  for (const v of first.slice(0, 10)) {
+    if (v === null || v === void 0 || v === "-") continue;
+    if (typeof v === "string") rows ??= 1;
+    else rows = 0;
+  }
+  return rows ?? 0;
+}
+function tableOf(option) {
+  const dataset = list(option["dataset"])[0];
+  const source = isObject$1(dataset) ? dataset["source"] : void 0;
+  if (isObject$1(dataset) && Array.isArray(source) && source.length > 0) {
+    const named2 = Array.isArray(dataset["dimensions"]) ? dataset["dimensions"].map((d) => isObject$1(d) ? cell(d["name"]) : cell(d)) : void 0;
+    if (Array.isArray(source[0])) {
+      const skip = headerRows(dataset, source[0]);
+      const rows = source.slice(skip);
+      const head = named2 ?? (skip > 0 ? source[0].map(cell) : []);
+      const width = Math.max(head.length, ...rows.slice(0, MAX_ROWS).map((r) => list(r).length));
+      return grid(width, rows.length, (c) => head[c] ?? "", (r, c) => cell(list(rows[r])[c]));
+    }
+    if (isObject$1(source[0])) {
+      const dims = named2 ?? Object.keys(source[0]);
+      return grid(dims.length, source.length, (c) => dims[c], (r, c) => {
+        const row = source[r];
+        return cell(isObject$1(row) ? row[dims[c]] : void 0);
+      });
+    }
+  }
+  const series = list(option["series"]).map((s, i) => ({ s, i })).filter((e) => isObject$1(e.s) && Array.isArray(e.s["data"]) && e.s["data"].length > 0);
+  if (series.length === 0) return null;
+  const axis = [...list(option["xAxis"]), ...list(option["yAxis"])].find((a) => isObject$1(a) && Array.isArray(a["data"]));
+  const name = ({ s, i }) => cell(s["name"]) || `${i + 1}`;
+  const dataOf = (c) => series[c].s["data"];
+  if (axis) {
+    const categories = axis["data"];
+    return grid(
+      series.length + 1,
+      categories.length,
+      (c) => c === 0 ? cell(axis["name"]) : name(series[c - 1]),
+      (r, c) => cell(c === 0 ? categories[r] : dataOf(c - 1)[r])
+    );
+  }
+  const named = series.find(({ s }) => s["data"].some((d) => isObject$1(d) && "name" in d));
+  if (named) {
+    const data = named.s["data"];
+    return grid(2, data.length, (c) => c === 0 ? "" : name(named), (r, c) => {
+      const d = data[r];
+      return c === 0 ? cell(isObject$1(d) ? d["name"] : "") : cell(d);
+    });
+  }
+  return null;
+}
+const ECHARTS_SERIES_HUES = {
+  light: ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"],
+  dark: ["#3987e5", "#d95926", "#199e70", "#c98500", "#d55181", "#008300", "#9085e9", "#e66767"]
+};
+function rgbOf(color) {
+  const c = color.trim();
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})(?:[0-9a-f]{2})?$/i.exec(c)?.[1];
+  if (hex) {
+    const full = hex.length === 3 ? hex.split("").map((h) => h + h).join("") : hex;
+    return [0, 2, 4].map((i) => parseInt(full.slice(i, i + 2), 16));
+  }
+  const fn = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i.exec(c);
+  return fn ? [Number(fn[1]), Number(fn[2]), Number(fn[3])] : null;
+}
+function oklab([r, g, b]) {
+  const lin = (v) => {
+    const s2 = v / 255;
+    return s2 <= 0.04045 ? s2 / 12.92 : ((s2 + 0.055) / 1.055) ** 2.4;
+  };
+  const [lr, lg, lb] = [lin(r), lin(g), lin(b)];
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function isDark(color) {
+  const rgb = rgbOf(color);
+  return rgb ? oklab(rgb)[0] < 0.6 : false;
+}
+function echartsPalette(primary, dark = false) {
+  const ring = [...dark ? ECHARTS_SERIES_HUES.dark : ECHARTS_SERIES_HUES.light];
+  const rgb = rgbOf(primary);
+  if (!rgb) return [primary, ...ring];
+  const p = oklab(rgb);
+  const grey = Math.hypot(p[1], p[2]) < 0.04;
+  const hueOf = (c) => Math.atan2(c[2], c[1]);
+  const distance = (q) => {
+    if (grey) return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+    const d = Math.abs(hueOf(p) - hueOf(q));
+    return Math.min(d, 2 * Math.PI - d);
+  };
+  let nearest = 0;
+  let best = Infinity;
+  ring.forEach((hue, i) => {
+    const d = distance(oklab(rgbOf(hue)));
+    if (d < best) {
+      best = d;
+      nearest = i;
+    }
+  });
+  return [primary, ...ring.slice(nearest + 1), ...ring.slice(0, nearest)];
+}
+function echartsTheme(tokens) {
+  const { text, muted, border, surface, background } = tokens;
+  const dark = tokens.dark ?? isDark(background);
+  const font = tokens.fontFamily && SAFE_FONT.test(tokens.fontFamily) ? { fontFamily: tokens.fontFamily } : {};
+  const axis = (splitLine) => ({
+    axisLine: { lineStyle: { color: border } },
+    axisTick: { lineStyle: { color: border } },
+    axisLabel: { color: muted },
+    nameTextStyle: { color: muted },
+    splitLine: { show: splitLine, lineStyle: { color: border } },
+    minorSplitLine: { lineStyle: { color: border } },
+    splitArea: { areaStyle: { color: ["transparent", surface] } }
+  });
+  return {
+    darkMode: dark,
+    color: echartsPalette(tokens.primary, dark),
+    backgroundColor: "transparent",
+    textStyle: { color: text, ...font },
+    title: { textStyle: { color: text }, subtextStyle: { color: muted } },
+    legend: {
+      textStyle: { color: text },
+      pageTextStyle: { color: muted },
+      pageIconColor: text,
+      pageIconInactiveColor: border,
+      inactiveColor: border
+    },
+    tooltip: { backgroundColor: surface, borderColor: border, textStyle: { color: text } },
+    axisPointer: {
+      lineStyle: { color: muted },
+      crossStyle: { color: muted },
+      label: { color: surface, backgroundColor: muted }
+    },
+    // A category axis draws no grid by default, in ECharts as here.
+    categoryAxis: axis(false),
+    valueAxis: axis(true),
+    logAxis: axis(true),
+    timeAxis: axis(true),
+    radar: {
+      axisName: { color: muted },
+      axisLine: { lineStyle: { color: border } },
+      splitLine: { lineStyle: { color: border } },
+      splitArea: { areaStyle: { color: ["transparent", surface] } }
+    },
+    dataZoom: {
+      borderColor: border,
+      textStyle: { color: muted },
+      handleStyle: { color: surface, borderColor: muted },
+      moveHandleStyle: { color: muted },
+      dataBackground: { lineStyle: { color: muted }, areaStyle: { color: border } }
+    },
+    visualMap: { textStyle: { color: text } },
+    timeline: {
+      lineStyle: { color: border },
+      label: { color: muted },
+      controlStyle: { color: muted, borderColor: muted }
+    },
+    toolbox: { iconStyle: { borderColor: muted } },
+    calendar: {
+      itemStyle: { color: "transparent", borderColor: border },
+      splitLine: { lineStyle: { color: muted } },
+      dayLabel: { color: muted },
+      monthLabel: { color: muted },
+      yearLabel: { color: text }
+    },
+    gauge: { title: { color: muted }, detail: { color: text }, axisLabel: { color: muted } },
+    // The gap between two slices is the ground showing through.
+    pie: { itemStyle: { borderColor: background } },
+    funnel: { itemStyle: { borderColor: background } },
+    sunburst: { itemStyle: { borderColor: background } },
+    map: { label: { color: text }, itemStyle: { areaColor: surface, borderColor: border } },
+    geo: { label: { color: text }, itemStyle: { areaColor: surface, borderColor: border } }
+  };
+}
+const TOKENS = {
+  text: ["--aparte-text", "#1a1a1a"],
+  muted: ["--aparte-text-muted", "#666666"],
+  border: ["--aparte-border", "#d0d0d0"],
+  surface: ["--aparte-surface-1", "#fafafa"],
+  background: ["--aparte-bg", "#ffffff"],
+  primary: ["--aparte-primary", "#3b5bdb"]
+};
+function readTokens(el) {
+  const style = getComputedStyle(el);
+  const probe = document.createElement("span");
+  probe.style.display = "none";
+  el.appendChild(probe);
+  const canvas = document.createElement("canvas");
+  canvas.width = canvas.height = 1;
+  const paint = canvas.getContext?.("2d", { willReadFrequently: true }) ?? null;
+  const read = (token, fallback) => {
+    probe.style.color = `var(${token}, ${fallback})`;
+    const computed = getComputedStyle(probe).color || fallback;
+    if (!paint) return computed;
+    paint.clearRect(0, 0, 1, 1);
+    paint.fillStyle = "#000";
+    paint.fillStyle = computed;
+    paint.fillRect(0, 0, 1, 1);
+    const [r, g, b, a] = paint.getImageData(0, 0, 1, 1).data;
+    return a === 255 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${((a ?? 0) / 255).toFixed(3)})`;
+  };
+  try {
+    const tokens = Object.fromEntries(
+      Object.entries(TOKENS).map(([name, [token, fallback]]) => [name, read(token, fallback)])
+    );
+    const font = style.getPropertyValue("--aparte-font-family").trim() || style.fontFamily;
+    if (font) tokens.fontFamily = font;
+    return tokens;
+  } finally {
+    probe.remove();
+  }
+}
+const WORDS = {
+  echartsChart: {
+    en: "Chart",
+    fr: "Graphique",
+    de: "Diagramm",
+    es: "Gráfico",
+    it: "Grafico",
+    ja: "グラフ",
+    ko: "차트",
+    pt: "Gráfico",
+    ru: "Диаграмма",
+    zh: "图表"
+  },
+  echartsError: {
+    en: "This chart could not be drawn.",
+    fr: "Ce graphique n’a pas pu être dessiné.",
+    de: "Dieses Diagramm konnte nicht gezeichnet werden.",
+    es: "No se pudo dibujar este gráfico.",
+    it: "Impossibile disegnare questo grafico.",
+    ja: "このグラフを描画できませんでした。",
+    ko: "이 차트를 그릴 수 없습니다.",
+    pt: "Não foi possível desenhar este gráfico.",
+    ru: "Не удалось построить эту диаграмму.",
+    zh: "无法绘制此图表。"
+  },
+  echartsLoading: {
+    en: "Loading chart",
+    fr: "Chargement du graphique",
+    de: "Diagramm wird geladen",
+    es: "Cargando gráfico",
+    it: "Caricamento del grafico",
+    ja: "グラフを読み込み中",
+    ko: "차트 불러오는 중",
+    pt: "Carregando gráfico",
+    ru: "Загрузка диаграммы",
+    zh: "正在加载图表"
+  },
+  echartsWaiting: {
+    en: "Waiting for your approval",
+    fr: "En attente de votre accord",
+    de: "Wartet auf Ihre Zustimmung",
+    es: "Esperando tu aprobación",
+    it: "In attesa della tua approvazione",
+    ja: "承認を待っています",
+    ko: "승인을 기다리는 중",
+    pt: "Aguardando sua aprovação",
+    ru: "Ожидает вашего подтверждения",
+    zh: "等待您的批准"
+  },
+  echartsNotRun: {
+    en: "No chart: the tool did not run.",
+    fr: "Pas de graphique : l’outil n’a pas été exécuté.",
+    de: "Kein Diagramm: Das Werkzeug wurde nicht ausgeführt.",
+    es: "Sin gráfico: la herramienta no se ejecutó.",
+    it: "Nessun grafico: lo strumento non è stato eseguito.",
+    ja: "グラフなし：ツールは実行されませんでした。",
+    ko: "차트 없음: 도구가 실행되지 않았습니다.",
+    pt: "Sem gráfico: a ferramenta não foi executada.",
+    ru: "Нет диаграммы: инструмент не был запущен.",
+    zh: "无图表：工具未运行。"
+  },
+  echartsFailed: {
+    en: "No chart: the tool failed.",
+    fr: "Pas de graphique : l’outil a échoué.",
+    de: "Kein Diagramm: Das Werkzeug ist fehlgeschlagen.",
+    es: "Sin gráfico: la herramienta falló.",
+    it: "Nessun grafico: lo strumento non è riuscito.",
+    ja: "グラフなし：ツールが失敗しました。",
+    ko: "차트 없음: 도구가 실패했습니다.",
+    pt: "Sem gráfico: a ferramenta falhou.",
+    ru: "Нет диаграммы: инструмент завершился с ошибкой.",
+    zh: "无图表：工具运行失败。"
+  },
+  echartsTableCut: {
+    en: "Only part of the data is listed.",
+    fr: "Seule une partie des données est listée.",
+    de: "Nur ein Teil der Daten ist aufgeführt.",
+    es: "Solo se muestra una parte de los datos.",
+    it: "È elencata solo una parte dei dati.",
+    ja: "データの一部のみを表示しています。",
+    ko: "데이터의 일부만 표시됩니다.",
+    pt: "Apenas parte dos dados está listada.",
+    ru: "Показана только часть данных.",
+    zh: "仅列出部分数据。"
+  }
+};
+function languageOf(config) {
+  const tag = config.getLocale().tag;
+  return typeof tag === "string" && tag ? tag.split("-")[0].toLowerCase() : "en";
+}
+function word(config, key) {
+  const fromApp = config.getLocale()[key];
+  if (typeof fromApp === "string" && fromApp) return fromApp;
+  const table = WORDS[key];
+  return table[languageOf(config)] ?? table.en;
+}
+const LANGUAGES = ["echarts", "echart"];
+const TAG = "aparte-echarts";
+const DEFAULT_HEIGHT = "18rem";
+const MAX_WIDTH = "40rem";
+const PROGRESSIVE_MS = 300;
+const LINGER_MS = 1e3;
+const ID_PREFIX = `aparte-echarts-${Math.random().toString(36).slice(2, 8)}`;
+let setups = 0;
+let streamIds = 0;
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const REGISTRY = Symbol.for("aparte.plugin-echarts.setups");
+function registry() {
+  const scope = globalThis;
+  return scope[REGISTRY] ??= /* @__PURE__ */ new Map();
+}
+function defineElement() {
+  if (typeof customElements === "undefined" || typeof HTMLElement === "undefined" || customElements.get(TAG)) return;
+  customElements.define(TAG, class extends HTMLElement {
+    connectedCallback() {
+      registry().get(this.getAttribute("data-aparte-echarts") ?? "")?.connected(this);
+    }
+    disconnectedCallback() {
+      registry().get(this.getAttribute("data-aparte-echarts") ?? "")?.disconnected(this);
+    }
+  });
+}
+function setupEChartsWith(echarts, options = {}, config = aparteGlobalConfig) {
+  const load = typeof echarts === "function" ? echarts : () => Promise.resolve(echarts);
+  defineElement();
+  const id = `${ID_PREFIX}-${++setups}`;
+  const charts = createCharts(load, options, config);
+  registry().set(id, charts);
+  const unregister = config.registerCodeLanguageRenderer(createFenceRenderer(id, options, charts));
+  const matchers = options.tool === void 0 ? [] : Array.isArray(options.tool) ? options.tool : [options.tool];
+  const tool = createToolRenderer(id, options, config, charts);
+  for (const match of matchers) config.registerToolRenderer(match, tool);
+  return () => {
+    for (const match of matchers) config.unregisterToolRenderer(match);
+    unregister();
+    charts.stop();
+    registry().delete(id);
+  };
+}
+function cssLength(height) {
+  if (typeof height === "number" && height > 0) return `${height}px`;
+  if (typeof height === "string" && /^\d+(\.\d+)?(px|rem|em|vh|svh|dvh|lh|%)$/.test(height.trim())) return height.trim();
+  return DEFAULT_HEIGHT;
+}
+function prefersReducedMotion() {
+  return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function skeleton(height) {
+  const box = document.createElement("span");
+  box.className = "aparte-skeleton aparte-skeleton--rect";
+  box.setAttribute("aria-hidden", "true");
+  box.style.setProperty("block-size", height);
+  box.style.setProperty("max-inline-size", MAX_WIDTH);
+  return box;
+}
+function note(config, key, className = "aparte-echarts-note") {
+  const p = document.createElement("p");
+  p.className = className;
+  p.setAttribute("role", "note");
+  p.setAttribute("data-aparte-echarts-word", key);
+  p.textContent = word(config, key);
+  return p;
+}
+function relabelWords(root, config) {
+  for (const el of Array.from(root.querySelectorAll("[data-aparte-echarts-word]"))) {
+    el.textContent = word(config, el.getAttribute("data-aparte-echarts-word"));
+  }
+}
+function finalOption(option, width = 0) {
+  const decal = isObject(option["aria"]) && isObject(option["aria"]["decal"]) ? { decal: option["aria"]["decal"] } : {};
+  const out = { ...option, aria: { enabled: true, label: { enabled: true }, ...decal } };
+  const title = fittedTitles(option, width);
+  if (title !== void 0) out["title"] = title;
+  return prefersReducedMotion() ? motionless(out) : out;
+}
+function fittedTitles(option, width) {
+  const titles = option["title"];
+  if (width <= 0 || titles === void 0) return void 0;
+  const fit = (t) => {
+    if (!isObject(t)) return t;
+    const style = isObject(t["textStyle"]) ? t["textStyle"] : {};
+    if (style["width"] !== void 0) return t;
+    return { ...t, textStyle: { ...style, width: Math.max(60, width - 32), overflow: "truncate" } };
+  };
+  return Array.isArray(titles) ? titles.map(fit) : fit(titles);
+}
+function motionless(option) {
+  const still = (o) => {
+    if (!isObject(o)) return o;
+    const out2 = { ...o, animation: false };
+    const series = (s) => {
+      if (!isObject(s)) return s;
+      const next = { ...s, animation: false };
+      if (s["type"] === "effectScatter") next["showEffectOn"] = "emphasis";
+      if (isObject(s["effect"])) next["effect"] = { ...s["effect"], show: false };
+      return next;
+    };
+    const each = (v, f) => Array.isArray(v) ? v.map(f) : f(v);
+    if (o["series"] !== void 0) out2["series"] = each(o["series"], series);
+    if (o["graphic"] !== void 0) out2["graphic"] = each(o["graphic"], (g) => isObject(g) ? { ...g, animation: false } : g);
+    if (o["timeline"] !== void 0) out2["timeline"] = each(o["timeline"], (t) => isObject(t) ? { ...t, autoPlay: false } : t);
+    return out2;
+  };
+  const out = still(option);
+  if (isObject(option["baseOption"])) out["baseOption"] = still(option["baseOption"]);
+  if (Array.isArray(option["options"])) out["options"] = option["options"].map(still);
+  if (Array.isArray(option["media"])) {
+    out["media"] = option["media"].map((m) => isObject(m) && isObject(m["option"]) ? { ...m, option: still(m["option"]) } : m);
+  }
+  return out;
+}
+function tableElement(option, name, config) {
+  const data = tableOf(option);
+  if (!data) return null;
+  const table = document.createElement("table");
+  table.className = "aparte-sr-only aparte-echarts-table";
+  const caption = table.createCaption();
+  caption.textContent = name;
+  const headRow = table.createTHead().insertRow();
+  for (const text of data.head) {
+    const th = document.createElement("th");
+    th.scope = "col";
+    th.textContent = text;
+    headRow.append(th);
+  }
+  if (data.cut) {
+    const cell2 = table.createTFoot().insertRow().insertCell();
+    cell2.colSpan = data.head.length;
+    cell2.setAttribute("data-aparte-echarts-word", "echartsTableCut");
+    cell2.textContent = word(config, "echartsTableCut");
+  }
+  const body = table.createTBody();
+  for (const row of data.rows) {
+    const tr = body.insertRow();
+    row.forEach((text, i) => {
+      const cell2 = document.createElement(i === 0 ? "th" : "td");
+      if (i === 0) cell2.scope = "row";
+      cell2.textContent = text;
+      tr.append(cell2);
+    });
+  }
+  return table;
+}
+function createCharts(load, options, config) {
+  const height = cssLength(options.height);
+  let library;
+  const libraryOf = () => library ??= load().catch((error) => {
+    library = void 0;
+    throw error;
+  });
+  const states = /* @__PURE__ */ new WeakMap();
+  const all = /* @__PURE__ */ new Set();
+  const live = /* @__PURE__ */ new Set();
+  const streams = /* @__PURE__ */ new Map();
+  const configs = /* @__PURE__ */ new WeakMap();
+  const roots = /* @__PURE__ */ new WeakSet();
+  let warned = false;
+  const warnOnce = (error) => {
+    if (warned) return;
+    warned = true;
+    console.warn("[aparte-echarts] a chart could not be drawn; a note is shown instead.", error);
+  };
+  const configOf = (el) => configs.get(el) ?? config;
+  const nameOf = (c) => titleOf(c.option) ?? word(configOf(c.el), "echartsChart");
+  const themeAt = (el) => {
+    const tokens = readTokens(el);
+    return { theme: echartsTheme(tokens), key: JSON.stringify(tokens) };
+  };
+  const retheme = (c) => {
+    if (!c.instance || !c.el.isConnected) return;
+    const { theme, key } = themeAt(c.el);
+    if (key === c.colours) return;
+    c.colours = key;
+    c.instance.setTheme(theme);
+  };
+  const watch = watchTheme(() => {
+    for (const c of live) retheme(c);
+  });
+  const destroy = (c) => {
+    c.dead = true;
+    clearTimeout(c.linger);
+    c.observer?.disconnect();
+    c.instance?.dispose();
+    c.instance = null;
+    live.delete(c);
+    all.delete(c);
+    if (states.get(c.el) === c) states.delete(c.el);
+    const stream = c.el.getAttribute("data-aparte-echarts-stream");
+    if (stream && streams.get(stream) === c.el) streams.delete(stream);
+  };
+  const fail = (c, error) => {
+    warnOnce(error);
+    destroy(c);
+    c.el.replaceChildren(note(configOf(c.el), "echartsError", "aparte-code-error"));
+  };
+  const apply = (c, option, fresh) => {
+    c.option = option;
+    const name = nameOf(c);
+    c.el.setAttribute("aria-label", name);
+    c.table?.remove();
+    c.table = tableElement(option, name, configOf(c.el));
+    if (c.table) c.el.append(c.table);
+    if (!c.instance) return;
+    try {
+      c.instance.setOption(finalOption(option, c.box.clientWidth), fresh ? { notMerge: true } : void 0);
+    } catch (error) {
+      fail(c, error);
+    }
+  };
+  const watchRoot = (el) => {
+    const root = el.getRootNode();
+    if (typeof ShadowRoot === "undefined" || !(root instanceof ShadowRoot) || roots.has(root)) return;
+    roots.add(root);
+    watch.add(root);
+  };
+  const mount = (el, option) => {
+    const box = document.createElement("div");
+    box.className = "aparte-echarts-chart";
+    box.style.setProperty("block-size", height);
+    box.style.setProperty("inline-size", "100%");
+    const waiting = skeleton("100%");
+    box.append(waiting);
+    el.replaceChildren(box);
+    const c = { el, box, table: null, instance: null, option, colours: "", observer: void 0, linger: void 0, dead: false };
+    states.set(el, c);
+    all.add(c);
+    live.add(c);
+    apply(c, option, true);
+    libraryOf().then((lib) => {
+      if (c.dead) return;
+      const { theme, key } = themeAt(c.el);
+      c.colours = key;
+      waiting.remove();
+      c.instance = lib.init(box, theme, {
+        renderer: options.renderer ?? "svg",
+        // ECharts' own description (aria) in the chat's language, when that language
+        // is registered with ECharts; English otherwise.
+        locale: languageOf(configOf(c.el)).toUpperCase()
+      });
+      if (typeof ResizeObserver !== "undefined") {
+        c.observer = new ResizeObserver(() => {
+          if (!c.instance) return;
+          try {
+            c.instance.resize();
+            const title = fittedTitles(c.option, c.box.clientWidth);
+            if (title !== void 0) c.instance.setOption({ title });
+          } catch (error) {
+            fail(c, error);
+          }
+        });
+        c.observer.observe(box);
+      }
+      apply(c, c.option, true);
+    }).catch((error) => {
+      if (!c.dead) fail(c, error);
+    });
+  };
+  return {
+    connected(el) {
+      el.style.setProperty("display", "block");
+      el.style.setProperty("inline-size", "100%");
+      el.style.setProperty("max-inline-size", MAX_WIDTH);
+      el.setAttribute("role", "figure");
+      watchRoot(el);
+      const kept = states.get(el);
+      if (kept) {
+        clearTimeout(kept.linger);
+        kept.linger = void 0;
+        live.add(kept);
+        return;
+      }
+      const option = sanitizeEChartsOption(parseOption(el.getAttribute("data-aparte-echarts-option") ?? ""));
+      if (!option) {
+        el.replaceChildren(note(configOf(el), "echartsError", "aparte-code-error"));
+        return;
+      }
+      const stream = el.getAttribute("data-aparte-echarts-stream");
+      const before = stream ? streams.get(stream) : void 0;
+      if (stream) streams.set(stream, el);
+      const adopted = before && before !== el && !before.isConnected ? states.get(before) : void 0;
+      if (adopted && !adopted.dead) {
+        clearTimeout(adopted.linger);
+        adopted.linger = void 0;
+        states.delete(adopted.el);
+        adopted.el = el;
+        states.set(el, adopted);
+        live.add(adopted);
+        el.replaceChildren(adopted.box);
+        apply(adopted, option, false);
+        return;
+      }
+      mount(el, option);
+    },
+    disconnected(el) {
+      const c = states.get(el);
+      if (!c) return;
+      live.delete(c);
+      clearTimeout(c.linger);
+      c.linger = setTimeout(() => {
+        if (c.el === el && !el.isConnected) destroy(c);
+      }, LINGER_MS);
+    },
+    /** The element is gone for good (a tool row's cleanup): no linger. */
+    dispose(el) {
+      const c = states.get(el);
+      if (c) destroy(c);
+    },
+    /** Name a chart in the locale of `cfg`, and keep that config for its later words. */
+    label(el, cfg) {
+      configs.set(el, cfg);
+      const c = states.get(el);
+      const name = c ? nameOf(c) : word(cfg, "echartsChart");
+      el.setAttribute("aria-label", name);
+      const caption = el.querySelector("caption");
+      if (caption) caption.textContent = name;
+      relabelWords(el, cfg);
+    },
+    stop() {
+      watch.stop();
+      for (const c of [...all]) destroy(c);
+    }
+  };
+}
+function createFenceRenderer(setupId, options, charts) {
+  const progressive = options.progressive !== false;
+  const height = cssLength(options.height);
+  const parts = /* @__PURE__ */ new WeakMap();
+  const arrivingOf = (host) => {
+    const part = host.closest("[data-segment-id]") ?? host.closest("pre")?.parentElement ?? host.parentElement ?? host;
+    const fences = Array.from(part.querySelectorAll(LANGUAGES.map((l) => `code.language-${l}`).join(", ")));
+    const rank = Math.max(0, fences.indexOf(host));
+    let byRank = parts.get(part);
+    if (!byRank) {
+      byRank = /* @__PURE__ */ new Map();
+      parts.set(part, byRank);
+    }
+    let state = byRank.get(rank);
+    if (!state) {
+      state = { id: `${setupId}-s${++streamIds}`, waiting: null, timer: void 0, at: 0, started: null, drawn: null };
+      byRank.set(rank, state);
+    }
+    return state;
+  };
+  const markup = (json, stream) => `<aparte-echarts class="aparte-echarts" data-aparte-echarts="${escapeAttr(setupId)}" data-aparte-echarts-stream="${escapeAttr(stream)}" data-aparte-echarts-option="${escapeAttr(json)}"></aparte-echarts>`;
+  const PENDING = '<span class="aparte-skeleton aparte-skeleton--rect aparte-echarts-pending" aria-hidden="true"></span>';
+  const FAILED = '<span class="aparte-code-error" role="note" data-aparte-echarts-error></span><pre class="aparte-code-error" data-aparte-echarts-source></pre>';
+  const schedule = (state) => {
+    if (state.timer !== void 0 || !state.waiting) return;
+    const wait = Math.max(0, state.at + PROGRESSIVE_MS - performance.now());
+    state.timer = setTimeout(() => {
+      state.timer = void 0;
+      const job = state.waiting;
+      state.waiting = null;
+      if (!job) return;
+      state.at = performance.now();
+      const option = sanitizeEChartsOption(parseOption(job.source, true));
+      const json = option && drawable(option) ? JSON.stringify(option) : null;
+      if (json === null || json === state.drawn) {
+        job.answer(null);
+        return;
+      }
+      state.drawn = json;
+      job.answer(markup(json, state.id));
+    }, wait);
+  };
+  return {
+    languages: LANGUAGES,
+    lazy: true,
+    render(ctx) {
+      if (!ctx.display) return null;
+      const state = arrivingOf(ctx.host);
+      state.waiting?.answer(null);
+      state.waiting = null;
+      if (!ctx.open) {
+        state.started = null;
+        state.drawn = null;
+        const option = sanitizeEChartsOption(parseOption(ctx.source));
+        return option && drawable(option) ? markup(JSON.stringify(option), state.id) : FAILED;
+      }
+      if (!progressive) return null;
+      if (state.started === null || !ctx.source.startsWith(state.started)) {
+        state.started = ctx.source;
+        state.drawn = null;
+        return PENDING;
+      }
+      return new Promise((answer) => {
+        state.waiting = { source: ctx.source, answer };
+        schedule(state);
+      });
+    },
+    relabel(drawing, ctx) {
+      const error = drawing.querySelector("[data-aparte-echarts-error]");
+      if (error) error.textContent = word(ctx.config, "echartsError");
+      const source = drawing.querySelector("[data-aparte-echarts-source]");
+      if (source) source.textContent = ctx.source;
+      for (const box of Array.from(drawing.querySelectorAll(".aparte-echarts-pending"))) {
+        box.style.setProperty("block-size", height);
+        box.style.setProperty("max-inline-size", MAX_WIDTH);
+      }
+      for (const el of Array.from(drawing.querySelectorAll(TAG))) charts.label(el, ctx.config);
+    }
+  };
+}
+function createToolRenderer(setupId, options, config, charts) {
+  const height = cssLength(options.height);
+  const shown = /* @__PURE__ */ new WeakMap();
+  let warned = false;
+  const optionOf = (segment) => {
+    let raw = segment.structuredResult;
+    if (raw === void 0 && typeof segment.result === "string") raw = parseOption(segment.result.trim()) ?? segment.result;
+    const input = isObject(segment.toolCall?.input) ? segment.toolCall.input : {};
+    try {
+      if (options.map) raw = options.map(raw, input);
+    } catch (error) {
+      if (!warned) {
+        warned = true;
+        console.warn(`[aparte-echarts] the \`map\` for tool "${segment.toolCall?.name}" threw:`, error);
+      }
+      return null;
+    }
+    const option = sanitizeEChartsOption(raw);
+    return option && drawable(option) ? option : null;
+  };
+  const chartOf = (option) => {
+    const el = document.createElement(TAG);
+    el.className = "aparte-echarts";
+    el.setAttribute("data-aparte-echarts", setupId);
+    el.setAttribute("data-aparte-echarts-option", JSON.stringify(option));
+    return el;
+  };
+  const fill = (root, segment) => {
+    let structured = "";
+    try {
+      structured = JSON.stringify(segment.structuredResult) ?? "";
+    } catch {
+    }
+    const signature = `${segment.status}
${segment.result ?? ""}
${structured}`;
+    if (shown.get(root) === signature) return;
+    shown.set(root, signature);
+    for (const el of Array.from(root.querySelectorAll(TAG))) charts.dispose(el);
+    root.removeAttribute("aria-busy");
+    root.removeAttribute("aria-label");
+    root.removeAttribute("data-aparte-echarts-label");
+    switch (segment.status) {
+      case "pending":
+        root.setAttribute("aria-busy", "true");
+        root.setAttribute("data-aparte-echarts-label", "echartsLoading");
+        root.setAttribute("aria-label", word(config, "echartsLoading"));
+        root.replaceChildren(skeleton(height));
+        return;
+      case "resolved": {
+        const option = optionOf(segment);
+        root.replaceChildren(option ? chartOf(option) : note(config, "echartsError"));
+        return;
+      }
+      case "awaiting-approval":
+        root.replaceChildren(note(config, "echartsWaiting"));
+        return;
+      case "rejected":
+      case "aborted":
+        root.replaceChildren(note(config, "echartsNotRun"));
+        return;
+      default:
+        root.replaceChildren(note(config, "echartsFailed"));
+    }
+  };
+  return {
+    render(segment) {
+      const root = document.createElement("div");
+      root.className = "aparte-echarts-tool";
+      fill(root, segment);
+      return root;
+    },
+    // Same element, new inside only when the call changed: a chart the reader is
+    // looking at is not drawn again because an approval or a relabel passed by.
+    update: (root, segment) => fill(root, segment),
+    relabel(root) {
+      const key = root.getAttribute("data-aparte-echarts-label");
+      if (key) root.setAttribute("aria-label", word(config, key));
+      relabelWords(root, config);
+      for (const el of Array.from(root.querySelectorAll(TAG))) charts.label(el, config);
+    },
+    cleanup(root) {
+      for (const el of Array.from(root.querySelectorAll(TAG))) charts.dispose(el);
+    }
+  };
+}
+function watchTheme(changed) {
+  if (typeof MutationObserver === "undefined" || typeof document === "undefined") return { add: () => {
+  }, stop: () => {
+  } };
+  const observer = new MutationObserver(changed);
+  const init = { attributes: true, subtree: true, attributeFilter: ["data-aparte-theme"] };
+  observer.observe(document.documentElement, init);
+  const media = typeof matchMedia === "function" ? matchMedia("(prefers-color-scheme: dark)") : null;
+  media?.addEventListener?.("change", changed);
+  return {
+    add: (root) => observer.observe(root, init),
+    stop: () => {
+      observer.disconnect();
+      media?.removeEventListener?.("change", changed);
+    }
+  };
+}
+export {
+  ECHARTS_SERIES_HUES,
+  echartsPalette,
+  echartsTheme,
+  sanitizeEChartsOption,
+  setupEChartsWith
+};
+//# sourceMappingURL=core.js.map