schematex 0.1.0

package/dist/chunk-D4JTSPOL.js

@@ -0,0 +1,1795 @@
+import { resolveGenogramTheme, STROKE_WIDTH, cssCustomProperties } from './chunk-IX554O5K.js';
+import { title, text, group, el, rect, pattern, path, circle, defs, polygon, line, desc, svgRoot } from './chunk-KLJEK547.js';
+
+// src/diagrams/genogram/parser.ts
+var ParseError = class extends Error {
+  constructor(message, line2, column, source) {
+    super(`Line ${line2}, col ${column}: ${message}
+  \u2192 ${source}`);
+    this.line = line2;
+    this.column = column;
+    this.source = source;
+    this.name = "ParseError";
+  }
+  line;
+  column;
+  source;
+};
+var COUPLE_OPS = [
+  { token: "-x-", type: "divorced" },
+  { token: "-/-", type: "separated" },
+  { token: "-o-", type: "engaged" },
+  { token: "==", type: "consanguineous" },
+  { token: "--", type: "married" },
+  { token: "~", type: "cohabiting" }
+];
+var VALID_SEX = /* @__PURE__ */ new Set(["male", "female", "unknown", "other"]);
+var VALID_STATUS = /* @__PURE__ */ new Set([
+  "deceased",
+  "stillborn",
+  "miscarriage",
+  "abortion"
+]);
+var SPECIAL_CHILD_PROPS = /* @__PURE__ */ new Set([
+  "adopted",
+  "foster",
+  "twin-identical",
+  "twin-fraternal"
+]);
+var VALID_FILLS = /* @__PURE__ */ new Set([
+  "full",
+  "half-left",
+  "half-right",
+  "half-top",
+  "half-bottom",
+  "quad-tl",
+  "quad-tr",
+  "quad-bl",
+  "quad-br",
+  "quarter",
+  "striped",
+  "dotted"
+]);
+var EMOTIONAL_TYPES = /* @__PURE__ */ new Set([
+  "harmony",
+  "close",
+  "bestfriends",
+  "love",
+  "inlove",
+  "friendship",
+  "hostile",
+  "conflict",
+  "enmity",
+  "distant-hostile",
+  "cutoff",
+  "close-hostile",
+  "fused",
+  "fused-hostile",
+  "distant",
+  "normal",
+  "nevermet",
+  "abuse",
+  "physical-abuse",
+  "emotional-abuse",
+  "sexual-abuse",
+  "neglect",
+  "manipulative",
+  "controlling",
+  "jealous",
+  "focused",
+  "focused-neg",
+  "distrust",
+  "admirer",
+  "limerence"
+]);
+function parseGenogram(text2) {
+  const rawLines = text2.split("\n");
+  const state = { lines: rawLines, currentLine: 0 };
+  skipBlankAndComments(state);
+  const metadata = {};
+  const headerLine = currentLineText(state);
+  if (headerLine === void 0) {
+    throw new ParseError("Empty input", 1, 1, "");
+  }
+  const headerTrimmed = headerLine.trim();
+  if (!headerTrimmed.toLowerCase().startsWith("genogram")) {
+    throw new ParseError(
+      'Expected "genogram" header',
+      state.currentLine + 1,
+      1,
+      headerLine
+    );
+  }
+  const titleMatch = headerTrimmed.match(/^genogram\s+"([^"]*)"$/i);
+  if (titleMatch) {
+    metadata.title = titleMatch[1];
+  }
+  state.currentLine++;
+  const individualsMap = /* @__PURE__ */ new Map();
+  const relationships = [];
+  const childSpecialProps = /* @__PURE__ */ new Map();
+  skipBlankAndComments(state);
+  while (state.currentLine < state.lines.length) {
+    skipBlankAndComments(state);
+    if (state.currentLine >= state.lines.length) break;
+    const lineText = state.lines[state.currentLine];
+    const trimmed = lineText.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      state.currentLine++;
+      continue;
+    }
+    const emotionalMatch = detectEmotionalOp(trimmed);
+    if (emotionalMatch) {
+      const { leftId, emotionalType, rightId: emRightId, directional, label: emLabel } = emotionalMatch;
+      const lineNum = state.currentLine + 1;
+      const leftKey = leftId.toLowerCase();
+      const rightKey = emRightId.toLowerCase();
+      if (!individualsMap.has(leftKey)) {
+        throw new ParseError(`Unknown individual '${leftId}'`, lineNum, 1, lineText);
+      }
+      if (!individualsMap.has(rightKey)) {
+        throw new ParseError(`Unknown individual '${emRightId}'`, lineNum, 1, lineText);
+      }
+      const rel = {
+        type: emotionalType,
+        from: leftKey,
+        to: rightKey
+      };
+      if (directional) rel.directional = true;
+      if (emLabel) rel.label = emLabel;
+      relationships.push(rel);
+      state.currentLine++;
+      continue;
+    }
+    const coupleMatch = detectCoupleOp(trimmed);
+    if (coupleMatch) {
+      const { leftId, op, rightRaw } = coupleMatch;
+      const lineNum = state.currentLine + 1;
+      const { cleaned: rightCleaned, label: relLabel } = extractRelLabel(rightRaw);
+      const { id: rightId, props: rightProps } = parseIdWithOptionalProps(rightCleaned);
+      const leftKey = leftId.toLowerCase();
+      if (!individualsMap.has(leftKey)) {
+        throw new ParseError(
+          `Unknown individual '${leftId}'`,
+          lineNum,
+          1,
+          lineText
+        );
+      }
+      const rightKey = rightId.toLowerCase();
+      if (rightProps) {
+        const rightIndividual = buildIndividual(rightId, rightProps, lineNum, lineText);
+        individualsMap.set(rightKey, rightIndividual);
+      } else if (!individualsMap.has(rightKey)) {
+        throw new ParseError(
+          `Unknown individual '${rightId}'`,
+          lineNum,
+          1,
+          lineText
+        );
+      }
+      const rel = { type: op.type, from: leftKey, to: rightKey };
+      if (relLabel) rel.label = relLabel;
+      relationships.push(rel);
+      const coupleIndent = getIndent(lineText);
+      state.currentLine++;
+      while (state.currentLine < state.lines.length) {
+        const childLine = state.lines[state.currentLine];
+        const childTrimmed = childLine.trim();
+        if (childTrimmed === "" || childTrimmed.startsWith("#")) {
+          state.currentLine++;
+          continue;
+        }
+        const childIndent = getIndent(childLine);
+        if (childIndent <= coupleIndent) break;
+        const childLineNum = state.currentLine + 1;
+        const { id: childId, propsStr } = splitIdAndProps(childTrimmed);
+        const childKey = childId.toLowerCase();
+        const individual = buildIndividual(
+          childId,
+          propsStr,
+          childLineNum,
+          childLine
+        );
+        if (propsStr) {
+          for (const sp of SPECIAL_CHILD_PROPS) {
+            if (propsTokens(propsStr).includes(sp)) {
+              childSpecialProps.set(childKey, sp);
+            }
+          }
+        }
+        individualsMap.set(childKey, individual);
+        const coupleKey = `${leftKey}+${rightKey}`;
+        const pcType = childSpecialProps.get(childKey);
+        const relType = pcType && (pcType === "adopted" || pcType === "foster") ? pcType : "parent-child";
+        relationships.push({ type: relType, from: coupleKey, to: childKey });
+        state.currentLine++;
+      }
+    } else {
+      const lineNum = state.currentLine + 1;
+      const { id, propsStr } = splitIdAndProps(trimmed);
+      const key = id.toLowerCase();
+      const individual = buildIndividual(id, propsStr, lineNum, lineText);
+      const existing = individualsMap.get(key);
+      if (existing) {
+        individualsMap.set(key, mergeIndividual(existing, individual));
+      } else {
+        individualsMap.set(key, individual);
+      }
+      state.currentLine++;
+    }
+  }
+  const twinGroups = /* @__PURE__ */ new Map();
+  for (const [childKey, prop] of childSpecialProps) {
+    if (prop === "twin-identical" || prop === "twin-fraternal") {
+      const pcRel = relationships.find(
+        (r) => r.to === childKey && (r.type === "parent-child" || r.type === "adopted" || r.type === "foster")
+      );
+      if (pcRel) {
+        const groupKey = `${pcRel.from}:${prop}`;
+        const group2 = twinGroups.get(groupKey) ?? [];
+        group2.push(childKey);
+        twinGroups.set(groupKey, group2);
+      }
+    }
+  }
+  for (const [groupKey, members] of twinGroups) {
+    const twinType = groupKey.split(":")[1];
+    for (let i = 0; i < members.length - 1; i++) {
+      relationships.push({
+        type: twinType,
+        from: members[i],
+        to: members[i + 1]
+      });
+    }
+  }
+  return {
+    type: "genogram",
+    individuals: Array.from(individualsMap.values()),
+    relationships,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+function currentLineText(state) {
+  return state.lines[state.currentLine];
+}
+function skipBlankAndComments(state) {
+  while (state.currentLine < state.lines.length) {
+    const t = state.lines[state.currentLine].trim();
+    if (t === "" || t.startsWith("#")) {
+      state.currentLine++;
+    } else {
+      break;
+    }
+  }
+}
+function getIndent(line2) {
+  const match = line2.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+function detectEmotionalOp(trimmed) {
+  const match = trimmed.match(
+    /^([a-zA-Z][a-zA-Z0-9_-]*)\s+-([\w-]+)->(.*)|^([a-zA-Z][a-zA-Z0-9_-]*)\s+-([\w-]+)-\s+(.*)/
+  );
+  if (!match) return null;
+  const directional = !!match[1];
+  const leftId = directional ? match[1] : match[4];
+  const emotionalType = directional ? match[2] : match[5];
+  const rest = (directional ? match[3] : match[6]).trim();
+  if (!EMOTIONAL_TYPES.has(emotionalType)) return null;
+  const { id: rightId, label } = extractIdAndLabel(rest);
+  if (!rightId || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(rightId)) return null;
+  return { leftId, emotionalType, rightId, directional, label };
+}
+function extractIdAndLabel(raw) {
+  const labelMatch = raw.match(/^([a-zA-Z][a-zA-Z0-9_-]*)\s+"([^"]*)"$/);
+  if (labelMatch) return { id: labelMatch[1], label: labelMatch[2] };
+  const idOnly = raw.match(/^([a-zA-Z][a-zA-Z0-9_-]*)$/);
+  if (idOnly) return { id: idOnly[1], label: null };
+  return { id: raw.trim(), label: null };
+}
+function extractRelLabel(rightRaw) {
+  const match = rightRaw.match(/^(.*?)\s+"([^"]*)"$/);
+  if (match) return { cleaned: match[1].trim(), label: match[2] };
+  return { cleaned: rightRaw, label: null };
+}
+function detectCoupleOp(trimmed) {
+  for (const op of COUPLE_OPS) {
+    const parts = splitByOperator(trimmed, op.token);
+    if (parts) {
+      return { leftId: parts.left.trim(), op, rightRaw: parts.right.trim() };
+    }
+  }
+  return null;
+}
+function splitByOperator(line2, op) {
+  let bracketDepth = 0;
+  for (let i = 0; i < line2.length; i++) {
+    if (line2[i] === "[") bracketDepth++;
+    if (line2[i] === "]") bracketDepth--;
+    if (bracketDepth > 0) continue;
+    if (line2.substring(i, i + op.length) === op) {
+      const left = line2.substring(0, i).trim();
+      const right = line2.substring(i + op.length).trim();
+      if (left && right) {
+        const leftId = left.match(/^[a-zA-Z][a-zA-Z0-9_-]*$/);
+        if (leftId) return { left, right };
+      }
+    }
+  }
+  return null;
+}
+function parseIdWithOptionalProps(raw) {
+  const bracketIdx = raw.indexOf("[");
+  if (bracketIdx === -1) {
+    return { id: raw.trim(), props: null };
+  }
+  const id = raw.substring(0, bracketIdx).trim();
+  const endBracket = raw.lastIndexOf("]");
+  const propsStr = raw.substring(bracketIdx + 1, endBracket === -1 ? raw.length : endBracket);
+  return { id, props: propsStr };
+}
+function splitIdAndProps(trimmed) {
+  const bracketIdx = trimmed.indexOf("[");
+  if (bracketIdx === -1) {
+    return { id: trimmed.trim(), propsStr: null };
+  }
+  const id = trimmed.substring(0, bracketIdx).trim();
+  const endBracket = trimmed.lastIndexOf("]");
+  const propsStr = trimmed.substring(
+    bracketIdx + 1,
+    endBracket === -1 ? trimmed.length : endBracket
+  );
+  return { id, propsStr };
+}
+function propsTokens(propsStr) {
+  return splitProps(propsStr).map((t) => t.trim().toLowerCase());
+}
+function splitProps(propsStr) {
+  const result = [];
+  let current = "";
+  let parenDepth = 0;
+  for (const ch of propsStr) {
+    if (ch === "(") parenDepth++;
+    if (ch === ")") parenDepth--;
+    if (ch === "," && parenDepth === 0) {
+      result.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) result.push(current);
+  return result;
+}
+function buildIndividual(id, propsStr, lineNum, lineText) {
+  const individual = {
+    id: id.toLowerCase(),
+    label: id,
+    sex: "unknown",
+    status: "alive"
+  };
+  if (!propsStr) return individual;
+  const tokens = splitProps(propsStr);
+  for (const rawToken of tokens) {
+    const token = rawToken.trim();
+    const tokenLower = token.toLowerCase();
+    if (VALID_SEX.has(tokenLower)) {
+      individual.sex = tokenLower;
+    } else if (VALID_STATUS.has(tokenLower)) {
+      individual.status = tokenLower;
+    } else if (tokenLower === "index") {
+      if (!individual.markers) individual.markers = [];
+      individual.markers.push("index-person");
+    } else if (SPECIAL_CHILD_PROPS.has(tokenLower)) {
+      continue;
+    } else if (/^\d{4}$/.test(tokenLower)) {
+      if (individual.birthYear !== void 0) {
+        individual.deathYear = parseInt(token, 10);
+      } else {
+        individual.birthYear = parseInt(token, 10);
+      }
+    } else if (tokenLower.startsWith("conditions:")) {
+      individual.conditions = parseConditions(
+        token.substring("conditions:".length).trim(),
+        lineNum,
+        lineText
+      );
+    } else if (token.includes(":")) {
+      const colonIdx = token.indexOf(":");
+      const key = token.substring(0, colonIdx).trim().toLowerCase();
+      const value = token.substring(colonIdx + 1).trim();
+      if (key === "age") {
+        const ageNum = parseInt(value, 10);
+        if (!isNaN(ageNum)) individual.age = ageNum;
+      } else if (key === "death") {
+        const deathNum = parseInt(value, 10);
+        if (!isNaN(deathNum)) individual.deathYear = deathNum;
+      } else if (key === "label") {
+        individual.label = value.replace(/^"|"$/g, "");
+      } else {
+        if (!individual.properties) individual.properties = {};
+        individual.properties[key] = value;
+      }
+    } else {
+      throw new ParseError(
+        `Unknown property '${token}'. Valid: male, female, unknown, deceased, stillborn, miscarriage, abortion, adopted, foster, twin-identical, twin-fraternal, index, a 4-digit year, conditions:..., age:N, death:YYYY, or key:value`,
+        lineNum,
+        1,
+        lineText
+      );
+    }
+  }
+  return individual;
+}
+function parseConditions(raw, lineNum, lineText) {
+  const parts = raw.split("+").map((s) => s.trim());
+  const conditions = [];
+  for (const part of parts) {
+    const match = part.match(/^([a-zA-Z0-9_-]+)\(([^)]+)\)$/);
+    if (!match) {
+      throw new ParseError(
+        `Invalid condition format '${part}'. Expected: name(fill) or name(fill, #color)`,
+        lineNum,
+        1,
+        lineText
+      );
+    }
+    const [, label, innerRaw] = match;
+    const innerParts = innerRaw.split(",").map((s) => s.trim());
+    const fill = innerParts[0];
+    const color = innerParts[1];
+    if (!VALID_FILLS.has(fill)) {
+      throw new ParseError(
+        `Invalid fill pattern '${fill}'. Valid: full, half-left, half-right, half-top, half-bottom, quad-tl, quad-tr, quad-bl, quad-br, quarter, striped, dotted`,
+        lineNum,
+        1,
+        lineText
+      );
+    }
+    const cond = { label, fill };
+    if (color) cond.color = color;
+    conditions.push(cond);
+  }
+  return conditions;
+}
+function mergeIndividual(existing, incoming) {
+  return {
+    ...existing,
+    sex: incoming.sex !== "unknown" ? incoming.sex : existing.sex,
+    status: incoming.status !== "alive" ? incoming.status : existing.status,
+    birthYear: incoming.birthYear ?? existing.birthYear,
+    deathYear: incoming.deathYear ?? existing.deathYear,
+    conditions: incoming.conditions ?? existing.conditions,
+    properties: {
+      ...existing.properties,
+      ...incoming.properties
+    }
+  };
+}
+
+// src/diagrams/genogram/layout.ts
+function layoutGenogram(ast, config) {
+  const graph = buildGraph(ast);
+  assignGenerations(graph);
+  const ordered = orderNodesInGenerations(graph);
+  const positions = assignPositions(ordered, graph, config);
+  const edges = computeEdges(graph, positions, config);
+  const emotionalEdges = computeEmotionalEdges(ast.relationships, positions, config);
+  return packageResult(positions, [...edges, ...emotionalEdges], graph, config);
+}
+function buildGraph(ast) {
+  const individuals = /* @__PURE__ */ new Map();
+  for (const ind of ast.individuals) {
+    individuals.set(ind.id, ind);
+  }
+  const familyUnits = [];
+  const childOf = /* @__PURE__ */ new Map();
+  const coupleRels = ast.relationships.filter(
+    (r) => r.type === "married" || r.type === "divorced" || r.type === "separated" || r.type === "engaged" || r.type === "cohabiting" || r.type === "consanguineous"
+  );
+  for (const rel of coupleRels) {
+    const fuId = `${rel.from}+${rel.to}`;
+    const indA = individuals.get(rel.from);
+    const indB = individuals.get(rel.to);
+    let partners;
+    if (indA && indB) {
+      if (indA.sex === "male" && indB.sex === "female") {
+        partners = [rel.from, rel.to];
+      } else if (indA.sex === "female" && indB.sex === "male") {
+        partners = [rel.to, rel.from];
+      } else {
+        const yearA = indA.birthYear ?? 9999;
+        const yearB = indB.birthYear ?? 9999;
+        partners = yearA <= yearB ? [rel.from, rel.to] : [rel.to, rel.from];
+      }
+    } else {
+      partners = [rel.from, rel.to];
+    }
+    const children = [];
+    for (const r of ast.relationships) {
+      if ((r.type === "parent-child" || r.type === "adopted" || r.type === "foster") && r.from === fuId) {
+        children.push(r.to);
+        childOf.set(r.to, fuId);
+      }
+    }
+    children.sort((a, b) => {
+      const indChildA = individuals.get(a);
+      const indChildB = individuals.get(b);
+      return (indChildA?.birthYear ?? 9999) - (indChildB?.birthYear ?? 9999);
+    });
+    familyUnits.push({
+      id: fuId,
+      partners,
+      relationship: rel.type,
+      label: rel.label,
+      children
+    });
+  }
+  return { individuals, familyUnits, generations: /* @__PURE__ */ new Map(), childOf };
+}
+function assignGenerations(graph) {
+  const { individuals, familyUnits, childOf, generations } = graph;
+  const allIds = Array.from(individuals.keys());
+  const roots = allIds.filter((id) => !childOf.has(id));
+  if (roots.length === 0 && allIds.length > 0) {
+    for (const id of allIds) generations.set(id, 0);
+    return;
+  }
+  for (const root of roots) {
+    if (!generations.has(root)) {
+      generations.set(root, 0);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const fu of familyUnits) {
+      const gen0 = generations.get(fu.partners[0]);
+      const gen1 = generations.get(fu.partners[1]);
+      let partnerGen;
+      if (gen0 !== void 0 && gen1 !== void 0) {
+        partnerGen = Math.max(gen0, gen1);
+        if (gen0 !== partnerGen) {
+          generations.set(fu.partners[0], partnerGen);
+          changed = true;
+        }
+        if (gen1 !== partnerGen) {
+          generations.set(fu.partners[1], partnerGen);
+          changed = true;
+        }
+      } else if (gen0 !== void 0) {
+        partnerGen = gen0;
+        generations.set(fu.partners[1], partnerGen);
+        changed = true;
+      } else if (gen1 !== void 0) {
+        partnerGen = gen1;
+        generations.set(fu.partners[0], partnerGen);
+        changed = true;
+      } else {
+        continue;
+      }
+      for (const childId of fu.children) {
+        const childGen = partnerGen + 1;
+        const existing = generations.get(childId);
+        if (existing === void 0 || existing < childGen) {
+          generations.set(childId, childGen);
+          changed = true;
+        }
+      }
+    }
+  }
+  for (const id of allIds) {
+    if (!generations.has(id)) {
+      generations.set(id, 0);
+    }
+  }
+}
+function orderNodesInGenerations(graph, _config) {
+  const { generations, familyUnits } = graph;
+  const genGroups = /* @__PURE__ */ new Map();
+  for (const [id, gen] of generations) {
+    const group2 = genGroups.get(gen) ?? [];
+    group2.push(id);
+    genGroups.set(gen, group2);
+  }
+  const genIndices = Array.from(genGroups.keys()).sort((a, b) => a - b);
+  const result = [];
+  for (const genIdx of genIndices) {
+    const nodeIds = genGroups.get(genIdx) ?? [];
+    const ordered = orderGeneration(nodeIds, genIdx, graph, familyUnits);
+    result.push({ index: genIdx, nodeIds: ordered });
+  }
+  return result;
+}
+function orderGeneration(nodeIds, _genIdx, graph, familyUnits) {
+  if (nodeIds.length <= 1) return [...nodeIds];
+  const nodeSet = new Set(nodeIds);
+  const placed = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const fuInGen = familyUnits.filter(
+    (fu) => nodeSet.has(fu.partners[0]) || nodeSet.has(fu.partners[1])
+  );
+  const personToFUs = /* @__PURE__ */ new Map();
+  for (const fu of fuInGen) {
+    for (const p of fu.partners) {
+      if (nodeSet.has(p)) {
+        const arr = personToFUs.get(p) ?? [];
+        arr.push(fu);
+        personToFUs.set(p, arr);
+      }
+    }
+  }
+  function placePersonAndExpand(id) {
+    if (placed.has(id)) return;
+    ordered.push(id);
+    placed.add(id);
+    const fus = personToFUs.get(id) ?? [];
+    const sortedFUs = [...fus].sort((a, b) => {
+      const scoreA = a.relationship === "divorced" || a.relationship === "separated" ? 0 : 1;
+      const scoreB = b.relationship === "divorced" || b.relationship === "separated" ? 0 : 1;
+      return scoreA - scoreB;
+    });
+    for (const fu of sortedFUs) {
+      const partner = fu.partners[0] === id ? fu.partners[1] : fu.partners[0];
+      if (!placed.has(partner) && nodeSet.has(partner)) {
+        ordered.push(partner);
+        placed.add(partner);
+        const partnerFUs = personToFUs.get(partner) ?? [];
+        for (const pfu of partnerFUs) {
+          if (pfu.id !== fu.id) {
+            const otherPartner = pfu.partners[0] === partner ? pfu.partners[1] : pfu.partners[0];
+            placePersonAndExpand(otherPartner);
+          }
+        }
+      }
+    }
+  }
+  for (const fu of fuInGen) {
+    if (!placed.has(fu.partners[0]) && nodeSet.has(fu.partners[0])) {
+      placePersonAndExpand(fu.partners[0]);
+    }
+    if (!placed.has(fu.partners[1]) && nodeSet.has(fu.partners[1])) {
+      placePersonAndExpand(fu.partners[1]);
+    }
+  }
+  const remaining = nodeIds.filter((id) => !placed.has(id));
+  remaining.sort((a, b) => {
+    const indA = graph.individuals.get(a);
+    const indB = graph.individuals.get(b);
+    return (indA?.birthYear ?? 9999) - (indB?.birthYear ?? 9999);
+  });
+  for (const id of remaining) {
+    ordered.push(id);
+    placed.add(id);
+  }
+  return ordered;
+}
+var LABEL_HEIGHT = 20;
+var LABEL_GAP = 6;
+function assignPositions(orderedGens, graph, config) {
+  const positions = /* @__PURE__ */ new Map();
+  const { nodeWidth, nodeSpacingX } = config;
+  const half = nodeWidth / 2;
+  const coupleGap = nodeWidth + nodeSpacingX * 0.6;
+  const familyGap = nodeWidth + nodeSpacingX * 1.5;
+  const genStepY = config.nodeHeight + LABEL_HEIGHT + LABEL_GAP + config.nodeSpacingY;
+  for (const gen of orderedGens) {
+    const y = gen.index * genStepY + half;
+    const segments = buildSegments(gen.nodeIds, gen.index, graph);
+    let xCursor = half;
+    for (let s = 0; s < segments.length; s++) {
+      const seg = segments[s];
+      if (s > 0) xCursor += familyGap;
+      if (seg.type === "couple") {
+        positions.set(seg.ids[0], { id: seg.ids[0], x: xCursor, y, generation: gen.index });
+        xCursor += coupleGap;
+        positions.set(seg.ids[1], { id: seg.ids[1], x: xCursor, y, generation: gen.index });
+      } else {
+        positions.set(seg.ids[0], { id: seg.ids[0], x: xCursor, y, generation: gen.index });
+      }
+    }
+  }
+  resolveOverlaps(positions, orderedGens, config);
+  centerChildrenUnderParents(positions, graph, config);
+  resolveOverlaps(positions, orderedGens, config);
+  return positions;
+}
+function buildSegments(nodeIds, _genIdx, graph) {
+  const nodeSet = new Set(nodeIds);
+  const personFUs = /* @__PURE__ */ new Map();
+  for (const fu of graph.familyUnits) {
+    if (nodeSet.has(fu.partners[0]) && nodeSet.has(fu.partners[1])) {
+      for (const p of fu.partners) {
+        const arr = personFUs.get(p) ?? [];
+        arr.push(fu);
+        personFUs.set(p, arr);
+      }
+    }
+  }
+  const multiMarried = /* @__PURE__ */ new Set();
+  for (const [id, fus] of personFUs) {
+    if (fus.length > 1) multiMarried.add(id);
+  }
+  const segments = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const id of nodeIds) {
+    if (placed.has(id)) continue;
+    if (multiMarried.has(id)) {
+      const fus = personFUs.get(id) ?? [];
+      const sorted = [...fus].sort((a, b) => {
+        const sa = a.relationship === "divorced" || a.relationship === "separated" ? 0 : 1;
+        const sb = b.relationship === "divorced" || b.relationship === "separated" ? 0 : 1;
+        return sa - sb;
+      });
+      for (const fu2 of sorted) {
+        const partner = fu2.partners[0] === id ? fu2.partners[1] : fu2.partners[0];
+        if (!placed.has(partner)) {
+          if (!placed.has(id)) {
+            segments.push({ type: "couple", ids: [partner, id], fuId: fu2.id });
+            placed.add(partner);
+            placed.add(id);
+          } else {
+            segments.push({ type: "couple", ids: [id, partner], fuId: fu2.id });
+            placed.add(partner);
+          }
+        }
+      }
+      if (!placed.has(id)) {
+        segments.push({ type: "single", ids: [id] });
+        placed.add(id);
+      }
+      continue;
+    }
+    const fu = graph.familyUnits.find(
+      (f) => (f.partners[0] === id || f.partners[1] === id) && !placed.has(f.partners[0]) && !placed.has(f.partners[1]) && nodeSet.has(f.partners[0]) && nodeSet.has(f.partners[1])
+    );
+    if (fu) {
+      segments.push({
+        type: "couple",
+        ids: [fu.partners[0], fu.partners[1]],
+        fuId: fu.id
+      });
+      placed.add(fu.partners[0]);
+      placed.add(fu.partners[1]);
+    } else {
+      segments.push({ type: "single", ids: [id] });
+      placed.add(id);
+    }
+  }
+  return segments;
+}
+function centerChildrenUnderParents(positions, graph, config) {
+  const coupleGap = config.nodeSpacingX + config.nodeWidth;
+  const personToFUs = /* @__PURE__ */ new Map();
+  for (const fu of graph.familyUnits) {
+    for (const p of fu.partners) {
+      const arr = personToFUs.get(p) ?? [];
+      arr.push(fu);
+      personToFUs.set(p, arr);
+    }
+  }
+  for (let pass = 0; pass < 3; pass++) {
+    for (const fu of graph.familyUnits) {
+      if (fu.children.length === 0) continue;
+      const posA = positions.get(fu.partners[0]);
+      const posB = positions.get(fu.partners[1]);
+      if (!posA || !posB) continue;
+      const parentMidX = (posA.x + posB.x) / 2;
+      const sortedChildren = [...fu.children].sort((a, b) => {
+        const indA = graph.individuals.get(a);
+        const indB = graph.individuals.get(b);
+        return (indA?.birthYear ?? 9999) - (indB?.birthYear ?? 9999);
+      });
+      const childSpacing = config.nodeSpacingX + config.nodeWidth;
+      if (sortedChildren.length > 1) {
+        const gaps = [];
+        for (let gi = 0; gi < sortedChildren.length - 1; gi++) {
+          let gap = childSpacing;
+          const nextChild = sortedChildren[gi + 1];
+          const nextFUs = personToFUs.get(nextChild) ?? [];
+          for (const cfu of nextFUs) {
+            const pid = cfu.partners[0] === nextChild ? cfu.partners[1] : cfu.partners[0];
+            const cInd = graph.individuals.get(nextChild);
+            const pInd = graph.individuals.get(pid);
+            if (!(cInd?.sex === "male" || cInd?.sex !== "female" && pInd?.sex === "female")) {
+              gap += coupleGap;
+            }
+          }
+          const currChild = sortedChildren[gi];
+          const currFUs = personToFUs.get(currChild) ?? [];
+          for (const cfu of currFUs) {
+            const pid = cfu.partners[0] === currChild ? cfu.partners[1] : cfu.partners[0];
+            const cInd = graph.individuals.get(currChild);
+            const pInd = graph.individuals.get(pid);
+            if (cInd?.sex === "male" || cInd?.sex !== "female" && pInd?.sex === "female") {
+              gap += coupleGap;
+            }
+          }
+          gaps.push(gap);
+        }
+        const totalWidth = gaps.reduce((s, g) => s + g, 0);
+        const startX = parentMidX - totalWidth / 2;
+        let cx = startX;
+        for (let i = 0; i < sortedChildren.length; i++) {
+          const pos = positions.get(sortedChildren[i]);
+          if (pos) pos.x = cx;
+          if (i < gaps.length) cx += gaps[i];
+        }
+      } else {
+        const pos = positions.get(sortedChildren[0]);
+        if (pos) pos.x = parentMidX;
+      }
+      for (const childId of fu.children) {
+        const childPos = positions.get(childId);
+        if (!childPos) continue;
+        const childFUs = personToFUs.get(childId) ?? [];
+        for (const childFU of childFUs) {
+          const partnerId = childFU.partners[0] === childId ? childFU.partners[1] : childFU.partners[0];
+          const partnerPos = positions.get(partnerId);
+          if (!partnerPos) continue;
+          const childInd = graph.individuals.get(childId);
+          const partnerInd = graph.individuals.get(partnerId);
+          if (childInd?.sex === "male" || childInd?.sex !== "female" && partnerInd?.sex === "female") {
+            partnerPos.x = childPos.x + coupleGap;
+          } else {
+            partnerPos.x = childPos.x - coupleGap;
+          }
+        }
+      }
+    }
+  }
+}
+function resolveOverlaps(positions, orderedGens, config) {
+  const minGap = config.nodeWidth + config.nodeSpacingX;
+  for (const gen of orderedGens) {
+    const genNodes = gen.nodeIds.map((id) => positions.get(id)).filter((p) => p !== void 0);
+    genNodes.sort((a, b) => a.x - b.x);
+    for (let i = 1; i < genNodes.length; i++) {
+      const gap = genNodes[i].x - genNodes[i - 1].x;
+      if (gap < minGap) {
+        const shift = minGap - gap;
+        for (let j = i; j < genNodes.length; j++) {
+          genNodes[j].x += shift;
+        }
+      }
+    }
+  }
+  let minX = Infinity;
+  for (const pos of positions.values()) {
+    if (pos.x < minX) minX = pos.x;
+  }
+  if (minX < config.nodeWidth / 2) {
+    const shift = config.nodeWidth / 2 - minX;
+    for (const pos of positions.values()) {
+      pos.x += shift;
+    }
+  }
+}
+function computeEdges(graph, positions, config) {
+  const edges = [];
+  const half = config.nodeWidth / 2;
+  const dropY_offset = config.nodeHeight / 2 + LABEL_HEIGHT + LABEL_GAP + config.nodeSpacingY * 0.35;
+  for (const fu of graph.familyUnits) {
+    const posA = positions.get(fu.partners[0]);
+    const posB = positions.get(fu.partners[1]);
+    if (!posA || !posB) continue;
+    const leftPos = posA.x < posB.x ? posA : posB;
+    const rightPos = posA.x < posB.x ? posB : posA;
+    const leftId = posA.x < posB.x ? fu.partners[0] : fu.partners[1];
+    const rightId = posA.x < posB.x ? fu.partners[1] : fu.partners[0];
+    const coupleRel = {
+      type: fu.relationship,
+      from: leftId,
+      to: rightId,
+      label: fu.label
+    };
+    const couplePath = `M ${leftPos.x + half} ${leftPos.y} L ${rightPos.x - half} ${rightPos.y}`;
+    edges.push({
+      from: leftId,
+      to: rightId,
+      relationship: coupleRel,
+      path: couplePath
+    });
+    if (fu.children.length > 0) {
+      const midX = (posA.x + posB.x) / 2;
+      const coupleY = posA.y;
+      const dropY = coupleY + dropY_offset;
+      const childPositions = fu.children.map((cid) => ({
+        id: cid,
+        pos: positions.get(cid)
+      })).filter(
+        (c) => c.pos !== void 0
+      );
+      if (childPositions.length === 0) continue;
+      childPositions.sort((a, b) => a.pos.x - b.pos.x);
+      const leftX = childPositions[0].pos.x;
+      const rightX = childPositions[childPositions.length - 1].pos.x;
+      const dropPath = `M ${midX} ${coupleY} L ${midX} ${dropY}`;
+      edges.push({
+        from: fu.partners[0],
+        to: fu.partners[1],
+        relationship: { type: "parent-child", from: fu.id, to: "_drop" },
+        path: dropPath
+      });
+      if (childPositions.length > 1) {
+        const sibPath = `M ${leftX} ${dropY} L ${rightX} ${dropY}`;
+        edges.push({
+          from: fu.partners[0],
+          to: fu.partners[1],
+          relationship: { type: "parent-child", from: fu.id, to: "_sibship" },
+          path: sibPath
+        });
+      }
+      for (const child of childPositions) {
+        const childTop = child.pos.y - config.nodeHeight / 2;
+        let childPath;
+        if (childPositions.length === 1) {
+          if (Math.abs(child.pos.x - midX) < 1) {
+            childPath = `M ${midX} ${coupleY} L ${midX} ${childTop}`;
+          } else {
+            childPath = `M ${midX} ${dropY} L ${child.pos.x} ${dropY} L ${child.pos.x} ${childTop}`;
+          }
+        } else {
+          childPath = `M ${child.pos.x} ${dropY} L ${child.pos.x} ${childTop}`;
+        }
+        const pcRel = findParentChildRel(graph, fu.id, child.id);
+        edges.push({
+          from: fu.id,
+          to: child.id,
+          relationship: pcRel ?? {
+            type: "parent-child",
+            from: fu.id,
+            to: child.id
+          },
+          path: childPath
+        });
+      }
+    }
+  }
+  return edges;
+}
+function findParentChildRel(graph, _fuId, childId) {
+  const fuId = graph.childOf.get(childId);
+  if (!fuId) return void 0;
+  return {
+    type: "parent-child",
+    from: fuId,
+    to: childId
+  };
+}
+function packageResult(positions, edges, graph, config) {
+  const padding = 40;
+  const nodes = [];
+  for (const [id, pos] of positions) {
+    const ind = graph.individuals.get(id);
+    if (!ind) continue;
+    nodes.push({
+      id,
+      x: pos.x - config.nodeWidth / 2 + padding,
+      y: pos.y - config.nodeHeight / 2 + padding,
+      width: config.nodeWidth,
+      height: config.nodeHeight,
+      generation: pos.generation,
+      individual: ind
+    });
+  }
+  const shiftedEdges = edges.map((e) => ({
+    ...e,
+    path: shiftPath(e.path, padding, padding)
+  }));
+  let maxX = 0;
+  let maxY = 0;
+  let minX = Infinity;
+  for (const node of nodes) {
+    const cx = node.x + node.width / 2;
+    const labelText = estimateLabelText(node.individual);
+    const labelHalfWidth = labelText.length * 3.8;
+    const right = Math.max(node.x + node.width, cx + labelHalfWidth);
+    const left = Math.min(node.x, cx - labelHalfWidth);
+    const bottom = node.y + node.height;
+    if (right > maxX) maxX = right;
+    if (bottom > maxY) maxY = bottom;
+    if (left < minX) minX = left;
+  }
+  if (minX < 0) {
+    const shift = -minX;
+    for (const node of nodes) {
+      node.x += shift;
+    }
+    for (const edge of shiftedEdges) {
+      edge.path = shiftPath(edge.path, shift, 0);
+    }
+    maxX += shift;
+  }
+  return {
+    width: maxX + padding,
+    height: maxY + padding + LABEL_GAP + LABEL_HEIGHT + 10,
+    nodes,
+    edges: shiftedEdges
+  };
+}
+function estimateLabelText(ind) {
+  const name = ind.label || ind.id;
+  if (ind.birthYear && ind.deathYear) return `${name} (${ind.birthYear}\u2013${ind.deathYear})`;
+  if (ind.birthYear) return `${name} (b. ${ind.birthYear})`;
+  return name;
+}
+var EMOTIONAL_REL_TYPES = /* @__PURE__ */ new Set([
+  "harmony",
+  "close",
+  "bestfriends",
+  "love",
+  "inlove",
+  "friendship",
+  "hostile",
+  "conflict",
+  "enmity",
+  "distant-hostile",
+  "cutoff",
+  "close-hostile",
+  "fused",
+  "fused-hostile",
+  "distant",
+  "normal",
+  "nevermet",
+  "abuse",
+  "physical-abuse",
+  "emotional-abuse",
+  "sexual-abuse",
+  "neglect",
+  "manipulative",
+  "controlling",
+  "jealous",
+  "focused",
+  "focused-neg",
+  "distrust",
+  "admirer",
+  "limerence"
+]);
+function computeEmotionalEdges(relationships, positions, config) {
+  const edges = [];
+  const half = config.nodeWidth / 2;
+  const emotionalRels = relationships.filter((r) => EMOTIONAL_REL_TYPES.has(r.type));
+  for (const rel of emotionalRels) {
+    const posA = positions.get(rel.from);
+    const posB = positions.get(rel.to);
+    if (!posA || !posB) continue;
+    const ax = posA.x;
+    const ay = posA.y;
+    const bx = posB.x;
+    const by = posB.y;
+    let pathData;
+    if (posA.generation === posB.generation) {
+      const midX = (ax + bx) / 2;
+      const curveY = ay + half + 30;
+      pathData = `M ${ax} ${ay + half} Q ${midX} ${curveY} ${bx} ${by + half}`;
+    } else {
+      const midY = (ay + by) / 2;
+      const maxX = Math.max(ax, bx);
+      const curveX = maxX + half + 30;
+      pathData = `M ${ax} ${ay} Q ${curveX} ${midY} ${bx} ${by}`;
+    }
+    edges.push({
+      from: rel.from,
+      to: rel.to,
+      relationship: rel,
+      path: pathData
+    });
+  }
+  return edges;
+}
+function shiftPath(pathData, dx, dy) {
+  return pathData.replace(
+    /([\d.-]+)\s+([\d.-]+)/g,
+    (_match, xStr, yStr) => {
+      const x = parseFloat(xStr) + dx;
+      const y = parseFloat(yStr) + dy;
+      return `${x} ${y}`;
+    }
+  );
+}
+
+// src/diagrams/genogram/symbols.ts
+function renderIndividualSymbol(individual, x, y, size) {
+  const half = size / 2;
+  const classes = [
+    "schematex-genogram-node",
+    `schematex-genogram-${individual.sex === "other" ? "unknown" : individual.sex}`
+  ];
+  if (individual.status === "deceased") classes.push("schematex-genogram-deceased");
+  const titleText = formatTitle(individual);
+  const children = [title(titleText)];
+  const isIndex = individual.markers?.includes("index-person");
+  if (isIndex) {
+    children.push(indexBorder(individual.sex, half));
+    classes.push("schematex-genogram-index-person");
+  }
+  children.push(baseShape(individual.sex, half));
+  if (individual.conditions?.length) {
+    for (const cond of individual.conditions) {
+      children.push(conditionFillElement(individual.sex, half, cond));
+    }
+  }
+  if (individual.status === "deceased") {
+    children.push(...deceasedOverlay(individual.sex, half));
+  }
+  const ageToShow = individual.age ?? calcAge(individual);
+  if (ageToShow !== void 0) {
+    children.push(
+      text(
+        {
+          x: 0,
+          y: 5,
+          class: "schematex-genogram-age",
+          "text-anchor": "middle",
+          "font-size": "11"
+        },
+        String(ageToShow)
+      )
+    );
+  }
+  return group(
+    {
+      class: classes.join(" "),
+      "data-individual-id": individual.id,
+      transform: `translate(${x}, ${y})`
+    },
+    children
+  );
+}
+function getRequiredDefs(individuals, includeArrowMarker = false) {
+  const neededFills = /* @__PURE__ */ new Set();
+  for (const ind of individuals) {
+    if (ind.conditions) {
+      for (const cond of ind.conditions) {
+        neededFills.add(cond.fill);
+      }
+    }
+  }
+  const children = [];
+  if (neededFills.has("half-left")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-half-left-rect" }, [
+        rect({ x: "0", y: "0", width: "50%", height: "100%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-half-left-circle" }, [
+        rect({ x: "-50", y: "-50", width: "50", height: "100" })
+      ])
+    );
+  }
+  if (neededFills.has("half-right")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-half-right-rect" }, [
+        rect({ x: "50%", y: "0", width: "50%", height: "100%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-half-right-circle" }, [
+        rect({ x: "0", y: "-50", width: "50", height: "100" })
+      ])
+    );
+  }
+  if (neededFills.has("half-bottom")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-half-bottom-rect" }, [
+        rect({ x: "0", y: "50%", width: "100%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-half-bottom-circle" }, [
+        rect({ x: "-50", y: "0", width: "100", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("quarter")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-quarter-rect" }, [
+        rect({ x: "0", y: "0", width: "50%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-quarter-circle" }, [
+        rect({ x: "-50", y: "-50", width: "50", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("half-top")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-half-top-rect" }, [
+        rect({ x: "0", y: "0", width: "100%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-half-top-circle" }, [
+        rect({ x: "-50", y: "-50", width: "100", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("quad-tl")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-quad-tl-rect" }, [
+        rect({ x: "0", y: "0", width: "50%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-quad-tl-circle" }, [
+        rect({ x: "-50", y: "-50", width: "50", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("quad-tr")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-quad-tr-rect" }, [
+        rect({ x: "50%", y: "0", width: "50%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-quad-tr-circle" }, [
+        rect({ x: "0", y: "-50", width: "50", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("quad-bl")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-quad-bl-rect" }, [
+        rect({ x: "0", y: "50%", width: "50%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-quad-bl-circle" }, [
+        rect({ x: "-50", y: "0", width: "50", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("quad-br")) {
+    children.push(
+      el("clipPath", { id: "schematex-genogram-clip-quad-br-rect" }, [
+        rect({ x: "50%", y: "50%", width: "50%", height: "50%" })
+      ]),
+      el("clipPath", { id: "schematex-genogram-clip-quad-br-circle" }, [
+        rect({ x: "0", y: "0", width: "50", height: "50" })
+      ])
+    );
+  }
+  if (neededFills.has("striped")) {
+    children.push(
+      pattern(
+        {
+          id: "schematex-genogram-pattern-striped",
+          patternUnits: "userSpaceOnUse",
+          width: "4",
+          height: "4"
+        },
+        [
+          path({
+            d: "M-1,1 l2,-2 M0,4 l4,-4 M3,5 l2,-2",
+            stroke: "#333",
+            "stroke-width": "1"
+          })
+        ]
+      )
+    );
+  }
+  if (neededFills.has("dotted")) {
+    children.push(
+      pattern(
+        {
+          id: "schematex-genogram-pattern-dotted",
+          patternUnits: "userSpaceOnUse",
+          width: "6",
+          height: "6"
+        },
+        [
+          circle({ cx: "3", cy: "3", r: "1", fill: "#333" })
+        ]
+      )
+    );
+  }
+  if (includeArrowMarker) {
+    children.push(
+      el("marker", {
+        id: "schematex-genogram-arrow",
+        viewBox: "0 0 10 10",
+        refX: "10",
+        refY: "5",
+        markerWidth: "6",
+        markerHeight: "6",
+        orient: "auto"
+      }, [
+        path({ d: "M 0 0 L 10 5 L 0 10 z", fill: "#333" })
+      ])
+    );
+  }
+  return defs(children);
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function formatTitle(ind) {
+  const name = capitalize(ind.label || ind.id);
+  if (ind.birthYear && ind.deathYear) {
+    return `${name} (${ind.birthYear}-${ind.deathYear})`;
+  }
+  if (ind.birthYear) {
+    return `${name} (${ind.birthYear})`;
+  }
+  return name;
+}
+function calcAge(ind) {
+  if (!ind.birthYear) return void 0;
+  if (ind.deathYear) return ind.deathYear - ind.birthYear;
+  if (ind.status === "deceased") return void 0;
+  return void 0;
+}
+function indexBorder(sex, half) {
+  const outer = half + 4;
+  switch (sex) {
+    case "male":
+      return rect({
+        x: -outer,
+        y: -outer,
+        width: outer * 2,
+        height: outer * 2,
+        class: "schematex-genogram-index-border"
+      });
+    case "female":
+      return circle({
+        cx: 0,
+        cy: 0,
+        r: outer,
+        class: "schematex-genogram-index-border"
+      });
+    case "unknown":
+    case "other":
+    case "nonbinary":
+    case "intersex":
+      return polygon({
+        points: `0,${-outer} ${outer},0 0,${outer} ${-outer},0`,
+        class: "schematex-genogram-index-border"
+      });
+  }
+}
+function baseShape(sex, half) {
+  switch (sex) {
+    case "male":
+      return rect({
+        x: -half,
+        y: -half,
+        width: half * 2,
+        height: half * 2,
+        class: "schematex-genogram-shape"
+      });
+    case "female":
+      return circle({
+        cx: 0,
+        cy: 0,
+        r: half,
+        class: "schematex-genogram-shape"
+      });
+    case "unknown":
+    case "other":
+    case "nonbinary":
+    case "intersex":
+      return polygon({
+        points: `0,${-half} ${half},0 0,${half} ${-half},0`,
+        class: "schematex-genogram-shape"
+      });
+  }
+}
+function deceasedOverlay(sex, half) {
+  const extend = sex === "female" ? half * 0.707 : half;
+  return [
+    line({
+      x1: -extend,
+      y1: -extend,
+      x2: extend,
+      y2: extend,
+      class: "schematex-genogram-deceased-mark",
+      stroke: "#333",
+      "stroke-width": "2"
+    }),
+    line({
+      x1: extend,
+      y1: -extend,
+      x2: -extend,
+      y2: extend,
+      class: "schematex-genogram-deceased-mark",
+      stroke: "#333",
+      "stroke-width": "2"
+    })
+  ];
+}
+function conditionFillElement(sex, half, cond) {
+  const fillColor = cond.color ?? "#333";
+  const attrs = {};
+  if (cond.fill === "full") {
+    attrs.fill = fillColor;
+  } else if (cond.fill === "striped") {
+    attrs.fill = "url(#schematex-genogram-pattern-striped)";
+  } else if (cond.fill === "dotted") {
+    attrs.fill = "url(#schematex-genogram-pattern-dotted)";
+  } else {
+    const clipSuffix = sex === "female" ? "circle" : "rect";
+    attrs["clip-path"] = `url(#schematex-genogram-clip-${cond.fill}-${clipSuffix})`;
+    attrs.fill = fillColor;
+  }
+  attrs.class = `schematex-genogram-condition-fill schematex-genogram-condition-${cond.label}`;
+  switch (sex) {
+    case "male":
+      return rect({ x: -half, y: -half, width: half * 2, height: half * 2, ...attrs });
+    case "female":
+      return circle({ cx: 0, cy: 0, r: half, ...attrs });
+    case "unknown":
+    case "other":
+    case "nonbinary":
+    case "intersex":
+    default:
+      return polygon({
+        points: `0,${-half} ${half},0 0,${half} ${-half},0`,
+        ...attrs
+      });
+  }
+}
+
+// src/diagrams/genogram/renderer.ts
+function renderGenogram(layout, config, ast) {
+  const hasDirectional = layout.edges.some((e) => e.relationship.directional);
+  const defsStr = getRequiredDefs(layout.nodes.map((n) => n.individual), hasDirectional);
+  const styleStr = buildStyles(config);
+  const genGroups = groupByGeneration(layout.nodes);
+  const structuralEdges = layout.edges.filter((e) => !EMOTIONAL_REL_TYPES2.has(e.relationship.type));
+  const emotionalEdges = layout.edges.filter((e) => EMOTIONAL_REL_TYPES2.has(e.relationship.type));
+  const edgeLayers = renderEdges(structuralEdges);
+  const emotionalLayer = renderEmotionalEdges(emotionalEdges);
+  const nodeLayers = renderNodes(genGroups);
+  const labelLayer = renderLabels(layout.nodes, config);
+  const edgeLabelLayer = renderEdgeLabels(structuralEdges, config);
+  const nodeCount = layout.nodes.length;
+  const genCount = genGroups.size;
+  const chartTitle = ast?.metadata?.title;
+  const titleHeight = chartTitle ? 40 : 0;
+  const totalHeight = layout.height + titleHeight;
+  const layers = [
+    title(chartTitle ? `Genogram: ${chartTitle}` : "Genogram"),
+    desc(
+      `Genogram diagram with ${nodeCount} individuals across ${genCount} generations`
+    ),
+    defsStr,
+    styleStr
+  ];
+  if (chartTitle) {
+    layers.push(
+      text(
+        {
+          x: layout.width / 2,
+          y: 28,
+          class: "schematex-genogram-title",
+          "text-anchor": "middle",
+          "font-size": "20",
+          "font-weight": "bold",
+          "font-family": config.fontFamily
+        },
+        chartTitle
+      )
+    );
+  }
+  const contentGroup = group(
+    { transform: titleHeight > 0 ? `translate(0, ${titleHeight})` : void 0 },
+    [edgeLayers, emotionalLayer, ...nodeLayers, labelLayer, edgeLabelLayer]
+  );
+  layers.push(contentGroup);
+  return svgRoot(
+    {
+      viewBox: `0 0 ${layout.width} ${totalHeight}`,
+      class: "schematex-diagram schematex-genogram",
+      width: layout.width,
+      height: totalHeight
+    },
+    layers
+  );
+}
+function buildStyles(config) {
+  const t = resolveGenogramTheme(config.theme);
+  const css = `
+.schematex-genogram {${cssCustomProperties(t)}
+  background: ${t.bg};
+}
+.schematex-genogram-shape { fill: ${t.fill}; stroke: ${t.stroke}; stroke-width: ${STROKE_WIDTH.normal}; stroke-linejoin: round; }
+.schematex-genogram-male .schematex-genogram-shape { fill: ${t.maleFill}; }
+.schematex-genogram-female .schematex-genogram-shape { fill: ${t.femaleFill}; }
+.schematex-genogram-unknown .schematex-genogram-shape { fill: ${t.unknownFill}; }
+.schematex-genogram-label { font-family: ${config.fontFamily}; font-size: ${config.fontSize}px; text-anchor: middle; fill: ${t.text}; }
+.schematex-genogram-edge { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; fill: none; stroke-linecap: round; stroke-linejoin: round; }
+.schematex-genogram-edge-cohabiting path { stroke-dasharray: 6,4; }
+.schematex-genogram-edge-divorced .schematex-genogram-divorce-mark { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; }
+.schematex-genogram-edge-separated .schematex-genogram-separation-mark { stroke: ${t.neutral}; stroke-width: ${STROKE_WIDTH.normal}; }
+.schematex-genogram-deceased-mark { stroke: ${t.deceasedMark}; stroke-width: ${STROKE_WIDTH.normal}; stroke-linecap: round; }
+.schematex-genogram-condition-fill { fill: ${t.conditionFill}; }
+.schematex-genogram-age { font-family: ${config.fontFamily}; fill: ${t.text}; pointer-events: none; }
+.schematex-genogram-title { fill: ${t.text}; }
+.schematex-genogram-edge-label { font-family: ${config.fontFamily}; fill: ${t.text}; }
+.schematex-genogram-index-border { stroke: ${t.warn}; stroke-width: ${STROKE_WIDTH.thick}; fill: none; }
+`;
+  return el("style", {}, css);
+}
+var EMOTIONAL_REL_TYPES2 = /* @__PURE__ */ new Set([
+  "harmony",
+  "close",
+  "bestfriends",
+  "love",
+  "inlove",
+  "friendship",
+  "hostile",
+  "conflict",
+  "enmity",
+  "distant-hostile",
+  "cutoff",
+  "close-hostile",
+  "fused",
+  "fused-hostile",
+  "distant",
+  "normal",
+  "nevermet",
+  "abuse",
+  "physical-abuse",
+  "emotional-abuse",
+  "sexual-abuse",
+  "neglect",
+  "manipulative",
+  "controlling",
+  "jealous",
+  "focused",
+  "focused-neg",
+  "distrust",
+  "admirer",
+  "limerence"
+]);
+function getEmotionalColor(type) {
+  if (["harmony", "close", "bestfriends", "love", "inlove", "friendship"].includes(type)) return "#4caf50";
+  if (["hostile", "conflict", "enmity", "distant-hostile", "cutoff"].includes(type)) return "#e53935";
+  if (["close-hostile", "fused", "fused-hostile"].includes(type)) return "#9c27b0";
+  if (["distant", "normal", "nevermet"].includes(type)) return "#9e9e9e";
+  if (["abuse", "physical-abuse", "emotional-abuse", "sexual-abuse", "neglect"].includes(type)) return "#b71c1c";
+  if (["manipulative", "controlling", "jealous"].includes(type)) return "#e65100";
+  return "#1565c0";
+}
+function getEmotionalLineStyle(type) {
+  if (["hostile", "conflict", "enmity", "distant-hostile", "close-hostile", "fused-hostile"].includes(type)) {
+    return "stroke-dasharray: 8,3,2,3;";
+  }
+  if (["distant", "distant-hostile", "nevermet"].includes(type)) {
+    return "stroke-dasharray: 6,4;";
+  }
+  if (type === "cutoff") {
+    return "stroke-dasharray: 2,8;";
+  }
+  return "";
+}
+function getEmotionalStrokeWidth(type) {
+  if (["fused", "fused-hostile", "bestfriends"].includes(type)) return 4;
+  if (["close", "close-hostile", "love", "inlove"].includes(type)) return 3;
+  return 2;
+}
+function renderEmotionalEdges(edges) {
+  if (edges.length === 0) return group({ class: "schematex-genogram-emotional-edges" }, []);
+  const children = [];
+  for (const edge of edges) {
+    const type = edge.relationship.type;
+    const color = getEmotionalColor(type);
+    const lineStyle = getEmotionalLineStyle(type);
+    const strokeWidth = getEmotionalStrokeWidth(type);
+    const directional = edge.relationship.directional;
+    const elements = [
+      el("path", {
+        d: edge.path,
+        fill: "none",
+        stroke: color,
+        "stroke-width": strokeWidth,
+        style: lineStyle || void 0,
+        "marker-end": directional ? "url(#schematex-genogram-arrow)" : void 0
+      })
+    ];
+    if (edge.relationship.label) {
+      const mid = pathMidpoint(edge.path);
+      if (mid) {
+        elements.push(
+          text(
+            {
+              x: mid.x,
+              y: mid.y - 6,
+              class: "schematex-genogram-edge-label",
+              "text-anchor": "middle",
+              "font-size": "10",
+              fill: color
+            },
+            edge.relationship.label
+          )
+        );
+      }
+    }
+    children.push(
+      group(
+        {
+          class: `schematex-genogram-emotional schematex-genogram-emotional-${type}`,
+          "data-from": edge.from,
+          "data-to": edge.to,
+          "data-relationship-type": type
+        },
+        elements
+      )
+    );
+  }
+  return group({ class: "schematex-genogram-emotional-edges" }, children);
+}
+function renderEdgeLabels(edges, config) {
+  const labels = [];
+  for (const edge of edges) {
+    if (!edge.relationship.label) continue;
+    const mid = pathMidpoint(edge.path);
+    if (!mid) continue;
+    labels.push(
+      text(
+        {
+          x: mid.x,
+          y: mid.y - 6,
+          class: "schematex-genogram-edge-label",
+          "text-anchor": "middle",
+          "font-size": "10",
+          "font-family": config.fontFamily
+        },
+        edge.relationship.label
+      )
+    );
+  }
+  return group({ class: "schematex-genogram-edge-labels" }, labels);
+}
+function renderEdges(edges) {
+  const children = [];
+  for (const edge of edges) {
+    const relType = edge.relationship.type;
+    const cssClass = `schematex-genogram-edge schematex-genogram-edge-${relType}`;
+    const elements = [
+      el("path", { d: edge.path, class: "schematex-genogram-edge-path" })
+    ];
+    if (relType === "divorced") {
+      const mid = pathMidpoint(edge.path);
+      if (mid) {
+        elements.push(
+          el("line", {
+            x1: mid.x - 4,
+            y1: mid.y - 6,
+            x2: mid.x + 4,
+            y2: mid.y + 6,
+            class: "schematex-genogram-divorce-mark",
+            stroke: "#333",
+            "stroke-width": "2"
+          }),
+          el("line", {
+            x1: mid.x - 4 + 6,
+            y1: mid.y - 6,
+            x2: mid.x + 4 + 6,
+            y2: mid.y + 6,
+            class: "schematex-genogram-divorce-mark",
+            stroke: "#333",
+            "stroke-width": "2"
+          })
+        );
+      }
+    }
+    if (relType === "separated") {
+      const mid = pathMidpoint(edge.path);
+      if (mid) {
+        elements.push(
+          el("line", {
+            x1: mid.x - 4,
+            y1: mid.y - 6,
+            x2: mid.x + 4,
+            y2: mid.y + 6,
+            class: "schematex-genogram-separation-mark",
+            stroke: "#333",
+            "stroke-width": "2"
+          })
+        );
+      }
+    }
+    children.push(
+      group(
+        {
+          class: cssClass,
+          "data-from": edge.from,
+          "data-to": edge.to
+        },
+        elements
+      )
+    );
+  }
+  return group({ class: "schematex-genogram-edges" }, children);
+}
+function pathMidpoint(pathData) {
+  const coords = pathData.match(/[\d.-]+/g);
+  if (!coords || coords.length < 4) return null;
+  const x1 = parseFloat(coords[0]);
+  const y1 = parseFloat(coords[1]);
+  const x2 = parseFloat(coords[2]);
+  const y2 = parseFloat(coords[3]);
+  return { x: (x1 + x2) / 2, y: (y1 + y2) / 2 };
+}
+function groupByGeneration(nodes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const gen = node.generation;
+    const group2 = groups.get(gen) ?? [];
+    group2.push(node);
+    groups.set(gen, group2);
+  }
+  return groups;
+}
+function renderNodes(genGroups) {
+  const layers = [];
+  const sortedGens = Array.from(genGroups.keys()).sort((a, b) => a - b);
+  for (const genIdx of sortedGens) {
+    const nodes = genGroups.get(genIdx) ?? [];
+    const nodeElements = [];
+    for (const node of nodes) {
+      const cx = node.x + node.width / 2;
+      const cy = node.y + node.height / 2;
+      nodeElements.push(
+        renderIndividualSymbol(node.individual, cx, cy, node.width)
+      );
+    }
+    layers.push(
+      group(
+        {
+          class: `schematex-genogram-generation schematex-genogram-generation-${genIdx}`,
+          "data-generation": genIdx
+        },
+        nodeElements
+      )
+    );
+  }
+  return layers;
+}
+function renderLabels(nodes, config) {
+  const labels = [];
+  for (const node of nodes) {
+    const ind = node.individual;
+    const label = ind.label || ind.id;
+    const cx = node.x + node.width / 2;
+    const labelY = node.y + node.height + 6 + config.fontSize;
+    let labelText = label.charAt(0).toUpperCase() + label.slice(1);
+    if (ind.birthYear && ind.deathYear) {
+      labelText += ` (${ind.birthYear}\u2013${ind.deathYear})`;
+    } else if (ind.birthYear) {
+      labelText += ` (b. ${ind.birthYear})`;
+    }
+    labels.push(
+      text(
+        {
+          x: cx,
+          y: labelY,
+          class: "schematex-genogram-label",
+          "data-individual-id": ind.id
+        },
+        labelText
+      )
+    );
+  }
+  return group({ class: "schematex-genogram-labels" }, labels);
+}
+
+// src/diagrams/genogram/index.ts
+var genogram = {
+  type: "genogram",
+  detect(text2) {
+    const firstLine = text2.trim().split("\n")[0]?.trim().toLowerCase() ?? "";
+    return firstLine === "genogram" || firstLine.startsWith("genogram ");
+  },
+  render(text2, config) {
+    const ast = parseGenogram(text2);
+    const layoutConfig = {
+      nodeSpacingX: 80,
+      nodeSpacingY: 100,
+      nodeWidth: 40,
+      nodeHeight: 40
+    };
+    const layout = layoutGenogram(ast, layoutConfig);
+    const renderConfig = {
+      fontFamily: config?.fontFamily ?? "system-ui, -apple-system, sans-serif",
+      fontSize: config?.fontSize ?? 12,
+      theme: config?.theme ?? "default",
+      padding: config?.padding ?? 20
+    };
+    return renderGenogram(layout, renderConfig, ast);
+  }
+};
+
+export { ParseError, genogram, getRequiredDefs, layoutGenogram, parseGenogram, renderGenogram, renderIndividualSymbol };
+//# sourceMappingURL=chunk-D4JTSPOL.js.map
+//# sourceMappingURL=chunk-D4JTSPOL.js.map