@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/chunk-O4VUFXIH.js

@@ -0,0 +1,574 @@
+import {
+  buildCoupleQuotient
+} from "./chunk-QQJUTGQH.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey
+} from "./chunk-WCUHAQKB.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  FAMILY_PERSON_REGISTRY,
+  FAMILY_UNION_REGISTRY,
+  cutUnionMetadata,
+  extractColor,
+  isReservedKey,
+  measureIndent,
+  parseFirstLine,
+  peelTrailingColorName,
+  splitNameAndMeta,
+  stripQuotes,
+  tokenizeQuoteAware,
+  tryParseSharedOption,
+  withTagAliases
+} from "./chunk-OTAL43EH.js";
+import {
+  nord,
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+import {
+  emit
+} from "./chunk-CXK4DZH3.js";
+
+// src/family/diagnostics.ts
+var FAMILY_DX = {
+  SELF_UNION: {
+    code: "E_FAMILY_SELF_UNION",
+    severity: "error",
+    chartType: "family",
+    title: "Self union",
+    message: (p) => `A person cannot marry themselves ('${p.name ?? "Anne"}')`,
+    hint: "A union line joins two DIFFERENT people \u2014 check the names on each side of `+`.",
+    example: `family
+Anne + Anne`
+  },
+  TOO_MANY_PARENTS: {
+    code: "E_FAMILY_TOO_MANY_PARENTS",
+    severity: "error",
+    chartType: "family",
+    title: "Too many parents in a union",
+    message: (p) => `A union joins at most two people, found ${p.count ?? 3} ('${p.line ?? "Anne + Bob + Carol"}')`,
+    hint: "Split into separate union lines \u2014 one couple per line. A trio like `A + B + C` is not a union.",
+    example: `family
+Anne + Bob + Carol`
+  },
+  MISSING_OPERAND: {
+    code: "E_FAMILY_MISSING_OPERAND",
+    severity: "error",
+    chartType: "family",
+    title: "Union missing an operand",
+    message: "A union line needs a name on both sides of `+`",
+    hint: "Write `NameA + NameB`. A trailing/leading/doubled `+` with a blank side is not a valid union.",
+    example: `family
+Anne +`
+  },
+  ANCESTRY_CYCLE: {
+    code: "E_FAMILY_ANCESTRY_CYCLE",
+    severity: "error",
+    chartType: "family",
+    title: "Ancestry cycle",
+    message: "union creates an ancestry cycle \u2014 a person and their own ancestor cannot share a marriage row",
+    hint: "Someone is listed as their own ancestor, married to a direct ancestor, or a parent-child pair forms a union. Remove the cycle.",
+    example: `family
+Anne + Bob
+  Carol
+Carol + Anne`
+  },
+  CHILD_OUTSIDE_UNION: {
+    code: "E_FAMILY_CHILD_OUTSIDE_UNION",
+    severity: "error",
+    chartType: "family",
+    title: "Child outside a union",
+    message: "indented child line has no union or person line above it to attach to",
+    hint: "A child must be indented under a union line (`A + B`) or a single parent line.",
+    example: `family
+  Carol`
+  },
+  UNKNOWN_KEY: {
+    code: "W_FAMILY_UNKNOWN_KEY",
+    severity: "warning",
+    chartType: "family",
+    title: "Unknown metadata key",
+    message: (p) => `Unknown metadata key "${p.key ?? "favouritecolor"}".`,
+    hint: "Recognized person keys: sex, b, d, bp, dp, occupation, military, education, religion, burial. Union key: m.",
+    example: `family
+Anne favouritecolor: red`
+  },
+  DUPLICATE_METADATA: {
+    code: "W_FAMILY_DUPLICATE_METADATA",
+    severity: "warning",
+    chartType: "family",
+    title: "Conflicting metadata re-declaration",
+    message: (p) => `Metadata key '${p.key ?? "b"}' re-declared with a different value ('${p.old ?? "1665"}' \u2192 '${p.new ?? "1666"}') \u2014 keeping the first.`,
+    hint: "A person was declared more than once with conflicting values for the same key. Consolidate the declarations.",
+    example: `family
+Anne b: 1665
+Anne b: 1666`
+  },
+  HIGHLIGHT_UNKNOWN: {
+    code: "W_FAMILY_HIGHLIGHT_UNKNOWN",
+    severity: "warning",
+    chartType: "family",
+    title: "Highlight target not found",
+    message: (p) => `\`highlight\` names an unknown person "${p.name ?? "Ghost"}" \u2014 nothing was dimmed.`,
+    hint: "The `highlight` directive must name a person that appears in the tree.",
+    example: `family
+highlight Ghost
+
+Anne + Bob`
+  }
+};
+var FAMILY_DIAGNOSTICS = Object.values(FAMILY_DX);
+
+// src/family/parser.ts
+function normKey(label) {
+  return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function splitUnionSides(nameRegion) {
+  const tokens = tokenizeQuoteAware(nameRegion);
+  const sides = [];
+  let cur = [];
+  for (const tok of tokens) {
+    if (tok === "+") {
+      sides.push(cur.join(" "));
+      cur = [];
+    } else {
+      cur.push(tok);
+    }
+  }
+  sides.push(cur.join(" "));
+  return sides;
+}
+function matchFamilyOption(line) {
+  const h = line.match(/^highlight\s+(.+)$/i);
+  if (h) return { key: "highlight", value: h[1].trim() };
+  if (/^generations$/i.test(line)) return { key: "generations", value: "true" };
+  if (/^no-daggers$/i.test(line)) return { key: "no-daggers", value: "true" };
+  return null;
+}
+function parseFamily(content, palette) {
+  const diagnostics = [];
+  const persons = /* @__PURE__ */ new Map();
+  const unions = [];
+  const tagGroups = [];
+  const options = {};
+  const rawLines = content.split("\n");
+  let title;
+  let titleLineNumber;
+  let startIdx = 0;
+  for (let i = 0; i < rawLines.length; i++) {
+    const t = rawLines[i].trim();
+    if (!t || t.startsWith("//")) continue;
+    const fl = parseFirstLine(rawLines[i]);
+    if (fl?.chartType === "family") {
+      title = fl.title;
+      titleLineNumber = i + 1;
+    }
+    startIdx = i + 1;
+    break;
+  }
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const aliasKeys = /* @__PURE__ */ new Set();
+  let currentTagGroup = null;
+  let sawContent = false;
+  for (let i = startIdx; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const lineNum = i + 1;
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(raw);
+    const tagMatch = matchTagBlockHeading(trimmed);
+    if (tagMatch && indent === 0 && !sawContent) {
+      const newGroup = {
+        name: tagMatch.name,
+        ...tagMatch.alias !== void 0 && { alias: tagMatch.alias },
+        entries: [],
+        lineNumber: lineNum
+      };
+      currentTagGroup = newGroup;
+      const attr = tagAttrKey(tagMatch.name);
+      metaAliasMap.set(normKey(tagMatch.name), attr);
+      aliasKeys.add(normKey(tagMatch.name));
+      if (tagMatch.alias) {
+        metaAliasMap.set(normKey(tagMatch.alias), attr);
+        aliasKeys.add(normKey(tagMatch.alias));
+      }
+      if (tagMatch.inlineValues) {
+        for (const rawVal of tagMatch.inlineValues) {
+          const { text, isDefault } = stripDefaultModifier(rawVal);
+          const { label, color } = extractColor(
+            text,
+            palette,
+            diagnostics,
+            lineNum
+          );
+          newGroup.entries.push({
+            value: label,
+            color: color ?? AUTO_TAG_COLOR_SENTINEL,
+            lineNumber: lineNum
+          });
+          if (isDefault) newGroup.defaultValue = label;
+        }
+        if (!newGroup.defaultValue && newGroup.entries.length > 0) {
+          newGroup.defaultValue = newGroup.entries[0].value;
+        }
+      }
+      tagGroups.push(newGroup);
+      continue;
+    }
+    if (currentTagGroup && indent > 0 && !sawContent) {
+      const { text, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        text,
+        palette,
+        diagnostics,
+        lineNum
+      );
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber: lineNum
+      });
+      if (isDefault || currentTagGroup.entries.length === 1) {
+        currentTagGroup.defaultValue = label;
+      }
+      continue;
+    }
+    if (indent === 0) currentTagGroup = null;
+    if (indent === 0) {
+      const fam = matchFamilyOption(trimmed);
+      if (fam) {
+        options[fam.key] = fam.value;
+        continue;
+      }
+    }
+    if (indent === 0 && tryParseSharedOption(trimmed, options)) continue;
+    if (indent === 0 && !tagMatch) sawContent = true;
+  }
+  const personRegistry = withTagAliases(FAMILY_PERSON_REGISTRY, aliasKeys);
+  const tagAttrKeys = new Set(tagGroups.map((g) => tagAttrKey(g.name)));
+  const aliasMap = /* @__PURE__ */ new Map();
+  const getPerson = (rawName, lineNum) => {
+    const aliasHit = aliasMap.get(normalizeName(rawName));
+    const id = aliasHit ?? normalizeName(rawName);
+    let p = persons.get(id);
+    if (!p) {
+      p = {
+        id,
+        label: displayName(rawName),
+        sex: "unknown",
+        metadata: {},
+        tagMetadata: {},
+        lineNumber: lineNum
+      };
+      persons.set(id, p);
+    }
+    return p;
+  };
+  const applyMeta = (p, meta, color, lineNum) => {
+    if (color !== void 0 && p.color === void 0) p.color = color;
+    for (const [k, v] of Object.entries(meta)) {
+      if (k === "sex") {
+        const s = v.trim().toLowerCase();
+        const sex = s === "m" ? "m" : s === "f" ? "f" : "unknown";
+        if (sex !== "unknown" && p.sex === "unknown") p.sex = sex;
+        continue;
+      }
+      if (tagAttrKeys.has(k)) {
+        p.tagMetadata[k] = v;
+        continue;
+      }
+      if (isReservedKey(FAMILY_PERSON_REGISTRY, k)) {
+        const prev = p.metadata[k];
+        if (prev !== void 0 && prev !== v) {
+          diagnostics.push(
+            emit(FAMILY_DX.DUPLICATE_METADATA, lineNum, {
+              key: k,
+              old: prev,
+              new: v
+            })
+          );
+          continue;
+        }
+        p.metadata[k] = v;
+        continue;
+      }
+      diagnostics.push(emit(FAMILY_DX.UNKNOWN_KEY, lineNum, { key: k }));
+    }
+  };
+  const parsePersonRef = (segment, lineNum, allowAdopted) => {
+    let adopted = false;
+    let seg = segment;
+    if (allowAdopted) {
+      const toks = tokenizeQuoteAware(seg);
+      if (toks.length >= 2 && toks[toks.length - 1] === "adopted") {
+        adopted = true;
+        seg = toks.slice(0, -1).join(" ");
+      }
+    }
+    const {
+      name,
+      meta,
+      color: rawColor,
+      alias
+    } = splitNameAndMeta(
+      seg,
+      personRegistry,
+      metaAliasMap,
+      palette,
+      diagnostics,
+      lineNum
+    );
+    let cleanName = name.replace(/,\s*$/, "").trim();
+    let color = rawColor;
+    if (allowAdopted) {
+      const toks = tokenizeQuoteAware(cleanName);
+      if (toks.length >= 2 && toks[toks.length - 1] === "adopted") {
+        adopted = true;
+        cleanName = toks.slice(0, -1).join(" ");
+        const re = peelTrailingColorName(cleanName);
+        if (re.colorName !== void 0) {
+          cleanName = re.label;
+          if (color === void 0) color = re.colorName;
+        }
+      }
+    }
+    if (!/^["']/.test(cleanName)) {
+      const um = cleanName.match(/\b([A-Za-z][\w-]*)\s*:/);
+      if (um?.index !== void 0 && um.index > 0 && !isReservedKey(personRegistry, um[1].toLowerCase())) {
+        diagnostics.push(
+          emit(FAMILY_DX.UNKNOWN_KEY, lineNum, { key: um[1].toLowerCase() })
+        );
+        cleanName = cleanName.slice(0, um.index).trim();
+      }
+    }
+    cleanName = stripQuotes(cleanName.trim());
+    if (cleanName === "?") {
+      const ph = {
+        id: `?#${++placeholderSeq}`,
+        label: "?",
+        sex: "unknown",
+        metadata: {},
+        tagMetadata: {},
+        placeholder: true,
+        lineNumber: lineNum
+      };
+      persons.set(ph.id, ph);
+      return { person: ph, adopted };
+    }
+    const person = getPerson(cleanName, lineNum);
+    if (alias !== void 0) aliasMap.set(normalizeName(alias), person.id);
+    applyMeta(person, meta, color, lineNum);
+    return { person, adopted };
+  };
+  const stack = [];
+  let unionSeq = 0;
+  let placeholderSeq = 0;
+  const unionById = /* @__PURE__ */ new Map();
+  const makeUnion = (parents, metadata, lineNum, divorced = false) => {
+    const u = {
+      id: `u${unionSeq++}`,
+      parents,
+      metadata,
+      children: [],
+      ...divorced && { divorced: true },
+      lineNumber: lineNum
+    };
+    unions.push(u);
+    unionById.set(u.id, u);
+    return u;
+  };
+  const attachChild = (parentScope, childId, adopted, lineNum) => {
+    let unionId = parentScope.unionId;
+    if (!unionId) {
+      if (!parentScope.singleParentUnionId) {
+        const u2 = makeUnion([parentScope.personId], {}, lineNum);
+        parentScope.singleParentUnionId = u2.id;
+      }
+      unionId = parentScope.singleParentUnionId;
+    }
+    const u = unionById.get(unionId);
+    u.children.push({ personId: childId, adopted });
+  };
+  let inTagBlock = false;
+  for (let i = startIdx; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const lineNum = i + 1;
+    let trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const cIdx = trimmed.indexOf(" //");
+    if (cIdx > 0) trimmed = trimmed.slice(0, cIdx).trim();
+    if (!trimmed) continue;
+    const indent = measureIndent(raw);
+    if (indent === 0 && matchTagBlockHeading(trimmed)) {
+      inTagBlock = true;
+      continue;
+    }
+    if (indent === 0) inTagBlock = false;
+    if (inTagBlock && indent > 0) continue;
+    if (indent === 0 && matchFamilyOption(trimmed)) continue;
+    if (indent === 0 && tryParseSharedOption(trimmed, {})) continue;
+    while (stack.length && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parentScope = stack.length ? stack[stack.length - 1] : null;
+    let divorced = false;
+    if (/\s\+\s/.test(trimmed) && /\s+divorced$/i.test(trimmed)) {
+      divorced = true;
+      trimmed = trimmed.replace(/\s+divorced$/i, "").trimEnd();
+    }
+    const cut = cutUnionMetadata(trimmed, FAMILY_UNION_REGISTRY);
+    const nameRegion = cut < 0 ? trimmed : trimmed.slice(0, cut).trimEnd();
+    const metaRegion = cut < 0 ? "" : trimmed.slice(cut);
+    const rawSides = splitUnionSides(nameRegion);
+    const hadPlus = rawSides.length >= 2;
+    const sides = rawSides.map((s) => s.trim()).filter((s) => s !== "");
+    if (hadPlus && sides.length >= 2) {
+      let parentSides = sides;
+      if (sides.length > 2) {
+        diagnostics.push(
+          emit(FAMILY_DX.TOO_MANY_PARENTS, lineNum, {
+            count: sides.length,
+            line: nameRegion
+          })
+        );
+        parentSides = sides.slice(0, 2);
+      }
+      const unionMeta = {};
+      if (metaRegion) {
+        const { meta } = splitNameAndMeta(
+          metaRegion,
+          withTagAliases(FAMILY_UNION_REGISTRY, /* @__PURE__ */ new Set()),
+          /* @__PURE__ */ new Map(),
+          palette,
+          diagnostics,
+          lineNum
+        );
+        for (const [k, v] of Object.entries(meta)) {
+          if (k === "m") unionMeta["m"] = v;
+          else
+            diagnostics.push(emit(FAMILY_DX.UNKNOWN_KEY, lineNum, { key: k }));
+        }
+      }
+      const parentPersons = parentSides.map(
+        (s) => parsePersonRef(s, lineNum, false).person
+      );
+      if (parentPersons.length === 2 && parentPersons[0].id === parentPersons[1].id) {
+        diagnostics.push(
+          emit(FAMILY_DX.SELF_UNION, lineNum, {
+            name: parentPersons[0].label
+          })
+        );
+      }
+      if (parentScope) {
+        attachChild(parentScope, parentPersons[0].id, false, lineNum);
+      }
+      const u = makeUnion(
+        parentPersons.map((p) => p.id),
+        unionMeta,
+        lineNum,
+        divorced
+      );
+      stack.push({ indent, unionId: u.id });
+    } else if (hadPlus) {
+      diagnostics.push(
+        emit(FAMILY_DX.MISSING_OPERAND, lineNum, { line: nameRegion })
+      );
+      if (sides.length === 1) {
+        const isChild = parentScope !== null;
+        const { person, adopted } = parsePersonRef(sides[0], lineNum, isChild);
+        if (parentScope) attachChild(parentScope, person.id, adopted, lineNum);
+        stack.push({ indent, personId: person.id });
+      }
+    } else {
+      const isChild = parentScope !== null;
+      const { person, adopted } = parsePersonRef(trimmed, lineNum, isChild);
+      if (parentScope) {
+        attachChild(parentScope, person.id, adopted, lineNum);
+      } else if (indent > 0) {
+        diagnostics.push(emit(FAMILY_DX.CHILD_OUTSIDE_UNION, lineNum, {}));
+      }
+      stack.push({ indent, personId: person.id });
+    }
+  }
+  finalizeAutoTagColors(tagGroups, palette);
+  const SEX_META = {
+    m: ["Male", "blue", nord.nord10],
+    f: ["Female", "purple", nord.nord15],
+    unknown: ["Unknown", "gray", nord.nord3]
+  };
+  const anySex = [...persons.values()].some((p) => p.sex !== "unknown");
+  if (anySex) {
+    const present = new Set([...persons.values()].map((p) => p.sex));
+    const order = ["m", "f", "unknown"];
+    const entries = order.filter((s) => present.has(s)).map((s) => {
+      const [label, colorName, fallback] = SEX_META[s];
+      return {
+        value: label,
+        color: resolveColor(colorName, palette) ?? fallback,
+        lineNumber: 0
+      };
+    });
+    for (const p of persons.values()) p.tagMetadata["sex"] = SEX_META[p.sex][0];
+    const sexGroup = {
+      name: "Sex",
+      entries,
+      defaultValue: entries[0].value,
+      lineNumber: 0
+    };
+    tagGroups.unshift(sexGroup);
+  }
+  const frozenPersons = /* @__PURE__ */ new Map();
+  for (const [id, p] of persons) {
+    frozenPersons.set(id, {
+      id: p.id,
+      label: p.label,
+      sex: p.sex,
+      metadata: p.metadata,
+      ...p.color !== void 0 && { color: p.color },
+      tagMetadata: p.tagMetadata,
+      ...p.placeholder && { placeholder: true },
+      lineNumber: p.lineNumber
+    });
+  }
+  if (options["highlight"]) {
+    const norm = normalizeName(options["highlight"]);
+    const hit = aliasMap.get(norm) ?? (frozenPersons.has(norm) ? norm : void 0);
+    if (hit) {
+      options["highlight"] = hit;
+    } else {
+      diagnostics.push(
+        emit(FAMILY_DX.HIGHLIGHT_UNKNOWN, 0, { name: options["highlight"] })
+      );
+      delete options["highlight"];
+    }
+  }
+  let error = null;
+  const quotient = buildCoupleQuotient(frozenPersons, unions);
+  if (quotient.cycle) {
+    const diag = emit(FAMILY_DX.ANCESTRY_CYCLE, 0, {});
+    diagnostics.push(diag);
+    error = diag.message;
+  }
+  return {
+    ...title !== void 0 && { title },
+    ...titleLineNumber !== void 0 && { titleLineNumber },
+    persons: frozenPersons,
+    unions,
+    tagGroups,
+    options,
+    diagnostics,
+    error
+  };
+}
+
+export {
+  FAMILY_DIAGNOSTICS,
+  parseFamily
+};
+//# sourceMappingURL=chunk-O4VUFXIH.js.map

package/dist/{chunk-RVMRZAPB.js → chunk-O76UD6VJ.js}

@@ -7,7 +7,7 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   normalizeName
 } from "./chunk-NOTA6TEI.js";
@@ -20,7 +20,7 @@ import {
   splitNameAndMeta,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   formatDgmoError,
   makeDgmoError,
@@ -351,4 +351,4 @@ export {
   looksLikeOrg,
   parseOrg
 };
-//# sourceMappingURL=chunk-RVMRZAPB.js.map
+//# sourceMappingURL=chunk-O76UD6VJ.js.map

package/dist/{chunk-JM4LEPY3.js → chunk-O7NUCTFU.js}

@@ -18,7 +18,7 @@ import {
 import {
   CHAR_WIDTH_RATIO,
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   contrastText,
   getSeriesColors,
@@ -433,4 +433,4 @@ export {
   renderPyramid,
   renderPyramidForExport
 };
-//# sourceMappingURL=chunk-JM4LEPY3.js.map
+//# sourceMappingURL=chunk-O7NUCTFU.js.map

package/dist/{chunk-JED6ZDEE.js → chunk-O7WP4ZD4.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6EK55ART.js";
 import {
   noteBoxSize
-} from "./chunk-TYS6CSS5.js";
+} from "./chunk-BCYVE3N5.js";
 
 // src/utils/notes/build.ts
 function buildPlacedNotes(anchors, noteByNode, direction, collapsedNotes) {
@@ -70,4 +70,4 @@ function buildPlacedNotes(anchors, noteByNode, direction, collapsedNotes) {
 export {
   buildPlacedNotes
 };
-//# sourceMappingURL=chunk-JED6ZDEE.js.map
+//# sourceMappingURL=chunk-O7WP4ZD4.js.map

package/dist/{chunk-EVCVDTXE.js → chunk-OHQEMBLI.js}

@@ -5,14 +5,14 @@ import {
   matchTagBlockHeading,
   stripDefaultModifier,
   validateTagGroupNames
-} from "./chunk-QLCCJEJI.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   OPTION_NOCOLON_RE,
   extractColor,
   measureIndent,
   parseFirstLine,
   tryParseSharedOption
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   formatDgmoError,
   makeDgmoError
@@ -729,4 +729,4 @@ export {
   resetWireframeIds,
   parseWireframe
 };
-//# sourceMappingURL=chunk-EVCVDTXE.js.map
+//# sourceMappingURL=chunk-OHQEMBLI.js.map

package/dist/{chunk-ZBWMSD5N.js → chunk-ONA5KPV3.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-PDKUANDZ.js";
 import {
   layoutGraph
-} from "./chunk-T3UBLACL.js";
+} from "./chunk-SCQ5VPUF.js";
 import {
   appendArrowheadMarkers
 } from "./chunk-LP7EC4MI.js";
@@ -32,7 +32,7 @@ import {
 } from "./chunk-6KFWC4CO.js";
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   contrastText,
   mix,
@@ -41,7 +41,7 @@ import {
 } from "./chunk-P6T66CCZ.js";
 import {
   parseState
-} from "./chunk-3MQQNXPD.js";
+} from "./chunk-2C56LEML.js";
 
 // src/graph/state-renderer.ts
 import * as d3Selection from "d3-selection";
@@ -375,4 +375,4 @@ export {
   renderState,
   renderStateForExport
 };
-//# sourceMappingURL=chunk-ZBWMSD5N.js.map
+//# sourceMappingURL=chunk-ONA5KPV3.js.map