@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-SML67VPV.js

@@ -0,0 +1,1025 @@
+import {
+  inferParticipantType
+} from "./chunk-C3Z4DX3V.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  parseArrow,
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  OPTION_NOCOLON_RE,
+  SEQUENCE_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/sequence/parser.ts
+var KNOWN_SEQ_OPTIONS = /* @__PURE__ */ new Set(["active-tag"]);
+var KNOWN_SEQ_BOOLEANS = /* @__PURE__ */ new Set(["solid-fill", "no-title"]);
+var NO_PREFIX_ONLY_BOOLEANS = /* @__PURE__ */ new Set(["activations"]);
+var VALID_PARTICIPANT_TYPES = /* @__PURE__ */ new Set([
+  "database",
+  "actor",
+  "queue",
+  "cache"
+]);
+function isSequenceBlock(el) {
+  return el.kind === "block";
+}
+function isSequenceSection(el) {
+  return el.kind === "section";
+}
+function isSequenceNote(el) {
+  return el.kind === "note";
+}
+var IS_A_PATTERN = /^([^:]+?)\s+is\s+an?\s+(\w+)(?:\s+(.+))?$/i;
+var COLORED_PARTICIPANT_PATTERN = /^(\S+?)\((red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\)\s*$/;
+var GROUP_HEADING_PATTERN = /^\[([^\]|]+?)(?:\(([^)]+)\))?\]\s*(.*)$/;
+var GROUP_HEADING_FALLBACK = /^\[([^\]]+)\]\s*(.*)$/;
+var SECTION_PATTERN = /^==\s+(.+?)(?:\s*==)?\s*$/;
+var ARROW_PATTERN = /\S+\s*(?:<-\S+-|<~\S+~|-\S+->|~\S+~>|->|~>|<-|<~)\s*\S+/;
+var NOTE_BARE = /^note\s+(.+)$/i;
+var NOTE_MULTI = /^note(?:\s+(right|left)(?:\s+(?:of\s+)?(.+?))?)?\s*$/i;
+function parseNoteLine(trimmed, participants, participantIds, sortedParticipantsCache, lastMsgFrom) {
+  const lower = trimmed.toLowerCase();
+  if (!lower.startsWith("note")) return null;
+  if (trimmed.length > 4 && trimmed[4] !== " ") return null;
+  const multiMatch = trimmed.match(NOTE_MULTI);
+  if (multiMatch) {
+    const position = multiMatch[1]?.toLowerCase() || "right";
+    let participantId = multiMatch[2] || null;
+    if (!participantId) {
+      if (!lastMsgFrom) return { kind: "skip" };
+      participantId = lastMsgFrom;
+    }
+    const lookupKey = normalizeName(participantId);
+    if (participantIds.has(lookupKey)) {
+      const found = participants.find((p) => normalizeName(p.id) === lookupKey);
+      return {
+        kind: "multi-head",
+        position,
+        // Verified participant — `participantIds.has(lookupKey)` confirmed.
+        participantId: found?.id ?? participantId
+      };
+    }
+  }
+  const bareMatch = trimmed.match(NOTE_BARE);
+  if (bareMatch) {
+    const rest = bareMatch[1].trim();
+    const restLower = rest.toLowerCase();
+    if (restLower.startsWith("left") || restLower.startsWith("right")) {
+      const posWord = restLower.startsWith("left") ? "left" : "right";
+      const position = posWord;
+      let afterPos = rest.substring(posWord.length).trim();
+      let hadOf = false;
+      if (afterPos.toLowerCase().startsWith("of ")) {
+        afterPos = afterPos.substring(3).trim();
+        hadOf = true;
+      }
+      if (!afterPos) {
+        if (!lastMsgFrom) return { kind: "skip" };
+        if (!participantIds.has(normalizeName(lastMsgFrom)))
+          return { kind: "skip" };
+        return {
+          kind: "multi-head",
+          position,
+          participantId: lastMsgFrom
+        };
+      }
+      const resolved = resolveParticipantAndText(
+        afterPos,
+        participants,
+        participantIds,
+        sortedParticipantsCache
+      );
+      if (resolved) {
+        if (resolved.text) {
+          return {
+            kind: "single",
+            position,
+            participantId: resolved.participantId,
+            text: resolved.text
+          };
+        } else {
+          return {
+            kind: "multi-head",
+            position,
+            participantId: resolved.participantId
+          };
+        }
+      }
+      if (hadOf) return { kind: "skip" };
+      if (!lastMsgFrom) return { kind: "skip" };
+      if (!participantIds.has(normalizeName(lastMsgFrom)))
+        return { kind: "skip" };
+      return {
+        kind: "single",
+        position,
+        // Verified by participantIds.has check above.
+        participantId: lastMsgFrom,
+        text: afterPos
+      };
+    }
+    if (!lastMsgFrom) return { kind: "skip" };
+    if (!participantIds.has(normalizeName(lastMsgFrom)))
+      return { kind: "skip" };
+    return {
+      kind: "single",
+      position: "right",
+      // Verified by participantIds.has check above.
+      participantId: lastMsgFrom,
+      text: rest
+    };
+  }
+  return null;
+}
+function resolveParticipantAndText(input, participants, participantIds, sortedParticipantsCache) {
+  if (input.startsWith('"') || input.startsWith("'")) {
+    const quote = input[0];
+    const endQuote = input.indexOf(quote, 1);
+    if (endQuote > 0) {
+      const name = input.substring(1, endQuote);
+      const key = normalizeName(name);
+      if (participantIds.has(key)) {
+        const text = input.substring(endQuote + 1).trim();
+        const found = participants.find((p) => normalizeName(p.id) === key);
+        return { participantId: found?.id ?? name, text };
+      }
+    }
+    return null;
+  }
+  const sorted = sortedParticipantsCache;
+  for (const p of sorted) {
+    const idLen = p.id.length;
+    if (input.length < idLen) continue;
+    const candidate = input.substring(0, idLen);
+    if (normalizeName(candidate) !== normalizeName(p.id)) continue;
+    const remaining = input.substring(idLen);
+    if (remaining === "" || remaining[0] === " " || remaining[0] === "	") {
+      return { participantId: p.id, text: remaining.trim() };
+    }
+  }
+  return null;
+}
+function parseSequenceDgmo(content, palette) {
+  const optionsAccumulator = {};
+  const result = {
+    title: null,
+    titleLineNumber: null,
+    participants: [],
+    messages: [],
+    elements: [],
+    groups: [],
+    sections: [],
+    tagGroups: [],
+    options: optionsAccumulator,
+    diagnostics: [],
+    error: null
+  };
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  const resolveAlias = (token) => {
+    const trimmed = token.trim();
+    return nameAliasMap.get(trimmed) ?? trimmed;
+  };
+  const fail = makeFail(result);
+  const pushError = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const pushWarning = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!content?.trim()) {
+    return fail(0, "Empty content");
+  }
+  const lines = content.split("\n");
+  let hasExplicitChart = false;
+  let contentStarted = false;
+  let bodyStarted = false;
+  let firstLineIndex = -1;
+  for (let fi = 0; fi < lines.length; fi++) {
+    const fl = lines[fi].trim();
+    if (!fl || fl.startsWith("//")) continue;
+    const parsed = parseFirstLine(fl);
+    if (parsed?.chartType === "sequence") {
+      hasExplicitChart = true;
+      firstLineIndex = fi;
+      if (parsed.title) {
+        result.title = parsed.title;
+        result.titleLineNumber = fi + 1;
+      }
+    }
+    break;
+  }
+  let activeGroup = null;
+  const participantIds = /* @__PURE__ */ new Set();
+  const idByKey = /* @__PURE__ */ new Map();
+  const addParticipant = (name, lineNumber, extras) => {
+    const key = normalizeName(name);
+    const trimmed = name.trim();
+    const incomingLabel = extras?.label ?? trimmed;
+    if (participantIds.has(key)) {
+      const existing = result.participants.find(
+        (p) => normalizeName(p.id) === key
+      );
+      if (existing) {
+        if (displayName(existing.label) !== displayName(incomingLabel) || displayName(existing.id) !== displayName(trimmed)) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              nameMergedMessage({
+                incomingDisplay: trimmed,
+                incomingLine: lineNumber,
+                existingDisplay: existing.id,
+                existingLine: existing.lineNumber
+              }),
+              "warning",
+              NAME_DIAGNOSTIC_CODES.NAME_MERGED
+            )
+          );
+        }
+        return existing.id;
+      }
+      return idByKey.get(key) ?? trimmed;
+    }
+    participantIds.add(key);
+    idByKey.set(key, trimmed);
+    sortedCacheDirty = true;
+    result.participants.push({
+      id: trimmed,
+      label: incomingLabel,
+      type: extras?.type ?? inferParticipantType(name),
+      lineNumber,
+      ...extras?.position !== void 0 ? { position: extras.position } : {},
+      // takePosition() may have emptied the metadata record (position was
+      // its only key) — don't attach an empty object.
+      ...extras?.metadata && Object.keys(extras.metadata).length > 0 ? { metadata: extras.metadata } : {}
+    });
+    return trimmed;
+  };
+  let sortedParticipantsCache = [];
+  let sortedCacheDirty = true;
+  const getSortedParticipants = () => {
+    if (sortedCacheDirty) {
+      sortedParticipantsCache = [...result.participants].sort(
+        (a, b) => b.label.length - a.label.length
+      );
+      sortedCacheDirty = false;
+    }
+    return sortedParticipantsCache;
+  };
+  const participantGroupMap = /* @__PURE__ */ new Map();
+  let currentTagGroup = null;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const splitPipe = (text, ln) => {
+    const registry = withTagAliases(
+      SEQUENCE_REGISTRY,
+      new Set(aliasMap.keys())
+    );
+    const split = splitNameAndMeta(text, registry, aliasMap);
+    if (ln != null) {
+      warnUnknownMetaKeys(
+        split.meta,
+        registry,
+        (msg) => pushWarning(ln, msg),
+        split.name
+      );
+    }
+    if (Object.keys(split.meta).length > 0) {
+      return {
+        core: split.name,
+        meta: split.meta,
+        ...split.alias !== void 0 && { alias: split.alias }
+      };
+    }
+    return { core: text };
+  };
+  const takePosition = (meta, ln) => {
+    if (meta?.["position"] === void 0) return void 0;
+    const raw = meta["position"];
+    delete meta["position"];
+    const n = parseInt(raw, 10);
+    if (!/^-?\d+$/.test(raw.trim()) || Number.isNaN(n)) {
+      pushError(ln, `'position: ${raw}' must be an integer slot index`);
+      return void 0;
+    }
+    return n;
+  };
+  const blockStack = [];
+  const currentContainer = () => {
+    if (blockStack.length === 0) return result.elements;
+    const top = blockStack[blockStack.length - 1];
+    if (top.activeElseIfBranch) return top.activeElseIfBranch.children;
+    return top.inElse ? top.block.elseChildren : top.block.children;
+  };
+  let lastMsgFrom = null;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    const lineNumber = i + 1;
+    if (!trimmed) {
+      activeGroup = null;
+      currentTagGroup = null;
+      continue;
+    }
+    if (i === firstLineIndex) continue;
+    const groupMatch = trimmed.match(GROUP_HEADING_PATTERN);
+    if (groupMatch) {
+      const groupName = groupMatch[1].trim();
+      const groupColor = groupMatch[2]?.trim();
+      let groupMeta;
+      const afterBracket = groupMatch[3]?.trim() || "";
+      let isCollapsed = false;
+      if (afterBracket) {
+        const groupRegistry = withTagAliases(
+          SEQUENCE_REGISTRY,
+          new Set(aliasMap.keys())
+        );
+        const split = splitNameAndMeta(afterBracket, groupRegistry, aliasMap);
+        warnUnknownMetaKeys(
+          split.meta,
+          groupRegistry,
+          (msg) => pushWarning(lineNumber, msg),
+          split.name
+        );
+        if (Object.keys(split.meta).length > 0) groupMeta = split.meta;
+        if (groupMeta?.["collapsed"]?.toLowerCase() === "true") {
+          isCollapsed = true;
+          delete groupMeta["collapsed"];
+          if (Object.keys(groupMeta).length === 0) groupMeta = void 0;
+        }
+      }
+      if (groupColor) {
+        pushWarning(
+          lineNumber,
+          `'(${groupColor})' parens-color syntax removed from sequence diagrams \u2014 use 'tag:' groups for coloring`
+        );
+      }
+      contentStarted = true;
+      activeGroup = {
+        name: groupName,
+        participantIds: [],
+        lineNumber,
+        ...groupMeta ? { metadata: groupMeta } : {},
+        ...isCollapsed ? { collapsed: true } : {}
+      };
+      result.groups.push(activeGroup);
+      continue;
+    }
+    if (trimmed.startsWith("[")) {
+      const fallbackMatch = trimmed.match(GROUP_HEADING_FALLBACK);
+      if (fallbackMatch && fallbackMatch[1].includes("|")) {
+        const rawInside = fallbackMatch[1];
+        const pipeIdx = rawInside.indexOf("|");
+        const cleanName = rawInside.substring(0, pipeIdx).trim().replace(/\([^)]*\)$/, "").trim();
+        const metaPart = rawInside.substring(pipeIdx).replace(/^\|\s*/, "").trim();
+        pushError(
+          lineNumber,
+          `Metadata goes after the bracket with no pipe \u2014 use '[${cleanName}] ${metaPart}' (e.g. '[Backend] t: Product'), not '[${rawInside.trim()}]'`
+        );
+        continue;
+      }
+    }
+    if (activeGroup && measureIndent(raw) === 0) {
+      activeGroup = null;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (trimmed.startsWith("#")) {
+      pushError(lineNumber, "Use // for comments");
+      continue;
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(lineNumber, "Tag groups must appear before sequence content");
+        continue;
+      }
+      const newTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      currentTagGroup = newTagGroup;
+      if (tagBlockMatch.alias) {
+        aliasMap.set(
+          tagBlockMatch.alias.toLowerCase(),
+          tagBlockMatch.name.toLowerCase()
+        );
+      }
+      aliasMap.set(
+        normalizeName(tagBlockMatch.name),
+        tagBlockMatch.name.toLowerCase()
+      );
+      result.tagGroups.push(newTagGroup);
+      continue;
+    }
+    if (currentTagGroup && !contentStarted && measureIndent(raw) > 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;
+    }
+    if (currentTagGroup) {
+      currentTagGroup = null;
+    }
+    const sectionMatch = trimmed.match(SECTION_PATTERN);
+    if (sectionMatch) {
+      const sectionIndent = measureIndent(raw);
+      while (blockStack.length > 0) {
+        const top = blockStack[blockStack.length - 1];
+        if (sectionIndent > top.indent) break;
+        blockStack.pop();
+      }
+      const labelRaw = sectionMatch[1].trim();
+      const colorMatch = labelRaw.match(
+        /^(.+?)\((red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\)$/
+      );
+      if (colorMatch) {
+        pushWarning(
+          lineNumber,
+          `'(${colorMatch[2]})' parens-color syntax removed from sequence diagrams \u2014 use 'tag:' groups for coloring`
+        );
+      }
+      contentStarted = true;
+      bodyStarted = true;
+      const section = {
+        kind: "section",
+        // Capture group 1 guaranteed present after successful match.
+        label: colorMatch ? colorMatch[1].trim() : labelRaw,
+        lineNumber
+      };
+      result.sections.push(section);
+      currentContainer().push(section);
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    const preColon = colonIndex > 0 ? trimmed.substring(0, colonIndex).trim() : "";
+    const preColonIsSingleIdent = /^[A-Za-z][\w-]*$/.test(preColon);
+    if (colonIndex > 0 && preColonIsSingleIdent && !trimmed.includes("->") && !trimmed.includes("~>") && !trimmed.includes("<-") && !trimmed.includes("<~") && !trimmed.includes("|")) {
+      const key = preColon.toLowerCase();
+      if (key === "note" || key.startsWith("note ")) {
+      } else {
+        const value = trimmed.substring(colonIndex + 1).trim();
+        if (contentStarted) {
+          pushError(
+            lineNumber,
+            `Options like '${key}: ${value}' must appear before the first message or declaration`
+          );
+          continue;
+        }
+        if (key === "title") {
+          result.title = value;
+          result.titleLineNumber = lineNumber;
+          continue;
+        }
+        result.options[key] = value;
+        continue;
+      }
+    }
+    {
+      const optLower = trimmed.toLowerCase();
+      if (optLower.startsWith("no-")) {
+        const base = optLower.substring(3);
+        if (KNOWN_SEQ_BOOLEANS.has(base) || NO_PREFIX_ONLY_BOOLEANS.has(base)) {
+          if (contentStarted) {
+            pushError(
+              lineNumber,
+              `Options like '${trimmed}' must appear before the first message or declaration`
+            );
+            continue;
+          }
+          result.options[base] = "off";
+          continue;
+        }
+      }
+      const spaceMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (spaceMatch) {
+        const optKey = spaceMatch[1].toLowerCase();
+        const optVal = spaceMatch[2].trim();
+        if (KNOWN_SEQ_OPTIONS.has(optKey) || KNOWN_SEQ_BOOLEANS.has(optKey)) {
+          if (contentStarted) {
+            pushError(
+              lineNumber,
+              `Options like '${trimmed}' must appear before the first message or declaration`
+            );
+            continue;
+          }
+          result.options[optKey] = optVal;
+          continue;
+        }
+      }
+      if (KNOWN_SEQ_BOOLEANS.has(optLower) && (optLower === "solid-fill" || optLower === "no-title")) {
+        if (contentStarted) {
+          pushError(
+            lineNumber,
+            `Options like '${trimmed}' must appear before the first message or declaration`
+          );
+          continue;
+        }
+        result.options[optLower] = "on";
+        continue;
+      }
+    }
+    const {
+      core: isACore,
+      meta: isAMeta,
+      alias: isAAlias
+    } = splitPipe(trimmed, lineNumber);
+    const isAMatch = !/^note(\s|$)/i.test(trimmed) ? isACore.match(IS_A_PATTERN) : null;
+    if (isAMatch) {
+      contentStarted = true;
+      const id = isAMatch[1];
+      const typeStr = isAMatch[2].toLowerCase();
+      const remainder = isAMatch[3]?.trim() || "";
+      const participantType = VALID_PARTICIPANT_TYPES.has(
+        typeStr
+      ) ? typeStr : "default";
+      if (isAAlias !== void 0) {
+        nameAliasMap.set(isAAlias, id);
+      }
+      const asInRemainder = remainder.match(
+        /^(.*?)\s*\bas\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/
+      );
+      if (asInRemainder) {
+        nameAliasMap.set(asInRemainder[2], id);
+      }
+      const position = takePosition(isAMeta, lineNumber);
+      const key = addParticipant(id, lineNumber, {
+        type: participantType,
+        ...position !== void 0 && { position },
+        ...isAMeta !== void 0 && { metadata: isAMeta }
+      });
+      if (activeGroup && !activeGroup.participantIds.includes(key)) {
+        const existingGroup = participantGroupMap.get(key);
+        if (existingGroup) {
+          pushError(
+            lineNumber,
+            `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
+          );
+        } else {
+          activeGroup.participantIds.push(key);
+          participantGroupMap.set(key, activeGroup.name);
+        }
+      }
+      continue;
+    }
+    const { core: colorCore, meta: colorMeta } = splitPipe(trimmed, lineNumber);
+    const coloredMatch = colorCore.match(COLORED_PARTICIPANT_PATTERN);
+    if (coloredMatch && !ARROW_PATTERN.test(colorCore)) {
+      const id = coloredMatch[1];
+      const color = coloredMatch[2].trim();
+      pushError(
+        lineNumber,
+        `'${id}(${color})' parens-color syntax is no longer supported \u2014 use 'tag:' groups for coloring`
+      );
+      contentStarted = true;
+      const key = addParticipant(id, lineNumber, {
+        ...colorMeta !== void 0 && { metadata: colorMeta }
+      });
+      if (activeGroup && !activeGroup.participantIds.includes(key)) {
+        const existingGroup = participantGroupMap.get(key);
+        if (existingGroup) {
+          pushError(
+            lineNumber,
+            `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
+          );
+        } else {
+          activeGroup.participantIds.push(key);
+          participantGroupMap.set(key, activeGroup.name);
+        }
+      }
+      continue;
+    }
+    {
+      const {
+        core: bareCore,
+        meta: bareMeta,
+        alias: bareAlias
+      } = splitPipe(trimmed, lineNumber);
+      const inGroup = activeGroup && measureIndent(raw) > 0;
+      if (/^\S+$/.test(bareCore) && !ARROW_PATTERN.test(bareCore) && (inGroup || !bodyStarted || bareMeta)) {
+        contentStarted = true;
+        const id = bareCore;
+        if (bareAlias !== void 0) nameAliasMap.set(bareAlias, id);
+        const position = takePosition(bareMeta, lineNumber);
+        const key = addParticipant(id, lineNumber, {
+          ...position !== void 0 && { position },
+          ...bareMeta !== void 0 && { metadata: bareMeta }
+        });
+        if (activeGroup && !activeGroup.participantIds.includes(key)) {
+          const existingGroup = participantGroupMap.get(key);
+          if (existingGroup) {
+            pushError(
+              lineNumber,
+              `Participant '${id}' is already in group '${existingGroup}' \u2014 participants can only belong to one group`
+            );
+          } else {
+            activeGroup.participantIds.push(key);
+            participantGroupMap.set(key, activeGroup.name);
+          }
+        }
+        continue;
+      }
+    }
+    const indent = measureIndent(raw);
+    while (blockStack.length > 0) {
+      const top = blockStack[blockStack.length - 1];
+      if (indent > top.indent) break;
+      if (indent === top.indent && (top.block.type === "if" || top.block.type === "parallel")) {
+        const lower = trimmed.toLowerCase();
+        if (lower === "else" || lower.startsWith("else if ")) break;
+      }
+      blockStack.pop();
+    }
+    const { core: arrowCore, meta: arrowMeta } = splitPipe(trimmed, lineNumber);
+    const asyncPrefixMatch = arrowCore.match(/^async\s+(.+)$/i);
+    if (asyncPrefixMatch && ARROW_PATTERN.test(asyncPrefixMatch[1])) {
+      pushError(lineNumber, "Use ~> for async messages: A ~> B: message");
+      continue;
+    }
+    const labeledArrow = parseArrow(arrowCore);
+    if (labeledArrow && "error" in labeledArrow) {
+      pushError(lineNumber, labeledArrow.error);
+      continue;
+    }
+    if (labeledArrow) {
+      contentStarted = true;
+      bodyStarted = true;
+      const { from, to, label: rawLabel, async: isAsync } = labeledArrow;
+      const fromKey = addParticipant(resolveAlias(from), lineNumber);
+      const toKey = addParticipant(resolveAlias(to), lineNumber);
+      lastMsgFrom = fromKey;
+      const labelResult = parseInArrowLabel(rawLabel, lineNumber);
+      labelResult.diagnostics.forEach((d) => result.diagnostics.push(d));
+      const label = labelResult.label ?? rawLabel;
+      const msg = {
+        kind: "message",
+        from: fromKey,
+        to: toKey,
+        label,
+        lineNumber,
+        ...isAsync ? { async: true } : {},
+        ...arrowMeta ? { metadata: arrowMeta } : {}
+      };
+      result.messages.push(msg);
+      currentContainer().push(msg);
+      continue;
+    }
+    const colonPostfixSync = arrowCore.match(
+      /^(\S+)\s*->\s*([^\s:]+)\s*:\s*(.+)$/
+    );
+    const colonPostfixAsync = arrowCore.match(
+      /^(\S+)\s*~>\s*([^\s:]+)\s*:\s*(.+)$/
+    );
+    const colonPostfix = colonPostfixSync || colonPostfixAsync;
+    if (colonPostfix) {
+      const a = colonPostfix[1];
+      const b = colonPostfix[2];
+      const msg = colonPostfix[3].trim();
+      const arrowChar = colonPostfixAsync ? "~" : "-";
+      const arrowEnd = colonPostfixAsync ? "~>" : "->";
+      pushError(
+        lineNumber,
+        `Colon syntax is no longer supported. Use '${a} ${arrowChar}${msg}${arrowEnd} ${b}' instead`
+      );
+      continue;
+    }
+    const bidiPlainMatch = arrowCore.match(/^(.+?)\s*(?:<->|<~>)\s*(.+)/);
+    if (bidiPlainMatch) {
+      pushError(
+        lineNumber,
+        "Bidirectional arrows are no longer supported. Use two separate lines: 'A -msg-> B' and 'B -msg-> A'"
+      );
+      continue;
+    }
+    const bareReturnSync = arrowCore.match(/^(.+?)\s*<-\s*(.+)$/);
+    const bareReturnAsync = arrowCore.match(/^(.+?)\s*<~\s*(.+)$/);
+    const bareReturn = bareReturnSync || bareReturnAsync;
+    if (bareReturn) {
+      const to = bareReturn[1];
+      const from = bareReturn[2];
+      pushError(
+        lineNumber,
+        `Left-pointing arrows are no longer supported. Write '${from} -> ${to}' instead`
+      );
+      continue;
+    }
+    const bareCallSync = arrowCore.match(/^(.+?)\s*->\s*(.+)$/);
+    const bareCallAsync = arrowCore.match(/^(.+?)\s*~>\s*(.+)$/);
+    const bareCall = bareCallSync || bareCallAsync;
+    if (bareCall) {
+      contentStarted = true;
+      bodyStarted = true;
+      const from = bareCall[1];
+      const to = bareCall[2];
+      const fromKey = addParticipant(resolveAlias(from), lineNumber);
+      const toKey = addParticipant(resolveAlias(to), lineNumber);
+      lastMsgFrom = fromKey;
+      const msg = {
+        kind: "message",
+        from: fromKey,
+        to: toKey,
+        label: "",
+        lineNumber,
+        ...bareCallAsync ? { async: true } : {},
+        ...arrowMeta ? { metadata: arrowMeta } : {}
+      };
+      result.messages.push(msg);
+      currentContainer().push(msg);
+      continue;
+    }
+    const ifMatch = trimmed.match(/^if\s+(.+)$/i);
+    if (ifMatch) {
+      contentStarted = true;
+      bodyStarted = true;
+      const block = {
+        kind: "block",
+        type: "if",
+        // Capture group 1 guaranteed present after successful match.
+        label: ifMatch[1].trim(),
+        children: [],
+        elseChildren: [],
+        lineNumber
+      };
+      currentContainer().push(block);
+      blockStack.push({ block, indent, inElse: false });
+      continue;
+    }
+    const loopMatch = trimmed.match(/^loop\s+(.+)$/i);
+    if (loopMatch) {
+      contentStarted = true;
+      bodyStarted = true;
+      const block = {
+        kind: "block",
+        type: "loop",
+        // Capture group 1 guaranteed present after successful match.
+        label: loopMatch[1].trim(),
+        children: [],
+        elseChildren: [],
+        lineNumber
+      };
+      currentContainer().push(block);
+      blockStack.push({ block, indent, inElse: false });
+      continue;
+    }
+    const parallelMatch = trimmed.match(/^parallel(?:\s+(.+))?$/i);
+    if (parallelMatch) {
+      contentStarted = true;
+      bodyStarted = true;
+      const block = {
+        kind: "block",
+        type: "parallel",
+        label: parallelMatch[1]?.trim() || "",
+        children: [],
+        elseChildren: [],
+        lineNumber
+      };
+      currentContainer().push(block);
+      blockStack.push({ block, indent, inElse: false });
+      continue;
+    }
+    const elseIfMatch = trimmed.match(/^else\s+if\s+(.+)$/i);
+    if (elseIfMatch) {
+      if (blockStack.length > 0 && // In-bounds by the length check above.
+      blockStack[blockStack.length - 1].indent === indent) {
+        const top = blockStack[blockStack.length - 1];
+        if (top.block.type === "parallel") {
+          pushError(
+            lineNumber,
+            "parallel blocks don't support else if \u2014 list all concurrent messages directly inside the block"
+          );
+          continue;
+        }
+        if (top.block.type === "if") {
+          const branch = {
+            // Capture group 1 guaranteed present after successful match.
+            label: elseIfMatch[1].trim(),
+            children: [],
+            lineNumber
+          };
+          if (!top.block.elseIfBranches) top.block.elseIfBranches = [];
+          const branches = top.block.elseIfBranches;
+          branches.push(branch);
+          top.activeElseIfBranch = branch;
+          top.inElse = false;
+        }
+      }
+      continue;
+    }
+    if (trimmed.toLowerCase() === "else") {
+      if (blockStack.length > 0 && // In-bounds by the length check above.
+      blockStack[blockStack.length - 1].indent === indent) {
+        const top = blockStack[blockStack.length - 1];
+        if (top.block.type === "parallel") {
+          pushError(
+            lineNumber,
+            "parallel blocks don't support else \u2014 list all concurrent messages directly inside the block"
+          );
+          continue;
+        }
+        if (top.block.type === "if") {
+          top.inElse = true;
+          delete top.activeElseIfBranch;
+          top.block.elseLineNumber = lineNumber;
+        }
+      }
+      continue;
+    }
+    const elifMatch = trimmed.match(/^elif\b\s*(.*)$/i);
+    if (elifMatch) {
+      const tailRaw = elifMatch[1].trim();
+      const tail = tailRaw ? " " + tailRaw : "";
+      pushError(
+        lineNumber,
+        `'elif' is not a keyword. Did you mean 'else if${tail}'?`
+      );
+      continue;
+    }
+    const elseLabelMatch = trimmed.match(/^else\s+(.+)$/i);
+    if (elseLabelMatch) {
+      const tail = elseLabelMatch[1].trim();
+      pushError(
+        lineNumber,
+        `'else' does not take a label. Did you mean 'else if ${tail}'?`
+      );
+      continue;
+    }
+    {
+      const noteParsed = parseNoteLine(
+        trimmed,
+        result.participants,
+        participantIds,
+        getSortedParticipants(),
+        lastMsgFrom
+      );
+      if (noteParsed) {
+        if (noteParsed.kind === "single") {
+          const note = {
+            kind: "note",
+            text: noteParsed.text,
+            position: noteParsed.position,
+            participantId: noteParsed.participantId,
+            lineNumber,
+            endLineNumber: lineNumber
+          };
+          bodyStarted = true;
+          currentContainer().push(note);
+          continue;
+        }
+        if (noteParsed.kind === "multi-head") {
+          const noteLines = [];
+          while (i + 1 < lines.length) {
+            const nextRaw = lines[i + 1];
+            const nextTrimmed = nextRaw.trim();
+            if (!nextTrimmed) break;
+            const nextIndent = measureIndent(nextRaw);
+            if (nextIndent <= indent) break;
+            noteLines.push(nextTrimmed);
+            i++;
+          }
+          if (noteLines.length === 0) continue;
+          const note = {
+            kind: "note",
+            text: noteLines.join("\n"),
+            position: noteParsed.position,
+            participantId: noteParsed.participantId,
+            lineNumber,
+            endLineNumber: i + 1
+            // i has advanced past the body lines (1-based)
+          };
+          bodyStarted = true;
+          currentContainer().push(note);
+          continue;
+        }
+        continue;
+      }
+    }
+    pushWarning(
+      lineNumber,
+      `Unexpected line: '${trimmed}'. Expected a message ('A -> B' or 'A -label-> B'), participant ('Name' or 'Name is a actor'), note ('note right of A Text'), section ('== Name =='), or block ('if/loop/parallel <label>').`
+    );
+  }
+  if (!hasExplicitChart && result.messages.length === 0) {
+    const hasArrows = lines.some((line) => ARROW_PATTERN.test(line.trim()));
+    if (!hasArrows) {
+      return fail(1, 'No "sequence" header and no sequence content detected');
+    }
+  }
+  if (result.messages.length > 0) {
+    const usedIds = /* @__PURE__ */ new Set();
+    for (const msg of result.messages) {
+      usedIds.add(msg.from);
+      usedIds.add(msg.to);
+    }
+    const walkElements = (elements) => {
+      for (const el of elements) {
+        if (isSequenceNote(el)) {
+          usedIds.add(el.participantId);
+        } else if (isSequenceBlock(el)) {
+          walkElements(el.children);
+          walkElements(el.elseChildren);
+          if (el.elseIfBranches) {
+            for (const branch of el.elseIfBranches) {
+              walkElements(branch.children);
+            }
+          }
+        }
+      }
+    };
+    walkElements(result.elements);
+    for (const p of result.participants) {
+      if (!usedIds.has(p.id)) {
+        pushWarning(
+          p.lineNumber,
+          `Participant "${p.label}" is declared but never used in any message or note`
+        );
+      }
+    }
+  }
+  for (const group of result.groups) {
+    if (group.participantIds.length === 0) {
+      pushWarning(
+        group.lineNumber,
+        `Empty group '${group.name}' \u2014 did you mean '== ${group.name} ==' for a section divider?`
+      );
+    }
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  if (result.tagGroups.length > 0) {
+    const entities = [];
+    for (const p of result.participants) {
+      if (p.metadata)
+        entities.push({ metadata: p.metadata, lineNumber: p.lineNumber });
+    }
+    for (const m of result.messages) {
+      if (m.metadata)
+        entities.push({ metadata: m.metadata, lineNumber: m.lineNumber });
+    }
+    for (const g of result.groups) {
+      if (g.metadata)
+        entities.push({ metadata: g.metadata, lineNumber: g.lineNumber });
+    }
+    validateTagValues(entities, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning, pushError);
+  }
+  return result;
+}
+function looksLikeSequence(content) {
+  if (!content) return false;
+  const lines = content.split("\n");
+  return lines.some((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//")) return false;
+    return ARROW_PATTERN.test(trimmed);
+  });
+}
+
+export {
+  isSequenceBlock,
+  isSequenceSection,
+  isSequenceNote,
+  parseSequenceDgmo,
+  looksLikeSequence
+};
+//# sourceMappingURL=chunk-SML67VPV.js.map