@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-BUVJFRPY.js

@@ -0,0 +1,887 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  injectDefaultTagMetadata,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  tryCollectNote
+} from "./chunk-5MLYVTYM.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  BOXES_AND_LINES_REGISTRY,
+  OPTION_NOCOLON_RE,
+  extractColor,
+  parseFirstLine,
+  peelRampColors,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/boxes-and-lines/parser.ts
+var MAX_GROUP_DEPTH = 2;
+function looksLikeBoxesAndLines(_content) {
+  return false;
+}
+function measureIndent(line) {
+  let count = 0;
+  for (const ch of line) {
+    if (ch === " ") count++;
+    else if (ch === "	") count += 4;
+    else break;
+  }
+  return count;
+}
+function parseTailMeta(rawTail, metaAliasMap) {
+  const segment = rawTail.trim();
+  if (!segment) return { metadata: {} };
+  const metadata = {};
+  let description;
+  for (const item of segment.split(",")) {
+    const trimmed = item.trim();
+    if (!trimmed) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx >= 0) {
+      const rawKey = trimmed.slice(0, colonIdx).trim().toLowerCase();
+      const value = trimmed.slice(colonIdx + 1).trim();
+      if (rawKey === "description") {
+        description = [value];
+      } else {
+        const resolvedKey = metaAliasMap.get(rawKey) ?? rawKey;
+        metadata[resolvedKey] = value;
+      }
+    }
+  }
+  return { metadata, ...description !== void 0 && { description } };
+}
+function groupId(label) {
+  return `__group_${label}`;
+}
+function parseBoxesAndLines(content, palette) {
+  const options = {};
+  const notes = [];
+  const initialHiddenTagValues = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const edges = [];
+  const groups = [];
+  const nodePositions = /* @__PURE__ */ new Map();
+  const result = {
+    type: "boxes-and-lines",
+    title: null,
+    titleLineNumber: null,
+    nodes,
+    edges,
+    groups,
+    tagGroups: [],
+    options,
+    initialHiddenTagValues,
+    direction: "LR",
+    diagnostics: [],
+    error: null
+  };
+  const lines = content.split("\n");
+  const nodeLabels = /* @__PURE__ */ new Set();
+  const groupLabels = /* @__PURE__ */ new Set();
+  let lastNodeLabel = null;
+  let lastSourceIsGroup = false;
+  let lastNodeIndent = 0;
+  let descState = null;
+  function flushDescription() {
+    if (descState && descState.lines.length > 0) {
+      const node = nodes.find((n) => n.label === descState.nodeLabel);
+      if (node) {
+        const existing = node.description ?? [];
+        node.description = [...existing, ...descState.lines];
+      }
+    }
+    descState = null;
+  }
+  const groupStack = [];
+  let contentStarted = false;
+  let inLayoutBlock = false;
+  const LAYOUT_ENTRY_RE = /^(.+?):\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/;
+  let currentTagGroup = null;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function peelAlias(label) {
+    const trimmed = label.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (!m) return { label: trimmed };
+    return { label: m[1].trim(), alias: m[2] };
+  }
+  const pushWarning = (lineNumber, message) => {
+    result.diagnostics.push(makeDgmoError(lineNumber, message, "warning"));
+  };
+  function currentGroupState() {
+    return groupStack.length > 0 ? groupStack[groupStack.length - 1] : null;
+  }
+  function closeGroupsToIndent(indent) {
+    while (groupStack.length > 0 && // In-bounds by length guard.
+    groupStack[groupStack.length - 1].indent >= indent) {
+      const gs = groupStack.pop();
+      result.groups.push(gs.group);
+    }
+  }
+  function ensureNode(label, lineNum) {
+    const key = normalizeName(label);
+    if (!nodeLabels.has(key)) {
+      result.nodes.push({
+        label,
+        lineNumber: lineNum,
+        metadata: {}
+      });
+      nodeLabels.add(key);
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    const indent = measureIndent(raw);
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const firstLineResult = parseFirstLine(trimmed);
+    if (firstLineResult && !contentStarted && i < 5) {
+      if (firstLineResult.chartType !== "boxes-and-lines") {
+        const diag = makeDgmoError(
+          lineNum,
+          `Expected chart type "boxes-and-lines", got "${firstLineResult.chartType}"`
+        );
+        result.diagnostics.push(diag);
+        result.error = diag.message;
+        return result;
+      }
+      if (firstLineResult.title) {
+        result.title = firstLineResult.title;
+        result.titleLineNumber = lineNum;
+      }
+      continue;
+    }
+    if (indent === 0) {
+      const dirMatch = trimmed.match(/^direction\s+(TB|LR)$/i);
+      if (dirMatch) {
+        result.direction = dirMatch[1].toUpperCase();
+        continue;
+      }
+      const hideMatch = trimmed.match(/^hide\s+(.+)/i);
+      if (hideMatch && !trimmed.match(/^hide\s*\|/)) {
+        const pairs = hideMatch[1].split(",");
+        for (const pair of pairs) {
+          const colonIdx = pair.indexOf(":");
+          if (colonIdx > 0) {
+            const groupKey = pair.substring(0, colonIdx).trim().toLowerCase();
+            const value = pair.substring(colonIdx + 1).trim().toLowerCase();
+            if (groupKey && value) {
+              if (!initialHiddenTagValues.has(groupKey)) {
+                initialHiddenTagValues.set(groupKey, /* @__PURE__ */ new Set());
+              }
+              initialHiddenTagValues.get(groupKey).add(value);
+            }
+          }
+        }
+        continue;
+      }
+      if (!contentStarted) {
+        const metricMatch = trimmed.match(/^heat\s+(.+)$/i);
+        if (metricMatch) {
+          const { label, low, high } = peelRampColors(metricMatch[1].trim());
+          result.boxMetric = label;
+          if (high !== void 0) result.boxMetricColor = high;
+          if (low !== void 0) result.boxMetricLowColor = low;
+          continue;
+        }
+        if (/^show-values$/i.test(trimmed)) {
+          result.showValues = true;
+          continue;
+        }
+      }
+      if (!contentStarted) {
+        const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+        if (optMatch) {
+          const key2 = optMatch[1].toLowerCase();
+          const value = optMatch[2].trim();
+          if (key2 === "active-tag") {
+            options[key2] = value;
+            continue;
+          }
+        }
+        if (tryParseSharedOption(trimmed, options)) {
+          continue;
+        }
+      }
+    }
+    if (indent === 0) {
+      const noteResult = tryCollectNote(
+        lines,
+        i,
+        indent,
+        palette,
+        result.diagnostics
+      );
+      if (noteResult) {
+        if (noteResult.note) notes.push(noteResult.note);
+        i = noteResult.lastIndex;
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch && indent === 0) {
+      if (contentStarted) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNum,
+            "Tag groups must appear before diagram content",
+            "error"
+          )
+        );
+        continue;
+      }
+      const newTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber: lineNum
+      };
+      currentTagGroup = newTagGroup;
+      if (tagBlockMatch.alias) {
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.alias),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      metaAliasMap.set(
+        normalizeName(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      if (tagBlockMatch.inlineValues) {
+        for (const rawVal of tagBlockMatch.inlineValues) {
+          const { text: cleanVal, isDefault } = stripDefaultModifier(rawVal);
+          const { label, color } = extractColor(
+            cleanVal,
+            palette,
+            result.diagnostics,
+            lineNum
+          );
+          newTagGroup.entries.push({
+            value: label,
+            color: color ?? AUTO_TAG_COLOR_SENTINEL,
+            lineNumber: lineNum
+          });
+          if (isDefault) newTagGroup.defaultValue = label;
+        }
+        if (!newTagGroup.defaultValue && newTagGroup.entries.length > 0) {
+          newTagGroup.defaultValue = newTagGroup.entries[0].value;
+        }
+      }
+      result.tagGroups.push(newTagGroup);
+      continue;
+    }
+    if (currentTagGroup && !contentStarted && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNum
+      );
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber: lineNum
+      });
+      if (isDefault) {
+        currentTagGroup.defaultValue = label;
+      } else if (currentTagGroup.entries.length === 1) {
+        currentTagGroup.defaultValue = label;
+      }
+      continue;
+    }
+    if (currentTagGroup && indent === 0) {
+      currentTagGroup = null;
+    }
+    if (!inLayoutBlock && indent === 0 && trimmed === "layout") {
+      let isBlock = false;
+      for (let j = i + 1; j < lines.length; j++) {
+        const peek = lines[j];
+        if (!peek.trim()) continue;
+        isBlock = measureIndent(peek) > 0 && LAYOUT_ENTRY_RE.test(peek.trim());
+        break;
+      }
+      if (isBlock) {
+        flushDescription();
+        closeGroupsToIndent(0);
+        inLayoutBlock = true;
+        continue;
+      }
+    }
+    if (inLayoutBlock) {
+      if (indent > 0) {
+        const lm = trimmed.match(LAYOUT_ENTRY_RE);
+        if (lm) {
+          nodePositions.set(lm[1].trim(), {
+            x: Number(lm[2]),
+            y: Number(lm[3])
+          });
+        } else {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNum,
+              `Invalid layout entry "${trimmed}" \u2014 expected "<node-id>: <x>, <y>"`,
+              "warning"
+            )
+          );
+        }
+        continue;
+      }
+      inLayoutBlock = false;
+    }
+    if (descState !== null) {
+      if (indent > descState.indent) {
+        if (trimmed.includes("->") || trimmed.includes("<->")) {
+          descState.edgeSeen = true;
+        } else if (descState.edgeSeen) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNum,
+              `Move description lines above edges for '${descState.nodeLabel}' \u2014 descriptions must come before -> lines`,
+              "warning"
+            )
+          );
+          continue;
+        } else if (/^-\s*\w/.test(trimmed) && !trimmed.startsWith("- ") && !trimmed.includes("->") && !trimmed.includes("<->")) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNum,
+              `Looks like an incomplete edge \u2014 did you mean "-> ${trimmed.slice(1).trim()}"?`,
+              "warning"
+            )
+          );
+          descState.lines.push(trimmed);
+          continue;
+        } else {
+          descState.lines.push(trimmed);
+          continue;
+        }
+      } else {
+        flushDescription();
+      }
+    }
+    if (indent === 0) {
+      closeGroupsToIndent(0);
+    } else if (groupStack.length > 0) {
+      closeGroupsToIndent(indent);
+    }
+    const groupEdgeMatch = trimmed.match(
+      /^\[(.+?)\]\s*(<->|->)\s*\[(.+?)\](.*)$/
+    );
+    if (groupEdgeMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      const sourceLabel = groupEdgeMatch[1];
+      const arrow = groupEdgeMatch[2];
+      const targetLabel = groupEdgeMatch[3];
+      const rawTail = groupEdgeMatch[4] ?? "";
+      const edgeMeta = parseTailMeta(rawTail, metaAliasMap).metadata;
+      result.edges.push({
+        // Regex capture groups present after successful match.
+        source: groupId(sourceLabel),
+        target: groupId(targetLabel),
+        bidirectional: arrow === "<->",
+        lineNumber: lineNum,
+        metadata: edgeMeta
+      });
+      continue;
+    }
+    const labeledGroupEdgeMatch = trimmed.match(
+      /^\[(.+?)\]\s*(?:<-(.+)->|-(.+)->)\s*\[(.+?)\](.*)$/
+    );
+    if (labeledGroupEdgeMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      const sourceLabel = labeledGroupEdgeMatch[1];
+      const biLabel = labeledGroupEdgeMatch[2];
+      const uniLabel = labeledGroupEdgeMatch[3];
+      const targetLabel = labeledGroupEdgeMatch[4];
+      const rawTail = labeledGroupEdgeMatch[5] ?? "";
+      const edgeMeta = parseTailMeta(rawTail, metaAliasMap).metadata;
+      const labeledEdgeLabel = (biLabel ?? uniLabel)?.trim();
+      result.edges.push({
+        // Regex capture groups present after successful match.
+        source: groupId(sourceLabel),
+        target: groupId(targetLabel),
+        ...labeledEdgeLabel !== void 0 && { label: labeledEdgeLabel },
+        bidirectional: !!biLabel,
+        lineNumber: lineNum,
+        metadata: edgeMeta
+      });
+      continue;
+    }
+    const groupMatch = trimmed.match(/^\[(.+?)\](.*)$/);
+    if (groupMatch && !trimmed.includes("->") && !trimmed.includes("<->")) {
+      contentStarted = true;
+      currentTagGroup = null;
+      flushDescription();
+      const groupPeeled = peelAlias(groupMatch[1]);
+      const label = groupPeeled.label;
+      if (groupPeeled.alias)
+        nameAliasMap.set(groupPeeled.alias, groupId(label));
+      const currentDepth = groupStack.length + 1;
+      if (currentDepth > MAX_GROUP_DEPTH) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNum,
+            `Group nesting exceeds maximum depth of ${MAX_GROUP_DEPTH}`,
+            "warning"
+          )
+        );
+        continue;
+      }
+      const groupMeta = parseTailMeta(
+        groupMatch[2] ?? "",
+        metaAliasMap
+      ).metadata;
+      const parentGs = currentGroupState();
+      const group = {
+        label,
+        children: [],
+        lineNumber: lineNum,
+        metadata: groupMeta,
+        ...parentGs ? { parentGroup: parentGs.group.label } : {}
+      };
+      if (parentGs && indent > parentGs.indent) {
+        parentGs.group.children.push(label);
+      }
+      groupLabels.add(normalizeName(label));
+      groupStack.push({ group, indent, depth: currentDepth });
+      lastNodeLabel = label;
+      lastSourceIsGroup = true;
+      continue;
+    }
+    if (trimmed.includes("->") || trimmed.includes("<->")) {
+      contentStarted = true;
+      currentTagGroup = null;
+      let edgeText = trimmed;
+      if (trimmed.startsWith("->") || /^-[^>].*->/.test(trimmed)) {
+        const gs2 = currentGroupState();
+        const inGroup = gs2 && indent > gs2.indent;
+        const indentedUnderNode = lastNodeLabel && !lastSourceIsGroup && indent > lastNodeIndent;
+        if (inGroup && !indentedUnderNode) {
+          const sourcePrefix = `[${gs2.group.label}]`;
+          edgeText = `${sourcePrefix} ${trimmed}`;
+        } else if (lastNodeLabel) {
+          const sourcePrefix = lastSourceIsGroup ? `[${lastNodeLabel}]` : lastNodeLabel;
+          edgeText = `${sourcePrefix} ${trimmed}`;
+        } else {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNum,
+              "Indented edge has no preceding node to use as source",
+              "warning"
+            )
+          );
+          continue;
+        }
+      }
+      const edge = parseEdgeLine(
+        edgeText,
+        lineNum,
+        metaAliasMap,
+        result.diagnostics,
+        nameAliasMap
+      );
+      if (edge) {
+        result.edges.push(edge);
+      }
+      continue;
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    flushDescription();
+    const node = parseNodeLine(
+      trimmed,
+      lineNum,
+      metaAliasMap,
+      result.diagnostics,
+      nameAliasMap
+    );
+    if (!node) {
+      result.diagnostics.push(
+        makeDgmoError(lineNum, `Unexpected line: '${trimmed}'.`, "warning")
+      );
+      continue;
+    }
+    lastNodeLabel = node.label;
+    lastSourceIsGroup = false;
+    lastNodeIndent = indent;
+    const gs = currentGroupState();
+    const isGroupChild = gs && indent > gs.indent;
+    const key = normalizeName(node.label);
+    if (nodeLabels.has(key)) {
+      if (isGroupChild) {
+        gs.group.children.push(node.label);
+        continue;
+      }
+      result.diagnostics.push(
+        makeDgmoError(lineNum, `Duplicate node "${node.label}"`, "warning")
+      );
+    } else {
+      nodeLabels.add(key);
+    }
+    if (isGroupChild) {
+      for (const [key2, val] of Object.entries(gs.group.metadata)) {
+        if (!(key2 in node.metadata)) {
+          node.metadata[key2] = val;
+        }
+      }
+      gs.group.children.push(node.label);
+    }
+    result.nodes.push(node);
+    descState = { nodeLabel: node.label, indent, lines: [], edgeSeen: false };
+  }
+  flushDescription();
+  while (groupStack.length > 0) {
+    const gs = groupStack.pop();
+    result.groups.push(gs.group);
+  }
+  const validEdges = [];
+  for (const edge of result.edges) {
+    let valid = true;
+    const allGroups = Array.from(groupLabels);
+    if (edge.source.startsWith("__group_")) {
+      const label = edge.source.slice("__group_".length);
+      const found = groupLabels.has(normalizeName(label));
+      if (!found) {
+        let msg = `Group '[${label}]' not found`;
+        const hint = suggest(normalizeName(label), allGroups);
+        if (hint) msg += `. ${hint}`;
+        result.diagnostics.push(makeDgmoError(edge.lineNumber, msg));
+        valid = false;
+      }
+    } else {
+      ensureNode(edge.source, edge.lineNumber);
+    }
+    if (edge.target.startsWith("__group_")) {
+      const label = edge.target.slice("__group_".length);
+      const found = groupLabels.has(normalizeName(label));
+      if (!found) {
+        let msg = `Group '[${label}]' not found`;
+        const hint = suggest(normalizeName(label), allGroups);
+        if (hint) msg += `. ${hint}`;
+        result.diagnostics.push(makeDgmoError(edge.lineNumber, msg));
+        valid = false;
+      }
+    } else {
+      ensureNode(edge.target, edge.lineNumber);
+    }
+    if (valid) {
+      validEdges.push(edge);
+    }
+  }
+  result.edges = validEdges;
+  if (notes.length > 0) {
+    result.notes = notes;
+    resolveNotes(
+      notes,
+      result.nodes.map((n) => ({ id: n.label, label: n.label })),
+      result.diagnostics
+    );
+  }
+  finalizeAutoTagColors(result.tagGroups);
+  if (nodePositions.size > 0) {
+    const nodeLabelSet = new Set(result.nodes.map((n) => n.label));
+    for (const id of nodePositions.keys()) {
+      if (!nodeLabelSet.has(id)) {
+        pushWarning(0, `layout entry for unknown node "${id}" (ignored)`);
+      }
+    }
+    const unpositioned = result.nodes.filter((n) => !nodePositions.has(n.label)).map((n) => n.label);
+    if (unpositioned.length > 0) {
+      pushWarning(
+        0,
+        `layout block is partial \u2014 ${unpositioned.length} node(s) without coordinates (${unpositioned.slice(0, 5).join(", ")}${unpositioned.length > 5 ? "\u2026" : ""}); ignoring the block and auto-laying-out`
+      );
+    }
+    result.nodePositions = nodePositions;
+  }
+  if (result.tagGroups.length > 0) {
+    injectDefaultTagMetadata(result.nodes, result.tagGroups);
+    validateTagValues(result.nodes, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning, (line, msg) => {
+      const diag = makeDgmoError(line, msg);
+      result.diagnostics.push(diag);
+      if (!result.error) result.error = diag.message;
+    });
+  }
+  return result;
+}
+function parseNodeLine(trimmed, lineNum, metaAliasMap, diagnostics, nameAliasMap) {
+  const registry = withTagAliases(
+    BOXES_AND_LINES_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    metaAliasMap,
+    void 0,
+    diagnostics,
+    lineNum
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => diagnostics.push(makeDgmoError(lineNum, msg, "warning")),
+    split.name
+  );
+  let label = split.name;
+  const metadata = { ...split.meta };
+  let description;
+  if (split.color !== void 0) {
+    label = `${label} ${split.color}`;
+  }
+  if (metadata["description"] !== void 0) {
+    description = [metadata["description"]];
+    delete metadata["description"];
+  }
+  let value;
+  if (metadata["heat"] !== void 0) {
+    const raw = metadata["heat"];
+    const num = Number(raw);
+    if (Number.isFinite(num)) {
+      value = num;
+    } else {
+      diagnostics.push(
+        makeDgmoError(lineNum, `heat must be a number (got "${raw}")`, "error")
+      );
+    }
+    delete metadata["heat"];
+  }
+  if (split.alias) {
+    nameAliasMap?.set(normalizeName(split.alias), label);
+  }
+  if (!label) return null;
+  return {
+    label,
+    lineNumber: lineNum,
+    metadata,
+    ...description !== void 0 && { description },
+    ...value !== void 0 && { value }
+  };
+}
+function splitTargetAndMeta(rest, metaAliasMap) {
+  const registry = withTagAliases(
+    BOXES_AND_LINES_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const split = splitNameAndMeta(rest, registry, metaAliasMap);
+  let target = split.name;
+  if (split.color !== void 0) {
+    target = `${target} ${split.color}`;
+  }
+  return { target, metadata: split.meta };
+}
+function resolveEndpoint(name, nameAliasMap) {
+  const m = name.match(/^\[(.+)\]$/);
+  if (m) return groupId(m[1].trim());
+  if (nameAliasMap) {
+    const aliased = nameAliasMap.get(name.trim());
+    if (aliased !== void 0) return aliased;
+  }
+  return name;
+}
+function parseEdgeLine(trimmed, lineNum, metaAliasMap, diagnostics, nameAliasMap) {
+  const edgeRegistry = withTagAliases(
+    BOXES_AND_LINES_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const biLabeledMatch = trimmed.match(/^(.+?)\s*<-(.+)->\s*(.+)$/);
+  if (biLabeledMatch) {
+    const rawSource2 = biLabeledMatch[1].trim();
+    const source2 = resolveEndpoint(rawSource2, nameAliasMap);
+    const labelResult = parseInArrowLabel(biLabeledMatch[2], lineNum);
+    diagnostics.push(...labelResult.diagnostics);
+    const label = labelResult.label;
+    let rest2 = biLabeledMatch[3].trim();
+    const { target: biTarget, metadata: metadata2 } = splitTargetAndMeta(
+      rest2,
+      metaAliasMap
+    );
+    warnUnknownMetaKeys(
+      metadata2,
+      edgeRegistry,
+      (msg) => diagnostics.push(makeDgmoError(lineNum, msg, "warning"))
+    );
+    rest2 = biTarget;
+    if (!source2 || !rest2) {
+      diagnostics.push(
+        makeDgmoError(lineNum, "Edge is missing source or target")
+      );
+      return null;
+    }
+    if (rawSource2.endsWith(":") || rest2.endsWith(":")) {
+      diagnostics.push(
+        makeDgmoError(
+          lineNum,
+          `Trailing colon is not valid \u2014 write '${rawSource2.replace(/:$/, "")} <-> ${rest2.replace(/:$/, "")}' instead`
+        )
+      );
+      return null;
+    }
+    return {
+      source: source2,
+      target: resolveEndpoint(rest2, nameAliasMap),
+      ...label !== void 0 && { label },
+      bidirectional: true,
+      lineNumber: lineNum,
+      metadata: metadata2
+    };
+  }
+  const biIdx = trimmed.indexOf("<->");
+  if (biIdx >= 0) {
+    const rawSource2 = trimmed.slice(0, biIdx).trim();
+    const source2 = resolveEndpoint(rawSource2, nameAliasMap);
+    let rest2 = trimmed.slice(biIdx + 3).trim();
+    const { target: plainTarget2, metadata: metadata2 } = splitTargetAndMeta(
+      rest2,
+      metaAliasMap
+    );
+    warnUnknownMetaKeys(
+      metadata2,
+      edgeRegistry,
+      (msg) => diagnostics.push(makeDgmoError(lineNum, msg, "warning"))
+    );
+    rest2 = plainTarget2;
+    if (!source2 || !rest2) {
+      diagnostics.push(
+        makeDgmoError(lineNum, "Edge is missing source or target")
+      );
+      return null;
+    }
+    if (rawSource2.endsWith(":") || rest2.endsWith(":")) {
+      diagnostics.push(
+        makeDgmoError(
+          lineNum,
+          `Trailing colon is not valid \u2014 write '${rawSource2.replace(/:$/, "")} <-> ${rest2.replace(/:$/, "")}' instead`
+        )
+      );
+      return null;
+    }
+    return {
+      source: source2,
+      target: resolveEndpoint(rest2, nameAliasMap),
+      bidirectional: true,
+      lineNumber: lineNum,
+      metadata: metadata2
+    };
+  }
+  const labeledMatch = trimmed.match(/^(.+?)\s+-(.+?)->\s*(.+)$/);
+  if (labeledMatch) {
+    const rawSource2 = labeledMatch[1].trim();
+    const source2 = resolveEndpoint(rawSource2, nameAliasMap);
+    const labelResult = parseInArrowLabel(labeledMatch[2], lineNum);
+    diagnostics.push(...labelResult.diagnostics);
+    const label = labelResult.label;
+    let rest2 = labeledMatch[3].trim();
+    if (label) {
+      const { target: labeledTarget, metadata: metadata2 } = splitTargetAndMeta(
+        rest2,
+        metaAliasMap
+      );
+      warnUnknownMetaKeys(
+        metadata2,
+        edgeRegistry,
+        (msg) => diagnostics.push(makeDgmoError(lineNum, msg, "warning"))
+      );
+      rest2 = labeledTarget;
+      if (!source2 || !rest2) {
+        diagnostics.push(
+          makeDgmoError(lineNum, "Edge is missing source or target")
+        );
+        return null;
+      }
+      if (rawSource2.endsWith(":") || rest2.endsWith(":")) {
+        diagnostics.push(
+          makeDgmoError(
+            lineNum,
+            `Trailing colon is not valid \u2014 write '${rawSource2.replace(/:$/, "")} -> ${rest2.replace(/:$/, "")}' instead`
+          )
+        );
+        return null;
+      }
+      return {
+        source: source2,
+        target: resolveEndpoint(rest2, nameAliasMap),
+        label,
+        bidirectional: false,
+        lineNumber: lineNum,
+        metadata: metadata2
+      };
+    }
+  }
+  const arrowIdx = trimmed.indexOf("->");
+  if (arrowIdx < 0) return null;
+  const rawSource = trimmed.slice(0, arrowIdx).trim();
+  const source = resolveEndpoint(rawSource, nameAliasMap);
+  let rest = trimmed.slice(arrowIdx + 2).trim();
+  if (!source || !rest) {
+    diagnostics.push(
+      makeDgmoError(lineNum, "Edge is missing source or target")
+    );
+    return null;
+  }
+  const { target: plainTarget, metadata } = splitTargetAndMeta(
+    rest,
+    metaAliasMap
+  );
+  warnUnknownMetaKeys(
+    metadata,
+    edgeRegistry,
+    (msg) => diagnostics.push(makeDgmoError(lineNum, msg, "warning"))
+  );
+  rest = plainTarget;
+  if (!rest) {
+    diagnostics.push(makeDgmoError(lineNum, "Edge is missing target"));
+    return null;
+  }
+  if (rawSource.endsWith(":") || rest.endsWith(":")) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNum,
+        `Trailing colon is not valid \u2014 write '${rawSource.replace(/:$/, "")} -> ${rest.replace(/:$/, "")}' instead`
+      )
+    );
+    return null;
+  }
+  return {
+    source,
+    target: resolveEndpoint(rest, nameAliasMap),
+    bidirectional: false,
+    lineNumber: lineNum,
+    metadata
+  };
+}
+
+export {
+  looksLikeBoxesAndLines,
+  parseBoxesAndLines
+};
+//# sourceMappingURL=chunk-BUVJFRPY.js.map