@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-2DXMZRWJ.js

@@ -0,0 +1,800 @@
+import {
+  tryStripDescriptionKeyword
+} from "./chunk-IYULMRBE.js";
+import {
+  inferParticipantType
+} from "./chunk-C3Z4DX3V.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  C4_REGISTRY,
+  OPTION_NOCOLON_RE,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/c4/parser.ts
+var CONTAINER_RE = /^\[([^\]]+)\]$/;
+var ELEMENT_RE = /^(person|system|container|component)\s+(.+)$/i;
+var IS_A_RE = /\s+is\s+a(?:n)?\s+(\w+)\s*$/i;
+var C4_IS_A_RE = /^([^:]+?)\s+is\s+an?\s+(person|system|container|component|external|database)\b(.*)$/i;
+var RELATIONSHIP_RE = /^(<?-?>|<?~?>)\s*(.+)$/;
+var C4_LABELED_SYNC_RE = /^-(.+?)->\s*(.+)$/;
+var C4_LABELED_ASYNC_RE = /^~(.+?)~>\s*(.+)$/;
+var C4_LABELED_BIDI_SYNC_RE = /^<-(.+?)->\s*(.+)$/;
+var C4_LABELED_BIDI_ASYNC_RE = /^<~(.+?)~>\s*(.+)$/;
+var SECTION_HEADER_RE = /^(containers|components|deployment)\s*$/i;
+var CONTAINER_REF_RE = /^container\s+(.+)$/i;
+var METADATA_RE = /^([a-z][a-z0-9-]*):\s+(.+)$/i;
+var VALID_ELEMENT_TYPES = /* @__PURE__ */ new Set([
+  "person",
+  "system",
+  "container",
+  "component"
+]);
+var VALID_SHAPES = /* @__PURE__ */ new Set([
+  "default",
+  "database",
+  "cache",
+  "queue",
+  "cloud",
+  "external"
+]);
+var KNOWN_C4_OPTIONS = /* @__PURE__ */ new Set(["layout", "active-tag"]);
+var KNOWN_C4_BOOLEANS = /* @__PURE__ */ new Set([
+  "direction-tb",
+  "solid-fill",
+  "no-title"
+]);
+var ALL_CHART_TYPES = [
+  "c4",
+  "org",
+  "class",
+  "flowchart",
+  "sequence",
+  "er",
+  "bar",
+  "line",
+  "pie",
+  "scatter",
+  "sankey",
+  "venn",
+  "timeline",
+  "arc",
+  "slope",
+  "kanban"
+];
+function participantTypeToC4Shape(pType) {
+  switch (pType) {
+    case "database":
+      return "database";
+    case "cache":
+      return "cache";
+    case "queue":
+      return "queue";
+    case "external":
+      return "external";
+    case "networking":
+      return "cloud";
+    default:
+      return "default";
+  }
+}
+function inferC4Shape(name, tech) {
+  if (tech) {
+    const techShape = participantTypeToC4Shape(inferParticipantType(tech));
+    if (techShape !== "default") return techShape;
+  }
+  return participantTypeToC4Shape(inferParticipantType(name));
+}
+function parseC4MetaTail(tail, metaAliasMap) {
+  const trimmed = tail.trim();
+  if (!trimmed) return {};
+  if (!trimmed.includes(":")) {
+    return {};
+  }
+  const registry = withTagAliases(C4_REGISTRY, new Set(metaAliasMap.keys()));
+  const split = splitNameAndMeta(
+    `color: __c4ph, ${trimmed}`,
+    registry,
+    metaAliasMap
+  );
+  const meta = split.meta;
+  if (meta["color"] === "__c4ph") delete meta["color"];
+  return meta;
+}
+function parseC4NameAndMeta(text, metaAliasMap) {
+  const registry = withTagAliases(C4_REGISTRY, new Set(metaAliasMap.keys()));
+  const split = splitNameAndMeta(text, registry, metaAliasMap);
+  return { name: split.name, metadata: split.meta };
+}
+function parseArrowType(arrow) {
+  switch (arrow) {
+    case "->":
+      return "sync";
+    case "~>":
+      return "async";
+    case "<->":
+      return "bidirectional";
+    case "<~>":
+      return "bidirectional-async";
+    default:
+      return null;
+  }
+}
+function parseC4(content, palette) {
+  const options = {};
+  const result = {
+    title: null,
+    titleLineNumber: null,
+    options,
+    tagGroups: [],
+    elements: [],
+    relationships: [],
+    deployment: [],
+    diagnostics: [],
+    error: null
+  };
+  const pushError = (line, message, severity = "error") => {
+    const diag = makeDgmoError(line, message, severity);
+    result.diagnostics.push(diag);
+    if (!result.error && severity === "error")
+      result.error = formatDgmoError(diag);
+  };
+  const fail = makeFail(result);
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let sawChartType = false;
+  let inDeployment = false;
+  let currentTagGroup = null;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function resolveNameRef(rawName) {
+    return nameAliasMap.get(rawName.trim()) ?? rawName;
+  }
+  const knownNames = /* @__PURE__ */ new Map();
+  const elementMetadata = /* @__PURE__ */ new WeakMap();
+  const elementDescription = /* @__PURE__ */ new WeakMap();
+  const stack = [];
+  const deployStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (currentTagGroup) currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!contentStarted && !sawChartType) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine) {
+        if (firstLine.chartType !== "c4") {
+          let msg = `Expected chart type "c4", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, ALL_CHART_TYPES);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        sawChartType = true;
+        if (firstLine.title) {
+          result.title = firstLine.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(lineNumber, "Tag groups must appear before content");
+        continue;
+      }
+      currentTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      if (tagBlockMatch.alias) {
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.alias),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      metaAliasMap.set(
+        normalizeName(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
+      if (KNOWN_C4_BOOLEANS.has(trimmed.toLowerCase())) {
+        options[trimmed.toLowerCase()] = "on";
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (KNOWN_C4_OPTIONS.has(key)) {
+          options[key] = optMatch[2].trim();
+          continue;
+        }
+      }
+    }
+    if (currentTagGroup && !contentStarted) {
+      const indent2 = measureIndent(line);
+      if (indent2 > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    if (!sawChartType) {
+      return fail(lineNumber, 'Missing "c4" header');
+    }
+    const indent = measureIndent(line);
+    if (inDeployment) {
+      while (deployStack.length > 0) {
+        const top = deployStack[deployStack.length - 1];
+        if (top.indent < indent) break;
+        deployStack.pop();
+      }
+      if (indent === 0 && (C4_IS_A_RE.test(trimmed) || ELEMENT_RE.test(trimmed))) {
+        inDeployment = false;
+      } else {
+        const refMatch = trimmed.match(CONTAINER_REF_RE);
+        if (refMatch) {
+          const refName = refMatch[1].trim();
+          if (deployStack.length > 0) {
+            deployStack[deployStack.length - 1].node.containerRefs.push(
+              refName
+            );
+          } else {
+            pushError(
+              lineNumber,
+              `"container ${refName}" must be indented under a deployment node (e.g. under 'Prod is a deployment-node')`
+            );
+          }
+          continue;
+        }
+        const { name: nodeName, metadata } = parseC4NameAndMeta(
+          trimmed,
+          metaAliasMap
+        );
+        warnUnknownMetaKeys(
+          metadata,
+          withTagAliases(C4_REGISTRY, new Set(metaAliasMap.keys())),
+          (msg) => pushError(lineNumber, msg, "warning"),
+          nodeName
+        );
+        const shape = inferC4Shape(
+          nodeName,
+          metadata["tech"] ?? metadata["technology"]
+        );
+        const dNode = {
+          name: nodeName,
+          metadata,
+          shape,
+          children: [],
+          containerRefs: [],
+          lineNumber
+        };
+        if (deployStack.length > 0) {
+          deployStack[deployStack.length - 1].node.children.push(dNode);
+        } else {
+          result.deployment.push(dNode);
+        }
+        deployStack.push({ node: dNode, indent });
+        continue;
+      }
+    }
+    const sectionMatch = trimmed.match(SECTION_HEADER_RE);
+    if (sectionMatch) {
+      const sectionType = sectionMatch[1].toLowerCase();
+      if (sectionType === "deployment") {
+        inDeployment = true;
+        continue;
+      }
+      const parentEntry = findParentElement(indent, stack);
+      if (parentEntry) {
+        parentEntry.element.sectionHeader = sectionType;
+        parentEntry.element.sectionHeaderLineNumber = lineNumber;
+        stack.push({
+          kind: "section",
+          sectionType,
+          parentElement: parentEntry.element,
+          indent
+        });
+      } else {
+        pushError(
+          lineNumber,
+          `"${sectionType}" must be indented under an element (e.g. under 'Web App is a container')`
+        );
+      }
+      continue;
+    }
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      if (top.indent < indent) break;
+      stack.pop();
+    }
+    const containerMatch = trimmed.match(CONTAINER_RE);
+    if (containerMatch) {
+      const groupName = containerMatch[1].trim();
+      const parentEntry = findParentElement(indent, stack);
+      if (parentEntry) {
+        const group = {
+          name: groupName,
+          children: [],
+          lineNumber
+        };
+        parentEntry.element.groups.push(group);
+        stack.push({
+          kind: "group",
+          group,
+          parentElement: parentEntry.element,
+          indent
+        });
+      } else {
+        pushError(
+          lineNumber,
+          `Group [${groupName}] must be indented under an element (e.g. under 'Web App is a container')`
+        );
+      }
+      continue;
+    }
+    {
+      const labeledPatterns = [
+        { re: C4_LABELED_BIDI_SYNC_RE, arrowType: "bidirectional" },
+        { re: C4_LABELED_BIDI_ASYNC_RE, arrowType: "bidirectional-async" },
+        { re: C4_LABELED_SYNC_RE, arrowType: "sync" },
+        { re: C4_LABELED_ASYNC_RE, arrowType: "async" }
+      ];
+      let labeledHandled = false;
+      for (const { re, arrowType } of labeledPatterns) {
+        const m = trimmed.match(re);
+        if (!m) continue;
+        const rawLabel = m[1].trim();
+        const targetBody = m[2].trim();
+        if (!rawLabel) break;
+        if (arrowType === "bidirectional" || arrowType === "bidirectional-async") {
+          const source = findParentElement(indent, stack)?.element.name ?? "?";
+          pushError(
+            lineNumber,
+            `Bidirectional arrows are no longer supported. Replace with two separate arrows:
+  -${rawLabel}-> ${targetBody}
+  ${targetBody} -${rawLabel}-> ${source}`
+          );
+          labeledHandled = true;
+          break;
+        }
+        const labelResult = parseInArrowLabel(rawLabel, lineNumber);
+        labelResult.diagnostics.forEach((d) => result.diagnostics.push(d));
+        const label = labelResult.label;
+        let technology;
+        const targetParsed = parseC4NameAndMeta(targetBody, metaAliasMap);
+        warnUnknownMetaKeys(
+          targetParsed.metadata,
+          withTagAliases(C4_REGISTRY, new Set(metaAliasMap.keys())),
+          (msg) => pushError(lineNumber, msg, "warning"),
+          targetParsed.name
+        );
+        const target = targetParsed.name;
+        if (targetParsed.metadata["tech"]) {
+          technology = targetParsed.metadata["tech"];
+        }
+        if (targetParsed.metadata["technology"]) {
+          technology = targetParsed.metadata["technology"];
+        }
+        const rel = {
+          target: resolveNameRef(target),
+          ...label !== void 0 && { label },
+          ...technology !== void 0 && { technology },
+          arrowType,
+          lineNumber
+        };
+        const parentEntry = findParentElement(indent, stack);
+        if (parentEntry) {
+          parentEntry.element.relationships.push(rel);
+        } else {
+          result.relationships.push(rel);
+        }
+        labeledHandled = true;
+        break;
+      }
+      if (labeledHandled) continue;
+    }
+    const relMatch = trimmed.match(RELATIONSHIP_RE);
+    if (relMatch) {
+      const arrowType = parseArrowType(relMatch[1]);
+      if (arrowType) {
+        if (arrowType === "bidirectional" || arrowType === "bidirectional-async") {
+          const arrow = relMatch[1];
+          const target2 = relMatch[2].trim();
+          const source = findParentElement(indent, stack)?.element.name ?? "?";
+          pushError(
+            lineNumber,
+            `'${arrow}' bidirectional arrows are no longer supported. Replace with two separate arrows:
+  -> ${target2}
+  ${target2} -> ${source}`
+          );
+          continue;
+        }
+        const target = relMatch[2].trim();
+        const rel = {
+          target: resolveNameRef(target),
+          arrowType,
+          lineNumber
+        };
+        const parentEntry = findParentElement(indent, stack);
+        if (parentEntry) {
+          parentEntry.element.relationships.push(rel);
+        } else {
+          result.relationships.push(rel);
+        }
+        continue;
+      }
+    }
+    const isATypeMatch = trimmed.match(C4_IS_A_RE);
+    if (isATypeMatch) {
+      let namePart = isATypeMatch[1].trim();
+      const rawType = isATypeMatch[2].toLowerCase();
+      let remainder = isATypeMatch[3];
+      const asPostfix = remainder.match(
+        /^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*(\|.*)?$/
+      );
+      if (asPostfix) {
+        nameAliasMap.set(asPostfix[2], namePart);
+        remainder = (asPostfix[1] + (asPostfix[3] ?? "")).trim();
+      } else {
+        const asInName = namePart.match(
+          /^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/
+        );
+        if (asInName) {
+          namePart = asInName[1].trim();
+          nameAliasMap.set(asInName[2], namePart);
+        }
+      }
+      let elementType;
+      let explicitShape = null;
+      if (rawType === "external") {
+        elementType = "system";
+        explicitShape = "external";
+      } else if (rawType === "database") {
+        elementType = "container";
+        explicitShape = "database";
+      } else {
+        elementType = rawType;
+      }
+      const remainderTrimmed = remainder.trim();
+      let metaTail = remainderTrimmed;
+      const remainderIsA = remainderTrimmed.match(
+        /^\s*is\s+a(?:n)?\s+(\w+)\s*(.*)$/i
+      );
+      if (remainderIsA) {
+        const shapeName = remainderIsA[1].toLowerCase();
+        if (VALID_SHAPES.has(shapeName)) {
+          explicitShape = shapeName;
+        } else {
+          pushError(
+            lineNumber,
+            `Unknown shape "${remainderIsA[1]}". Valid shapes: ${[...VALID_SHAPES].join(", ")}`
+          );
+        }
+        metaTail = remainderIsA[2].trim();
+      }
+      const nameIsAMatch = namePart.match(IS_A_RE);
+      if (nameIsAMatch) {
+        const shapeName = nameIsAMatch[1].toLowerCase();
+        if (VALID_SHAPES.has(shapeName)) {
+          explicitShape = shapeName;
+        } else {
+          pushError(
+            lineNumber,
+            `Unknown shape "${nameIsAMatch[1]}". Valid shapes: ${[...VALID_SHAPES].join(", ")}`
+          );
+        }
+        namePart = namePart.substring(0, nameIsAMatch.index).trim();
+      }
+      const metadata = parseC4MetaTail(metaTail, metaAliasMap);
+      const shape = explicitShape ?? inferC4Shape(namePart, metadata["tech"] ?? metadata["technology"]);
+      let isADescription;
+      if ("description" in metadata) {
+        const descVal = metadata["description"].trim();
+        if (descVal) isADescription = [descVal];
+        delete metadata["description"];
+      }
+      const element = {
+        name: namePart,
+        type: elementType,
+        shape,
+        metadata,
+        ...isADescription !== void 0 && { description: isADescription },
+        children: [],
+        groups: [],
+        relationships: [],
+        lineNumber
+      };
+      elementMetadata.set(element, metadata);
+      if (isADescription !== void 0)
+        elementDescription.set(element, isADescription);
+      const key = normalizeName(namePart);
+      const existingLine = knownNames.get(key);
+      if (existingLine !== void 0) {
+        pushError(
+          lineNumber,
+          `Duplicate element name "${namePart}" (first defined on line ${existingLine})`
+        );
+      } else {
+        knownNames.set(key, lineNumber);
+      }
+      attachElement(element, indent, stack, result);
+      continue;
+    }
+    const elementMatch = trimmed.match(ELEMENT_RE);
+    if (elementMatch) {
+      const elementType = elementMatch[1].toLowerCase();
+      const nameAndRest = elementMatch[2];
+      const parsed = parseC4NameAndMeta(nameAndRest, metaAliasMap);
+      warnUnknownMetaKeys(
+        parsed.metadata,
+        withTagAliases(C4_REGISTRY, new Set(metaAliasMap.keys())),
+        (msg) => pushError(lineNumber, msg, "warning"),
+        parsed.name
+      );
+      let namePart = parsed.name;
+      const metadata = parsed.metadata;
+      let explicitShape = null;
+      const isAMatch = namePart.match(IS_A_RE);
+      if (isAMatch) {
+        const shapeName = isAMatch[1].toLowerCase();
+        if (VALID_SHAPES.has(shapeName)) {
+          explicitShape = shapeName;
+        } else {
+          pushError(
+            lineNumber,
+            `Unknown shape "${isAMatch[1]}". Valid shapes: ${[...VALID_SHAPES].join(", ")}`
+          );
+        }
+        namePart = namePart.substring(0, isAMatch.index).trim();
+      }
+      pushError(
+        lineNumber,
+        `'${elementMatch[1]} ${namePart}' prefix syntax is no longer supported \u2014 use '${namePart} is a ${elementType}' instead`
+      );
+      const shape = explicitShape ?? inferC4Shape(namePart, metadata["tech"] ?? metadata["technology"]);
+      let prefixDescription;
+      if ("description" in metadata) {
+        const descVal = metadata["description"].trim();
+        if (descVal) prefixDescription = [descVal];
+        delete metadata["description"];
+      }
+      const element = {
+        name: namePart,
+        type: elementType,
+        shape,
+        metadata,
+        ...prefixDescription !== void 0 && {
+          description: prefixDescription
+        },
+        children: [],
+        groups: [],
+        relationships: [],
+        lineNumber
+      };
+      elementMetadata.set(element, metadata);
+      if (prefixDescription !== void 0)
+        elementDescription.set(element, prefixDescription);
+      const key = normalizeName(namePart);
+      const existingLine = knownNames.get(key);
+      if (existingLine !== void 0) {
+        pushError(
+          lineNumber,
+          `Duplicate element name "${namePart}" (first defined on line ${existingLine})`
+        );
+      } else {
+        knownNames.set(key, lineNumber);
+      }
+      attachElement(element, indent, stack, result);
+      continue;
+    }
+    const metadataMatch = trimmed.match(METADATA_RE);
+    if (metadataMatch && !ELEMENT_RE.test(trimmed)) {
+      const parentEntry = findParentElement(indent, stack);
+      if (parentEntry) {
+        const rawKey = metadataMatch[1].trim().toLowerCase();
+        if (rawKey === "import") {
+          parentEntry.element.importPath = metadataMatch[2].trim();
+          continue;
+        }
+        const key = metaAliasMap.get(rawKey) ?? rawKey;
+        const value = metadataMatch[2].trim();
+        if (key === "description") {
+          let desc = elementDescription.get(parentEntry.element);
+          if (!desc) {
+            desc = [];
+            elementDescription.set(parentEntry.element, desc);
+            parentEntry.element.description = desc;
+          }
+          desc.push(value);
+          continue;
+        }
+        const meta = elementMetadata.get(parentEntry.element);
+        if (meta) meta[key] = value;
+        continue;
+      }
+    }
+    const firstWord = trimmed.split(/\s+/)[0].toLowerCase();
+    if (firstWord.length > 3) {
+      const hint = suggest(firstWord, [...VALID_ELEMENT_TYPES]);
+      if (hint) {
+        pushError(lineNumber, `Unknown keyword "${firstWord}". ${hint}`);
+        continue;
+      }
+    }
+    const parent = findParentElement(indent, stack);
+    const descResult = tryStripDescriptionKeyword(trimmed);
+    if (parent && descResult.isKeyword && !descResult.needsColon) {
+      let desc = elementDescription.get(parent.element);
+      if (!desc) {
+        desc = [];
+        elementDescription.set(parent.element, desc);
+        parent.element.description = desc;
+      }
+      desc.push(descResult.text);
+    } else {
+      pushError(
+        lineNumber,
+        `Unexpected content: "${trimmed}". Expected an element ('Web App is a container'), a relationship ('-Uses-> Database'), indented metadata ('tech: React'), or a group ('[Backend]'). (\xA78)`
+      );
+    }
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  validateRelationshipTargets(result, knownNames, pushError);
+  validateDeploymentRefs(result, knownNames, pushError);
+  validateTagGroupNames(
+    result.tagGroups,
+    (line, msg) => pushError(line, msg, "warning")
+  );
+  return result;
+}
+function findParentElement(indent, stack) {
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const entry = stack[i];
+    if (entry.indent >= indent) continue;
+    if (entry.kind === "element") return entry;
+    if (entry.kind === "group") {
+      continue;
+    }
+    if (entry.kind === "section") {
+      return {
+        kind: "element",
+        element: entry.parentElement,
+        indent: entry.indent
+      };
+    }
+  }
+  return null;
+}
+function attachElement(element, indent, stack, result) {
+  let attached = false;
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const entry = stack[i];
+    if (entry.indent >= indent) continue;
+    if (entry.kind === "group") {
+      entry.group.children.push(element);
+      attached = true;
+      break;
+    }
+    if (entry.kind === "section") {
+      entry.parentElement.children.push(element);
+      attached = true;
+      break;
+    }
+    if (entry.kind === "element") {
+      entry.element.children.push(element);
+      attached = true;
+      break;
+    }
+  }
+  if (!attached) {
+    result.elements.push(element);
+  }
+  stack.push({ kind: "element", element, indent });
+}
+function validateRelationshipTargets(result, knownNames, pushWarning) {
+  const allNames = Array.from(knownNames.keys());
+  function walkRels(elements) {
+    for (const el of elements) {
+      for (const rel of el.relationships) {
+        if (!knownNames.has(normalizeName(rel.target))) {
+          let msg = `Relationship target "${rel.target}" not found \u2014 declare it first (e.g. '${rel.target} is a container'), then reference it in the arrow`;
+          const hint = suggest(normalizeName(rel.target), allNames);
+          if (hint) msg += `. ${hint}`;
+          pushWarning(rel.lineNumber, msg, "warning");
+        }
+      }
+      walkRels(el.children);
+      for (const g of el.groups) {
+        walkRels(g.children);
+      }
+    }
+  }
+  walkRels(result.elements);
+  for (const rel of result.relationships) {
+    if (!knownNames.has(normalizeName(rel.target))) {
+      let msg = `Relationship target "${rel.target}" not found`;
+      const hint = suggest(normalizeName(rel.target), allNames);
+      if (hint) msg += `. ${hint}`;
+      pushWarning(rel.lineNumber, msg, "warning");
+    }
+  }
+}
+function validateDeploymentRefs(result, knownNames, pushWarning) {
+  const allNames = Array.from(knownNames.keys());
+  function walkDeploy(nodes) {
+    for (const node of nodes) {
+      for (const ref of node.containerRefs) {
+        if (!knownNames.has(normalizeName(ref))) {
+          let msg = `Deployment reference "container ${ref}" not found \u2014 declare the container element first, then reference it under the deployment node`;
+          const hint = suggest(normalizeName(ref), allNames);
+          if (hint) msg += `. ${hint}`;
+          pushWarning(node.lineNumber, msg, "warning");
+        }
+      }
+      walkDeploy(node.children);
+    }
+  }
+  walkDeploy(result.deployment);
+}
+
+export {
+  parseC4
+};
+//# sourceMappingURL=chunk-2DXMZRWJ.js.map