@diagrammo/dgmo 0.54.0 → 0.56.0

package/dist/{layout-search-LUI475P3.js → layout-search-I4VNIRGT.js}

@@ -1,22 +1,24 @@
-import {
-  groupedTierCandidates
-} from "./chunk-7U4OR7CD.js";
 import {
   EDGE_LABEL_FONT_SIZE,
-  NODE_HEIGHT,
-  NODE_WIDTH,
   computeNodeSize,
   measureEdgeLabel
-} from "./chunk-I47VHSPS.js";
+} from "./chunk-R7ECJQTB.js";
+import {
+  groupedTierCandidates
+} from "./chunk-W4EKQ2P6.js";
+import {
+  NODE_HEIGHT,
+  NODE_WIDTH
+} from "./chunk-WTTIODDV.js";
 import "./chunk-5HWPEYWB.js";
 import "./chunk-6EK55ART.js";
 import "./chunk-UU6LUYUH.js";
 import "./chunk-5DH3KYFH.js";
 import "./chunk-BMR4CIEO.js";
-import "./chunk-QZAW5SFH.js";
+import "./chunk-7NK42OIB.js";
 import "./chunk-4ASYQ347.js";
 import "./chunk-NOTA6TEI.js";
-import "./chunk-4W2PE66Q.js";
+import "./chunk-OLMWTJVU.js";
 import "./chunk-5WRI5ZAA.js";
 
 // src/boxes-and-lines/layout-search.ts
@@ -195,9 +197,9 @@ function layeredCandidates(parsed, sizes, opts) {
     const m = Math.floor(vals.length / 2);
     if (vals.length % 2 === 1) return vals[m];
     if (vals.length === 2) return (vals[0] + vals[1]) / 2;
-    const left = vals[m - 1] - vals[0];
-    const right = vals[vals.length - 1] - vals[m];
-    return left + right === 0 ? (vals[m - 1] + vals[m]) / 2 : (vals[m - 1] * right + vals[m] * left) / (left + right);
+    const left2 = vals[m - 1] - vals[0];
+    const right2 = vals[vals.length - 1] - vals[m];
+    return left2 + right2 === 0 ? (vals[m - 1] + vals[m]) / 2 : (vals[m - 1] * right2 + vals[m] * left2) / (left2 + right2);
   };
   const wmedianRank = (r, useUp) => {
     const ids = ranks[r];
@@ -520,6 +522,275 @@ function layeredCandidates(parsed, sizes, opts) {
   }
 }
 
+// src/boxes-and-lines/layout-stable-collapse.ts
+var GROUP_PAD = 16;
+var GROUP_LABEL_ZONE = 32;
+var MARGIN2 = 40;
+var MIN_GAP = 36;
+var gid = (label) => `__group_${label}`;
+var left = (r) => r.x - r.width / 2;
+var right = (r) => r.x + r.width / 2;
+var top = (r) => r.y - r.height / 2;
+var bottom = (r) => r.y + r.height / 2;
+function bboxOf(rects) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const r of rects) {
+    x0 = Math.min(x0, left(r));
+    y0 = Math.min(y0, top(r));
+    x1 = Math.max(x1, right(r));
+    y1 = Math.max(y1, bottom(r));
+  }
+  return {
+    x: (x0 + x1) / 2,
+    y: (y0 + y1) / 2,
+    width: x1 - x0,
+    height: y1 - y0
+  };
+}
+function borderPoint(rect, toward) {
+  const dx = toward.x - rect.x;
+  const dy = toward.y - rect.y;
+  const sx = dx === 0 ? Infinity : rect.width / 2 / Math.abs(dx);
+  const sy = dy === 0 ? Infinity : rect.height / 2 / Math.abs(dy);
+  const s = Math.min(sx, sy);
+  if (!Number.isFinite(s)) return { x: rect.x, y: rect.y };
+  return { x: rect.x + dx * s, y: rect.y + dy * s };
+}
+function tryStableCollapseLayout(input) {
+  const {
+    parsed,
+    collapseInfo,
+    collapsedGroupLabels,
+    previousPositions,
+    sizes
+  } = input;
+  const prev = previousPositions;
+  const rects = /* @__PURE__ */ new Map();
+  for (const n of parsed.nodes) {
+    const p = prev.get(n.label);
+    const s = sizes.get(n.label);
+    if (!p || !s) return null;
+    rects.set(n.label, { x: p.x, y: p.y, width: s.width, height: s.height });
+  }
+  const ogByLabel = /* @__PURE__ */ new Map();
+  for (const g of collapseInfo.originalGroups) ogByLabel.set(g.label, g);
+  const descendantNodes = (label, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(label)) return [];
+    seen.add(label);
+    const g = ogByLabel.get(label);
+    if (!g) return [];
+    const out = [];
+    for (const c of g.children) {
+      if (ogByLabel.has(c)) out.push(...descendantNodes(c, seen));
+      else out.push(c);
+    }
+    return out;
+  };
+  const newlyCollapsed = [];
+  for (const label of collapsedGroupLabels) {
+    const own = prev.get(gid(label));
+    if (own) {
+      rects.set(gid(label), {
+        x: own.x,
+        y: own.y,
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT
+      });
+      continue;
+    }
+    const members = descendantNodes(label);
+    if (members.length === 0) return null;
+    const memberRects = [];
+    for (const m of members) {
+      const p = prev.get(m);
+      if (!p) return null;
+      memberRects.push({
+        x: p.x,
+        y: p.y,
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT
+      });
+    }
+    const bbox = bboxOf(memberRects);
+    rects.set(gid(label), {
+      x: bbox.x,
+      y: bbox.y,
+      width: NODE_WIDTH,
+      height: NODE_HEIGHT
+    });
+    newlyCollapsed.push({ label, memberBbox: bbox });
+  }
+  const groupByLabel = new Map(parsed.groups.map((g) => [g.label, g]));
+  const inUnit = /* @__PURE__ */ new Set();
+  const unitKeys = (label, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(label)) return [];
+    seen.add(label);
+    const g = groupByLabel.get(label);
+    if (!g) return [];
+    const out = [];
+    for (const c of g.children) {
+      if (groupByLabel.has(c)) out.push(...unitKeys(c, seen));
+      else if (rects.has(c)) out.push(c);
+      else if (rects.has(gid(c))) out.push(gid(c));
+    }
+    return out;
+  };
+  const units = [];
+  for (const g of parsed.groups) {
+    if (g.parentGroup) continue;
+    const keys = unitKeys(g.label);
+    if (keys.length === 0) continue;
+    for (const k of keys) inUnit.add(k);
+    units.push(keys);
+  }
+  for (const key of rects.keys()) if (!inUnit.has(key)) units.push([key]);
+  const axes = ["x", "y"];
+  for (const { label, memberBbox } of newlyCollapsed) {
+    const pill = rects.get(gid(label));
+    for (const axis of axes) {
+      const size = axis === "x" ? "width" : "height";
+      const perpMin = axis === "x" ? top : left;
+      const perpMax = axis === "x" ? bottom : right;
+      const axMin = axis === "x" ? left : top;
+      const axMax = axis === "x" ? right : bottom;
+      const reclaim = memberBbox[size] - pill[size];
+      if (reclaim <= 0) continue;
+      const unitBbox = (keys) => bboxOf(keys.map((k) => rects.get(k)));
+      const sliding = [];
+      const staticRects = [];
+      for (const u of units) {
+        const b = unitBbox(u);
+        if (axMin(b) >= pill[axis] && !u.includes(gid(label))) sliding.push(u);
+        else staticRects.push(...u.map((k) => rects.get(k)));
+      }
+      if (sliding.length === 0) continue;
+      let delta = reclaim;
+      for (const u of sliding) {
+        const b = unitBbox(u);
+        for (const s of staticRects) {
+          const overlaps = perpMin(b) < perpMax(s) - 4 && perpMax(b) > perpMin(s) + 4;
+          if (!overlaps || axMax(s) > axMin(b)) continue;
+          delta = Math.min(delta, axMin(b) - axMax(s) - MIN_GAP);
+        }
+      }
+      if (delta <= 0) continue;
+      for (const u of sliding)
+        for (const k of u) {
+          const r = rects.get(k);
+          rects.set(k, { ...r, [axis]: r[axis] - delta });
+        }
+    }
+  }
+  const groupRect = /* @__PURE__ */ new Map();
+  const buildGroupRect = (label, seen = /* @__PURE__ */ new Set()) => {
+    if (groupRect.has(label)) return groupRect.get(label);
+    if (seen.has(label)) return null;
+    seen.add(label);
+    const g = groupByLabel.get(label);
+    if (!g) return null;
+    const memberRects = [];
+    for (const c of g.children) {
+      if (groupByLabel.has(c)) {
+        const sub = buildGroupRect(c, seen);
+        if (sub) memberRects.push(sub);
+      } else if (rects.has(c)) memberRects.push(rects.get(c));
+      else if (rects.has(gid(c))) memberRects.push(rects.get(gid(c)));
+    }
+    if (memberRects.length === 0) return null;
+    const b = bboxOf(memberRects);
+    const rect = {
+      x: b.x,
+      y: b.y - GROUP_LABEL_ZONE / 2,
+      width: b.width + 2 * GROUP_PAD,
+      height: b.height + 2 * GROUP_PAD + GROUP_LABEL_ZONE
+    };
+    groupRect.set(label, rect);
+    return rect;
+  };
+  for (const g of parsed.groups) if (!buildGroupRect(g.label)) return null;
+  const boxes = [...rects.values()];
+  for (let i = 0; i < boxes.length; i++)
+    for (let j = i + 1; j < boxes.length; j++) {
+      const a = boxes[i];
+      const b = boxes[j];
+      if (Math.abs(a.x - b.x) < (a.width + b.width) / 2 - 4 && Math.abs(a.y - b.y) < (a.height + b.height) / 2 - 4)
+        return null;
+    }
+  const endpointRect = (key) => {
+    const direct = rects.get(key);
+    if (direct) return direct;
+    if (key.startsWith("__group_")) {
+      const label = key.slice("__group_".length);
+      return groupRect.get(label) ?? null;
+    }
+    return groupRect.get(key) ?? null;
+  };
+  const edges = [];
+  for (const e of parsed.edges) {
+    const sr = endpointRect(e.source);
+    const tr = endpointRect(e.target);
+    if (!sr || !tr) return null;
+    edges.push({
+      source: e.source,
+      target: e.target,
+      ...e.label !== void 0 && { label: e.label },
+      bidirectional: e.bidirectional,
+      lineNumber: e.lineNumber,
+      points: [borderPoint(sr, tr), borderPoint(tr, sr)],
+      yOffset: 0,
+      parallelCount: 1,
+      metadata: e.metadata
+    });
+  }
+  const allRects = [...rects.values(), ...groupRect.values()];
+  const total = bboxOf(allRects);
+  const dx = MARGIN2 - left(total);
+  const dy = MARGIN2 - top(total);
+  const shift = (r) => ({ ...r, x: r.x + dx, y: r.y + dy });
+  const nodes = parsed.nodes.map((n) => {
+    const r = shift(rects.get(n.label));
+    return { label: n.label, x: r.x, y: r.y, width: r.width, height: r.height };
+  });
+  const groups = parsed.groups.map((g) => {
+    const r = shift(groupRect.get(g.label));
+    return {
+      label: g.label,
+      lineNumber: g.lineNumber,
+      x: r.x,
+      y: r.y,
+      width: r.width,
+      height: r.height,
+      collapsed: false,
+      childCount: g.children.length
+    };
+  });
+  for (const label of collapsedGroupLabels) {
+    const r = shift(rects.get(gid(label)));
+    groups.push({
+      label,
+      lineNumber: 0,
+      x: r.x,
+      y: r.y,
+      width: r.width,
+      height: r.height,
+      collapsed: true,
+      childCount: collapseInfo.collapsedChildCounts.get(label) ?? 0
+    });
+  }
+  const shiftedEdges = edges.map((e) => ({
+    ...e,
+    points: e.points.map((p) => ({ x: p.x + dx, y: p.y + dy }))
+  }));
+  const shiftedTotal = shift(total);
+  return {
+    nodes,
+    edges: shiftedEdges,
+    groups,
+    width: right(shiftedTotal) + MARGIN2,
+    height: bottom(shiftedTotal) + MARGIN2
+  };
+}
+
 // src/boxes-and-lines/layout-search.ts
 var DEFAULT_LAMBDA = 4;
 var ESCALATE_THRESHOLD = 4;
@@ -873,7 +1144,7 @@ function countEdgeNearMiss(layout, opts) {
   const over = detectEdgeOverlaps(layout, { dist: tight, minLen }).length;
   return Math.max(0, close - over);
 }
-var GROUP_LABEL_ZONE = 32;
+var GROUP_LABEL_ZONE2 = 32;
 function detectGroupOverlaps(layout, opts) {
   const margin = opts?.margin ?? 4;
   const raw = layout.groups.map((g) => ({
@@ -886,7 +1157,7 @@ function detectGroupOverlaps(layout, opts) {
   const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
   const rend = raw.map((a, i) => {
     const parent = raw.some((b, j) => j !== i && contains(a, b));
-    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE } : a;
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE2 } : a;
   });
   const hit = /* @__PURE__ */ new Set();
   for (let i = 0; i < raw.length; i++)
@@ -913,7 +1184,7 @@ function countGroupOverlaps(layout, opts) {
   const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
   const rend = raw.map((a, i) => {
     const parent = raw.some((b, j) => j !== i && contains(a, b));
-    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE } : a;
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE2 } : a;
   });
   let count = 0;
   for (let i = 0; i < raw.length; i++)
@@ -956,7 +1227,7 @@ function separateGroupBands(layout, parsed) {
     let lo = (axis === "y" ? g.y : g.x) - half2;
     const hi = (axis === "y" ? g.y : g.x) + half2;
     const isParent = parsed.groups.some((c) => c.parentGroup === label);
-    if (axis === "y" && isParent) lo -= GROUP_LABEL_ZONE;
+    if (axis === "y" && isParent) lo -= GROUP_LABEL_ZONE2;
     return { label, lo, hi, c: (lo + hi) / 2 };
   });
   bands.sort((a, b) => a.c - b.c);
@@ -992,8 +1263,8 @@ function separateGroupBands(layout, parsed) {
   const nodeDelta = (label) => {
     if (label.startsWith("__group_"))
       return delta.get(topOf(label.slice("__group_".length))) ?? 0;
-    const top = nodeTop.get(label);
-    return top ? delta.get(top) ?? 0 : 0;
+    const top2 = nodeTop.get(label);
+    return top2 ? delta.get(top2) ?? 0 : 0;
   };
   const shift = (p, d) => axis === "y" ? { x: p.x, y: p.y + d } : { x: p.x + d, y: p.y };
   const nodes = layout.nodes.map((n) => {
@@ -1027,7 +1298,7 @@ function separateGroupBands(layout, parsed) {
     acc(n.x + n.width / 2, n.y + n.height / 2);
   }
   for (const g of groups) {
-    acc(g.x - g.width / 2, g.y - g.height / 2 - GROUP_LABEL_ZONE);
+    acc(g.x - g.width / 2, g.y - g.height / 2 - GROUP_LABEL_ZONE2);
     acc(g.x + g.width / 2, g.y + g.height / 2);
   }
   for (const e of edges) for (const p of e.points) acc(p.x, p.y);
@@ -1146,8 +1417,19 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
         sizes.set(node.label, { width: s.width, height: maxDescH });
       }
   }
-  const gid = (label) => `__group_${label}`;
+  const gid2 = (label) => `__group_${label}`;
   const rankdir = parsed.direction === "TB" ? "TB" : "LR";
+  if (opts?.stableCollapse && collapseInfo && collapsedGroupLabels.size > 0 && opts.previousPositions) {
+    const stable = tryStableCollapseLayout({
+      parsed,
+      collapseInfo,
+      collapsedGroupLabels,
+      previousPositions: opts.previousPositions,
+      sizes,
+      rankdir
+    });
+    if (stable) return stable;
+  }
   const nodeLabelSet = new Set(parsed.nodes.map((n2) => n2.label));
   const directNodeChildren = /* @__PURE__ */ new Map();
   const childGroupsOf = /* @__PURE__ */ new Map();
@@ -1205,8 +1487,8 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
       if (rankOf(mem) > rankOf(exit)) exit = mem;
       if (rankOf(mem) < rankOf(entry)) entry = mem;
     }
-    gidSourceRep.set(gid(grp.label), exit);
-    gidTargetRep.set(gid(grp.label), entry);
+    gidSourceRep.set(gid2(grp.label), exit);
+    gidTargetRep.set(gid2(grp.label), entry);
   }
   const srcRep = (label) => gidSourceRep.get(label) ?? label;
   const tgtRep = (label) => gidTargetRep.get(label) ?? label;
@@ -1236,25 +1518,25 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
     });
     g.setDefaultEdgeLabel(() => ({}));
     for (const grp of ord(parsed.groups))
-      g.setNode(gid(grp.label), { label: grp.label });
+      g.setNode(gid2(grp.label), { label: grp.label });
     for (const node of ord(parsed.nodes)) {
       const s = sizes.get(node.label);
       g.setNode(node.label, { width: s.width, height: s.height });
     }
     for (const label of collapsedGroupLabels)
-      g.setNode(gid(label), { width: NODE_WIDTH, height: NODE_HEIGHT });
+      g.setNode(gid2(label), { width: NODE_WIDTH, height: NODE_HEIGHT });
     for (const grp of parsed.groups) {
-      if (grp.parentGroup && g.hasNode(gid(grp.parentGroup)))
-        g.setParent(gid(grp.label), gid(grp.parentGroup));
+      if (grp.parentGroup && g.hasNode(gid2(grp.parentGroup)))
+        g.setParent(gid2(grp.label), gid2(grp.parentGroup));
       for (const c of ord(grp.children)) {
-        if (g.hasNode(c)) g.setParent(c, gid(grp.label));
+        if (g.hasNode(c)) g.setParent(c, gid2(grp.label));
       }
     }
     if (collapseInfo)
       for (const label of collapsedGroupLabels) {
         const og = collapseInfo.originalGroups.find((x) => x.label === label);
-        if (og?.parentGroup && !collapsedGroupLabels.has(og.parentGroup) && g.hasNode(gid(og.parentGroup)))
-          g.setParent(gid(label), gid(og.parentGroup));
+        if (og?.parentGroup && !collapsedGroupLabels.has(og.parentGroup) && g.hasNode(gid2(og.parentGroup)))
+          g.setParent(gid2(label), gid2(og.parentGroup));
       }
     for (const e of ord(parsed.edges)) {
       const s = srcRep(e.source);
@@ -1281,7 +1563,7 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
     });
     const groups = parsed.groups.map(
       (grp) => {
-        const p = g.node(gid(grp.label));
+        const p = g.node(gid2(grp.label));
         return {
           label: grp.label,
           lineNumber: grp.lineNumber,
@@ -1295,7 +1577,7 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
       }
     );
     for (const label of collapsedGroupLabels) {
-      const p = g.node(gid(label));
+      const p = g.node(gid2(label));
       groups.push({
         label,
         lineNumber: 0,
@@ -1309,9 +1591,9 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
     }
     const groupRectByGid = /* @__PURE__ */ new Map();
     for (const grp of parsed.groups) {
-      const p = g.node(gid(grp.label));
+      const p = g.node(gid2(grp.label));
       if (p)
-        groupRectByGid.set(gid(grp.label), {
+        groupRectByGid.set(gid2(grp.label), {
           x: p.x,
           y: p.y,
           w: p.width,
@@ -1422,9 +1704,11 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
   if (!pool.length)
     return place({ ranker: "network-simplex", nodesep: 50, ranksep: 60 });
   let layered = [];
-  try {
-    layered = layeredCandidates(parsed, sizes);
-  } catch {
+  if (collapsedGroupLabels.size === 0) {
+    try {
+      layered = layeredCandidates(parsed, sizes);
+    } catch {
+    }
   }
   if (parsed.groups.length > 0 && collapsedGroupLabels.size === 0) {
     try {
@@ -1522,4 +1806,4 @@ export {
   layoutBoxesAndLinesSearch,
   separateGroupBands
 };
-//# sourceMappingURL=layout-search-LUI475P3.js.map
+//# sourceMappingURL=layout-search-I4VNIRGT.js.map

package/dist/{legend-constants-B77VKB3R.js → legend-constants-QQU3QYBF.js}

@@ -21,11 +21,11 @@ import {
   legendChromeColors,
   measureLegendText,
   truncateLegendText
-} from "./chunk-Q5IHQ4NW.js";
+} from "./chunk-SCJ7CAJF.js";
 import "./chunk-4ASYQ347.js";
-import "./chunk-JYDMBWRP.js";
-import "./chunk-ZKPPI6BF.js";
-import "./chunk-4W2PE66Q.js";
+import "./chunk-42IT4BG2.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
 import "./chunk-5WRI5ZAA.js";
 export {
   CONTROLS_ICON_PATH,
@@ -51,4 +51,4 @@ export {
   measureLegendText,
   truncateLegendText
 };
-//# sourceMappingURL=legend-constants-B77VKB3R.js.map
+//# sourceMappingURL=legend-constants-QQU3QYBF.js.map

package/dist/{palettes-FGTNFARW.js → palettes-WO3VA6NU.js}

@@ -24,9 +24,9 @@ import {
   shapeFill,
   themeBaseBg,
   tint
-} from "./chunk-JYDMBWRP.js";
-import "./chunk-ZKPPI6BF.js";
-import "./chunk-4W2PE66Q.js";
+} from "./chunk-42IT4BG2.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
 import "./chunk-5WRI5ZAA.js";
 export {
   atlasPalette,
@@ -53,4 +53,4 @@ export {
   tint,
   tokyoNightPalette
 };
-//# sourceMappingURL=palettes-FGTNFARW.js.map
+//# sourceMappingURL=palettes-WO3VA6NU.js.map

package/dist/parser-4TX6U4ZU.js

@@ -0,0 +1,11 @@
+import {
+  parseVersionControl
+} from "./chunk-D64FRGKU.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseVersionControl
+};
+//# sourceMappingURL=parser-4TX6U4ZU.js.map

package/dist/{parser-X5XLFY4Z.js → parser-4ZIJDGPG.js}

@@ -3,15 +3,15 @@ import {
   looksLikePert,
   parseEdgeLabel,
   parsePert
-} from "./chunk-RRGKMJYL.js";
+} from "./chunk-DIKIHU52.js";
 import "./chunk-3TYUXC7D.js";
 import "./chunk-EQW6HOP4.js";
 import "./chunk-DAOFNU6J.js";
 import "./chunk-NOTA6TEI.js";
-import "./chunk-AHTTKERF.js";
-import "./chunk-3FRO35WW.js";
-import "./chunk-ZKPPI6BF.js";
-import "./chunk-4W2PE66Q.js";
+import "./chunk-D5FANMSG.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
 import "./chunk-5WRI5ZAA.js";
 export {
   extractPertSymbols,
@@ -19,4 +19,4 @@ export {
   parseEdgeLabel,
   parsePert
 };
-//# sourceMappingURL=parser-X5XLFY4Z.js.map
+//# sourceMappingURL=parser-4ZIJDGPG.js.map

package/dist/parser-5UZWYSIV.js

@@ -0,0 +1,16 @@
+import {
+  looksLikeSitemap,
+  parseSitemap
+} from "./chunk-OHBIN74X.js";
+import "./chunk-IYULMRBE.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-D5FANMSG.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  looksLikeSitemap,
+  parseSitemap
+};
+//# sourceMappingURL=parser-5UZWYSIV.js.map

package/dist/parser-6CM27UPA.js

@@ -0,0 +1,14 @@
+import {
+  parseFamily
+} from "./chunk-ES3MUYRX.js";
+import "./chunk-QQJUTGQH.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-D5FANMSG.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseFamily
+};
+//# sourceMappingURL=parser-6CM27UPA.js.map

package/dist/parser-73YUU35J.js

@@ -0,0 +1,11 @@
+import {
+  parsePyramid
+} from "./chunk-MGLJA5TK.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parsePyramid
+};
+//# sourceMappingURL=parser-73YUU35J.js.map

package/dist/parser-A6M25MLK.js

@@ -0,0 +1,11 @@
+import {
+  parseRing
+} from "./chunk-RV2N7COG.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseRing
+};
+//# sourceMappingURL=parser-A6M25MLK.js.map

package/dist/parser-AYZTKZC3.js

@@ -0,0 +1,11 @@
+import {
+  parseCycle
+} from "./chunk-4MB4UOT5.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseCycle
+};
+//# sourceMappingURL=parser-AYZTKZC3.js.map

package/dist/parser-CCAUZLYI.js

@@ -0,0 +1,15 @@
+import {
+  looksLikeOrg,
+  parseOrg
+} from "./chunk-PFG3EVRD.js";
+import "./chunk-NOTA6TEI.js";
+import "./chunk-D5FANMSG.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  looksLikeOrg,
+  parseOrg
+};
+//# sourceMappingURL=parser-CCAUZLYI.js.map

package/dist/parser-D7YZX3CH.js

@@ -0,0 +1,12 @@
+import {
+  parseClock
+} from "./chunk-YNAHUNMA.js";
+import "./chunk-A2RUBBVT.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseClock
+};
+//# sourceMappingURL=parser-D7YZX3CH.js.map

package/dist/parser-DQ2DGDYO.js

@@ -0,0 +1,11 @@
+import {
+  parseGoal
+} from "./chunk-5XMDSXZT.js";
+import "./chunk-3KOPPSUQ.js";
+import "./chunk-EXNKNJ65.js";
+import "./chunk-OLMWTJVU.js";
+import "./chunk-5WRI5ZAA.js";
+export {
+  parseGoal
+};
+//# sourceMappingURL=parser-DQ2DGDYO.js.map