@diagrammo/dgmo 0.49.0 → 0.50.1

package/dist/chunk-FA6K3FWM.js

@@ -0,0 +1,940 @@
+import {
+  renderInlineText
+} from "./chunk-3HDBAXF5.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-HEVYAHLW.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-7UEMZREK.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  LEGEND_GROUP_GAP
+} from "./chunk-HQCHYB5F.js";
+import {
+  measureText
+} from "./chunk-5LWQH6QV.js";
+import {
+  getSeriesColors,
+  mix,
+  shapeFill,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-FJUNPCYI.js";
+import {
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/bracket/renderer.ts
+import * as d3Selection from "d3-selection";
+
+// src/bracket/layout.ts
+var BOX_W = 176;
+var BOX_H = 30;
+var PAIR_GAP = 8;
+var ROW = 82;
+var COL_W = 220;
+var COMMENT_W = BOX_W - 14;
+var HALF_SPAN = (BOX_H + PAIR_GAP) / 2;
+function stripInline(s) {
+  return s.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*|__|\*|_|`/g, "");
+}
+function wrapText(text, maxW, fs) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    const attempt = cur ? `${cur} ${w}` : w;
+    if (!cur || measureText(stripInline(attempt), fs) * 1.06 <= maxW)
+      cur = attempt;
+    else {
+      lines.push(cur);
+      cur = w;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines.length ? lines : [""];
+}
+function commentaryLineCount(commentary) {
+  return commentary.reduce((s, l) => s + wrapText(l, COMMENT_W, 11).length, 0);
+}
+function mean(xs) {
+  return xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function nextPow2(n) {
+  let p = 1;
+  while (p < n) p *= 2;
+  return Math.max(2, p);
+}
+function seedOrder(b) {
+  let order = [1];
+  while (order.length < b) {
+    const n = order.length * 2;
+    const next = [];
+    for (const s of order) {
+      next.push(s);
+      next.push(n + 1 - s);
+    }
+    order = next;
+  }
+  return order;
+}
+function winnerNameOf(n) {
+  if (n.winner === "top") return n.topName;
+  if (n.winner === "bot") return n.botName;
+  return null;
+}
+function resolveNames(nodes) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const ordered = [...nodes].sort((a, b) => a.round - b.round);
+  for (const n of ordered) {
+    const tc = n.topChildId !== null ? byId.get(n.topChildId) : void 0;
+    const bc = n.botChildId !== null ? byId.get(n.botChildId) : void 0;
+    n.topName = tc ? winnerNameOf(tc) : n.topSeedName;
+    n.botName = bc ? winnerNameOf(bc) : n.botSeedName;
+  }
+}
+function applyResults(nodes, results, diagnostics) {
+  const pending = results.filter((r) => r.decided);
+  const done = /* @__PURE__ */ new Set();
+  for (let guard = 0; guard < pending.length + 2; guard++) {
+    resolveNames(nodes);
+    let progressed = false;
+    for (const r of pending) {
+      if (done.has(r)) continue;
+      const node = [...nodes].sort((a, b) => a.round - b.round).find(
+        (n) => n.winner === null && (n.topName === r.p1 && n.botName === r.p2 || n.topName === r.p2 && n.botName === r.p1)
+      );
+      if (node) {
+        node.winner = node.topName === r.p1 ? "top" : "bot";
+        node.score = r.score;
+        node.commentary = [...r.commentary];
+        node.homeName = r.home;
+        done.add(r);
+        progressed = true;
+      }
+    }
+    if (!progressed) break;
+  }
+  resolveNames(nodes);
+  for (const r of pending) {
+    if (!done.has(r)) {
+      diagnostics.push(
+        makeDgmoError(
+          r.lineNumber,
+          `No open matchup between "${r.p1}" and "${r.p2}" \u2014 check the seeding or earlier results.`,
+          "warning"
+        )
+      );
+    }
+  }
+  for (const r of results) {
+    if (r.decided) continue;
+    const has = nodes.some(
+      (n) => n.topName === r.p1 && n.botName === r.p2 || n.topName === r.p2 && n.botName === r.p1
+    );
+    if (!has) {
+      diagnostics.push(
+        makeDgmoError(
+          r.lineNumber,
+          `Pending matchup "${r.p1} vs ${r.p2}" doesn't line up with the seeded bracket.`,
+          "warning"
+        )
+      );
+    }
+  }
+}
+function buildSeededSide(seeds, results, side, nextId, diagnostics) {
+  const seedByNum = /* @__PURE__ */ new Map();
+  for (const s of seeds)
+    if (!seedByNum.has(s.seed)) seedByNum.set(s.seed, s.name);
+  const n = seeds.length;
+  const nodes = [];
+  if (n < 2) {
+    return buildCasualSide(results, side, nextId, diagnostics);
+  }
+  const b = nextPow2(n);
+  const order = seedOrder(b);
+  let level = order.map((seedNo) => ({
+    kind: "seed",
+    seedNo,
+    name: seedNo <= n ? seedByNum.get(seedNo) ?? null : null,
+    phantom: seedNo > n
+  }));
+  const carrierName = (c) => c.kind === "seed" ? c.name : null;
+  const carrierChild = (c) => c.kind === "match" ? c.id : null;
+  let round = 1;
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const a = level[i];
+      const bb = level[i + 1];
+      const aPhantom = a.kind === "seed" && a.phantom;
+      const bPhantom = bb.kind === "seed" && bb.phantom;
+      if (aPhantom && !bPhantom) {
+        next.push(bb);
+      } else if (bPhantom && !aPhantom) {
+        next.push(a);
+      } else if (aPhantom && bPhantom) {
+        next.push(a);
+      } else {
+        const id = nextId();
+        nodes[id] = {
+          id,
+          round,
+          side,
+          topSeedName: carrierName(a),
+          botSeedName: carrierName(bb),
+          topChildId: carrierChild(a),
+          botChildId: carrierChild(bb),
+          topName: null,
+          botName: null,
+          winner: null,
+          score: null,
+          commentary: [],
+          homeName: null,
+          lineNumber: null,
+          isChampionship: false,
+          y: 0,
+          x: 0
+        };
+        next.push({ kind: "match", id });
+      }
+    }
+    level = next;
+    round++;
+  }
+  const rootId = level[0]?.kind === "match" ? level[0].id : null;
+  const compact = nodes.filter(Boolean);
+  applyResults(compact, results, diagnostics);
+  const rounds = compact.reduce((m, x) => Math.max(m, x.round), 0);
+  return { nodes: compact, rootId, rounds };
+}
+function buildCasualSide(matches, side, nextId, diagnostics) {
+  const nodes = matches.map((m) => {
+    const id = nextId();
+    return {
+      id,
+      round: 1,
+      side,
+      topSeedName: m.p1,
+      botSeedName: m.p2,
+      topChildId: null,
+      botChildId: null,
+      topName: m.p1,
+      botName: m.p2,
+      winner: m.decided ? "top" : null,
+      score: m.score,
+      commentary: [...m.commentary],
+      homeName: m.home,
+      lineNumber: m.lineNumber,
+      isChampionship: false,
+      y: 0,
+      x: 0
+    };
+  });
+  const winnerOf = (idx) => matches[idx].decided ? matches[idx].p1 : null;
+  const feeder = (p, idx) => {
+    for (let j = idx - 1; j >= 0; j--) {
+      if (winnerOf(j) === p) return j;
+    }
+    return null;
+  };
+  const baseId = nodes.length ? nodes[0].id : 0;
+  for (let idx = 0; idx < matches.length; idx++) {
+    const m = matches[idx];
+    const tf = feeder(m.p1, idx);
+    const bf = feeder(m.p2, idx);
+    nodes[idx].topChildId = tf !== null ? baseId + tf : null;
+    nodes[idx].botChildId = bf !== null ? baseId + bf : null;
+  }
+  const roundMemo = new Array(matches.length).fill(0);
+  const inProgress = /* @__PURE__ */ new Set();
+  const roundOf = (idx) => {
+    if (roundMemo[idx]) return roundMemo[idx];
+    if (inProgress.has(idx)) return 1;
+    inProgress.add(idx);
+    const m = matches[idx];
+    const rs = [];
+    const tf = feeder(m.p1, idx);
+    const bf = feeder(m.p2, idx);
+    if (tf !== null) rs.push(roundOf(tf));
+    if (bf !== null) rs.push(roundOf(bf));
+    inProgress.delete(idx);
+    const r = rs.length ? 1 + Math.max(...rs) : 1;
+    roundMemo[idx] = r;
+    return r;
+  };
+  for (let idx = 0; idx < matches.length; idx++)
+    nodes[idx].round = roundOf(idx);
+  const winnerFutureCount = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < matches.length; idx++) {
+    const w = winnerOf(idx);
+    if (!w) continue;
+    let count = 0;
+    for (let j = 0; j < matches.length; j++) {
+      if (j === idx) continue;
+      if (matches[j].p1 === w || matches[j].p2 === w) count++;
+    }
+    if (count > 1) winnerFutureCount.set(w, count);
+  }
+  for (const [w] of winnerFutureCount) {
+    const first = matches.findIndex((_, i) => winnerOf(i) === w);
+    diagnostics.push(
+      makeDgmoError(
+        matches[first]?.lineNumber ?? 1,
+        `"${w}" advances into more than one later match \u2014 using the first in source order.`,
+        "warning"
+      )
+    );
+  }
+  const childIds = /* @__PURE__ */ new Set();
+  for (const nd of nodes) {
+    if (nd.topChildId !== null) childIds.add(nd.topChildId);
+    if (nd.botChildId !== null) childIds.add(nd.botChildId);
+  }
+  const roots = nodes.filter((nd) => !childIds.has(nd.id));
+  roots.sort((a, b) => b.round - a.round || a.id - b.id);
+  const rootId = roots.length ? roots[0].id : null;
+  const rounds = nodes.reduce((m, x) => Math.max(m, x.round), 0);
+  return { nodes, rootId, rounds };
+}
+function positionSide(built, rowScale) {
+  const byId = new Map(built.nodes.map((n) => [n.id, n]));
+  let slot = 0;
+  const R = HALF_SPAN / rowScale;
+  const place = (id) => {
+    const n = byId.get(id);
+    const tHas = n.topChildId !== null;
+    const bHas = n.botChildId !== null;
+    let ty;
+    let by;
+    const winBoxY = (m) => m.y + (m.winner === "bot" ? R : m.winner === "top" ? -R : 0);
+    if (tHas && bHas) {
+      ty = place(n.topChildId);
+      by = place(n.botChildId);
+      const tc = byId.get(n.topChildId);
+      const bc = byId.get(n.botChildId);
+      if (tc.round === bc.round) n.y = mean([ty, by]);
+      else if (tc.round < bc.round) n.y = winBoxY(tc) + R;
+      else n.y = winBoxY(bc) - R;
+    } else if (tHas) {
+      const f = byId.get(n.topChildId);
+      place(n.topChildId);
+      n.y = winBoxY(f) + R;
+    } else if (bHas) {
+      const f = byId.get(n.botChildId);
+      place(n.botChildId);
+      n.y = winBoxY(f) - R;
+    } else {
+      ty = slot++;
+      by = slot++;
+      n.y = mean([ty, by]);
+    }
+    return n.y;
+  };
+  const childIds = /* @__PURE__ */ new Set();
+  for (const n of built.nodes) {
+    if (n.topChildId !== null) childIds.add(n.topChildId);
+    if (n.botChildId !== null) childIds.add(n.botChildId);
+  }
+  const roots = built.nodes.filter((n) => !childIds.has(n.id)).sort((a, b) => a.id - b.id);
+  for (const r of roots) place(r.id);
+}
+function roundLabel(r, rounds, defs, twoSide) {
+  const d = defs[r - 1];
+  if (d)
+    return d.color !== void 0 ? { label: d.name, color: d.color } : { label: d.name };
+  if (!twoSide && r === rounds) return { label: "Final" };
+  return { label: `Round ${r}` };
+}
+function layoutBracket(parsed) {
+  const diagnostics = [...parsed.diagnostics];
+  let idCounter = 0;
+  const nextId = () => idCounter++;
+  const groups = [];
+  const buildFor = (label, color) => {
+    const sideSeeds = parsed.seeds.filter((s) => s.side === label);
+    const sideMatches = parsed.matches.filter((m) => m.side === label);
+    const built = parsed.seeded ? buildSeededSide(sideSeeds, sideMatches, label, nextId, diagnostics) : buildCasualSide(sideMatches, label, nextId, diagnostics);
+    groups.push(
+      color !== void 0 ? { label, color, built } : { label, built }
+    );
+  };
+  if (parsed.sides.length === 0) {
+    buildFor(null, void 0);
+  } else {
+    for (const s of parsed.sides) buildFor(s.label, s.color);
+  }
+  const maxComment = Math.max(
+    0,
+    ...groups.flatMap(
+      (g) => g.built.nodes.map((n) => commentaryLineCount(n.commentary))
+    )
+  );
+  const COMMENT_LH2 = 15;
+  const rowScale = maxComment > 0 ? Math.max(ROW, 2 * BOX_H + PAIR_GAP + maxComment * COMMENT_LH2 + 16) : ROW;
+  for (const g of groups) positionSide(g.built, rowScale);
+  const champResults = parsed.matches.filter(
+    (m) => m.side === null && parsed.sides.length >= 1
+  );
+  const twoSide = groups.length === 2;
+  const allNodes = [];
+  const nodeById = /* @__PURE__ */ new Map();
+  const columnLabels = [];
+  const sideLabelOut = [];
+  const pushSide = (x0, x1, label, color) => {
+    sideLabelOut.push(
+      color !== void 0 ? { x0, x1, label, color } : { x0, x1, label }
+    );
+  };
+  const seenColX = /* @__PURE__ */ new Set();
+  const addColLabel = (x, rl) => {
+    if (parsed.noRounds) return;
+    if (seenColX.has(x)) return;
+    seenColX.add(x);
+    columnLabels.push(
+      rl.color !== void 0 ? { x, label: rl.label, color: rl.color } : { x, label: rl.label }
+    );
+  };
+  let champion = null;
+  if (!twoSide) {
+    let yOffset = 0;
+    for (const g of groups) {
+      const rounds = g.built.rounds;
+      for (const n of g.built.nodes) {
+        n.x = (n.round - 1) * COL_W + BOX_W / 2;
+        n.y = n.y * rowScale + yOffset;
+        allNodes.push(n);
+        nodeById.set(n.id, n);
+        addColLabel(n.x, roundLabel(n.round, rounds, parsed.roundNames, false));
+      }
+      if (g.label) {
+        pushSide(0, (rounds - 1) * COL_W + BOX_W, g.label, g.color);
+      }
+      const slotSpan = Math.max(0, ...g.built.nodes.map((n) => n.y)) + rowScale;
+      yOffset = slotSpan + rowScale;
+    }
+    const rootWinners = groups.map(
+      (g) => g.built.rootId !== null ? nodeById.get(g.built.rootId) : null
+    ).filter(Boolean);
+    if (rootWinners.length) {
+      const finalNode = rootWinners.sort((a, b) => b.round - a.round)[0];
+      champion = winnerNameOf(finalNode);
+    }
+  } else {
+    const left = groups[0];
+    const right = groups[1];
+    const L = left.built.rounds;
+    const R = right.built.rounds;
+    const centerX = L * COL_W + BOX_W / 2;
+    for (const n of left.built.nodes) {
+      n.x = (n.round - 1) * COL_W + BOX_W / 2;
+      n.y = n.y * rowScale;
+      allNodes.push(n);
+      nodeById.set(n.id, n);
+      addColLabel(n.x, roundLabel(n.round, L, parsed.roundNames, true));
+    }
+    for (const n of right.built.nodes) {
+      n.x = centerX + (R - n.round + 1) * COL_W;
+      n.y = n.y * rowScale;
+      allNodes.push(n);
+      nodeById.set(n.id, n);
+      addColLabel(n.x, roundLabel(n.round, R, parsed.roundNames, true));
+    }
+    if (left.label)
+      pushSide(0, (L - 1) * COL_W + BOX_W, left.label, left.color);
+    if (right.label)
+      pushSide(
+        centerX + COL_W - BOX_W / 2,
+        centerX + R * COL_W + BOX_W / 2,
+        right.label,
+        right.color
+      );
+    const leftRoot = left.built.rootId !== null ? nodeById.get(left.built.rootId) : null;
+    const rightRoot = right.built.rootId !== null ? nodeById.get(right.built.rootId) : null;
+    const cid = nextId();
+    const champNode = {
+      id: cid,
+      round: 0,
+      side: null,
+      topSeedName: null,
+      botSeedName: null,
+      topChildId: leftRoot ? leftRoot.id : null,
+      botChildId: rightRoot ? rightRoot.id : null,
+      topName: leftRoot ? winnerNameOf(leftRoot) : null,
+      botName: rightRoot ? winnerNameOf(rightRoot) : null,
+      winner: null,
+      score: null,
+      commentary: [],
+      homeName: null,
+      lineNumber: null,
+      isChampionship: true,
+      x: centerX,
+      y: mean([leftRoot?.y ?? 0, rightRoot?.y ?? 0])
+    };
+    for (const r of champResults) {
+      if (!r.decided) continue;
+      if (champNode.topName === r.p1 && champNode.botName === r.p2) {
+        champNode.winner = "top";
+        champNode.score = r.score;
+        champNode.commentary = [...r.commentary];
+        champNode.homeName = r.home;
+      } else if (champNode.topName === r.p2 && champNode.botName === r.p1) {
+        champNode.winner = "bot";
+        champNode.score = r.score;
+        champNode.commentary = [...r.commentary];
+        champNode.homeName = r.home;
+      }
+    }
+    allNodes.push(champNode);
+    nodeById.set(cid, champNode);
+    const centerDef = parsed.roundNames[L];
+    addColLabel(
+      centerX,
+      centerDef ? centerDef.color !== void 0 ? { label: centerDef.name, color: centerDef.color } : { label: centerDef.name } : { label: parsed.title ?? "Final" }
+    );
+    champion = winnerNameOf(champNode);
+  }
+  const half = HALF_SPAN;
+  const winnerBoxCy = (n) => {
+    if (n.winner === "bot") return n.y + half;
+    if (n.winner === "top") return n.y - half;
+    return n.y;
+  };
+  const fromPoint = (c) => {
+    const y = winnerBoxCy(c);
+    return c.winner === null ? { x: c.x, y, yA: c.y - half, yB: c.y + half } : { x: c.x, y, yA: y, yB: y };
+  };
+  const matches = allNodes.map((n) => {
+    const topChild = n.topChildId !== null ? nodeById.get(n.topChildId) : null;
+    const botChild = n.botChildId !== null ? nodeById.get(n.botChildId) : null;
+    return {
+      round: n.round,
+      side: n.side,
+      x: n.x,
+      y: n.y,
+      top: n.topName,
+      bot: n.botName,
+      winner: n.winner,
+      score: n.score,
+      pending: n.winner === null && n.topName !== null && n.botName !== null,
+      isChampionship: n.isChampionship,
+      topFrom: topChild ? fromPoint(topChild) : null,
+      botFrom: botChild ? fromPoint(botChild) : null,
+      commentary: n.commentary,
+      home: n.homeName,
+      lineNumber: n.lineNumber
+    };
+  });
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const m of matches) {
+    minX = Math.min(minX, m.x - BOX_W / 2);
+    maxX = Math.max(maxX, m.x + BOX_W / 2);
+    minY = Math.min(minY, m.y - half - BOX_H / 2);
+    maxY = Math.max(maxY, m.y + half + BOX_H / 2);
+    if (m.commentary.length) {
+      const commentX = m.x - BOX_W / 2 + 2;
+      maxX = Math.max(maxX, commentX + COMMENT_W);
+      const wl = commentaryLineCount(m.commentary);
+      maxY = Math.max(
+        maxY,
+        m.y + half + BOX_H / 2 + 13 + (wl - 1) * COMMENT_LH2 + 4
+      );
+    }
+  }
+  for (const s of sideLabelOut) {
+    minX = Math.min(minX, s.x0 - 8);
+    maxX = Math.max(maxX, s.x1 + 8);
+  }
+  if (!Number.isFinite(minX)) {
+    minX = 0;
+    maxX = BOX_W;
+    minY = 0;
+    maxY = BOX_H;
+  }
+  const SIDE_BAR = sideLabelOut.length ? 30 : 0;
+  const LABEL_BAND = columnLabels.length ? 48 : 0;
+  const topBand = SIDE_BAR + LABEL_BAND;
+  const shiftX = -minX;
+  const shiftY = -minY + topBand;
+  const shifted = matches.map((m) => ({
+    ...m,
+    x: m.x + shiftX,
+    y: m.y + shiftY,
+    topFrom: m.topFrom ? {
+      x: m.topFrom.x + shiftX,
+      y: m.topFrom.y + shiftY,
+      yA: m.topFrom.yA + shiftY,
+      yB: m.topFrom.yB + shiftY
+    } : null,
+    botFrom: m.botFrom ? {
+      x: m.botFrom.x + shiftX,
+      y: m.botFrom.y + shiftY,
+      yA: m.botFrom.yA + shiftY,
+      yB: m.botFrom.yB + shiftY
+    } : null
+  }));
+  const shiftedCols = columnLabels.map((c) => ({ ...c, x: c.x + shiftX }));
+  const shiftedSides = sideLabelOut.map((s) => ({
+    ...s,
+    x0: s.x0 + shiftX,
+    x1: s.x1 + shiftX
+  }));
+  return {
+    matches: shifted,
+    columns: shiftedCols,
+    sideLabels: shiftedSides,
+    width: maxX - minX,
+    height: maxY - minY + topBand,
+    champion,
+    diagnostics
+  };
+}
+
+// src/bracket/renderer.ts
+var PADDING = 16;
+var TITLE_BAND = 40;
+var HALF_SPAN2 = (BOX_H + PAIR_GAP) / 2;
+var COMMENT_LH = 15;
+var LEGEND_POSITION = {
+  placement: "top-center",
+  titleRelation: "below-title"
+};
+function clip(s, maxW, fs) {
+  if (measureText(s, fs) <= maxW) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (measureText(s.slice(0, mid) + "\u2026", fs) <= maxW) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo <= 0 ? "" : s.slice(0, lo) + "\u2026";
+}
+function paintForAccent(palette, isDark, accent) {
+  const base = themeBaseBg(palette, isDark);
+  return {
+    accent,
+    ink: palette.text,
+    muted: mix(palette.text, base, 52),
+    // Loser / TBD outlines + connectors are ink-based (not the pale border) so
+    // they stay legible on top of a colored, shaded column band.
+    hair: mix(palette.text, base, 34),
+    wire: mix(palette.text, base, 30),
+    track: mix(palette.border, base, 55),
+    tint: shapeFill(palette, accent, isDark)
+  };
+}
+function paintFor(palette, isDark, sideColor) {
+  const accent = sideColor && resolveColor(sideColor, palette) || sideColor || getSeriesColors(palette)[0];
+  return paintForAccent(palette, isDark, accent);
+}
+function resolveBracketLegend(parsed, palette) {
+  const activeTag = parsed.activeTag;
+  const activeGroup = activeTag ? parsed.tagGroups.find((g) => tagAttrKey(g.name) === tagAttrKey(activeTag)) : void 0;
+  const legendGroups = activeGroup && !parsed.noLegend ? [
+    {
+      name: activeGroup.name,
+      entries: activeGroup.entries.map((e) => ({
+        value: e.value,
+        color: resolveColor(e.color, palette) ?? e.color
+      }))
+    }
+  ] : [];
+  return { activeGroup, legendGroups };
+}
+function bracketExportDimensions(parsed, palette) {
+  const layout = layoutBracket(parsed);
+  const width = layout.width + PADDING * 2;
+  const titleH = parsed.title ? TITLE_BAND : 0;
+  const { legendGroups } = resolveBracketLegend(parsed, palette);
+  const legendReserve = legendGroups.length > 0 ? getMaxLegendReservedHeight(
+    { groups: legendGroups, position: LEGEND_POSITION, mode: "export" },
+    width
+  ) + LEGEND_GROUP_GAP : 0;
+  const height = titleH + legendReserve + PADDING + layout.height + PADDING;
+  return { width, height };
+}
+function renderBracket(container, parsed, palette, isDark, exportDims) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  if (parsed.error) return;
+  const layout = layoutBracket(parsed);
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const showTitle = !!parsed.title;
+  const titleH = showTitle ? TITLE_BAND : 0;
+  const exportMode = exportDims !== void 0;
+  const seedByName = /* @__PURE__ */ new Map();
+  for (const s of parsed.seeds)
+    if (!seedByName.has(s.name)) seedByName.set(s.name, s.seed);
+  const activeTag = parsed.activeTag;
+  const activeKey = activeTag ? tagAttrKey(activeTag) : null;
+  const tagValueOf = (name) => {
+    if (!name || !activeKey) return null;
+    const meta = parsed.competitorMeta.get(name);
+    return meta?.[activeKey] ?? null;
+  };
+  const tagColorOf = (name) => {
+    if (!name || !activeTag) return null;
+    const meta = parsed.competitorMeta.get(name);
+    if (!meta || !activeKey || !meta[activeKey]) return null;
+    const c = resolveTagColor(meta, [...parsed.tagGroups], activeTag);
+    return c ? resolveColor(c, palette) ?? c : null;
+  };
+  const { activeGroup, legendGroups } = resolveBracketLegend(parsed, palette);
+  const legendReserve = legendGroups.length > 0 ? getMaxLegendReservedHeight(
+    { groups: legendGroups, position: LEGEND_POSITION, mode: "preview" },
+    width
+  ) + LEGEND_GROUP_GAP : 0;
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMin meet").attr("xmlns", "http://www.w3.org/2000/svg").attr("class", "dgmo-bracket").attr("role", "img").attr(
+    "aria-label",
+    `Tournament bracket${parsed.title ? ` \u2014 ${parsed.title}` : ""}${layout.champion ? `, champion ${layout.champion}` : ""}`
+  ).style("font-family", FONT_FAMILY);
+  if (showTitle) {
+    const t = svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).text(parsed.title);
+    if (parsed.titleLineNumber !== null)
+      t.attr("data-line-number", parsed.titleLineNumber);
+  }
+  const areaY = titleH + legendReserve + PADDING;
+  const areaX = PADDING;
+  const areaW = Math.max(1, width - PADDING * 2);
+  const areaH = Math.max(1, height - areaY - PADDING);
+  const scale = Math.min(1, areaW / layout.width, areaH / layout.height);
+  const offsetX = areaX + (areaW - layout.width * scale) / 2;
+  const offsetY = areaY;
+  const root = svg.append("g").attr("class", "dgmo-bracket-body").attr("transform", `translate(${offsetX},${offsetY}) scale(${scale})`);
+  if (legendGroups.length > 0) {
+    const legendG = svg.append("g").attr("class", "dgmo-bracket-legend").attr("transform", `translate(0, ${titleH})`);
+    renderIntegratedLegend(legendG, {
+      groups: legendGroups,
+      palette: {
+        bg: palette.bg,
+        surface: palette.surface,
+        text: palette.text,
+        textMuted: palette.textMuted,
+        primary: palette.primary
+      },
+      isDark,
+      width,
+      mode: exportMode ? "export" : "preview",
+      position: LEGEND_POSITION,
+      activeGroup: activeGroup?.name ?? null
+    });
+  }
+  const baseAccent = parsed.accentColor ?? resolveColor("blue", palette) ?? getSeriesColors(palette)[0];
+  const basePaint = paintForAccent(palette, isDark, baseAccent);
+  const sideColorByLabel = /* @__PURE__ */ new Map();
+  for (const s of parsed.sides) sideColorByLabel.set(s.label, s.color);
+  const sideBarH = layout.sideLabels.length ? 30 : 0;
+  const bandTop = sideBarH + 2;
+  const roundY = sideBarH + 24;
+  for (const col of layout.columns) {
+    if (!col.color) continue;
+    const covered = layout.sideLabels.some(
+      (s) => col.x >= s.x0 && col.x <= s.x1
+    );
+    const top = covered ? bandTop : 2;
+    const c = resolveColor(col.color, palette) ?? col.color;
+    root.append("rect").attr("x", col.x - BOX_W / 2 - 10).attr("y", top).attr("width", BOX_W + 20).attr("height", Math.max(0, layout.height - top)).attr("rx", 10).attr("fill", mix(c, palette.bg, isDark ? 12 : 8));
+  }
+  for (const s of layout.sideLabels) {
+    const c = s.color ? resolveColor(s.color, palette) ?? s.color : basePaint.accent;
+    root.append("rect").attr("x", s.x0 - 8).attr("y", 2).attr("width", s.x1 - s.x0 + 16).attr("height", 24).attr("rx", 8).attr("fill", mix(c, palette.bg, isDark ? 20 : 14)).attr("stroke", mix(c, palette.bg, 55)).attr("stroke-width", 1);
+    root.append("text").attr("x", (s.x0 + s.x1) / 2).attr("y", 18).attr("text-anchor", "middle").attr("font-size", 13).attr("font-weight", 800).attr("letter-spacing", 0.3).attr("fill", c).text(clip(s.label, s.x1 - s.x0, 13));
+  }
+  for (const col of layout.columns) {
+    const c = col.color ? resolveColor(col.color, palette) ?? col.color : basePaint.muted;
+    const covered = layout.sideLabels.some(
+      (s) => col.x >= s.x0 && col.x <= s.x1
+    );
+    root.append("text").attr("x", col.x).attr("y", covered ? roundY : 22).attr("text-anchor", "middle").attr("font-size", covered ? 14 : 15).attr("font-weight", covered ? 700 : 800).attr("fill", c).attr("letter-spacing", 0.4).text(clip(col.label, BOX_W + 20, covered ? 14 : 15));
+  }
+  for (const m of layout.matches) {
+    drawConnector(root, m, m.topFrom, m.y - HALF_SPAN2, basePaint);
+    drawConnector(root, m, m.botFrom, m.y + HALF_SPAN2, basePaint);
+  }
+  for (const m of layout.matches) {
+    const sidePaint = m.side && sideColorByLabel.get(m.side) ? paintFor(palette, isDark, sideColorByLabel.get(m.side)) : basePaint;
+    const topSeed = seedByName.get(m.top ?? "") ?? null;
+    const botSeed = seedByName.get(m.bot ?? "") ?? null;
+    let homeName = m.home;
+    if (!homeName && topSeed !== null && botSeed !== null) {
+      homeName = topSeed <= botSeed ? m.top : m.bot;
+    }
+    const [wSeed, lSeed] = m.winner === "top" ? [topSeed, botSeed] : m.winner === "bot" ? [botSeed, topSeed] : [null, null];
+    const isUpset = wSeed !== null && lSeed !== null && wSeed > lSeed && !m.isChampionship;
+    const scoreParts = m.score ? m.score.split(/[-–]/).map((p) => p.trim()) : null;
+    const winScore = scoreParts?.length === 2 ? scoreParts[0] : "";
+    const loseScore = scoreParts?.length === 2 ? scoreParts[1] : "";
+    const champWinner = m.isChampionship ? layout.champion : null;
+    const mkInfo = (side, name) => {
+      const isWinner = m.winner === side;
+      const isLoser = m.winner !== null && m.winner !== side;
+      return {
+        isWinner,
+        isLoser,
+        pending: m.pending,
+        isChampion: champWinner !== null && isWinner,
+        score: isWinner ? winScore : isLoser ? loseScore : "",
+        seed: seedByName.get(name ?? "") ?? null,
+        tagColor: tagColorOf(name),
+        tagValue: tagValueOf(name),
+        isHome: homeName !== null && homeName === name
+      };
+    };
+    drawBox(
+      root,
+      m.x,
+      m.y - HALF_SPAN2,
+      m.top,
+      mkInfo("top", m.top),
+      sidePaint,
+      palette,
+      isDark,
+      m,
+      activeKey
+    );
+    drawBox(
+      root,
+      m.x,
+      m.y + HALF_SPAN2,
+      m.bot,
+      mkInfo("bot", m.bot),
+      sidePaint,
+      palette,
+      isDark,
+      m,
+      activeKey
+    );
+    if (isUpset) drawUpset(root, m, sidePaint);
+    if (m.commentary.length) drawCommentary(root, m, palette);
+  }
+}
+function drawConnector(g, m, from, toCy, paint) {
+  if (!from) return;
+  const parentLeft = m.x - BOX_W / 2;
+  const parentRight = m.x + BOX_W / 2;
+  const childIsLeft = from.x < m.x;
+  const childEdge = childIsLeft ? from.x + BOX_W / 2 : from.x - BOX_W / 2;
+  const parentEdge = childIsLeft ? parentLeft : parentRight;
+  const midX = (childEdge + parentEdge) / 2;
+  const vLo = Math.min(from.yA, from.yB, toCy);
+  const vHi = Math.max(from.yA, from.yB, toCy);
+  const d = from.yA !== from.yB ? `M ${childEdge} ${from.yA} H ${midX} M ${childEdge} ${from.yB} H ${midX} M ${midX} ${vLo} V ${vHi} M ${midX} ${toCy} H ${parentEdge}` : `M ${childEdge} ${from.y} H ${midX} V ${toCy} H ${parentEdge}`;
+  g.append("path").attr("d", d).attr("fill", "none").attr("stroke", paint.wire).attr("stroke-width", 1.5);
+}
+function drawBox(g, cx, cy, name, info, sidePaint, palette, isDark, m, activeKey) {
+  const x = cx - BOX_W / 2;
+  const y = cy - BOX_H / 2;
+  const paint = info.tagColor ? paintForAccent(palette, isDark, info.tagColor) : sidePaint;
+  const cell = g.append("g").attr("class", "dgmo-bracket-box");
+  if (m.lineNumber !== null) cell.attr("data-line-number", m.lineNumber);
+  if (activeKey && info.tagValue)
+    cell.attr(`data-tag-${activeKey}`, info.tagValue.toLowerCase());
+  const isTBD = name === null;
+  let fill = "none";
+  let stroke = paint.hair;
+  let sw = 1.25;
+  let dash = null;
+  let textColor = paint.ink;
+  let weight = 600;
+  if (info.isChampion) {
+    fill = paint.tint;
+    stroke = paint.accent;
+    sw = 3;
+    weight = 800;
+  } else if (isTBD) {
+    fill = paint.track;
+    dash = "4 4";
+    textColor = paint.muted;
+    weight = 500;
+  } else if (info.isWinner) {
+    fill = paint.tint;
+    stroke = paint.accent;
+    sw = 2;
+    weight = 700;
+  } else if (info.isLoser) {
+    stroke = paint.hair;
+    textColor = paint.muted;
+    weight = 500;
+  } else if (info.pending) {
+    stroke = mix(paint.accent, paint.hair, 50);
+  }
+  const rect = cell.append("rect").attr("x", x).attr("y", y).attr("width", BOX_W).attr("height", BOX_H).attr("rx", 6).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", sw);
+  if (dash) rect.attr("stroke-dasharray", dash);
+  let leftPad = 11;
+  if (info.seed !== null) {
+    cell.append("text").attr("x", x + 9).attr("y", cy + 4).attr("text-anchor", "start").attr("font-size", 10).attr("font-weight", 700).attr("fill", paint.muted).text(info.seed);
+    leftPad = 9 + Math.max(12, measureText(String(info.seed), 10)) + 6;
+  }
+  let rightPad = 11;
+  if (info.score) rightPad += 20;
+  if (info.isHome) {
+    drawHome(cell, x + BOX_W - rightPad - 6, cy, paint.muted);
+    rightPad += 16;
+  }
+  cell.append("text").attr("x", x + leftPad).attr("y", cy + 4).attr("text-anchor", "start").attr("font-size", 12.5).attr("font-weight", weight).attr("fill", textColor).text(clip(isTBD ? "TBD" : name, BOX_W - leftPad - rightPad, 12.5));
+  if (info.score) {
+    cell.append("text").attr("x", x + BOX_W - 11).attr("y", cy + 4).attr("text-anchor", "end").attr("font-size", 12).attr("font-weight", info.isWinner ? 700 : 500).attr("fill", info.isWinner ? textColor : paint.muted).text(info.score);
+  }
+}
+function drawHome(cell, hx, cy, color) {
+  const s = 5;
+  const yTop = cy - s - 1;
+  const d = `M ${hx - s} ${cy - 1} L ${hx} ${yTop} L ${hx + s} ${cy - 1} L ${hx + s} ${cy + s} L ${hx - s} ${cy + s} Z`;
+  cell.append("path").attr("d", d).attr("fill", "none").attr("stroke", color).attr("stroke-width", 1.2).attr("stroke-linejoin", "round");
+}
+function drawUpset(g, m, paint) {
+  g.append("text").attr("x", m.x + BOX_W / 2).attr("y", m.y - HALF_SPAN2 - BOX_H / 2 - 4).attr("text-anchor", "end").attr("font-size", 9).attr("font-weight", 800).attr("letter-spacing", 0.6).attr("fill", paint.accent).text("UPSET");
+}
+function drawCommentary(g, m, palette) {
+  const x = m.x - BOX_W / 2 + 2;
+  let y = m.y + HALF_SPAN2 + BOX_H / 2 + 13;
+  const muted = mix(palette.text, palette.bg, 45);
+  const bulletW = measureText("\u2022 ", 11);
+  const emit = (line, lx) => {
+    const t = g.append("text").attr("x", lx).attr("y", y).attr("text-anchor", "start").attr("font-size", 11).attr("font-style", "italic").attr("fill", muted);
+    renderInlineText(t, line, palette, 11);
+    y += COMMENT_LH;
+  };
+  for (const raw of m.commentary) {
+    const isBullet = raw.startsWith("\u2022 ");
+    if (isBullet) {
+      const body = raw.slice(2);
+      wrapText(body, COMMENT_W - bulletW, 11).forEach(
+        (line, i) => i === 0 ? emit(`\u2022 ${line}`, x) : emit(line, x + bulletW)
+      );
+    } else {
+      for (const line of wrapText(raw, COMMENT_W, 11)) emit(line, x);
+    }
+  }
+}
+function renderBracketForExport(container, parsed, palette, isDark, exportDims) {
+  renderBracket(container, parsed, palette, isDark, exportDims);
+}
+
+export {
+  layoutBracket,
+  bracketExportDimensions,
+  renderBracket,
+  renderBracketForExport
+};
+//# sourceMappingURL=chunk-FA6K3FWM.js.map