@diagrammo/dgmo 0.48.2 → 0.49.0

package/dist/chunk-SGHSY3LU.js

@@ -0,0 +1,377 @@
+import {
+  SKETCH_DIAGNOSTIC_CODES
+} from "./chunk-XHVV4NVW.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/sketch/geometry.ts
+var SKETCH_PHI = (1 + Math.sqrt(5)) / 2;
+var SKETCH_GEOMETRY = {
+  /** px per grid cell (the dot-grid pitch) */
+  cellPx: 26,
+  /** universal footprint width, in grid cells */
+  footprintCellsW: 8,
+  /** mandatory gap between footprints, in cells */
+  gapCellsX: 4,
+  gapCellsY: 4,
+  /** box reserved top band, px (spec decision 12) */
+  bandPx: 44,
+  /** box frame padding around the children bbox, px */
+  boxPadPx: 26,
+  /** edge-ring (connect hook) width as a fraction of footprint height */
+  ringFrac: 0.22
+};
+var SKETCH_FOOT_W = SKETCH_GEOMETRY.footprintCellsW * SKETCH_GEOMETRY.cellPx;
+var SKETCH_FOOT_H = Math.round(SKETCH_FOOT_W / SKETCH_PHI);
+var SKETCH_HALF_SLOT_X = (SKETCH_FOOT_W + SKETCH_GEOMETRY.gapCellsX * SKETCH_GEOMETRY.cellPx) / 2;
+var SKETCH_HALF_SLOT_Y = (SKETCH_FOOT_H + SKETCH_GEOMETRY.gapCellsY * SKETCH_GEOMETRY.cellPx) / 2;
+var SKETCH_SEP = 2;
+function sketchSlotToPx(c, r) {
+  return { x: c * SKETCH_HALF_SLOT_X, y: r * SKETCH_HALF_SLOT_Y };
+}
+
+// src/sketch/collapse.ts
+function collapseSketch(parsed, collapsedLabels) {
+  const collapsed = collapsedLabels ?? new Set(parsed.boxes.filter((b) => b.collapsed).map((b) => b.label));
+  if (collapsed.size === 0) {
+    return {
+      nodes: parsed.nodes,
+      boxes: parsed.boxes,
+      virtualBoxes: [],
+      edges: parsed.edges,
+      collapsedChildCounts: /* @__PURE__ */ new Map()
+    };
+  }
+  const virtualBoxes = parsed.boxes.filter((b) => collapsed.has(b.label));
+  const boxes = parsed.boxes.filter((b) => !collapsed.has(b.label));
+  const nodeToVirtual = /* @__PURE__ */ new Map();
+  const collapsedChildCounts = /* @__PURE__ */ new Map();
+  for (const box of virtualBoxes) {
+    collapsedChildCounts.set(box.label, box.children.length);
+    for (const childId of box.children) nodeToVirtual.set(childId, box.id);
+  }
+  const nodes = parsed.nodes.filter((n) => !nodeToVirtual.has(n.id));
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of parsed.edges) {
+    const sourceId = nodeToVirtual.get(edge.sourceId) ?? edge.sourceId;
+    const targetId = nodeToVirtual.get(edge.targetId) ?? edge.targetId;
+    if (sourceId === targetId) continue;
+    const key = `${sourceId}|${targetId}|${edge.label ?? ""}|${edge.heads}|${edge.dashed}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({ ...edge, sourceId, targetId });
+  }
+  return { nodes, boxes, virtualBoxes, edges, collapsedChildCounts };
+}
+
+// src/sketch/layout.ts
+function unitRect(c, r) {
+  return { c, r, w: SKETCH_SEP, h: SKETCH_SEP };
+}
+function rectsOverlap(a, b) {
+  return a.c < b.c + b.w && b.c < a.c + a.w && a.r < b.r + b.h && b.r < a.r + a.h;
+}
+function collidesAny(rect, occupied) {
+  for (const o of occupied) if (rectsOverlap(rect, o)) return true;
+  return false;
+}
+function nearestFree(base, occupied) {
+  if (!collidesAny(base, occupied)) return { c: base.c, r: base.r };
+  for (let d = 1; d <= 200; d++) {
+    const candidates = [];
+    for (let dc = -d; dc <= d; dc++) {
+      const dr = d - Math.abs(dc);
+      candidates.push({ c: base.c + dc, r: base.r + dr });
+      if (dr !== 0) candidates.push({ c: base.c + dc, r: base.r - dr });
+    }
+    candidates.sort((a, b) => {
+      const costA = (a.r < base.r ? 2 : 0) + (a.c < base.c ? 1 : 0);
+      const costB = (b.r < base.r ? 2 : 0) + (b.c < base.c ? 1 : 0);
+      return costA - costB || a.r - b.r || a.c - b.c;
+    });
+    for (const cand of candidates) {
+      if (!collidesAny({ ...base, c: cand.c, r: cand.r }, occupied)) {
+        return cand;
+      }
+    }
+  }
+  return { c: base.c, r: base.r };
+}
+function layoutChildren(box, nodesById, warn) {
+  const occupied = [];
+  const children = [];
+  const pending = [];
+  for (const id of box.children) {
+    const node = nodesById.get(id);
+    if (!node) continue;
+    if (node.at === null) {
+      pending.push(node);
+      continue;
+    }
+    const target = unitRect(node.at.c, node.at.r);
+    const spot = nearestFree(target, occupied);
+    if (spot.c !== node.at.c || spot.r !== node.at.r) {
+      warn(node.lineNumber, node.label);
+    }
+    occupied.push(unitRect(spot.c, spot.r));
+    children.push({ node, c: spot.c, r: spot.r });
+  }
+  let flowRow = occupied.length > 0 ? Math.max(...occupied.map((o) => o.r)) + SKETCH_SEP : 0;
+  let flowCol = 0;
+  const wrapAt = Math.max(
+    SKETCH_SEP * 3,
+    occupied.length > 0 ? Math.max(...occupied.map((o) => o.c)) + SKETCH_SEP : SKETCH_SEP * 3
+  );
+  for (const node of pending) {
+    let placed = false;
+    while (!placed) {
+      const rect = unitRect(flowCol, flowRow);
+      if (!collidesAny(rect, occupied)) {
+        occupied.push(rect);
+        children.push({ node, c: flowCol, r: flowRow });
+        placed = true;
+      }
+      flowCol += SKETCH_SEP;
+      if (flowCol > wrapAt) {
+        flowCol = 0;
+        flowRow += SKETCH_SEP;
+      }
+    }
+  }
+  let extent;
+  if (occupied.length === 0) {
+    extent = { c: 0, r: 0, w: SKETCH_SEP, h: SKETCH_SEP };
+  } else {
+    const cMin = Math.min(...occupied.map((o) => o.c));
+    const rMin = Math.min(...occupied.map((o) => o.r));
+    const cMax = Math.max(...occupied.map((o) => o.c + o.w));
+    const rMax = Math.max(...occupied.map((o) => o.r + o.h));
+    extent = { c: cMin, r: rMin, w: cMax - cMin, h: rMax - rMin };
+  }
+  return { children, extent };
+}
+function layoutSketch(parsed, options = {}) {
+  const diagnostics = [];
+  const overlapWarn = (line, label) => {
+    diagnostics.push(
+      makeDgmoError(
+        line,
+        `Shape "${label}" overlapped another at its authored position \u2014 moved to the nearest free slot`,
+        "warning",
+        SKETCH_DIAGNOSTIC_CODES.OVERLAP_RESOLVED
+      )
+    );
+  };
+  const collapsed = collapseSketch(parsed, options.collapsedBoxes);
+  const nodesById = new Map(collapsed.nodes.map((n) => [n.id, n]));
+  const padHsX = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_X;
+  const padHsY = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_Y;
+  const bandHs = SKETCH_GEOMETRY.bandPx / SKETCH_HALF_SLOT_Y;
+  const boxLocal = /* @__PURE__ */ new Map();
+  const inExpandedBox = /* @__PURE__ */ new Set();
+  for (const box of collapsed.boxes) {
+    const local = layoutChildren(box, nodesById, overlapWarn);
+    boxLocal.set(box.id, local);
+    for (const child of local.children) inExpandedBox.add(child.node.id);
+  }
+  const rootUnits = [];
+  for (const node of collapsed.nodes) {
+    if (!inExpandedBox.has(node.id)) rootUnits.push({ kind: "shape", node });
+  }
+  for (const box of collapsed.virtualBoxes) {
+    rootUnits.push({ kind: "virtual", box });
+  }
+  for (const box of collapsed.boxes) {
+    rootUnits.push({ kind: "box", box });
+  }
+  rootUnits.sort((a, b) => {
+    const la = a.kind === "shape" ? a.node.lineNumber : a.box.lineNumber;
+    const lb = b.kind === "shape" ? b.node.lineNumber : b.box.lineNumber;
+    return la - lb;
+  });
+  const rectFor = (unit, c, r) => {
+    if (unit.kind === "box") {
+      const local = boxLocal.get(unit.box.id);
+      return {
+        c: c + local.extent.c - padHsX,
+        r: r + local.extent.r - bandHs,
+        w: local.extent.w + 2 * padHsX,
+        h: local.extent.h + bandHs + padHsY
+      };
+    }
+    return unitRect(c, r);
+  };
+  const occupied = [];
+  const placedAt = /* @__PURE__ */ new Map();
+  const pending = [];
+  for (const unit of rootUnits) {
+    const at = unit.kind === "shape" ? unit.node.at : unit.box.at;
+    if (at === null) {
+      pending.push(unit);
+      continue;
+    }
+    const base = rectFor(unit, at.c, at.r);
+    let spot = { c: at.c, r: at.r };
+    if (collidesAny(base, occupied)) {
+      const freed = nearestFree(base, occupied);
+      spot = {
+        c: at.c + (freed.c - base.c),
+        r: at.r + (freed.r - base.r)
+      };
+      const line = unit.kind === "shape" ? unit.node.lineNumber : unit.box.lineNumber;
+      const label = unit.kind === "shape" ? unit.node.label : unit.box.label;
+      overlapWarn(line, label);
+    }
+    occupied.push(rectFor(unit, spot.c, spot.r));
+    placedAt.set(unit, spot);
+  }
+  let flowRow = occupied.length > 0 ? Math.ceil(Math.max(...occupied.map((o) => o.r + o.h))) : 0;
+  let flowCol = 0;
+  const wrapAt = Math.max(
+    SKETCH_SEP * 4,
+    occupied.length > 0 ? Math.ceil(Math.max(...occupied.map((o) => o.c + o.w))) : SKETCH_SEP * 4
+  );
+  for (const unit of pending) {
+    let placed = false;
+    while (!placed) {
+      const rect = rectFor(unit, flowCol, flowRow);
+      if (!collidesAny(rect, occupied)) {
+        occupied.push(rect);
+        placedAt.set(unit, { c: flowCol, r: flowRow });
+        placed = true;
+      }
+      flowCol += SKETCH_SEP;
+      if (flowCol > wrapAt) {
+        flowCol = 0;
+        flowRow += SKETCH_SEP;
+      }
+    }
+  }
+  const allRects = rootUnits.map((u) => {
+    const spot = placedAt.get(u);
+    return rectFor(u, spot.c, spot.r);
+  });
+  const cMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.c)) : 0;
+  const rMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.r)) : 0;
+  const toPx = (c, r) => ({
+    x: (c - cMin) * SKETCH_HALF_SLOT_X,
+    y: (r - rMin) * SKETCH_HALF_SLOT_Y
+  });
+  const nodes = [];
+  const boxes = [];
+  for (const unit of rootUnits) {
+    const spot = placedAt.get(unit);
+    if (unit.kind === "shape") {
+      const { x, y } = toPx(spot.c, spot.r);
+      nodes.push({
+        id: unit.node.id,
+        label: unit.node.label,
+        shape: unit.node.shape,
+        metadata: unit.node.metadata,
+        ...unit.node.description && { description: unit.node.description },
+        lineNumber: unit.node.lineNumber,
+        slot: spot,
+        x,
+        y,
+        w: SKETCH_FOOT_W,
+        h: SKETCH_FOOT_H
+      });
+    } else if (unit.kind === "virtual") {
+      const { x, y } = toPx(spot.c, spot.r);
+      nodes.push({
+        id: unit.box.id,
+        label: unit.box.label,
+        shape: "rectangle",
+        metadata: unit.box.metadata,
+        lineNumber: unit.box.lineNumber,
+        slot: spot,
+        x,
+        y,
+        w: SKETCH_FOOT_W,
+        h: SKETCH_FOOT_H,
+        isCollapsedBox: true,
+        childCount: collapsed.collapsedChildCounts.get(unit.box.label) ?? 0
+      });
+    } else {
+      const local = boxLocal.get(unit.box.id);
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const child of local.children) {
+        const abs = toPx(spot.c + child.c, spot.r + child.r);
+        nodes.push({
+          id: child.node.id,
+          label: child.node.label,
+          shape: child.node.shape,
+          metadata: child.node.metadata,
+          ...child.node.description && {
+            description: child.node.description
+          },
+          boxLabel: unit.box.label,
+          lineNumber: child.node.lineNumber,
+          slot: { c: spot.c + child.c, r: spot.r + child.r },
+          x: abs.x,
+          y: abs.y,
+          w: SKETCH_FOOT_W,
+          h: SKETCH_FOOT_H
+        });
+        minX = Math.min(minX, abs.x);
+        minY = Math.min(minY, abs.y);
+        maxX = Math.max(maxX, abs.x + SKETCH_FOOT_W);
+        maxY = Math.max(maxY, abs.y + SKETCH_FOOT_H);
+      }
+      if (minX === Infinity) {
+        const origin = toPx(spot.c, spot.r);
+        minX = origin.x;
+        minY = origin.y + SKETCH_GEOMETRY.bandPx;
+        maxX = origin.x + SKETCH_FOOT_W;
+        maxY = minY;
+      }
+      boxes.push({
+        id: unit.box.id,
+        label: unit.box.label,
+        metadata: unit.box.metadata,
+        lineNumber: unit.box.lineNumber,
+        x: minX - SKETCH_GEOMETRY.boxPadPx,
+        y: minY - SKETCH_GEOMETRY.bandPx,
+        w: maxX - minX + 2 * SKETCH_GEOMETRY.boxPadPx,
+        h: maxY - minY + SKETCH_GEOMETRY.bandPx + SKETCH_GEOMETRY.boxPadPx,
+        bandH: SKETCH_GEOMETRY.bandPx
+      });
+    }
+  }
+  let width = 0;
+  let height = 0;
+  for (const n of nodes) {
+    width = Math.max(width, n.x + n.w);
+    height = Math.max(height, n.y + n.h);
+  }
+  for (const b of boxes) {
+    width = Math.max(width, b.x + b.w);
+    height = Math.max(height, b.y + b.h);
+  }
+  return {
+    nodes,
+    boxes,
+    edges: collapsed.edges,
+    width,
+    height,
+    diagnostics
+  };
+}
+
+export {
+  SKETCH_GEOMETRY,
+  SKETCH_FOOT_W,
+  SKETCH_FOOT_H,
+  SKETCH_HALF_SLOT_X,
+  SKETCH_HALF_SLOT_Y,
+  SKETCH_SEP,
+  sketchSlotToPx,
+  collapseSketch,
+  layoutSketch
+};
+//# sourceMappingURL=chunk-SGHSY3LU.js.map

package/dist/{chunk-SRTU6HMQ.js → chunk-SJEGO2QL.js}

@@ -4,15 +4,15 @@ import {
 import {
   wrapDescriptionLines
 } from "./chunk-BMR4CIEO.js";
-import {
-  renderIntegratedLegend
-} from "./chunk-PWIHZ6NJ.js";
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-4UDKKGHH.js";
 import {
   getMaxLegendReservedHeight
-} from "./chunk-YAA6IID3.js";
+} from "./chunk-7UEMZREK.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,
@@ -24,7 +24,7 @@ import {
 import {
   measureText,
   truncateText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   contrastText,
   mix,
@@ -35,11 +35,11 @@ import {
   isSequenceBlock,
   isSequenceNote,
   isSequenceSection
-} from "./chunk-SML67VPV.js";
+} from "./chunk-D5AVQCDN.js";
 import {
   resolveActiveTagGroup,
   tagAttrKey
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-HBVD67XG.js";
 
 // src/sequence/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -1848,4 +1848,4 @@ export {
   renderSequenceDiagram,
   buildNoteMessageMap
 };
-//# sourceMappingURL=chunk-SRTU6HMQ.js.map
+//# sourceMappingURL=chunk-SJEGO2QL.js.map

package/dist/chunk-SQDFK5ZQ.js

@@ -0,0 +1,273 @@
+import {
+  familyCardRows,
+  familyDisplayLabel
+} from "./chunk-IVKC4GID.js";
+import {
+  CARD_RADIUS,
+  EDGE_STROKE_WIDTH,
+  HEADER_HEIGHT,
+  LABEL_FONT_SIZE,
+  META_FONT_SIZE,
+  META_LINE_HEIGHT,
+  NODE_STROKE_WIDTH,
+  SEPARATOR_GAP
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-4UDKKGHH.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 {
+  contrastText,
+  mix,
+  shapeFill,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-HBVD67XG.js";
+import {
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+
+// src/family/renderer.ts
+import * as d3Selection from "d3-selection";
+var KEY_X = 10;
+var KEY_VALUE_GAP = 6;
+var BAR_DOT_R = 3.5;
+var TITLE_RESERVE = 40;
+var DIM_OPACITY = 0.28;
+var ROMAN = [
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(n) {
+  let out = "";
+  let v = n;
+  for (const [val, sym] of ROMAN)
+    while (v >= val) {
+      out += sym;
+      v -= val;
+    }
+  return out;
+}
+function baseColor(node, parsed, palette, activeTagGroup) {
+  if (node.color) {
+    const c = resolveColor(node.color, palette);
+    if (c) return c;
+  }
+  if (activeTagGroup) {
+    const c = resolveTagColor(
+      node.tagMetadata,
+      [...parsed.tagGroups],
+      activeTagGroup
+    );
+    if (c && c !== "#999999") return c;
+  }
+  return palette.primary;
+}
+function renderFamilyForExport(container, parsed, layout, palette, isDark, opts = {}) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const activeTagGroup = opts.activeTagGroup ?? null;
+  const solid = parsed.options["solid-fill"] === "on";
+  const noDaggers = parsed.options["no-daggers"] === "true";
+  const baseBg = themeBaseBg(palette, isDark);
+  const PAD = 20;
+  const MAX_SCALE = 1.5;
+  const titleReserve = parsed.title ? TITLE_RESERVE : 0;
+  const legendGroups = parsed.tagGroups.filter((g) => g.entries.length > 0).map((g) => ({
+    name: g.name,
+    entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
+  }));
+  const hasLegend = legendGroups.length > 0;
+  const legendConfig = {
+    groups: legendGroups,
+    position: { placement: "top-center", titleRelation: "below-title" },
+    mode: opts.exportMode ? "export" : "preview",
+    showInactivePills: true
+  };
+  const contentW = layout.width;
+  const contentH = layout.height;
+  const W = opts.fit?.width ?? opts.exportDims?.width ?? contentW + PAD * 2;
+  const legendReserve = hasLegend ? getMaxLegendReservedHeight(legendConfig, W) + LEGEND_GROUP_GAP : 0;
+  const chrome = titleReserve + legendReserve;
+  let scale = 1;
+  let H;
+  if (opts.fit) {
+    H = opts.fit.height;
+    const availW = Math.max(1, W - PAD * 2);
+    const availH = Math.max(1, H - chrome - PAD * 2);
+    scale = Math.min(MAX_SCALE, availW / contentW, availH / contentH);
+    if (!Number.isFinite(scale) || scale <= 0) scale = 1;
+  } else {
+    H = contentH + chrome + PAD * 2;
+  }
+  const svg = d3Selection.select(container).append("svg").attr("xmlns", "http://www.w3.org/2000/svg").attr("width", W).attr("height", H).attr("viewBox", `0 0 ${W} ${H}`).attr("preserveAspectRatio", "xMidYMin meet").attr("data-fit-scale", scale.toFixed(3)).style("font-family", FONT_FAMILY);
+  svg.append("style").text(
+    ".family-focus-icon{opacity:0;transition:opacity .15s ease;pointer-events:none}.family-card:hover .family-focus-icon{opacity:.6;pointer-events:all}.family-focus-icon:hover{opacity:1}"
+  );
+  if (parsed.title) {
+    svg.append("text").attr("x", W / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).text(parsed.title);
+  }
+  if (hasLegend) {
+    const legendParent = svg.append("g").attr("transform", `translate(0, ${titleReserve})`);
+    renderIntegratedLegend(legendParent, {
+      ...legendConfig,
+      palette,
+      isDark,
+      width: W,
+      activeGroup: activeTagGroup
+    });
+    legendParent.selectAll("[data-legend-group]").classed("family-legend-group", true);
+  }
+  const contentX = (W - contentW * scale) / 2;
+  const root = svg.append("g").attr(
+    "transform",
+    `translate(${contentX}, ${chrome + PAD}) scale(${scale})`
+  );
+  if (parsed.options["generations"] === "true" && layout.rows.length > 0) {
+    const bandG = root.append("g").attr("class", "family-generation-bands");
+    const toneA = mix(palette.textMuted, baseBg, 7);
+    const toneB = mix(palette.textMuted, baseBg, 2);
+    const BAND_VPAD = 12;
+    const BAND_INSET = 2;
+    for (let i = 0; i < layout.rows.length; i++) {
+      const r = layout.rows[i];
+      bandG.append("rect").attr("x", BAND_INSET).attr("y", r.y - BAND_VPAD).attr("width", Math.max(0, contentW - BAND_INSET * 2)).attr("height", r.height + BAND_VPAD * 2).attr("rx", CARD_RADIUS).attr("fill", i % 2 === 0 ? toneA : toneB);
+    }
+  }
+  const edgeG = root.append("g").attr("class", "family-edges");
+  const pathD = (pts) => pts.map((p, i) => `${i ? "L" : "M"}${p.x} ${p.y}`).join(" ");
+  const line = (pts, dashed, dimmed) => {
+    edgeG.append("path").attr("d", pathD(pts)).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", EDGE_STROKE_WIDTH).attr("stroke-dasharray", dashed ? "6 3" : null).attr("stroke-opacity", dimmed ? DIM_OPACITY : null);
+  };
+  const byUnion = /* @__PURE__ */ new Map();
+  for (const e of layout.edges) {
+    (byUnion.get(e.unionId) ?? byUnion.set(e.unionId, []).get(e.unionId)).push(
+      e
+    );
+  }
+  for (const group of byUnion.values()) {
+    const first = group[0];
+    const allAdopted = group.every((e) => e.adopted);
+    const trunkDimmed = group.every((e) => e.dimmed);
+    if (first.points.length > 2) {
+      line(first.points.slice(0, 2), allAdopted, trunkDimmed);
+      for (const e of group) line(e.points.slice(1), e.adopted, !!e.dimmed);
+    } else {
+      for (const e of group) line(e.points, e.adopted, !!e.dimmed);
+    }
+    for (const e of group) {
+      if (!e.adopted) continue;
+      const last = e.points[e.points.length - 1];
+      const prev = e.points[e.points.length - 2] ?? last;
+      edgeG.append("text").attr("x", last.x + 5).attr("y", (last.y + prev.y) / 2).attr("font-size", META_FONT_SIZE).attr("font-style", "italic").attr("fill", palette.textMuted).attr("fill-opacity", e.dimmed ? DIM_OPACITY : null).text("adopted");
+    }
+  }
+  const barG = root.append("g").attr("class", "family-bars");
+  for (const bar of layout.bars) {
+    const bg = barG.append("g");
+    if (bar.dimmed) bg.attr("opacity", DIM_OPACITY);
+    bg.append("line").attr("x1", bar.x1).attr("y1", bar.y).attr("x2", bar.x2).attr("y2", bar.y).attr("stroke", palette.textMuted).attr("stroke-width", EDGE_STROKE_WIDTH).attr("stroke-dasharray", bar.divorced ? "6 3" : null).attr("class", "family-marriage-bar").attr("data-line-number", String(bar.lineNumber));
+    bg.append("circle").attr("cx", bar.midX).attr("cy", bar.y).attr("r", BAR_DOT_R).attr("fill", palette.textMuted);
+    if (bar.year) {
+      bg.append("text").attr("x", bar.labelX).attr("y", bar.y - BAR_DOT_R - 3).attr("text-anchor", "middle").attr("font-size", META_FONT_SIZE).attr("fill", palette.textMuted).attr("stroke", baseBg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("paint-order", "stroke").text(`m. ${bar.year}`);
+    }
+  }
+  const occludeG = root.append("g").attr("class", "family-dim-occluders");
+  for (const node of layout.nodes) {
+    if (!node.dimmed) continue;
+    occludeG.append("rect").attr("x", node.x).attr("y", node.y).attr("width", node.width).attr("height", node.height).attr("rx", CARD_RADIUS).attr("fill", baseBg);
+  }
+  const cardsG = root.append("g").attr("class", "family-cards");
+  for (const node of layout.nodes) {
+    const isPh = !!node.placeholder;
+    const base = baseColor(node, parsed, palette, activeTagGroup);
+    const fill = isPh ? mix(palette.textMuted, baseBg, 6) : shapeFill(palette, base, isDark, { solid });
+    const stroke = isPh ? palette.textMuted : base;
+    const labelColor = isPh ? palette.textMuted : contrastText(fill, palette.textOnFillLight, palette.textOnFillDark);
+    const g = cardsG.append("g").attr("class", "family-card").attr("transform", `translate(${node.x}, ${node.y})`).attr("data-line-number", String(node.lineNumber)).attr("data-person-id", node.id);
+    if (node.dimmed) g.attr("opacity", DIM_OPACITY);
+    if (activeTagGroup) {
+      const key = tagAttrKey(activeTagGroup);
+      const v = node.tagMetadata[key];
+      if (v) g.attr(`data-tag-${key}`, v.toLowerCase());
+    }
+    g.append("rect").attr("x", 0).attr("y", 0).attr("width", node.width).attr("height", node.height).attr("rx", CARD_RADIUS).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", NODE_STROKE_WIDTH);
+    g.append("text").attr("x", node.width / 2).attr("y", HEADER_HEIGHT / 2 + LABEL_FONT_SIZE / 2 - 2).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", LABEL_FONT_SIZE).attr("font-weight", "bold").text(noDaggers ? node.label : familyDisplayLabel(node));
+    if (isPh) continue;
+    const fx = node.width - 13;
+    const fy = 9;
+    const focusG = g.append("g").attr("class", "family-focus-icon").attr("data-focus-person", node.id).attr("data-export-ignore", "true").style("cursor", "pointer");
+    focusG.append("rect").attr("x", fx - 6).attr("y", fy - 6).attr("width", 16).attr("height", 16).attr("fill", "transparent");
+    focusG.append("circle").attr("cx", fx).attr("cy", fy).attr("r", 5).attr("fill", "none").attr("stroke", labelColor).attr("stroke-width", 1.4);
+    focusG.append("circle").attr("cx", fx).attr("cy", fy).attr("r", 1.6).attr("fill", labelColor);
+    const rows = familyCardRows(node);
+    if (rows.length === 0) continue;
+    g.append("line").attr("x1", 0).attr("y1", HEADER_HEIGHT).attr("x2", node.width).attr("y2", HEADER_HEIGHT).attr("stroke", solid ? labelColor : stroke).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+    const maxKeyWidth = Math.max(
+      0,
+      ...rows.filter((r) => !r.year).map((r) => measureText(`${r.key}: `, META_FONT_SIZE))
+    );
+    const valueX = KEY_X + maxKeyWidth + KEY_VALUE_GAP;
+    const startY = HEADER_HEIGHT + SEPARATOR_GAP + META_FONT_SIZE;
+    rows.forEach((r, i) => {
+      const rowY = startY + i * META_LINE_HEIGHT;
+      if (r.year) {
+        g.append("text").attr("x", KEY_X).attr("y", rowY).attr("fill", labelColor).attr("fill-opacity", 0.7).attr("font-size", META_FONT_SIZE).text(r.value);
+      } else {
+        g.append("text").attr("x", KEY_X).attr("y", rowY).attr("fill", labelColor).attr("font-size", META_FONT_SIZE).text(`${r.key}: `);
+        g.append("text").attr("x", valueX).attr("y", rowY).attr("fill", labelColor).attr("font-size", META_FONT_SIZE).text(r.value);
+      }
+    });
+  }
+  if (parsed.options["generations"] === "true") {
+    const genG = root.append("g").attr("class", "family-generations");
+    for (const rw of layout.rows) {
+      genG.append("text").attr("x", 6).attr("y", rw.y + rw.height / 2).attr("dominant-baseline", "middle").attr("font-size", META_FONT_SIZE).attr("font-weight", "bold").attr("fill", palette.textMuted).text(`Gen ${toRoman(rw.row + 1)}`);
+    }
+  }
+  if (layout.ancestors.length > 0 && layout.focusAnchor) {
+    const aG = root.append("g").attr("class", "family-ancestors");
+    const anchor = layout.focusAnchor;
+    const dotY = layout.ancestors[0].y;
+    aG.append("line").attr("x1", anchor.x).attr("y1", dotY).attr("x2", anchor.x).attr("y2", anchor.y).attr("stroke", palette.textMuted).attr("stroke-width", EDGE_STROKE_WIDTH).attr("stroke-opacity", 0.5);
+    for (const a of layout.ancestors) {
+      const hue = (a.color ? resolveColor(a.color, palette) : null) ?? resolveColor(
+        a.sex === "m" ? "blue" : a.sex === "f" ? "purple" : "gray",
+        palette
+      ) ?? palette.textMuted;
+      const dot = aG.append("g").attr("data-ancestor", a.label).attr("data-focus-person", a.id).style("cursor", "pointer");
+      dot.append("circle").attr("cx", a.x).attr("cy", a.y).attr("r", 6).attr("fill", mix(hue, baseBg, 40)).attr("stroke", hue).attr("stroke-width", 1.5);
+      dot.append("text").attr("x", a.x + 10).attr("y", a.y).attr("dominant-baseline", "middle").attr("font-size", META_FONT_SIZE).attr("fill", palette.textMuted).attr("stroke", baseBg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("paint-order", "stroke").text(a.label);
+    }
+  }
+}
+function renderFamily(container, parsed, layout, palette, isDark, opts = {}) {
+  renderFamilyForExport(container, parsed, layout, palette, isDark, opts);
+}
+
+export {
+  renderFamilyForExport,
+  renderFamily
+};
+//# sourceMappingURL=chunk-SQDFK5ZQ.js.map