@miragon/event-storming-dsl 0.1.0

package/dist/index.cjs

@@ -0,0 +1,682 @@
+'use strict';
+
+var eventStormingSchemaModel = require('@miragon/event-storming-schema-model');
+
+// src/parser.ts
+
+// src/lexer.ts
+var COORDS_RE = /\[\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\]/;
+function parseCoords(line) {
+  const m = COORDS_RE.exec(line);
+  if (!m) return null;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (Number.isNaN(a) || Number.isNaN(b)) return null;
+  return { a, b };
+}
+function splitAtCoords(line) {
+  const m = COORDS_RE.exec(line);
+  if (!m) return null;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (Number.isNaN(a) || Number.isNaN(b)) return null;
+  return {
+    name: line.slice(0, m.index).trim(),
+    coords: { a, b },
+    suffix: line.slice(m.index + m[0].length)
+  };
+}
+var MULTI_COORDS_RE = /\[\s{0,8}(\[[^[\]]*\](?:\s{0,8},\s{0,8}\[[^[\]]*\])+)\s{0,8}\]/;
+function parseMultiCoords(line) {
+  const m = MULTI_COORDS_RE.exec(line);
+  if (!m) return null;
+  const tuples = [];
+  const inner = /\[\s{0,8}([-\d.]+)\s{0,8},\s{0,8}([-\d.]+)\s{0,8}\]/g;
+  let t;
+  while (t = inner.exec(m[1])) {
+    const a = Number(t[1]);
+    const b = Number(t[2]);
+    if (!Number.isNaN(a) && !Number.isNaN(b)) tuples.push({ a, b });
+  }
+  if (!tuples.length) return null;
+  return { tuples, rest: line.replace(MULTI_COORDS_RE, " ") };
+}
+function splitLineComment(line) {
+  let inQuote = false;
+  for (let i = 0; i < line.length - 1; i++) {
+    const ch = line[i];
+    if (ch === "'") inQuote = !inQuote;
+    else if (!inQuote && ch === "/" && line[i + 1] === "/" && line[i - 1] !== ":") {
+      return { code: line.slice(0, i), comment: line.slice(i) };
+    }
+  }
+  return { code: line, comment: null };
+}
+function indexOfOutsideQuotes(line, needle) {
+  let inQuote = false;
+  for (let i = 0; i + needle.length <= line.length; i++) {
+    const ch = line[i];
+    if (ch === "'") {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (!inQuote && line.startsWith(needle, i)) return i;
+  }
+  return -1;
+}
+var COLOR_RE = /\(\s*color\s+(#[0-9a-fA-F]{3,8}|[a-zA-Z][\w-]*)\s*\)/i;
+function parseColor(line) {
+  const m = COLOR_RE.exec(line);
+  if (!m || !m[1]) return { rest: line };
+  return { color: m[1], rest: line.replace(COLOR_RE, " ") };
+}
+var ON_RE = /\(\s*on\s+/i;
+function parseOn(line) {
+  const m = ON_RE.exec(line);
+  if (!m) return { rest: line };
+  const start = m.index + m[0].length;
+  const close = line.lastIndexOf(")");
+  if (close < start) return { rest: line };
+  const host = line.slice(start, close).trim();
+  if (!host) return { rest: line };
+  return { host, rest: `${line.slice(0, m.index)} ${line.slice(close + 1)}` };
+}
+var ID_CHARSET_RE = /^[A-Za-z0-9_-]+$/;
+var ID_RE = /\(\s*id\s+([A-Za-z0-9_-]+)\s*\)/i;
+var ID_PRESENT_RE = /\(\s*id\b[^)]*\)/i;
+function parseId(line) {
+  const m = ID_RE.exec(line);
+  if (m?.[1]) return { id: m[1], rest: line.replace(ID_RE, " ") };
+  const p = ID_PRESENT_RE.exec(line);
+  if (!p) return { rest: line };
+  return { invalid: p[0], rest: line.replace(ID_PRESENT_RE, " ") };
+}
+var SIZE_RE = /\(\s*size\s+([\d.]+)\s*x\s*([\d.]+)\s*\)/i;
+var SIZE_PRESENT_RE = /\(\s*size\b[^)]*\)/i;
+function parseSize(line) {
+  const m = SIZE_RE.exec(line);
+  if (m) {
+    const width = Number(m[1]);
+    const height = Number(m[2]);
+    if (width > 0 && height > 0) {
+      return { size: { width, height }, rest: line.replace(SIZE_RE, " ") };
+    }
+  }
+  const p = SIZE_PRESENT_RE.exec(line);
+  if (!p) return { rest: line };
+  return { invalid: p[0], rest: line.replace(SIZE_PRESENT_RE, " ") };
+}
+var ALIGN_RE = /\(\s*align\s+(left|center|right)\s+(top|middle|bottom)\s*\)/i;
+var ALIGN_PRESENT_RE = /\(\s*align\b[^)]*\)/i;
+function parseAlign(line) {
+  const m = ALIGN_RE.exec(line);
+  if (m) {
+    return {
+      align: {
+        horizontal: m[1].toLowerCase(),
+        vertical: m[2].toLowerCase()
+      },
+      rest: line.replace(ALIGN_RE, " ")
+    };
+  }
+  const p = ALIGN_PRESENT_RE.exec(line);
+  if (!p) return { rest: line };
+  return { invalid: p[0], rest: line.replace(ALIGN_PRESENT_RE, " ") };
+}
+function keywordOf(line) {
+  const m = /^\s*([A-Za-z][\w-]*)/.exec(line);
+  return m ? m[1].toLowerCase() : "";
+}
+function slug(label) {
+  return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_/, "").replace(/_$/, "") || "x";
+}
+
+// src/parser.ts
+function splitArrow(core) {
+  const arrow = core.indexOf("->");
+  if (arrow <= 0) return null;
+  const left = core.slice(0, arrow).trim();
+  const right = core.slice(arrow + 2).trim();
+  return left && right ? { left, right } : null;
+}
+var KNOWN_STYLES = /* @__PURE__ */ new Set(["classic", "dark"]);
+var ATTACHABLE_KINDS = new Set(eventStormingSchemaModel.ATTACHABLE_STICKY_KINDS);
+var HOST_KINDS = new Set(eventStormingSchemaModel.HOST_STICKY_KINDS);
+var KNOWN_LEVELS = /* @__PURE__ */ new Set(["big-picture", "process", "design"]);
+function decodeName(name) {
+  return name.replace(/\\n/g, "\n");
+}
+var STICKY_ID_PREFIXES = {
+  event: "event",
+  command: "cmd",
+  actor: "actor",
+  aggregate: "agg",
+  policy: "policy",
+  readmodel: "read",
+  external: "ext",
+  hotspot: "hot"
+};
+var STICKY_KINDS = new Set(Object.keys(STICKY_ID_PREFIXES));
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function modelAlign(align) {
+  if (!align) return void 0;
+  const out = compact({
+    horizontal: align.horizontal === "left" ? void 0 : align.horizontal,
+    vertical: align.vertical === "top" ? void 0 : align.vertical
+  });
+  return Object.keys(out).length ? out : void 0;
+}
+var IdAllocator = class {
+  used = /* @__PURE__ */ new Set();
+  /** Explicit `(id …)` — false when the id is already taken (caller reports + allocates). */
+  claim(id) {
+    if (this.used.has(id)) return false;
+    this.used.add(id);
+    return true;
+  }
+  alloc(prefix, label) {
+    const base = `${prefix}_${slug(label)}`;
+    let id = base;
+    let i = 2;
+    while (this.used.has(id)) id = `${base}_${i++}`;
+    this.used.add(id);
+    return id;
+  }
+};
+function parseDSL(text) {
+  return parseDSLWithDiagnostics(text).board;
+}
+function parseDSLWithDiagnostics(text) {
+  const diagnostics = [];
+  const ids = new IdAllocator();
+  const nameToId = /* @__PURE__ */ new Map();
+  const elements = [];
+  const rawPassthrough = [];
+  const pendingArrows = [];
+  const pendingAttachments = [];
+  let config = { title: "Untitled Board" };
+  let inBlockComment = false;
+  const register = (name, id) => {
+    if (!nameToId.has(name)) nameToId.set(name, id);
+  };
+  let lineNo = 0;
+  let currentLine = "";
+  const pushArrow = (line) => {
+    const semi = line.indexOf(";");
+    const core = semi >= 0 ? line.slice(0, semi).trim() : line;
+    const arrowLabel = semi >= 0 ? line.slice(semi + 1).trim() : "";
+    const arrow = splitArrow(core);
+    if (!arrow) return false;
+    pendingArrows.push({
+      left: arrow.left,
+      right: arrow.right,
+      ...arrowLabel ? { label: arrowLabel } : {},
+      raw: line,
+      lineNo
+    });
+    return true;
+  };
+  const diag = (message, atLine = lineNo, text_ = currentLine) => diagnostics.push({ line: atLine, message, text: text_ });
+  const failed = (l) => {
+    rawPassthrough.push(l);
+    diag("Line could not be interpreted (kept losslessly in rawPassthrough)");
+  };
+  const pos = (x, y) => ({ x, y });
+  const sourceLines = text.split(/\r?\n/);
+  for (let i = 0; i < sourceLines.length; i++) {
+    const raw = sourceLines[i];
+    lineNo = i + 1;
+    currentLine = raw.trim();
+    let working = raw;
+    if (inBlockComment) {
+      const close = working.indexOf("*/");
+      if (close < 0) {
+        rawPassthrough.push(raw);
+        continue;
+      }
+      rawPassthrough.push(working.slice(0, close + 2));
+      working = working.slice(close + 2);
+      inBlockComment = false;
+    }
+    let open = indexOfOutsideQuotes(working, "/*");
+    while (open >= 0) {
+      const close = working.indexOf("*/", open + 2);
+      if (close < 0) {
+        rawPassthrough.push(working.slice(open));
+        working = working.slice(0, open);
+        inBlockComment = true;
+        break;
+      }
+      rawPassthrough.push(working.slice(open, close + 2));
+      working = `${working.slice(0, open)} ${working.slice(close + 2)}`;
+      open = indexOfOutsideQuotes(working, "/*");
+    }
+    const { code, comment } = splitLineComment(working);
+    if (comment !== null) rawPassthrough.push(comment);
+    working = code;
+    const line = working.trim();
+    if (!line) continue;
+    const kw = keywordOf(line);
+    const after = line.slice(kw.length).trim();
+    const semi = line.indexOf(";");
+    const beforeAnnotation = semi >= 0 ? line.slice(0, semi) : line;
+    const titleAsArrow = () => {
+      const arrow = splitArrow(beforeAnnotation.trim());
+      return arrow !== null && nameToId.has(decodeName(arrow.left));
+    };
+    if ((kw !== "title" || titleAsArrow()) && !parseCoords(beforeAnnotation) && pushArrow(line)) {
+      continue;
+    }
+    switch (kw) {
+      case "title":
+        config = { ...config, title: after };
+        break;
+      case "style": {
+        const s = after.toLowerCase();
+        if (KNOWN_STYLES.has(s)) config = { ...config, style: s };
+        else failed(line);
+        break;
+      }
+      case "level": {
+        const l = after.toLowerCase();
+        if (KNOWN_LEVELS.has(l)) config = { ...config, level: l };
+        else failed(line);
+        break;
+      }
+      case "event":
+      case "command":
+      case "actor":
+      case "aggregate":
+      case "policy":
+      case "readmodel":
+      case "external":
+      case "hotspot": {
+        const node = parseSticky(after);
+        if (!node) {
+          failed(line);
+          break;
+        }
+        if (node.idInvalid) {
+          diag(
+            `Id: could not read "${node.idInvalid.trim()}" \u2014 expected (id <id>) with letters, digits, '_' or '-'`
+          );
+        }
+        const explicit = node.id !== void 0 && ids.claim(node.id) ? node.id : void 0;
+        if (node.id !== void 0 && explicit === void 0) {
+          diag(`Id: "${node.id}" is already taken \u2014 the element got a fresh id`);
+        }
+        const id = explicit ?? ids.alloc(STICKY_ID_PREFIXES[kw], node.name);
+        elements.push(
+          compact({
+            id,
+            elementType: kw,
+            label: node.name,
+            position: pos(node.coords.x, node.coords.y),
+            color: node.color
+          })
+        );
+        register(node.name, id);
+        if (node.host !== void 0) {
+          if (ATTACHABLE_KINDS.has(kw)) {
+            pendingAttachments.push({
+              index: elements.length - 1,
+              host: node.host,
+              raw: line,
+              lineNo
+            });
+          } else {
+            diag(`Attachment: a ${kw} cannot be pinned \u2014 only actor/hotspot/note support (on \u2026)`);
+          }
+        }
+        if (node.sizeSuffix) {
+          diag(`Size: a ${kw} cannot be resized \u2014 only notes support (size \u2026)`);
+        }
+        if (node.alignSuffix) {
+          diag(`Align: a ${kw} cannot be aligned \u2014 only notes support (align \u2026)`);
+        }
+        break;
+      }
+      case "note": {
+        const split = splitAtCoords(after);
+        if (!split && after.includes("[")) {
+          failed(line);
+          break;
+        }
+        const on = parseOn(split ? split.suffix : after);
+        const al = parseAlign(on.rest);
+        const sz = parseSize(al.rest);
+        const idp = parseId(sz.rest);
+        const col = parseColor(idp.rest);
+        if (al.invalid) {
+          diag(
+            `Align: could not read "${al.invalid.trim()}" \u2014 expected (align left|center|right top|middle|bottom)`
+          );
+        }
+        if (sz.invalid) {
+          diag(
+            `Size: could not read "${sz.invalid.trim()}" \u2014 expected (size <w>x<h>) with positive numbers`
+          );
+        }
+        if (idp.id !== void 0 || idp.invalid) {
+          diag("Id: a note cannot be referenced \u2014 only sticky kinds support (id \u2026)");
+        }
+        const textPart = decodeName((split ? split.name : col.rest).trim());
+        const id = ids.alloc("note", textPart || "note");
+        const note = compact({
+          id,
+          elementType: "note",
+          label: textPart,
+          position: split ? pos(split.coords.a, split.coords.b) : pos(0, 0),
+          color: col.color,
+          size: sz.size,
+          align: modelAlign(al.align)
+        });
+        elements.push(note);
+        if (on.host !== void 0) {
+          pendingAttachments.push({ index: elements.length - 1, host: on.host, raw: line, lineNo });
+        }
+        break;
+      }
+      case "line": {
+        const col = parseColor(after);
+        const multi = parseMultiCoords(col.rest);
+        if (!multi || multi.tuples.length < 2) {
+          failed(line);
+          break;
+        }
+        const onDrawing = parseOn(multi.rest);
+        if (onDrawing.host !== void 0) {
+          diag("Attachment: a drawing cannot be pinned \u2014 only actor/hotspot/note support (on \u2026)");
+        }
+        const szDrawing = parseSize(onDrawing.rest);
+        if (szDrawing.size || szDrawing.invalid) {
+          diag("Size: a drawing cannot be resized \u2014 only notes support (size \u2026)");
+        }
+        const alDrawing = parseAlign(onDrawing.rest);
+        if (alDrawing.align || alDrawing.invalid) {
+          diag("Align: a drawing cannot be aligned \u2014 only notes support (align \u2026)");
+        }
+        const idDrawing = parseId(onDrawing.rest);
+        if (idDrawing.id !== void 0 || idDrawing.invalid) {
+          diag("Id: a drawing cannot be referenced \u2014 only sticky kinds support (id \u2026)");
+        }
+        const flags = onDrawing.rest.toLowerCase();
+        const strokeStyle = flags.includes("(dashed)") ? "dashed" : flags.includes("(dotted)") ? "dotted" : void 0;
+        const points = multi.tuples.map((t) => pos(t.a, t.b));
+        const drawing = {
+          id: ids.alloc("draw", "line"),
+          elementType: "drawing",
+          label: "",
+          position: points[0],
+          points,
+          ...flags.includes("(closed)") ? { closed: true } : {},
+          ...strokeStyle ? { strokeStyle } : {},
+          ...col.color ? { color: col.color } : {}
+        };
+        elements.push(drawing);
+        break;
+      }
+      default: {
+        if (!pushArrow(line)) rawPassthrough.push(line);
+      }
+    }
+  }
+  const resolve = (token) => {
+    if (token.startsWith("#")) {
+      const id2 = token.slice(1);
+      return elements.find((e) => e.id === id2);
+    }
+    const id = nameToId.get(decodeName(token));
+    return id !== void 0 ? elements.find((e) => e.id === id) : void 0;
+  };
+  for (const att of pendingAttachments) {
+    const host = resolve(att.host);
+    if (!host) {
+      diag(`Attachment: "${att.host}" not found`, att.lineNo, att.raw);
+      continue;
+    }
+    if (!HOST_KINDS.has(host.elementType)) {
+      diag(
+        `Attachment: "${att.host}" is a ${host.elementType} \u2014 actors/hotspots/notes may only attach to host stickies`,
+        att.lineNo,
+        att.raw
+      );
+      continue;
+    }
+    elements[att.index] = { ...elements[att.index], attachedTo: host.id };
+  }
+  let arrowN = 0;
+  const elementIds = new Set(elements.map((e) => e.id));
+  const nextArrowId = () => {
+    let id = `arrow_${++arrowN}`;
+    while (elementIds.has(id)) id = `arrow_${++arrowN}`;
+    return id;
+  };
+  const edges = [];
+  for (const arrow of pendingArrows) {
+    const from = resolve(arrow.left);
+    const to = resolve(arrow.right);
+    if (!from || !to) {
+      rawPassthrough.push(arrow.raw);
+      diag(
+        `Arrow: ${!from ? `"${arrow.left}"` : `"${arrow.right}"`} not found`,
+        arrow.lineNo,
+        arrow.raw
+      );
+      continue;
+    }
+    const nonSticky = !STICKY_KINDS.has(from.elementType) ? [arrow.left, from] : !STICKY_KINDS.has(to.elementType) ? [arrow.right, to] : void 0;
+    if (nonSticky) {
+      rawPassthrough.push(arrow.raw);
+      diag(
+        `Arrow: "${nonSticky[0]}" is a ${nonSticky[1].elementType} \u2014 arrows may only connect stickies`,
+        arrow.lineNo,
+        arrow.raw
+      );
+      continue;
+    }
+    edges.push(
+      compact({
+        id: nextArrowId(),
+        edgeType: "arrow",
+        from: from.id,
+        to: to.id,
+        label: arrow.label
+      })
+    );
+  }
+  const board = compact({
+    schemaVersion: eventStormingSchemaModel.CURRENT_SCHEMA_VERSION,
+    config,
+    elements,
+    edges,
+    rawPassthrough: rawPassthrough.length ? rawPassthrough : void 0
+  });
+  return { board: eventStormingSchemaModel.validateBoard(board), diagnostics };
+}
+function parseSticky(after) {
+  const split = splitAtCoords(after);
+  if (split) {
+    if (!split.name) return null;
+    const on2 = parseOn(split.suffix);
+    const idp2 = parseId(on2.rest);
+    const al2 = parseAlign(idp2.rest);
+    const sz2 = parseSize(al2.rest);
+    const col2 = parseColor(sz2.rest);
+    return compact({
+      name: decodeName(split.name),
+      coords: { x: split.coords.a, y: split.coords.b },
+      color: col2.color ?? void 0,
+      host: on2.host,
+      id: idp2.id,
+      idInvalid: idp2.invalid,
+      sizeSuffix: sz2.size || sz2.invalid ? true : void 0,
+      alignSuffix: al2.align || al2.invalid ? true : void 0
+    });
+  }
+  if (after.includes("[")) return null;
+  const on = parseOn(after);
+  const idp = parseId(on.rest);
+  const al = parseAlign(idp.rest);
+  const sz = parseSize(al.rest);
+  const col = parseColor(sz.rest);
+  const name = col.rest.trim();
+  if (!name) return null;
+  return compact({
+    name: decodeName(name),
+    coords: { x: 0, y: 0 },
+    color: col.color ?? void 0,
+    host: on.host,
+    id: idp.id,
+    idInvalid: idp.invalid,
+    sizeSuffix: sz.size || sz.invalid ? true : void 0,
+    alignSuffix: al.align || al.invalid ? true : void 0
+  });
+}
+
+// src/serializer.ts
+function r(n) {
+  const v = Math.abs(n) < 1e21 ? Math.round(n * 1e3) / 1e3 : n;
+  return Math.abs(v) < 1e21 ? String(v) : BigInt(v).toString();
+}
+function escapeText(label) {
+  return label.trim().replace(/\n/g, "\\n").replace(/(?<!:)\/\//g, "\u2215\u2215").replace(/\/\*/g, "\u2215*");
+}
+function escapeName(label) {
+  return escapeText(label).replace(/->/g, "\u2192");
+}
+var NAMED_TYPES = /* @__PURE__ */ new Set([
+  "event",
+  "command",
+  "actor",
+  "aggregate",
+  "policy",
+  "readmodel",
+  "external",
+  "hotspot"
+]);
+var DEFAULT_NAMES = {
+  event: "Domain Event",
+  command: "Command",
+  actor: "Actor",
+  aggregate: "Aggregate",
+  policy: "Policy",
+  readmodel: "Read Model",
+  external: "External System",
+  hotspot: "Hotspot"
+};
+function defaultName(type) {
+  return DEFAULT_NAMES[type] ?? "Sticky";
+}
+function serializedNames(board) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const el of board.elements) {
+    if (!NAMED_TYPES.has(el.elementType)) continue;
+    byId.set(el.id, escapeName(el.label) || defaultName(el.elementType));
+  }
+  return byId;
+}
+function colorSuffix(el) {
+  return el.color ? ` (color ${el.color})` : "";
+}
+function alignSuffix(el) {
+  const horizontal = el.align?.horizontal ?? "left";
+  const vertical = el.align?.vertical ?? "top";
+  return horizontal === "left" && vertical === "top" ? "" : ` (align ${horizontal} ${vertical})`;
+}
+function serializeDSL(board) {
+  const lines = [];
+  const names = serializedNames(board);
+  const nameOf = (el) => names.get(el.id) ?? el.label;
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const name of names.values()) nameCount.set(name, (nameCount.get(name) ?? 0) + 1);
+  const needsId = (id) => {
+    const name = names.get(id);
+    return name !== void 0 && (nameCount.get(name) > 1 || name.startsWith("#"));
+  };
+  const emitIds = /* @__PURE__ */ new Map();
+  const taken = new Set(board.elements.map((e) => e.id));
+  for (const el of board.elements) {
+    if (!needsId(el.id) || ID_CHARSET_RE.test(el.id)) continue;
+    let candidate = slug(el.id);
+    for (let i = 2; taken.has(candidate); i++) candidate = `${slug(el.id)}_${i}`;
+    taken.add(candidate);
+    emitIds.set(el.id, candidate);
+  }
+  const idOf = (id) => emitIds.get(id) ?? id;
+  const ref = (id) => needsId(id) ? `#${idOf(id)}` : names.get(id) ?? id;
+  lines.push(`title ${board.config.title}`);
+  if (board.config.style) lines.push(`style ${board.config.style}`);
+  if (board.config.level) lines.push(`level ${board.config.level}`);
+  const onSuffix = (el) => {
+    const hostId = el.elementType === "actor" || el.elementType === "hotspot" || el.elementType === "note" ? el.attachedTo : void 0;
+    return hostId ? ` (on ${ref(hostId)})` : "";
+  };
+  for (const el of board.elements) {
+    const idSuffix = needsId(el.id) ? ` (id ${idOf(el.id)})` : "";
+    lines.push(elementLine(el, nameOf(el), idSuffix, onSuffix(el)));
+  }
+  for (const edge of board.edges) {
+    const annotation = edge.label ? `; ${edge.label}` : "";
+    lines.push(`${ref(edge.from)} -> ${ref(edge.to)}${annotation}`);
+  }
+  if (board.rawPassthrough) {
+    const emitted = /* @__PURE__ */ new Set(["title"]);
+    if (board.config.style) emitted.add("style");
+    if (board.config.level) emitted.add("level");
+    for (const raw of board.rawPassthrough) {
+      if (emitted.has(raw.trim().split(/\s+/)[0])) continue;
+      lines.push(raw);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function elementLine(el, name, idSuffix, attach) {
+  const p = el.position;
+  switch (el.elementType) {
+    case "event":
+    case "command":
+    case "actor":
+    case "aggregate":
+    case "policy":
+    case "readmodel":
+    case "external":
+    case "hotspot":
+      return `${el.elementType} ${name} [${r(p.x)}, ${r(p.y)}]${colorSuffix(el)}${idSuffix}${attach}`;
+    case "note": {
+      const size = el.size ? ` (size ${r(el.size.width)}x${r(el.size.height)})` : "";
+      return `note ${escapeText(name)} [${r(p.x)}, ${r(p.y)}]${colorSuffix(el)}${size}${alignSuffix(el)}${attach}`;
+    }
+    case "drawing": {
+      const pts = el.points.map((q) => `[${r(q.x)}, ${r(q.y)}]`).join(", ");
+      const closed = el.closed ? " (closed)" : "";
+      const stroke = el.strokeStyle && el.strokeStyle !== "solid" ? ` (${el.strokeStyle})` : "";
+      return `line [${pts}]${closed}${stroke}${colorSuffix(el)}`;
+    }
+  }
+}
+
+Object.defineProperty(exports, "boardFromJSON", {
+  enumerable: true,
+  get: function () { return eventStormingSchemaModel.parseBoardJSON; }
+});
+Object.defineProperty(exports, "boardToJSON", {
+  enumerable: true,
+  get: function () { return eventStormingSchemaModel.serializeBoard; }
+});
+Object.defineProperty(exports, "loadBoard", {
+  enumerable: true,
+  get: function () { return eventStormingSchemaModel.loadBoard; }
+});
+exports.keywordOf = keywordOf;
+exports.parseCoords = parseCoords;
+exports.parseDSL = parseDSL;
+exports.parseDSLWithDiagnostics = parseDSLWithDiagnostics;
+exports.serializeDSL = serializeDSL;
+exports.slug = slug;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map