@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/{chunk-SGZYXELT.js → chunk-H73FP42Q.js}

@@ -4,6 +4,10 @@ import {
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
+import {
+  VARIANTS,
+  allTasks
+} from "./chunk-PGEGPSCZ.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_FONT_WEIGHT,
@@ -16,11 +20,7 @@ import {
   measureText,
   truncateText,
   wrapTextToWidth
-} from "./chunk-WCT3NYCV.js";
-import {
-  VARIANTS,
-  allTasks
-} from "./chunk-RYEGFMUO.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   contrastText,
   mix,
@@ -260,6 +260,9 @@ function renderRaci(container, parsed, palette, isDark, handlers, exportDims) {
   const totalHeight = colBottomY + sVMargin;
   const svgHeight = exportDims ? totalHeight : Math.max(height, totalHeight);
   const svg = d3Selection.select(container).append("svg").attr("xmlns", "http://www.w3.org/2000/svg").attr("width", width).attr("height", svgHeight).attr("viewBox", `0 0 ${width} ${svgHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY);
+  if (!exportDims && svgHeight > totalHeight) {
+    svg.attr("data-content-height", Math.ceil(totalHeight));
+  }
   if (ctx.isBelowFloor) {
     svg.attr("width", "100%");
   }
@@ -744,4 +747,4 @@ export {
   renderRaci,
   renderRaciForExport
 };
-//# sourceMappingURL=chunk-SGZYXELT.js.map
+//# sourceMappingURL=chunk-H73FP42Q.js.map

package/dist/{chunk-PBAHEPLQ.js → chunk-HGN652MU.js}

@@ -1,6 +1,6 @@
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 
 // src/label-layout.ts
 function rectsOverlap(a, b) {
@@ -57,16 +57,16 @@ function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
 function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius, fontSize) {
   const labelHeight = fontSize + 4;
   const stepSize = labelHeight + 2;
-  const minGap = pointRadius + 4;
   const pointCircles = points.map((p) => ({
     cx: p.cx,
     cy: p.cy,
-    r: pointRadius
+    r: p.r ?? pointRadius
   }));
   const placedLabels = [];
   const results = [];
   for (let i = 0; i < points.length; i++) {
     const pt = points[i];
+    const minGap = (pt.r ?? pointRadius) + 4;
     const labelWidth = measureText(pt.label, fontSize) + 8;
     let best = null;
     const directions = [
@@ -190,8 +190,9 @@ function computeQuadrantPointLabels(points, chartBounds, obstacles, pointRadius,
       const dx = best.textX - pt.cx;
       const dy = best.textY - pt.cy;
       const angle = Math.atan2(dy, dx);
-      const x1 = pt.cx + Math.cos(angle) * pointRadius;
-      const y1 = pt.cy + Math.sin(angle) * pointRadius;
+      const ptR = pt.r ?? pointRadius;
+      const x1 = pt.cx + Math.cos(angle) * ptR;
+      const y1 = pt.cy + Math.sin(angle) * ptR;
       const x2 = Math.max(
         best.rect.x,
         Math.min(pt.cx, best.rect.x + best.rect.w)
@@ -220,4 +221,4 @@ export {
   segmentsCross,
   computeQuadrantPointLabels
 };
-//# sourceMappingURL=chunk-PBAHEPLQ.js.map
+//# sourceMappingURL=chunk-HGN652MU.js.map

package/dist/{chunk-3SMGIJDD.js → chunk-HHXOONLX.js}

@@ -70,6 +70,18 @@ var MAP_DX = {
     hint: "Multiple places share this name \u2014 add a scope or `locale <ISO>` to steer it.",
     example: "map\npoi Portland"
   },
+  AMBIGUOUS_LABEL: {
+    // Runtime severity: 'error' (matches E_ prefix). A route/edge referenced a
+    // POI by its `label:`, but two or more declared POIs share that label, so the
+    // reference can't bind to one. Disambiguate with a unique `as <alias>`.
+    code: "E_MAP_AMBIGUOUS_LABEL",
+    severity: "error",
+    chartType: "map",
+    title: "Ambiguous POI label",
+    message: (p) => `Reference "${p.name ?? ""}" matches the label of two or more POIs \u2014 give each a distinct \`as <alias>\` and reference the alias instead.`,
+    hint: "Multiple POIs share this label \u2014 reference a unique `as <alias>` rather than the label.",
+    example: "map\npoi 1 2 label: Depot\npoi 3 4 label: Depot"
+  },
   DUPLICATE_POI: {
     // Runtime severity: 'warning' (matches W_ prefix). Only a declared-over-
     // declared collision warns; an implicit endpoint never triggers it.
@@ -109,4 +121,4 @@ export {
   MAP_DX,
   MAP_DIAGNOSTICS
 };
-//# sourceMappingURL=chunk-3SMGIJDD.js.map
+//# sourceMappingURL=chunk-HHXOONLX.js.map

package/dist/{chunk-QOOUC2J5.js → chunk-HQCHYB5F.js}

@@ -1,7 +1,7 @@
 import {
   measureText,
   truncateText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 
 // src/utils/legend-constants.ts
 var LEGEND_HEIGHT = 28;
@@ -49,4 +49,4 @@ export {
   LEGEND_TOGGLE_OFF_OPACITY,
   LEGEND_GEAR_PILL_W
 };
-//# sourceMappingURL=chunk-QOOUC2J5.js.map
+//# sourceMappingURL=chunk-HQCHYB5F.js.map

package/dist/{chunk-AELOBFW5.js → chunk-I4IFRCUB.js}

@@ -5,7 +5,7 @@ import {
   stripDefaultModifier,
   tagAttrKey,
   validateTagGroupNames
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   normalizeName
 } from "./chunk-NOTA6TEI.js";
@@ -18,7 +18,7 @@ import {
   splitNameAndMeta,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   resolveColorWithDiagnostic
 } from "./chunk-TLVIHFRO.js";
@@ -372,4 +372,4 @@ function parseCardLine(trimmed, lineNumber, counter, metaAliasMap, _palette, dia
 export {
   parseKanban
 };
-//# sourceMappingURL=chunk-AELOBFW5.js.map
+//# sourceMappingURL=chunk-I4IFRCUB.js.map

package/dist/{chunk-GMR5MFHJ.js → chunk-I7F2A35O.js}

@@ -3,7 +3,7 @@ import {
   splitNameAndMeta,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   makeDgmoError
 } from "./chunk-CXK4DZH3.js";
@@ -336,4 +336,4 @@ export {
   parseTimelineDate,
   parseTimelineEventLine
 };
-//# sourceMappingURL=chunk-GMR5MFHJ.js.map
+//# sourceMappingURL=chunk-I7F2A35O.js.map

package/dist/{chunk-T2OE3YQB.js → chunk-IA3FJYWR.js}

@@ -4,14 +4,14 @@ import {
 import {
   measureText,
   truncateText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   preprocessDescriptionLine
 } from "./chunk-IYULMRBE.js";
 import {
   injectDefaultTagMetadata,
   resolveTagColor
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 
 // src/mindmap/text-wrap.ts
 var H_PAD = 16;
@@ -547,4 +547,4 @@ export {
   computeNodeText,
   layoutMindmap
 };
-//# sourceMappingURL=chunk-T2OE3YQB.js.map
+//# sourceMappingURL=chunk-IA3FJYWR.js.map

package/dist/chunk-IAEC4KLA.js

@@ -0,0 +1,492 @@
+import {
+  familyCardRows
+} from "./chunk-IVKC4GID.js";
+import {
+  HEADER_HEIGHT,
+  LABEL_FONT_SIZE,
+  META_FONT_SIZE,
+  META_LINE_HEIGHT,
+  SEPARATOR_GAP
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  measureText
+} from "./chunk-5LWQH6QV.js";
+import {
+  buildCoupleQuotient,
+  rankClasses
+} from "./chunk-QQJUTGQH.js";
+
+// src/family/layout.ts
+var MARGIN = 30;
+var MIN_CARD_W = 132;
+var CARD_H_PAD = 12;
+var CARD_TEXT_PAD = 12;
+var H_GAP = 60;
+var ROW_GAP = 74;
+var KEY_VALUE_GAP = 6;
+var KEY_X = 10;
+var GUTTER_WIDTH = 72;
+function birthYear(persons, id) {
+  const b = persons.get(id)?.metadata["b"];
+  if (b === void 0) return null;
+  const n = parseInt(b, 10);
+  return Number.isFinite(n) ? n : null;
+}
+function sortChildrenByBirth(children, persons) {
+  return children.map((c, i) => ({ c, i, b: birthYear(persons, c.personId) })).sort((x, y) => {
+    if (x.b !== null && y.b !== null) return x.b - y.b || x.i - y.i;
+    if (x.b !== null) return -1;
+    if (y.b !== null) return 1;
+    return x.i - y.i;
+  }).map((o) => o.c);
+}
+function computeBloodline(unions, focusId) {
+  const childOf = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  const unionById = new Map(unions.map((u) => [u.id, u]));
+  for (const u of unions) {
+    for (const p of u.parents)
+      (parentOf.get(p) ?? parentOf.set(p, []).get(p)).push(u.id);
+    for (const c of u.children)
+      (childOf.get(c.personId) ?? childOf.set(c.personId, []).get(c.personId)).push(u.id);
+  }
+  const set = /* @__PURE__ */ new Set([focusId]);
+  const up = [focusId];
+  while (up.length) {
+    const id = up.pop();
+    for (const uid of childOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents)
+        if (!set.has(p)) {
+          set.add(p);
+          up.push(p);
+        }
+  }
+  const down = [focusId];
+  while (down.length) {
+    const id = down.pop();
+    for (const uid of parentOf.get(id) ?? [])
+      for (const c of unionById.get(uid).children)
+        if (!set.has(c.personId)) {
+          set.add(c.personId);
+          down.push(c.personId);
+        }
+  }
+  for (const id of [...set])
+    for (const uid of parentOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents) set.add(p);
+  return set;
+}
+function cardSize(p) {
+  const rows = familyCardRows(p);
+  const labeled = rows.filter((r) => !r.year);
+  const maxKeyW = labeled.length ? Math.max(...labeled.map((r) => measureText(`${r.key}: `, META_FONT_SIZE))) : 0;
+  const valueX = KEY_X + maxKeyW + KEY_VALUE_GAP;
+  let contentRight = 0;
+  for (const r of rows) {
+    const right = r.year ? KEY_X + measureText(r.value, META_FONT_SIZE) : valueX + measureText(r.value, META_FONT_SIZE);
+    contentRight = Math.max(contentRight, right);
+  }
+  const labelW = measureText(p.label, LABEL_FONT_SIZE);
+  const width = Math.max(
+    MIN_CARD_W,
+    labelW + CARD_TEXT_PAD * 2,
+    contentRight + CARD_TEXT_PAD
+  );
+  const height = rows.length > 0 ? HEADER_HEIGHT + SEPARATOR_GAP + rows.length * META_LINE_HEIGHT + CARD_H_PAD : HEADER_HEIGHT + CARD_H_PAD;
+  return { width, height };
+}
+function orderRow(persons, parentUnions, unionParents, unionChildren, unionOrder) {
+  const disco = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const visit = (id) => {
+    if (disco.has(id)) return;
+    disco.set(id, seq++);
+    for (const uid of parentUnions.get(id) ?? []) {
+      for (const sp of unionParents.get(uid) ?? []) visit(sp);
+      for (const ch of unionChildren.get(uid) ?? []) visit(ch);
+    }
+  };
+  for (const uid of unionOrder) {
+    for (const p of unionParents.get(uid) ?? []) visit(p);
+  }
+  for (const id of persons.keys()) visit(id);
+  return disco;
+}
+function orderRowSpouses(ids, spouseAdj, discoOf) {
+  const inRow = new Set(ids);
+  const nbrs = (id) => [...spouseAdj.get(id) ?? []].filter((n) => inRow.has(n));
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const seed of [...ids].sort((a, b) => discoOf(a) - discoOf(b))) {
+    if (visited.has(seed)) continue;
+    const comp = [];
+    const stack = [seed];
+    visited.add(seed);
+    while (stack.length) {
+      const v = stack.pop();
+      comp.push(v);
+      for (const w of nbrs(v))
+        if (!visited.has(w)) {
+          visited.add(w);
+          stack.push(w);
+        }
+    }
+    if (comp.length === 1) {
+      components.push(comp);
+      continue;
+    }
+    const start = comp.filter((id) => nbrs(id).length <= 1).sort((a, b) => discoOf(a) - discoOf(b))[0] ?? comp.slice().sort((a, b) => discoOf(a) - discoOf(b))[0];
+    const path = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cur = start;
+    while (cur !== void 0 && !seen.has(cur)) {
+      seen.add(cur);
+      path.push(cur);
+      cur = nbrs(cur).filter((n) => !seen.has(n)).sort((a, b) => discoOf(a) - discoOf(b))[0];
+    }
+    for (const id of comp) if (!seen.has(id)) path.push(id);
+    components.push(path);
+  }
+  components.sort(
+    (x, y) => Math.min(...x.map(discoOf)) - Math.min(...y.map(discoOf))
+  );
+  return components.flat();
+}
+function focusFamily(parsed, focusId) {
+  if (!parsed.persons.has(focusId)) {
+    return { persons: parsed.persons, unions: parsed.unions, parents: [] };
+  }
+  const childOf = /* @__PURE__ */ new Map();
+  const parentOf = /* @__PURE__ */ new Map();
+  const unionById = new Map(parsed.unions.map((u) => [u.id, u]));
+  for (const u of parsed.unions) {
+    for (const p of u.parents)
+      (parentOf.get(p) ?? parentOf.set(p, []).get(p)).push(u.id);
+    for (const c of u.children)
+      (childOf.get(c.personId) ?? childOf.set(c.personId, []).get(c.personId)).push(u.id);
+  }
+  const visible = /* @__PURE__ */ new Set([focusId]);
+  const down = [focusId];
+  while (down.length) {
+    const id = down.pop();
+    for (const uid of parentOf.get(id) ?? [])
+      for (const c of unionById.get(uid).children)
+        if (!visible.has(c.personId)) {
+          visible.add(c.personId);
+          down.push(c.personId);
+        }
+  }
+  for (const id of [...visible])
+    for (const uid of parentOf.get(id) ?? [])
+      for (const p of unionById.get(uid).parents) visible.add(p);
+  const parentIds = /* @__PURE__ */ new Set();
+  for (const uid of childOf.get(focusId) ?? [])
+    for (const p of unionById.get(uid).parents) parentIds.add(p);
+  const parents = [...parentIds].map((id) => parsed.persons.get(id)).filter((p) => p !== void 0);
+  const persons = /* @__PURE__ */ new Map();
+  for (const [id, p] of parsed.persons) if (visible.has(id)) persons.set(id, p);
+  const unions = parsed.unions.filter((u) => u.parents.every((p) => visible.has(p))).map((u) => ({
+    ...u,
+    children: u.children.filter((c) => visible.has(c.personId))
+  }));
+  return { persons, unions, parents };
+}
+function layoutFamily(parsed, focusId) {
+  const focused = focusId ? focusFamily(parsed, focusId) : null;
+  const persons = focused ? focused.persons : parsed.persons;
+  const unions = (focused ? focused.unions : parsed.unions).map((u) => ({ ...u, children: sortChildrenByBirth(u.children, persons) }));
+  const focusParents = focused ? focused.parents : [];
+  const highlightId = parsed.options["highlight"] || null;
+  const litSet = highlightId ? computeBloodline(unions, highlightId) : null;
+  const showGen = parsed.options["generations"] === "true";
+  const ANCESTOR_STAGGER = 20;
+  const ANCESTOR_BAND = focusParents.length > 0 ? 34 + Math.max(0, focusParents.length - 1) * ANCESTOR_STAGGER : 0;
+  const quotient = buildCoupleQuotient(persons, unions);
+  const classRow = quotient.cycle ? /* @__PURE__ */ new Map() : rankClasses(quotient);
+  const rowOf = (id) => {
+    const c = quotient.classOf.get(id);
+    return c === void 0 ? 0 : classRow.get(c) ?? 0;
+  };
+  const parentUnions = /* @__PURE__ */ new Map();
+  const unionParents = /* @__PURE__ */ new Map();
+  const unionChildren = /* @__PURE__ */ new Map();
+  const unionOrder = [];
+  for (const u of unions) {
+    unionOrder.push(u.id);
+    unionParents.set(u.id, [...u.parents]);
+    unionChildren.set(
+      u.id,
+      u.children.map((c) => c.personId)
+    );
+    for (const p of u.parents) {
+      (parentUnions.get(p) ?? parentUnions.set(p, []).get(p)).push(u.id);
+    }
+  }
+  const disco = orderRow(
+    persons,
+    parentUnions,
+    unionParents,
+    unionChildren,
+    unionOrder
+  );
+  const sizes = /* @__PURE__ */ new Map();
+  for (const [id, p] of persons) sizes.set(id, cardSize(p));
+  const rowPersons = /* @__PURE__ */ new Map();
+  let maxRow = 0;
+  for (const id of persons.keys()) {
+    const r = rowOf(id);
+    maxRow = Math.max(maxRow, r);
+    (rowPersons.get(r) ?? rowPersons.set(r, []).get(r)).push(id);
+  }
+  const spouseAdj = /* @__PURE__ */ new Map();
+  for (const u of unions) {
+    if (u.parents.length !== 2) continue;
+    const [a, b] = u.parents;
+    (spouseAdj.get(a) ?? spouseAdj.set(a, /* @__PURE__ */ new Set()).get(a)).add(b);
+    (spouseAdj.get(b) ?? spouseAdj.set(b, /* @__PURE__ */ new Set()).get(b)).add(a);
+  }
+  const discoOf = (id) => disco.get(id) ?? 0;
+  for (const [r, arr] of rowPersons) {
+    rowPersons.set(r, orderRowSpouses(arr, spouseAdj, discoOf));
+  }
+  const rowHeight = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    let h = 0;
+    for (const id of rowPersons.get(r) ?? [])
+      h = Math.max(h, sizes.get(id).height);
+    rowHeight.set(r, h);
+  }
+  const rowY = /* @__PURE__ */ new Map();
+  {
+    let acc = MARGIN + ANCESTOR_BAND;
+    for (let r = 0; r <= maxRow; r++) {
+      rowY.set(r, acc);
+      acc += (rowHeight.get(r) ?? 0) + ROW_GAP;
+    }
+  }
+  const centerX = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    let acc = 0;
+    for (const id of rowPersons.get(r) ?? []) {
+      const w = sizes.get(id).width;
+      centerX.set(id, acc + w / 2);
+      acc += w + H_GAP;
+    }
+  }
+  const resolveRow = (ids, desired) => {
+    let prevRight = -Infinity;
+    for (const id of ids) {
+      const half = sizes.get(id).width / 2;
+      let c = desired.get(id) ?? centerX.get(id);
+      const minC = prevRight + H_GAP + half;
+      if (c < minC) c = minC;
+      centerX.set(id, c);
+      prevRight = c + half;
+    }
+  };
+  const childrenBlockCenter = (uid) => {
+    const cs = (unionChildren.get(uid) ?? []).filter((c) => centerX.has(c)).map((c) => centerX.get(c));
+    if (cs.length === 0) return void 0;
+    return (Math.min(...cs) + Math.max(...cs)) / 2;
+  };
+  const rowOfPerson = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++)
+    for (const id of rowPersons.get(r) ?? []) rowOfPerson.set(id, r);
+  for (let iter = 0; iter < 4; iter++) {
+    for (let r = maxRow - 1; r >= 0; r--) {
+      const desiredParts = /* @__PURE__ */ new Map();
+      const add = (id, x) => {
+        (desiredParts.get(id) ?? desiredParts.set(id, []).get(id)).push(x);
+      };
+      for (const u of unions) {
+        const onRow = u.parents.filter((p) => rowOfPerson.get(p) === r);
+        if (onRow.length === 0) continue;
+        const cc = childrenBlockCenter(u.id);
+        if (cc === void 0) continue;
+        if (onRow.length === 2) {
+          const lr = [...onRow].sort(
+            (a, b) => centerX.get(a) - centerX.get(b)
+          );
+          const [l, rr] = lr;
+          const d = sizes.get(l).width / 2 + H_GAP + sizes.get(rr).width / 2;
+          add(l, cc - d / 2);
+          add(rr, cc + d / 2);
+        } else {
+          for (const p of onRow) add(p, cc);
+        }
+      }
+      const desired = /* @__PURE__ */ new Map();
+      for (const [id, xs] of desiredParts)
+        desired.set(id, xs.reduce((a, b) => a + b, 0) / xs.length);
+      resolveRow(rowPersons.get(r) ?? [], desired);
+    }
+  }
+  const unionMid = (u) => {
+    const ps = u.parents.filter((p) => centerX.has(p));
+    return ps.reduce((s, p) => s + centerX.get(p), 0) / ps.length;
+  };
+  for (let pass = 0; pass < 2; pass++) {
+    for (let r = 1; r <= maxRow; r++) {
+      const desired = /* @__PURE__ */ new Map();
+      for (const u of unions) {
+        const kids = u.children.map((c) => c.personId).filter((id) => rowOfPerson.get(id) === r && centerX.has(id)).sort((a, b) => centerX.get(a) - centerX.get(b));
+        if (kids.length === 0 || u.parents.every((p) => !centerX.has(p)))
+          continue;
+        const blockW = kids.reduce((s, id) => s + sizes.get(id).width, 0) + H_GAP * (kids.length - 1);
+        let left = unionMid(u) - blockW / 2;
+        for (const id of kids) {
+          const w = sizes.get(id).width;
+          desired.set(id, left + w / 2);
+          left += w + H_GAP;
+        }
+      }
+      resolveRow(rowPersons.get(r) ?? [], desired);
+    }
+  }
+  let minLeft = Infinity;
+  for (const id of persons.keys())
+    minLeft = Math.min(minLeft, centerX.get(id) - sizes.get(id).width / 2);
+  const gutter = showGen ? GUTTER_WIDTH : 0;
+  const dx = (Number.isFinite(minLeft) ? MARGIN - minLeft : MARGIN) + gutter;
+  const nodes = [];
+  const topY = /* @__PURE__ */ new Map();
+  const bottomY = /* @__PURE__ */ new Map();
+  for (let r = 0; r <= maxRow; r++) {
+    for (const id of rowPersons.get(r) ?? []) {
+      const p = persons.get(id);
+      const s = sizes.get(id);
+      const x = centerX.get(id) - s.width / 2 + dx;
+      const y = rowY.get(r);
+      centerX.set(id, x + s.width / 2);
+      topY.set(id, y);
+      bottomY.set(id, y + s.height);
+      nodes.push({
+        id: p.id,
+        label: p.label,
+        sex: p.sex,
+        metadata: p.metadata,
+        ...p.color !== void 0 && { color: p.color },
+        tagMetadata: p.tagMetadata,
+        x,
+        y,
+        width: s.width,
+        height: s.height,
+        row: r,
+        ...p.placeholder && { placeholder: true },
+        ...litSet && !litSet.has(id) && { dimmed: true },
+        lineNumber: p.lineNumber
+      });
+    }
+  }
+  let contentRightEdge = 0;
+  for (const n of nodes)
+    contentRightEdge = Math.max(contentRightEdge, n.x + n.width);
+  const bars = [];
+  for (const u of unions) {
+    if (u.parents.length !== 2) continue;
+    const [a, b] = u.parents;
+    if (!centerX.has(a) || !centerX.has(b)) continue;
+    const rowTop = Math.min(topY.get(a), topY.get(b));
+    const ay = rowTop + HEADER_HEIGHT / 2;
+    const ax = centerX.get(a);
+    const bx = centerX.get(b);
+    const x1 = Math.min(ax, bx);
+    const x2 = Math.max(ax, bx);
+    const leftId = ax <= bx ? a : b;
+    const rightId = ax <= bx ? b : a;
+    const gapCenter = (centerX.get(leftId) + sizes.get(leftId).width / 2 + (centerX.get(rightId) - sizes.get(rightId).width / 2)) / 2;
+    bars.push({
+      unionId: u.id,
+      x1,
+      x2,
+      y: ay,
+      midX: (x1 + x2) / 2,
+      labelX: gapCenter,
+      ...u.metadata["m"] !== void 0 && { year: u.metadata["m"] },
+      ...u.divorced && { divorced: true },
+      ...litSet && !(litSet.has(a) && litSet.has(b)) && { dimmed: true },
+      lineNumber: u.lineNumber
+    });
+  }
+  const barByUnion = new Map(bars.map((bar) => [bar.unionId, bar]));
+  const edges = [];
+  for (const u of unions) {
+    if (u.children.length === 0) continue;
+    let anchorX;
+    let anchorY;
+    const bar = barByUnion.get(u.id);
+    if (bar) {
+      anchorX = bar.midX;
+      anchorY = bar.y;
+    } else {
+      const p = u.parents[0];
+      if (p === void 0 || !centerX.has(p)) continue;
+      anchorX = centerX.get(p);
+      anchorY = bottomY.get(p);
+    }
+    const kids = u.children.filter((c) => centerX.has(c.personId));
+    if (kids.length === 0) continue;
+    const childTop = Math.min(...kids.map((c) => topY.get(c.personId)));
+    const parentsBottom = Math.max(
+      ...u.parents.filter((p) => bottomY.has(p)).map((p) => bottomY.get(p))
+    );
+    const midY = (parentsBottom + childTop) / 2;
+    for (const c of kids) {
+      const cx = centerX.get(c.personId);
+      const cTop = topY.get(c.personId);
+      edges.push({
+        unionId: u.id,
+        childId: c.personId,
+        points: [
+          { x: anchorX, y: anchorY },
+          { x: anchorX, y: midY },
+          { x: cx, y: midY },
+          { x: cx, y: cTop }
+        ],
+        adopted: c.adopted,
+        ...litSet && !litSet.has(c.personId) && { dimmed: true }
+      });
+    }
+  }
+  const ancestors = [];
+  let focusAnchor;
+  if (focusId && focusParents.length > 0 && centerX.has(focusId)) {
+    const fx = centerX.get(focusId);
+    const fTop = topY.get(focusId);
+    focusAnchor = { x: fx, y: fTop };
+    focusParents.forEach((p, i) => {
+      ancestors.push({
+        id: p.id,
+        label: p.label,
+        sex: p.sex,
+        ...p.color !== void 0 && { color: p.color },
+        x: fx,
+        y: MARGIN + 10 + i * ANCESTOR_STAGGER
+      });
+    });
+  }
+  const width = contentRightEdge + MARGIN;
+  const lastR = maxRow;
+  const height = (rowY.get(lastR) ?? MARGIN) + (rowHeight.get(lastR) ?? 0) + MARGIN;
+  const rows = [];
+  for (let r = 0; r <= maxRow; r++) {
+    if (!rowPersons.get(r)?.length) continue;
+    rows.push({ row: r, y: rowY.get(r), height: rowHeight.get(r) ?? 0 });
+  }
+  return {
+    nodes,
+    bars,
+    edges,
+    ancestors,
+    ...focusAnchor !== void 0 && { focusAnchor },
+    rows,
+    width,
+    height
+  };
+}
+
+export {
+  focusFamily,
+  layoutFamily
+};
+//# sourceMappingURL=chunk-IAEC4KLA.js.map