@bicharts/chart-host 0.6.84 → 0.6.85

package/dist/legend-fit.mjs

@@ -0,0 +1,1613 @@
+/*! @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 {
+  chartSvgOf
+} from "./chunk-ZGQURBRJ.mjs";
+import {
+  FIT_CONTENT_SELECTOR,
+  ctmScaleOf,
+  isPhantomBox
+} from "./chunk-BQFG5HWZ.mjs";
+import "./chunk-MR6TL7QZ.mjs";
+import "./chunk-GHODWOAL.mjs";
+
+// src/legendFit/legendReconcile.ts
+var MIN_OVERLAP = 2;
+var MAX_GUTTER_FRACTION = 0.6;
+function overlap1D(aLo, aHi, bLo, bHi) {
+  return Math.min(aHi, bHi) - Math.max(aLo, bLo);
+}
+function rightmostOverlappingPlotEdge(legendBox, plotRects) {
+  let edge = -Infinity;
+  for (const r of plotRects) {
+    if (!r) continue;
+    if (overlap1D(legendBox.top, legendBox.bottom, r.top, r.bottom) <= 0) continue;
+    if (r.left <= legendBox.left && r.right >= legendBox.right) continue;
+    if (r.right > edge) edge = r.right;
+  }
+  return edge;
+}
+function bottommostOverlappingPlotEdge(legendBox, plotRects) {
+  let edge = -Infinity;
+  for (const r of plotRects) {
+    if (!r) continue;
+    if (overlap1D(legendBox.left, legendBox.right, r.left, r.right) <= 0) continue;
+    if (overlap1D(legendBox.top, legendBox.bottom, r.top, r.bottom) <= 0) continue;
+    if (r.left <= legendBox.left && r.right >= legendBox.right && r.top <= legendBox.top && r.bottom >= legendBox.bottom) continue;
+    if (r.bottom > edge) edge = r.bottom;
+  }
+  return edge;
+}
+function planLegendReconcile(legendBox, plotRects, viewBox, opts = {}, side = "right") {
+  const minOverlap = opts.minOverlap ?? MIN_OVERLAP;
+  const maxGutterFraction = opts.maxGutterFraction ?? MAX_GUTTER_FRACTION;
+  const pad = opts.pad ?? 8;
+  const edgePad = opts.edgePad ?? 4;
+  const none = (reason, vb) => ({
+    action: "none",
+    legendDx: 0,
+    legendDy: 0,
+    ext: 0,
+    newViewBox: vb || { x: 0, y: 0, w: 0, h: 0 },
+    reason
+  });
+  if (!legendBox || !plotRects || plotRects.length === 0) return none("missing-box", viewBox);
+  if (!viewBox || viewBox.w <= 0 || viewBox.h <= 0) return none("no-viewbox", viewBox);
+  const legW = legendBox.right - legendBox.left;
+  const legH = legendBox.bottom - legendBox.top;
+  if (side === "bottom") {
+    const plotBottom = bottommostOverlappingPlotEdge(legendBox, plotRects);
+    if (plotBottom === -Infinity) return none("no-overlap", viewBox);
+    const overlap2 = plotBottom - legendBox.top;
+    if (overlap2 <= minOverlap) return none("no-overlap", viewBox);
+    if (legW <= legH * 2) return none("not-horizontal-legend", viewBox);
+    if (legendBox.top < viewBox.y + 0.55 * viewBox.h) return none("not-bottom-legend", viewBox);
+    const legendDy = plotBottom + pad - legendBox.top;
+    const viewBoxBottom = viewBox.y + viewBox.h;
+    const extB = Math.max(0, Math.ceil(legendBox.bottom + legendDy + edgePad - viewBoxBottom));
+    if (extB > viewBox.h * maxGutterFraction) return none("none-too-big", viewBox);
+    return {
+      action: "reserve",
+      legendDx: 0,
+      legendDy: Math.ceil(legendDy),
+      ext: extB,
+      newViewBox: { x: viewBox.x, y: viewBox.y, w: viewBox.w, h: viewBox.h + extB },
+      reason: "reserve"
+    };
+  }
+  const plotRight = rightmostOverlappingPlotEdge(legendBox, plotRects);
+  if (plotRight === -Infinity) return none("no-overlap", viewBox);
+  const overlap = plotRight - legendBox.left;
+  if (overlap <= minOverlap) return none("no-overlap", viewBox);
+  if (legW > legH * 2) return none("not-vertical-legend", viewBox);
+  if (legendBox.left < viewBox.x + 0.55 * viewBox.w) return none("not-right-legend", viewBox);
+  const legendDx = plotRight + pad - legendBox.left;
+  const viewBoxRight = viewBox.x + viewBox.w;
+  const ext = Math.max(0, Math.ceil(legendBox.right + legendDx + edgePad - viewBoxRight));
+  if (ext > viewBox.w * maxGutterFraction) return none("none-too-big", viewBox);
+  return {
+    action: "reserve",
+    legendDx: Math.ceil(legendDx),
+    legendDy: 0,
+    ext,
+    newViewBox: { x: viewBox.x, y: viewBox.y, w: viewBox.w + ext, h: viewBox.h },
+    reason: "reserve"
+  };
+}
+var COLORBAR_ON_PLOT_COVER = 0.5;
+function colorbarProbePoints(bar, cols = 3, rows = 5) {
+  if (!bar || !(cols > 0) || !(rows > 0)) return [];
+  const w = bar.right - bar.left, h = bar.bottom - bar.top;
+  if (!(w > 0) || !(h > 0)) return [];
+  const pts = [];
+  for (let i = 0; i < cols; i++) {
+    for (let j = 0; j < rows; j++) {
+      pts.push({ x: bar.left + w * (i + 0.5) / cols, y: bar.top + h * (j + 0.5) / rows });
+    }
+  }
+  return pts;
+}
+function colorbarOnPlot(inkHits, probes, minCover = COLORBAR_ON_PLOT_COVER) {
+  return probes > 0 && inkHits / probes >= minCover;
+}
+function colorbarSitsOnMarks(bar, marks, minCover = COLORBAR_ON_PLOT_COVER) {
+  if (!bar || !marks || marks.length === 0) return false;
+  const barArea = (bar.right - bar.left) * (bar.bottom - bar.top);
+  if (!(barArea > 0)) return false;
+  for (const m of marks) {
+    if (!m) continue;
+    const ox = Math.min(bar.right, m.right) - Math.max(bar.left, m.left);
+    const oy = Math.min(bar.bottom, m.bottom) - Math.max(bar.top, m.top);
+    if (ox <= MIN_OVERLAP || oy <= MIN_OVERLAP) continue;
+    if (ox * oy / barArea >= minCover) return true;
+  }
+  return false;
+}
+function colorbarReconcileSide(bar, viewBox) {
+  if (!bar || !viewBox || viewBox.w <= 0 || viewBox.h <= 0) return null;
+  const w = bar.right - bar.left;
+  const h = bar.bottom - bar.top;
+  if (!(w > 0) || !(h > 0)) return null;
+  if (w > h * 2) {
+    return bar.top >= viewBox.y + 0.55 * viewBox.h ? "bottom" : null;
+  }
+  return bar.left >= viewBox.x + 0.55 * viewBox.w ? "right" : null;
+}
+var MAX_FIT_FRACTION = 0.35;
+var FIT_PAD = 4;
+var LEGIBILITY_GRACE_PX = 1;
+var MIN_LEGIBLE_PX = 10;
+function planContentFit(contentRects, viewBox, opts = {}) {
+  const zero = { left: 0, top: 0, right: 0, bottom: 0 };
+  const none = (reason) => ({
+    action: "none",
+    newViewBox: viewBox || { x: 0, y: 0, w: 0, h: 0 },
+    reason,
+    cut: zero
+  });
+  if (!viewBox || viewBox.w <= 0 || viewBox.h <= 0) return none("no-viewbox");
+  if (!contentRects || contentRects.length === 0) return none("no-content");
+  const minOverhang = opts.minOverhang ?? MIN_OVERLAP;
+  const maxFit = opts.maxFitFraction ?? MAX_FIT_FRACTION;
+  const pad = opts.pad ?? FIT_PAD;
+  const capX = maxFit * viewBox.w;
+  const capY = maxFit * viewBox.h;
+  const vbR = viewBox.x + viewBox.w;
+  const vbB = viewBox.y + viewBox.h;
+  let uL = Infinity, uT = Infinity, uR = -Infinity, uB = -Infinity;
+  for (const r of contentRects) {
+    if (!r || r.right <= r.left || r.bottom <= r.top) continue;
+    if (r.right < viewBox.x - capX || r.left > vbR + capX) continue;
+    if (r.bottom < viewBox.y - capY || r.top > vbB + capY) continue;
+    if (r.left < uL) uL = r.left;
+    if (r.top < uT) uT = r.top;
+    if (r.right > uR) uR = r.right;
+    if (r.bottom > uB) uB = r.bottom;
+  }
+  if (uL === Infinity) return none("no-content");
+  const overL = Math.max(0, viewBox.x - uL);
+  const overT = Math.max(0, viewBox.y - uT);
+  const overR = Math.max(0, uR - vbR);
+  const overB = Math.max(0, uB - vbB);
+  let clamped = 0;
+  const ext = (over, cap) => {
+    if (over <= minOverhang) return 0;
+    const need = Math.ceil(over + pad);
+    if (need > Math.ceil(cap)) {
+      clamped++;
+      return 0;
+    }
+    return need;
+  };
+  const cut = {
+    left: ext(overL, capX),
+    top: ext(overT, capY),
+    right: ext(overR, capX),
+    bottom: ext(overB, capY)
+  };
+  if (cut.left === 0 && cut.top === 0 && cut.right === 0 && cut.bottom === 0) {
+    return none(clamped > 0 ? "clamped" : "fits");
+  }
+  const shrink = Math.min(
+    viewBox.w / (viewBox.w + cut.left + cut.right),
+    viewBox.h / (viewBox.h + cut.top + cut.bottom)
+  );
+  const smallest = opts.smallestTextPx;
+  if (typeof smallest === "number" && isFinite(smallest) && smallest > 0) {
+    const floorPx = opts.minLegiblePx ?? MIN_LEGIBLE_PX;
+    const grace = opts.legibilityGracePx ?? LEGIBILITY_GRACE_PX;
+    const allowed = Math.min(floorPx, smallest) - grace;
+    if (smallest * shrink < allowed) return none("legibility");
+  }
+  return {
+    action: "fit",
+    newViewBox: {
+      x: viewBox.x - cut.left,
+      y: viewBox.y - cut.top,
+      w: viewBox.w + cut.left + cut.right,
+      h: viewBox.h + cut.top + cut.bottom
+    },
+    reason: "fit",
+    cut
+  };
+}
+var BOTTOM_TEXT_MIN_TICK_HITS = 2;
+function planBottomTextPush(candidate, tickBoxes, gap = 6, transform = "") {
+  if (tickBoxes.length === 0) return { move: false, dy: 0 };
+  if (!(candidate.right - candidate.left > candidate.bottom - candidate.top)) return { move: false, dy: 0 };
+  if (/rotate\s*\(/i.test(transform)) return { move: false, dy: 0 };
+  let hits = 0;
+  let floor = -Infinity;
+  for (const t of tickBoxes) {
+    if (candidate.left < t.right && candidate.right > t.left && candidate.top < t.bottom && candidate.bottom > t.top) {
+      hits++;
+      if (t.bottom > floor) floor = t.bottom;
+    }
+  }
+  if (hits < BOTTOM_TEXT_MIN_TICK_HITS) return { move: false, dy: 0 };
+  const dy = floor + gap - candidate.top;
+  return dy > 0.5 ? { move: true, dy } : { move: false, dy: 0 };
+}
+var SWATCH_MAX_PX = 28;
+var SWATCH_LABEL_GAP_PX = 30;
+var SIGNATURE_MIN_PAIRS = 2;
+function swatchPairs(shapes, texts) {
+  let pairs = 0;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const s of shapes) {
+    const w = s.right - s.left, h = s.bottom - s.top;
+    if (!(w > 0 || h > 0)) continue;
+    if (w > SWATCH_MAX_PX || h > SWATCH_MAX_PX) continue;
+    const beside = texts.some((t) => t.left >= s.right - 2 && t.left - s.right <= SWATCH_LABEL_GAP_PX && Math.min(t.bottom, s.bottom) - Math.max(t.top, s.top) > 0);
+    if (!beside) continue;
+    pairs++;
+    sizes.add(Math.round(w) + "x" + Math.round(h));
+  }
+  return { pairs, sameSize: pairs > 1 && sizes.size === 1 };
+}
+function isLegendSignature(p) {
+  return p.pairs >= SIGNATURE_MIN_PAIRS && p.sameSize;
+}
+var AXIS_THIN_MIN_TICKS = 4;
+var AXIS_THIN_GAP = 2;
+function planAxisTickThin(boxes, gap = AXIS_THIN_GAP, minTicks = AXIS_THIN_MIN_TICKS) {
+  const n = boxes.length;
+  if (n < minTicks) return { stride: 1, hide: [], reason: "too-few" };
+  const order = boxes.map((b, i) => ({ b, i })).sort((p, q) => p.b.left - q.b.left);
+  const collides = (a, b) => b.left < a.right + gap;
+  let any = false;
+  for (let i = 1; i < n; i++) {
+    if (collides(order[i - 1].b, order[i].b)) {
+      any = true;
+      break;
+    }
+  }
+  if (!any) return { stride: 1, hide: [], reason: "no-overlap" };
+  const cleanAt = (k) => {
+    let prev = -1;
+    for (let i = 0; i < n; i += k) {
+      if (prev >= 0 && collides(order[prev].b, order[i].b)) return false;
+      prev = i;
+    }
+    return true;
+  };
+  for (let k = 2; k <= Math.floor(n / 2); k++) {
+    if (!cleanAt(k)) continue;
+    const hide2 = [];
+    for (let i = 0; i < n; i++) if (i % k !== 0) hide2.push(order[i].i);
+    return { stride: k, hide: hide2.sort((a, b) => a - b), reason: "stride" };
+  }
+  if (collides(order[0].b, order[n - 1].b)) return { stride: 1, hide: [], reason: "unfixable" };
+  const hide = [];
+  for (let i = 1; i < n - 1; i++) hide.push(order[i].i);
+  return { stride: 0, hide: hide.sort((a, b) => a - b), reason: "ends-only" };
+}
+var LABEL_ROW_MIN_TEXTS = 3;
+var LABEL_ROW_Y_TOLERANCE = 2;
+function isNumericLabelText(s) {
+  const t = (s || "").trim();
+  if (!t || !/\d/.test(t)) return false;
+  return /^[\s$\u20ac\u00a3\u00a5%+\-\u2013\u2212.,0-9kKmMbB:]+$/.test(t);
+}
+var EN_MONTHS = [
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "sept",
+  "oct",
+  "nov",
+  "dec",
+  "january",
+  "february",
+  "march",
+  "april",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december"
+];
+var EN_DAYS = [
+  "mon",
+  "tue",
+  "tues",
+  "wed",
+  "thu",
+  "thur",
+  "thurs",
+  "fri",
+  "sat",
+  "sun",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+];
+var calendarWords = null;
+function calendarWordSet() {
+  if (calendarWords) return calendarWords;
+  const set = /* @__PURE__ */ new Set([...EN_MONTHS, ...EN_DAYS]);
+  try {
+    const add = (s) => {
+      const w = s.toLowerCase().replace(/\.$/, "").trim();
+      if (w) set.add(w);
+    };
+    for (const month of ["short", "long"]) {
+      const f = new Intl.DateTimeFormat(void 0, { month });
+      for (let m = 0; m < 12; m++) add(f.format(new Date(2026, m, 15)));
+    }
+    for (const weekday of ["short", "long"]) {
+      const f = new Intl.DateTimeFormat(void 0, { weekday });
+      for (let d = 0; d < 7; d++) add(f.format(new Date(2026, 0, 4 + d)));
+    }
+  } catch {
+  }
+  calendarWords = set;
+  return set;
+}
+function isDateLikeLabelText(s) {
+  const t = (s || "").trim();
+  if (!t) return false;
+  if (/(^|\D)(1[89]|20)\d{2}(\D|$)/.test(t)) return true;
+  if (/^(Q|H|T|W|FY|CW|KW)\s?\d{1,2}$/i.test(t) || /\bQ[1-4]\b/.test(t)) return true;
+  if (/^\d{1,4}[\/.\-]\d{1,2}([\/.\-]\d{1,4})?$/.test(t)) return true;
+  if (/^\d{1,2}(:\d{2})?\s*(am|pm|a\.m\.|p\.m\.)$/i.test(t)) return true;
+  const words = t.toLowerCase().split(/[\s,.'\-\/]+/).filter((w) => w !== "");
+  const cal = calendarWordSet();
+  return words.length > 0 && words.length <= 3 && words.some((w) => cal.has(w)) && words.every((w) => cal.has(w) || /^\d{1,4}(st|nd|rd|th)?$/.test(w));
+}
+function isOrderedAxisLabelText(s) {
+  return isNumericLabelText(s) || isDateLikeLabelText(s);
+}
+function axisLabelsAreNominal(labels) {
+  return labels.some((s) => (s || "").trim() !== "" && !isOrderedAxisLabelText(s));
+}
+function nominalLabelRooms(anchors, gap = AXIS_THIN_GAP) {
+  const n = anchors.length;
+  if (n < 2) return anchors.map(() => Infinity);
+  const order = anchors.map((x, i) => ({ x, i })).sort((p, q) => p.x - q.x);
+  const out = new Array(n);
+  for (let k = 0; k < n; k++) {
+    const left = k > 0 ? order[k].x - order[k - 1].x : Infinity;
+    const right = k < n - 1 ? order[k + 1].x - order[k].x : Infinity;
+    out[order[k].i] = Math.min(left, right) - gap;
+  }
+  return out;
+}
+function groupLabelRows(boxes, tol = LABEL_ROW_Y_TOLERANCE) {
+  const used = new Array(boxes.length).fill(false);
+  const rows = [];
+  for (let i = 0; i < boxes.length; i++) {
+    if (used[i]) continue;
+    const cy = (boxes[i].top + boxes[i].bottom) / 2;
+    const row = [i];
+    used[i] = true;
+    for (let j = i + 1; j < boxes.length; j++) {
+      if (used[j]) continue;
+      const cj = (boxes[j].top + boxes[j].bottom) / 2;
+      if (Math.abs(cj - cy) <= tol) {
+        row.push(j);
+        used[j] = true;
+      }
+    }
+    if (row.length >= 2) rows.push(row.sort((a, b) => boxes[a].left - boxes[b].left));
+  }
+  return rows;
+}
+var LABEL_ROW_TRACK_COVER = 0.8;
+var LABEL_ROW_TRACK_REACH = 3;
+function labelRowHasTrack(row, candidates, cover = LABEL_ROW_TRACK_COVER, reach = LABEL_ROW_TRACK_REACH) {
+  if (row.length === 0 || candidates.length === 0) return false;
+  let l = Infinity, r = -Infinity, cy = 0, fs = 0;
+  for (const b of row) {
+    if (b.left < l) l = b.left;
+    if (b.right > r) r = b.right;
+    cy += (b.top + b.bottom) / 2;
+    fs += b.bottom - b.top;
+  }
+  cy /= row.length;
+  fs /= row.length;
+  if (!(r > l) || !(fs > 0)) return false;
+  let tl = Infinity, tr = -Infinity, any = false;
+  for (const c of candidates) {
+    if (!(c.right > c.left)) continue;
+    if (Math.abs((c.top + c.bottom) / 2 - cy) > reach * fs) continue;
+    any = true;
+    if (c.left < tl) tl = c.left;
+    if (c.right > tr) tr = c.right;
+  }
+  if (!any) return false;
+  const overlap = Math.min(r, tr) - Math.max(l, tl);
+  return overlap >= cover * (r - l);
+}
+
+// src/legendFit/frameFit.ts
+var FRAME_PAD = 1;
+var MAX_EXTEND_FRACTION = 0.08;
+function planFrameFit(boxes, vb, maxFraction = MAX_EXTEND_FRACTION) {
+  const deferredIdx = [];
+  const rescuedIdx = [];
+  const none = (reason, considered, deferred2, idx = deferredIdx) => ({
+    action: deferred2 > 0 && considered > 0 ? "defer" : "none",
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    newViewBox: vb,
+    considered,
+    rescued: 0,
+    deferred: deferred2,
+    deferredIdx: idx.slice().sort((a, b) => a - b),
+    reason
+  });
+  if (!boxes || boxes.length === 0) return none("no-text", 0, 0);
+  if (!vb || !(vb.w > 0) || !(vb.h > 0)) return none("bad-viewbox", boxes.length, 0);
+  const maxH = vb.w * maxFraction;
+  const maxV = vb.h * maxFraction;
+  const vbRight = vb.x + vb.w;
+  const vbBottom = vb.y + vb.h;
+  let top = 0, right = 0, bottom = 0, left = 0;
+  let rescued = 0, deferred = 0;
+  for (let bi = 0; bi < boxes.length; bi++) {
+    const b = boxes[bi];
+    if (!b || !isFinite(b.left) || !isFinite(b.top) || !isFinite(b.right) || !isFinite(b.bottom)) {
+      continue;
+    }
+    const needTop = vb.y - b.top + FRAME_PAD;
+    const needLeft = vb.x - b.left + FRAME_PAD;
+    const needRight = b.right - vbRight + FRAME_PAD;
+    const needBottom = b.bottom - vbBottom + FRAME_PAD;
+    const worstV = Math.max(needTop, needBottom);
+    const worstH = Math.max(needLeft, needRight);
+    if (worstV <= 0 && worstH <= 0) continue;
+    if (worstV > maxV || worstH > maxH) {
+      deferred++;
+      deferredIdx.push(bi);
+      continue;
+    }
+    let drove = false;
+    if (needTop > 0) {
+      top = Math.max(top, needTop);
+      drove = true;
+    }
+    if (needLeft > 0) {
+      left = Math.max(left, needLeft);
+      drove = true;
+    }
+    if (needRight > 0) {
+      right = Math.max(right, needRight);
+      drove = true;
+    }
+    if (needBottom > 0) {
+      bottom = Math.max(bottom, needBottom);
+      drove = true;
+    }
+    if (drove) {
+      rescued++;
+      rescuedIdx.push(bi);
+    }
+  }
+  if (rescued === 0) {
+    return none(deferred > 0 ? "all-overflow-structural" : "all-inside", boxes.length, deferred);
+  }
+  if (top + bottom > maxV || left + right > maxH) {
+    return none("accumulated-overflow-structural", boxes.length, deferred + rescued, deferredIdx.concat(rescuedIdx));
+  }
+  const parts = [];
+  if (top > 0) parts.push("top+" + round2(top));
+  if (right > 0) parts.push("right+" + round2(right));
+  if (bottom > 0) parts.push("bottom+" + round2(bottom));
+  if (left > 0) parts.push("left+" + round2(left));
+  return {
+    action: "extend",
+    top: round2(top),
+    right: round2(right),
+    bottom: round2(bottom),
+    left: round2(left),
+    newViewBox: {
+      x: round2(vb.x - left),
+      y: round2(vb.y - top),
+      w: round2(vb.w + left + right),
+      h: round2(vb.h + top + bottom)
+    },
+    considered: boxes.length,
+    rescued,
+    deferred,
+    deferredIdx: deferredIdx.slice(),
+    reason: parts.join(",")
+  };
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function viewBoxAttr(vb) {
+  return `${vb.x} ${vb.y} ${vb.w} ${vb.h}`;
+}
+var FIT_TYPE_FLOOR = 10;
+var FIT_SHRINK_FLOOR = 0.8;
+function labelRoom(box, frame, anchor) {
+  if (!box || !frame || ![box.left, box.right, box.top, box.bottom].every(isFinite)) return null;
+  const fl = frame.x + FRAME_PAD, fr = frame.x + frame.w - FRAME_PAD;
+  const ft = frame.y, fb = frame.y + frame.h;
+  if (box.top < ft - FRAME_PAD || box.bottom > fb + FRAME_PAD) return null;
+  let room;
+  if (anchor === "end") {
+    if (box.right > fr) return null;
+    room = box.right - fl;
+  } else if (anchor === "start") {
+    if (box.left < fl) return null;
+    room = fr - box.left;
+  } else {
+    const c = (box.left + box.right) / 2;
+    if (c < fl || c > fr) return null;
+    room = 2 * Math.min(c - fl, fr - c);
+  }
+  return room > 0 ? round2(room) : null;
+}
+function labelFitDecision(width, room, fontSize) {
+  if (!(width > 0) || !(room > 0) || !(fontSize > 0) || width <= room) return { action: "none", fontSize };
+  const floor = Math.min(fontSize, Math.max(FIT_TYPE_FLOOR, fontSize * FIT_SHRINK_FLOOR));
+  const want = Math.floor(fontSize * room / width * 2) / 2;
+  if (want >= floor && want < fontSize) return { action: "shrink", fontSize: want };
+  return { action: "cut", fontSize };
+}
+function cutToFit(full, fits, ell = "\u2026") {
+  if (fits(full)) return full;
+  let lo = 0, hi = full.length;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (fits(full.slice(0, mid) + ell)) lo = mid;
+    else hi = mid - 1;
+  }
+  const digit = (i) => i >= 0 && i < full.length && /[0-9]/.test(full.charAt(i));
+  const sep = (i) => i >= 0 && i < full.length && /[.,]/.test(full.charAt(i));
+  const splits = digit(lo - 1) ? digit(lo) || sep(lo) && digit(lo + 1) : sep(lo - 1) && digit(lo - 2) && digit(lo);
+  if (lo > 0 && splits) {
+    while (lo > 0 && (digit(lo - 1) || sep(lo - 1) && digit(lo - 2))) lo--;
+    while (lo > 0 && /[\s+\-$]/.test(full.charAt(lo - 1))) lo--;
+  }
+  while (lo > 0 && /\s/.test(full.charAt(lo - 1))) lo--;
+  return lo > 0 ? full.slice(0, lo) + ell : "";
+}
+
+// src/legendFit/frameFitDom.ts
+function presentation(el, attr, cssProp, computed) {
+  const own = (e) => (e.getAttribute && e.getAttribute(attr) || e.style && e.style[cssProp] || "").trim();
+  let v = own(el);
+  if (!v) {
+    try {
+      if (typeof getComputedStyle === "function") v = (computed(getComputedStyle(el)) || "").trim();
+    } catch {
+    }
+  }
+  for (let n = el.parentElement; !v && n; n = n.parentElement) v = own(n);
+  return v;
+}
+function anchorOf(el) {
+  const v = presentation(el, "text-anchor", "textAnchor", (cs) => cs.getPropertyValue("text-anchor"));
+  return v === "end" ? "end" : v === "middle" ? "middle" : "start";
+}
+function fontSizeOf(el) {
+  let raw = presentation(el, "font-size", "fontSize", (cs) => cs.fontSize);
+  if (/(em|%)\s*$/.test(raw)) {
+    try {
+      if (typeof getComputedStyle === "function") raw = getComputedStyle(el).fontSize || raw;
+    } catch {
+    }
+  }
+  const v = parseFloat(raw);
+  return v > 0 && !/(em|%)\s*$/.test(raw) ? v : 10;
+}
+function ownText(el) {
+  let s = "";
+  el.childNodes.forEach((n) => {
+    if (n.nodeType === 3) s += n.nodeValue || "";
+  });
+  return s;
+}
+function setOwnText(el, s) {
+  const texts = [];
+  el.childNodes.forEach((n) => {
+    if (n.nodeType === 3) texts.push(n);
+  });
+  if (texts.length === 0) {
+    el.insertBefore(el.ownerDocument.createTextNode(s), el.firstChild);
+    return;
+  }
+  texts[0].nodeValue = s;
+  for (let i = 1; i < texts.length; i++) texts[i].nodeValue = "";
+}
+function rotated(el) {
+  try {
+    const m = el.getCTM ? el.getCTM() : null;
+    return !!m && (Math.abs(m.b) > 1e-6 || Math.abs(m.c) > 1e-6);
+  } catch {
+    return false;
+  }
+}
+function fitLabelToRoom(el, width, room, widthNow, minChars = 0) {
+  const full = ownText(el);
+  const d = labelFitDecision(width, room, fontSizeOf(el));
+  if (d.action === "none") return "none";
+  if (d.action === "shrink") {
+    el.setAttribute("font-size", String(d.fontSize));
+    if (widthNow() <= room + 0.5) return "shrunk";
+  }
+  let fitted = cutToFit(full, (s) => {
+    setOwnText(el, s);
+    return widthNow() <= room + 0.5;
+  });
+  const keep = full.trim();
+  if (minChars > 0 && fitted.length - 1 < minChars && keep.length > minChars) {
+    fitted = Array.from(keep).slice(0, minChars).join("") + "\u2026";
+  }
+  setOwnText(el, fitted);
+  if (!Array.from(el.children).some((c) => c.tagName.toLowerCase() === "title")) {
+    const t = el.ownerDocument.createElementNS("http://www.w3.org/2000/svg", "title");
+    t.textContent = full;
+    el.appendChild(t);
+  }
+  return "cut";
+}
+function fitDeferredLabels(els, frame, measure) {
+  const rep = { deferred: els.length, shrunk: 0, cut: 0, unfixable: 0, labels: [] };
+  for (const el of els) {
+    try {
+      const kids = Array.from(el.children).filter((c) => c.tagName.toLowerCase() !== "title");
+      if (kids.length > 0 || rotated(el)) {
+        rep.unfixable++;
+        continue;
+      }
+      const box = measure(el);
+      if (!box) {
+        rep.unfixable++;
+        continue;
+      }
+      const room = labelRoom(box, frame, anchorOf(el));
+      if (room == null) {
+        rep.unfixable++;
+        continue;
+      }
+      const full = ownText(el);
+      if (!full.trim()) continue;
+      const done = fitLabelToRoom(el, box.right - box.left, room, () => {
+        const b = measure(el);
+        return b ? b.right - b.left : Infinity;
+      });
+      if (done === "none") continue;
+      if (done === "shrunk") rep.shrunk++;
+      else rep.cut++;
+      if (rep.labels.length < 6) rep.labels.push(full.slice(0, 40));
+    } catch {
+      rep.unfixable++;
+    }
+  }
+  return rep;
+}
+var FRAME_FIT_TEXT_CAP = 600;
+function fitTextToFrame(host) {
+  const svg = chartSvgOf(host);
+  if (!svg) return null;
+  const texts = svg.querySelectorAll("text");
+  if (texts.length === 0) return null;
+  if (texts.length > FRAME_FIT_TEXT_CAP) return { skipped: { texts: texts.length, cap: FRAME_FIT_TEXT_CAP } };
+  const userMapper = () => {
+    const ctm = svg.getScreenCTM();
+    if (!ctm) return null;
+    const inv = ctm.inverse();
+    return (r) => {
+      const map = (x, y) => {
+        const p = svg.createSVGPoint();
+        p.x = x;
+        p.y = y;
+        return p.matrixTransform(inv);
+      };
+      const tl = map(r.left, r.top), br = map(r.right, r.bottom);
+      return { left: Math.min(tl.x, br.x), top: Math.min(tl.y, br.y), right: Math.max(tl.x, br.x), bottom: Math.max(tl.y, br.y) };
+    };
+  };
+  const toUser = userMapper();
+  if (!toUser) return null;
+  const vbAttr = svg.getAttribute("viewBox");
+  let vb;
+  if (vbAttr) {
+    const n = vbAttr.trim().split(/[\s,]+/).map(parseFloat);
+    if (n.length !== 4 || n.some((v) => !isFinite(v))) return null;
+    vb = { x: n[0], y: n[1], w: n[2], h: n[3] };
+  } else {
+    const w = parseFloat(svg.getAttribute("width") || "") || host.offsetWidth;
+    const h = parseFloat(svg.getAttribute("height") || "") || host.offsetHeight;
+    if (!(w > 0) || !(h > 0)) return null;
+    vb = { x: 0, y: 0, w, h };
+  }
+  const boxes = [];
+  const els = [];
+  for (let i = 0; i < texts.length; i++) {
+    const el = texts[i];
+    if (isClippedOrScrolled(el, svg)) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width <= 0 && r.height <= 0) continue;
+    boxes.push(toUser(r));
+    els.push(el);
+  }
+  const plan = planFrameFit(boxes, vb);
+  const out = { plan };
+  let frame = vb;
+  if (plan.action === "extend") {
+    svg.setAttribute("viewBox", viewBoxAttr(plan.newViewBox));
+    if (!svg.getAttribute("preserveAspectRatio")) svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    frame = plan.newViewBox;
+  }
+  if (plan.deferredIdx.length > 0) {
+    const after = userMapper();
+    if (after) {
+      out.labels = fitDeferredLabels(plan.deferredIdx.map((i) => els[i]), frame, (el) => {
+        const r = el.getBoundingClientRect();
+        return r.width > 0 || r.height > 0 ? after(r) : null;
+      });
+    }
+  }
+  return out;
+}
+function isClippedOrScrolled(el, stopAt) {
+  let n = el;
+  while (n && n !== stopAt.parentElement) {
+    const tag = n.tagName ? n.tagName.toLowerCase() : "";
+    if (tag === "defs" || tag === "clippath" || tag === "mask" || tag === "symbol") return true;
+    if (n.getAttribute && (n.getAttribute("clip-path") || n.getAttribute("mask"))) return true;
+    if (typeof getComputedStyle === "function") {
+      try {
+        const cs = getComputedStyle(n);
+        if (cs.clipPath && cs.clipPath !== "none") return true;
+        if (cs.overflow === "auto" || cs.overflow === "scroll" || cs.overflowY === "auto" || cs.overflowY === "scroll") return true;
+      } catch {
+      }
+    }
+    n = n.parentElement;
+  }
+  return false;
+}
+
+// src/legendFit/legendReconcileDom.ts
+function readViewBox(svg) {
+  const vbAttr = svg.getAttribute("viewBox");
+  if (vbAttr) {
+    const p = vbAttr.split(/[\s,]+/).map(Number).filter((n) => isFinite(n));
+    if (p.length === 4) return { x: p[0], y: p[1], w: p[2], h: p[3] };
+  }
+  const svgRect = svg.getBoundingClientRect();
+  const w = parseFloat(svg.getAttribute("width") || "") || svgRect.width;
+  const h = parseFloat(svg.getAttribute("height") || "") || svgRect.height;
+  if (w > 0 && h > 0) return { x: 0, y: 0, w, h };
+  return null;
+}
+var FIT_WALK_CAP = 8e3;
+var FONT_SCAN_CAP = 400;
+function smallestRenderedTextPx(svg, ctmScale) {
+  if (!(ctmScale > 0) || !isFinite(ctmScale)) return null;
+  const texts = svg.querySelectorAll("text");
+  let smallest = Infinity;
+  const n = Math.min(texts.length, FONT_SCAN_CAP);
+  for (let i = 0; i < n; i++) {
+    try {
+      const el = texts[i];
+      const r = el.getBoundingClientRect();
+      if (r.width <= 0 && r.height <= 0) continue;
+      const px = parseFloat(getComputedStyle(el).fontSize);
+      if (isFinite(px) && px > 0 && px < smallest) smallest = px;
+    } catch {
+    }
+  }
+  return isFinite(smallest) ? smallest * ctmScale : null;
+}
+function fitSvgToContent(svg) {
+  const vbox = readViewBox(svg);
+  if (!vbox) return { applied: false };
+  const ctm = svg.getScreenCTM();
+  if (!ctm) return { applied: false };
+  const inv = ctm.inverse();
+  const toUser = (r) => {
+    const a = new DOMPoint(r.left, r.top).matrixTransform(inv);
+    const b = new DOMPoint(r.right, r.bottom).matrixTransform(inv);
+    return { left: Math.min(a.x, b.x), right: Math.max(a.x, b.x), top: Math.min(a.y, b.y), bottom: Math.max(a.y, b.y) };
+  };
+  const els = svg.querySelectorAll(FIT_CONTENT_SELECTOR);
+  const rects = [];
+  for (let i = 0; i < els.length && rects.length < FIT_WALK_CAP; i++) {
+    const r = els[i].getBoundingClientRect();
+    if (r.width <= 0 && r.height <= 0) continue;
+    const ur = toUser(r);
+    if (isPhantomBox(ur.right - ur.left, ur.bottom - ur.top, vbox.w, vbox.h)) continue;
+    rects.push(ur);
+  }
+  const smallestTextPx = smallestRenderedTextPx(svg, ctmScaleOf(ctm)) ?? void 0;
+  const plan = planContentFit(rects, vbox, { smallestTextPx });
+  if (plan.action !== "fit") {
+    return { applied: false, declined: plan.reason, smallestTextPx };
+  }
+  svg.setAttribute("viewBox", `${plan.newViewBox.x} ${plan.newViewBox.y} ${plan.newViewBox.w} ${plan.newViewBox.h}`);
+  if (!svg.getAttribute("preserveAspectRatio")) svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  const c = plan.cut;
+  return { applied: true, fit: `L${c.left} R${c.right} T${c.top} B${c.bottom}` };
+}
+function styleDeclaresScroll(inlineStyle, overflow, overflowY) {
+  if (inlineStyle && /overflow(-[xy])?\s*:\s*(auto|scroll)/i.test(inlineStyle)) return true;
+  const v = (s) => s === "auto" || s === "scroll";
+  return v(overflow) || v(overflowY);
+}
+function hasSelfManagedScrollLayout(svg) {
+  const fos = svg.querySelectorAll("foreignObject");
+  if (fos.length === 0) return false;
+  const win = svg.ownerDocument && svg.ownerDocument.defaultView;
+  const CAP = 2e3;
+  let seen = 0;
+  for (let i = 0; i < fos.length; i++) {
+    const kids = fos[i].querySelectorAll("*");
+    for (let j = 0; j < kids.length && seen < CAP; j++, seen++) {
+      const el = kids[j];
+      const inline = el.getAttribute && el.getAttribute("style") || "";
+      let cs = null;
+      if (win) {
+        try {
+          cs = win.getComputedStyle(el);
+        } catch {
+          cs = null;
+        }
+      }
+      if (styleDeclaresScroll(inline, cs?.overflow, cs?.overflowY)) return true;
+    }
+    if (seen >= CAP) break;
+  }
+  return false;
+}
+function thinAxisTicksPhase(svg) {
+  const none = { applied: false, axes: 0, hidden: 0, stride: 1 };
+  const ticks = svg.querySelectorAll(".tick");
+  if (ticks.length < AXIS_THIN_MIN_TICKS) return none;
+  const byAxis = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ticks.length; i++) {
+    const parent = ticks[i].parentElement;
+    if (!parent) continue;
+    const list = byAxis.get(parent);
+    if (list) list.push(ticks[i]);
+    else byAxis.set(parent, [ticks[i]]);
+  }
+  const isRotated = (el) => {
+    let n = el;
+    while (n && n !== svg) {
+      const t = n.getAttribute ? n.getAttribute("transform") : null;
+      if (t && t.indexOf("rotate") >= 0) return true;
+      n = n.parentElement;
+    }
+    return false;
+  };
+  let axesTouched = 0, hiddenTotal = 0, strideUsed = 1, cutTotal = 0, shrunkTotal = 0, nominalAxes = 0, collidingTotal = 0;
+  byAxis.forEach((group, axis) => {
+    if (group.length < AXIS_THIN_MIN_TICKS) return;
+    if (axis.getAttribute("data-lch-ticks-thinned") === "1") return;
+    const texts = [];
+    const boxes = [];
+    let rotated2 = false;
+    for (const tick of group) {
+      const t = tick.querySelector("text");
+      if (!t) continue;
+      if (isRotated(t)) {
+        rotated2 = true;
+        break;
+      }
+      const r = t.getBoundingClientRect();
+      if (r.width <= 0 || r.height <= 0) continue;
+      texts.push(t);
+      boxes.push({ left: r.left, right: r.right, top: r.top, bottom: r.bottom });
+    }
+    if (rotated2 || boxes.length < AXIS_THIN_MIN_TICKS) return;
+    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 (cx < minX) minX = cx;
+      if (cx > maxX) maxX = cx;
+      if (cy < minY) minY = cy;
+      if (cy > maxY) maxY = cy;
+    }
+    if (maxX - minX <= maxY - minY) return;
+    const plan = planAxisTickThin(boxes, AXIS_THIN_GAP);
+    if (plan.hide.length === 0) return;
+    if (axisLabelsAreNominal(texts.map((t) => ownTextOf(t)))) {
+      const anchor = anchorKindOf(texts[0]);
+      const anchors = boxes.map((b) => anchor === "start" ? b.left : anchor === "end" ? b.right : (b.left + b.right) / 2);
+      const rooms = nominalLabelRooms(anchors, AXIS_THIN_GAP);
+      let cut = 0, shrunk = 0;
+      texts.forEach((t, i) => {
+        const width = boxes[i].right - boxes[i].left;
+        if (!(rooms[i] < width)) return;
+        const done = fitLabelToRoom(t, width, Math.max(1, rooms[i]), () => t.getBoundingClientRect().width, 1);
+        if (done === "cut") cut++;
+        else if (done === "shrunk") shrunk++;
+      });
+      if (cut + shrunk === 0) return;
+      const after = texts.map((t) => {
+        const r = t.getBoundingClientRect();
+        return { left: r.left, right: r.right, top: r.top, bottom: r.bottom };
+      }).sort((p, q) => p.left - q.left);
+      let colliding = 0;
+      for (let i = 1; i < after.length; i++) if (after[i].left < after[i - 1].right) colliding++;
+      axis.setAttribute("data-lch-ticks-thinned", "1");
+      axesTouched++;
+      nominalAxes++;
+      cutTotal += cut;
+      shrunkTotal += shrunk;
+      collidingTotal += colliding;
+      return;
+    }
+    for (const idx of plan.hide) texts[idx].setAttribute("display", "none");
+    axis.setAttribute("data-lch-ticks-thinned", "1");
+    axesTouched++;
+    hiddenTotal += plan.hide.length;
+    if (plan.stride > strideUsed) strideUsed = plan.stride;
+  });
+  if (axesTouched === 0) return none;
+  const out = {
+    applied: true,
+    at: "axes" + axesTouched + " hid" + hiddenTotal + " k" + strideUsed + (nominalAxes > 0 ? " cut" + cutTotal + " shr" + shrunkTotal : ""),
+    axes: axesTouched,
+    hidden: hiddenTotal,
+    stride: strideUsed
+  };
+  if (nominalAxes > 0) {
+    out.nominal = true;
+    out.cut = cutTotal;
+    out.shrunk = shrunkTotal;
+    if (collidingTotal > 0) out.colliding = collidingTotal;
+  }
+  return out;
+}
+function ownTextOf(el) {
+  let s = "";
+  el.childNodes.forEach((n) => {
+    if (n.nodeType === 3) s += n.nodeValue || "";
+  });
+  return s.trim() !== "" ? s : el.textContent || "";
+}
+function anchorKindOf(el) {
+  for (let n = el; n; n = n.parentElement) {
+    const v = n.getAttribute && n.getAttribute("text-anchor") || n.style && n.style.textAnchor || "";
+    if (v === "start" || v === "end" || v === "middle") return v;
+  }
+  try {
+    const v = typeof getComputedStyle === "function" ? getComputedStyle(el).getPropertyValue("text-anchor") : "";
+    if (v === "start" || v === "end") return v;
+  } catch {
+  }
+  return "middle";
+}
+function hasRotateAbove(el, stop) {
+  let n = el;
+  while (n && n !== stop) {
+    const t = n.getAttribute ? n.getAttribute("transform") : null;
+    if (t && t.indexOf("rotate") >= 0) return true;
+    n = n.parentElement;
+  }
+  return false;
+}
+function rowSitsOnTrack(els, rowBoxes, svg) {
+  let lca = els[0].parentElement;
+  while (lca && lca !== svg && !els.every((e) => lca.contains(e))) lca = lca.parentElement;
+  if (!lca || lca === svg) return false;
+  if (lca.querySelector(".d3-mark")) return false;
+  const cands = [];
+  const shapes = lca.querySelectorAll("rect, line, path, polyline");
+  for (let i = 0; i < shapes.length; i++) {
+    const el = shapes[i];
+    if (el.closest(".d3-mark")) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width <= 0) continue;
+    cands.push({ left: r.left, right: r.right, top: r.top, bottom: r.bottom });
+  }
+  return labelRowHasTrack(rowBoxes, cands);
+}
+function thinLabelRowsPhase(svg) {
+  const none = { applied: false, rows: 0, hidden: 0, stride: 0 };
+  const all = svg.querySelectorAll("text");
+  if (all.length < LABEL_ROW_MIN_TEXTS) return none;
+  const texts = [];
+  const boxes = [];
+  for (let i = 0; i < all.length; i++) {
+    const t = all[i];
+    if (t.closest("svg") !== svg) continue;
+    if (t.closest(".tick, g.llm-zoom-pad, g.llm-zoom-btn, g.llm-map-labels, foreignObject")) continue;
+    if (t.getAttribute("display") === "none") continue;
+    if (!isNumericLabelText(t.textContent || "")) continue;
+    if (hasRotateAbove(t, svg)) continue;
+    const r = t.getBoundingClientRect();
+    if (r.width <= 0 || r.height <= 0) continue;
+    texts.push(t);
+    boxes.push({ left: r.left, right: r.right, top: r.top, bottom: r.bottom });
+  }
+  if (boxes.length < LABEL_ROW_MIN_TEXTS) return none;
+  let rowsTouched = 0, hiddenTotal = 0, strideUsed = 0;
+  for (const row of groupLabelRows(boxes)) {
+    if (row.length < LABEL_ROW_MIN_TEXTS) continue;
+    const rowBoxes = row.map((i) => boxes[i]);
+    if (!rowSitsOnTrack(row.map((i) => texts[i]), rowBoxes, svg)) continue;
+    const plan = planAxisTickThin(rowBoxes, AXIS_THIN_GAP, LABEL_ROW_MIN_TEXTS);
+    if (plan.hide.length === 0) continue;
+    for (const k of plan.hide) {
+      texts[row[k]].setAttribute("display", "none");
+      texts[row[k]].setAttribute("data-lch-label-thinned", "1");
+    }
+    rowsTouched++;
+    hiddenTotal += plan.hide.length;
+    if (plan.stride > strideUsed) strideUsed = plan.stride;
+  }
+  if (rowsTouched === 0) return none;
+  return {
+    applied: true,
+    lt: "rows" + rowsTouched + " hid" + hiddenTotal + " k" + strideUsed,
+    rows: rowsTouched,
+    hidden: hiddenTotal,
+    stride: strideUsed
+  };
+}
+function axisThinReportOf(r) {
+  const out = { axes: r.axes, hidden: r.hidden, stride: r.stride };
+  if (r.nominal) {
+    out.nominal = true;
+    out.cut = r.cut;
+    out.shrunk = r.shrunk;
+    if (r.colliding) out.colliding = r.colliding;
+  }
+  return out;
+}
+function reconcileLegendInSvg(svg, opts = {}) {
+  if (svg.getAttribute("data-lch-legend-fixed") === "1") return { applied: false, reason: "already-fixed" };
+  if (hasSelfManagedScrollLayout(svg)) {
+    svg.setAttribute("data-lch-legend-fixed", "1");
+    return { applied: false, reason: "self-managed-layout" };
+  }
+  const legendRes = reconcileLegendPhase(svg, opts);
+  let cbRes = { applied: false };
+  try {
+    cbRes = reconcileColorbarPhase(svg, opts);
+  } catch {
+  }
+  let atRes = { applied: false, axes: 0, hidden: 0, stride: 1 };
+  try {
+    atRes = thinAxisTicksPhase(svg);
+  } catch {
+  }
+  let ltRes = { applied: false, rows: 0, hidden: 0, stride: 0 };
+  try {
+    ltRes = thinLabelRowsPhase(svg);
+  } catch {
+  }
+  let btRes = { applied: false };
+  try {
+    btRes = reconcileBottomTextPhase(svg);
+  } catch {
+  }
+  let fitRes = { applied: false };
+  try {
+    fitRes = fitSvgToContent(svg);
+  } catch {
+  }
+  return {
+    ...legendRes,
+    applied: legendRes.applied || cbRes.applied || atRes.applied || ltRes.applied || btRes.applied || fitRes.applied,
+    reason: legendRes.applied ? legendRes.reason : cbRes.applied ? "colorbar" : atRes.applied ? "axis-thin" : ltRes.applied ? "label-thin" : btRes.applied ? "bottom-text" : fitRes.applied ? "fit" : legendRes.reason,
+    cb: cbRes.cb,
+    bt: btRes.bt,
+    at: atRes.at,
+    axisThin: atRes.applied ? axisThinReportOf(atRes) : void 0,
+    lt: ltRes.lt,
+    labelThin: ltRes.applied ? { rows: ltRes.rows, hidden: ltRes.hidden, stride: ltRes.stride } : void 0,
+    fit: fitRes.fit,
+    // Only when the fit DECLINED for a reason of its own ("clamped" / "legibility") —
+    // not for "fits" or "no-content", which are silence for the right reasons.
+    fitDeclined: fitRes.declined === "clamped" || fitRes.declined === "legibility" ? fitRes.declined : void 0,
+    smallestTextPx: fitRes.smallestTextPx !== void 0 ? Math.round(fitRes.smallestTextPx * 10) / 10 : void 0
+  };
+}
+function findSignatureLegendGroups(svg) {
+  const SHAPES = "rect,circle,ellipse,line,path,polygon,polyline";
+  const PLOT_MARK = ".d3-mark:not(.d3-legend-mark)";
+  const out = [];
+  const px = (el) => {
+    const r = el.getBoundingClientRect();
+    return { left: r.left, top: r.top, right: r.right, bottom: r.bottom };
+  };
+  const walk = (g) => {
+    for (let i = 0; i < g.children.length; i++) {
+      const ch = g.children[i];
+      const tag = ch.tagName.toLowerCase();
+      if (tag !== "g") continue;
+      if (ch.matches("g.llm-zoom-pad, g.llm-zoom-btn")) continue;
+      const markFree = !ch.querySelector(PLOT_MARK) && !!ch.querySelector("text") && !!ch.querySelector(SHAPES);
+      if (!markFree) {
+        walk(ch);
+        continue;
+      }
+      if (ch.querySelector("g.tick, path.domain") || /axis/i.test(ch.getAttribute("class") || "")) continue;
+      const shapes = Array.from(ch.querySelectorAll(SHAPES)).map(px);
+      const texts = Array.from(ch.querySelectorAll("text")).map(px).filter((t) => t.right > t.left);
+      if (isLegendSignature(swatchPairs(shapes, texts))) out.push(ch);
+    }
+  };
+  walk(svg);
+  return out;
+}
+function reconcileLegendPhase(svg, opts = {}) {
+  const legendMarks = svg.querySelectorAll(".d3-legend-mark");
+  let source = "class";
+  let signatureGroups = [];
+  if (legendMarks.length === 0) {
+    signatureGroups = findSignatureLegendGroups(svg);
+    if (signatureGroups.length === 0) {
+      svg.setAttribute("data-lch-legend-fixed", "1");
+      return { applied: false, reason: "no-legend" };
+    }
+    source = "signature";
+  }
+  const plotMarks = svg.querySelectorAll(".d3-mark");
+  if (plotMarks.length === 0) {
+    svg.setAttribute("data-lch-legend-fixed", "1");
+    return { applied: false, reason: "no-marks", source };
+  }
+  const groupHasPlotMark = (el) => {
+    const dm = el.querySelectorAll(".d3-mark");
+    for (let j = 0; j < dm.length; j++) if (!dm[j].classList.contains("d3-legend-mark")) return true;
+    return false;
+  };
+  let legendGroup = source === "signature" ? signatureGroups[0] : legendMarks[0].parentElement;
+  while (source === "class" && legendGroup && legendGroup !== svg) {
+    let containsAll = true;
+    for (let i = 0; i < legendMarks.length; i++) {
+      if (!legendGroup.contains(legendMarks[i])) {
+        containsAll = false;
+        break;
+      }
+    }
+    if (containsAll) break;
+    legendGroup = legendGroup.parentElement;
+  }
+  let legendContainers;
+  let mixedGroup = false;
+  if (source === "signature") {
+    legendContainers = signatureGroups;
+  } else if (!legendGroup || legendGroup === svg) {
+    const set = /* @__PURE__ */ new Set();
+    for (let i = 0; i < legendMarks.length; i++) {
+      let el = legendMarks[i];
+      while (el && el.parentElement !== svg) el = el.parentElement;
+      if (!el) return { applied: false, reason: "no-clean-group" };
+      set.add(el);
+    }
+    legendContainers = Array.from(set);
+    for (const c of legendContainers) {
+      if (groupHasPlotMark(c)) return { applied: false, reason: "impure-group" };
+    }
+    legendGroup = legendContainers[0];
+  } else {
+    if (groupHasPlotMark(legendGroup)) {
+      mixedGroup = true;
+      legendContainers = Array.from(legendMarks);
+    } else {
+      legendContainers = [legendGroup];
+    }
+  }
+  const ctm = svg.getScreenCTM();
+  if (!ctm) return { applied: false, reason: "no-ctm" };
+  const inv = ctm.inverse();
+  const toUserRect = (r) => {
+    const a = new DOMPoint(r.left, r.top).matrixTransform(inv);
+    const b = new DOMPoint(r.right, r.bottom).matrixTransform(inv);
+    return { left: Math.min(a.x, b.x), right: Math.max(a.x, b.x), top: Math.min(a.y, b.y), bottom: Math.max(a.y, b.y) };
+  };
+  const userRectOf = (el) => toUserRect(el.getBoundingClientRect());
+  let vbox = null;
+  const vbAttr = svg.getAttribute("viewBox");
+  if (vbAttr) {
+    const p = vbAttr.split(/[\s,]+/).map(Number).filter((n) => isFinite(n));
+    if (p.length === 4) vbox = { x: p[0], y: p[1], w: p[2], h: p[3] };
+  }
+  if (!vbox) {
+    const svgRect = svg.getBoundingClientRect();
+    const w = parseFloat(svg.getAttribute("width") || "") || svgRect.width;
+    const h = parseFloat(svg.getAttribute("height") || "") || svgRect.height;
+    if (w > 0 && h > 0) vbox = { x: 0, y: 0, w, h };
+  }
+  if (!vbox) return { applied: false, reason: "no-viewbox" };
+  let lbL = Infinity, lbT = Infinity, lbR = -Infinity, lbB = -Infinity;
+  for (const c of legendContainers) {
+    const cb = userRectOf(c);
+    lbL = Math.min(lbL, cb.left);
+    lbT = Math.min(lbT, cb.top);
+    lbR = Math.max(lbR, cb.right);
+    lbB = Math.max(lbB, cb.bottom);
+  }
+  const legendBox = { left: lbL, top: lbT, right: lbR, bottom: lbB };
+  const tol = Math.max(8, vbox.w * 0.015);
+  const isOrHasPlotMark = (el) => {
+    if (el.matches && el.matches(".d3-mark") && !(el.classList && el.classList.contains("d3-legend-mark"))) return true;
+    return groupHasPlotMark(el);
+  };
+  const furniture = legendContainers.slice();
+  if (mixedGroup) {
+    const xTol = Math.min(4, tol);
+    const yPad = Math.max(28, legendBox.bottom - legendBox.top);
+    const cand = legendGroup.querySelectorAll("text, rect");
+    for (let i = 0; i < cand.length; i++) {
+      const el = cand[i];
+      if (furniture.indexOf(el) >= 0) continue;
+      if (isOrHasPlotMark(el)) continue;
+      const ub = userRectOf(el);
+      if (ub.right <= ub.left || ub.bottom <= ub.top) continue;
+      if (ub.left < legendBox.left - xTol) continue;
+      if (ub.bottom < legendBox.top - yPad || ub.top > legendBox.bottom + yPad) continue;
+      furniture.push(el);
+    }
+  } else {
+    const parent = legendGroup.parentElement;
+    if (parent) {
+      const sibs = parent.children;
+      for (let i = 0; i < sibs.length; i++) {
+        const el = sibs[i];
+        if (furniture.indexOf(el) >= 0) continue;
+        const tag = el.tagName.toLowerCase();
+        if (tag === "defs" || tag === "style" || tag === "title") continue;
+        if (isOrHasPlotMark(el)) continue;
+        const ub = userRectOf(el);
+        if (ub.right <= ub.left || ub.bottom <= ub.top) continue;
+        if (ub.left >= legendBox.left - tol) furniture.push(el);
+      }
+    }
+  }
+  const CAP = 4e3;
+  const inFurniture = (node) => furniture.some((f) => f.contains(node));
+  let totalDx = 0, totalDy = 0, totalExt = 0, passes = 0;
+  let lastReason = "no-overlap";
+  let lastW = vbox.w;
+  for (let pass = 0; pass < 3; pass++) {
+    const ctmP = svg.getScreenCTM();
+    if (!ctmP) break;
+    const invP = ctmP.inverse();
+    const toUserP = (r) => {
+      const a = new DOMPoint(r.left, r.top).matrixTransform(invP);
+      const b = new DOMPoint(r.right, r.bottom).matrixTransform(invP);
+      return { left: Math.min(a.x, b.x), right: Math.max(a.x, b.x), top: Math.min(a.y, b.y), bottom: Math.max(a.y, b.y) };
+    };
+    let vbP = null;
+    const vbA = svg.getAttribute("viewBox");
+    if (vbA) {
+      const p = vbA.split(/[\s,]+/).map(Number).filter((n) => isFinite(n));
+      if (p.length === 4) vbP = { x: p[0], y: p[1], w: p[2], h: p[3] };
+    }
+    if (!vbP) vbP = vbox;
+    let uL = Infinity, uT = Infinity, uR = -Infinity, uB = -Infinity;
+    for (const f of furniture) {
+      const ub = toUserP(f.getBoundingClientRect());
+      uL = Math.min(uL, ub.left);
+      uT = Math.min(uT, ub.top);
+      uR = Math.max(uR, ub.right);
+      uB = Math.max(uB, ub.bottom);
+    }
+    const unionBox = { left: uL, top: uT, right: uR, bottom: uB };
+    const plotRects = [];
+    for (let i = 0; i < plotMarks.length && plotRects.length < CAP; i++) {
+      if (inFurniture(plotMarks[i])) continue;
+      const r = plotMarks[i].getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) plotRects.push(toUserP(r));
+    }
+    const texts = svg.querySelectorAll("text");
+    for (let i = 0; i < texts.length && plotRects.length < CAP; i++) {
+      if (inFurniture(texts[i])) continue;
+      const r = texts[i].getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) plotRects.push(toUserP(r));
+    }
+    const side = source === "class" ? "right" : colorbarReconcileSide(unionBox, vbP);
+    if (!side) {
+      lastReason = "not-a-margin-legend";
+      break;
+    }
+    const plan = planLegendReconcile(unionBox, plotRects, vbP, opts, side);
+    lastReason = plan.reason;
+    if (plan.action !== "reserve") break;
+    svg.setAttribute("viewBox", `${plan.newViewBox.x} ${plan.newViewBox.y} ${plan.newViewBox.w} ${plan.newViewBox.h}`);
+    if (!svg.getAttribute("preserveAspectRatio")) svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    for (const f of furniture) {
+      const prior = f.getAttribute("transform") || "";
+      f.setAttribute("transform", `translate(${plan.legendDx},${plan.legendDy}) ${prior}`.trim());
+    }
+    totalDx += plan.legendDx;
+    totalDy += plan.legendDy;
+    totalExt += plan.ext;
+    lastW = plan.newViewBox.w;
+    passes++;
+  }
+  svg.setAttribute("data-lch-legend-fixed", "1");
+  if (passes === 0) return { applied: false, reason: lastReason, furniture: furniture.length, source };
+  return {
+    applied: true,
+    reason: passes > 1 ? `reserve-x${passes}` : "reserve",
+    dx: totalDx,
+    dy: totalDy || void 0,
+    ext: totalExt,
+    newW: lastW,
+    furniture: furniture.length,
+    source
+  };
+}
+function findColorbarFurniture(svg) {
+  const none = { groups: [], bars: [] };
+  const gradIds = /* @__PURE__ */ new Set();
+  const grads = svg.querySelectorAll("linearGradient[id], radialGradient[id]");
+  for (let i = 0; i < grads.length; i++) {
+    const id = grads[i].getAttribute("id");
+    if (id) gradIds.add("#" + id);
+  }
+  if (gradIds.size === 0) return none;
+  const bars = [];
+  const rects = svg.querySelectorAll("rect");
+  for (let i = 0; i < rects.length; i++) {
+    const r = rects[i];
+    if (r.classList && r.classList.contains("d3-mark") && !r.classList.contains("d3-legend-mark")) continue;
+    const fill = r.getAttribute("fill") || r.style && r.style.fill || "";
+    const m = /url\((#[^)\s]+)\)/.exec(fill);
+    if (m && gradIds.has(m[1])) bars.push(r);
+  }
+  if (bars.length === 0) return none;
+  const furnSet = /* @__PURE__ */ new Set();
+  for (const bar of bars) {
+    const p = bar.parentElement;
+    furnSet.add(p && p !== svg && p.tagName.toLowerCase() === "g" ? p : bar);
+  }
+  return { groups: Array.from(furnSet), bars };
+}
+function barHasMarkInkUnderIt(svg, bar, ctm, inFurniture) {
+  const probes = colorbarProbePoints(bar);
+  if (probes.length === 0) return false;
+  const screen = probes.map((p) => new DOMPoint(p.x, p.y).matrixTransform(ctm));
+  const marks = svg.querySelectorAll(".d3-mark");
+  const hit = new Array(probes.length).fill(false);
+  let hits = 0;
+  for (let i = 0; i < marks.length && hits < probes.length; i++) {
+    const el = marks[i];
+    if (inFurniture(el)) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width <= 0 || r.height <= 0) continue;
+    const geo = el;
+    let inv = null;
+    const canProbe = typeof geo.isPointInFill === "function";
+    if (canProbe) {
+      const m = el.getScreenCTM();
+      inv = m ? m.inverse() : null;
+    }
+    for (let p = 0; p < screen.length; p++) {
+      if (hit[p]) continue;
+      const s = screen[p];
+      if (s.x < r.left || s.x > r.right || s.y < r.top || s.y > r.bottom) continue;
+      let painted = true;
+      if (canProbe && inv) {
+        const q = new DOMPoint(s.x, s.y).matrixTransform(inv);
+        try {
+          painted = geo.isPointInFill(q) || typeof geo.isPointInStroke === "function" && geo.isPointInStroke(q);
+        } catch {
+          painted = true;
+        }
+      }
+      if (painted) {
+        hit[p] = true;
+        hits++;
+      }
+    }
+  }
+  return colorbarOnPlot(hits, probes.length);
+}
+function reconcileColorbarPhase(svg, opts = {}) {
+  const found = findColorbarFurniture(svg);
+  const furniture = found.groups;
+  if (furniture.length === 0) return { applied: false, reason: "no-colorbar" };
+  const vbox0 = readViewBox(svg);
+  if (!vbox0) return { applied: false, reason: "no-viewbox" };
+  const inFurniture = (node) => furniture.some((f) => f === node || f.contains(node));
+  const CAP = 4e3;
+  let totalDx = 0, totalDy = 0, totalExt = 0, passes = 0;
+  let lastReason = "no-overlap";
+  let sideUsed = "bottom";
+  for (let pass = 0; pass < 3; pass++) {
+    const ctm = svg.getScreenCTM();
+    if (!ctm) break;
+    const inv = ctm.inverse();
+    const toUser = (r) => {
+      const a = new DOMPoint(r.left, r.top).matrixTransform(inv);
+      const b = new DOMPoint(r.right, r.bottom).matrixTransform(inv);
+      return { left: Math.min(a.x, b.x), right: Math.max(a.x, b.x), top: Math.min(a.y, b.y), bottom: Math.max(a.y, b.y) };
+    };
+    const vbP = readViewBox(svg) || vbox0;
+    let uL = Infinity, uT = Infinity, uR = -Infinity, uB = -Infinity;
+    for (const f of furniture) {
+      const ub = toUser(f.getBoundingClientRect());
+      uL = Math.min(uL, ub.left);
+      uT = Math.min(uT, ub.top);
+      uR = Math.max(uR, ub.right);
+      uB = Math.max(uB, ub.bottom);
+    }
+    const unionBox = { left: uL, top: uT, right: uR, bottom: uB };
+    const plotRects = [];
+    const marks = svg.querySelectorAll(".d3-mark");
+    for (let i = 0; i < marks.length && plotRects.length < CAP; i++) {
+      if (inFurniture(marks[i])) continue;
+      const r = marks[i].getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) plotRects.push(toUser(r));
+    }
+    const markCount = plotRects.length;
+    const texts = svg.querySelectorAll("text");
+    for (let i = 0; i < texts.length && plotRects.length < CAP; i++) {
+      if (inFurniture(texts[i])) continue;
+      const r = texts[i].getBoundingClientRect();
+      if (r.width > 0 && r.height > 0) plotRects.push(toUser(r));
+    }
+    const side = colorbarReconcileSide(unionBox, vbP);
+    if (!side) {
+      lastReason = "not-a-margin-colorbar";
+      break;
+    }
+    if (side === "right") {
+      let bL = Infinity, bT = Infinity, bR = -Infinity, bB = -Infinity;
+      for (const bar of found.bars) {
+        const bb = toUser(bar.getBoundingClientRect());
+        bL = Math.min(bL, bb.left);
+        bT = Math.min(bT, bb.top);
+        bR = Math.max(bR, bb.right);
+        bB = Math.max(bB, bb.bottom);
+      }
+      const barBox = { left: bL, top: bT, right: bR, bottom: bB };
+      const markRects = plotRects.slice(0, markCount);
+      if (!(bR > -Infinity) || !colorbarSitsOnMarks(barBox, markRects) || !barHasMarkInkUnderIt(svg, barBox, ctm, inFurniture)) {
+        lastReason = "colorbar-clear-of-marks";
+        break;
+      }
+    }
+    sideUsed = side;
+    const plan = planLegendReconcile(unionBox, plotRects, vbP, opts, side);
+    lastReason = plan.reason;
+    if (plan.action !== "reserve") break;
+    svg.setAttribute("viewBox", `${plan.newViewBox.x} ${plan.newViewBox.y} ${plan.newViewBox.w} ${plan.newViewBox.h}`);
+    if (!svg.getAttribute("preserveAspectRatio")) svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    for (const f of furniture) {
+      const prior = f.getAttribute("transform") || "";
+      f.setAttribute("transform", `translate(${plan.legendDx},${plan.legendDy}) ${prior}`.trim());
+    }
+    totalDx += plan.legendDx;
+    totalDy += plan.legendDy;
+    totalExt += plan.ext;
+    passes++;
+  }
+  if (passes === 0) return { applied: false, reason: lastReason };
+  return {
+    applied: true,
+    reason: "reserve",
+    cb: sideUsed === "right" ? `dx${totalDx} w+${totalExt}` : `dy${totalDy} h+${totalExt}`
+  };
+}
+function reconcileBottomTextPhase(svg) {
+  const vbox = readViewBox(svg);
+  if (!vbox) return { applied: false };
+  const ctm = svg.getScreenCTM();
+  if (!ctm) return { applied: false };
+  const inv = ctm.inverse();
+  const toUser = (r) => {
+    const a = new DOMPoint(r.left, r.top).matrixTransform(inv);
+    const b = new DOMPoint(r.right, r.bottom).matrixTransform(inv);
+    return { left: Math.min(a.x, b.x), right: Math.max(a.x, b.x), top: Math.min(a.y, b.y), bottom: Math.max(a.y, b.y) };
+  };
+  const tickEls = svg.querySelectorAll(".tick text");
+  if (tickEls.length === 0) return { applied: false };
+  const tickBoxes = [];
+  for (let i = 0; i < tickEls.length; i++) {
+    const r = tickEls[i].getBoundingClientRect();
+    if (r.width > 0 && r.height > 0) tickBoxes.push(toUser(r));
+  }
+  if (tickBoxes.length === 0) return { applied: false };
+  const inTick = (n) => {
+    let p = n;
+    while (p) {
+      if (p.classList && p.classList.contains("tick")) return true;
+      p = p.parentElement;
+    }
+    return false;
+  };
+  const GAP = 6;
+  let moved = 0, maxDy = 0, maxBottom = -Infinity;
+  const texts = svg.querySelectorAll("text");
+  const CAP = 4e3;
+  for (let i = 0; i < texts.length && i < CAP; i++) {
+    const el = texts[i];
+    if (inTick(el)) continue;
+    if (el.classList && (el.classList.contains("d3-mark") || el.classList.contains("d3-legend-mark"))) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width <= 0 || r.height <= 0) continue;
+    const box = toUser(r);
+    const prior = el.getAttribute("transform") || "";
+    const plan = planBottomTextPush(box, tickBoxes, GAP, prior);
+    if (!plan.move) continue;
+    el.setAttribute("transform", `translate(0,${plan.dy}) ${prior}`.trim());
+    moved++;
+    if (plan.dy > maxDy) maxDy = plan.dy;
+    const nb = box.bottom + plan.dy;
+    if (nb > maxBottom) maxBottom = nb;
+  }
+  if (moved === 0) return { applied: false };
+  if (maxBottom > vbox.y + vbox.h) {
+    const newH = maxBottom - vbox.y + GAP;
+    svg.setAttribute("viewBox", `${vbox.x} ${vbox.y} ${vbox.w} ${newH}`);
+    if (!svg.getAttribute("preserveAspectRatio")) svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+  }
+  return { applied: true, bt: `moved${moved} dy${Math.round(maxDy)}` };
+}
+export {
+  AXIS_THIN_GAP,
+  AXIS_THIN_MIN_TICKS,
+  BOTTOM_TEXT_MIN_TICK_HITS,
+  COLORBAR_ON_PLOT_COVER,
+  FIT_PAD,
+  FIT_SHRINK_FLOOR,
+  FIT_TYPE_FLOOR,
+  FRAME_FIT_TEXT_CAP,
+  FRAME_PAD,
+  LABEL_ROW_MIN_TEXTS,
+  LABEL_ROW_TRACK_COVER,
+  LABEL_ROW_TRACK_REACH,
+  LABEL_ROW_Y_TOLERANCE,
+  LEGIBILITY_GRACE_PX,
+  MAX_EXTEND_FRACTION,
+  MAX_FIT_FRACTION,
+  MAX_GUTTER_FRACTION,
+  MIN_LEGIBLE_PX,
+  MIN_OVERLAP,
+  SIGNATURE_MIN_PAIRS,
+  SWATCH_LABEL_GAP_PX,
+  SWATCH_MAX_PX,
+  axisLabelsAreNominal,
+  bottommostOverlappingPlotEdge,
+  colorbarOnPlot,
+  colorbarProbePoints,
+  colorbarReconcileSide,
+  colorbarSitsOnMarks,
+  cutToFit,
+  findColorbarFurniture,
+  findSignatureLegendGroups,
+  fitDeferredLabels,
+  fitLabelToRoom,
+  fitTextToFrame,
+  groupLabelRows,
+  isClippedOrScrolled,
+  isDateLikeLabelText,
+  isLegendSignature,
+  isNumericLabelText,
+  isOrderedAxisLabelText,
+  labelFitDecision,
+  labelRoom,
+  labelRowHasTrack,
+  nominalLabelRooms,
+  planAxisTickThin,
+  planBottomTextPush,
+  planContentFit,
+  planFrameFit,
+  planLegendReconcile,
+  reconcileLegendInSvg,
+  rightmostOverlappingPlotEdge,
+  smallestRenderedTextPx,
+  styleDeclaresScroll,
+  swatchPairs,
+  viewBoxAttr
+};