@likec4/core 1.44.0 → 1.45.0

package/dist/shared/{core.23WeDKcI.mjs → core.CWwSgOzF.mjs}

@@ -1,32 +1,34 @@
-import { b as t$d, n as n$e, c as t$j, t as t$k, d as t$l, e as t$m, i as isElementModel, f as isNestedElementOfDeployedInstanceModel, g as isDeployedInstanceModel, h as isDeploymentNodeModel, j as isDeploymentElementModel, k as buildElementNotations, L as LikeC4Model, a as t$q } from './core.h4TqqSC0.mjs';
-import { t as t$b, a as t$c } from './core.BsSXS-_R.mjs';
-import { t as t$f } from './core.CbT8JVYL.mjs';
-import { c as commonHead, t as t$g, o as objectHash, b as t$n, a as compareRelations, S as Stack } from './core.DFCHU59b.mjs';
+import { n as n$d, b as t$i, d as t$k, e as t$l, f as t$n, g as buildElementNotations, t as t$q } from './core.vzLtp8i3.mjs';
+import { t as t$a, a as t$b } from './core.BsSXS-_R.mjs';
+import { t as t$e } from './core.CbT8JVYL.mjs';
+import { a as t$c, t as t$j, i as isElementModel, b as isNestedElementOfDeployedInstanceModel, c as isDeployedInstanceModel, d as isDeploymentNodeModel, e as isDeploymentElementModel, L as LikeC4Model } from './core.CRI1AjFj.mjs';
+import { c as commonHead, t as t$f, o as objectHash, b as t$m, a as compareRelations, S as Stack } from './core.DViDmiAu.mjs';
 import { a as nonNullable, i as invariant, n as nonexhaustive } from './core.D4npX2q8.mjs';
 import { G as Graph } from './core.DrUt0Lbi.mjs';
 import { r as requireIterables, e as exact, t as t$o } from './core.M9ayqQZa.mjs';
 import { r as requireIterator } from './core.BdPcbSkN.mjs';
 import { g as getDefaultExportFromCjs } from './core.B85MJLTf.mjs';
-import { n as n$d, t as t$e } from './core.OHD4KXm9.mjs';
+import { n as n$c, t as t$d } from './core.3ZhnKAlZ.mjs';
 import { e as e$4 } from './core.BKlholso.mjs';
 import { f as flattenMarkdownOrString, i as isGroupElementKind, G as GroupElementKind, d as stepEdgeId } from './core.C_Ni6yHl.mjs';
-import { b as isDescendantOf, f as sortParentsFirst, i as isAncestor, p as parentFqn, j as compareByFqnHierarchically, c as isNonEmptyArray, n as nameFromFqn, o as sortByFqnHierarchically, g as commonAncestor, a as ancestorsFqn, d as isSameHierarchy } from './core.6VsRBhGY.mjs';
-import { d as difference, i as intersection, u as union, h as hasIntersection } from './core.CbsSAn1j.mjs';
-import { e as e$8 } from './core.B9BjmjuH.mjs';
-import { e as e$5, n as n$f, d as deploymentConnection, R as RelationshipsAccum, D as DeploymentConnectionModel } from './core.CHwVhuc9.mjs';
-import { w as whereOperatorAsPredicate, m as isViewRuleStyle, v as t$h, l as isViewRulePredicate, a as _type, _ as _stage, u as e$b, t as isDynamicView, s as isDeploymentView, p as isElementView } from './core.DH7TXqXf.mjs';
+import { b as isDescendantOf, f as sortParentsFirst, i as isAncestor, p as parentFqn, j as compareByFqnHierarchically, c as isNonEmptyArray, n as nameFromFqn, o as sortByFqnHierarchically, g as commonAncestor, a as ancestorsFqn, d as isSameHierarchy } from './core.CdNCAwq7.mjs';
+import { d as difference, i as intersection, u as union, h as hasIntersection } from './core.DbfO90vF.mjs';
+import { e as e$8 } from './core.Coi_LOUZ.mjs';
+import { n as n$e } from './core.BhNcrwzK.mjs';
+import { w as whereOperatorAsPredicate, m as isViewRuleStyle, v as t$g, l as isViewRulePredicate, a as _type, _ as _stage, u as e$b, t as isDynamicView, s as isDeploymentView, p as isElementView } from './core.DH7TXqXf.mjs';
 import { e as e$6, a as iunique, i as iflat } from './core.C4x8aaWa.mjs';
+import { e as e$5, d as deploymentConnection, R as RelationshipsAccum, D as DeploymentConnectionModel } from './core.D_f4F48-.mjs';
 import { e as e$7 } from './core.BoYfZOBm.mjs';
 import { ModelFqnExpr, ModelRelationExpr, ModelExpression } from '../types/expression-model.mjs';
 import { FqnRef } from '../types/fqnRef.mjs';
 import { preferSummary } from '../types/_aux.mjs';
-import { a as t$i } from './core.DEieYfbG.mjs';
+import { a as t$h } from './core.DEieYfbG.mjs';
 import { FqnExpr, RelationExpr } from '../types/expression.mjs';
-import { f as findAscendingConnections, m as mergeConnections, d as differenceConnections, j as isNestedConnection, s as sortConnectionsByBoundaryHierarchy, o as findConnectionsBetween$3, p as findConnection$3, n as modelConnection, b as findDescendantConnections, a as findDeepestNestedConnection, i as isAnyInOut, k as isOutgoing, g as isIncoming, C as ConnectionModel } from './core.bKIs4oDO.mjs';
+import { f as findAscendingConnections, m as mergeConnections, d as differenceConnections, j as isNestedConnection, s as sortConnectionsByBoundaryHierarchy, o as findConnectionsBetween$3, p as findConnection$3, n as modelConnection, b as findDescendantConnections, a as findDeepestNestedConnection, i as isAnyInOut, k as isOutgoing, g as isIncoming, C as ConnectionModel } from './core.CQPEY2wQ.mjs';
 import { t as toSet, a as toArray, i as imap } from './core.C3JowhaZ.mjs';
 import { D as DefaultMap } from './core.BbE4y-yl.mjs';
 import { i as ifilter } from './core.DRJma0Ol.mjs';
-import { C as Connection, c as customInspectSymbol } from './core.C0Ye2OCr.mjs';
+import { C as Connection, c as customInspectSymbol } from './core.DqlrMlsf.mjs';
 import { i as isome } from './core.FZ305VYd.mjs';
 import { i as isIterable, e as e$9 } from './core.RfnaEmgA.mjs';
 import { j as e$a, c as isViewRuleAutoLayout, h as isViewRuleGroup, a as isViewRuleGlobalPredicateRef, i as isViewRuleGlobalStyle, e as isDynamicStepsParallel, f as isDynamicStepsSeries } from './core.BuQZczj6.mjs';
@@ -34,35 +36,33 @@ import { t as t$p } from './core.q10OP9oJ.mjs';
 
 function e$3(e){return ()=>e}
 
-function t$a(...t){return t$b(n$c,t)}function n$c(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return []}
+function t$9(...t){return t$a(n$b,t)}function n$b(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return []}
 
 const e$2=e=>Object.assign(e,{single:true});
 
-function t$9(...t){return t$b(n$b,t)}const n$b=(e,t)=>{for(let n=e.length-1;n>=0;n--){let r=e[n];if(t(r,n,e))return r}};
+function t$8(...t){return t$a(n$a,t)}const n$a=(e,t)=>{for(let n=e.length-1;n>=0;n--){let r=e[n];if(t(r,n,e))return r}};
 
-function n$a(...n){return t$b(r$3,n,e$2(i$1))}const r$3=([e])=>e,i$1=()=>a,a=e=>({hasNext:true,next:e,done:true});
+function n$9(...n){return t$a(r$3,n,e$2(i$1))}const r$3=([e])=>e,i$1=()=>a,a=e=>({hasNext:true,next:e,done:true});
 
-function t$8(...t){return t$b(n$9,t,r$2)}function n$9(e,t){return e.forEach(t),e}const r$2=e=>(t,n,r)=>(e(t,n,r),{done:false,hasNext:true,next:t});
+function t$7(...t){return t$a(n$8,t,r$2)}function n$8(e,t){return e.forEach(t),e}const r$2=e=>(t,n,r)=>(e(t,n,r),{done:false,hasNext:true,next:t});
 
 function e$1(e){return typeof e==`boolean`}
 
-function t$7(...t){return t$b(n$8,t)}function n$8(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o;}return n}
+function t$6(...t){return t$a(n$7,t)}function n$7(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o;}return n}
 
-function n$7(...t){return t$b(r$1,t)}function r$1(e,n){if(!t$c(n,1))return {...e};if(!t$c(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}
+function n$6(...t){return t$a(r$1,t)}function r$1(e,n){if(!t$b(n,1))return {...e};if(!t$b(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}
 
-function t$6(...t){return t$b(n$6,t)}const n$6=e=>e.length===1?e[0]:void 0;
+function t$5(...t){return t$a(n$5,t)}const n$5=e=>e.length===1?e[0]:void 0;
 
-function t$5(...t){return t$b(n$5,t)}const n$5=(e,t)=>{let n=[[],[]];for(let[r,i]of e.entries())t(i,r,e)?n[0].push(i):n[1].push(i);return n};
+function t$4(...t){return t$a(n$4,t)}const n$4=(e,t)=>{let n=[[],[]];for(let[r,i]of e.entries())t(i,r,e)?n[0].push(i):n[1].push(i);return n};
 
-function t$4(...t){return t$b(n$4,t)}function n$4(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}
+function t$3(...t){return t$a(n$3,t)}function n$3(e,t){let n={};for(let[r,i]of Object.entries(e))t(i,r,e)&&(n[r]=i);return n}
 
-function t$3(...t){return t$b(n$3,t)}function n$3(e,t){let n={};for(let[r,i]of Object.entries(e))t(i,r,e)&&(n[r]=i);return n}
+function t$2(...t){return t$a(n$2,t)}const n$2=(e,t,n)=>e.reduce(t,n);
 
-function t$2(...t){return t$b(n$2,t)}const n$2=(e,t,n)=>e.reduce(t,n);
+function t$1(...t){return t$a(n$1,t)}function n$1(e){return [...e].reverse()}
 
-function t$1(...t){return t$b(n$1,t)}function n$1(e){return [...e].reverse()}
-
-function n(...t){return t$b(r,t,i)}const r=(e,t)=>t<0?[]:e.slice(0,t);function i(e){if(e<=0)return n$d;let n=e;return e=>(--n,{done:n<=0,hasNext:true,next:e})}
+function n(...t){return t$a(r,t,i)}const r=(e,t)=>t<0?[]:e.slice(0,t);function i(e){if(e<=0)return n$c;let n=e;return e=>(--n,{done:n<=0,hasNext:true,next:e})}
 
 function e(...e){return e.length===2?(n,...r)=>t(n,...e,...r):t(...e)}const t=(e,t,n,...r)=>t(e,...r)?typeof n==`function`?n(e,...r):n.onTrue(e,...r):typeof n==`function`?e:n.onFalse(e,...r);
 
@@ -88,7 +88,7 @@ function linkNodesWithEdges(nodesMap, edges) {
     const sourceAncestors = ancestorsOfNode(source, nodesMap);
     const targetAncestors = ancestorsOfNode(target, nodesMap);
     const hasAncestors = sourceAncestors.length > 0 && targetAncestors.length > 0;
-    const edgeParent = hasAncestors ? t$d(
+    const edgeParent = hasAncestors ? t$c(
       commonHead(
         t$1(sourceAncestors),
         t$1(targetAncestors)
@@ -793,9 +793,9 @@ function topologicalSort(param) {
     allowSelfLoops: true,
     type: "directed"
   });
-  const enrichedEdges = t$e(
+  const enrichedEdges = t$d(
     edges,
-    t$f((edge) => {
+    t$e((edge) => {
       const source = getNode(edge.source), target = getNode(edge.target), parent = edge.parent ? getNode(edge.parent) : null;
       return {
         id: edge.id,
@@ -806,7 +806,7 @@ function topologicalSort(param) {
       };
     })
   );
-  const [edgesBetweenLeafs, edgesWithCompounds] = t$5(
+  const [edgesBetweenLeafs, edgesWithCompounds] = t$4(
     enrichedEdges,
     ({ source, target }) => source.children.length === 0 && target.children.length === 0
   );
@@ -822,10 +822,10 @@ function topologicalSort(param) {
   for (const { edge, source, target } of edgesBetweenLeafs) {
     addEdgeToGraph(edge);
     if (target.parent && target.parent !== edge.parent) {
-      t$e(
+      t$d(
         ancestorsOfNode(target, param.nodes),
-        t$g((ancestor) => ancestor.inEdges.includes(edge.id)),
-        t$8((ancestor) => {
+        t$f((ancestor) => ancestor.inEdges.includes(edge.id)),
+        t$7((ancestor) => {
           g.mergeNode(ancestor.id);
           if (!willCreateCycle(g, edge.source, ancestor.id)) {
             g.mergeDirectedEdge(edge.source, ancestor.id);
@@ -888,9 +888,9 @@ function calcViewLayoutHash(view) {
     id: view.id,
     __: view._type ?? "element",
     autoLayout: view.autoLayout,
-    nodes: t$e(
+    nodes: t$d(
       view.nodes,
-      t$f((n) => ({
+      t$e((n) => ({
         id: n.id,
         icon: e$4(n.icon) && n.icon !== "none" ? "Y" : "N",
         title: n.title,
@@ -902,11 +902,11 @@ function calcViewLayoutHash(view) {
         padding: n.style.padding ?? null,
         children: n.children
       })),
-      t$7(({ id, ...node }) => [id, node])
+      t$6(({ id, ...node }) => [id, node])
     ),
-    edges: t$e(
+    edges: t$d(
       view.edges,
-      t$f((e) => ({
+      t$e((e) => ({
         source: e.source,
         target: e.target,
         label: e.label,
@@ -917,7 +917,7 @@ function calcViewLayoutHash(view) {
         tail: e.tail,
         line: e.line
       })),
-      t$7(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+      t$6(({ source, target, ...edge }) => [`${source}:${target}`, edge])
     )
   };
   view.hash = objectHash(tohash);
@@ -1035,7 +1035,7 @@ class AbstractStageExclude {
       disconnected,
       state.elements
     );
-    disconnected = t$e(
+    disconnected = t$d(
       disconnected,
       ifilter((el) => {
         return state.explicits.has(el) && !isome(state.final, isDescendantOf(el));
@@ -1243,7 +1243,7 @@ class AbstractStageInclude {
     let state = this.precommit(this.memory.mutableState());
     let fromConnections = /* @__PURE__ */ new Set();
     if (this._connections.length > 0) {
-      const [fromKnown, rest] = t$5(
+      const [fromKnown, rest] = t$4(
         this._connections,
         (c) => state.final.has(c.source)
       );
@@ -1356,11 +1356,11 @@ function elementExprToPredicate(target) {
 function applyViewRuleStyle(rule, predicates, nodes) {
   const { shape, color, icon, ...rest } = rule.style;
   const nonEmptyStyle = !e$5(rest);
-  t$e(
+  t$d(
     nodes,
-    n$e(e$7(isGroupElementKind)),
-    n$e(t$h(predicates)),
-    t$8((n) => {
+    n$d(e$7(isGroupElementKind)),
+    n$d(t$g(predicates)),
+    t$7((n) => {
       n.shape = shape ?? n.shape;
       n.color = color ?? n.color;
       if (e$6(icon)) {
@@ -1405,7 +1405,7 @@ function elementModelToNodeSource(el) {
     id,
     title,
     ...rest
-  } = n$7(el.$element, ["summary", "description", "metadata", "style", "tags"]);
+  } = n$6(el.$element, ["summary", "description", "metadata", "style", "tags"]);
   const { color, icon, shape, ...style } = el.style;
   return exact({
     id,
@@ -1527,14 +1527,14 @@ function pickRelationshipProps(relation) {
   };
 }
 function mergePropsFromRelationships(relations, prefer) {
-  const allprops = t$e(
+  const allprops = t$d(
     relations,
     t$2(
       (acc, r) => {
         if (e$4(r.title) && !acc.title.includes(r.title)) {
           acc.title.push(r.title);
         }
-        if (e$4(r.description) && !acc.description.some(t$i(r.description))) {
+        if (e$4(r.description) && !acc.description.some(t$h(r.description))) {
           acc.description.push(r.description);
         }
         if (e$4(r.technology) && !acc.technology.includes(r.technology)) {
@@ -1577,20 +1577,20 @@ function mergePropsFromRelationships(relations, prefer) {
       }
     )
   );
-  let technology = t$6(allprops.technology);
-  let title = t$6(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : null);
-  const tags = n$f(allprops.tags);
+  let technology = t$5(allprops.technology);
+  let title = t$5(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : null);
+  const tags = n$e(allprops.tags);
   let merged = exact({
     // If there is no title, but there is technology, use technology as title
     title: title ?? (technology ? `[${technology}]` : null),
-    description: t$6(allprops.description),
+    description: t$5(allprops.description),
     technology,
-    kind: t$6(allprops.kind),
-    head: t$6(allprops.head),
-    tail: t$6(allprops.tail),
-    color: t$6(allprops.color),
-    line: t$6(allprops.line),
-    navigateTo: t$6(allprops.navigateTo),
+    kind: t$5(allprops.kind),
+    head: t$5(allprops.head),
+    tail: t$5(allprops.tail),
+    color: t$5(allprops.color),
+    line: t$5(allprops.line),
+    navigateTo: t$5(allprops.navigateTo),
     ...isNonEmptyArray(tags) && { tags }
   });
   if (prefer) {
@@ -1721,7 +1721,7 @@ function toNodeSource(el) {
     let tags = [...el.tags];
     summary ??= description2;
     if (onlyOneInstance) {
-      tags = n$f([...tags, ...onlyOneInstance.tags]);
+      tags = n$e([...tags, ...onlyOneInstance.tags]);
       if (title === nameFromFqn(el.id)) {
         title = onlyOneInstance.title;
       }
@@ -1743,7 +1743,7 @@ function toNodeSource(el) {
       icon: icon2,
       description: summary,
       tags,
-      style: n$7(el.style, ["icon", "shape", "color"])
+      style: n$6(el.style, ["icon", "shape", "color"])
     });
   }
   invariant(el.isInstance(), "Expected Instance");
@@ -1764,7 +1764,7 @@ function toNodeSource(el) {
     description,
     technology,
     tags: [...el.tags],
-    links: t$c(links, 1) ? links : void 0,
+    links: t$b(links, 1) ? links : void 0,
     icon,
     color,
     shape,
@@ -1780,7 +1780,7 @@ function toComputedEdges$1(connections) {
       ...e.relations.model,
       ...e.relations.deployment
     ];
-    invariant(t$c(relations, 1), "Edge must have at least one relation");
+    invariant(t$b(relations, 1), "Edge must have at least one relation");
     const defaults = e.source.$model.$styles.defaults;
     const source = e.source.id;
     const target = e.target.id;
@@ -1844,28 +1844,28 @@ function findCrossBoundarySameSourceOrTarget(connections) {
   }
   const excludedRelations = new DefaultMap(() => /* @__PURE__ */ new Set());
   for (const [relation, sameRelationGroup] of groupedByRelation) {
-    if (!t$c(sameRelationGroup, 2)) {
+    if (!t$b(sameRelationGroup, 2)) {
       continue;
     }
-    t$e(
+    t$d(
       sameRelationGroup,
-      t$m((conn) => [
+      t$l((conn) => [
         { group: `$source-${conn.source.id}`, conn },
         { group: `$target-${conn.target.id}`, conn }
       ]),
-      t$l(e$8("group")),
-      t$k(),
-      n$e(t$c(2)),
-      t$8(
+      t$k(e$8("group")),
+      t$j(),
+      n$d(t$b(2)),
+      t$7(
         // In each group, sort by hierarchy, first are deepest
-        t$j(
-          t$f(e$8("conn")),
+        t$i(
+          t$e(e$8("conn")),
           sortConnectionsByBoundaryHierarchy("desc"),
           // Drop first, as it is the deepest
           // Drop if boundary is same as previous
-          t$a((conn, i, all) => i === 0 || conn.boundary === all[i - 1].boundary),
+          t$9((conn, i, all) => i === 0 || conn.boundary === all[i - 1].boundary),
           // Drop relations from boundaries above
-          t$8((conn) => {
+          t$7((conn) => {
             excludedRelations.get(conn).add(relation);
           })
         )
@@ -1910,7 +1910,7 @@ function findCrossBoundaryConnections(connections) {
       }
     }
   }
-  return t$e(
+  return t$d(
     excludedRelations.entries(),
     imap(
       ([c, excluded]) => c.update({
@@ -1928,7 +1928,7 @@ function cleanCrossBoundary(connections) {
   );
 }
 function findRedundantConnections$1(connections) {
-  return t$e(
+  return t$d(
     connections,
     mergeConnections,
     t$2((redundants, connection) => {
@@ -2010,25 +2010,25 @@ let StageInclude$1 = class StageInclude extends AbstractStageInclude {
     return hasChanged();
   }
   processConnections(connections) {
-    const clean = t$e(
+    const clean = t$d(
       connections,
       cleanCrossBoundary,
       cleanRedundantRelationships
     );
-    t$e(
+    t$d(
       clean,
       // Process only connection from this stage
       // filter(c => this._connections.some(c2 => c2.id === c.id)),
-      t$8(({ source, target, boundary }) => {
-        t$e(
-          t$n(
+      t$7(({ source, target, boundary }) => {
+        t$d(
+          t$m(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
           ),
           // Filter out common ancestors
-          t$a(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
+          t$9(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
           n(1),
-          t$8(([sourceAncestor, targetAncestor]) => {
+          t$7(([sourceAncestor, targetAncestor]) => {
             if (source === sourceAncestor && target === targetAncestor) {
               this.addImplicit(boundary);
               return;
@@ -2077,7 +2077,7 @@ let Memory$1 = class Memory extends AbstractMemory {
     });
   }
   equals(other) {
-    return other instanceof Memory && t$i(this.state, other.state);
+    return other instanceof Memory && t$h(this.state, other.state);
   }
   diff(state) {
     return {
@@ -2154,9 +2154,9 @@ const IncomingRelationPredicate = {
       return stage;
     }
     const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = t$e(
+    const toExclude = t$d(
       memory.connections,
-      n$e(isIncoming),
+      n$d(isIncoming),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2164,7 +2164,7 @@ const IncomingRelationPredicate = {
   }
 };
 function filterIncomingConnections(targets) {
-  return t$h(
+  return t$g(
     targets.map((target) => {
       const satisfies = (el) => el === target || isAncestor(target, el);
       return (connection) => {
@@ -2213,9 +2213,9 @@ const OutgoingRelationPredicate = {
       return stage;
     }
     const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = t$e(
+    const toExclude = t$d(
       memory.connections,
-      n$e(isOutgoing),
+      n$d(isOutgoing),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2223,7 +2223,7 @@ const OutgoingRelationPredicate = {
   }
 };
 function filterOutgoingConnections(sources) {
-  return t$h(
+  return t$g(
     sources.map((source) => {
       const satisfies = (el) => el === source || isAncestor(source, el);
       return (connection) => {
@@ -2261,10 +2261,10 @@ const DirectRelationPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        connections = t$e(
+        connections = t$d(
           findConnectionsWithin$1(model.instances()),
           applyPredicate(where),
-          t$f((c) => {
+          t$e((c) => {
             stage.addImplicit(c.boundary);
             return c;
           })
@@ -2280,13 +2280,13 @@ const DirectRelationPredicate = {
           const isTarget = filterIncomingConnections(sources);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = t$e(
+        connections = t$d(
           sources,
-          t$m((source2) => {
+          t$l((source2) => {
             const targets = resolveAscendingSiblings(source2);
             return findConnectionsBetween$2(source2, targets, dir);
           }),
-          n$e(postFilter),
+          n$d(postFilter),
           applyPredicate(where)
         );
         break;
@@ -2300,13 +2300,13 @@ const DirectRelationPredicate = {
           const isSource = filterOutgoingConnections(targets);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = t$e(
+        connections = t$d(
           targets,
-          t$m((target2) => {
+          t$l((target2) => {
             const sources = resolveAscendingSiblings(target2);
             return [...sources].flatMap((source2) => findConnection$2(source2, target2, dir));
           }),
-          n$e(postFilter),
+          n$d(postFilter),
           applyPredicate(where)
         );
         break;
@@ -2318,10 +2318,10 @@ const DirectRelationPredicate = {
         const targets = resolveElements$1(model, target);
         const isSource = filterOutgoingConnections(sources);
         const isTarget = filterIncomingConnections(targets);
-        connections = t$e(
+        connections = t$d(
           sources,
-          t$m((s) => findConnectionsBetween$2(s, targets, dir)),
-          n$e((c) => isSource(c) && isTarget(c)),
+          t$l((s) => findConnectionsBetween$2(s, targets, dir)),
+          n$d((c) => isSource(c) && isTarget(c)),
           applyPredicate(where)
         );
       }
@@ -2380,9 +2380,9 @@ const DirectRelationPredicate = {
         const satisfies = (connection) => {
           return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source);
         };
-        const deploymentRelationsToExclude = t$e(
+        const deploymentRelationsToExclude = t$d(
           memory.connections,
-          n$e(satisfies),
+          n$d(satisfies),
           applyPredicate(where)
         );
         if (deploymentRelationsToExclude.length === 0) {
@@ -2449,9 +2449,9 @@ const InOutRelationPredicate$1 = {
     const elements = resolveElements$1(model, expr.inout);
     const isIncoming = filterIncomingConnections(elements);
     const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = t$e(
+    const toExclude = t$d(
       memory.connections,
-      n$e((c) => isIncoming(c) !== isOutgoing(c)),
+      n$d((c) => isIncoming(c) !== isOutgoing(c)),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2473,10 +2473,10 @@ const WhereRelationPredicate = {
 const WildcardPredicate$1 = {
   include: ({ model, stage, where }) => {
     const children = [];
-    const rootElements = t$e(
+    const rootElements = t$d(
       [...model.roots()],
       applyElementPredicate(where),
-      t$f((root) => {
+      t$e((root) => {
         if (!root.onlyOneInstance()) {
           children.push(...root.children());
         }
@@ -2493,7 +2493,7 @@ const WildcardPredicate$1 = {
     return stage;
   },
   exclude: ({ stage, memory, where }) => {
-    const elementsToExclude = t$e(
+    const elementsToExclude = t$d(
       [...memory.elements],
       applyElementPredicate(where)
     );
@@ -2535,19 +2535,19 @@ function excludeModelRelations(relationsToExclude, { stage, memory }, where, fil
   if (relationsToExclude.size === 0) {
     return stage;
   }
-  const toExclude = t$e(
+  const toExclude = t$d(
     memory.connections,
-    n$e((c) => filterConnections(c)),
+    n$d((c) => filterConnections(c)),
     // Find connections that have at least one relation in common with the excluded relations
-    n$e((c) => hasIntersection(c.relations.model, relationsToExclude)),
-    t$f(
+    n$d((c) => hasIntersection(c.relations.model, relationsToExclude)),
+    t$e(
       (c) => c.update({
         deployment: null,
         model: intersection(c.relations.model, relationsToExclude)
       })
     ),
     applyPredicate(where),
-    n$e((c) => c.nonEmpty())
+    n$d((c) => c.nonEmpty())
   );
   if (toExclude.length === 0) {
     return stage;
@@ -2587,9 +2587,9 @@ function matchConnections(connections, where) {
   if (!where) {
     return connections;
   }
-  return t$e(
+  return t$d(
     connections,
-    n$e((c) => matchConnection(c, where))
+    n$d((c) => matchConnection(c, where))
   );
 }
 function toFilterable(relationEndpoint, connectionEndpoint) {
@@ -2601,7 +2601,7 @@ function toFilterable(relationEndpoint, connectionEndpoint) {
     };
   }
   if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) {
-    return t$4(relationEndpoint.element, ["tags", "kind"]);
+    return t$n(relationEndpoint.element, ["tags", "kind"]);
   }
   if (isDeployedInstanceModel(relationEndpoint)) {
     return {
@@ -2610,7 +2610,7 @@ function toFilterable(relationEndpoint, connectionEndpoint) {
     };
   }
   if (isDeploymentNodeModel(relationEndpoint)) {
-    return t$4(relationEndpoint, ["tags", "kind"]);
+    return t$n(relationEndpoint, ["tags", "kind"]);
   }
   nonexhaustive(relationEndpoint);
 }
@@ -2655,9 +2655,9 @@ const DeploymentRefPredicate = {
   },
   exclude: ({ expr, stage, memory, where }) => {
     const exprPredicate = deploymentExpressionToPredicate(expr);
-    const toExclude = t$e(
+    const toExclude = t$d(
       [...memory.elements],
-      n$e(exprPredicate),
+      n$d(exprPredicate),
       applyElementPredicate(where)
     );
     stage.exclude(toExclude);
@@ -2717,14 +2717,14 @@ function includeDeployedNodeDescendants(node, { stage, where }) {
   }
   stage.connectWithExisting(descendants, "out");
   const allConnected = findConnectedElements(stage);
-  t$e(
+  t$d(
     descendants,
-    n$e((desc) => allConnected.has(desc)),
-    t$8((desc) => stage.addExplicit(desc))
+    n$d((desc) => allConnected.has(desc)),
+    t$7((desc) => stage.addExplicit(desc))
   );
 }
 function findConnectedElements(stage) {
-  return t$e(
+  return t$d(
     stage.mergedConnections(),
     cleanCrossBoundary,
     cleanRedundantRelationships,
@@ -2747,7 +2747,7 @@ let StageFinal$1 = class StageFinal {
     if (memory.connections.length < 2) {
       return memory;
     }
-    const connections = t$e(
+    const connections = t$d(
       memory.connections,
       // Keep connections
       // - between leafs
@@ -2799,12 +2799,12 @@ let StageFinal$1 = class StageFinal {
       }
       return false;
     };
-    t$e(
+    t$d(
       difference(implicits, snapshot),
       ifilter((e) => e.isDeploymentNode()),
       toArray(),
       sortByFqnHierarchically,
-      t$8((el) => {
+      t$7((el) => {
         const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
         if (childrensToWrap >= 2) {
           final.add(el);
@@ -2827,12 +2827,12 @@ let StageFinal$1 = class StageFinal {
     const tree = treeFromMemoryState(memory, "final");
     const stage = memory.stageExclude({});
     const isRemovable = (el) => !(boundaries.has(el) || memory.explicits.has(el) || tree.hasInOut(el) || tree.root.has(el));
-    const singleRoot = t$6([...tree.root]);
+    const singleRoot = t$5([...tree.root]);
     if (singleRoot && !memory.explicits.has(singleRoot)) {
       stage.exclude(singleRoot);
     }
     for (const el of memory.final) {
-      const singleChild = t$6(tree.children(el));
+      const singleChild = t$5(tree.children(el));
       if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
         stage.exclude(el);
       }
@@ -2939,7 +2939,7 @@ function computeDeploymentView(likec4model, {
     rules,
     sorted.nodes
   );
-  const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
+  const autoLayoutRule = t$8(rules, isViewRuleAutoLayout);
   const elementNotations = buildElementNotations(nodes);
   return calcViewLayoutHash({
     ...view,
@@ -2951,7 +2951,7 @@ function computeDeploymentView(likec4model, {
       ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
     },
     edges: sorted.edges,
-    nodes: t$f(nodes, (n) => {
+    nodes: t$e(nodes, (n) => {
       if (n.icon === "none") {
         delete n.icon;
       }
@@ -3133,7 +3133,7 @@ function elementsFromSteps(model, steps) {
       actors.push(target);
     }
   };
-  for (const step of t$m(steps, flattenSteps)) {
+  for (const step of t$l(steps, flattenSteps)) {
     const source = model.element(step.source);
     const target = model.element(step.target);
     let sourceColumn = actors.indexOf(source);
@@ -3166,29 +3166,29 @@ function findRelations(source, target, currentViewId) {
       line: relation2.$relationship.line
     });
   }
-  const alltags = t$e(
+  const alltags = t$d(
     relationships,
-    t$m((r) => r.tags),
-    n$f()
+    t$l((r) => r.tags),
+    n$e()
   );
-  const tags = t$c(alltags, 1) ? alltags : void 0;
-  const relations = t$f(relationships, (r) => r.id);
-  const relation = n$a(relationships);
+  const tags = t$b(alltags, 1) ? alltags : void 0;
+  const relations = t$e(relationships, (r) => r.id);
+  const relation = n$9(relationships);
   let navigateTo = relation.$relationship.navigateTo;
   if (navigateTo === currentViewId) {
     navigateTo = void 0;
   }
   if (!navigateTo) {
-    navigateTo = t$e(
+    navigateTo = t$d(
       relationships,
-      t$m(
+      t$l(
         (r) => r.$relationship.navigateTo && r.$relationship.navigateTo !== currentViewId ? r.$relationship.navigateTo : []
       ),
-      n$f(),
-      t$6()
+      n$e(),
+      t$5()
     );
   }
-  const commonProperties = t$e(
+  const commonProperties = t$d(
     relationships,
     t$2((acc, { title, $relationship: r }) => {
       e$4(title) && acc.title.add(title);
@@ -3207,10 +3207,10 @@ function findRelations(source, target, currentViewId) {
     tags: tags ?? void 0,
     relations,
     navigateTo,
-    kind: t$6([...commonProperties.kind]),
-    title: t$6([...commonProperties.title]),
-    color: t$6([...commonProperties.color]),
-    line: t$6([...commonProperties.line])
+    kind: t$5([...commonProperties.kind]),
+    title: t$5([...commonProperties.title]),
+    color: t$5([...commonProperties.color]),
+    line: t$5([...commonProperties.line])
   });
 }
 
@@ -3233,7 +3233,7 @@ class DynamicViewCompute {
     const rules = resolveGlobalRulesInDynamicView(_rules, this.model.globals);
     const explicits = elementsFromIncludeProperties(this.model, rules);
     const fromSteps = elementsFromSteps(this.model, viewSteps);
-    const actors = t$e(
+    const actors = t$d(
       union(
         // First all actors, that are explicitly included
         intersection(explicits, fromSteps),
@@ -3366,7 +3366,7 @@ class DynamicViewCompute {
         actors.map((e) => nonNullable(nodesMap.get(e.id)))
       )
     );
-    const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
+    const autoLayoutRule = t$8(rules, isViewRuleAutoLayout);
     const nodeNotations = buildElementNotations(nodes);
     return calcViewLayoutHash({
       ...view,
@@ -3378,7 +3378,7 @@ class DynamicViewCompute {
         ...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
         ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
       },
-      nodes: t$f(nodes, (n) => {
+      nodes: t$e(nodes, (n) => {
         if (n.icon === "none") {
           delete n.icon;
         }
@@ -3471,7 +3471,7 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
       if (!source || !target) {
         return;
       }
-      if (satisfies({ source, target, ...t$4(edge, ["kind", "tags"]) })) {
+      if (satisfies({ source, target, ...t$n(edge, ["kind", "tags"]) })) {
         edges[i] = {
           ...edge,
           ...props,
@@ -3512,10 +3512,10 @@ class NodesGroup {
 
 class StageExclude extends AbstractStageExclude {
   excludeRelations(excluded) {
-    t$e(
+    t$d(
       this.memory.connections,
-      n$e((c) => hasIntersection(c.relations, excluded)),
-      t$8((c) => {
+      n$d((c) => hasIntersection(c.relations, excluded)),
+      t$7((c) => {
         this.excludeConnections(
           c.update(intersection(c.relations, excluded))
         );
@@ -3610,18 +3610,18 @@ class StageInclude extends AbstractStageInclude {
     if (ModelExpression.isRelationExpr(this.expression)) {
       return connections;
     }
-    t$e(
+    t$d(
       connections,
-      t$8(({ source, target, boundary }) => {
-        t$e(
-          t$n(
+      t$7(({ source, target, boundary }) => {
+        t$d(
+          t$m(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
           ),
           // Filter out common ancestors
-          t$a(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
+          t$9(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
           n(1),
-          t$8(([sourceAncestor, targetAncestor]) => {
+          t$7(([sourceAncestor, targetAncestor]) => {
             if (sourceAncestor === source && targetAncestor === target) {
               this.addImplicitWithinScope(boundary);
               return;
@@ -3773,7 +3773,7 @@ class ActiveGroupMemory extends Memory {
 }
 
 function findRedundantConnections(connections) {
-  return t$e(
+  return t$d(
     [...connections],
     mergeConnections,
     t$2((reducedConnections, connection, _, all) => {
@@ -3853,11 +3853,11 @@ class StageFinal {
       }
       return false;
     };
-    t$e(
+    t$d(
       difference(implicits, snapshot),
       toArray(),
       sortByFqnHierarchically,
-      t$8((el) => {
+      t$7((el) => {
         const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
         if (childrensToWrap >= 2) {
           final.add(el);
@@ -3880,12 +3880,12 @@ class StageFinal {
     const tree = treeFromMemoryState(memory, "final");
     const stage = memory.stageExclude({});
     const isRemovable = (el) => !(boundaries.has(el) || memory.explicits.has(el) || tree.hasInOut(el) || tree.root.has(el));
-    const singleRoot = t$6([...tree.root]);
+    const singleRoot = t$5([...tree.root]);
     if (singleRoot && !memory.explicits.has(singleRoot)) {
       stage.exclude(singleRoot);
     }
     for (const el of memory.final) {
-      const singleChild = t$6(tree.children(el));
+      const singleChild = t$5(tree.children(el));
       if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
         stage.exclude(el);
       }
@@ -3939,7 +3939,7 @@ function includeDescendantsFromMemory(elements, memory) {
   if (memory.isEmpty() || elements.length === 0) {
     return elements;
   }
-  const descedantsOf = t$h(elements.map((e) => isDescendantOf(e)));
+  const descedantsOf = t$g(elements.map((e) => isDescendantOf(e)));
   const fromMemory = toArray(
     ifilter(
       memory.elements,
@@ -4030,7 +4030,7 @@ function toComputedEdges(connections) {
     const relations = [
       ...e.relations
     ];
-    invariant(t$c(relations, 1), "Edge must have at least one relation");
+    invariant(t$b(relations, 1), "Edge must have at least one relation");
     const $defaults = e.source.$model.$styles.defaults;
     const source = e.source.id;
     const target = e.target.id;
@@ -4044,8 +4044,8 @@ function toComputedEdges(connections) {
       relations.map((r) => r.$relationship),
       // Prefer only single relationship
       // https://github.com/likec4/likec4/issues/1423
-      t$6(
-        n$e(relations, (r) => r.source.id === source && r.target.id === target)
+      t$5(
+        n$d(relations, (r) => r.source.id === source && r.target.id === target)
       )?.$relationship
     );
     const edge = exact({
@@ -4083,11 +4083,11 @@ const DirectRelationExprPredicate = {
       // This is a special case, we look for all relationships that satisfy the where clause
       // * -> * ; Empty memory; Where clause
       case (sourceIsWildcard && targetIsWildcard && memory.isEmpty() && where !== NoWhere): {
-        const connections2 = t$e(
+        const connections2 = t$d(
           model.relationships(),
           ifilter(where),
           toArray(),
-          t$f((r) => new ConnectionModel(r.source, r.target, /* @__PURE__ */ new Set([r])))
+          t$e((r) => new ConnectionModel(r.source, r.target, /* @__PURE__ */ new Set([r])))
         );
         stage.addConnections(connections2);
         return stage;
@@ -4111,10 +4111,10 @@ const DirectRelationExprPredicate = {
       // element -> *; Where clause
       case (!sourceIsWildcard && targetIsWildcard && where !== NoWhere): {
         const sources = resolveElements(model, source);
-        const connections2 = t$e(
+        const connections2 = t$d(
           sources,
-          t$m(
-            (source2) => t$e(
+          t$l(
+            (source2) => t$d(
               source2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4123,12 +4123,12 @@ const DirectRelationExprPredicate = {
               ifilter(where),
               iunique(),
               toArray(),
-              t$5((r) => r.source === source2),
+              t$4((r) => r.source === source2),
               ([outgoing, incoming]) => t$p(
-                t$e(
+                t$d(
                   outgoing,
-                  n$e((r) => !isAncestorOrDescendantOf(source2, r.target)),
-                  t$f(
+                  n$d((r) => !isAncestorOrDescendantOf(source2, r.target)),
+                  t$e(
                     (outgoing2) => new ConnectionModel(
                       source2,
                       outgoing2.target,
@@ -4136,10 +4136,10 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                t$e(
+                t$d(
                   incoming,
-                  n$e((r) => !isAncestorOrDescendantOf(source2, r.source)),
-                  t$f(
+                  n$d((r) => !isAncestorOrDescendantOf(source2, r.source)),
+                  t$e(
                     (incoming2) => new ConnectionModel(
                       incoming2.source,
                       source2,
@@ -4169,10 +4169,10 @@ const DirectRelationExprPredicate = {
       // * -> element; Where clause
       case (sourceIsWildcard && !targetIsWildcard && where !== NoWhere): {
         const targets = resolveElements(model, target);
-        const connections2 = t$e(
+        const connections2 = t$d(
           targets,
-          t$m(
-            (target2) => t$e(
+          t$l(
+            (target2) => t$d(
               target2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4180,12 +4180,12 @@ const DirectRelationExprPredicate = {
               }),
               ifilter(where),
               toArray(),
-              t$5((r) => r.target === target2),
+              t$4((r) => r.target === target2),
               ([incoming, outgoing]) => t$p(
-                t$e(
+                t$d(
                   outgoing,
-                  n$e((r) => !isAncestorOrDescendantOf(target2, r.target)),
-                  t$f(
+                  n$d((r) => !isAncestorOrDescendantOf(target2, r.target)),
+                  t$e(
                     (outgoing2) => new ConnectionModel(
                       target2,
                       outgoing2.target,
@@ -4193,10 +4193,10 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                t$e(
+                t$d(
                   incoming,
-                  n$e((r) => !isAncestorOrDescendantOf(target2, r.source)),
-                  t$f(
+                  n$d((r) => !isAncestorOrDescendantOf(target2, r.source)),
+                  t$e(
                     (incoming2) => new ConnectionModel(
                       incoming2.source,
                       target2,
@@ -4247,9 +4247,9 @@ const DirectRelationExprPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        relations = t$e(
+        relations = t$d(
           memory.connections,
-          t$m(t$j(
+          t$l(t$i(
             e$8("relations"),
             ifilter(where),
             toArray()
@@ -4261,10 +4261,10 @@ const DirectRelationExprPredicate = {
       // element -> *
       case (!sourceIsWildcard && targetIsWildcard): {
         const sources = resolveElements(model, source);
-        relations = t$e(
+        relations = t$d(
           sources,
-          t$m(
-            (source2) => t$e(
+          t$l(
+            (source2) => t$d(
               source2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4281,10 +4281,10 @@ const DirectRelationExprPredicate = {
       // * -> element
       case (sourceIsWildcard && !targetIsWildcard): {
         const targets = resolveElements(model, target);
-        relations = t$e(
+        relations = t$d(
           targets,
-          t$m(
-            (target2) => t$e(
+          t$l(
+            (target2) => t$d(
               target2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4325,7 +4325,7 @@ const DirectRelationExprPredicate = {
 };
 function resolveWildcard(nonWildcard, { memory, model }) {
   let sources = resolveElements(model, nonWildcard);
-  if (!t$c(sources, 1)) {
+  if (!t$b(sources, 1)) {
     return [[], []];
   }
   if (ModelFqnExpr.isModelRef(nonWildcard)) {
@@ -4336,9 +4336,9 @@ function resolveWildcard(nonWildcard, { memory, model }) {
       includeDescendantsFromMemory(targets2, memory)
     ];
   }
-  const targets = t$e(
+  const targets = t$d(
     sources,
-    t$f((el) => el.ascendingSiblings()),
+    t$e((el) => el.ascendingSiblings()),
     iflat(),
     iunique(),
     toArray(),
@@ -4369,7 +4369,7 @@ const IncomingExprPredicate = {
       const visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
         visibleElements.push(
-          ...n$f(
+          ...n$e(
             targets.flatMap((el) => [...el.ascendingSiblings()])
           )
         );
@@ -4416,7 +4416,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "children"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h(
+      return t$g(
         [...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
         )
@@ -4424,7 +4424,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h([
+      return t$g([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
@@ -4433,7 +4433,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h([
+      return t$g([
         Connection.isIncoming(fqn),
         Connection.isInside(fqn)
       ]);
@@ -4464,7 +4464,7 @@ const InOutRelationPredicate = {
       const elements = resolveAndIncludeFromMemory(inout, { memory, model });
       let visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
-        visibleElements = n$f(
+        visibleElements = n$e(
           elements.flatMap((el) => toArray(el.ascendingSiblings()))
         );
       }
@@ -4521,7 +4521,7 @@ const OutgoingExprPredicate = {
       const visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
         visibleElements.push(
-          ...n$f(
+          ...n$e(
             elements.flatMap((el) => [...el.ascendingSiblings()])
           )
         );
@@ -4570,7 +4570,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "children"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h(
+      return t$g(
         [...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
         )
@@ -4578,7 +4578,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h([
+      return t$g([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
@@ -4587,7 +4587,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$h([
+      return t$g([
         Connection.isOutgoing(fqn),
         Connection.isInside(fqn)
       ]);
@@ -4652,7 +4652,7 @@ const WildcardPredicate = {
   exclude: ({ scope, memory, stage, where }) => {
     if (where !== NoWhere) {
       stage.exclude(
-        n$e(
+        n$d(
           [...memory.elements],
           where
         )
@@ -4678,7 +4678,7 @@ function processElementPredicate(expr, op, ctx) {
     case ModelFqnExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition);
       const filterWhere = (elements) => {
-        return n$e(elements, where);
+        return n$d(elements, where);
       };
       return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere });
     }
@@ -4710,13 +4710,13 @@ function processRelationtPredicate(expr, op, ctx) {
     case ModelRelationExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition);
       const filterRelations = (relations) => {
-        return new Set(n$e([...relations], where));
+        return new Set(n$d([...relations], where));
       };
       const filterWhere = (connections) => {
-        return t$e(
+        return t$d(
           connections,
-          t$f((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
-          n$e((c) => c.nonEmpty())
+          t$e((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
+          n$d((c) => c.nonEmpty())
         );
       };
       return processRelationtPredicate(expr.where.expr, op, {
@@ -4822,7 +4822,7 @@ function computeElementView(likec4model, {
       sorted.nodes
     )
   );
-  const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
+  const autoLayoutRule = t$8(rules, isViewRuleAutoLayout);
   const nodeNotations = buildElementNotations(nodes);
   return calcViewLayoutHash({
     ...view,
@@ -4833,7 +4833,7 @@ function computeElementView(likec4model, {
       ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
     },
     edges: applyCustomRelationProperties(rules, nodes, sorted.edges),
-    nodes: t$f(nodes, (n) => {
+    nodes: t$e(nodes, (n) => {
       if (n.icon === "none") {
         delete n.icon;
       }
@@ -4874,9 +4874,9 @@ function assignElementsToGroups(memory) {
     }
     return false;
   };
-  t$e(
+  t$d(
     sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
-    t$8((el) => {
+    t$7((el) => {
       if (!isAncestorAssigned(el)) {
         const groupId = nonNullable(memory.explicitFirstSeenIn.get(el));
         assignedTo.set(el, groupId);
@@ -4884,10 +4884,10 @@ function assignElementsToGroups(memory) {
       }
     })
   );
-  t$e(
+  t$d(
     sortParentsFirst([...memory.lastSeenIn.keys()]),
-    n$e((el) => !assignedTo.has(el)),
-    t$8((el) => {
+    n$d((el) => !assignedTo.has(el)),
+    t$7((el) => {
       if (isAncestorAssigned(el)) {
         return;
       }
@@ -4956,4 +4956,4 @@ function computeLikeC4Model(parsed) {
   return LikeC4Model.create(computeParsedModelData(parsed));
 }
 
-export { t$7 as a, computeParsedModelData as b, computeLikeC4Model as c, computeView as d, n$7 as n, topologicalSortExports as t, unsafeComputeView as u, willCreateCycle as w };
+export { t$6 as a, computeParsedModelData as b, computeLikeC4Model as c, computeView as d, n$6 as n, topologicalSortExports as t, unsafeComputeView as u, willCreateCycle as w };