@likec4/core 1.42.1 → 1.44.0

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

@@ -1,136 +1,71 @@
-import { t as t$g, a as t$i } from './core.BsSXS-_R.mjs';
-import { b as t$k, e as e$4, a as t$l, c as t$n, t as t$s, i as isElementModel, d as isNestedElementOfDeployedInstanceModel, f as isDeployedInstanceModel, g as isDeploymentNodeModel, h as isDeploymentElementModel, L as LikeC4Model } from './core.C8sl5Y8Z.mjs';
-import { t as t$m } from './core.CbT8JVYL.mjs';
-import { a as t$h, t as t$j, n as n$i } from './core.OHD4KXm9.mjs';
-import { n as n$j, e as e$6, t as t$q, d as deploymentConnection, R as RelationshipsAccum, D as DeploymentConnectionModel } from './core.BIqHjQiH.mjs';
-import { c as commonHead, t as t$o, o as objectHash, b as t$t, a as compareRelations, S as Stack } from './core.C8YY6Uub.mjs';
+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 { a as nonNullable, i as invariant, n as nonexhaustive } from './core.D4npX2q8.mjs';
-import { G as Graph } from './core.CNgZvKb8.mjs';
-import { r as requireForeach } from './core.1vX5a9AY.mjs';
-import { a as requireIterator } from './core.rCeaAqgW.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 { e as e$5 } from './core.BKlholso.mjs';
-import { b as isDescendantOf, f as sortParentsFirst, i as isAncestor, p as parentFqn, l as compareByFqnHierarchically, c as isNonEmptyArray, n as nameFromFqn, r as sortByFqnHierarchically, k as commonAncestor, a as ancestorsFqn, d as isSameHierarchy } from './core.DRhg-gVU.mjs';
-import { d as difference, i as intersection, u as union, h as hasIntersection } from './core.C2TiyjI6.mjs';
-import { w as whereOperatorAsPredicate, t as t$p, a as _type, _ as _stage, k as e$b } from './core.BYNkXQ8A.mjs';
-import { e as e$7, a as iunique, i as iflat } from './core.C4x8aaWa.mjs';
-import { e as e$8 } from './core.BoYfZOBm.mjs';
+import { n as n$d, t as t$e } from './core.OHD4KXm9.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 { e as e$6, a as iunique, i as iflat } from './core.C4x8aaWa.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 { a as isViewRuleStyle, s as e$a, i as isViewRulePredicate, m as isViewRuleAutoLayout, r as isViewRuleGroup, k as isViewRuleGlobalPredicateRef, j as isViewRuleGlobalStyle, p as isDynamicStepsParallel, q as isDynamicStepsSeries, h as isDynamicView, g as isDeploymentView, d as isElementView } from './core.BzTakU3I.mjs';
-import { i as isGroupElementKind, G as GroupElementKind, d as stepEdgeId } from './core.C_Ni6yHl.mjs';
-import { a as preferSummary } from './core.BazD6cot.mjs';
-import { e as exact, t as t$u } from './core.01VTr9qu.mjs';
-import { a as t$r } from './core.DNbUPnve.mjs';
+import { preferSummary } from '../types/_aux.mjs';
+import { a as t$i } 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.lRvxPoao.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 { 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.B7KhhkRY.mjs';
+import { C as Connection, c as customInspectSymbol } from './core.C0Ye2OCr.mjs';
 import { i as isome } from './core.FZ305VYd.mjs';
 import { i as isIterable, e as e$9 } from './core.RfnaEmgA.mjs';
-
-function t$f(...t){return t$g(n$h,t)}const n$h=(e,t)=>[...e,...t];
+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';
+import { t as t$p } from './core.q10OP9oJ.mjs';
 
 function e$3(e){return ()=>e}
 
-function t$e(...t){return t$g(n$g,t)}function n$g(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return []}
-
-function n$f(...t){return t$g(r$5,t,i$2)}const r$5=(e,t)=>e.filter(t),i$2=e=>(n,r,i)=>e(n,r,i)?{done:false,hasNext:true,next:n}:t$h;
+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 []}
 
 const e$2=e=>Object.assign(e,{single:true});
 
-function t$d(...t){return t$g(n$e,t)}const n$e=(e,t)=>{for(let n=e.length-1;n>=0;n--){let r=e[n];if(t(r,n,e))return r}};
-
-function n$d(...n){return t$g(r$4,n,e$2(i$1))}const r$4=([e])=>e,i$1=()=>a,a=e=>({hasNext:true,next:e,done: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$c(...t){return t$g(n$c,t,r$3)}const n$c=(e,t)=>e.flatMap(t),r$3=e=>(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:false,hasNext:true,hasMany:true,next:i}:{done:false,hasNext:true,next:i}};
+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 t$b(...t){return t$g(n$b,t,r$2)}function n$b(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$a(...t){return t$g(n$a,t)}const n$a=(e,t)=>{let n=Object.create(null);for(let r=0;r<e.length;r++){let i=e[r],a=t(i,r,e);if(a!==void 0){let e=n[a];e===void 0?n[a]=[i]:e.push(i);}}return Object.setPrototypeOf(n,Object.prototype),n};
-
-function t$9(...t){return t$g(n$9,t)}function n$9(e,t){let n={};for(let[r,i]of e.entries()){let a=t(i,r,e);n[a]=i;}return n}
+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 e$1(e){return typeof e==`boolean`}
 
-function t$8(...t){return t$g(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$7(...t){return t$g(n$7,t)}function n$7(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}
+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 n$6(...t){return t$g(r$1,t)}function r$1(e,n){if(!t$i(n,1))return {...e};if(!t$i(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$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 t$6(...t){return t$g(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$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$g(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$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$g(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$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 n=>t$j(n,...t)}
+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$g(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$g(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$g(r,t,i)}const r=(e,t)=>t<0?[]:e.slice(0,t);function i(e){if(e<=0)return n$i;let n=e;return e=>(--n,{done:n<=0,hasNext:true,next:e})}
+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 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);
 
-function buildElementNotations(nodes) {
-  return t$j(
-    nodes,
-    n$f((n) => !!n.notation),
-    t$a(e$4("notation")),
-    t$7(
-      t$3(
-        t$a(e$4("shape")),
-        t$7(
-          t$3(
-            t$a(e$4("color")),
-            t$7(
-              t$3(
-                t$m(e$4("kind")),
-                n$j()
-              )
-            ),
-            t$l(),
-            t$m(([color, kinds]) => ({
-              kinds,
-              color
-            }))
-          )
-        ),
-        t$l(),
-        t$c(
-          ([shape, colors]) => colors.map(({ color, kinds }) => ({
-            shape,
-            color,
-            kinds
-          }))
-        )
-      )
-    ),
-    t$l(),
-    t$c(
-      ([title, shapes]) => shapes.map(({ shape, color, kinds }) => ({
-        title,
-        shape,
-        color,
-        kinds
-      }))
-    ),
-    t$k(
-      e$4("shape"),
-      e$4("title"),
-      [
-        (n) => n.kinds.length,
-        "desc"
-      ]
-    )
-  );
-}
-
 function ancestorsOfNode(node, nodes) {
   const ancestors = [];
   let parentId = node.parent;
@@ -153,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$n(
+    const edgeParent = hasAncestors ? t$d(
       commonHead(
         t$1(sourceAncestors),
         t$1(targetAncestors)
@@ -209,309 +144,6 @@ function requireIsGraph () {
 	return isGraph;
 }
 
-var iterables = {};
-
-var typedArrays = {};
-
-/**
- * Mnemonist Typed Array Helpers
- * ==============================
- *
- * Miscellaneous helpers related to typed arrays.
- */
-
-var hasRequiredTypedArrays;
-
-function requireTypedArrays () {
-	if (hasRequiredTypedArrays) return typedArrays;
-	hasRequiredTypedArrays = 1;
-	(function (exports) {
-		/**
-		 * When using an unsigned integer array to store pointers, one might want to
-		 * choose the optimal word size in regards to the actual numbers of pointers
-		 * to store.
-		 *
-		 * This helpers does just that.
-		 *
-		 * @param  {number} size - Expected size of the array to map.
-		 * @return {TypedArray}
-		 */
-		var MAX_8BIT_INTEGER = Math.pow(2, 8) - 1,
-		    MAX_16BIT_INTEGER = Math.pow(2, 16) - 1,
-		    MAX_32BIT_INTEGER = Math.pow(2, 32) - 1;
-
-		var MAX_SIGNED_8BIT_INTEGER = Math.pow(2, 7) - 1,
-		    MAX_SIGNED_16BIT_INTEGER = Math.pow(2, 15) - 1,
-		    MAX_SIGNED_32BIT_INTEGER = Math.pow(2, 31) - 1;
-
-		exports.getPointerArray = function(size) {
-		  var maxIndex = size - 1;
-
-		  if (maxIndex <= MAX_8BIT_INTEGER)
-		    return Uint8Array;
-
-		  if (maxIndex <= MAX_16BIT_INTEGER)
-		    return Uint16Array;
-
-		  if (maxIndex <= MAX_32BIT_INTEGER)
-		    return Uint32Array;
-
-		  throw new Error('mnemonist: Pointer Array of size > 4294967295 is not supported.');
-		};
-
-		exports.getSignedPointerArray = function(size) {
-		  var maxIndex = size - 1;
-
-		  if (maxIndex <= MAX_SIGNED_8BIT_INTEGER)
-		    return Int8Array;
-
-		  if (maxIndex <= MAX_SIGNED_16BIT_INTEGER)
-		    return Int16Array;
-
-		  if (maxIndex <= MAX_SIGNED_32BIT_INTEGER)
-		    return Int32Array;
-
-		  return Float64Array;
-		};
-
-		/**
-		 * Function returning the minimal type able to represent the given number.
-		 *
-		 * @param  {number} value - Value to test.
-		 * @return {TypedArrayClass}
-		 */
-		exports.getNumberType = function(value) {
-
-		  // <= 32 bits itnteger?
-		  if (value === (value | 0)) {
-
-		    // Negative
-		    if (Math.sign(value) === -1) {
-		      if (value <= 127 && value >= -128)
-		        return Int8Array;
-
-		      if (value <= 32767 && value >= -32768)
-		        return Int16Array;
-
-		      return Int32Array;
-		    }
-		    else {
-
-		      if (value <= 255)
-		        return Uint8Array;
-
-		      if (value <= 65535)
-		        return Uint16Array;
-
-		      return Uint32Array;
-		    }
-		  }
-
-		  // 53 bits integer & floats
-		  // NOTE: it's kinda hard to tell whether we could use 32bits or not...
-		  return Float64Array;
-		};
-
-		/**
-		 * Function returning the minimal type able to represent the given array
-		 * of JavaScript numbers.
-		 *
-		 * @param  {array}    array  - Array to represent.
-		 * @param  {function} getter - Optional getter.
-		 * @return {TypedArrayClass}
-		 */
-		var TYPE_PRIORITY = {
-		  Uint8Array: 1,
-		  Int8Array: 2,
-		  Uint16Array: 3,
-		  Int16Array: 4,
-		  Uint32Array: 5,
-		  Int32Array: 6,
-		  Float32Array: 7,
-		  Float64Array: 8
-		};
-
-		// TODO: make this a one-shot for one value
-		exports.getMinimalRepresentation = function(array, getter) {
-		  var maxType = null,
-		      maxPriority = 0,
-		      p,
-		      t,
-		      v,
-		      i,
-		      l;
-
-		  for (i = 0, l = array.length; i < l; i++) {
-		    v = getter ? getter(array[i]) : array[i];
-		    t = exports.getNumberType(v);
-		    p = TYPE_PRIORITY[t.name];
-
-		    if (p > maxPriority) {
-		      maxPriority = p;
-		      maxType = t;
-		    }
-		  }
-
-		  return maxType;
-		};
-
-		/**
-		 * Function returning whether the given value is a typed array.
-		 *
-		 * @param  {any} value - Value to test.
-		 * @return {boolean}
-		 */
-		exports.isTypedArray = function(value) {
-		  return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(value);
-		};
-
-		/**
-		 * Function used to concat byte arrays.
-		 *
-		 * @param  {...ByteArray}
-		 * @return {ByteArray}
-		 */
-		exports.concat = function() {
-		  var length = 0,
-		      i,
-		      o,
-		      l;
-
-		  for (i = 0, l = arguments.length; i < l; i++)
-		    length += arguments[i].length;
-
-		  var array = new (arguments[0].constructor)(length);
-
-		  for (i = 0, o = 0; i < l; i++) {
-		    array.set(arguments[i], o);
-		    o += arguments[i].length;
-		  }
-
-		  return array;
-		};
-
-		/**
-		 * Function used to initialize a byte array of indices.
-		 *
-		 * @param  {number}    length - Length of target.
-		 * @return {ByteArray}
-		 */
-		exports.indices = function(length) {
-		  var PointerArray = exports.getPointerArray(length);
-
-		  var array = new PointerArray(length);
-
-		  for (var i = 0; i < length; i++)
-		    array[i] = i;
-
-		  return array;
-		}; 
-	} (typedArrays));
-	return typedArrays;
-}
-
-/**
- * Mnemonist Iterable Function
- * ============================
- *
- * Harmonized iteration helpers over mixed iterable targets.
- */
-
-var hasRequiredIterables;
-
-function requireIterables () {
-	if (hasRequiredIterables) return iterables;
-	hasRequiredIterables = 1;
-	var forEach = requireForeach();
-
-	var typed = /*@__PURE__*/ requireTypedArrays();
-
-	/**
-	 * Function used to determine whether the given object supports array-like
-	 * random access.
-	 *
-	 * @param  {any} target - Target object.
-	 * @return {boolean}
-	 */
-	function isArrayLike(target) {
-	  return Array.isArray(target) || typed.isTypedArray(target);
-	}
-
-	/**
-	 * Function used to guess the length of the structure over which we are going
-	 * to iterate.
-	 *
-	 * @param  {any} target - Target object.
-	 * @return {number|undefined}
-	 */
-	function guessLength(target) {
-	  if (typeof target.length === 'number')
-	    return target.length;
-
-	  if (typeof target.size === 'number')
-	    return target.size;
-
-	  return;
-	}
-
-	/**
-	 * Function used to convert an iterable to an array.
-	 *
-	 * @param  {any}   target - Iteration target.
-	 * @return {array}
-	 */
-	function toArray(target) {
-	  var l = guessLength(target);
-
-	  var array = typeof l === 'number' ? new Array(l) : [];
-
-	  var i = 0;
-
-	  // TODO: we could optimize when given target is array like
-	  forEach(target, function(value) {
-	    array[i++] = value;
-	  });
-
-	  return array;
-	}
-
-	/**
-	 * Same as above but returns a supplementary indices array.
-	 *
-	 * @param  {any}   target - Iteration target.
-	 * @return {array}
-	 */
-	function toArrayWithIndices(target) {
-	  var l = guessLength(target);
-
-	  var IndexArray = typeof l === 'number' ?
-	    typed.getPointerArray(l) :
-	    Array;
-
-	  var array = typeof l === 'number' ? new Array(l) : [];
-	  var indices = typeof l === 'number' ? new IndexArray(l) : [];
-
-	  var i = 0;
-
-	  // TODO: we could optimize when given target is array like
-	  forEach(target, function(value) {
-	    array[i] = value;
-	    indices[i] = i++;
-	  });
-
-	  return [array, indices];
-	}
-
-	/**
-	 * Exporting.
-	 */
-	iterables.isArrayLike = isArrayLike;
-	iterables.guessLength = guessLength;
-	iterables.toArray = toArray;
-	iterables.toArrayWithIndices = toArrayWithIndices;
-	return iterables;
-}
-
 /**
  * Mnemonist FixedDeque
  * =====================
@@ -1161,9 +793,9 @@ function topologicalSort(param) {
     allowSelfLoops: true,
     type: "directed"
   });
-  const enrichedEdges = t$j(
+  const enrichedEdges = t$e(
     edges,
-    t$m((edge) => {
+    t$f((edge) => {
       const source = getNode(edge.source), target = getNode(edge.target), parent = edge.parent ? getNode(edge.parent) : null;
       return {
         id: edge.id,
@@ -1174,7 +806,7 @@ function topologicalSort(param) {
       };
     })
   );
-  const [edgesBetweenLeafs, edgesWithCompounds] = t$6(
+  const [edgesBetweenLeafs, edgesWithCompounds] = t$5(
     enrichedEdges,
     ({ source, target }) => source.children.length === 0 && target.children.length === 0
   );
@@ -1190,10 +822,10 @@ function topologicalSort(param) {
   for (const { edge, source, target } of edgesBetweenLeafs) {
     addEdgeToGraph(edge);
     if (target.parent && target.parent !== edge.parent) {
-      t$j(
+      t$e(
         ancestorsOfNode(target, param.nodes),
-        t$o((ancestor) => ancestor.inEdges.includes(edge.id)),
-        t$b((ancestor) => {
+        t$g((ancestor) => ancestor.inEdges.includes(edge.id)),
+        t$8((ancestor) => {
           g.mergeNode(ancestor.id);
           if (!willCreateCycle(g, edge.source, ancestor.id)) {
             g.mergeDirectedEdge(edge.source, ancestor.id);
@@ -1256,13 +888,13 @@ function calcViewLayoutHash(view) {
     id: view.id,
     __: view._type ?? "element",
     autoLayout: view.autoLayout,
-    nodes: t$j(
+    nodes: t$e(
       view.nodes,
-      t$m((n) => ({
+      t$f((n) => ({
         id: n.id,
-        icon: e$5(n.icon) ? "Y" : "N",
+        icon: e$4(n.icon) && n.icon !== "none" ? "Y" : "N",
         title: n.title,
-        description: n.description?.md ?? n.description?.txt ?? null,
+        description: flattenMarkdownOrString(n.description),
         technology: n.technology ?? null,
         shape: n.shape,
         size: n.style.size ?? null,
@@ -1270,22 +902,22 @@ function calcViewLayoutHash(view) {
         padding: n.style.padding ?? null,
         children: n.children
       })),
-      t$8(({ id, ...node }) => [id, node])
+      t$7(({ id, ...node }) => [id, node])
     ),
-    edges: t$j(
+    edges: t$e(
       view.edges,
-      t$m((e) => ({
+      t$f((e) => ({
         source: e.source,
         target: e.target,
         label: e.label,
-        description: e.description?.md ?? e.description?.txt ?? null,
+        description: flattenMarkdownOrString(e.description),
         technology: e.technology ?? null,
         dir: e.dir,
         head: e.head,
         tail: e.tail,
         line: e.line
       })),
-      t$8(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+      t$7(({ source, target, ...edge }) => [`${source}:${target}`, edge])
     )
   };
   view.hash = objectHash(tohash);
@@ -1403,7 +1035,7 @@ class AbstractStageExclude {
       disconnected,
       state.elements
     );
-    disconnected = t$j(
+    disconnected = t$e(
       disconnected,
       ifilter((el) => {
         return state.explicits.has(el) && !isome(state.final, isDescendantOf(el));
@@ -1611,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$6(
+      const [fromKnown, rest] = t$5(
         this._connections,
         (c) => state.final.has(c.source)
       );
@@ -1723,18 +1355,18 @@ function elementExprToPredicate(target) {
 
 function applyViewRuleStyle(rule, predicates, nodes) {
   const { shape, color, icon, ...rest } = rule.style;
-  const nonEmptyStyle = !e$6(rest);
-  t$j(
+  const nonEmptyStyle = !e$5(rest);
+  t$e(
     nodes,
-    n$f(e$8(isGroupElementKind)),
-    n$f(t$p(predicates)),
-    t$b((n) => {
+    n$e(e$7(isGroupElementKind)),
+    n$e(t$h(predicates)),
+    t$8((n) => {
       n.shape = shape ?? n.shape;
       n.color = color ?? n.color;
-      if (e$7(icon)) {
+      if (e$6(icon)) {
         n.icon = icon;
       }
-      if (e$7(rule.notation)) {
+      if (e$6(rule.notation)) {
         n.notation = rule.notation;
       }
       if (nonEmptyStyle) {
@@ -1773,7 +1405,7 @@ function elementModelToNodeSource(el) {
     id,
     title,
     ...rest
-  } = n$6(el.$element, ["summary", "description", "metadata", "style", "tags"]);
+  } = n$7(el.$element, ["summary", "description", "metadata", "style", "tags"]);
   const { color, icon, shape, ...style } = el.style;
   return exact({
     id,
@@ -1895,35 +1527,35 @@ function pickRelationshipProps(relation) {
   };
 }
 function mergePropsFromRelationships(relations, prefer) {
-  const allprops = t$j(
+  const allprops = t$e(
     relations,
     t$2(
       (acc, r) => {
-        if (e$5(r.title) && !acc.title.includes(r.title)) {
+        if (e$4(r.title) && !acc.title.includes(r.title)) {
           acc.title.push(r.title);
         }
-        if (e$5(r.description) && !acc.description.some(t$r(r.description))) {
+        if (e$4(r.description) && !acc.description.some(t$i(r.description))) {
           acc.description.push(r.description);
         }
-        if (e$5(r.technology) && !acc.technology.includes(r.technology)) {
+        if (e$4(r.technology) && !acc.technology.includes(r.technology)) {
           acc.technology.push(r.technology);
         }
-        if (e$5(r.kind) && !acc.kind.includes(r.kind)) {
+        if (e$4(r.kind) && !acc.kind.includes(r.kind)) {
           acc.kind.push(r.kind);
         }
-        if (e$5(r.color) && !acc.color.includes(r.color)) {
+        if (e$4(r.color) && !acc.color.includes(r.color)) {
           acc.color.push(r.color);
         }
-        if (e$5(r.line) && !acc.line.includes(r.line)) {
+        if (e$4(r.line) && !acc.line.includes(r.line)) {
           acc.line.push(r.line);
         }
-        if (e$5(r.head) && !acc.head.includes(r.head)) {
+        if (e$4(r.head) && !acc.head.includes(r.head)) {
           acc.head.push(r.head);
         }
-        if (e$5(r.tail) && !acc.tail.includes(r.tail)) {
+        if (e$4(r.tail) && !acc.tail.includes(r.tail)) {
           acc.tail.push(r.tail);
         }
-        if (e$5(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
+        if (e$4(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
           acc.navigateTo.push(r.navigateTo);
         }
         if (r.tags) {
@@ -1945,26 +1577,26 @@ function mergePropsFromRelationships(relations, prefer) {
       }
     )
   );
-  let technology = t$q(allprops.technology);
-  let title = t$q(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : null);
-  const tags = n$j(allprops.tags);
+  let technology = t$6(allprops.technology);
+  let title = t$6(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : null);
+  const tags = n$f(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$q(allprops.description),
+    description: t$6(allprops.description),
     technology,
-    kind: t$q(allprops.kind),
-    head: t$q(allprops.head),
-    tail: t$q(allprops.tail),
-    color: t$q(allprops.color),
-    line: t$q(allprops.line),
-    navigateTo: t$q(allprops.navigateTo),
+    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),
     ...isNonEmptyArray(tags) && { tags }
   });
   if (prefer) {
     return {
       ...merged,
-      ...t$4(pickRelationshipProps(prefer), e$5)
+      ...t$3(pickRelationshipProps(prefer), e$4)
     };
   }
   return merged;
@@ -2089,7 +1721,7 @@ function toNodeSource(el) {
     let tags = [...el.tags];
     summary ??= description2;
     if (onlyOneInstance) {
-      tags = n$j([...tags, ...onlyOneInstance.tags]);
+      tags = n$f([...tags, ...onlyOneInstance.tags]);
       if (title === nameFromFqn(el.id)) {
         title = onlyOneInstance.title;
       }
@@ -2111,7 +1743,7 @@ function toNodeSource(el) {
       icon: icon2,
       description: summary,
       tags,
-      style: n$6(el.style, ["icon", "shape", "color"])
+      style: n$7(el.style, ["icon", "shape", "color"])
     });
   }
   invariant(el.isInstance(), "Expected Instance");
@@ -2132,7 +1764,7 @@ function toNodeSource(el) {
     description,
     technology,
     tags: [...el.tags],
-    links: t$i(links, 1) ? links : void 0,
+    links: t$c(links, 1) ? links : void 0,
     icon,
     color,
     shape,
@@ -2148,7 +1780,7 @@ function toComputedEdges$1(connections) {
       ...e.relations.model,
       ...e.relations.deployment
     ];
-    invariant(t$i(relations, 1), "Edge must have at least one relation");
+    invariant(t$c(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;
@@ -2212,28 +1844,28 @@ function findCrossBoundarySameSourceOrTarget(connections) {
   }
   const excludedRelations = new DefaultMap(() => /* @__PURE__ */ new Set());
   for (const [relation, sameRelationGroup] of groupedByRelation) {
-    if (!t$i(sameRelationGroup, 2)) {
+    if (!t$c(sameRelationGroup, 2)) {
       continue;
     }
-    t$j(
+    t$e(
       sameRelationGroup,
-      t$c((conn) => [
+      t$m((conn) => [
         { group: `$source-${conn.source.id}`, conn },
         { group: `$target-${conn.target.id}`, conn }
       ]),
-      t$a(e$4("group")),
-      t$s(),
-      n$f(t$i(2)),
-      t$b(
+      t$l(e$8("group")),
+      t$k(),
+      n$e(t$c(2)),
+      t$8(
         // In each group, sort by hierarchy, first are deepest
-        t$3(
-          t$m(e$4("conn")),
+        t$j(
+          t$f(e$8("conn")),
           sortConnectionsByBoundaryHierarchy("desc"),
           // Drop first, as it is the deepest
           // Drop if boundary is same as previous
-          t$e((conn, i, all) => i === 0 || conn.boundary === all[i - 1].boundary),
+          t$a((conn, i, all) => i === 0 || conn.boundary === all[i - 1].boundary),
           // Drop relations from boundaries above
-          t$b((conn) => {
+          t$8((conn) => {
             excludedRelations.get(conn).add(relation);
           })
         )
@@ -2278,7 +1910,7 @@ function findCrossBoundaryConnections(connections) {
       }
     }
   }
-  return t$j(
+  return t$e(
     excludedRelations.entries(),
     imap(
       ([c, excluded]) => c.update({
@@ -2296,7 +1928,7 @@ function cleanCrossBoundary(connections) {
   );
 }
 function findRedundantConnections$1(connections) {
-  return t$j(
+  return t$e(
     connections,
     mergeConnections,
     t$2((redundants, connection) => {
@@ -2378,25 +2010,25 @@ let StageInclude$1 = class StageInclude extends AbstractStageInclude {
     return hasChanged();
   }
   processConnections(connections) {
-    const clean = t$j(
+    const clean = t$e(
       connections,
       cleanCrossBoundary,
       cleanRedundantRelationships
     );
-    t$j(
+    t$e(
       clean,
       // Process only connection from this stage
       // filter(c => this._connections.some(c2 => c2.id === c.id)),
-      t$b(({ source, target, boundary }) => {
-        t$j(
-          t$t(
+      t$8(({ source, target, boundary }) => {
+        t$e(
+          t$n(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
           ),
           // Filter out common ancestors
-          t$e(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
+          t$a(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
           n(1),
-          t$b(([sourceAncestor, targetAncestor]) => {
+          t$8(([sourceAncestor, targetAncestor]) => {
             if (source === sourceAncestor && target === targetAncestor) {
               this.addImplicit(boundary);
               return;
@@ -2445,7 +2077,7 @@ let Memory$1 = class Memory extends AbstractMemory {
     });
   }
   equals(other) {
-    return other instanceof Memory && t$r(this.state, other.state);
+    return other instanceof Memory && t$i(this.state, other.state);
   }
   diff(state) {
     return {
@@ -2522,9 +2154,9 @@ const IncomingRelationPredicate = {
       return stage;
     }
     const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = t$j(
+    const toExclude = t$e(
       memory.connections,
-      n$f(isIncoming),
+      n$e(isIncoming),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2532,7 +2164,7 @@ const IncomingRelationPredicate = {
   }
 };
 function filterIncomingConnections(targets) {
-  return t$p(
+  return t$h(
     targets.map((target) => {
       const satisfies = (el) => el === target || isAncestor(target, el);
       return (connection) => {
@@ -2581,9 +2213,9 @@ const OutgoingRelationPredicate = {
       return stage;
     }
     const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = t$j(
+    const toExclude = t$e(
       memory.connections,
-      n$f(isOutgoing),
+      n$e(isOutgoing),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2591,7 +2223,7 @@ const OutgoingRelationPredicate = {
   }
 };
 function filterOutgoingConnections(sources) {
-  return t$p(
+  return t$h(
     sources.map((source) => {
       const satisfies = (el) => el === source || isAncestor(source, el);
       return (connection) => {
@@ -2629,10 +2261,10 @@ const DirectRelationPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        connections = t$j(
+        connections = t$e(
           findConnectionsWithin$1(model.instances()),
           applyPredicate(where),
-          t$m((c) => {
+          t$f((c) => {
             stage.addImplicit(c.boundary);
             return c;
           })
@@ -2648,13 +2280,13 @@ const DirectRelationPredicate = {
           const isTarget = filterIncomingConnections(sources);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = t$j(
+        connections = t$e(
           sources,
-          t$c((source2) => {
+          t$m((source2) => {
             const targets = resolveAscendingSiblings(source2);
             return findConnectionsBetween$2(source2, targets, dir);
           }),
-          n$f(postFilter),
+          n$e(postFilter),
           applyPredicate(where)
         );
         break;
@@ -2668,13 +2300,13 @@ const DirectRelationPredicate = {
           const isSource = filterOutgoingConnections(targets);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = t$j(
+        connections = t$e(
           targets,
-          t$c((target2) => {
+          t$m((target2) => {
             const sources = resolveAscendingSiblings(target2);
             return [...sources].flatMap((source2) => findConnection$2(source2, target2, dir));
           }),
-          n$f(postFilter),
+          n$e(postFilter),
           applyPredicate(where)
         );
         break;
@@ -2686,10 +2318,10 @@ const DirectRelationPredicate = {
         const targets = resolveElements$1(model, target);
         const isSource = filterOutgoingConnections(sources);
         const isTarget = filterIncomingConnections(targets);
-        connections = t$j(
+        connections = t$e(
           sources,
-          t$c((s) => findConnectionsBetween$2(s, targets, dir)),
-          n$f((c) => isSource(c) && isTarget(c)),
+          t$m((s) => findConnectionsBetween$2(s, targets, dir)),
+          n$e((c) => isSource(c) && isTarget(c)),
           applyPredicate(where)
         );
       }
@@ -2748,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$j(
+        const deploymentRelationsToExclude = t$e(
           memory.connections,
-          n$f(satisfies),
+          n$e(satisfies),
           applyPredicate(where)
         );
         if (deploymentRelationsToExclude.length === 0) {
@@ -2817,9 +2449,9 @@ const InOutRelationPredicate$1 = {
     const elements = resolveElements$1(model, expr.inout);
     const isIncoming = filterIncomingConnections(elements);
     const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = t$j(
+    const toExclude = t$e(
       memory.connections,
-      n$f((c) => isIncoming(c) !== isOutgoing(c)),
+      n$e((c) => isIncoming(c) !== isOutgoing(c)),
       applyPredicate(where)
     );
     stage.excludeConnections(toExclude);
@@ -2841,10 +2473,10 @@ const WhereRelationPredicate = {
 const WildcardPredicate$1 = {
   include: ({ model, stage, where }) => {
     const children = [];
-    const rootElements = t$j(
+    const rootElements = t$e(
       [...model.roots()],
       applyElementPredicate(where),
-      t$m((root) => {
+      t$f((root) => {
         if (!root.onlyOneInstance()) {
           children.push(...root.children());
         }
@@ -2861,7 +2493,7 @@ const WildcardPredicate$1 = {
     return stage;
   },
   exclude: ({ stage, memory, where }) => {
-    const elementsToExclude = t$j(
+    const elementsToExclude = t$e(
       [...memory.elements],
       applyElementPredicate(where)
     );
@@ -2903,19 +2535,19 @@ function excludeModelRelations(relationsToExclude, { stage, memory }, where, fil
   if (relationsToExclude.size === 0) {
     return stage;
   }
-  const toExclude = t$j(
+  const toExclude = t$e(
     memory.connections,
-    n$f((c) => filterConnections(c)),
+    n$e((c) => filterConnections(c)),
     // Find connections that have at least one relation in common with the excluded relations
-    n$f((c) => hasIntersection(c.relations.model, relationsToExclude)),
-    t$m(
+    n$e((c) => hasIntersection(c.relations.model, relationsToExclude)),
+    t$f(
       (c) => c.update({
         deployment: null,
         model: intersection(c.relations.model, relationsToExclude)
       })
     ),
     applyPredicate(where),
-    n$f((c) => c.nonEmpty())
+    n$e((c) => c.nonEmpty())
   );
   if (toExclude.length === 0) {
     return stage;
@@ -2955,9 +2587,9 @@ function matchConnections(connections, where) {
   if (!where) {
     return connections;
   }
-  return t$j(
+  return t$e(
     connections,
-    n$f((c) => matchConnection(c, where))
+    n$e((c) => matchConnection(c, where))
   );
 }
 function toFilterable(relationEndpoint, connectionEndpoint) {
@@ -2969,7 +2601,7 @@ function toFilterable(relationEndpoint, connectionEndpoint) {
     };
   }
   if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) {
-    return t$5(relationEndpoint.element, ["tags", "kind"]);
+    return t$4(relationEndpoint.element, ["tags", "kind"]);
   }
   if (isDeployedInstanceModel(relationEndpoint)) {
     return {
@@ -2978,7 +2610,7 @@ function toFilterable(relationEndpoint, connectionEndpoint) {
     };
   }
   if (isDeploymentNodeModel(relationEndpoint)) {
-    return t$5(relationEndpoint, ["tags", "kind"]);
+    return t$4(relationEndpoint, ["tags", "kind"]);
   }
   nonexhaustive(relationEndpoint);
 }
@@ -3023,9 +2655,9 @@ const DeploymentRefPredicate = {
   },
   exclude: ({ expr, stage, memory, where }) => {
     const exprPredicate = deploymentExpressionToPredicate(expr);
-    const toExclude = t$j(
+    const toExclude = t$e(
       [...memory.elements],
-      n$f(exprPredicate),
+      n$e(exprPredicate),
       applyElementPredicate(where)
     );
     stage.exclude(toExclude);
@@ -3085,14 +2717,14 @@ function includeDeployedNodeDescendants(node, { stage, where }) {
   }
   stage.connectWithExisting(descendants, "out");
   const allConnected = findConnectedElements(stage);
-  t$j(
+  t$e(
     descendants,
-    n$f((desc) => allConnected.has(desc)),
-    t$b((desc) => stage.addExplicit(desc))
+    n$e((desc) => allConnected.has(desc)),
+    t$8((desc) => stage.addExplicit(desc))
   );
 }
 function findConnectedElements(stage) {
-  return t$j(
+  return t$e(
     stage.mergedConnections(),
     cleanCrossBoundary,
     cleanRedundantRelationships,
@@ -3115,7 +2747,7 @@ let StageFinal$1 = class StageFinal {
     if (memory.connections.length < 2) {
       return memory;
     }
-    const connections = t$j(
+    const connections = t$e(
       memory.connections,
       // Keep connections
       // - between leafs
@@ -3167,12 +2799,12 @@ let StageFinal$1 = class StageFinal {
       }
       return false;
     };
-    t$j(
+    t$e(
       difference(implicits, snapshot),
       ifilter((e) => e.isDeploymentNode()),
       toArray(),
       sortByFqnHierarchically,
-      t$b((el) => {
+      t$8((el) => {
         const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
         if (childrensToWrap >= 2) {
           final.add(el);
@@ -3195,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$q([...tree.root]);
+    const singleRoot = t$6([...tree.root]);
     if (singleRoot && !memory.explicits.has(singleRoot)) {
       stage.exclude(singleRoot);
     }
     for (const el of memory.final) {
-      const singleChild = t$q(tree.children(el));
+      const singleChild = t$6(tree.children(el));
       if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
         stage.exclude(el);
       }
@@ -3307,7 +2939,7 @@ function computeDeploymentView(likec4model, {
     rules,
     sorted.nodes
   );
-  const autoLayoutRule = t$d(rules, isViewRuleAutoLayout);
+  const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
   const elementNotations = buildElementNotations(nodes);
   return calcViewLayoutHash({
     ...view,
@@ -3319,7 +2951,7 @@ function computeDeploymentView(likec4model, {
       ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
     },
     edges: sorted.edges,
-    nodes: t$m(nodes, (n) => {
+    nodes: t$f(nodes, (n) => {
       if (n.icon === "none") {
         delete n.icon;
       }
@@ -3362,7 +2994,7 @@ function applyCustomElementProperties(_rules, _nodes) {
       textSize,
       description,
       ...rest
-    } = t$u(props, e$b);
+    } = t$o(props, e$b);
     const style = exact({
       border,
       opacity,
@@ -3371,8 +3003,8 @@ function applyCustomElementProperties(_rules, _nodes) {
       size,
       textSize
     });
-    const styleNotEmpty = !e$6(style);
-    const propsNotEmpty = !e$6(rest);
+    const styleNotEmpty = !e$5(style);
+    const propsNotEmpty = !e$5(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
       if (isGroupElementKind(node) || !satisfies(node)) {
@@ -3501,7 +3133,7 @@ function elementsFromSteps(model, steps) {
       actors.push(target);
     }
   };
-  for (const step of t$c(steps, flattenSteps)) {
+  for (const step of t$m(steps, flattenSteps)) {
     const source = model.element(step.source);
     const target = model.element(step.target);
     let sourceColumn = actors.indexOf(source);
@@ -3534,35 +3166,35 @@ function findRelations(source, target, currentViewId) {
       line: relation2.$relationship.line
     });
   }
-  const alltags = t$j(
+  const alltags = t$e(
     relationships,
-    t$c((r) => r.tags),
-    n$j()
+    t$m((r) => r.tags),
+    n$f()
   );
-  const tags = t$i(alltags, 1) ? alltags : void 0;
-  const relations = t$m(relationships, (r) => r.id);
-  const relation = n$d(relationships);
+  const tags = t$c(alltags, 1) ? alltags : void 0;
+  const relations = t$f(relationships, (r) => r.id);
+  const relation = n$a(relationships);
   let navigateTo = relation.$relationship.navigateTo;
   if (navigateTo === currentViewId) {
     navigateTo = void 0;
   }
   if (!navigateTo) {
-    navigateTo = t$j(
+    navigateTo = t$e(
       relationships,
-      t$c(
+      t$m(
         (r) => r.$relationship.navigateTo && r.$relationship.navigateTo !== currentViewId ? r.$relationship.navigateTo : []
       ),
-      n$j(),
-      t$q()
+      n$f(),
+      t$6()
     );
   }
-  const commonProperties = t$j(
+  const commonProperties = t$e(
     relationships,
     t$2((acc, { title, $relationship: r }) => {
-      e$5(title) && acc.title.add(title);
-      e$5(r.color) && acc.color.add(r.color);
-      e$5(r.line) && acc.line.add(r.line);
-      e$5(r.kind) && acc.kind.add(r.kind);
+      e$4(title) && acc.title.add(title);
+      e$4(r.color) && acc.color.add(r.color);
+      e$4(r.line) && acc.line.add(r.line);
+      e$4(r.kind) && acc.kind.add(r.kind);
       return acc;
     }, {
       kind: /* @__PURE__ */ new Set(),
@@ -3575,10 +3207,10 @@ function findRelations(source, target, currentViewId) {
     tags: tags ?? void 0,
     relations,
     navigateTo,
-    kind: t$q([...commonProperties.kind]),
-    title: t$q([...commonProperties.title]),
-    color: t$q([...commonProperties.color]),
-    line: t$q([...commonProperties.line])
+    kind: t$6([...commonProperties.kind]),
+    title: t$6([...commonProperties.title]),
+    color: t$6([...commonProperties.color]),
+    line: t$6([...commonProperties.line])
   });
 }
 
@@ -3601,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$j(
+    const actors = t$e(
       union(
         // First all actors, that are explicitly included
         intersection(explicits, fromSteps),
@@ -3657,7 +3289,7 @@ class DynamicViewCompute {
         navigateTo: derivedNavigateTo,
         ...derived
       } = findRelations(source, target, this.view.id);
-      const navigateTo = e$5(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
+      const navigateTo = e$4(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
       this.steps.push(exact({
         ...derived,
         ...rest,
@@ -3734,7 +3366,7 @@ class DynamicViewCompute {
         actors.map((e) => nonNullable(nodesMap.get(e.id)))
       )
     );
-    const autoLayoutRule = t$d(rules, isViewRuleAutoLayout);
+    const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
     const nodeNotations = buildElementNotations(nodes);
     return calcViewLayoutHash({
       ...view,
@@ -3746,7 +3378,7 @@ class DynamicViewCompute {
         ...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
         ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
       },
-      nodes: t$m(nodes, (n) => {
+      nodes: t$f(nodes, (n) => {
         if (n.icon === "none") {
           delete n.icon;
         }
@@ -3821,7 +3453,7 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
   } of rules) {
     const description = _description ? { description: { txt: _description } } : {};
     const notes = _notes ? { notes: { txt: _notes } } : {};
-    const props = t$u(customprops, e$b);
+    const props = t$o(customprops, e$b);
     const satisfies = relationExpressionToPredicates(expr);
     edges.forEach((edge, i) => {
       let source, target;
@@ -3839,7 +3471,7 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
       if (!source || !target) {
         return;
       }
-      if (satisfies({ source, target, ...t$5(edge, ["kind", "tags"]) })) {
+      if (satisfies({ source, target, ...t$4(edge, ["kind", "tags"]) })) {
         edges[i] = {
           ...edge,
           ...props,
@@ -3880,10 +3512,10 @@ class NodesGroup {
 
 class StageExclude extends AbstractStageExclude {
   excludeRelations(excluded) {
-    t$j(
+    t$e(
       this.memory.connections,
-      n$f((c) => hasIntersection(c.relations, excluded)),
-      t$b((c) => {
+      n$e((c) => hasIntersection(c.relations, excluded)),
+      t$8((c) => {
         this.excludeConnections(
           c.update(intersection(c.relations, excluded))
         );
@@ -3978,18 +3610,18 @@ class StageInclude extends AbstractStageInclude {
     if (ModelExpression.isRelationExpr(this.expression)) {
       return connections;
     }
-    t$j(
+    t$e(
       connections,
-      t$b(({ source, target, boundary }) => {
-        t$j(
-          t$t(
+      t$8(({ source, target, boundary }) => {
+        t$e(
+          t$n(
             [...toArray(source.ancestors()).reverse(), source],
             [...toArray(target.ancestors()).reverse(), target]
           ),
           // Filter out common ancestors
-          t$e(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
+          t$a(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
           n(1),
-          t$b(([sourceAncestor, targetAncestor]) => {
+          t$8(([sourceAncestor, targetAncestor]) => {
             if (sourceAncestor === source && targetAncestor === target) {
               this.addImplicitWithinScope(boundary);
               return;
@@ -4141,13 +3773,13 @@ class ActiveGroupMemory extends Memory {
 }
 
 function findRedundantConnections(connections) {
-  return t$j(
+  return t$e(
     [...connections],
     mergeConnections,
     t$2((reducedConnections, connection, _, all) => {
       const descendants = findDescendantConnections(all, connection);
       const nestedRelations = union(
-        ...descendants.map(e$4("relations"))
+        ...descendants.map(e$8("relations"))
       );
       let accum = intersection(connection.relations, nestedRelations);
       if (descendants.length > 0) {
@@ -4221,11 +3853,11 @@ class StageFinal {
       }
       return false;
     };
-    t$j(
+    t$e(
       difference(implicits, snapshot),
       toArray(),
       sortByFqnHierarchically,
-      t$b((el) => {
+      t$8((el) => {
         const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length;
         if (childrensToWrap >= 2) {
           final.add(el);
@@ -4248,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$q([...tree.root]);
+    const singleRoot = t$6([...tree.root]);
     if (singleRoot && !memory.explicits.has(singleRoot)) {
       stage.exclude(singleRoot);
     }
     for (const el of memory.final) {
-      const singleChild = t$q(tree.children(el));
+      const singleChild = t$6(tree.children(el));
       if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
         stage.exclude(el);
       }
@@ -4307,7 +3939,7 @@ function includeDescendantsFromMemory(elements, memory) {
   if (memory.isEmpty() || elements.length === 0) {
     return elements;
   }
-  const descedantsOf = t$p(elements.map((e) => isDescendantOf(e)));
+  const descedantsOf = t$h(elements.map((e) => isDescendantOf(e)));
   const fromMemory = toArray(
     ifilter(
       memory.elements,
@@ -4398,7 +4030,7 @@ function toComputedEdges(connections) {
     const relations = [
       ...e.relations
     ];
-    invariant(t$i(relations, 1), "Edge must have at least one relation");
+    invariant(t$c(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;
@@ -4412,8 +4044,8 @@ function toComputedEdges(connections) {
       relations.map((r) => r.$relationship),
       // Prefer only single relationship
       // https://github.com/likec4/likec4/issues/1423
-      t$q(
-        n$f(relations, (r) => r.source.id === source && r.target.id === target)
+      t$6(
+        n$e(relations, (r) => r.source.id === source && r.target.id === target)
       )?.$relationship
     );
     const edge = exact({
@@ -4451,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$j(
+        const connections2 = t$e(
           model.relationships(),
           ifilter(where),
           toArray(),
-          t$m((r) => new ConnectionModel(r.source, r.target, /* @__PURE__ */ new Set([r])))
+          t$f((r) => new ConnectionModel(r.source, r.target, /* @__PURE__ */ new Set([r])))
         );
         stage.addConnections(connections2);
         return stage;
@@ -4479,10 +4111,10 @@ const DirectRelationExprPredicate = {
       // element -> *; Where clause
       case (!sourceIsWildcard && targetIsWildcard && where !== NoWhere): {
         const sources = resolveElements(model, source);
-        const connections2 = t$j(
+        const connections2 = t$e(
           sources,
-          t$c(
-            (source2) => t$j(
+          t$m(
+            (source2) => t$e(
               source2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4491,12 +4123,12 @@ const DirectRelationExprPredicate = {
               ifilter(where),
               iunique(),
               toArray(),
-              t$6((r) => r.source === source2),
-              ([outgoing, incoming]) => t$f(
-                t$j(
+              t$5((r) => r.source === source2),
+              ([outgoing, incoming]) => t$p(
+                t$e(
                   outgoing,
-                  n$f((r) => !isAncestorOrDescendantOf(source2, r.target)),
-                  t$m(
+                  n$e((r) => !isAncestorOrDescendantOf(source2, r.target)),
+                  t$f(
                     (outgoing2) => new ConnectionModel(
                       source2,
                       outgoing2.target,
@@ -4504,10 +4136,10 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                t$j(
+                t$e(
                   incoming,
-                  n$f((r) => !isAncestorOrDescendantOf(source2, r.source)),
-                  t$m(
+                  n$e((r) => !isAncestorOrDescendantOf(source2, r.source)),
+                  t$f(
                     (incoming2) => new ConnectionModel(
                       incoming2.source,
                       source2,
@@ -4537,10 +4169,10 @@ const DirectRelationExprPredicate = {
       // * -> element; Where clause
       case (sourceIsWildcard && !targetIsWildcard && where !== NoWhere): {
         const targets = resolveElements(model, target);
-        const connections2 = t$j(
+        const connections2 = t$e(
           targets,
-          t$c(
-            (target2) => t$j(
+          t$m(
+            (target2) => t$e(
               target2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4548,12 +4180,12 @@ const DirectRelationExprPredicate = {
               }),
               ifilter(where),
               toArray(),
-              t$6((r) => r.target === target2),
-              ([incoming, outgoing]) => t$f(
-                t$j(
+              t$5((r) => r.target === target2),
+              ([incoming, outgoing]) => t$p(
+                t$e(
                   outgoing,
-                  n$f((r) => !isAncestorOrDescendantOf(target2, r.target)),
-                  t$m(
+                  n$e((r) => !isAncestorOrDescendantOf(target2, r.target)),
+                  t$f(
                     (outgoing2) => new ConnectionModel(
                       target2,
                       outgoing2.target,
@@ -4561,10 +4193,10 @@ const DirectRelationExprPredicate = {
                     )
                   )
                 ),
-                t$j(
+                t$e(
                   incoming,
-                  n$f((r) => !isAncestorOrDescendantOf(target2, r.source)),
-                  t$m(
+                  n$e((r) => !isAncestorOrDescendantOf(target2, r.source)),
+                  t$f(
                     (incoming2) => new ConnectionModel(
                       incoming2.source,
                       target2,
@@ -4615,10 +4247,10 @@ const DirectRelationExprPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        relations = t$j(
+        relations = t$e(
           memory.connections,
-          t$c(t$3(
-            e$4("relations"),
+          t$m(t$j(
+            e$8("relations"),
             ifilter(where),
             toArray()
           )),
@@ -4629,10 +4261,10 @@ const DirectRelationExprPredicate = {
       // element -> *
       case (!sourceIsWildcard && targetIsWildcard): {
         const sources = resolveElements(model, source);
-        relations = t$j(
+        relations = t$e(
           sources,
-          t$c(
-            (source2) => t$j(
+          t$m(
+            (source2) => t$e(
               source2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4649,10 +4281,10 @@ const DirectRelationExprPredicate = {
       // * -> element
       case (sourceIsWildcard && !targetIsWildcard): {
         const targets = resolveElements(model, target);
-        relations = t$j(
+        relations = t$e(
           targets,
-          t$c(
-            (target2) => t$j(
+          t$m(
+            (target2) => t$e(
               target2,
               e(e$3(isBidirectional === true), {
                 onTrue: (s) => union(s.allIncoming, s.allOutgoing),
@@ -4693,7 +4325,7 @@ const DirectRelationExprPredicate = {
 };
 function resolveWildcard(nonWildcard, { memory, model }) {
   let sources = resolveElements(model, nonWildcard);
-  if (!t$i(sources, 1)) {
+  if (!t$c(sources, 1)) {
     return [[], []];
   }
   if (ModelFqnExpr.isModelRef(nonWildcard)) {
@@ -4704,9 +4336,9 @@ function resolveWildcard(nonWildcard, { memory, model }) {
       includeDescendantsFromMemory(targets2, memory)
     ];
   }
-  const targets = t$j(
+  const targets = t$e(
     sources,
-    t$m((el) => el.ascendingSiblings()),
+    t$f((el) => el.ascendingSiblings()),
     iflat(),
     iunique(),
     toArray(),
@@ -4737,7 +4369,7 @@ const IncomingExprPredicate = {
       const visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
         visibleElements.push(
-          ...n$j(
+          ...n$f(
             targets.flatMap((el) => [...el.ascendingSiblings()])
           )
         );
@@ -4784,7 +4416,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "children"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p(
+      return t$h(
         [...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
         )
@@ -4792,7 +4424,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p([
+      return t$h([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
           (el) => Connection.isIncoming(el.id)
@@ -4801,7 +4433,7 @@ function incomingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p([
+      return t$h([
         Connection.isIncoming(fqn),
         Connection.isInside(fqn)
       ]);
@@ -4832,7 +4464,7 @@ const InOutRelationPredicate = {
       const elements = resolveAndIncludeFromMemory(inout, { memory, model });
       let visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
-        visibleElements = n$j(
+        visibleElements = n$f(
           elements.flatMap((el) => toArray(el.ascendingSiblings()))
         );
       }
@@ -4889,7 +4521,7 @@ const OutgoingExprPredicate = {
       const visibleElements = [...memory.elements];
       if (visibleElements.length === 0) {
         visibleElements.push(
-          ...n$j(
+          ...n$f(
             elements.flatMap((el) => [...el.ascendingSiblings()])
           )
         );
@@ -4938,7 +4570,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "children"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p(
+      return t$h(
         [...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
         )
@@ -4946,7 +4578,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "descendants"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p([
+      return t$h([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
           (el) => Connection.isOutgoing(el.id)
@@ -4955,7 +4587,7 @@ function outgoingConnectionPredicate(model, expr) {
     }
     case (ModelFqnExpr.isModelRef(expr) && expr.selector === "expanded"): {
       const fqn = FqnRef.flatten(expr.ref);
-      return t$p([
+      return t$h([
         Connection.isOutgoing(fqn),
         Connection.isInside(fqn)
       ]);
@@ -5020,7 +4652,7 @@ const WildcardPredicate = {
   exclude: ({ scope, memory, stage, where }) => {
     if (where !== NoWhere) {
       stage.exclude(
-        n$f(
+        n$e(
           [...memory.elements],
           where
         )
@@ -5046,7 +4678,7 @@ function processElementPredicate(expr, op, ctx) {
     case ModelFqnExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition);
       const filterWhere = (elements) => {
-        return n$f(elements, where);
+        return n$e(elements, where);
       };
       return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere });
     }
@@ -5078,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$f([...relations], where));
+        return new Set(n$e([...relations], where));
       };
       const filterWhere = (connections) => {
-        return t$j(
+        return t$e(
           connections,
-          t$m((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
-          n$f((c) => c.nonEmpty())
+          t$f((c) => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
+          n$e((c) => c.nonEmpty())
         );
       };
       return processRelationtPredicate(expr.where.expr, op, {
@@ -5190,7 +4822,7 @@ function computeElementView(likec4model, {
       sorted.nodes
     )
   );
-  const autoLayoutRule = t$d(rules, isViewRuleAutoLayout);
+  const autoLayoutRule = t$9(rules, isViewRuleAutoLayout);
   const nodeNotations = buildElementNotations(nodes);
   return calcViewLayoutHash({
     ...view,
@@ -5201,7 +4833,7 @@ function computeElementView(likec4model, {
       ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
     },
     edges: applyCustomRelationProperties(rules, nodes, sorted.edges),
-    nodes: t$m(nodes, (n) => {
+    nodes: t$f(nodes, (n) => {
       if (n.icon === "none") {
         delete n.icon;
       }
@@ -5242,9 +4874,9 @@ function assignElementsToGroups(memory) {
     }
     return false;
   };
-  t$j(
+  t$e(
     sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
-    t$b((el) => {
+    t$8((el) => {
       if (!isAncestorAssigned(el)) {
         const groupId = nonNullable(memory.explicitFirstSeenIn.get(el));
         assignedTo.set(el, groupId);
@@ -5252,10 +4884,10 @@ function assignElementsToGroups(memory) {
       }
     })
   );
-  t$j(
+  t$e(
     sortParentsFirst([...memory.lastSeenIn.keys()]),
-    n$f((el) => !assignedTo.has(el)),
-    t$b((el) => {
+    n$e((el) => !assignedTo.has(el)),
+    t$8((el) => {
       if (isAncestorAssigned(el)) {
         return;
       }
@@ -5308,15 +4940,20 @@ function computeView(viewsource, likec4model) {
 }
 function computeParsedModelData(parsed) {
   const likec4model = LikeC4Model.create(parsed);
-  const views = t$s(parsed.views).map((v) => unsafeComputeView(v, likec4model));
+  let {
+    views: _views,
+    _stage: __omitted,
+    ...rest
+  } = parsed;
+  const views = t$q(_views, (v) => unsafeComputeView(v, likec4model));
   return {
-    ...parsed,
     [_stage]: "computed",
-    views: t$9(views, (v) => v.id)
+    ...rest,
+    views
   };
 }
 function computeLikeC4Model(parsed) {
   return LikeC4Model.create(computeParsedModelData(parsed));
 }
 
-export { t$7 as a, t$8 as b, computeLikeC4Model as c, computeParsedModelData as d, computeView as e, n$6 as n, topologicalSortExports as t, unsafeComputeView as u, willCreateCycle as w };
+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 };