@bicharts/chart-host 0.6.75 → 0.6.77

package/dist/chunk-IMNZYSIC.mjs

@@ -0,0 +1,3806 @@
+/*! @bicharts/chart-host — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; Natural Earth and US Census/TIGER (public domain). Full text: NOTICE in this package. */
+import {
+  Fn,
+  J3,
+  Xn,
+  Yn,
+  ge
+} from "./chunk-H2P63UMG.mjs";
+import {
+  NA_ISO3,
+  NA_LAT_MAX,
+  clipFeatureToLat
+} from "./chunk-A2GMXZP7.mjs";
+import {
+  ACTIVE_TICK_CLASS,
+  ANIM_LOOP_DELAY_DEFAULT,
+  ANIM_LOOP_DELAY_MIN,
+  ANIM_MAX_IDEAL_FRAMES_DEFAULT,
+  ANIM_MAX_IDEAL_FRAMES_MAX,
+  ANIM_MAX_IDEAL_FRAMES_MIN,
+  ANIM_PLAY_SPEED_DEFAULT,
+  ANIM_PLAY_SPEED_MAX,
+  ANIM_PLAY_SPEED_MIN,
+  APPROXIMATE_POSITIONS_DEFAULT,
+  AXIS_FILTER_CLASS,
+  COLOR_SCALE_SELF_CLAMP_PCT_DEFAULT,
+  COLOR_SCALE_SELF_CLAMP_PCT_MAX,
+  COLOR_SCALE_SELF_CLAMP_PCT_MIN,
+  CONTAINER_SLOT_ANIM_STOP,
+  CONTAINER_SLOT_CLICKED_MARKS,
+  CONTAINER_SLOT_INITIAL_XF_MARK,
+  CONTAINER_SLOT_UI_STATE,
+  CONTAINER_SLOT_XF_CLEAR,
+  CONTROL_CLASS,
+  DIM_OPACITY_DEFAULT,
+  DIM_OPACITY_VAR,
+  FLIP_DIRECTION_DEFAULT,
+  FLIP_MODE_DEFAULT,
+  HOST_CONTAINER_CLASS,
+  HOST_CONTRACT_VERSION,
+  LEGEND_MARK_CLASS,
+  LIFT_SELECTED_CLASS,
+  MARK_CLASS,
+  MARK_KEY_ATTR,
+  MARK_SELECTED_CLASS,
+  MAX_MAP_POINTS_DEFAULT,
+  NO_ROW_MARKS_ATTR,
+  ROW_IDX_ATTR,
+  SEASONAL_MARKERS_DEFAULT,
+  SELECTION_ACTIVE_CLASS,
+  SELECTION_RULE_ATTR,
+  SELECTION_RULE_CLICKED_MARKS,
+  SNAPSHOT_SVG_ATTR,
+  VALUE_AXIS_BASELINE_DEFAULT,
+  XFILTER_REFRESH_EVENT,
+  chartOwnsTimeline,
+  periodTickSuppressesFeedback
+} from "./chunk-7JWL6LYE.mjs";
+
+// src/labelContrast.ts
+function parseRGBA(c) {
+  if (typeof c !== "string") return null;
+  const s = c.trim();
+  const m = s.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/i);
+  if (m) return [parseFloat(m[1]), parseFloat(m[2]), parseFloat(m[3]), m[4] !== void 0 ? parseFloat(m[4]) : 1];
+  let h = s.replace(/^#/, "");
+  if (h.length === 3) h = h.split("").map((ch) => ch + ch).join("");
+  if (h.length === 6 && /^[0-9a-fA-F]{6}$/.test(h)) {
+    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16), 1];
+  }
+  return null;
+}
+var DARK_TEXT = "#111111";
+var LIGHT_TEXT = "#ffffff";
+var MIN_CONTRAST = 3;
+var WHITE_TEXT_BG_LUM = 0.5;
+var PILL_MIN_ALPHA = 0.05;
+var PILL_OPAQUE_ALPHA = 0.85;
+var PAGE_MATCH_TOLERANCE = 2;
+function isPillBackdropAlpha(a) {
+  return a >= PILL_MIN_ALPHA && a < PILL_OPAQUE_ALPHA;
+}
+var PILL_MIN_COVERAGE = 0.6;
+function pillBacksGlyph(overlapArea, glyphArea) {
+  if (!(glyphArea > 0) || !isFinite(overlapArea) || overlapArea <= 0) return false;
+  return overlapArea / glyphArea >= PILL_MIN_COVERAGE;
+}
+var BACKING_MAJORITY = 0.5;
+function backingHoldsGlyph(backedArea, glyphArea) {
+  if (!(glyphArea > 0) || !isFinite(backedArea) || backedArea <= 0) return false;
+  return backedArea / glyphArea >= BACKING_MAJORITY;
+}
+function cellSuppressesNormalize(cellClass) {
+  return typeof cellClass === "string" && /(^|\s)lch-deck-panel(\s|$)/.test(cellClass);
+}
+var NAMED = {
+  white: [255, 255, 255, 1],
+  black: [0, 0, 0, 1],
+  none: [0, 0, 0, 0],
+  transparent: [0, 0, 0, 0]
+};
+function toRGBA(c) {
+  if (typeof c !== "string") return null;
+  const k = c.trim().toLowerCase();
+  if (k in NAMED) return NAMED[k];
+  return parseRGBA(c);
+}
+function compositeOver(fg, bg) {
+  const a = Math.max(0, Math.min(1, fg[3]));
+  return [
+    Math.round(fg[0] * a + bg[0] * (1 - a)),
+    Math.round(fg[1] * a + bg[1] * (1 - a)),
+    Math.round(fg[2] * a + bg[2] * (1 - a))
+  ];
+}
+function relativeLuminance(rgb) {
+  const lin = rgb.map((v) => {
+    const s = v / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
+}
+function contrastRatio(l1, l2) {
+  const hi = Math.max(l1, l2);
+  const lo = Math.min(l1, l2);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function decideLabelColor(textColor, fill, fillOpacity, pageBg, minContrast = MIN_CONTRAST, normalize = false) {
+  const fillRGBA = toRGBA(fill);
+  if (!fillRGBA) return { fix: false, color: "", reason: "fill-unparsed" };
+  const pageRGBA = toRGBA(pageBg) || [255, 255, 255, 1];
+  const pageRGB = [pageRGBA[0], pageRGBA[1], pageRGBA[2]];
+  const effFill = [fillRGBA[0], fillRGBA[1], fillRGBA[2], fillRGBA[3] * clamp01(fillOpacity)];
+  const bgRGB = compositeOver(effFill, pageRGB);
+  const bgLum = relativeLuminance(bgRGB);
+  const bgIsPage = Math.abs(bgRGB[0] - pageRGB[0]) <= PAGE_MATCH_TOLERANCE && Math.abs(bgRGB[1] - pageRGB[1]) <= PAGE_MATCH_TOLERANCE && Math.abs(bgRGB[2] - pageRGB[2]) <= PAGE_MATCH_TOLERANCE;
+  const effNormalize = normalize && !bgIsPage;
+  const textRGBA = toRGBA(textColor);
+  if (!effNormalize && textRGBA) {
+    const txtRGB = compositeOver(textRGBA, bgRGB);
+    const cur = contrastRatio(relativeLuminance(txtRGB), bgLum);
+    if (cur >= minContrast) return { fix: false, color: "", reason: "ok" };
+  }
+  const darkC = contrastRatio(relativeLuminance(hexToRGB(DARK_TEXT)), bgLum);
+  const lightC = contrastRatio(relativeLuminance(hexToRGB(LIGHT_TEXT)), bgLum);
+  let useLight = bgLum <= WHITE_TEXT_BG_LUM;
+  if (useLight && lightC < minContrast && darkC >= minContrast) useLight = false;
+  if (!useLight && darkC < minContrast && lightC >= minContrast) useLight = true;
+  return useLight ? { fix: true, color: LIGHT_TEXT, reason: "fixed-light" } : { fix: true, color: DARK_TEXT, reason: "fixed-dark" };
+}
+var GLYPH_SAMPLE_N = 3;
+function glyphSampleGrid(box2, n = GLYPH_SAMPLE_N) {
+  const out = [];
+  if (!box2 || !(box2.width > 0) || !(box2.height > 0) || !(n >= 1)) return out;
+  const k = Math.floor(n);
+  for (let i = 0; i < k; i++) {
+    for (let j = 0; j < k; j++) {
+      out.push({
+        x: box2.left + box2.width * (i + 0.5) / k,
+        y: box2.top + box2.height * (j + 0.5) / k
+      });
+    }
+  }
+  return out;
+}
+var STRADDLE_COLS = 8;
+var STRADDLE_ROWS = 2;
+var STRADDLE_MIN_SHARE = 0.125;
+var STRADDLE_TARGET_CONTRAST = 4.5;
+var STRADDLE_PILL_ALPHA = 0.9;
+function straddleSampleGrid(box2) {
+  const out = [];
+  if (!box2 || !(box2.width > 0) || !(box2.height > 0)) return out;
+  for (let i = 0; i < STRADDLE_COLS; i++) {
+    for (let j = 0; j < STRADDLE_ROWS; j++) {
+      out.push({
+        x: box2.left + box2.width * (i + 0.5) / STRADDLE_COLS,
+        y: box2.top + box2.height * (j + 0.5) / STRADDLE_ROWS
+      });
+    }
+  }
+  return out;
+}
+function backgroundGroups(bgs, tol = 8) {
+  const groups = [];
+  for (const b of bgs || []) {
+    const g = groups.find((x) => Math.abs(x.rgb[0] - b[0]) <= tol && Math.abs(x.rgb[1] - b[1]) <= tol && Math.abs(x.rgb[2] - b[2]) <= tol);
+    if (g) g.n++;
+    else groups.push({ rgb: [b[0], b[1], b[2]], n: 1 });
+  }
+  return groups.sort((a, b) => b.n - a.n);
+}
+function straddles(bgs) {
+  if (!bgs || bgs.length < 2) return false;
+  const g = backgroundGroups(bgs);
+  return g.length >= 2 && g[1].n / bgs.length >= STRADDLE_MIN_SHARE;
+}
+function minContrastOver(textColor, bgs) {
+  const t = toRGBA(textColor);
+  if (!t || !bgs || !bgs.length) return 0;
+  let worst = Infinity;
+  for (const b of bgs) {
+    const tx = compositeOver(t, b);
+    worst = Math.min(worst, contrastRatio(relativeLuminance(tx), relativeLuminance(b)));
+  }
+  return worst;
+}
+function pickColorOver(textColor, bgs, target = STRADDLE_TARGET_CONTRAST) {
+  const cur = minContrastOver(textColor, bgs);
+  if (cur >= target) return { color: String(textColor), contrast: cur, keep: true };
+  const d = minContrastOver(DARK_TEXT, bgs), l = minContrastOver(LIGHT_TEXT, bgs);
+  const best = d >= l ? { color: DARK_TEXT, contrast: d } : { color: LIGHT_TEXT, contrast: l };
+  return best.contrast > cur ? { ...best, keep: false } : { color: String(textColor), contrast: cur, keep: true };
+}
+function clamp01(v) {
+  if (typeof v !== "number" || !isFinite(v)) return 1;
+  return Math.max(0, Math.min(1, v));
+}
+function hexToRGB(hex2) {
+  const p = toRGBA(hex2);
+  return [p[0], p[1], p[2]];
+}
+
+// src/deltaE.ts
+function linearise(c) {
+  const v = c / 255;
+  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+var Xn2 = 0.95047;
+var Yn2 = 1;
+var Zn = 1.08883;
+var EPS = 216 / 24389;
+var KAPPA = 24389 / 27;
+function f(t) {
+  return t > EPS ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+}
+function rgbToLab(r, g, b) {
+  const R = linearise(r), G = linearise(g), B = linearise(b);
+  const X = 0.4124564 * R + 0.3575761 * G + 0.1804375 * B;
+  const Y = 0.2126729 * R + 0.7151522 * G + 0.072175 * B;
+  const Z = 0.0193339 * R + 0.119192 * G + 0.9503041 * B;
+  const fx = f(X / Xn2), fy = f(Y / Yn2), fz = f(Z / Zn);
+  return { L: 116 * fy - 16, a: 500 * (fx - fy), b: 200 * (fy - fz) };
+}
+function hexToLab(hex2) {
+  const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex2.trim());
+  if (!m) return null;
+  const h = m[1].length === 3 ? m[1][0] + m[1][0] + m[1][1] + m[1][1] + m[1][2] + m[1][2] : m[1];
+  return rgbToLab(parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16));
+}
+var RAD = Math.PI / 180;
+var DEG = 180 / Math.PI;
+var NEUTRAL_CHROMA = 1e-4;
+function deltaE2000(c1, c2) {
+  const C1 = Math.hypot(c1.a, c1.b), C2 = Math.hypot(c2.a, c2.b);
+  const Cbar = (C1 + C2) / 2;
+  const C7 = Math.pow(Cbar, 7);
+  const G = 0.5 * (1 - Math.sqrt(C7 / (C7 + Math.pow(25, 7))));
+  const a1p = (1 + G) * c1.a, a2p = (1 + G) * c2.a;
+  const C1p = Math.hypot(a1p, c1.b), C2p = Math.hypot(a2p, c2.b);
+  const neutral = C1p < NEUTRAL_CHROMA || C2p < NEUTRAL_CHROMA;
+  const h1p = C1p < NEUTRAL_CHROMA ? 0 : (Math.atan2(c1.b, a1p) * DEG + 360) % 360;
+  const h2p = C2p < NEUTRAL_CHROMA ? 0 : (Math.atan2(c2.b, a2p) * DEG + 360) % 360;
+  const dLp = c2.L - c1.L;
+  const dCp = C2p - C1p;
+  let dhp;
+  if (neutral) dhp = 0;
+  else if (Math.abs(h2p - h1p) <= 180) dhp = h2p - h1p;
+  else if (h2p - h1p > 180) dhp = h2p - h1p - 360;
+  else dhp = h2p - h1p + 360;
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(dhp / 2 * RAD);
+  const Lbarp = (c1.L + c2.L) / 2;
+  const Cbarp = (C1p + C2p) / 2;
+  let hbarp;
+  if (neutral) hbarp = h1p + h2p;
+  else if (Math.abs(h1p - h2p) <= 180) hbarp = (h1p + h2p) / 2;
+  else if (h1p + h2p < 360) hbarp = (h1p + h2p + 360) / 2;
+  else hbarp = (h1p + h2p - 360) / 2;
+  const T = 1 - 0.17 * Math.cos((hbarp - 30) * RAD) + 0.24 * Math.cos(2 * hbarp * RAD) + 0.32 * Math.cos((3 * hbarp + 6) * RAD) - 0.2 * Math.cos((4 * hbarp - 63) * RAD);
+  const dTheta = 30 * Math.exp(-Math.pow((hbarp - 275) / 25, 2));
+  const Cbarp7 = Math.pow(Cbarp, 7);
+  const RC = 2 * Math.sqrt(Cbarp7 / (Cbarp7 + Math.pow(25, 7)));
+  const RT = -RC * Math.sin(2 * dTheta * RAD);
+  const Lm50 = Math.pow(Lbarp - 50, 2);
+  const SL = 1 + 0.015 * Lm50 / Math.sqrt(20 + Lm50);
+  const SC = 1 + 0.045 * Cbarp;
+  const SH = 1 + 0.015 * Cbarp * T;
+  const tL = dLp / SL, tC = dCp / SC, tH = dHp / SH;
+  return Math.sqrt(tL * tL + tC * tC + tH * tH + RT * tC * tH);
+}
+function labToHex(lab) {
+  const finv = (t) => {
+    const t3 = t * t * t;
+    return t3 > EPS ? t3 : (116 * t - 16) / KAPPA;
+  };
+  const fy = (lab.L + 16) / 116, fx = fy + lab.a / 500, fz = fy - lab.b / 200;
+  const X = Xn2 * finv(fx);
+  const Y = Yn2 * (lab.L > KAPPA * EPS ? fy * fy * fy : lab.L / KAPPA);
+  const Z = Zn * finv(fz);
+  const lin = [
+    3.2404542 * X - 1.5371385 * Y - 0.4985314 * Z,
+    -0.969266 * X + 1.8760108 * Y + 0.041556 * Z,
+    0.0556434 * X - 0.2040259 * Y + 1.0572252 * Z
+  ];
+  return "#" + lin.map((v) => {
+    const c = Math.max(0, Math.min(1, v));
+    const g = c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+    return Math.round(g * 255).toString(16).padStart(2, "0");
+  }).join("");
+}
+function deltaEHex(a, b) {
+  const la = hexToLab(a), lb = hexToLab(b);
+  return la && lb ? deltaE2000(la, lb) : NaN;
+}
+
+// src/colourSpread.ts
+var SAME_SHADE_DELTA_E = 5;
+var MIN_RAMP_FILLS = 4;
+var RAMP_SLACK_MAX = 0.15;
+var MIN_MARKS = 24;
+var ELEMENT_CAP = 5e3;
+var MAX_CELLS = 48;
+var CELL_STEP = 32;
+var EMPTY = { marks: 0, distinctFills: 0, crowdShare: 0, spanDeltaE: 0 };
+function styleOf(el, doc) {
+  try {
+    const view = doc?.defaultView;
+    return view?.getComputedStyle ? view.getComputedStyle(el) : null;
+  } catch {
+    return null;
+  }
+}
+function fillOf(el, cs) {
+  const a = el.getAttribute?.("fill");
+  if (a !== null && a !== void 0 && String(a).trim() !== "") return String(a).trim();
+  const c = cs?.fill;
+  return c === null || c === void 0 ? "" : String(c).trim();
+}
+function toRgb(raw) {
+  const s = raw.trim().toLowerCase();
+  if (!s || s === "none" || s === "transparent") return null;
+  const hex2 = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(s);
+  if (hex2) {
+    const h = hex2[1];
+    const full = h.length === 3 ? h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : h;
+    return [
+      parseInt(full.slice(0, 2), 16),
+      parseInt(full.slice(2, 4), 16),
+      parseInt(full.slice(4, 6), 16)
+    ];
+  }
+  const m = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)\s*(?:[,/]\s*([\d.]+)\s*)?\)$/.exec(s);
+  if (!m) return null;
+  if (m[4] !== void 0 && parseFloat(m[4]) === 0) return null;
+  return [Math.round(parseFloat(m[1])), Math.round(parseFloat(m[2])), Math.round(parseFloat(m[3]))];
+}
+function cellKey(rgb) {
+  return [
+    Math.round(rgb[0] / CELL_STEP),
+    Math.round(rgb[1] / CELL_STEP),
+    Math.round(rgb[2] / CELL_STEP)
+  ].join(",");
+}
+function hex(rgb) {
+  return "#" + rgb.map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")).join("");
+}
+function censusColourSpread(container, doc) {
+  if (!container || typeof container.querySelectorAll !== "function") return EMPTY;
+  try {
+    const els = Array.from(
+      container.querySelectorAll(`.${MARK_CLASS}, [${ROW_IDX_ATTR}]`)
+    );
+    if (els.length === 0 || els.length > ELEMENT_CAP) return EMPTY;
+    const ownerDoc = doc ?? container.ownerDocument;
+    const painted = [];
+    for (const el of els) {
+      const rgb = toRgb(fillOf(el, styleOf(el, ownerDoc)));
+      if (rgb) painted.push({ rgb, tag: String(el.tagName || "").toLowerCase() });
+    }
+    const byTag = /* @__PURE__ */ new Map();
+    for (const p of painted) {
+      const g = byTag.get(p.tag) ?? { fills: /* @__PURE__ */ new Set(), n: 0 };
+      g.fills.add(p.rgb.join(","));
+      g.n++;
+      byTag.set(p.tag, g);
+    }
+    const overlays = new Set([...byTag].filter(([, g]) => g.fills.size === 1 && g.n >= MIN_MARKS).map(([t]) => t));
+    const restFills = new Set([...byTag].filter(([t]) => !overlays.has(t)).flatMap(([, g]) => [...g.fills]));
+    const counted = restFills.size > 1 ? painted.filter((p) => !overlays.has(p.tag)) : painted;
+    const distinct = /* @__PURE__ */ new Set();
+    const cells = /* @__PURE__ */ new Map();
+    let marks = 0;
+    for (const { rgb } of counted) {
+      marks++;
+      distinct.add(rgb.join(","));
+      const k = cellKey(rgb);
+      const cur = cells.get(k);
+      if (cur) cur.n++;
+      else cells.set(k, { rgb, n: 1 });
+    }
+    if (marks < MIN_MARKS || distinct.size < MIN_RAMP_FILLS) return EMPTY;
+    const top = [...cells.values()].sort((a, b) => b.n - a.n).slice(0, MAX_CELLS);
+    const cs = top.map((c) => hexToLab(hex(c.rgb))).filter((l) => l !== null);
+    if (cs.length < MIN_RAMP_FILLS) return EMPTY;
+    const d = cs.map(() => new Array(cs.length).fill(0));
+    let span = 0, lo = 0, hi = 1;
+    for (let i = 0; i < cs.length; i++) {
+      for (let j = i + 1; j < cs.length; j++) {
+        const v = deltaE2000(cs[i], cs[j]);
+        d[i][j] = v;
+        d[j][i] = v;
+        if (v > span) {
+          span = v;
+          lo = i;
+          hi = j;
+        }
+      }
+    }
+    if (span <= 0) return EMPTY;
+    let slack = 0, interior = 0;
+    for (let i = 0; i < cs.length; i++) {
+      if (i === lo || i === hi) continue;
+      slack += (d[lo][i] + d[i][hi]) / span - 1;
+      interior++;
+    }
+    if (interior < 2 || slack / interior > RAMP_SLACK_MAX) return EMPTY;
+    let crowd = 0;
+    for (let i = 0; i < cs.length; i++) {
+      let n = 0;
+      for (let j = 0; j < cs.length; j++) {
+        if (i === j || d[i][j] <= SAME_SHADE_DELTA_E) n += top[j].n;
+      }
+      if (n > crowd) crowd = n;
+    }
+    return {
+      marks,
+      distinctFills: distinct.size,
+      crowdShare: Math.round(crowd / marks * 100),
+      spanDeltaE: Math.round(span)
+    };
+  } catch {
+    return EMPTY;
+  }
+}
+function colourSpreadFlag(c) {
+  if (c.marks === 0) return "";
+  return "ramp:d3:crowd" + Math.min(80, Math.floor(c.crowdShare / 20) * 20);
+}
+
+// src/autoRamp.ts
+var AUTO_RAMP_CLASSES = 7;
+var AUTO_RAMP_DRAWN_OPACITY = 0.5;
+var AUTO_RAMP_MIN_STEP_DELTA_E = 2.3;
+var FALLBACK_ACCENT = "#3182bd";
+var MIN_ACCENT_VS_CANVAS = 20;
+var HEX = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function normHex(raw) {
+  if (typeof raw !== "string") return null;
+  const m = HEX.exec(raw.trim());
+  if (!m) return null;
+  const h = m[1].length === 3 ? m[1].split("").map((c) => c + c).join("") : m[1];
+  return "#" + h.toLowerCase();
+}
+function mixLab(a, b, t) {
+  return { L: a.L + (b.L - a.L) * t, a: a.a + (b.a - a.a) * t, b: a.b + (b.b - a.b) * t };
+}
+function paintedOver(fg, canvas, alpha) {
+  const f2 = [1, 3, 5].map((i) => parseInt(fg.slice(i, i + 2), 16));
+  const c = [1, 3, 5].map((i) => parseInt(canvas.slice(i, i + 2), 16));
+  const mixed = f2.map((v, i) => Math.round(v * alpha + c[i] * (1 - alpha))).map((v) => v.toString(16).padStart(2, "0"));
+  return hexToLab("#" + mixed.join(""));
+}
+function autoRampMinStep(low, high, canvas, classes = AUTO_RAMP_CLASSES, opacity = AUTO_RAMP_DRAWN_OPACITY) {
+  const lo = hexToLab(low), hi = hexToLab(high);
+  const bg = normHex(canvas);
+  if (!lo || !hi || !bg || classes < 2) return NaN;
+  let prev = null, min = Infinity;
+  for (let k = 0; k < classes; k++) {
+    const painted = paintedOver(labToHex(mixLab(lo, hi, k / (classes - 1))), bg, opacity);
+    if (prev) min = Math.min(min, deltaE2000(prev, painted));
+    prev = painted;
+  }
+  return min;
+}
+function autoRampCanvas(p) {
+  return normHex(p.backgroundColor) ?? normHex(p.themeBg) ?? "#ffffff";
+}
+var memoKey = "";
+var memoValue = { low: "", high: "" };
+function resolveAutoColorScale(p) {
+  const canvas = autoRampCanvas(p);
+  const palette = Array.isArray(p.palette) ? p.palette : [];
+  const key = [canvas, p.isHighContrast ? 1 : 0, p.themeAccent ?? "", p.themeFg ?? "", palette.join(",")].join("|");
+  if (key === memoKey) return memoValue;
+  const bg = hexToLab(canvas);
+  const darkCanvas = bg.L < 50;
+  const usable = (hex2) => {
+    const lab = hex2 ? hexToLab(hex2) : null;
+    return !!lab && deltaE2000(lab, bg) >= MIN_ACCENT_VS_CANVAS;
+  };
+  const candidates = p.isHighContrast ? [normHex(p.themeAccent), normHex(p.themeFg)] : [...palette.map(normHex), normHex(p.themeAccent), normHex(p.themeFg)];
+  const accent = candidates.find(usable) ?? FALLBACK_ACCENT;
+  const A = hexToLab(accent);
+  let t = 0.1;
+  let low = mixLab(bg, A, t);
+  while (t < 0.6 && deltaE2000(paintedOver(labToHex(low), canvas, AUTO_RAMP_DRAWN_OPACITY), bg) < SAME_SHADE_DELTA_E) {
+    t += 0.02;
+    low = mixLab(bg, A, t);
+  }
+  const lowHex = labToHex(low);
+  let high = { ...A };
+  let highHex = labToHex(high);
+  for (let step = 0; step < 80 && autoRampMinStep(lowHex, highHex, canvas) < AUTO_RAMP_MIN_STEP_DELTA_E; step++) {
+    const L = Math.max(4, Math.min(98, high.L + (darkCanvas ? 1 : -1)));
+    if (L === high.L) break;
+    high = { ...high, L };
+    highHex = labToHex(high);
+  }
+  memoKey = key;
+  memoValue = { low: lowHex, high: highHex };
+  return memoValue;
+}
+
+// src/defaults.ts
+function themedLand(p) {
+  const bg = p.geoLandColor ? null : toRGBA(p.backgroundColor);
+  if (!bg || bg[3] < 1 || relativeLuminance([bg[0], bg[1], bg[2]]) > 0.2) return void 0;
+  const fg = toRGBA(p.themeFg) ?? [255, 255, 255, 1];
+  return "#" + compositeOver([fg[0], fg[1], fg[2], 0.18], [bg[0], bg[1], bg[2]]).map((v) => v.toString(16).padStart(2, "0")).join("");
+}
+var clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+var numberOr = (raw, dflt) => {
+  const n = raw == null || raw === "" ? NaN : Number(raw);
+  return Number.isFinite(n) ? n : dflt;
+};
+function resolveOptions(p) {
+  return {
+    // ---- host fields: pass through exactly as supplied ----
+    width: p.width,
+    height: p.height,
+    palette: p.palette,
+    geoUnmatched: p.geoUnmatched,
+    geo: p.geo,
+    geoPoint: p.geoPoint,
+    // THIRD AND FOURTH OCCURRENCES OF THE animLoopDelaySec OMISSION, found together by
+    // reading the contract against this list rather than by a bug report. geoPointDest is
+    // declared on RenderOptions, passed by the visual and read by the route archetypes, and
+    // was missing here - so a chart that claims "an arc is only as honest as its worse
+    // endpoint" never saw the destination end at all. The guard test at the bottom of
+    // tests/defaults.test.ts now compares the two lists, because four instances of one
+    // omission is a missing check, not four mistakes.
+    geoPointDest: p.geoPointDest,
+    // A host FACT about the data it serialised (contract 1.9.0), passed through untouched.
+    dateCellsAreUtcDays: p.dateCellsAreUtcDays,
+    // NO LONGER A PASS-THROUGH. A host without a Max Map Points setting used to leave this
+    // undefined, and every map chart then fell back to whatever number its own code carried -
+    // 1000 in every archetype written so far - while the offer gate used the server's. One
+    // default here makes the chart and the gate agree in every host. A positive value from
+    // the host wins; absent, blank, zero or junk means the shared default.
+    maxMapPoints: (() => {
+      const n = numberOr(p.maxMapPoints, 0);
+      return n > 0 ? Math.round(n) : MAX_MAP_POINTS_DEFAULT;
+    })(),
+    // FIFTH AND SIXTH OCCURRENCES, and the two that argue hardest for the guard test: both
+    // were passed by the visual AND read by the charts, and neither was ever declared here or
+    // in the contract - so the contract-vs-whitelist check could not see them either. What
+    // found them was scanning the OTHER direction, from the caller and the charts inward.
+    // 0 is MEANINGFUL for both ("let the chart choose", "no paging"), so numberOr rather than
+    // `|| DEFAULT`, which would turn an explicit 0 into something else. Clamping stays
+    // chart-side for the same reason it does for flipIntervalMs.
+    geoPointRadiusPx: Math.max(0, numberOr(p.geoPointRadiusPx, 0)),
+    pageSize: Math.max(0, numberOr(p.pageSize, 0)),
+    uiState: p.uiState,
+    setUiState: p.setUiState,
+    backgroundColor: p.backgroundColor,
+    themeBg: p.themeBg,
+    themeFg: p.themeFg,
+    isHighContrast: p.isHighContrast,
+    themeAccent: p.themeAccent,
+    cultureCode: p.cultureCode,
+    allowTooltips: p.allowTooltips,
+    noDataText: p.noDataText,
+    onSelect: p.onSelect,
+    // Control gestures (1.10.0). Passed straight through like onSelect: the host owns what a gesture MEANS,
+    // and a host that supplies nothing leaves every control behaving exactly as before.
+    onControlChange: p.onControlChange,
+    // ---- live-restyle knobs: `raw || undefined` / `.toString() || undefined` ----
+    colorScaleLow: p.colorScaleLow || void 0,
+    colorScaleHigh: p.colorScaleHigh || void 0,
+    // DERIVED, never passed: the automatic ends a blank picker stands for, resolved from the
+    // same palette and canvas the chart is handed on this render (autoRamp.ts).
+    colorScaleAutoLow: resolveAutoColorScale(p).low,
+    colorScaleAutoHigh: resolveAutoColorScale(p).high,
+    // "" (global, the default), "frame", or "self"; anything else fails open to global.
+    colorScaleScope: p.colorScaleScope === "frame" || p.colorScaleScope === "self" ? p.colorScaleScope : "",
+    // Math.max(50, Math.min(100, Number(raw) || 95)) — only meaningful under "self".
+    colorScaleSelfClampPct: clamp(Number(p.colorScaleSelfClampPct) || COLOR_SCALE_SELF_CLAMP_PCT_DEFAULT, COLOR_SCALE_SELF_CLAMP_PCT_MIN, COLOR_SCALE_SELF_CLAMP_PCT_MAX),
+    // Map fills: `raw || undefined` like the colour-scale endpoints. The no-data ->
+    // land cascade is left to the chart (so the fallback chain is visible in the
+    // generated code); HC substitution has already happened in the caller.
+    geoLandColor: p.geoLandColor || themedLand(p) || void 0,
+    geoNoDataColor: p.geoNoDataColor || void 0,
+    aggregation: (p.aggregation == null ? "" : String(p.aggregation)) || void 0,
+    // A recognised value wins, anything else falls to the default: an unknown string must
+    // never reach a chart as a live mode. Both of these are read on EVERY render, so a
+    // reader can change their mind about a cached chart without regenerating it.
+    approximatePositions: (() => {
+      const v = (p.approximatePositions == null ? "" : String(p.approximatePositions)).toLowerCase();
+      return v === "mark" || v === "aggregate" || v === "skip" ? v : APPROXIMATE_POSITIONS_DEFAULT;
+    })(),
+    valueAxisBaseline: (() => {
+      const v = (p.valueAxisBaseline == null ? "" : String(p.valueAxisBaseline)).toLowerCase();
+      return v === "zero" || v === "fit" || v === "auto" ? v : VALUE_AXIS_BASELINE_DEFAULT;
+    })(),
+    // Same shape, and the same reason for it: an unrecognised string must never reach a chart
+    // as a live mode. Failing open to "auto" is the conservative direction here — "auto" is
+    // the setting that makes the chart PROVE the grid before it names a period, so a garbled
+    // value withdraws the claim rather than asserting one.
+    seasonalMarkers: (() => {
+      const v = (p.seasonalMarkers == null ? "" : String(p.seasonalMarkers)).toLowerCase();
+      return v === "auto" || v === "always" || v === "never" ? v : SEASONAL_MARKERS_DEFAULT;
+    })(),
+    // ---- animation: booleans, default+clamp numerics, "" default enum ----
+    animAutoPlay: !!p.animAutoPlay,
+    // Math.max(250, Math.min(5000, Number(raw) || 1000))
+    animPlaySpeedMs: clamp(Number(p.animPlaySpeedMs) || ANIM_PLAY_SPEED_DEFAULT, ANIM_PLAY_SPEED_MIN, ANIM_PLAY_SPEED_MAX),
+    // Loop-restart delay (seconds on the overview between auto-play passes).
+    // Floored at 0, deliberately NO upper clamp (huge = play once per viewing),
+    // and 0 must survive as 0 — hence numberOr, not `|| DEFAULT`. This field was
+    // MISSING from the resolve list when the assembly moved here, so callers
+    // that passed it saw it dropped: the scrubber read undefined -> 0 -> every
+    // pass restarted instantly and resumed-state auto-play lost its pacing.
+    animLoopDelaySec: Math.max(ANIM_LOOP_DELAY_MIN, numberOr(p.animLoopDelaySec, ANIM_LOOP_DELAY_DEFAULT)),
+    // Math.max(3, Math.min(500, Number(raw) || 60))
+    animMaxIdealFrames: clamp(Number(p.animMaxIdealFrames) || ANIM_MAX_IDEAL_FRAMES_DEFAULT, ANIM_MAX_IDEAL_FRAMES_MIN, ANIM_MAX_IDEAL_FRAMES_MAX),
+    animStopAtEnd: !!p.animStopAtEnd,
+    filtersDuringPlay: !!p.filtersDuringPlay,
+    animTimelineStyle: (p.animTimelineStyle || "").toString(),
+    // ---- card deck ----
+    // SECOND OCCURRENCE OF THE animLoopDelaySec BUG, six lines above (2026-08-13). The
+    // visual passed both of these, the generated code read both correctly, and this
+    // function — a whitelist that returns a NEW object — dropped them in between. Symptoms
+    // were exactly what the two defaults produce: flipSync undefined -> `!== false` -> true
+    // -> always synced, so "Flip Cards Together = Off" did nothing and the deck kept its
+    // shared strip; flipIntervalMs undefined -> `+(undefined || 0)` -> 0 -> the timer branch
+    // never ran, so a 1000 ms interval produced no flips. Two dead knobs, one omission.
+    //
+    // flipSync DEFAULTS TRUE, so it cannot use `!!p.flipSync` — that would read a missing
+    // value as "independent" and hand every deck twelve control strips. Absent means
+    // synced; only an explicit false switches it.
+    flipSync: p.flipSync === void 0 || p.flipSync === null ? true : !!p.flipSync,
+    // WHERE the controls live, which is a different question from whether the cards move
+    // together (2026-08-13: "the ability to flip individual cards shouldn't necessarily
+    // stop being able to flip all together too"). Resolution order matters and is the whole
+    // back-compat story:
+    //   1. an explicit, recognised flipMode wins;
+    //   2. otherwise DERIVE from flipSync, so a chart generated before this option existed
+    //      behaves exactly as it did - true -> "all", false -> "single";
+    //   3. and a caller that sends neither gets the default.
+    // Deriving rather than defaulting is the point: a cached chart must not change behaviour
+    // because a newer client shipped, and "both" would have done exactly that to every deck
+    // already in a report.
+    flipMode: (() => {
+      const m = (p.flipMode == null ? "" : String(p.flipMode)).toLowerCase();
+      if (m === "single" || m === "all" || m === "both") return m;
+      if (p.flipSync === false) return "single";
+      if (p.flipSync === true) return "all";
+      return FLIP_MODE_DEFAULT;
+    })(),
+    // WHICH WAY A FACE TURNS. Anything unrecognised - including absent, which is every host
+    // that predates the option - is the default, side to side, which is what every chart that
+    // turns did before it existed.
+    flipDirection: (() => {
+      const d = (p.flipDirection == null ? "" : String(p.flipDirection)).toLowerCase();
+      return d === "horizontal" || d === "vertical" ? d : FLIP_DIRECTION_DEFAULT;
+    })(),
+    // 0 is MEANINGFUL here (manual only), so numberOr — not `|| DEFAULT` — for the same
+    // reason animLoopDelaySec uses it. UNSET STAYS UNSET (undefined), because the default is
+    // the CHART's, not this function's: the card deck reads `+(x || 0)` and is manual, a
+    // carousel reads `x == null ? 5000 : +x` and turns by itself. Resolving unset to 0 here
+    // made the carousel's default unreachable - every host handed it an explicit "manual".
+    // Clamping stays chart-side too: the archetypes clamp 500..120000, and two clamps in two
+    // repositories is how they end up disagreeing.
+    flipIntervalMs: (() => {
+      const n = numberOr(p.flipIntervalMs, NaN);
+      return Number.isFinite(n) ? Math.max(0, n) : void 0;
+    })(),
+    // `raw || undefined`, the same idiom as the colour-scale endpoints and the map fills:
+    // blank must arrive as ABSENT, not as an empty string, because the chart's fallback is
+    // `options.cardBackgroundColor || <its own choice>` and "" would satisfy a truthiness
+    // test in some hands while painting nothing in others.
+    cardBackgroundColor: p.cardBackgroundColor || void 0,
+    // A reader's on / off, or UNSET - never filled with false, for the flipIntervalMs reason: the
+    // default is the chart's (on only where its request asked for drop lines), and a host that
+    // turned unset into false would make that default unreachable. Pane choices arrive as text.
+    hoverDropLines: (() => {
+      const v = p.hoverDropLines;
+      if (typeof v === "boolean") return v;
+      const s = v == null ? "" : String(v).trim().toLowerCase();
+      return s === "on" || s === "true" || s === "1" ? true : s === "off" || s === "false" || s === "0" ? false : void 0;
+    })()
+  };
+}
+
+// src/geoLazy.ts
+var byKind = /* @__PURE__ */ new Map();
+var byAsset = /* @__PURE__ */ new Map();
+var _na;
+function geoAssetFor(geoKind) {
+  if (!geoKind) return null;
+  const k = geoKind.toLowerCase();
+  if (/^country/.test(k)) return "world";
+  if (k === "north-america") return "world";
+  if (k === "world") return "world";
+  if (k === "us-state-code" || k === "us-state-name") return "us-states";
+  if (k === "us-zip5") return "us-zip3";
+  return null;
+}
+var _worldBase;
+function worldBasemap(world) {
+  if (!_worldBase) {
+    _worldBase = {
+      type: "FeatureCollection",
+      features: world.features.filter((f2) => f2?.geometry && f2.geometry.type !== "Point")
+    };
+  }
+  return _worldBase;
+}
+function northAmerica(world) {
+  if (!_na) {
+    _na = {
+      type: "FeatureCollection",
+      features: world.features.filter((f2) => NA_ISO3.has(f2?.id) && f2?.geometry && f2.geometry.type !== "Point").map((f2) => clipFeatureToLat(f2, NA_LAT_MAX)).filter((f2) => f2 !== null)
+    };
+  }
+  return _na;
+}
+function fromAssets(key) {
+  const asset = geoAssetFor(key);
+  if (!asset) return void 0;
+  const geo = byAsset.get(asset);
+  if (!geo) return void 0;
+  if (key === "north-america") return northAmerica(geo);
+  if (key === "world") return worldBasemap(geo);
+  return geo;
+}
+async function loadGeo(geoKind) {
+  if (!geoKind) return void 0;
+  const key = geoKind.toLowerCase();
+  const already = geoFromCache(key);
+  if (already) return already;
+  const asset = geoAssetFor(key);
+  if (!asset) return void 0;
+  if (asset === "us-states") {
+    byAsset.set(asset, (await import("./geoUsStates.generated-JEFM6OHO.mjs")).US_STATES);
+  } else if (asset === "us-zip3") {
+    byAsset.set(asset, (await import("./geoUsZip3.generated-VSWL7D6F.mjs")).US_ZIP3);
+  } else {
+    byAsset.set(asset, (await import("./geoWorld110m.generated-TD2TA7S7.mjs")).WORLD_110M);
+  }
+  return fromAssets(key);
+}
+function geoFromCache(geoKind) {
+  if (!geoKind) return void 0;
+  const key = geoKind.toLowerCase();
+  return byKind.get(key) ?? fromAssets(key);
+}
+function registerGeo(geoKind, geo) {
+  if (geoKind && geo) byKind.set(geoKind.toLowerCase(), geo);
+}
+function registerGeoAsset(asset, geo) {
+  if (!asset || !geo) return;
+  byAsset.set(asset, geo);
+  if (asset === "world") {
+    _na = void 0;
+    _worldBase = void 0;
+  }
+}
+function clearGeoCache() {
+  byKind.clear();
+  byAsset.clear();
+  _na = void 0;
+  _worldBase = void 0;
+}
+
+// src/payload.ts
+var ROW_IDX_COLUMN = "__rowIdx__";
+function resolvePointChannel(cols, rowObjs, point) {
+  let pLat = null;
+  let pLon = null;
+  let pPrec = null;
+  let geoPoint;
+  let bind = point ?? null;
+  let rolesBackfilled = [];
+  let rolesRefused = [];
+  let labelCol;
+  if (bind) {
+    const dims = cols.filter((c) => !c.isMeasure).map((c) => c.name);
+    const res = Xn(dims, rowObjs, bind, point?.mapKind, cols.map((c) => c.name));
+    bind = res.bind;
+    rolesBackfilled = res.backfilled;
+    rolesRefused = res.refused;
+    const lf = res.labelFallback;
+    labelCol = lf && (lf.country || lf.city || lf.state || lf.zip);
+  }
+  const hasPointBind = !!bind && !!(bind.city || bind.state || bind.zip || bind.country || bind.lat && bind.lon);
+  if (hasPointBind) {
+    const p = bind;
+    const built = J3(rowObjs.map((r) => ({
+      lat: p.lat ? r[p.lat] : null,
+      lon: p.lon ? r[p.lon] : null,
+      city: p.city ? r[p.city] : null,
+      state: p.state ? r[p.state] : null,
+      zip: p.zip ? r[p.zip] : null,
+      country: p.country ? r[p.country] : null,
+      label: labelCol ? r[labelCol] : null
+    })), point?.mapKind);
+    pLat = built.lat;
+    pLon = built.lon;
+    pPrec = built.precisions;
+    geoPoint = {
+      precision: built.precision,
+      precisionCounts: built.precisionCounts,
+      coarseExamples: built.coarseExamples,
+      // STRICTLY no-match. Ambiguous rows are deliberately NOT in here: new charts
+      // report them from ambiguousRows/ambiguousExamples, while OLD generated code
+      // still shows them — it computes its own off-map count from null coordinates
+      // and takes max(offMap, unplaced), so the not-shown total stays right without
+      // double-counting on either side of the upgrade.
+      unplaced: built.totalRows - built.matchedRows - built.ambiguousRows,
+      unplacedExamples: built.unmatched.slice(0, 8),
+      ambiguousRows: built.ambiguousRows,
+      ...built.ambiguousExamples.length ? { ambiguousExamples: built.ambiguousExamples } : {},
+      // Omitted entirely when nothing was adjusted, so the common case adds no bytes
+      // and a chart can treat presence as "something about this binding is worth
+      // saying".
+      ...rolesBackfilled.length ? { rolesBackfilled } : {},
+      ...rolesRefused.length ? { rolesRefused } : {}
+    };
+  }
+  return { lat: pLat, lon: pLon, prec: pPrec, geoPoint, rolesRefused };
+}
+function buildRenderPayload(cols, rowObjs, geo, point, destination, opts) {
+  cols = cols.filter((c) => c.name !== ROW_IDX_COLUMN);
+  let utcDayColumns = null;
+  if (opts?.utcDays) {
+    const norm = ge(cols, rowObjs);
+    rowObjs = norm.rows;
+    utcDayColumns = norm.columns;
+  }
+  const o = resolvePointChannel(cols, rowObjs, point);
+  const d = resolvePointChannel(cols, rowObjs, destination);
+  const pLat = o.lat, pLon = o.lon, pPrec = o.prec;
+  const dLat = d.lat, dLon = d.lon, dPrec = d.prec;
+  const geoPoint = o.geoPoint;
+  const geoPointDest = d.geoPoint;
+  const rolesRefused = [...o.rolesRefused, ...d.rolesRefused.map((s) => `destination: ${s}`)];
+  let geoIso = null;
+  let geoUnmatched;
+  let geoUnmatchedDistinct;
+  if (geo && geo.column && geo.kind && Yn(geo.kind)) {
+    const built = Fn(rowObjs.map((r) => r[geo.column]), geo.kind);
+    geoIso = built.iso;
+    geoUnmatched = { count: built.totalRows - built.matchedRows, examples: built.unmatched.slice(0, 8) };
+    geoUnmatchedDistinct = built.unmatched.length;
+  }
+  const hostNames = [ROW_IDX_COLUMN];
+  if (geoIso) hostNames.push("__geoIso__");
+  if (pLat) hostNames.push("__geoLat__", "__geoLon__", "__geoPrecision__");
+  if (dLat) hostNames.push("__geoLatD__", "__geoLonD__", "__geoPrecisionD__");
+  const owned = new Set(hostNames);
+  if (cols.some((c) => owned.has(c.name))) cols = cols.filter((c) => !owned.has(c.name));
+  const colNames = cols.map((c) => c.name);
+  const aliasCols = [];
+  if (opts?.aliases && opts.aliases.length > 0) {
+    const claimed = /* @__PURE__ */ new Set([...colNames, ...hostNames]);
+    for (const a of opts.aliases) {
+      const from = a ? colNames.indexOf(a.name) : -1;
+      if (from < 0 || !a.alias || claimed.has(a.alias)) continue;
+      claimed.add(a.alias);
+      aliasCols.push({ from, name: a.alias });
+    }
+  }
+  const extra = hostNames.length + aliasCols.length;
+  const out = new Array(rowObjs.length);
+  for (let r = 0; r < rowObjs.length; r++) {
+    const row = rowObjs[r];
+    const a = new Array(cols.length + extra);
+    for (let c = 0; c < cols.length; c++) {
+      const v = row[colNames[c]];
+      if (v instanceof Date) {
+        a[c] = v.toISOString();
+      } else {
+        a[c] = v ?? null;
+      }
+    }
+    let k = cols.length;
+    a[k++] = r;
+    if (geoIso) a[k++] = geoIso[r];
+    if (pLat && pLon) {
+      a[k++] = pLat[r];
+      a[k++] = pLon[r];
+      a[k++] = pPrec ? pPrec[r] : null;
+    }
+    if (dLat && dLon) {
+      a[k++] = dLat[r];
+      a[k++] = dLon[r];
+      a[k++] = dPrec ? dPrec[r] : null;
+    }
+    for (const ac of aliasCols) a[k++] = a[ac.from];
+    out[r] = a;
+  }
+  const colsOut = [...cols, { name: ROW_IDX_COLUMN, dataType: "Integer", isMeasure: false, modelDesc: "" }];
+  if (geoIso) colsOut.push({ name: "__geoIso__", dataType: "String", isMeasure: false, modelDesc: "" });
+  if (pLat) colsOut.push(
+    { name: "__geoLat__", dataType: "Double", isMeasure: false, modelDesc: "" },
+    { name: "__geoLon__", dataType: "Double", isMeasure: false, modelDesc: "" },
+    // Host metadata like the two above: which TIER placed this row ("latlon" | "city" |
+    // "zip3" | "state" | "country"), null when it was not placed. Never a dimension,
+    // never a label, never a colour grouping.
+    { name: "__geoPrecision__", dataType: "String", isMeasure: false, modelDesc: "" }
+  );
+  if (dLat) colsOut.push(
+    { name: "__geoLatD__", dataType: "Double", isMeasure: false, modelDesc: "" },
+    { name: "__geoLonD__", dataType: "Double", isMeasure: false, modelDesc: "" },
+    { name: "__geoPrecisionD__", dataType: "String", isMeasure: false, modelDesc: "" }
+  );
+  for (const ac of aliasCols) colsOut.push({ ...cols[ac.from], name: ac.name, aliasOf: cols[ac.from].name });
+  return {
+    columns: colsOut,
+    rows: out,
+    geoUnmatched,
+    geoUnmatchedDistinct,
+    geoPoint,
+    // Omitted when there is no second endpoint, so every existing chart's options object
+    // is unchanged rather than gaining an undefined key.
+    ...geoPointDest ? { geoPointDest } : {},
+    // Survives a refusal that placed nothing — see geoPointRefused. Omitted when empty so
+    // the ordinary case adds no bytes.
+    ...rolesRefused.length ? { geoPointRefused: rolesRefused } : {},
+    ...utcDayColumns ? { dateCellsAreUtcDays: true, utcDayColumns } : {}
+  };
+}
+
+// src/codeComments.ts
+function stripJsComments(code) {
+  const src = String(code ?? "");
+  const n = src.length;
+  let out = "";
+  let i = 0;
+  const templates = [];
+  let prevSig = "";
+  let prevWord = "";
+  let wordOpen = false;
+  const regexMayFollow = () => {
+    if (prevSig === "") return true;
+    if ("(,=:[!&|?{};+-*%<>~^".includes(prevSig)) return true;
+    return /^(return|typeof|instanceof|in|of|new|delete|void|throw|case|do|else|yield|await)$/.test(prevWord);
+  };
+  while (i < n) {
+    const ch = src[i];
+    const next = i + 1 < n ? src[i + 1] : "";
+    const top = templates.length > 0 ? templates[templates.length - 1] : null;
+    if (top === -1) {
+      if (ch === "\\") {
+        out += src.slice(i, i + 2);
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        templates.pop();
+        out += ch;
+        i++;
+        prevSig = "`";
+        prevWord = "";
+        wordOpen = false;
+        continue;
+      }
+      if (ch === "$" && next === "{") {
+        templates[templates.length - 1] = 0;
+        out += "${";
+        i += 2;
+        prevSig = "{";
+        prevWord = "";
+        wordOpen = false;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      let j = i + 2;
+      while (j < n && src[j] !== "\n" && src[j] !== "\r") j++;
+      out += " ";
+      i = j;
+      wordOpen = false;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      const end = src.indexOf("*/", i + 2);
+      const body = end < 0 ? src.slice(i + 2) : src.slice(i + 2, end);
+      const newlines = body.match(/\r\n|\r|\n/g);
+      out += newlines ? newlines.join("") : " ";
+      i = end < 0 ? n : end + 2;
+      wordOpen = false;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      while (j < n && src[j] !== ch && src[j] !== "\n") j += src[j] === "\\" ? 2 : 1;
+      out += src.slice(i, Math.min(j + 1, n));
+      i = j + 1;
+      prevSig = ch;
+      prevWord = "";
+      wordOpen = false;
+      continue;
+    }
+    if (ch === "`") {
+      templates.push(-1);
+      out += ch;
+      i++;
+      wordOpen = false;
+      continue;
+    }
+    if (ch === "/" && regexMayFollow()) {
+      let j = i + 1, inClass = false;
+      while (j < n && src[j] !== "\n") {
+        const c = src[j];
+        if (c === "\\") {
+          j += 2;
+          continue;
+        }
+        if (c === "[") inClass = true;
+        else if (c === "]") inClass = false;
+        else if (c === "/" && !inClass) break;
+        j++;
+      }
+      if (j < n && src[j] === "/") {
+        j++;
+        while (j < n && /[A-Za-z]/.test(src[j])) j++;
+        out += src.slice(i, j);
+        i = j;
+        prevSig = "/";
+        prevWord = "";
+        wordOpen = false;
+        continue;
+      }
+    }
+    if (top !== null && top >= 0) {
+      if (ch === "{") templates[templates.length - 1] = top + 1;
+      else if (ch === "}") {
+        if (top === 0) {
+          templates[templates.length - 1] = -1;
+          out += ch;
+          i++;
+          continue;
+        }
+        templates[templates.length - 1] = top - 1;
+      }
+    }
+    out += ch;
+    i++;
+    if (/\s/.test(ch)) {
+      wordOpen = false;
+    } else {
+      if (/[A-Za-z0-9_$]/.test(ch)) {
+        prevWord = wordOpen ? prevWord + ch : ch;
+        wordOpen = true;
+      } else {
+        prevWord = "";
+        wordOpen = false;
+      }
+      prevSig = ch;
+    }
+  }
+  return out;
+}
+
+// src/selection.ts
+function rowIdxsFromMark(el) {
+  if (!el) return [];
+  const raw = el.getAttribute("data-row-idx");
+  if (!raw) return [];
+  const out = [];
+  for (const tok of raw.split(",")) {
+    const n = parseInt(tok.trim(), 10);
+    if (!isNaN(n) && n >= 0) out.push(n);
+  }
+  return out;
+}
+function nextSelection(current, rowIdxs, mods = {}) {
+  const cur = Array.from(current ?? []);
+  if (mods.ctrl || mods.shift) {
+    const next = new Set(cur);
+    for (const r of rowIdxs) {
+      if (next.has(r)) next.delete(r);
+      else next.add(r);
+    }
+    return Array.from(next);
+  }
+  const same = cur.length === rowIdxs.length && rowIdxs.every((r) => cur.includes(r));
+  return same ? [] : rowIdxs.slice();
+}
+function selectionRuleOf(container) {
+  try {
+    const el = container?.querySelector?.(`[${SELECTION_RULE_ATTR}]`);
+    return el?.getAttribute(SELECTION_RULE_ATTR) === SELECTION_RULE_CLICKED_MARKS ? "clicked-marks" : "any-row";
+  } catch {
+    return "any-row";
+  }
+}
+function markKeyOf(el) {
+  if (!el) return "";
+  const k = el.getAttribute(MARK_KEY_ATTR);
+  if (k != null && k !== "") return k;
+  return "rows:" + (el.getAttribute(ROW_IDX_ATTR) || "").replace(/\s+/g, "");
+}
+var toSet = (s) => new Set(Array.from(s ?? []));
+function sameRowSet(a, b) {
+  const A = toSet(a), B = toSet(b);
+  if (A.size !== B.size) return false;
+  for (const r of A) if (!B.has(r)) return false;
+  return true;
+}
+function planSelectionPaint(marks, selection, rule, clicked) {
+  const sel = toSet(selection);
+  if (sel.size === 0) return { on: marks.map(() => false), mode: "none", keys: [] };
+  const anyRow = () => marks.map((m) => m.rows.some((r) => sel.has(r)));
+  if (rule !== "clicked-marks") return { on: anyRow(), mode: "any-row", keys: [] };
+  if (clicked && clicked.keys.length && sameRowSet(clicked.selection, sel)) {
+    const want = new Set(clicked.keys);
+    const on = marks.map((m) => m.rows.length > 0 && want.has(m.key));
+    if (on.some(Boolean)) return { on, mode: "clicked", keys: marks.filter((_, i) => on[i]).map((m) => m.key) };
+  }
+  const exact = marks.map((m) => m.rows.length > 0 && sameRowSet(m.rows, sel));
+  if (exact.some(Boolean)) return { on: exact, mode: "exact", keys: marks.filter((_, i) => exact[i]).map((m) => m.key) };
+  return { on: anyRow(), mode: "fallback-any-row", keys: [] };
+}
+function nextClickedMarks(prev, current, key, next, mods = {}) {
+  if (!next.length) return null;
+  if (!(mods.ctrl || mods.shift)) return { keys: [key], selection: next.slice() };
+  const held = prev && sameRowSet(prev.selection, current) ? prev.keys : [];
+  const keys = held.includes(key) ? held.filter((k) => k !== key) : [...held, key];
+  return { keys, selection: next.slice() };
+}
+function isInsideControl(target, container) {
+  let el = target;
+  if (el && el.nodeType !== 1) el = el.parentElement ?? el.parentNode ?? null;
+  while (el && el !== container) {
+    if (el.nodeType === 1 && el.classList?.contains?.(CONTROL_CLASS)) return true;
+    el = el.parentElement ?? el.parentNode ?? null;
+  }
+  return false;
+}
+function createMarkResolver(env) {
+  const { root, doc, log } = env;
+  const isElement = (t) => {
+    const E = doc?.defaultView?.Element ?? globalThis.Element;
+    if (E && t instanceof E) return true;
+    return !!t && typeof t.closest === "function" && typeof t.getAttribute === "function";
+  };
+  const viewStyle = (n) => {
+    try {
+      const gcs = doc?.defaultView?.getComputedStyle ?? (typeof getComputedStyle === "function" ? getComputedStyle : null);
+      return gcs ? gcs(n).pointerEvents : "";
+    } catch {
+      return "";
+    }
+  };
+  const isInvisibleStrokePath = (el) => {
+    if (el.tagName.toLowerCase() !== "path") return false;
+    const f2 = el.getAttribute("fill");
+    if (f2 !== null && f2 !== "" && f2 !== "none" && f2 !== "transparent") return false;
+    const s = (el.getAttribute("stroke") || "").trim().toLowerCase();
+    const so = parseFloat(el.getAttribute("stroke-opacity") || "1");
+    return s === "transparent" || s === "none" || so <= 0.01;
+  };
+  const distToPathCenterline = (el, x, y) => {
+    const L = el.getTotalLength();
+    if (!(L > 0)) return Number.MAX_VALUE;
+    const m = el.getScreenCTM();
+    if (!m) return Number.MAX_VALUE;
+    let best = Number.MAX_VALUE;
+    const N = 64;
+    for (let i = 0; i <= N; i++) {
+      const pt = el.getPointAtLength(L * i / N);
+      const dx = m.a * pt.x + m.c * pt.y + m.e - x;
+      const dy = m.b * pt.x + m.d * pt.y + m.f - y;
+      const d = dx * dx + dy * dy;
+      if (d < best) best = d;
+    }
+    return Math.sqrt(best);
+  };
+  const refineHitCorridor = (mark, x, y, sel) => {
+    try {
+      if (!mark || !isInvisibleStrokePath(mark) || !mark.getAttribute("data-row-idx")) return mark;
+      const stack = doc.elementsFromPoint(x, y);
+      const candidates = [];
+      for (const el of stack) {
+        if (!root.contains(el)) continue;
+        if (!el.matches || !el.matches(sel)) continue;
+        if (!el.getAttribute("data-row-idx")) continue;
+        if (!isInvisibleStrokePath(el)) continue;
+        candidates.push(el);
+      }
+      if (candidates.indexOf(mark) < 0) candidates.push(mark);
+      if (candidates.length < 2) return mark;
+      let best = mark;
+      let bestD = Number.MAX_VALUE;
+      for (const el of candidates) {
+        const d = distToPathCenterline(el, x, y);
+        if (d < bestD) {
+          bestD = d;
+          best = el;
+        }
+      }
+      if (best !== mark) {
+        log("d3-hit-corridor-refined", {
+          candidates: candidates.length,
+          distPx: Math.round(bestD),
+          fromRows: (mark.getAttribute("data-row-idx") || "").slice(0, 24),
+          toRows: (best.getAttribute("data-row-idx") || "").slice(0, 24)
+        });
+      }
+      return best;
+    } catch {
+      return mark;
+    }
+  };
+  const findMark = (target, sel = ".d3-mark", ev) => {
+    if (!isElement(target)) return null;
+    const el = target;
+    const m = el.closest(sel);
+    if (m && ev) return refineHitCorridor(m, ev.clientX, ev.clientY, sel);
+    return m;
+  };
+  const penetrateOverlayAt = (x, y, sel) => {
+    try {
+      const stack = doc.elementsFromPoint(x, y);
+      for (const el of stack) {
+        if (!root.contains(el) || !isElement(el)) continue;
+        const cand = el.matches(sel) ? el : el.closest(sel);
+        if (!cand || !root.contains(cand) || !cand.getAttribute("data-row-idx")) continue;
+        log("d3_click-overlay-penetrated", { tag: el.tagName, cls: el.getAttribute("class"), via: el === cand ? "self" : "closest" });
+        return cand;
+      }
+    } catch {
+    }
+    return null;
+  };
+  const resolveByGeometry = (x, y, sel) => {
+    try {
+      const cands = root.querySelectorAll(sel);
+      let best = null, bestArea = Number.MAX_VALUE;
+      if (cands.length <= 600) {
+        for (const el of Array.from(cands)) {
+          if (!el.getAttribute("data-row-idx")) continue;
+          const r = el.getBoundingClientRect ? el.getBoundingClientRect() : null;
+          if (!r || r.width <= 0 || r.height <= 0) continue;
+          if (x < r.left || x > r.right || y < r.top || y > r.bottom) continue;
+          const area2 = r.width * r.height;
+          if (area2 < bestArea) {
+            bestArea = area2;
+            best = el;
+          }
+        }
+      }
+      const hasHittableShape = (node) => {
+        const SHAPE = /^(rect|circle|ellipse|path|line|polygon|polyline|text|image|use)$/;
+        const all = [node, ...Array.from(node.querySelectorAll("*"))];
+        for (const n of all) {
+          const tag = (n.tagName || "").toLowerCase();
+          if (!SHAPE.test(tag)) continue;
+          const pe = viewStyle(n);
+          if (pe && pe !== "none") return true;
+        }
+        return false;
+      };
+      if (best && !hasHittableShape(best)) {
+        log("d3_click-geom-resolved", { rows: (best.getAttribute("data-row-idx") || "").slice(0, 24) });
+        return best;
+      } else if (best) {
+        log("d3_click-geom-skip-hittable", {});
+      }
+    } catch {
+    }
+    return null;
+  };
+  return { isInvisibleStrokePath, distToPathCenterline, refineHitCorridor, findMark, rowIdxsFromMark, penetrateOverlayAt, resolveByGeometry };
+}
+function collectD3GlyphCenters(container, baseRect, out) {
+  const Point = container.ownerDocument?.defaultView?.DOMPoint ?? globalThis.DOMPoint;
+  const marks = container.querySelectorAll(`.${MARK_CLASS}.${MARK_SELECTED_CLASS}`);
+  const rects = [];
+  for (let i = 0; i < marks.length; i++) {
+    const r = marks[i].getBoundingClientRect();
+    rects.push(r);
+  }
+  const CONTAINMENT_CAP = 300;
+  const EPS2 = 1;
+  const filterContainers = marks.length <= CONTAINMENT_CAP;
+  const enclosesAnother = (ci) => {
+    const c = rects[ci];
+    const cArea = c.width * c.height;
+    if (cArea <= 0) return false;
+    for (let mj = 0; mj < rects.length; mj++) {
+      if (mj === ci) continue;
+      const m = rects[mj];
+      const mArea = m.width * m.height;
+      if (mArea <= 0 || mArea >= cArea) continue;
+      if (m.left >= c.left - EPS2 && m.right <= c.right + EPS2 && m.top >= c.top - EPS2 && m.bottom <= c.bottom + EPS2) return true;
+    }
+    return false;
+  };
+  for (let i = 0; i < marks.length; i++) {
+    const el = marks[i];
+    const r = rects[i];
+    if (r.width === 0 && r.height === 0) continue;
+    if (filterContainers && enclosesAnother(i)) continue;
+    const tag = el.tagName.toLowerCase();
+    let sx;
+    let sy;
+    const cxA = el.getAttribute("data-cx"), cyA = el.getAttribute("data-cy");
+    if (cxA != null && cyA != null && typeof el.getScreenCTM === "function") {
+      const ctm = el.getScreenCTM();
+      const cxN = parseFloat(cxA), cyN = parseFloat(cyA);
+      if (ctm && isFinite(cxN) && isFinite(cyN)) {
+        const p = new Point(cxN, cyN).matrixTransform(ctm);
+        sx = p.x;
+        sy = p.y;
+      }
+    }
+    if (sx === void 0 && tag === "path" && typeof el.getPointAtLength === "function") {
+      try {
+        const len = el.getTotalLength();
+        const ctm = el.getScreenCTM();
+        if (len > 0 && ctm) {
+          const dAttr = el.getAttribute("d") || "";
+          const isArcSector = /[Aa]/.test(dAttr) && !/[CcSsQqTt]/.test(dAttr);
+          let local;
+          if (isArcSector) {
+            const N = 24;
+            let ax = 0, ay = 0;
+            for (let k = 0; k < N; k++) {
+              const sp = el.getPointAtLength(len * k / N);
+              ax += sp.x;
+              ay += sp.y;
+            }
+            const cand = new Point(ax / N, ay / N);
+            let inside = true;
+            try {
+              if (typeof el.isPointInFill === "function") {
+                inside = el.isPointInFill(cand);
+              }
+            } catch {
+              inside = true;
+            }
+            if (inside) local = cand;
+          }
+          if (!local) local = el.getPointAtLength(len / 2);
+          const p = local.matrixTransform(ctm);
+          sx = p.x;
+          sy = p.y;
+        }
+      } catch {
+      }
+    }
+    if (sx === void 0 || sy === void 0) {
+      const isRect = tag === "rect";
+      sx = isRect ? r.left + r.width * 0.8 : r.left + r.width / 2;
+      sy = isRect ? r.top + r.height * 0.2 : r.top + r.height / 2;
+    }
+    out.push({ x: sx - baseRect.left, y: sy - baseRect.top });
+  }
+}
+var SELECTION_GLYPH_CLASS = "lch-sel-glyph";
+function clearSelectionGlyphs(overlay) {
+  if (overlay) {
+    while (overlay.firstChild) overlay.removeChild(overlay.firstChild);
+  }
+}
+function paintSelectionGlyphs(overlay, centers, style) {
+  const doc = overlay.ownerDocument;
+  const frag = doc.createDocumentFragment();
+  const count = Math.min(centers.length, style.max ?? 600);
+  for (let i = 0; i < count; i++) {
+    const c = centers[i];
+    const g = doc.createElement("span");
+    g.className = SELECTION_GLYPH_CLASS;
+    g.textContent = style.symbol;
+    g.style.position = "absolute";
+    g.style.left = c.x + "px";
+    g.style.top = c.y + "px";
+    g.style.transform = "translate(-50%, -50%)";
+    g.style.font = "700 11px/1 system-ui, -apple-system, Segoe UI, sans-serif";
+    g.style.color = style.color;
+    const halo = style.halo;
+    g.style.textShadow = `-1px -1px 1px ${halo}, 1px -1px 1px ${halo}, -1px 1px 1px ${halo}, 1px 1px 1px ${halo}, 0 0 2px ${halo}`;
+    g.style.pointerEvents = "none";
+    frag.appendChild(g);
+  }
+  overlay.appendChild(frag);
+  return count;
+}
+
+// src/hitTargets.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var HIT_ATTR = "data-lch-hit";
+var ELEMENT_CAP2 = 5e3;
+var mapsPresentationAttributes = /* @__PURE__ */ new WeakMap();
+function engineMapsPresentationAttributes(ownerDoc, view) {
+  if (!ownerDoc || typeof ownerDoc !== "object") return false;
+  const known = mapsPresentationAttributes.get(ownerDoc);
+  if (known !== void 0) return known;
+  let maps = false;
+  try {
+    const host = ownerDoc.documentElement;
+    const probe = ownerDoc.createElementNS(SVG_NS, "svg");
+    const shape = ownerDoc.createElementNS(SVG_NS, "rect");
+    shape.setAttribute("fill", "none");
+    probe.appendChild(shape);
+    host.appendChild(probe);
+    try {
+      maps = String(view.getComputedStyle(shape).fill ?? "").trim().toLowerCase() === "none";
+    } finally {
+      host.removeChild(probe);
+    }
+  } catch {
+    maps = false;
+  }
+  mapsPresentationAttributes.set(ownerDoc, maps);
+  return maps;
+}
+function ensureCrossfilterHitTargets(container, doc) {
+  const report = { tagged: 0, hitRects: 0, peFlips: 0, peStrokeOnly: 0 };
+  try {
+    if (!container || typeof container.querySelectorAll !== "function") return report;
+    const els = container.querySelectorAll(
+      `.${MARK_CLASS}, .${LEGEND_MARK_CLASS}, .${AXIS_FILTER_CLASS}`
+    );
+    report.tagged = els.length;
+    if (els.length === 0 || els.length > ELEMENT_CAP2) return report;
+    const ownerDoc = doc ?? container.ownerDocument;
+    const view = ownerDoc?.defaultView;
+    const computed = (el) => {
+      try {
+        return view?.getComputedStyle ? view.getComputedStyle(el) : null;
+      } catch {
+        return null;
+      }
+    };
+    for (const el of Array.from(els)) {
+      const tag = String(el.tagName || "").toLowerCase();
+      if (tag === "g") {
+        if (!el.hasAttribute?.(ROW_IDX_ATTR)) continue;
+        if (el.querySelector?.(`rect[${HIT_ATTR}="1"]`)) continue;
+        const cls = el.getAttribute?.("class") || "";
+        const isFurniture = cls.indexOf(LEGEND_MARK_CLASS) >= 0 || cls.indexOf(AXIS_FILTER_CLASS) >= 0;
+        if (!isFurniture) {
+          let hasHittableChild = false;
+          const kids = el.querySelectorAll?.("*") ?? [];
+          for (const kid of Array.from(kids)) {
+            const ktag = String(kid.tagName || "").toLowerCase();
+            if (ktag === "g" || ktag === "tspan" || ktag === "title" || ktag === "defs") continue;
+            const cs = computed(kid);
+            if (!cs || cs.pointerEvents !== "none") {
+              hasHittableChild = true;
+              break;
+            }
+          }
+          if (hasHittableChild) continue;
+        }
+        let bb = null;
+        try {
+          bb = el.getBBox?.();
+        } catch {
+          bb = null;
+        }
+        if (!bb || !(bb.width > 0) || !(bb.height > 0)) continue;
+        const rect = ownerDoc.createElementNS(SVG_NS, "rect");
+        rect.setAttribute("x", String(bb.x));
+        rect.setAttribute("y", String(bb.y));
+        rect.setAttribute("width", String(bb.width));
+        rect.setAttribute("height", String(bb.height));
+        rect.setAttribute("fill", "transparent");
+        rect.setAttribute(HIT_ATTR, "1");
+        if (rect.style) {
+          rect.style.pointerEvents = "all";
+          rect.style.cursor = "pointer";
+        }
+        el.insertBefore(rect, el.firstChild);
+        report.hitRects++;
+      } else {
+        const cs = computed(el);
+        if (cs && cs.pointerEvents === "none") {
+          const fill = String((engineMapsPresentationAttributes(ownerDoc, view) ? cs.fill : el.getAttribute?.("fill") ?? cs.fill) ?? "").trim().toLowerCase();
+          const unfilled = fill === "none" || fill === "transparent" || fill === "rgba(0, 0, 0, 0)";
+          if (el.style) el.style.pointerEvents = unfilled ? "stroke" : "all";
+          report.peFlips++;
+          if (unfilled) report.peStrokeOnly++;
+        }
+      }
+    }
+  } catch {
+  }
+  return report;
+}
+
+// src/blankRender.ts
+var EMPTY2 = { markCount: 0, legendMarkCount: 0, containerKind: "empty", declaresNoRowMarks: false };
+function censusMarks(container) {
+  if (!container || typeof container.querySelectorAll !== "function") return EMPTY2;
+  try {
+    const marks = /* @__PURE__ */ new Set();
+    for (const el of Array.from(container.querySelectorAll(`.${MARK_CLASS}`))) marks.add(el);
+    for (const el of Array.from(container.querySelectorAll(`[${ROW_IDX_ATTR}]`))) marks.add(el);
+    const legend = /* @__PURE__ */ new Set();
+    for (const el of Array.from(container.querySelectorAll(`.${LEGEND_MARK_CLASS}`))) {
+      legend.add(el);
+      marks.delete(el);
+    }
+    const hasSvg = !!container.querySelector("svg");
+    const hasAnything = hasSvg || (container.childElementCount ?? 0) > 0;
+    return {
+      markCount: marks.size,
+      legendMarkCount: legend.size,
+      containerKind: hasSvg ? "svg" : hasAnything ? "html" : "empty",
+      declaresNoRowMarks: !!container.querySelector(`[${NO_ROW_MARKS_ATTR}]`)
+    };
+  } catch {
+    return EMPTY2;
+  }
+}
+function isBlankRender(i) {
+  if (i.contractUntagged) return false;
+  if (i.declaresNoRowMarks) return false;
+  if (i.animated) return false;
+  if (i.authoredNoDataText) return false;
+  if (!(i.rows > 0)) return false;
+  return i.markCount === 0;
+}
+function blankRenderFlag(lang, cause) {
+  const clean = (s) => String(s || "unknown").toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+  return `blankrender:${clean(lang)}:${clean(cause)}`;
+}
+
+// src/hitBands.ts
+var MIN_HIT_BAND_PX = 8;
+var ELEMENT_CAP3 = 5e3;
+var EMPTY3 = {
+  openStrokes: 0,
+  interactive: 0,
+  hairline: 0,
+  uncovered: 0,
+  widestPx: 0
+};
+var OPEN_TAGS = /* @__PURE__ */ new Set(["path", "line", "polyline"]);
+function styleOf2(el, doc) {
+  try {
+    const view = doc?.defaultView;
+    return view?.getComputedStyle ? view.getComputedStyle(el) : null;
+  } catch {
+    return null;
+  }
+}
+function attrOrComputed(el, name, cs) {
+  const a = el.getAttribute?.(name);
+  if (a !== null && a !== void 0 && String(a).trim() !== "") return String(a).trim();
+  const c = cs?.[name === "stroke-width" ? "strokeWidth" : name];
+  return c === null || c === void 0 ? "" : String(c).trim();
+}
+function isUnfilled(fill) {
+  const f2 = fill.toLowerCase();
+  return f2 === "none" || f2 === "transparent" || f2 === "rgba(0, 0, 0, 0)" || f2 === "rgba(0,0,0,0)";
+}
+function widthPx(raw) {
+  const m = /^(-?\d+(?:\.\d+)?)\s*(px)?$/i.exec(raw);
+  if (!m) return NaN;
+  const n = parseFloat(m[1]);
+  return isFinite(n) ? n : NaN;
+}
+function censusHitBands(container, doc) {
+  if (!container || typeof container.querySelectorAll !== "function") return EMPTY3;
+  try {
+    const els = Array.from(
+      container.querySelectorAll(`.${MARK_CLASS}, [${ROW_IDX_ATTR}]`)
+    );
+    if (els.length === 0 || els.length > ELEMENT_CAP3) return EMPTY3;
+    const ownerDoc = doc ?? container.ownerDocument;
+    const widestByGeom = /* @__PURE__ */ new Map();
+    const rows = [];
+    for (const el of els) {
+      const tag = String(el.tagName || "").toLowerCase();
+      if (!OPEN_TAGS.has(tag)) continue;
+      const cs = styleOf2(el, ownerDoc);
+      const open = isUnfilled(attrOrComputed(el, "fill", cs));
+      const w = widthPx(attrOrComputed(el, "stroke-width", cs) || "1");
+      const geom = String(el.getAttribute?.("d") ?? "") || `${tag}#${String(el.getAttribute?.(ROW_IDX_ATTR) ?? "")}`;
+      const inert = String(cs?.pointerEvents ?? el.style?.pointerEvents ?? "") === "none";
+      rows.push({ el, geom, w, open, inert });
+      if (isFinite(w)) {
+        const prev = widestByGeom.get(geom);
+        if (prev === void 0 || w > prev) widestByGeom.set(geom, w);
+      }
+    }
+    const out = { ...EMPTY3 };
+    for (const r of rows) {
+      if (!r.open) continue;
+      out.openStrokes++;
+      if (r.inert) continue;
+      out.interactive++;
+      if (isFinite(r.w) && r.w > out.widestPx) out.widestPx = Math.round(r.w);
+      if (!(r.w < MIN_HIT_BAND_PX)) continue;
+      out.hairline++;
+      const best = widestByGeom.get(r.geom);
+      if (best === void 0 || best < MIN_HIT_BAND_PX) out.uncovered++;
+    }
+    return out;
+  } catch {
+    return EMPTY3;
+  }
+}
+function hitBandFlag(c) {
+  if (c.interactive === 0) return "";
+  return c.uncovered > 0 ? "hitband:d3:thin" : "hitband:d3:ok";
+}
+
+// src/clippedText.ts
+var CLIP_TOLERANCE_PX = 1;
+var MAX_REPORTED = 8;
+function censusClippedText(container) {
+  const none = { measured: 0, clipped: [], clippedCount: 0, laidOut: false };
+  try {
+    const svg = container?.querySelector?.("svg");
+    if (!svg) return none;
+    const f2 = svg.getBoundingClientRect();
+    if (!f2 || !(f2.width > 0) || !(f2.height > 0)) return none;
+    const view = svg.ownerDocument?.defaultView;
+    const clipped = [];
+    let measured = 0;
+    for (const t of Array.from(svg.querySelectorAll("text"))) {
+      const r = t.getBoundingClientRect();
+      if (!r || !(r.width > 0) || !(r.height > 0)) continue;
+      const s = view?.getComputedStyle?.(t);
+      if (s && (s.display === "none" || s.visibility === "hidden" || s.opacity === "0")) continue;
+      measured++;
+      const top = f2.top - r.top, left = f2.left - r.left, bottom = r.bottom - f2.bottom, right = r.right - f2.right;
+      if (top > CLIP_TOLERANCE_PX || left > CLIP_TOLERANCE_PX || bottom > CLIP_TOLERANCE_PX || right > CLIP_TOLERANCE_PX) {
+        clipped.push({
+          text: String(t.textContent ?? "").slice(0, 40),
+          top: Math.max(0, Math.round(top)),
+          left: Math.max(0, Math.round(left)),
+          bottom: Math.max(0, Math.round(bottom)),
+          right: Math.max(0, Math.round(right))
+        });
+      }
+    }
+    clipped.sort((a, b) => Math.max(b.top, b.left, b.bottom, b.right) - Math.max(a.top, a.left, a.bottom, a.right));
+    return { measured, clipped: clipped.slice(0, MAX_REPORTED), clippedCount: clipped.length, laidOut: true };
+  } catch {
+    return none;
+  }
+}
+function clippedTextFlag(c) {
+  if (!c.laidOut || c.clippedCount === 0) return "";
+  const worst = c.clipped[0];
+  const side = ["top", "left", "bottom", "right"].reduce((a, k) => worst[k] > worst[a] ? k : a, "top");
+  return `${c.clippedCount} of ${c.measured} text label(s) are cut off by the frame; the worst, "${worst.text}", by ${worst[side]}px at the ${side}.`;
+}
+
+// src/valuePlacement.ts
+var MIN_MARKS2 = 24;
+var ELEMENT_CAP4 = 5e3;
+var FIT_SAMPLE = 90;
+var VALUE_AXIS_MIN_FIT = 0.8;
+var MIN_AXIS_SPAN_PX = 40;
+var EMPTY4 = { marks: 0, axis: "", column: "", fit: 0, offShare: 0, medianOffRadii: 0 };
+function num(el, name) {
+  const v = el.getAttribute?.(name);
+  if (v === null || v === void 0 || String(v).trim() === "") return NaN;
+  return parseFloat(String(v));
+}
+function median(xs) {
+  if (!xs.length) return NaN;
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function robustLine(v, pos) {
+  const n = v.length;
+  const step = Math.max(1, Math.floor(n / FIT_SAMPLE));
+  const idx = [];
+  for (let i = 0; i < n; i += step) idx.push(i);
+  const slopes = [];
+  for (let p = 0; p < idx.length; p++) {
+    for (let q = p + 1; q < idx.length; q++) {
+      const dv = v[idx[q]] - v[idx[p]];
+      if (Math.abs(dv) < 1e-12) continue;
+      slopes.push((pos[idx[q]] - pos[idx[p]]) / dv);
+    }
+  }
+  if (slopes.length < 3) return null;
+  const b = median(slopes);
+  if (!Number.isFinite(b) || Math.abs(b) < 1e-12) return null;
+  const a = median(pos.map((y, i) => y - b * v[i]));
+  return Number.isFinite(a) ? { a, b } : null;
+}
+function censusValuePlacement(container, data) {
+  try {
+    if (!container || typeof container.querySelectorAll !== "function") return EMPTY4;
+    const rows = data?.rows;
+    const columns = data?.columns ?? [];
+    if (!Array.isArray(rows) || !rows.length || !columns.length) return EMPTY4;
+    const els = Array.from(container.querySelectorAll(`circle[${ROW_IDX_ATTR}]`));
+    if (els.length < MIN_MARKS2 || els.length > ELEMENT_CAP4) return EMPTY4;
+    const dots = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const el of els) {
+      const raw = String(el.getAttribute(ROW_IDX_ATTR) ?? "").trim();
+      if (!/^\d+$/.test(raw)) continue;
+      const i = +raw;
+      const row = rows[i];
+      const x = num(el, "cx"), y = num(el, "cy"), r = num(el, "r");
+      if (!row || !Number.isFinite(x) || !Number.isFinite(y) || !(r > 0)) continue;
+      seen.add(i);
+      dots.push({ row, x, y, r });
+    }
+    if (dots.length < MIN_MARKS2 || seen.size < dots.length * 0.9) return EMPTY4;
+    let best = null;
+    for (let c = 0; c < columns.length; c++) {
+      if (/^__.*__$/.test(String(columns[c]?.name ?? ""))) continue;
+      const vals = dots.map((d) => {
+        const v = d.row[c];
+        return v === null || v === void 0 || v === "" ? NaN : typeof v === "number" ? v : Number(v);
+      });
+      const finite = vals.filter(Number.isFinite);
+      if (finite.length < dots.length * 0.9 || new Set(finite).size < 8) continue;
+      const logs = finite.every((v) => v > 0) ? [false, true] : [false];
+      for (const log of logs) {
+        for (const axis of ["x", "y"]) {
+          const keep = [];
+          const v = [], pos = [];
+          dots.forEach((d, k) => {
+            if (!Number.isFinite(vals[k])) return;
+            keep.push(k);
+            v.push(log ? Math.log10(vals[k]) : vals[k]);
+            pos.push(axis === "x" ? d.x : d.y);
+          });
+          const line = robustLine(v, pos);
+          if (!line) continue;
+          const lo = Math.min(...pos), hi = Math.max(...pos);
+          if (hi - lo < MIN_AXIS_SPAN_PX) continue;
+          const mean = pos.reduce((s, p) => s + p, 0) / pos.length;
+          let ssRes = 0, ssTot = 0;
+          const res = pos.map((p, k) => {
+            const e = p - (line.a + line.b * v[k]);
+            ssRes += e * e;
+            ssTot += (p - mean) ** 2;
+            return e;
+          });
+          if (ssTot <= 0) continue;
+          const fit = 1 - ssRes / ssTot;
+          if (fit >= VALUE_AXIS_MIN_FIT && (!best || fit > best.fit)) {
+            const full = new Array(dots.length).fill(NaN);
+            keep.forEach((k, j) => {
+              full[k] = res[j];
+            });
+            best = { col: c, axis, fit, res: full, log };
+          }
+        }
+      }
+    }
+    if (!best) return EMPTY4;
+    let off = 0, measured = 0;
+    const radii = [];
+    dots.forEach((d, k) => {
+      const e = best.res[k];
+      if (!Number.isFinite(e)) return;
+      measured++;
+      const inRadii = Math.abs(e) / Math.max(d.r, 1);
+      radii.push(inRadii);
+      if (inRadii > 1) off++;
+    });
+    if (measured < MIN_MARKS2) return EMPTY4;
+    return {
+      marks: measured,
+      axis: best.axis,
+      column: String(columns[best.col]?.name ?? ""),
+      fit: Math.round(best.fit * 1e3) / 1e3,
+      offShare: Math.round(off / measured * 1e3) / 10,
+      medianOffRadii: Math.round(median(radii) * 100) / 100
+    };
+  } catch {
+    return EMPTY4;
+  }
+}
+function valuePlacementFlag(c) {
+  if (c.marks === 0) return "";
+  const s = c.offShare;
+  const bucket = s <= 0 ? 0 : s < 5 ? 1 : s < 20 ? 5 : s < 50 ? 20 : 50;
+  return "place:d3:off" + bucket;
+}
+
+// src/fit.ts
+var SCROLL_SLACK_PX = 8;
+function needsScroll(contentPx, viewportPx, slackPx = SCROLL_SLACK_PX) {
+  if (!isFinite(contentPx) || !isFinite(viewportPx)) return false;
+  if (contentPx <= 0 || viewportPx <= 0) return false;
+  return contentPx - viewportPx > slackPx;
+}
+function contentExtentOf(boxes) {
+  if (!boxes || boxes.length === 0) return { w: 0, h: 0, source: "none" };
+  const usable = boxes.filter((b) => b && isFinite(b.right) && isFinite(b.bottom) && (b.right > 0 || b.bottom > 0));
+  if (usable.length === 0) return { w: 0, h: 0, source: "none" };
+  const inFlow = usable.filter((b) => !b.floating);
+  const counted = inFlow.length > 0 ? inFlow : usable;
+  let w = 0, h = 0;
+  for (const b of counted) {
+    if (b.right > w) w = b.right;
+    if (b.bottom > h) h = b.bottom;
+  }
+  return { w, h, source: inFlow.length > 0 ? "in-flow" : "all-floating" };
+}
+function scrollFitFor(contentW, contentH, viewportW, viewportH, slackPx = SCROLL_SLACK_PX) {
+  return {
+    overflowX: needsScroll(contentW, viewportW, slackPx) ? "auto" : "hidden",
+    overflowY: needsScroll(contentH, viewportH, slackPx) ? "auto" : "hidden"
+  };
+}
+var FIT_CONTENT_SELECTOR = "text, .d3-mark, .d3-legend-mark";
+var PHANTOM_FRACTION = 0.95;
+function isPhantomBox(w, h, refW, refH) {
+  return w > refW * PHANTOM_FRACTION || h > refH * PHANTOM_FRACTION;
+}
+var MAX_FRAME_GROW_FACTOR = 20;
+function planFrameGrow(inkBottomPx, elHeightPx, viewBoxH, ctmScale, slackPx = SCROLL_SLACK_PX, maxFactor = MAX_FRAME_GROW_FACTOR) {
+  const none = (reason) => ({ grow: false, heightPx: elHeightPx, viewBoxH, reason });
+  if (!isFinite(inkBottomPx) || !isFinite(elHeightPx) || elHeightPx <= 0) return none("unmeasurable");
+  if (!needsScroll(inkBottomPx, elHeightPx, slackPx)) return none("fits");
+  if (inkBottomPx > elHeightPx * maxFactor) return none("beyond-ceiling");
+  const heightPx = Math.ceil(inkBottomPx);
+  const delta = heightPx - elHeightPx;
+  if (!(viewBoxH > 0)) return { grow: true, heightPx, viewBoxH, reason: "grow-no-viewbox" };
+  if (!(ctmScale > 0) || !isFinite(ctmScale)) return none("no-scale");
+  return { grow: true, heightPx, viewBoxH: viewBoxH + delta / ctmScale, reason: "grow" };
+}
+var AXIS_PIN_MIN_LABELS = 2;
+var AXIS_PIN_BAND_PAD_PX = 2;
+var AXIS_PIN_MAX_BAND_FRACTION = 0.4;
+var AXIS_PIN_TRACK_REACH_PX = 12;
+function isHorizontalLabelRow(boxes) {
+  if (!boxes || boxes.length < 2) return false;
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (const b of boxes) {
+    const cx = (b.left + b.right) / 2, cy = (b.top + b.bottom) / 2;
+    if (!isFinite(cx) || !isFinite(cy)) return false;
+    if (cx < minX) minX = cx;
+    if (cx > maxX) maxX = cx;
+    if (cy < minY) minY = cy;
+    if (cy > maxY) maxY = cy;
+  }
+  return maxX - minX > maxY - minY;
+}
+function labelBand(boxes, tracks = [], pad = AXIS_PIN_BAND_PAD_PX, trackReach = AXIS_PIN_TRACK_REACH_PX) {
+  if (!boxes || boxes.length === 0) return null;
+  let top = Infinity, bottom = -Infinity;
+  for (const b of boxes) {
+    if (!isFinite(b.top) || !isFinite(b.bottom)) continue;
+    if (b.top < top) top = b.top;
+    if (b.bottom > bottom) bottom = b.bottom;
+  }
+  if (!isFinite(top) || !isFinite(bottom) || bottom <= top) return null;
+  for (const t of tracks || []) {
+    if (!isFinite(t.top) || !isFinite(t.bottom)) continue;
+    const gap = t.bottom < top ? top - t.bottom : t.top > bottom ? t.top - bottom : 0;
+    if (gap > trackReach) continue;
+    if (t.top < top) top = t.top;
+    if (t.bottom > bottom) bottom = t.bottom;
+  }
+  return { top: top - pad, bottom: bottom + pad };
+}
+function planAxisPin(candidates, viewportH, minLabels = AXIS_PIN_MIN_LABELS, maxFraction = AXIS_PIN_MAX_BAND_FRACTION) {
+  const none = (reason) => ({ pin: false, index: -1, band: null, reason });
+  if (!isFinite(viewportH) || viewportH <= 0) return none("unmeasurable");
+  let sawAxis = false, best = null;
+  for (const c of candidates || []) {
+    if (!c || !c.labels || c.labels.length < minLabels) continue;
+    sawAxis = true;
+    if (!isHorizontalLabelRow(c.labels)) continue;
+    if (!best || c.labels.length > best.labels.length) best = c;
+  }
+  if (!best) return none(sawAxis ? "vertical-only" : "no-axis");
+  const band = labelBand(best.labels, best.tracks || []);
+  if (!band) return none("unmeasurable");
+  if (band.bottom - band.top > viewportH * maxFraction) return none("band-too-tall");
+  return { pin: true, index: best.index, band, reason: "pinned" };
+}
+function axisPinPlacement(band, scrollTop, viewportH) {
+  if (!band || !isFinite(band.top) || !isFinite(band.bottom)) return null;
+  if (!isFinite(scrollTop) || !isFinite(viewportH) || viewportH <= 0) return null;
+  if (band.top < scrollTop) return "top";
+  if (band.bottom > scrollTop + viewportH) return "bottom";
+  return null;
+}
+
+// src/fitDom.ts
+var FIT_WALK_CAP = 8e3;
+function ctmScaleOf(m) {
+  if (!m) return 0;
+  const s = Math.hypot(m.a, m.b);
+  return isFinite(s) && s > 0 ? s : 0;
+}
+function svgInkReach(svg) {
+  try {
+    const box2 = svg.getBoundingClientRect();
+    if (!(box2.width > 0) || !(box2.height > 0)) return null;
+    const els = svg.querySelectorAll(FIT_CONTENT_SELECTOR);
+    const clipOf = clipWindowReader(svg);
+    let right = -Infinity, bottom = -Infinity, seen = 0;
+    for (let i = 0; i < els.length && seen < FIT_WALK_CAP; i++) {
+      const r = els[i].getBoundingClientRect();
+      if (r.width <= 0 && r.height <= 0) continue;
+      if (isPhantomBox(r.width, r.height, box2.width, box2.height)) continue;
+      let rr = r.right, rb = r.bottom;
+      const clip = clipOf(els[i]);
+      if (clip) {
+        if (r.left >= clip.right || r.top >= clip.bottom) continue;
+        rr = Math.min(rr, clip.right);
+        rb = Math.min(rb, clip.bottom);
+      }
+      seen++;
+      if (rr > right) right = rr;
+      if (rb > bottom) bottom = rb;
+    }
+    if (seen === 0) return null;
+    return { right: right - box2.left, bottom: bottom - box2.top };
+  } catch {
+    return null;
+  }
+}
+function clipWindowOf(el) {
+  try {
+    const m = /url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(el.getAttribute("clip-path") || "");
+    const cp = m ? (el.closest("svg") ?? el.ownerDocument).querySelector(`clipPath[id="${m[1].replace(/"/g, '\\"')}"]`) : null;
+    const ctm = cp ? el.getScreenCTM?.() : null;
+    if (!cp || !ctm || cp.getAttribute("clipPathUnits") === "objectBoundingBox") return null;
+    let l = Infinity, t = Infinity, r = -Infinity, b = -Infinity;
+    for (let i = 0; i < cp.children.length; i++) {
+      const bb = cp.children[i].getBBox?.();
+      if (!bb || !(bb.width > 0) || !(bb.height > 0)) continue;
+      for (const [x, y] of [[bb.x, bb.y], [bb.x + bb.width, bb.y], [bb.x, bb.y + bb.height], [bb.x + bb.width, bb.y + bb.height]]) {
+        const sx = ctm.a * x + ctm.c * y + ctm.e, sy = ctm.b * x + ctm.d * y + ctm.f;
+        l = Math.min(l, sx);
+        t = Math.min(t, sy);
+        r = Math.max(r, sx);
+        b = Math.max(b, sy);
+      }
+    }
+    return isFinite(r) && isFinite(b) ? { left: l, top: t, right: r, bottom: b } : null;
+  } catch {
+    return null;
+  }
+}
+function clipWindowReader(svg) {
+  const own = /* @__PURE__ */ new Map();
+  const windowOf = (el) => {
+    if (!own.has(el)) own.set(el, clipWindowOf(el));
+    return own.get(el);
+  };
+  return (el) => {
+    let acc = null;
+    for (let a = el; a && a !== svg; a = a.parentElement) {
+      const w = windowOf(a);
+      if (w) acc = acc ? { right: Math.min(acc.right, w.right), bottom: Math.min(acc.bottom, w.bottom) } : w;
+    }
+    return acc;
+  };
+}
+function measureContainerBoxes(c, inkOf) {
+  const boxes = [];
+  if (!c || !c.children) return boxes;
+  const view = c.ownerDocument && c.ownerDocument.defaultView || globalThis;
+  const cRect = c.getBoundingClientRect();
+  for (let i = 0; i < c.children.length; i++) {
+    const el = c.children[i];
+    let floating = false;
+    try {
+      const cs = view.getComputedStyle(el);
+      if (cs.display === "none") continue;
+      floating = cs.position === "absolute" || cs.position === "fixed";
+    } catch {
+    }
+    const r = el.getBoundingClientRect();
+    let right = r.right - cRect.left - c.clientLeft + c.scrollLeft;
+    let bottom = r.bottom - cRect.top - c.clientTop + c.scrollTop;
+    if (inkOf) {
+      try {
+        const ink = inkOf(el);
+        if (ink) {
+          const originX = r.left - cRect.left - c.clientLeft + c.scrollLeft;
+          const originY = r.top - cRect.top - c.clientTop + c.scrollTop;
+          if (isFinite(ink.right)) right = Math.max(right, originX + ink.right);
+          if (isFinite(ink.bottom)) bottom = Math.max(bottom, originY + ink.bottom);
+        }
+      } catch {
+      }
+    }
+    boxes.push({ right, bottom, floating });
+  }
+  return boxes;
+}
+function fitReadingFor(lane, c, slackPx = SCROLL_SLACK_PX, inkOf) {
+  if (!c) return null;
+  const viewW = c.clientWidth, viewH = c.clientHeight;
+  if (!(viewW > 0) || !(viewH > 0)) return null;
+  const boxes = measureContainerBoxes(c, inkOf);
+  const extent = contentExtentOf(boxes);
+  const contentW = extent.source === "none" ? c.scrollWidth : extent.w;
+  const contentH = extent.source === "none" ? c.scrollHeight : extent.h;
+  if (!isFinite(contentW) || !isFinite(contentH)) return null;
+  return {
+    lane,
+    contentW: Math.round(contentW),
+    contentH: Math.round(contentH),
+    viewW,
+    viewH,
+    overflowsX: needsScroll(contentW, viewW, slackPx),
+    overflowsY: needsScroll(contentH, viewH, slackPx),
+    extentSource: extent.source,
+    boxes: boxes.length,
+    floating: boxes.filter((b) => b.floating).length,
+    scrollW: c.scrollWidth,
+    scrollH: c.scrollHeight
+  };
+}
+var noPin = (reason) => ({ pinned: false, reason, bandPx: 0, axisAt: "", labels: 0, carried: 0, edge: null });
+var CONTAINER_SLOT_AXIS_PIN = "__bicAxisPin";
+var SVG_NS2 = "http://www.w3.org/2000/svg";
+var AXIS_PIN_MAX_CARRIED = 12;
+function unpinScrolledAxis(container) {
+  if (!container) return;
+  const st = container[CONTAINER_SLOT_AXIS_PIN];
+  if (!st) return;
+  try {
+    container.removeEventListener("scroll", st.onScroll);
+  } catch {
+  }
+  try {
+    if (st.overlay.parentNode) st.overlay.parentNode.removeChild(st.overlay);
+  } catch {
+  }
+  try {
+    delete container[CONTAINER_SLOT_AXIS_PIN];
+  } catch {
+  }
+}
+function textHidden(t, view) {
+  if (t.getAttribute("display") === "none" || t.getAttribute("visibility") === "hidden") return true;
+  try {
+    const cs = view.getComputedStyle(t);
+    if (cs && (cs.display === "none" || cs.visibility === "hidden")) return true;
+  } catch {
+  }
+  return false;
+}
+function backdropFill(svg, container, view, svgBox) {
+  try {
+    const rects = svg.querySelectorAll("rect");
+    for (let i = 0; i < rects.length && i < 6; i++) {
+      const r = rects[i];
+      if (r.closest(".d3-mark")) continue;
+      const b = r.getBoundingClientRect();
+      if (b.width >= svgBox.width * 0.9 && b.height >= svgBox.height * 0.9) {
+        let fill = "";
+        try {
+          fill = view.getComputedStyle(r).fill || "";
+        } catch {
+        }
+        if (!fill || fill === "none") fill = r.getAttribute("fill") || "";
+        if (fill && fill !== "none" && fill !== "transparent") return fill;
+        break;
+      }
+    }
+  } catch {
+  }
+  try {
+    let el = container;
+    for (let hops = 0; el && hops < 12; hops++, el = el.parentElement) {
+      const bg = view.getComputedStyle(el).backgroundColor;
+      if (bg && bg !== "transparent" && bg !== "rgba(0, 0, 0, 0)") return bg;
+    }
+  } catch {
+  }
+  return "#ffffff";
+}
+function cloneWithChain(el, svg, root) {
+  const chain = [];
+  let n = el.parentElement;
+  while (n && n !== svg) {
+    chain.unshift(n);
+    n = n.parentElement;
+  }
+  let parent = root;
+  for (const anc of chain) {
+    const c = anc.cloneNode(false);
+    parent.appendChild(c);
+    parent = c;
+  }
+  parent.appendChild(el.cloneNode(true));
+  const ids = root.querySelectorAll("[id]");
+  for (let i = 0; i < ids.length; i++) ids[i].removeAttribute("id");
+}
+function pinScrolledAxis(container, svg) {
+  unpinScrolledAxis(container);
+  if (!container) return noPin("no-container");
+  if (!svg) return noPin("no-svg");
+  try {
+    const doc = svg.ownerDocument;
+    const view = doc && doc.defaultView || globalThis;
+    const svgBox = svg.getBoundingClientRect();
+    if (!(svgBox.width > 0) || !(svgBox.height > 0)) return noPin("unmeasurable");
+    const m = typeof svg.getScreenCTM === "function" ? svg.getScreenCTM() : null;
+    if (!m || !(m.a > 0) || !(m.d > 0) || !isFinite(m.e) || !isFinite(m.f)) return noPin("no-ctm");
+    const viewportH = container.clientHeight;
+    if (!(viewportH > 0)) return noPin("unmeasurable");
+    const rel = (r) => ({ left: r.left - svgBox.left, top: r.top - svgBox.top, right: r.right - svgBox.left, bottom: r.bottom - svgBox.top });
+    const ticks = svg.querySelectorAll(".tick");
+    const byAxis = /* @__PURE__ */ new Map();
+    for (let i = 0; i < ticks.length; i++) {
+      const t = ticks[i];
+      if (t.closest("svg") !== svg) continue;
+      const p = t.parentElement;
+      if (!p) continue;
+      const list = byAxis.get(p);
+      if (list) list.push(t);
+      else byAxis.set(p, [t]);
+    }
+    const axes = [];
+    const cands = [];
+    byAxis.forEach((group, axis2) => {
+      const labels = [];
+      for (const tick of group) {
+        const txt = tick.querySelector("text");
+        if (!txt || textHidden(txt, view)) continue;
+        const r = txt.getBoundingClientRect();
+        if (!(r.width > 0) || !(r.height > 0)) continue;
+        labels.push(rel(r));
+      }
+      const tracks = [];
+      for (let i = 0; i < axis2.children.length; i++) {
+        const ch = axis2.children[i];
+        if (ch.tagName.toLowerCase() !== "path" || !(ch.getAttribute("class") || "").split(/\s+/).includes("domain")) continue;
+        const r = ch.getBoundingClientRect();
+        if (r.width > 0 && r.height <= 4) tracks.push(rel(r));
+      }
+      cands.push({ index: axes.length, labels, tracks });
+      axes.push(axis2);
+    });
+    const plan = planAxisPin(cands, viewportH);
+    if (!plan.pin || !plan.band) return noPin(plan.reason);
+    const axis = axes[plan.index];
+    const band = { top: Math.max(0, plan.band.top), bottom: Math.min(svgBox.height, plan.band.bottom) };
+    const bandPx = band.bottom - band.top;
+    if (!(bandPx > 0)) return noPin("unmeasurable");
+    const carried = [];
+    const texts = svg.querySelectorAll("text");
+    for (let i = 0; i < texts.length && carried.length < AXIS_PIN_MAX_CARRIED; i++) {
+      const t = texts[i];
+      if (t.closest("svg") !== svg) continue;
+      if (t.closest(".tick") || t.closest(".d3-mark") || t.closest(".d3-legend-mark")) continue;
+      if (axis.contains(t) || textHidden(t, view)) continue;
+      const r = rel(t.getBoundingClientRect());
+      if (!(r.right > r.left) || !(r.bottom > r.top)) continue;
+      if (r.top >= band.top && r.bottom <= band.bottom) carried.push(t);
+    }
+    const pinSvg = doc.createElementNS(SVG_NS2, "svg");
+    for (const a of ["font-family", "font-size", "font-weight", "font", "fill", "color", "text-rendering"]) {
+      const v = svg.getAttribute(a);
+      if (v) pinSvg.setAttribute(a, v);
+    }
+    const styles = svg.querySelectorAll("style");
+    for (let i = 0; i < styles.length; i++) pinSvg.appendChild(styles[i].cloneNode(true));
+    const vbX = (svgBox.left - m.e) / m.a, vbY = (svgBox.top + band.top - m.f) / m.d;
+    const vbW = svgBox.width / m.a, vbH = bandPx / m.d;
+    pinSvg.setAttribute("viewBox", `${vbX} ${vbY} ${vbW} ${vbH}`);
+    pinSvg.setAttribute("preserveAspectRatio", "none");
+    pinSvg.setAttribute("width", String(svgBox.width));
+    pinSvg.setAttribute("height", String(bandPx));
+    pinSvg.setAttribute("aria-hidden", "true");
+    pinSvg.style.display = "block";
+    pinSvg.style.pointerEvents = "none";
+    const back = doc.createElementNS(SVG_NS2, "rect");
+    back.setAttribute("x", String(vbX));
+    back.setAttribute("y", String(vbY));
+    back.setAttribute("width", String(vbW));
+    back.setAttribute("height", String(vbH));
+    back.setAttribute("fill", backdropFill(svg, container, view, svgBox));
+    pinSvg.appendChild(back);
+    cloneWithChain(axis, svg, pinSvg);
+    for (const t of carried) cloneWithChain(t, svg, pinSvg);
+    const overlay = doc.createElement("div");
+    overlay.setAttribute("data-bic-axis-pin", "1");
+    const o = overlay.style;
+    o.position = "absolute";
+    o.margin = "0";
+    o.padding = "0";
+    o.border = "0";
+    o.width = `${svgBox.width}px`;
+    o.height = `${bandPx}px`;
+    o.overflow = "hidden";
+    o.pointerEvents = "none";
+    o.zIndex = "3";
+    o.display = "none";
+    overlay.appendChild(pinSvg);
+    try {
+      const cs = view.getComputedStyle(container);
+      const pos = cs && cs.position || container.style.position;
+      if (!pos || pos === "static") container.style.position = "relative";
+    } catch {
+      container.style.position = container.style.position || "relative";
+    }
+    const cRect = container.getBoundingClientRect();
+    const svgLeft = svgBox.left - cRect.left - container.clientLeft + container.scrollLeft;
+    const svgTop = svgBox.top - cRect.top - container.clientTop + container.scrollTop;
+    const contentBand = { top: svgTop + band.top, bottom: svgTop + band.bottom };
+    const place = () => {
+      const st = container.scrollTop, vh = container.clientHeight;
+      const edge2 = axisPinPlacement(contentBand, st, vh);
+      if (!edge2) {
+        o.display = "none";
+        return null;
+      }
+      o.display = "block";
+      o.left = `${svgLeft}px`;
+      o.top = `${edge2 === "top" ? st : st + vh - bandPx}px`;
+      return edge2;
+    };
+    const onScroll = () => {
+      try {
+        if (!overlay.isConnected) {
+          unpinScrolledAxis(container);
+          return;
+        }
+        place();
+      } catch {
+      }
+    };
+    container.appendChild(overlay);
+    container.addEventListener("scroll", onScroll, { passive: true });
+    container[CONTAINER_SLOT_AXIS_PIN] = { overlay, onScroll };
+    const edge = place();
+    const mid = (band.top + band.bottom) / 2 / svgBox.height;
+    return {
+      pinned: true,
+      reason: "pinned",
+      bandPx: Math.round(bandPx),
+      axisAt: mid < 1 / 3 ? "top" : mid > 2 / 3 ? "bottom" : "middle",
+      labels: cands[plan.index].labels.length,
+      carried: carried.length,
+      edge
+    };
+  } catch {
+    unpinScrolledAxis(container);
+    return noPin("threw");
+  }
+}
+function fitRenderedChart(container, opts = {}) {
+  const slackPx = opts.slackPx ?? SCROLL_SLACK_PX;
+  const result = {
+    grew: false,
+    growFrom: 0,
+    growTo: 0,
+    growReason: "no-container",
+    overflowX: "hidden",
+    overflowY: "hidden",
+    reading: null,
+    axisPin: noPin("no-container")
+  };
+  if (!container) return result;
+  try {
+    let svg = container.querySelector(`svg[${SNAPSHOT_SVG_ATTR}]`);
+    for (let i = 0; i < container.children.length && !svg; i++) {
+      const el = container.children[i];
+      if (el.tagName && el.tagName.toLowerCase() === "svg") svg = el;
+    }
+    if (!svg) svg = container.querySelector("svg");
+    let inkCache;
+    const svgInk = (el) => {
+      if (inkCache === void 0) inkCache = svgInkReach(el);
+      return inkCache;
+    };
+    const inkOf = (el) => el && el.tagName && el.tagName.toLowerCase() === "svg" ? svgInk(el) : null;
+    if (svg && opts.grow !== false) {
+      try {
+        const ink = svgInk(svg);
+        const elH = svg.getBoundingClientRect().height;
+        const vb = svg.viewBox && svg.viewBox.baseVal ? svg.viewBox.baseVal.height : 0;
+        const ctm = typeof svg.getScreenCTM === "function" ? svg.getScreenCTM() : null;
+        const plan = planFrameGrow(
+          ink ? ink.bottom : NaN,
+          elH,
+          vb,
+          ctmScaleOf(ctm),
+          slackPx
+        );
+        result.growFrom = Math.round(elH);
+        result.growTo = plan.heightPx;
+        result.growReason = plan.reason;
+        if (plan.grow) {
+          svg.setAttribute("height", String(plan.heightPx));
+          if (vb > 0) {
+            const b = svg.viewBox.baseVal;
+            svg.setAttribute("viewBox", `${b.x} ${b.y} ${b.width} ${plan.viewBoxH}`);
+          }
+          result.grew = true;
+        }
+      } catch {
+        result.growReason = "grow-threw";
+      }
+    } else if (!svg) {
+      result.growReason = "no-svg";
+    } else {
+      result.growReason = "grow-disabled";
+    }
+    const reading = fitReadingFor(opts.lane ?? "chart", container, slackPx, inkOf);
+    result.reading = reading;
+    const boxes = measureContainerBoxes(container, inkOf);
+    const extent = contentExtentOf(boxes);
+    const svgBox = svg ? svg.getBoundingClientRect() : null;
+    const contentW = extent.source === "none" ? Math.max(container.scrollWidth, svgBox ? svgBox.width : 0) : extent.w;
+    const contentH = extent.source === "none" ? Math.max(container.scrollHeight, svgBox ? svgBox.height : 0) : extent.h;
+    const fit = scrollFitFor(contentW, contentH, container.clientWidth, container.clientHeight, slackPx);
+    result.overflowX = fit.overflowX;
+    result.overflowY = fit.overflowY;
+    if (opts.applyOverflow !== false) {
+      container.style.overflowX = fit.overflowX;
+      container.style.overflowY = fit.overflowY;
+      if (fit.overflowY !== "auto") {
+        unpinScrolledAxis(container);
+        result.axisPin = noPin("not-scrolling");
+      } else if (opts.pinAxis === false) {
+        unpinScrolledAxis(container);
+        result.axisPin = noPin("disabled");
+      } else result.axisPin = pinScrolledAxis(container, svg);
+    } else {
+      unpinScrolledAxis(container);
+      result.axisPin = noPin("overflow-not-applied");
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/labelContrastDom.ts
+var LABEL_CONTRAST_DONE_ATTR = "data-lch-contrast";
+var LABEL_CONTRAST_CAP = 2e3;
+var EMPTY5 = {
+  rects: 0,
+  scanned: 0,
+  fixed: 0,
+  pillsBoosted: 0,
+  offFill: 0,
+  pageMajority: 0,
+  paintedOver: 0,
+  straddlePills: 0,
+  pillsExtended: 0,
+  raised: 0
+};
+function backedSamples(el, pts) {
+  try {
+    const ge2 = el;
+    if (typeof ge2.isPointInFill !== "function" || typeof ge2.getScreenCTM !== "function") return null;
+    const m = ge2.getScreenCTM();
+    const svg = ge2.ownerSVGElement;
+    if (!m || !svg || typeof svg.createSVGPoint !== "function") return null;
+    if (pts.length === 0) return null;
+    const inv = m.inverse();
+    const hit = [];
+    for (let i = 0; i < pts.length; i++) {
+      const p = svg.createSVGPoint();
+      p.x = pts[i].x;
+      p.y = pts[i].y;
+      hit.push(ge2.isPointInFill(p.matrixTransform(inv)));
+    }
+    return hit;
+  } catch {
+    return null;
+  }
+}
+var DOC_POSITION_FOLLOWING = 4;
+function paintRoot(el, container) {
+  let root = null;
+  for (let n = el.parentElement; n; n = n.parentElement) {
+    if (String(n.tagName || "").toLowerCase() === "svg") root = n;
+    if (n === container) break;
+  }
+  return root;
+}
+function drawnBeneath(shape, text2, textRoot) {
+  if (!shape.root || shape.root !== textRoot) return true;
+  if (typeof shape.el.compareDocumentPosition !== "function") return true;
+  return (shape.el.compareDocumentPosition(text2) & DOC_POSITION_FOLLOWING) !== 0;
+}
+function sampleBackgrounds(shapes, pts, pageRGB, effAlpha) {
+  if (pts.length === 0 || shapes.length === 0) return null;
+  const ordered = shapes.slice().sort((a, b) => a.ord - b.ord);
+  const masks = [];
+  for (const mk of ordered) {
+    const m = backedSamples(mk.el, pts);
+    if (m === null) return null;
+    masks.push(m);
+  }
+  return pts.map((_, i) => {
+    let bg = [pageRGB[0], pageRGB[1], pageRGB[2]];
+    for (let k = 0; k < ordered.length; k++) {
+      if (!masks[k][i]) continue;
+      const a = effAlpha(ordered[k]);
+      if (a < PILL_MIN_ALPHA) continue;
+      const c = toRGBA(ordered[k].fill);
+      if (c) bg = compositeOver([c[0], c[1], c[2], a], bg);
+    }
+    return bg;
+  });
+}
+function extendPillOver(pill, tr) {
+  try {
+    if (String(pill.tagName || "").toLowerCase() !== "rect") return false;
+    const ge2 = pill;
+    if (typeof ge2.getScreenCTM !== "function") return false;
+    const m = ge2.getScreenCTM();
+    if (!m || Math.abs(m.b) > 1e-6 || Math.abs(m.c) > 1e-6 || !(m.a > 0) || !(m.d > 0)) return false;
+    const inv = m.inverse();
+    const toUser = (x2, y2) => ({ x: inv.a * x2 + inv.c * y2 + inv.e, y: inv.b * x2 + inv.d * y2 + inv.f });
+    const a = toUser(tr.left, tr.top), b = toUser(tr.right, tr.bottom);
+    const num2 = (k) => {
+      const v = parseFloat(pill.getAttribute(k) || "");
+      return isFinite(v) ? v : NaN;
+    };
+    const x = num2("x"), y = num2("y"), w = num2("width"), h = num2("height");
+    if (![x, y, w, h].every((v) => isFinite(v)) || !(w > 0) || !(h > 0)) return false;
+    const pad = 1 / m.a;
+    const x0 = Math.min(x, Math.min(a.x, b.x) - pad), x1 = Math.max(x + w, Math.max(a.x, b.x) + pad);
+    const y0 = Math.min(y, Math.min(a.y, b.y) - pad), y1 = Math.max(y + h, Math.max(a.y, b.y) + pad);
+    if (x0 >= x - 0.01 && x1 <= x + w + 0.01 && y0 >= y - 0.01 && y1 <= y + h + 0.01) return false;
+    pill.setAttribute("x", String(+x0.toFixed(2)));
+    pill.setAttribute("y", String(+y0.toFixed(2)));
+    pill.setAttribute("width", String(+(x1 - x0).toFixed(2)));
+    pill.setAttribute("height", String(+(y1 - y0).toFixed(2)));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function raiseOverOccluders(tx, occluders, tr, effAlpha) {
+  try {
+    const parent = tx.parentNode;
+    if (!parent || typeof parent.contains !== "function") return false;
+    if (!occluders.every((o) => parent.contains(o.el))) return false;
+    const pts = straddleSampleGrid(tr);
+    if (pts.length === 0) return false;
+    const covered = pts.map(() => false);
+    let opaque = 0;
+    for (const o of occluders) {
+      if (effAlpha(o) < PILL_OPAQUE_ALPHA) continue;
+      const m = backedSamples(o.el, pts);
+      if (m === null) return false;
+      opaque++;
+      for (let i = 0; i < m.length; i++) if (m[i]) covered[i] = true;
+    }
+    const n = covered.filter(Boolean).length;
+    if (opaque === 0 || n === 0 || n === pts.length) return false;
+    parent.appendChild(tx);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LABEL_PILL_CLASS = "lch-label-pill";
+function addPill(tx, fill) {
+  try {
+    const parent = tx.parentNode;
+    if (!parent || typeof tx.getBBox !== "function") return null;
+    const bb = tx.getBBox();
+    if (!bb || !(bb.width > 0) || !(bb.height > 0)) return null;
+    const doc = tx.ownerDocument;
+    if (!doc) return null;
+    const r = doc.createElementNS("http://www.w3.org/2000/svg", "rect");
+    const px = Math.max(2, bb.height * 0.2), py = 1;
+    r.setAttribute("x", String(+(bb.x - px).toFixed(2)));
+    r.setAttribute("y", String(+(bb.y - py).toFixed(2)));
+    r.setAttribute("width", String(+(bb.width + 2 * px).toFixed(2)));
+    r.setAttribute("height", String(+(bb.height + 2 * py).toFixed(2)));
+    r.setAttribute("rx", "2");
+    r.setAttribute("fill", fill);
+    r.setAttribute("fill-opacity", String(STRADDLE_PILL_ALPHA));
+    r.setAttribute("pointer-events", "none");
+    r.setAttribute("class", LABEL_PILL_CLASS);
+    r.setAttribute(LABEL_CONTRAST_DONE_ATTR, "1");
+    const tf = tx.getAttribute("transform");
+    if (tf) r.setAttribute("transform", tf);
+    parent.insertBefore(r, tx);
+    return r;
+  } catch {
+    return null;
+  }
+}
+function applyLabelContrast(container, opts = {}) {
+  const report = { ...EMPTY5 };
+  if (!container) {
+    report.skipped = "no-container";
+    return report;
+  }
+  const CAP = opts.cap ?? LABEL_CONTRAST_CAP;
+  const pageBg = opts.pageBg || "#ffffff";
+  try {
+    const rects = [];
+    let ord = 0;
+    const pushShape = (el) => {
+      const tag = el.tagName.toLowerCase();
+      if (tag !== "rect" && tag !== "path") return;
+      const r = el.getBoundingClientRect();
+      if (r.width <= 0 || r.height <= 0) return;
+      let fill = el.getAttribute("fill") || "";
+      const win2 = container.ownerDocument?.defaultView;
+      if ((!fill || fill === "none") && win2 && typeof win2.getComputedStyle === "function") {
+        fill = win2.getComputedStyle(el).fill || "";
+      }
+      if (!fill || fill === "none") return;
+      const opAttr = el.getAttribute("fill-opacity");
+      const op = opAttr === null ? 1 : parseFloat(opAttr);
+      rects.push({
+        r,
+        fill,
+        op: isFinite(op) ? op : 1,
+        area: r.width * r.height,
+        el,
+        ord: ord++,
+        root: paintRoot(el, container)
+      });
+    };
+    const shapeEls = container.querySelectorAll("rect, path");
+    if (shapeEls.length === 0) {
+      report.skipped = "no-shapes";
+      return report;
+    }
+    if (shapeEls.length > CAP) {
+      report.skipped = "too-many-shapes";
+      return report;
+    }
+    for (let i = 0; i < shapeEls.length; i++) pushShape(shapeEls[i]);
+    if (rects.length === 0) {
+      report.skipped = "no-shapes";
+      return report;
+    }
+    report.rects = rects.length;
+    const pageRGBA = toRGBA(pageBg) || [255, 255, 255, 1];
+    const pageRGB = [pageRGBA[0], pageRGBA[1], pageRGBA[2]];
+    const effAlpha = (mk) => {
+      const c = toRGBA(mk.fill);
+      return (c ? c[3] : 1) * mk.op;
+    };
+    const texts = container.querySelectorAll("text");
+    if (texts.length > CAP) {
+      report.skipped = "too-many-texts";
+      return report;
+    }
+    const win = container.ownerDocument?.defaultView;
+    for (let t = 0; t < texts.length; t++) {
+      const tx = texts[t];
+      if (tx.getAttribute(LABEL_CONTRAST_DONE_ATTR) === "1") continue;
+      const tr = tx.getBoundingClientRect();
+      if (tr.width <= 0 || tr.height <= 0) continue;
+      const ovArea = (r) => Math.max(0, Math.min(r.right, tr.right) - Math.max(r.left, tr.left)) * Math.max(0, Math.min(r.bottom, tr.bottom) - Math.max(r.top, tr.top));
+      const glyphArea = tr.width * tr.height;
+      const txRoot = paintRoot(tx, container);
+      let over = 0;
+      const occluders = [];
+      const boxed = rects.map((mk) => ({ mk, ov: ovArea(mk.r) })).filter((x) => {
+        if (!(x.ov > 0)) return false;
+        if (drawnBeneath(x.mk, tx, txRoot)) return true;
+        if (effAlpha(x.mk) >= PILL_MIN_ALPHA) {
+          over++;
+          occluders.push(x.mk);
+        }
+        return false;
+      });
+      const raised = occluders.length > 0 && raiseOverOccluders(tx, occluders, tr, effAlpha);
+      if (raised) {
+        report.raised++;
+        tx.setAttribute(LABEL_CONTRAST_DONE_ATTR, "1");
+        for (const mk of occluders) boxed.push({ mk, ov: ovArea(mk.r) });
+        over = 0;
+      }
+      if (over > 0) report.paintedOver++;
+      const pts = glyphSampleGrid({ left: tr.left, top: tr.top, width: tr.width, height: tr.height });
+      const painted = pts.map(() => false);
+      let unmeasured = 0;
+      const under = boxed.map((x) => {
+        const mask = backedSamples(x.mk.el, pts);
+        if (mask === null) {
+          unmeasured++;
+          return x;
+        }
+        let inside = 0;
+        const paints = effAlpha(x.mk) >= PILL_MIN_ALPHA;
+        for (let i = 0; i < mask.length; i++) {
+          if (!mask[i]) continue;
+          inside++;
+          if (paints) painted[i] = true;
+        }
+        return { mk: x.mk, ov: glyphArea * (inside / mask.length) };
+      }).filter((x) => x.ov > 0);
+      if (under.length === 0 && boxed.length > 0) report.offFill++;
+      if (under.length === 0) continue;
+      let raisedOnPage = false;
+      if (unmeasured === 0 && pts.length > 0) {
+        let held = 0;
+        for (let i = 0; i < painted.length; i++) if (painted[i]) held++;
+        if (!backingHoldsGlyph(glyphArea * (held / pts.length), glyphArea)) {
+          if (!raised) {
+            report.pageMajority++;
+            continue;
+          }
+          raisedOnPage = true;
+        }
+      }
+      report.scanned++;
+      const opaqueUnder = under.filter((x) => effAlpha(x.mk) >= PILL_OPAQUE_ALPHA);
+      const cellEntry = (opaqueUnder.length ? opaqueUnder : under).reduce((a, b) => b.ov > a.ov || b.ov === a.ov && b.mk.ord > a.mk.ord ? b : a);
+      const cell = cellEntry.mk;
+      const pill = under.find((x) => x.mk !== cell && isPillBackdropAlpha(effAlpha(x.mk)) && x.mk.ord > cell.ord && pillBacksGlyph(x.ov, glyphArea))?.mk;
+      const cellRGBA = toRGBA(cell.fill);
+      let bgRGB = cellRGBA ? compositeOver([cellRGBA[0], cellRGBA[1], cellRGBA[2], cellRGBA[3] * cell.op], pageRGB) : pageRGB;
+      if (pill) {
+        const pr = toRGBA(pill.fill);
+        if (pr) {
+          bgRGB = compositeOver([pr[0], pr[1], pr[2], 0.9], bgRGB);
+          pill.el.setAttribute("fill", `rgb(${pr[0]}, ${pr[1]}, ${pr[2]})`);
+          pill.el.setAttribute("fill-opacity", "0.9");
+          report.pillsBoosted++;
+          if (extendPillOver(pill.el, tr)) report.pillsExtended++;
+        }
+      }
+      const cur = tx.getAttribute("fill") || (win && typeof win.getComputedStyle === "function" ? win.getComputedStyle(tx).fill : "");
+      if (!pill && unmeasured === 0) {
+        const bgs = sampleBackgrounds(boxed.map((x) => x.mk), straddleSampleGrid(tr), pageRGB, effAlpha);
+        if (bgs && straddles(bgs)) {
+          if (minContrastOver(cur, bgs) >= STRADDLE_TARGET_CONTRAST) continue;
+          const pillEl = addPill(tx, `rgb(${pageRGB[0]}, ${pageRGB[1]}, ${pageRGB[2]})`);
+          const behind = pillEl ? bgs.map((b) => compositeOver([pageRGB[0], pageRGB[1], pageRGB[2], STRADDLE_PILL_ALPHA], b)) : bgs;
+          if (pillEl) report.straddlePills++;
+          const pick = pickColorOver(cur, behind);
+          if (!pick.keep) {
+            tx.setAttribute("fill", pick.color);
+            report.fixed++;
+          }
+          tx.setAttribute(LABEL_CONTRAST_DONE_ATTR, "1");
+          continue;
+        }
+      }
+      if (raisedOnPage) continue;
+      const normalize = !cellSuppressesNormalize(cell.el.getAttribute("class"));
+      const d = decideLabelColor(cur, `rgb(${bgRGB[0]}, ${bgRGB[1]}, ${bgRGB[2]})`, 1, pageBg, MIN_CONTRAST, normalize);
+      if (d.fix) {
+        tx.setAttribute("fill", d.color);
+        report.fixed++;
+      }
+      if (pill || d.fix) tx.setAttribute(LABEL_CONTRAST_DONE_ATTR, "1");
+    }
+    return report;
+  } catch {
+    report.skipped = "error";
+    return report;
+  }
+}
+
+// src/idScope.ts
+var seq = 0;
+function newIdScope() {
+  seq += 1;
+  return "h" + seq;
+}
+var URL_REF = /url\(\s*(['"]?)#([^'")\s]+)\1\s*\)/g;
+function scopeChartIds(c, scope) {
+  const r = { renamed: 0, collisions: [] };
+  try {
+    const tag = "--" + scope, doc = c.ownerDocument, map = /* @__PURE__ */ new Map();
+    const refs = [], used = /* @__PURE__ */ new Set();
+    c.querySelectorAll("*").forEach((el) => {
+      for (const a of el.getAttributeNames()) {
+        const v = el.getAttribute(a);
+        const href = (a === "href" || a === "xlink:href") && v[0] === "#";
+        if (!href && v.indexOf("url(") < 0) continue;
+        refs.push([el, a, v]);
+        if (href) used.add(v.slice(1));
+        for (const m of v.matchAll(URL_REF)) used.add(m[2]);
+      }
+    });
+    c.querySelectorAll("[id]").forEach((el) => {
+      const id = el.id;
+      if (!used.has(id) || id.endsWith(tag)) return;
+      const q = id.replace(/["\\]/g, "\\$&");
+      if (doc && Array.from(doc.querySelectorAll(`[id="${q}"],[id^="${q}--h"]`)).some((o) => !c.contains(o))) {
+        r.collisions.push(id);
+      }
+      map.set(id, el.id = id + tag);
+      r.renamed++;
+    });
+    for (const [el, a, v] of refs) {
+      const nv = v[0] === "#" && map.has(v.slice(1)) ? "#" + map.get(v.slice(1)) : v.replace(URL_REF, (m, q, id) => map.has(id) ? `url(${q}#${map.get(id)}${q})` : m);
+      if (nv !== v) el.setAttribute(a, nv);
+    }
+  } catch {
+  }
+  return r;
+}
+
+// src/invalidSentinel.ts
+function isInvalidSentinelError(text2) {
+  if (!text2) return false;
+  return /\bINVALID\s*:/.test(text2);
+}
+function invalidSentinelReason(text2, max = 240) {
+  if (!text2) return "";
+  const m = /\bINVALID\s*:\s*([^\r\n]*)/.exec(text2);
+  if (!m) return "";
+  const reason = m[1].trim();
+  const cap = Math.max(0, Math.floor(max));
+  if (reason.length <= cap) return reason;
+  return cap <= 3 ? reason.slice(0, cap) : reason.slice(0, cap - 3).trimEnd() + "...";
+}
+
+// src/annotations.ts
+var ANNOTATION_LAYER_CLASS = "bic-annotations";
+var ANNOTATION_CLASS = "bic-annotation";
+var ZOOM_PAD_CLASS = "llm-zoom-pad";
+var text = (v) => v == null ? "" : String(v).trim();
+var FREE = { l: -Infinity, t: -Infinity, r: Infinity, b: Infinity };
+var box = (r) => ({ l: r.left, t: r.top, r: r.right, b: r.bottom });
+var area = (b) => (b.r - b.l) * (b.b - b.t);
+var cut = (a, b) => {
+  if (!a) return null;
+  const c = { l: Math.max(a.l, b.l), t: Math.max(a.t, b.t), r: Math.min(a.r, b.r), b: Math.min(a.b, b.b) };
+  return c.r > c.l && c.b > c.t ? c : null;
+};
+function shapeTest(mark) {
+  const g = mark;
+  let inv = null;
+  try {
+    inv = g?.isPointInFill ? g.getScreenCTM?.()?.inverse() ?? null : null;
+  } catch {
+    inv = null;
+  }
+  if (!g || !inv) return () => true;
+  const m = inv;
+  return (x, y) => {
+    try {
+      return g.isPointInFill({ x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f });
+    } catch {
+      return true;
+    }
+  };
+}
+var parseIdxs = (s) => (s || "").split(",").map((x) => parseInt(x, 10)).filter((n) => Number.isFinite(n));
+function createAnnotationLayer(container, onClick) {
+  let list = [];
+  let report = { shown: 0, notShown: 0 };
+  let last = null;
+  const doc = container.ownerDocument;
+  const win = doc.defaultView;
+  let observer = null;
+  let queued = false;
+  const redrawSoon = () => {
+    if (queued || !last) return;
+    queued = true;
+    const run = () => {
+      queued = false;
+      if (last) paint(last.data, last.theme);
+    };
+    if (win?.requestAnimationFrame) win.requestAnimationFrame(run);
+    else setTimeout(run, 16);
+  };
+  const watch = (on) => {
+    const MO = win?.MutationObserver;
+    if (on && !observer && MO) {
+      observer = new MO((records) => {
+        if (records.some((r) => !r.target.closest?.(`.${ANNOTATION_LAYER_CLASS}`))) redrawSoon();
+      });
+      observer.observe(container, { subtree: true, attributes: true, attributeFilter: ["transform", "d", "cx", "cy", "x", "y", "points"] });
+    } else if (!on && observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  };
+  function paint(data, theme) {
+    let layer = container.querySelector(`:scope > .${ANNOTATION_LAYER_CLASS}`);
+    if (!list.length) {
+      layer?.remove();
+      report = { shown: 0, notShown: 0 };
+      return;
+    }
+    if (!layer) {
+      layer = doc.createElement("div");
+      layer.className = ANNOTATION_LAYER_CLASS;
+      layer.setAttribute("aria-hidden", "false");
+      Object.assign(layer.style, { position: "absolute", left: "0", top: "0", width: "0", height: "0", overflow: "visible", zIndex: "2" });
+      if (win?.getComputedStyle(container).position === "static") container.style.position = "relative";
+      container.appendChild(layer);
+    }
+    layer.textContent = "";
+    const names = (data.columns || []).map((c) => typeof c === "string" ? c : c?.name);
+    const marks = Array.from(container.querySelectorAll(`.${MARK_CLASS}[${ROW_IDX_ATTR}]`)).filter((m) => !m.closest(`.${ANNOTATION_LAYER_CLASS}`));
+    const marksByRow = /* @__PURE__ */ new Map();
+    for (const m of marks) for (const r of parseIdxs(m.getAttribute(ROW_IDX_ATTR))) {
+      const at = marksByRow.get(r);
+      if (at) at.push(m);
+      else marksByRow.set(r, [m]);
+    }
+    const origin = container.getBoundingClientRect();
+    const open = origin.width > 0 && origin.height > 0 ? box(origin) : FREE;
+    const clipOf = /* @__PURE__ */ new Map();
+    const viewOf = (m) => {
+      let v = open;
+      const svg = m.closest("svg");
+      if (svg) {
+        const s = svg.getBoundingClientRect();
+        if (s.width > 0 && s.height > 0) v = cut(v, box(s));
+      }
+      for (let el = m.parentElement; v && el && el !== svg && el !== container; el = el.parentElement) {
+        if (!clipOf.has(el)) {
+          const w2 = clipWindowOf(el);
+          clipOf.set(el, w2 && box(w2));
+        }
+        const w = clipOf.get(el);
+        if (w) v = cut(v, w);
+      }
+      return v;
+    };
+    const controls = Array.from(container.querySelectorAll(`.${CONTROL_CLASS}, .${ZOOM_PAD_CLASS}`)).map((c) => c.getBoundingClientRect()).filter((r) => r.width > 0 && r.height > 0).map(box);
+    const clear = (v, len, mark) => {
+      const hw = Math.max(16, len * 6 + 8) / 2, hh = 8, g = 2;
+      const cx = (v.l + v.r) / 2, cy = (v.t + v.b) / 2;
+      const free = (x, y) => x >= v.l && x <= v.r && y >= v.t && y <= v.b && controls.every((c) => x + hw <= c.l || x - hw >= c.r || y + hh <= c.t || y - hh >= c.b);
+      const onShape = shapeTest(mark);
+      const tries = [[cx, cy]];
+      for (let i = 0; i <= 8; i++) for (let j = 0; j <= 6; j++) tries.push([v.l + (v.r - v.l) * i / 8, v.t + (v.b - v.t) * j / 6]);
+      tries.sort((p, q) => Math.hypot(p[0] - cx, p[1] - cy) - Math.hypot(q[0] - cx, q[1] - cy));
+      for (const c of controls) tries.push([cx, c.b + hh + g], [cx, c.t - hh - g], [c.l - hw - g, cy], [c.r + hw + g, cy]);
+      return tries.find(([x, y]) => free(x, y) && onShape(x, y)) ?? tries.find(([x, y]) => free(x, y)) ?? null;
+    };
+    let shown = 0;
+    for (const a of list) {
+      const pairs = (a.where ? Object.entries(a.where) : a.column != null ? [[a.column, a.value]] : []).map(([c, v]) => [names.indexOf(c), text(v)]);
+      const want = pairs.map((p) => p[1]).join(" / ");
+      const hits = /* @__PURE__ */ new Set();
+      if (pairs.length && pairs.every((p) => p[0] >= 0)) (data.rows || []).forEach((row, r) => {
+        if (pairs.every(([ci, v]) => text(row?.[ci]) === v)) for (const m of marksByRow.get(r) ?? []) hits.add(m);
+      });
+      if (!hits.size) continue;
+      let best = null, bestMark = null, laidOut = false;
+      for (const m of hits) {
+        const b = m.getBoundingClientRect();
+        if (!(b.width > 0 && b.height > 0)) continue;
+        laidOut = true;
+        const v = cut(box(b), viewOf(m));
+        if (v && (!best || area(v) > area(best))) {
+          best = v;
+          bestMark = m;
+        }
+      }
+      const pt = best ? clear(best, (a.label ?? "\u2022").length, bestMark) : null;
+      if (laidOut && !pt) continue;
+      shown++;
+      const badge = doc.createElement("div");
+      badge.className = ANNOTATION_CLASS;
+      badge.textContent = a.label ?? "\u2022";
+      if (a.title) badge.setAttribute("title", a.title);
+      badge.setAttribute("role", "button");
+      badge.setAttribute("aria-label", a.title ? `Note: ${a.title}` : `Note on ${want}`);
+      Object.assign(badge.style, {
+        position: "absolute",
+        left: `${Math.round(pt ? pt[0] - origin.left : 0)}px`,
+        top: `${Math.round(pt ? pt[1] - origin.top : 0)}px`,
+        transform: "translate(-50%, -50%)",
+        minWidth: "16px",
+        height: "16px",
+        padding: "0 4px",
+        boxSizing: "border-box",
+        borderRadius: "8px",
+        font: "600 10px/16px system-ui, sans-serif",
+        textAlign: "center",
+        color: theme.bg || "#ffffff",
+        background: theme.accent || theme.fg || "#0f6cbd",
+        boxShadow: `0 0 0 1.5px ${theme.bg || "#ffffff"}`,
+        cursor: onClick ? "pointer" : "default",
+        // Never pointer-events (a host failsafe turns it back on); visibility hides a badge whose mark
+        // has no box yet.
+        visibility: laidOut ? "visible" : "hidden"
+      });
+      badge.addEventListener("click", (e) => {
+        e.stopPropagation();
+        onClick?.(a);
+      });
+      layer.appendChild(badge);
+    }
+    report = { shown, notShown: list.length - shown };
+  }
+  return {
+    set(next) {
+      list = Array.isArray(next) ? next.slice() : [];
+      watch(list.length > 0);
+      if (last) paint(last.data, last.theme);
+    },
+    draw(data, theme) {
+      last = { data, theme };
+      paint(data, theme);
+    },
+    get report() {
+      return report;
+    },
+    destroy() {
+      watch(false);
+      list = [];
+      last = null;
+      container.querySelector(`:scope > .${ANNOTATION_LAYER_CLASS}`)?.remove();
+    }
+  };
+}
+
+// src/host.ts
+function sessionViewStateProvider(container) {
+  const holder = container;
+  const existing = holder[CONTAINER_SLOT_UI_STATE];
+  const store = existing && typeof existing === "object" ? existing : holder[CONTAINER_SLOT_UI_STATE] = {};
+  return {
+    load: () => store,
+    save: (next) => {
+      if (!next || typeof next !== "object") return;
+      for (const k of Object.keys(store)) delete store[k];
+      Object.assign(store, next);
+    }
+  };
+}
+function noopViewStateProvider() {
+  return { load: () => ({}), save: () => {
+  } };
+}
+var parseRowIdxs = (s) => (s || "").split(",").map((x) => parseInt(x, 10)).filter((n) => Number.isFinite(n));
+function assembleD3(base, ...plugins) {
+  return Object.assign({}, base, ...plugins);
+}
+var D3_PLUGIN_PACKAGES = Object.freeze({
+  sankey: "d3-sankey",
+  sankeyLinkHorizontal: "d3-sankey",
+  sankeyJustify: "d3-sankey",
+  sankeyCenter: "d3-sankey",
+  sankeyLeft: "d3-sankey",
+  sankeyRight: "d3-sankey",
+  hexbin: "d3-hexbin",
+  voronoiTreemap: "d3-voronoi-treemap",
+  voronoiMap: "d3-voronoi-map",
+  weightedVoronoi: "d3-weighted-voronoi",
+  // Attached onto d3 like the rest, but reached as d3.mermaid.render(...) — a NAMESPACE
+  // OBJECT with methods, not a function on d3. The scan below accounts for that shape.
+  mermaid: "mermaid",
+  // AND THE NAME A REAL CHART ACTUALLY WRITES. This one is not a member of the mermaid
+  // package at all: it is a helper the SERVER prepends into the generated code, and the
+  // helper is what reaches for the library. So a genuine diagram chart contains
+  // `d3.llmMermaid(` and never once writes `d3.mermaid` — measured on the first real
+  // generation of that type, for which this scan returned an EMPTY list. It drew, because
+  // the host it ran in happened to carry the library; a host relying on this answer to
+  // decide what to install would have been told nothing and failed several frames deep.
+  //
+  // Mapping the helper is right rather than a hack, because this map answers "what must a
+  // host INSTALL for this code to run" and not "which package exports this symbol". For
+  // code that calls the helper, the answer is the library the helper reaches for.
+  llmMermaid: "mermaid"
+});
+function requiredD3Plugins(code) {
+  const out = /* @__PURE__ */ new Set();
+  const body = stripJsComments(String(code || ""));
+  const add = (name) => {
+    const pkg = D3_PLUGIN_PACKAGES[name];
+    if (pkg) out.add(pkg);
+  };
+  for (const m of body.matchAll(/\bd3\s*\.\s*(\w+)/g)) add(m[1]);
+  for (const m of body.matchAll(/\bd3\s*\[\s*['"](\w+)['"]\s*\]/g)) add(m[1]);
+  for (const m of body.matchAll(/\{([^{}]*)\}\s*=\s*d3\b/g)) {
+    for (const part of m[1].split(",")) add(part.split(":")[0].trim());
+  }
+  return [...out].sort();
+}
+function explainRenderFailure(err, d3) {
+  const msg = String(err?.message ?? err ?? "");
+  if (!d3) {
+    return new Error(
+      "[@bicharts/chart-host] no d3 was provided, so the generated chart could not run. Pass it explicitly \u2014 createChartHost(el, { d3 }) / <BicChart d3={d3} /> \u2014 or set window.d3. The chart needs D3 v7 (npm install d3@7). Original error: " + msg
+    );
+  }
+  if (typeof d3?.mermaid?.render !== "function" && /\bmermaid\b/i.test(msg)) {
+    return new Error(
+      "[@bicharts/chart-host] this chart draws its diagram with Mermaid, which it reaches as d3.mermaid.render(...), and the d3 you passed has no mermaid on it \u2014 this host did not load the library. A host supplies it exactly the way the other plugins are supplied: hand createChartHost ONE d3 that carries it, the SAME d3 every chart gets \u2014  npm install mermaid  then  import * as d3base from 'd3'; import mermaid from 'mermaid'; import { assembleD3 } from '@bicharts/chart-host'; const d3 = assembleD3(d3base, { mermaid });  (an ES-module d3 namespace is frozen, so assigning onto it throws)  Original error: " + msg
+    );
+  }
+  const m = /d3\.(\w+) is not a function|(\w+) is not a function/.exec(msg);
+  const name = m?.[1] ?? m?.[2] ?? "";
+  const pkg = D3_PLUGIN_PACKAGES[name];
+  if (pkg) {
+    return new Error(
+      `[@bicharts/chart-host] this chart calls d3.${name}(), which comes from the separate "${pkg}" package and is not attached to the d3 you passed. Install it and hand the host ONE d3 that carries it, the SAME d3 every chart gets:  npm install ${pkg}  then  import * as d3base from "d3"; import { ${name} } from "${pkg}"; import { assembleD3 } from "@bicharts/chart-host"; const d3 = assembleD3(d3base, { ${name} });  (an ES-module d3 namespace is frozen, so assigning onto it throws)  Original error: ` + msg
+    );
+  }
+  return err;
+}
+var ESM_EXPORT_CLAUSE = /^[ \t]*export[ \t]+(?:\{[^}]*\}|default[ \t]+[A-Za-z_$][\w$]*)[ \t]*;?[ \t]*$/gm;
+var ESM_EXPORT_DECL = /^([ \t]*)export[ \t]+(?=(?:async[ \t]+)?function\b|const\b|let\b|var\b|class\b)/gm;
+function stripEsmExports(code) {
+  return String(code || "").replace(ESM_EXPORT_CLAUSE, "").replace(ESM_EXPORT_DECL, "$1");
+}
+function writableD3(d3) {
+  if (d3 == null || typeof d3 !== "object") return d3;
+  if (Object.isExtensible(d3)) return d3;
+  return { ...d3 };
+}
+function compileRenderFn(code, win, doc, d3) {
+  const body = stripEsmExports(code) + "\n;return (typeof render === 'function') ? render : null;";
+  let factory;
+  try {
+    factory = new Function("container", "data", "options", "window", "document", "d3", body);
+  } catch (e) {
+    const msg = String(e?.message ?? e ?? "");
+    const modular = /\bimport\b|\bexport\b/.test(String(code || ""));
+    throw new Error(
+      "[@bicharts/chart-host] the generated code could not be COMPILED, so nothing was drawn. This path evaluates the chart as a code string, which cannot contain ES-module syntax" + (modular ? " \u2014 and this code still has `import`/`export` in it after the export clause was stripped. Either request the plain form from the generator, or `import` the module yourself and pass the render function directly." : ".") + " Original error: " + msg
+    );
+  }
+  const fn = factory.call(null, null, null, null, win, doc, writableD3(d3));
+  if (typeof fn !== "function") throw new Error("generated code did not define render(container, data, options)");
+  return fn;
+}
+var ASYNC_RENDER_TIMEOUT_MS = 15e3;
+var isThenable = (v) => !!v && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+function createChartHost(container, config) {
+  const doc = container.ownerDocument;
+  const win = doc?.defaultView ?? globalThis;
+  const d3 = config.d3 ?? globalThis.d3 ?? win?.d3;
+  let data = config.data;
+  {
+    const stamped = config.data?.meta?.hostContract;
+    const major = (v) => (v || "").split(".")[0];
+    if (stamped && major(stamped) !== major(HOST_CONTRACT_VERSION)) {
+      try {
+        (win?.console ?? console)?.warn(
+          `[@bicharts/chart-host] contract MAJOR mismatch: this chart was generated against v${stamped}, the host implements v${HOST_CONTRACT_VERSION}. Marks, container slots or the cross-filter event may not line up \u2014 regenerate the chart.`
+        );
+      } catch {
+      }
+    }
+  }
+  let raw = { ...config.options ?? {} };
+  if (typeof raw.setUiState !== "function") {
+    const provider = config.viewState ?? sessionViewStateProvider(container);
+    let bag;
+    try {
+      bag = provider.load() ?? {};
+    } catch {
+      bag = {};
+    }
+    if (raw.uiState && typeof raw.uiState === "object" && Object.keys(bag).length === 0)
+      Object.assign(bag, raw.uiState);
+    raw.uiState = bag;
+    raw.setUiState = (s) => {
+      if (!s || typeof s !== "object") return;
+      try {
+        provider.save(s);
+      } catch {
+      }
+    };
+  }
+  const resolveForHost = (input) => {
+    const out = resolveOptions(input);
+    return out.allowTooltips == null ? { ...out, allowTooltips: true } : out;
+  };
+  let resolved = resolveForHost(raw);
+  let renderFn = config.renderFn ?? null;
+  let destroyed = false;
+  let warnedGeo = false;
+  let warnedBlank = false;
+  let warnedIds = false;
+  const idScope = newIdScope();
+  let renderSeq = 0;
+  const annotationLayer = createAnnotationLayer(container, (a) => config.onAnnotationClick?.(a));
+  const drawAnnotations = () => annotationLayer.draw(
+    { columns: data.columns, rows: data.rows },
+    {
+      fg: resolved.themeFg,
+      accent: resolved.themeAccent,
+      bg: resolved.backgroundColor ?? resolved.themeBg
+    }
+  );
+  annotationLayer.set(config.annotations ?? []);
+  let renderedPromise = Promise.resolve();
+  const settle = (p) => {
+    renderedPromise = p;
+    p.catch(() => {
+    });
+  };
+  let current = null;
+  let activeTickEl = null;
+  let selectionIsPeriod = false;
+  let selectionFromChart = false;
+  const clickedMarks = () => container[CONTAINER_SLOT_CLICKED_MARKS] ?? null;
+  const setClickedMarks = (c) => {
+    try {
+      container[CONTAINER_SLOT_CLICKED_MARKS] = c;
+    } catch {
+    }
+  };
+  const subs = /* @__PURE__ */ new Set();
+  const ensureAffordanceStyles = () => {
+    try {
+      if (!doc || doc.getElementById("bic-chart-host-affordances")) return;
+      const st = doc.createElement("style");
+      st.id = "bic-chart-host-affordances";
+      st.textContent = `
+/* TYPOGRAPHY FIREWALL. Generated charts set font-size but almost never line-height or
+   letter-spacing, so they INHERIT whatever the host page cascades in. A page with
+   \`:root { font: 18px/145% }\` (the stock Vite template does exactly this) hands every
+   chart an inherited 26.1px line box; an 11px label in a 14px band is then sliced through
+   the middle. The chart is not wrong and the host is not wrong \u2014 the boundary between
+   them is, so the boundary fixes it. Both properties are overridable: a chart that sets
+   its own line-height still wins. Deliberately NOT resetting font-family or color, which
+   a host SHOULD be able to theme. Found 2026-07-26 in the React demo, on a chart that
+   renders perfectly inside Power BI. */
+.${HOST_CONTAINER_CLASS} { line-height: normal; letter-spacing: normal; }
+/* BACKGROUND MARKS ARE NOT DATA. A mark whose ${ROW_IDX_ATTR} is EMPTY has no rows in the
+   CURRENT frame \u2014 an animated map's region before its country enters the series. Every
+   affordance below therefore skips it: brightening or dimming it manufactures a shade
+   that appears in no legend, and at 25% grey over white it comes out LIGHTER than plain
+   land, which reads as a real bottom-of-scale value rather than as absence. The guard is
+   exactly [${ROW_IDX_ATTR}=""] \u2014 an ABSENT attribute is a tagged companion layer (an
+   anomaly badge, a highlight stroke) and must keep dimming with its datum. */
+.${HOST_CONTAINER_CLASS} .${MARK_CLASS} { cursor: pointer; transition: opacity 120ms ease-in-out, filter 100ms ease-in-out; }
+.${HOST_CONTAINER_CLASS} .${MARK_CLASS}:not([${ROW_IDX_ATTR}=""]):hover { filter: brightness(1.1) drop-shadow(0 0 1.5px rgba(0,0,0,0.5)) !important; }
+.${HOST_CONTAINER_CLASS}:has(.${MARK_CLASS}:not([${ROW_IDX_ATTR}=""]):hover) .${MARK_CLASS}:not(:hover):not([${ROW_IDX_ATTR}=""]) { opacity: 0.55; }
+.${HOST_CONTAINER_CLASS}.${SELECTION_ACTIVE_CLASS} .${MARK_CLASS}:not(.${MARK_SELECTED_CLASS}):not([${ROW_IDX_ATTR}=""]) {
+    opacity: var(${DIM_OPACITY_VAR}, ${DIM_OPACITY_DEFAULT}) !important;
+}
+/* THE LIFT, BY DECLARATION ONLY. Dimming the others is all the rule above does; a selected
+   mark keeps whatever paint its chart gave it. A chart that draws every mark pale on purpose
+   (a parallel-coordinates plot at 0.38 so overplotting reads) therefore shows its SELECTED
+   lines at 38% - the same eye-reading as dimmed. Inside a group the chart stamps
+   ${LIFT_SELECTED_CLASS} on, a selected mark is painted at full opacity. Opacity only, never
+   stroke geometry. Undeclared charts are byte-identical, which is what keeps an alpha
+   ENCODING (a depth cue, a hierarchy level) from being flattened by a fix meant for one. */
+.${HOST_CONTAINER_CLASS}.${SELECTION_ACTIVE_CLASS} .${LIFT_SELECTED_CLASS} .${MARK_CLASS}.${MARK_SELECTED_CLASS},
+.${HOST_CONTAINER_CLASS}.${SELECTION_ACTIVE_CLASS} .${MARK_CLASS}.${LIFT_SELECTED_CLASS}.${MARK_SELECTED_CLASS} {
+    opacity: 1 !important; stroke-opacity: 1 !important; fill-opacity: 1 !important;
+}
+.${HOST_CONTAINER_CLASS} .${LEGEND_MARK_CLASS} { cursor: pointer; }
+/* An axis/group header that filters when clicked LOOKS like inert text, and until it is
+   marked there is no way to tell a landed filter from a dead label \u2014 the report reads
+   "the axis labels are not clickable" even when every click resolved. Weight + underline
+   rather than a colour: these labels sit wherever the host page's theme puts them, and
+   the host has no reliable contrast partner out in the axis gutter. This paints NO marks,
+   so it is the one acknowledgement a PERIOD tick can have without breaking the rule that
+   a timeline never dims its own chart. */
+.${HOST_CONTAINER_CLASS} .${AXIS_FILTER_CLASS} { cursor: pointer; }
+.${HOST_CONTAINER_CLASS} .${ACTIVE_TICK_CLASS},
+.${HOST_CONTAINER_CLASS} .${ACTIVE_TICK_CLASS} text {
+    font-weight: 700 !important;
+    text-decoration: underline !important;
+}`;
+      (doc.head || doc.documentElement)?.appendChild(st);
+    } catch {
+    }
+  };
+  const paintSelection = () => {
+    try {
+      const sel = current;
+      const active = !!sel && sel.length > 0;
+      const dim = active && !selectionIsPeriod;
+      container.classList?.[dim ? "add" : "remove"](SELECTION_ACTIVE_CLASS);
+      const lit = container.querySelectorAll(`.${ACTIVE_TICK_CLASS}`);
+      for (const t of Array.from(lit)) t.classList?.remove(ACTIVE_TICK_CLASS);
+      const tickStillDrawn = !!activeTickEl && (typeof container.contains === "function" ? container.contains(activeTickEl) : activeTickEl.isConnected !== false);
+      if (active && tickStillDrawn) activeTickEl.classList?.add(ACTIVE_TICK_CLASS);
+      const wanted = new Set(sel ?? []);
+      const marks = container.querySelectorAll(`.${MARK_CLASS}[${ROW_IDX_ATTR}], .${LEGEND_MARK_CLASS}[${ROW_IDX_ATTR}]`);
+      const rule = selectionRuleOf(container);
+      if (rule !== "any-row") {
+        const list = Array.from(marks);
+        const plan = planSelectionPaint(
+          list.map((m) => ({ key: markKeyOf(m), rows: parseRowIdxs(m.getAttribute(ROW_IDX_ATTR)) })),
+          active ? wanted : [],
+          rule,
+          clickedMarks()
+        );
+        list.forEach((m, i) => m.classList?.[plan.on[i] ? "add" : "remove"](MARK_SELECTED_CLASS));
+        setClickedMarks(plan.keys.length ? { keys: plan.keys, selection: Array.from(wanted) } : null);
+        if (active) {
+          try {
+            config.onSelectionPaint?.({
+              rule,
+              mode: plan.mode,
+              lit: plan.on.filter(Boolean).length,
+              marks: list.length,
+              selection: wanted.size
+            });
+          } catch {
+          }
+        }
+        return;
+      }
+      for (const m of Array.from(marks)) {
+        const rows = parseRowIdxs(m.getAttribute(ROW_IDX_ATTR));
+        const on = active && rows.some((r) => wanted.has(r));
+        m.classList?.[on ? "add" : "remove"](MARK_SELECTED_CLASS);
+      }
+    } catch {
+    }
+  };
+  const notify = (rowIdxs, source, tick, fromChart = false) => {
+    current = rowIdxs;
+    selectionFromChart = rowIdxs.length > 0 && fromChart;
+    activeTickEl = rowIdxs.length ? tick ?? null : null;
+    selectionIsPeriod = rowIdxs.length > 0 && periodTickSuppressesFeedback(!!tick, chartOwnsTimeline(container));
+    paintSelection();
+    for (const cb of subs) {
+      try {
+        cb(rowIdxs, source);
+      } catch {
+      }
+    }
+  };
+  let xfAt = 0;
+  const XF_ECHO_MS = 150;
+  const onXf = (e) => {
+    const d = e?.detail || {};
+    xfAt = Date.now();
+    if (d.clear) notify([], d.source || "chart");
+    else if (d.mark) notify(parseRowIdxs(d.mark.getAttribute?.(ROW_IDX_ATTR)), d.source || "chart", d.mark, true);
+  };
+  const resolver = createMarkResolver({
+    root: container,
+    doc,
+    log: () => {
+    }
+  });
+  const clickSel = `.${MARK_CLASS}[${ROW_IDX_ATTR}], .${LEGEND_MARK_CLASS}[${ROW_IDX_ATTR}], .${AXIS_FILTER_CLASS}[${ROW_IDX_ATTR}]`;
+  const onClick = (e) => {
+    if (Date.now() - xfAt < XF_ECHO_MS) return;
+    if (isInsideControl(e?.target, container)) return;
+    let el = resolver.findMark(e?.target, clickSel, e);
+    if (!el) el = resolver.penetrateOverlayAt(e?.clientX, e?.clientY, clickSel);
+    if (!el) el = resolver.resolveByGeometry(e?.clientX, e?.clientY, clickSel);
+    if (!el) {
+      if (current && current.length) {
+        const slot = container[CONTAINER_SLOT_XF_CLEAR];
+        if (selectionFromChart && typeof slot === "function") {
+          try {
+            slot();
+          } catch {
+          }
+        }
+        if (current && current.length) notify([], "user");
+      }
+      return;
+    }
+    const rows = parseRowIdxs(el.getAttribute(ROW_IDX_ATTR));
+    if (!rows.length) return;
+    const tick = el.classList?.contains?.(AXIS_FILTER_CLASS) ? el : null;
+    const multi = !!(e?.ctrlKey || e?.metaKey || e?.shiftKey);
+    const next = nextSelection(current, rows, { ctrl: !!(e?.ctrlKey || e?.metaKey), shift: !!e?.shiftKey });
+    const toggledOff = !multi && next.length === 0;
+    setClickedMarks(nextClickedMarks(
+      clickedMarks(),
+      current,
+      markKeyOf(el),
+      next,
+      { ctrl: !!(e?.ctrlKey || e?.metaKey), shift: !!e?.shiftKey }
+    ));
+    notify(next, "user", toggledOff ? null : tick);
+  };
+  container.addEventListener(XFILTER_REFRESH_EVENT, onXf);
+  container.addEventListener("click", onClick);
+  container.classList?.add(HOST_CONTAINER_CLASS);
+  ensureAffordanceStyles();
+  const fitOpts = config.fit ?? true;
+  const labelContrastOpts = config.labelContrast ?? true;
+  const stopAnim = () => {
+    const s = container[CONTAINER_SLOT_ANIM_STOP];
+    if (typeof s === "function") {
+      try {
+        s();
+      } catch {
+      }
+    }
+  };
+  const runPostRenderPasses = () => {
+    try {
+      const r = scopeChartIds(container, idScope);
+      if (r.collisions.length && !warnedIds) {
+        warnedIds = true;
+        try {
+          (win?.console ?? console)?.warn(
+            `[@bicharts/chart-host] ids shared with another chart, scoped: ${r.collisions.slice(0, 5).join(", ")}`
+          );
+        } catch {
+        }
+      }
+      config.onIdScope?.(r);
+    } catch {
+    }
+    if (labelContrastOpts !== false) {
+      try {
+        const lc = labelContrastOpts === true ? {} : { ...labelContrastOpts };
+        if (!lc.pageBg) {
+          const bg = resolved.backgroundColor ?? resolved.themeBg;
+          if (typeof bg === "string" && bg) lc.pageBg = bg;
+        }
+        const r = applyLabelContrast(container, lc);
+        config.onLabelContrast?.(r);
+      } catch {
+      }
+    }
+    ensureCrossfilterHitTargets(container, doc);
+    paintSelection();
+    try {
+      const census = censusMarks(container);
+      if (isBlankRender({
+        markCount: census.markCount,
+        rows: data.rows ? data.rows.length : 0,
+        animated: config.animated,
+        contractUntagged: config.contractUntagged,
+        declaresNoRowMarks: census.declaresNoRowMarks
+      })) {
+        if (!warnedBlank) {
+          warnedBlank = true;
+          try {
+            (win?.console ?? console)?.warn(
+              `[@bicharts/chart-host] this chart rendered without error but painted no data marks, against ${data.rows.length} row(s) \u2014 so the container is empty. The usual cause is that the generated code binds a column BY NAME that is no longer in the data, sending it down its own "no data" branch. Check that the columns in your table still match the ones the chart was generated for.`
+            );
+          } catch {
+          }
+        }
+        config.onBlankRender?.({ census, rows: data.rows ? data.rows.length : 0 });
+      }
+    } catch {
+    }
+    if (config.onHitBandCensus) {
+      try {
+        config.onHitBandCensus(censusHitBands(container, doc));
+      } catch {
+      }
+    }
+    if (config.onColourSpreadCensus) {
+      try {
+        config.onColourSpreadCensus(censusColourSpread(container, doc));
+      } catch {
+      }
+    }
+    if (config.onClippedTextCensus) {
+      try {
+        config.onClippedTextCensus(censusClippedText(container));
+      } catch {
+      }
+    }
+    if (config.onValuePlacementCensus) {
+      try {
+        config.onValuePlacementCensus(censusValuePlacement(container, data));
+      } catch {
+      }
+    }
+    if (fitOpts !== false) {
+      try {
+        const r = fitRenderedChart(container, fitOpts === true ? {} : fitOpts);
+        config.onFit?.(r);
+      } catch {
+      }
+    }
+    try {
+      drawAnnotations();
+    } catch {
+    }
+  };
+  const renderFailure = (err) => {
+    const message = String(err?.message ?? err ?? "");
+    if (config.onInvalidSentinel && isInvalidSentinelError(message)) {
+      stopAnim();
+      container.innerHTML = "";
+      config.onInvalidSentinel({ reason: invalidSentinelReason(message), message });
+      return null;
+    }
+    return explainRenderFailure(err, d3);
+  };
+  const host = {
+    render() {
+      if (destroyed) return;
+      const seq2 = ++renderSeq;
+      stopAnim();
+      container.innerHTML = "";
+      if (!renderFn) {
+        if (!config.code) throw new Error("createChartHost: provide code or renderFn");
+        renderFn = compileRenderFn(config.code, win, doc, d3);
+      }
+      if (resolved.geo === void 0 && config.geoKind) {
+        const g = config.geoProvider?.(config.geoKind) ?? geoFromCache(config.geoKind);
+        if (g) resolved = { ...resolved, geo: g };
+        else if (!warnedGeo) {
+          warnedGeo = true;
+          try {
+            (win?.console ?? console)?.warn(
+              `[@bicharts/chart-host] geoKind "${config.geoKind}" was set but no geometry is available, so this chart will draw without a basemap. Either \`await loadGeo("${config.geoKind}")\` before rendering, pass a geoProvider, or import { geoForKind } from "@bicharts/chart-host/geo" and set options.geo.`
+            );
+          } catch {
+          }
+        }
+      }
+      if (resolved.geoUnmatched === void 0 && data.geoUnmatched) resolved = { ...resolved, geoUnmatched: data.geoUnmatched };
+      if (resolved.geoPoint === void 0 && data.geoPoint) resolved = { ...resolved, geoPoint: data.geoPoint };
+      if (resolved.geoPointDest === void 0 && data.geoPointDest) resolved = { ...resolved, geoPointDest: data.geoPointDest };
+      if (resolved.dateCellsAreUtcDays === void 0 && data.dateCellsAreUtcDays) resolved = { ...resolved, dateCellsAreUtcDays: true };
+      let outcome;
+      try {
+        outcome = renderFn(container, { columns: data.columns, rows: data.rows }, resolved);
+      } catch (err) {
+        const fatal = renderFailure(err);
+        if (fatal) {
+          settle(Promise.reject(fatal));
+          throw fatal;
+        }
+        settle(Promise.resolve());
+        return;
+      }
+      if (!isThenable(outcome)) {
+        runPostRenderPasses();
+        settle(Promise.resolve());
+        return;
+      }
+      settle(new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error(
+            `[@bicharts/chart-host] the chart did not finish drawing within ${Math.round(ASYNC_RENDER_TIMEOUT_MS / 1e3)}s, so the host stopped waiting for it. Nothing past that point ran: no label-contrast pass, no hit-target heal, no census, no fit. A render() that returns a promise has to settle it.`
+          ));
+        }, ASYNC_RENDER_TIMEOUT_MS);
+        const done = (fn) => {
+          clearTimeout(timer);
+          fn();
+        };
+        Promise.resolve(outcome).then(
+          () => done(() => {
+            if (destroyed || seq2 !== renderSeq) {
+              resolve();
+              return;
+            }
+            runPostRenderPasses();
+            resolve();
+          }),
+          (err) => done(() => {
+            if (destroyed || seq2 !== renderSeq) {
+              resolve();
+              return;
+            }
+            const fatal = renderFailure(err);
+            if (fatal) reject(fatal);
+            else resolve();
+          })
+        );
+      }));
+    },
+    setOptions(partial) {
+      raw = { ...raw, ...partial };
+      resolved = resolveForHost(raw);
+      host.render();
+    },
+    setData(next) {
+      data = next;
+      host.render();
+    },
+    get options() {
+      return resolved;
+    },
+    setAnnotations(list) {
+      annotationLayer.set(list);
+      if (!destroyed) try {
+        drawAnnotations();
+      } catch {
+      }
+    },
+    get annotationReport() {
+      return annotationLayer.report;
+    },
+    // A GETTER, not a captured value: `rendered` names the LATEST render, so a host that
+    // read it once would otherwise hold the promise of a draw long since replaced.
+    get rendered() {
+      return renderedPromise;
+    },
+    selection: {
+      onChange(cb) {
+        subs.add(cb);
+        return () => subs.delete(cb);
+      },
+      clear() {
+        const s = container[CONTAINER_SLOT_XF_CLEAR];
+        if (typeof s === "function") {
+          try {
+            s();
+          } catch {
+          }
+        }
+        setClickedMarks(null);
+        notify([], "host");
+      },
+      highlight(rowIdxs) {
+        notify(Array.isArray(rowIdxs) ? rowIdxs.slice() : [], "host");
+      },
+      get current() {
+        return current;
+      }
+    },
+    animation: { stop: stopAnim },
+    initialMark() {
+      return container[CONTAINER_SLOT_INITIAL_XF_MARK] ?? null;
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      stopAnim();
+      container.removeEventListener(XFILTER_REFRESH_EVENT, onXf);
+      container.removeEventListener("click", onClick);
+      subs.clear();
+      annotationLayer.destroy();
+      unpinScrolledAxis(container);
+      container.innerHTML = "";
+    }
+  };
+  return host;
+}
+
+// src/group.ts
+var EMPTY6 = Object.freeze({ sourceId: null, rows: Object.freeze([]) });
+function toSourceRows(rowMap, payloadRowIdxs) {
+  if (!rowMap) return payloadRowIdxs.slice();
+  return payloadRowIdxs.map((i) => rowMap[i]).filter((i) => i !== void 0);
+}
+function toPayloadRows(rowMap, sourceRowIdxs) {
+  const at = /* @__PURE__ */ new Map();
+  rowMap.forEach((src, k) => {
+    if (!at.has(src)) at.set(src, k);
+  });
+  return sourceRowIdxs.map((s) => at.get(s)).filter((k) => k !== void 0);
+}
+var sameRows = (a, b) => {
+  if (a.length !== b.length) return false;
+  const x = a.slice().sort((p, q) => p - q), y = b.slice().sort((p, q) => p - q);
+  return x.every((v, i) => v === y[i]);
+};
+function syncMemberSelection(host, selection, id, highlight, incoming, rowMap) {
+  const mine = selection.sourceId === id && selection.rows.length > 0;
+  if (mine) {
+    if (rowMap) {
+      const want = toPayloadRows(rowMap, selection.rows);
+      if (!sameRows(want, host.selection.current ?? [])) host.selection.highlight(want);
+    }
+    return;
+  }
+  if (highlight && incoming && incoming.length) {
+    host.selection.highlight(incoming.slice());
+    return;
+  }
+  if (host.selection.current && host.selection.current.length) host.selection.clear();
+}
+function createChartGroup(columns, rows, opts = {}) {
+  let cols = columns;
+  let table = rows;
+  let geo = opts.geo ?? null;
+  let point = opts.point ?? null;
+  let destination = opts.destination ?? null;
+  let selection = EMPTY6;
+  const subs = /* @__PURE__ */ new Set();
+  const members = /* @__PURE__ */ new Set();
+  const notify = (change) => {
+    for (const cb of Array.from(subs)) cb(selection, change);
+  };
+  const incomingFor = (id, filteredBy) => {
+    const s = selection;
+    const forId = s.rows.length && s.sourceId && s.sourceId !== id ? s.rows.slice() : null;
+    if (filteredBy) return s.sourceId === filteredBy ? forId : null;
+    return forId;
+  };
+  const payloadFor = (sourceRowIdxs) => {
+    const idxs = sourceRowIdxs ? sourceRowIdxs.slice() : table.map((_, i) => i);
+    const subset = idxs.map((i) => table[i]);
+    const payload = buildRenderPayload(
+      cols,
+      subset,
+      geo ?? void 0,
+      point ?? void 0,
+      destination ?? void 0
+    );
+    return { payload, rowMap: idxs };
+  };
+  const memberPayload = (id, o = {}) => payloadFor(o.respondsWith === "highlight" ? null : incomingFor(id, o.filteredBy));
+  const group = {
+    get selection() {
+      return selection;
+    },
+    get columns() {
+      return cols;
+    },
+    get rows() {
+      return table;
+    },
+    incomingFor,
+    payloadFor,
+    memberPayload,
+    publish(id, sourceRowIdxs) {
+      selection = sourceRowIdxs.length ? { sourceId: id, rows: sourceRowIdxs.slice() } : { sourceId: null, rows: [] };
+      notify(sourceRowIdxs.length ? "select" : "clear");
+    },
+    clear() {
+      selection = { sourceId: null, rows: [] };
+      notify("clear");
+    },
+    setSource(nextColumns, nextRows, o = {}) {
+      cols = nextColumns;
+      table = nextRows;
+      geo = o.geo ?? null;
+      point = o.point ?? null;
+      destination = o.destination ?? null;
+      notify("source");
+    },
+    onChange(cb) {
+      subs.add(cb);
+      return () => {
+        subs.delete(cb);
+      };
+    },
+    attach(id, host, o = {}) {
+      const highlight = o.respondsWith === "highlight";
+      let rowMap = memberPayload(id, o).rowMap;
+      const filterKey = (incoming) => highlight || !incoming ? "*" : incoming.join(",");
+      let drawnUnder = filterKey(incomingFor(id, o.filteredBy));
+      const offHost = host.selection.onChange((payloadIdxs, source) => {
+        if (source === "host") return;
+        const sourceIdxs = toSourceRows(rowMap, payloadIdxs);
+        if (id) group.publish(id, sourceIdxs);
+        o.onSelect?.(sourceIdxs);
+      });
+      const offGroup = group.onChange((sel, change) => {
+        const incoming = incomingFor(id, o.filteredBy);
+        const key = filterKey(incoming);
+        if (change === "source" || key !== drawnUnder) {
+          const next = payloadFor(highlight ? null : incoming);
+          rowMap = next.rowMap;
+          drawnUnder = key;
+          host.setData(next.payload);
+        }
+        syncMemberSelection(host, sel, id, highlight, incoming, rowMap);
+      });
+      const member = {
+        get rowMap() {
+          return rowMap;
+        },
+        detach() {
+          offHost();
+          offGroup();
+          members.delete(member);
+        }
+      };
+      members.add(member);
+      return member;
+    },
+    destroy() {
+      for (const m of Array.from(members)) m.detach();
+      subs.clear();
+    }
+  };
+  return group;
+}
+
+export {
+  DARK_TEXT,
+  LIGHT_TEXT,
+  MIN_CONTRAST,
+  WHITE_TEXT_BG_LUM,
+  PILL_MIN_ALPHA,
+  PILL_OPAQUE_ALPHA,
+  PAGE_MATCH_TOLERANCE,
+  isPillBackdropAlpha,
+  PILL_MIN_COVERAGE,
+  pillBacksGlyph,
+  BACKING_MAJORITY,
+  backingHoldsGlyph,
+  cellSuppressesNormalize,
+  toRGBA,
+  compositeOver,
+  relativeLuminance,
+  contrastRatio,
+  decideLabelColor,
+  GLYPH_SAMPLE_N,
+  glyphSampleGrid,
+  STRADDLE_COLS,
+  STRADDLE_ROWS,
+  STRADDLE_MIN_SHARE,
+  STRADDLE_TARGET_CONTRAST,
+  STRADDLE_PILL_ALPHA,
+  straddleSampleGrid,
+  straddles,
+  minContrastOver,
+  pickColorOver,
+  deltaEHex,
+  SAME_SHADE_DELTA_E,
+  MIN_RAMP_FILLS,
+  censusColourSpread,
+  colourSpreadFlag,
+  AUTO_RAMP_CLASSES,
+  AUTO_RAMP_DRAWN_OPACITY,
+  AUTO_RAMP_MIN_STEP_DELTA_E,
+  autoRampMinStep,
+  autoRampCanvas,
+  resolveAutoColorScale,
+  resolveOptions,
+  geoAssetFor,
+  loadGeo,
+  geoFromCache,
+  registerGeo,
+  registerGeoAsset,
+  clearGeoCache,
+  buildRenderPayload,
+  stripJsComments,
+  rowIdxsFromMark,
+  nextSelection,
+  selectionRuleOf,
+  markKeyOf,
+  sameRowSet,
+  planSelectionPaint,
+  nextClickedMarks,
+  isInsideControl,
+  createMarkResolver,
+  collectD3GlyphCenters,
+  SELECTION_GLYPH_CLASS,
+  clearSelectionGlyphs,
+  paintSelectionGlyphs,
+  ensureCrossfilterHitTargets,
+  censusMarks,
+  isBlankRender,
+  blankRenderFlag,
+  MIN_HIT_BAND_PX,
+  censusHitBands,
+  hitBandFlag,
+  CLIP_TOLERANCE_PX,
+  censusClippedText,
+  clippedTextFlag,
+  VALUE_AXIS_MIN_FIT,
+  censusValuePlacement,
+  valuePlacementFlag,
+  SCROLL_SLACK_PX,
+  needsScroll,
+  contentExtentOf,
+  scrollFitFor,
+  FIT_CONTENT_SELECTOR,
+  PHANTOM_FRACTION,
+  isPhantomBox,
+  MAX_FRAME_GROW_FACTOR,
+  planFrameGrow,
+  AXIS_PIN_MIN_LABELS,
+  AXIS_PIN_BAND_PAD_PX,
+  AXIS_PIN_MAX_BAND_FRACTION,
+  AXIS_PIN_TRACK_REACH_PX,
+  isHorizontalLabelRow,
+  labelBand,
+  planAxisPin,
+  axisPinPlacement,
+  ctmScaleOf,
+  svgInkReach,
+  measureContainerBoxes,
+  fitReadingFor,
+  unpinScrolledAxis,
+  pinScrolledAxis,
+  fitRenderedChart,
+  LABEL_CONTRAST_DONE_ATTR,
+  LABEL_CONTRAST_CAP,
+  LABEL_PILL_CLASS,
+  applyLabelContrast,
+  newIdScope,
+  scopeChartIds,
+  isInvalidSentinelError,
+  invalidSentinelReason,
+  ANNOTATION_LAYER_CLASS,
+  ANNOTATION_CLASS,
+  sessionViewStateProvider,
+  noopViewStateProvider,
+  assembleD3,
+  D3_PLUGIN_PACKAGES,
+  requiredD3Plugins,
+  explainRenderFailure,
+  stripEsmExports,
+  compileRenderFn,
+  createChartHost,
+  toSourceRows,
+  syncMemberSelection,
+  createChartGroup
+};