@likec4/core 1.19.1 → 1.20.0

package/dist/shared/{index.DafVOuVd.js → core.CqCTxzMY.mjs}

@@ -1,13 +1,610 @@
-import { O as x, P as s$1, Q as a$4, k as hierarchyLevel, o as isAncestor, f as commonAncestor, r as sortNaturalByFqn, m as m$3, c as commonHead, R as getDefaultExportFromCjs, S as requireForeach, T as requireIterator, U as u$7, N as objectHash, J as intersection, H as difference, L as union, M as stringHash, I as equals, x as isString, q as isDescendantOf, a as isSameHierarchy, C as isome, y as ifilter, B as isIterable, G as toSet, u as sortParentsFirst, F as toArray, D as DefaultMap, A as imap, i as i$9, V as d$6, p as parentFqn, W as n$5, g as compareByFqnHierarchically, w as isNonEmptyArray, d as compareNatural, n as nameFromFqn, t as t$6, l as l$7, X as hasIntersection, s as sortByFqnHierarchically, e as ancestorsFqn, E as iunique, z as iflat, v as getOrCreate } from './object_hash.CE_oF3I3.js';
-import { e as DefaultElementShape, d as DefaultThemeColor, a7 as o$9, q as isElementWhere, M as whereOperatorAsPredicate, z as isWildcard, l as isElementKindExpr, p as isElementTagExpr, n as n$4, r as isExpandedElementExpr, m as isElementRef, h as isCustomElement, a5 as isViewRuleStyle, a8 as y$1, Q as ComputedNode, E as ElementKind, N as DefaultArrowType, F as FqnExpr, a4 as isViewRulePredicate, R as RelationExpr, a0 as isViewRuleAutoLayout, a3 as isViewRuleGroup, a1 as isViewRuleGlobalPredicateRef, a2 as isViewRuleGlobalStyle, a6 as stepEdgeId, _ as isDynamicViewParallelSteps, P as DefaultRelationshipColor, O as DefaultLineStyle, u as isOutgoing$1, s as isIncoming$1, t as isInOut, v as isRelation, y as isRelationWhere, j as isCustomRelationExpr, x as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, Z as isDynamicView, Y as isDeploymentView, D as DeploymentElement, U as extractStep, $ as isStepEdgeId, c as isScopedElementView } from './view.CyZrG8BJ.js';
-import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './chunk-RAAYCPUM.M-JWF7SS.js';
+import { g as getDefaultExportFromCjs, P as x, Q as s$1, R as a$4, r as hierarchyLevel, s as isAncestor, j as commonAncestor, w as sortNaturalByFqn, m as m$3, e as commonHead, S as u$7, O as objectHash, K as intersection, I as difference, M as union, N as stringHash, J as equals, A as isString, u as isDescendantOf, c as isSameHierarchy, F as isome, B as ifilter, E as isIterable, t as toSet, x as sortParentsFirst, H as toArray, D as imap, a as i$9, T as d$6, p as parentFqn, U as n$5, k as compareByFqnHierarchically, z as isNonEmptyArray, f as compareNatural, n as nameFromFqn, b as t$6, V as hasIntersection, l as l$7, v as sortByFqnHierarchically, h as ancestorsFqn, G as iunique, C as iflat, y as getOrCreate, i as ifind } from './core.BxvDITEI.mjs';
+import { e as DefaultElementShape, d as DefaultThemeColor, a7 as o$9, q as isElementWhere, M as whereOperatorAsPredicate, z as isWildcard, l as isElementKindExpr, p as isElementTagExpr, n as n$4, r as isExpandedElementExpr, m as isElementRef, h as isCustomElement, a5 as isViewRuleStyle, a8 as y$1, Q as ComputedNode, E as ElementKind, N as DefaultArrowType, F as FqnExpr, R as RelationExpr, o as o$a, a4 as isViewRulePredicate, a0 as isViewRuleAutoLayout, a3 as isViewRuleGroup, a1 as isViewRuleGlobalPredicateRef, a2 as isViewRuleGlobalStyle, a6 as stepEdgeId, _ as isDynamicViewParallelSteps, P as DefaultRelationshipColor, O as DefaultLineStyle, u as isOutgoing$1, s as isIncoming$1, t as isInOut, v as isRelation, y as isRelationWhere, j as isCustomRelationExpr, x as isRelationPredicateExpr, b as isElementPredicateExpr, a as isElementView, Z as isDynamicView, Y as isDeploymentView, D as DeploymentElement, U as extractStep, $ as isStepEdgeId, c as isScopedElementView } from './core.DunIMHRf.mjs';
+import { u as u$6, a as nonNullable, i as invariant, n as nonexhaustive } from './core.M-JWF7SS.mjs';
 
-function r$3(...t){return u$6(Object.values,t)}
+/**
+ * Mnemonist DefaultMap
+ * =====================
+ *
+ * JavaScript implementation of a default map that will return a constructed
+ * value any time one tries to access an inexisting key. It's quite similar
+ * to python's defaultdict.
+ */
+
+var defaultMap;
+var hasRequiredDefaultMap;
+
+function requireDefaultMap () {
+	if (hasRequiredDefaultMap) return defaultMap;
+	hasRequiredDefaultMap = 1;
+	/**
+	 * DefaultMap.
+	 *
+	 * @constructor
+	 */
+	function DefaultMap(factory) {
+	  if (typeof factory !== 'function')
+	    throw new Error('mnemonist/DefaultMap.constructor: expecting a function.');
+
+	  this.items = new Map();
+	  this.factory = factory;
+	  this.size = 0;
+	}
+
+	/**
+	 * Method used to clear the structure.
+	 *
+	 * @return {undefined}
+	 */
+	DefaultMap.prototype.clear = function() {
+
+	  // Properties
+	  this.items.clear();
+	  this.size = 0;
+	};
+
+	/**
+	 * Method used to get the value set for given key. If the key does not exist,
+	 * the value will be created using the provided factory.
+	 *
+	 * @param  {any} key - Target key.
+	 * @return {any}
+	 */
+	DefaultMap.prototype.get = function(key) {
+	  var value = this.items.get(key);
+
+	  if (typeof value === 'undefined') {
+	    value = this.factory(key, this.size);
+	    this.items.set(key, value);
+	    this.size++;
+	  }
+
+	  return value;
+	};
+
+	/**
+	 * Method used to get the value set for given key. If the key does not exist,
+	 * a value won't be created.
+	 *
+	 * @param  {any} key - Target key.
+	 * @return {any}
+	 */
+	DefaultMap.prototype.peek = function(key) {
+	  return this.items.get(key);
+	};
+
+	/**
+	 * Method used to set a value for given key.
+	 *
+	 * @param  {any} key   - Target key.
+	 * @param  {any} value - Value.
+	 * @return {DefaultMap}
+	 */
+	DefaultMap.prototype.set = function(key, value) {
+	  this.items.set(key, value);
+	  this.size = this.items.size;
+
+	  return this;
+	};
+
+	/**
+	 * Method used to test the existence of a key in the map.
+	 *
+	 * @param  {any} key   - Target key.
+	 * @return {boolean}
+	 */
+	DefaultMap.prototype.has = function(key) {
+	  return this.items.has(key);
+	};
+
+	/**
+	 * Method used to delete target key.
+	 *
+	 * @param  {any} key   - Target key.
+	 * @return {boolean}
+	 */
+	DefaultMap.prototype.delete = function(key) {
+	  var deleted = this.items.delete(key);
+
+	  this.size = this.items.size;
+
+	  return deleted;
+	};
+
+	/**
+	 * Method used to iterate over each of the key/value pairs.
+	 *
+	 * @param  {function}  callback - Function to call for each item.
+	 * @param  {object}    scope    - Optional scope.
+	 * @return {undefined}
+	 */
+	DefaultMap.prototype.forEach = function(callback, scope) {
+	  scope = arguments.length > 1 ? scope : this;
+
+	  this.items.forEach(callback, scope);
+	};
+
+	/**
+	 * Iterators.
+	 */
+	DefaultMap.prototype.entries = function() {
+	  return this.items.entries();
+	};
+
+	DefaultMap.prototype.keys = function() {
+	  return this.items.keys();
+	};
+
+	DefaultMap.prototype.values = function() {
+	  return this.items.values();
+	};
+
+	/**
+	 * Attaching the #.entries method to Symbol.iterator if possible.
+	 */
+	if (typeof Symbol !== 'undefined')
+	  DefaultMap.prototype[Symbol.iterator] = DefaultMap.prototype.entries;
+
+	/**
+	 * Convenience known methods.
+	 */
+	DefaultMap.prototype.inspect = function() {
+	  return this.items;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  DefaultMap.prototype[Symbol.for('nodejs.util.inspect.custom')] = DefaultMap.prototype.inspect;
+
+	/**
+	 * Typical factories.
+	 */
+	DefaultMap.autoIncrement = function() {
+	  var i = 0;
+
+	  return function() {
+	    return i++;
+	  };
+	};
+
+	/**
+	 * Exporting.
+	 */
+	defaultMap = DefaultMap;
+	return defaultMap;
+}
+
+var defaultMapExports = requireDefaultMap();
+const DefaultMap = /*@__PURE__*/getDefaultExportFromCjs(defaultMapExports);
+
+/**
+ * Obliterator Iterator Class
+ * ===========================
+ *
+ * Simple class representing the library's iterators.
+ */
+
+var iterator;
+var hasRequiredIterator;
+
+function requireIterator () {
+	if (hasRequiredIterator) return iterator;
+	hasRequiredIterator = 1;
+	/**
+	 * Iterator class.
+	 *
+	 * @constructor
+	 * @param {function} next - Next function.
+	 */
+	function Iterator(next) {
+	  if (typeof next !== 'function')
+	    throw new Error('obliterator/iterator: expecting a function!');
+
+	  this.next = next;
+	}
+
+	/**
+	 * If symbols are supported, we add `next` to `Symbol.iterator`.
+	 */
+	if (typeof Symbol !== 'undefined')
+	  Iterator.prototype[Symbol.iterator] = function () {
+	    return this;
+	  };
+
+	/**
+	 * Returning an iterator of the given values.
+	 *
+	 * @param  {any...} values - Values.
+	 * @return {Iterator}
+	 */
+	Iterator.of = function () {
+	  var args = arguments,
+	    l = args.length,
+	    i = 0;
+
+	  return new Iterator(function () {
+	    if (i >= l) return {done: true};
+
+	    return {done: false, value: args[i++]};
+	  });
+	};
+
+	/**
+	 * Returning an empty iterator.
+	 *
+	 * @return {Iterator}
+	 */
+	Iterator.empty = function () {
+	  var iterator = new Iterator(function () {
+	    return {done: true};
+	  });
+
+	  return iterator;
+	};
+
+	/**
+	 * Returning an iterator over the given indexed sequence.
+	 *
+	 * @param  {string|Array} sequence - Target sequence.
+	 * @return {Iterator}
+	 */
+	Iterator.fromSequence = function (sequence) {
+	  var i = 0,
+	    l = sequence.length;
+
+	  return new Iterator(function () {
+	    if (i >= l) return {done: true};
+
+	    return {done: false, value: sequence[i++]};
+	  });
+	};
+
+	/**
+	 * Returning whether the given value is an iterator.
+	 *
+	 * @param  {any} value - Value.
+	 * @return {boolean}
+	 */
+	Iterator.is = function (value) {
+	  if (value instanceof Iterator) return true;
+
+	  return (
+	    typeof value === 'object' &&
+	    value !== null &&
+	    typeof value.next === 'function'
+	  );
+	};
+
+	/**
+	 * Exporting.
+	 */
+	iterator = Iterator;
+	return iterator;
+}
+
+var support = {};
+
+var hasRequiredSupport;
+
+function requireSupport () {
+	if (hasRequiredSupport) return support;
+	hasRequiredSupport = 1;
+	support.ARRAY_BUFFER_SUPPORT = typeof ArrayBuffer !== 'undefined';
+	support.SYMBOL_SUPPORT = typeof Symbol !== 'undefined';
+	return support;
+}
+
+/**
+ * Obliterator ForEach Function
+ * =============================
+ *
+ * Helper function used to easily iterate over mixed values.
+ */
+
+var foreach;
+var hasRequiredForeach;
+
+function requireForeach () {
+	if (hasRequiredForeach) return foreach;
+	hasRequiredForeach = 1;
+	var support = requireSupport();
+
+	var ARRAY_BUFFER_SUPPORT = support.ARRAY_BUFFER_SUPPORT;
+	var SYMBOL_SUPPORT = support.SYMBOL_SUPPORT;
+
+	/**
+	 * Function able to iterate over almost any iterable JS value.
+	 *
+	 * @param  {any}      iterable - Iterable value.
+	 * @param  {function} callback - Callback function.
+	 */
+	foreach = function forEach(iterable, callback) {
+	  var iterator, k, i, l, s;
+
+	  if (!iterable) throw new Error('obliterator/forEach: invalid iterable.');
+
+	  if (typeof callback !== 'function')
+	    throw new Error('obliterator/forEach: expecting a callback.');
+
+	  // The target is an array or a string or function arguments
+	  if (
+	    Array.isArray(iterable) ||
+	    (ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable)) ||
+	    typeof iterable === 'string' ||
+	    iterable.toString() === '[object Arguments]'
+	  ) {
+	    for (i = 0, l = iterable.length; i < l; i++) callback(iterable[i], i);
+	    return;
+	  }
+
+	  // The target has a #.forEach method
+	  if (typeof iterable.forEach === 'function') {
+	    iterable.forEach(callback);
+	    return;
+	  }
+
+	  // The target is iterable
+	  if (
+	    SYMBOL_SUPPORT &&
+	    Symbol.iterator in iterable &&
+	    typeof iterable.next !== 'function'
+	  ) {
+	    iterable = iterable[Symbol.iterator]();
+	  }
+
+	  // The target is an iterator
+	  if (typeof iterable.next === 'function') {
+	    iterator = iterable;
+	    i = 0;
+
+	    while (((s = iterator.next()), s.done !== true)) {
+	      callback(s.value, i);
+	      i++;
+	    }
+
+	    return;
+	  }
+
+	  // The target is a plain object
+	  for (k in iterable) {
+	    if (iterable.hasOwnProperty(k)) {
+	      callback(iterable[k], k);
+	    }
+	  }
+
+	  return;
+	};
+	return foreach;
+}
+
+/**
+ * Mnemonist Stack
+ * ================
+ *
+ * Stack implementation relying on JavaScript arrays, which are fast enough &
+ * correctly optimized for this kind of work.
+ */
+
+var stack;
+var hasRequiredStack;
+
+function requireStack () {
+	if (hasRequiredStack) return stack;
+	hasRequiredStack = 1;
+	var Iterator = requireIterator(),
+	    forEach = requireForeach();
+
+	/**
+	 * Stack
+	 *
+	 * @constructor
+	 */
+	function Stack() {
+	  this.clear();
+	}
+
+	/**
+	 * Method used to clear the stack.
+	 *
+	 * @return {undefined}
+	 */
+	Stack.prototype.clear = function() {
+
+	  // Properties
+	  this.items = [];
+	  this.size = 0;
+	};
+
+	/**
+	 * Method used to add an item to the stack.
+	 *
+	 * @param  {any}    item - Item to add.
+	 * @return {number}
+	 */
+	Stack.prototype.push = function(item) {
+	  this.items.push(item);
+	  return ++this.size;
+	};
+
+	/**
+	 * Method used to retrieve & remove the last item of the stack.
+	 *
+	 * @return {any}
+	 */
+	Stack.prototype.pop = function() {
+	  if (this.size === 0)
+	    return;
+
+	  this.size--;
+	  return this.items.pop();
+	};
+
+	/**
+	 * Method used to get the last item of the stack.
+	 *
+	 * @return {any}
+	 */
+	Stack.prototype.peek = function() {
+	  return this.items[this.size - 1];
+	};
+
+	/**
+	 * Method used to iterate over the stack.
+	 *
+	 * @param  {function}  callback - Function to call for each item.
+	 * @param  {object}    scope    - Optional scope.
+	 * @return {undefined}
+	 */
+	Stack.prototype.forEach = function(callback, scope) {
+	  scope = arguments.length > 1 ? scope : this;
+
+	  for (var i = 0, l = this.items.length; i < l; i++)
+	    callback.call(scope, this.items[l - i - 1], i, this);
+	};
+
+	/**
+	 * Method used to convert the stack to a JavaScript array.
+	 *
+	 * @return {array}
+	 */
+	Stack.prototype.toArray = function() {
+	  var array = new Array(this.size),
+	      l = this.size - 1,
+	      i = this.size;
+
+	  while (i--)
+	    array[i] = this.items[l - i];
+
+	  return array;
+	};
+
+	/**
+	 * Method used to create an iterator over a stack's values.
+	 *
+	 * @return {Iterator}
+	 */
+	Stack.prototype.values = function() {
+	  var items = this.items,
+	      l = items.length,
+	      i = 0;
+
+	  return new Iterator(function() {
+	    if (i >= l)
+	      return {
+	        done: true
+	      };
+
+	    var value = items[l - i - 1];
+	    i++;
+
+	    return {
+	      value: value,
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Method used to create an iterator over a stack's entries.
+	 *
+	 * @return {Iterator}
+	 */
+	Stack.prototype.entries = function() {
+	  var items = this.items,
+	      l = items.length,
+	      i = 0;
+
+	  return new Iterator(function() {
+	    if (i >= l)
+	      return {
+	        done: true
+	      };
+
+	    var value = items[l - i - 1];
+
+	    return {
+	      value: [i++, value],
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Attaching the #.values method to Symbol.iterator if possible.
+	 */
+	if (typeof Symbol !== 'undefined')
+	  Stack.prototype[Symbol.iterator] = Stack.prototype.values;
 
-function d$5(...e){return e.length===2?(n,...r)=>t$5(n,...e,...r):t$5(...e)}var t$5=(e,n,r,...a)=>n(e,...a)?typeof r=="function"?r(e,...a):r.onTrue(e,...a):typeof r=="function"?e:r.onFalse(e,...a);
+
+	/**
+	 * Convenience known methods.
+	 */
+	Stack.prototype.toString = function() {
+	  return this.toArray().join(',');
+	};
+
+	Stack.prototype.toJSON = function() {
+	  return this.toArray();
+	};
+
+	Stack.prototype.inspect = function() {
+	  var array = this.toArray();
+
+	  // Trick so that node displays the name of the constructor
+	  Object.defineProperty(array, 'constructor', {
+	    value: Stack,
+	    enumerable: false
+	  });
+
+	  return array;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  Stack.prototype[Symbol.for('nodejs.util.inspect.custom')] = Stack.prototype.inspect;
+
+	/**
+	 * Static @.from function taking an arbitrary iterable & converting it into
+	 * a stack.
+	 *
+	 * @param  {Iterable} iterable   - Target iterable.
+	 * @return {Stack}
+	 */
+	Stack.from = function(iterable) {
+	  var stack = new Stack();
+
+	  forEach(iterable, function(value) {
+	    stack.push(value);
+	  });
+
+	  return stack;
+	};
+
+	/**
+	 * Static @.of function taking an arbitrary number of arguments & converting it
+	 * into a stack.
+	 *
+	 * @param  {...any} args
+	 * @return {Stack}
+	 */
+	Stack.of = function() {
+	  return Stack.from(arguments);
+	};
+
+	/**
+	 * Exporting.
+	 */
+	stack = Stack;
+	return stack;
+}
+
+var stackExports = requireStack();
+const Stack = /*@__PURE__*/getDefaultExportFromCjs(stackExports);
 
 function f(t,i){let o=i.length-t.length;if(o===1){let[n,...r]=i;return x(n,{lazy:t,lazyArgs:r})}if(o===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>x(e,n),n)}throw new Error("Wrong number of arguments")}
 
+function r$3(...t){return u$6(Object.values,t)}
+
+function d$5(...e){return e.length===2?(n,...r)=>t$5(n,...e,...r):t$5(...e)}var t$5=(e,n,r,...a)=>n(e,...a)?typeof r=="function"?r(e,...a):r.onTrue(e,...a):typeof r=="function"?e:r.onFalse(e,...a);
+
 function i$8(...e){return f(o$8,e)}function o$8(){let e=new Set;return t=>e.has(t)?s$1:(e.add(t),{done:!1,hasNext:!0,next:t})}
 
 function l$6(...e){return u$6(o$7,e,u$5)}var o$7=(e,r)=>r<0?[]:e.slice(0,r);function u$5(e){if(e<=0)return a$4;let r=e;return a=>(r-=1,{done:r<=0,hasNext:!0,next:a})}
@@ -22,50 +619,50 @@ function l$5(...e){return u$6(u$3,e)}var u$3=(e,a,n)=>e.reduce(a,n);
 
 function t$4(...e){return u$6(r$2,e)}function r$2(e){return [...e].reverse()}
 
-function i$7(...e){return u$6(o$5,e)}function o$5(e,n){let t={};for(let r of n)r in e&&(t[r]=e[r]);return t}
+function p$1(...e){return u$6(t$3,e)}var t$3=(e,o)=>e[o];
 
-function d$3(...e){return u$6(i$6,e)}function i$6(e,o){let t={};for(let[r,n]of Object.entries(e))o(n,r,e)&&(t[r]=n);return t}
+function d$3(...r){return u$6(i$7,r)}var i$7=(r,t)=>{let a=[[],[]];for(let[o,e]of r.entries())t(e,o,r)?a[0].push(e):a[1].push(e);return a};
 
-function i$5(...n){return o=>x(o,...n)}
+function i$6(...e){return u$6(o$5,e)}function o$5(e,n){let t={};for(let r of n)r in e&&(t[r]=e[r]);return t}
 
-function p$1(...n){return u$6(t$3,n)}var t$3=(n,e)=>n[e];
+function d$2(...e){return u$6(i$5,e)}function i$5(e,o){let t={};for(let[r,n]of Object.entries(e))o(n,r,e)&&(t[r]=n);return t}
 
-function d$2(...e){return u$6(l$4,e)}function l$4(e,a){let t={...e};for(let[n,o]of Object.entries(t))a(o,n,e)&&delete t[n];return t}
+function i$4(...n){return o=>x(o,...n)}
 
-function t$2(...n){return u$6(o$4,n)}var o$4=n=>n.length===1?n[0]:void 0;
+function d$1(...e){return u$6(l$4,e)}function l$4(e,a){let t={...e};for(let[n,o]of Object.entries(t))a(o,n,e)&&delete t[n];return t}
 
-function d$1(...r){return u$6(i$4,r)}var i$4=(r,t)=>{let a=[[],[]];for(let[o,e]of r.entries())t(e,o,r)?a[0].push(e):a[1].push(e);return a};
+function t$2(...n){return u$6(o$4,n)}var o$4=n=>n.length===1?n[0]:void 0;
 
-function a$2(...e){return u$6(n$2,e)}var n$2=e=>e.at(-1);
+function i$3(...e){return u$6(o$3,e)}function o$3(e,r){let a={};for(let[n,u]of Object.entries(e)){let l=r(u,n,e);a[n]=l;}return a}
 
-function l$3(...n){return u$6(d,n)}function d(n,o){let e={};for(let[a,t]of n.entries()){let[y,u]=o(t,a,n);e[y]=u;}return e}
+function n$2(e){return !!e}
 
-function i$3(...e){return u$6(o$3,e)}function o$3(e,r){let a={};for(let[n,u]of Object.entries(e)){let l=r(u,n,e);a[n]=l;}return a}
+function a$2(...e){return u$6(n$1,e)}var n$1=e=>e.at(-1);
 
-function n$1(e){return !!e}
+function l$3(...n){return u$6(d,n)}function d(n,o){let e={};for(let[a,t]of n.entries()){let[y,u]=o(t,a,n);e[y]=u;}return e}
 
 function e$1(r){return typeof r=="number"&&!Number.isNaN(r)}
 
+function n(e){return e===void 0?!0:typeof e=="string"||Array.isArray(e)?e.length===0:Object.keys(e).length===0}
+
 function e(o){return typeof o=="boolean"}
 
-function n(e){return e===void 0?!0:typeof e=="string"||Array.isArray(e)?e.length===0:Object.keys(e).length===0}
+function i$2(...e){return u$6(p,e)}var p=(e,a)=>{let n={};for(let[d,t]of e.entries()){let y=a(t,d,e);if(y!==void 0){let{[y]:r}=n;r===void 0&&(r=[],n[y]=r),r.push(t);}}return n};
 
 function k(...n){return u$6(u$2,n)}function u$2(n,e){if(n===e||Object.is(n,e))return !0;if(typeof n!="object"||typeof e!="object"||n===null||e===null||Object.getPrototypeOf(n)!==Object.getPrototypeOf(e))return !1;if(Array.isArray(n))return l$2(n,e);if(n instanceof Map)return a$1(n,e);if(n instanceof Set)return c(n,e);if(n instanceof Date)return n.getTime()===e.getTime();if(n instanceof RegExp)return n.toString()===e.toString();if(Object.keys(n).length!==Object.keys(e).length)return !1;for(let[r,t]of Object.entries(n))if(!(r in e)||!u$2(t,e[r]))return !1;return !0}function l$2(n,e){if(n.length!==e.length)return !1;for(let[r,t]of n.entries())if(!u$2(t,e[r]))return !1;return !0}function a$1(n,e){if(n.size!==e.size)return !1;for(let[r,t]of n.entries())if(!e.has(r)||!u$2(t,e.get(r)))return !1;return !0}function c(n,e){if(n.size!==e.size)return !1;let r=[...e];for(let t of n){let o=!1;for(let[s,f]of r.entries())if(u$2(t,f)){o=!0,r.splice(s,1);break}if(!o)return !1}return !0}
 
 function u$1(...a){return u$6(o$2,a,l$1)}var o$2=(a,r)=>a.flatMap(r),l$1=a=>(r,t,y)=>{let n=a(r,t,y);return Array.isArray(n)?{done:!1,hasNext:!0,hasMany:!0,next:n}:{done:!1,hasNext:!0,next:n}};
 
-function u(...e){return u$6(o$1,e,i$2)}function o$1(e,r){return e.forEach(r),e}var i$2=e=>(r,n,t)=>(e(r,n,t),{done:!1,hasNext:!0,next:r});
+function u(...e){return u$6(o$1,e,i$1)}function o$1(e,r){return e.forEach(r),e}var i$1=e=>(r,n,t)=>(e(r,n,t),{done:!1,hasNext:!0,next:r});
 
-function i$1(...e){return u$6(p,e)}var p=(e,a)=>{let n={};for(let[d,t]of e.entries()){let y=a(t,d,e);if(y!==void 0){let{[y]:r}=n;r===void 0&&(r=[],n[y]=r),r.push(t);}}return n};
+function t$1(...r){return u$6(Object.entries,r)}
 
 function T(...a){return u$6(l,a,y)}var l=(a,e)=>a.filter(e),y=a=>(e,t,o)=>a(e,t,o)?{done:!1,hasNext:!0,next:e}:s$1;
 
-function o(...e){return u$6(t$1,e)}var t$1=(e,r)=>{for(let n=e.length-1;n>=0;n--){let a=e[n];if(r(a,n,e))return a}};
+function o(...e){return u$6(t,e)}var t=(e,r)=>{for(let n=e.length-1;n>=0;n--){let a=e[n];if(r(a,n,e))return a}};
 
 function m(...e){return u$6(i,e)}function i(e,t){for(let[n,o]of e.entries())if(!t(o,n,e))return e.slice(n);return []}
 
-function t(...r){return u$6(Object.entries,r)}
-
 function a(...e){return u$6(r$1,e)}var r$1=(e,t)=>[...e,...t];
 
 function r(n){return ()=>n}
@@ -91,6 +688,9 @@ class ElementModel {
   get color() {
     return this.$element.color ?? DefaultThemeColor;
   }
+  get icon() {
+    return this.$element.icon ?? null;
+  }
   get tags() {
     return this.$element.tags ?? [];
   }
@@ -109,6 +709,9 @@ class ElementModel {
   get defaultView() {
     return this.scopedViews().next().value ?? null;
   }
+  get isRoot() {
+    return this.parent === null;
+  }
   isAncestorOf(another) {
     return isAncestor(this, another);
   }
@@ -235,37 +838,40 @@ class ElementModel {
    * @returns true if the element is deployed
    */
   isDeployed() {
-    return n$1(this.deployments().next().value);
+    return n$2(this.deployments().next().value);
   }
   deployments() {
     return this.$model.deployment.instancesOf(this);
   }
 }
+function isElementModel(element) {
+  return element instanceof ElementModel;
+}
 
 function buildElementNotations(nodes) {
   return x(
     nodes,
-    i$1(p$1("notation")),
+    i$2(p$1("notation")),
     i$3(
-      i$5(
-        i$1(p$1("shape")),
+      i$4(
+        i$2(p$1("shape")),
         i$3(
-          i$5(
-            i$1(p$1("color")),
+          i$4(
+            i$2(p$1("color")),
             i$3(
-              i$5(
+              i$4(
                 m$3(p$1("kind")),
                 i$8()
               )
             ),
-            t(),
+            t$1(),
             m$3(([color, kinds]) => ({
               kinds,
               color
             }))
           )
         ),
-        t(),
+        t$1(),
         u$1(
           ([shape, colors]) => colors.map(({ color, kinds }) => ({
             shape,
@@ -275,7 +881,7 @@ function buildElementNotations(nodes) {
         )
       )
     ),
-    t(),
+    t$1(),
     u$1(
       ([title, shapes]) => shapes.map(({ shape, color, kinds }) => ({
         title,
@@ -1362,7 +1968,7 @@ function topologicalSort(param) {
     //   // [prop('sourceLevel'), 'asc'],
     // ),
   );
-  const [edgesBetweenLeafs, edgesWithCompounds] = d$1(
+  const [edgesBetweenLeafs, edgesWithCompounds] = d$3(
     enrichedEdges,
     ({ source, target }) => source.children.length === 0 && target.children.length === 0
   );
@@ -1446,12 +2052,12 @@ function calcViewLayoutHash(view) {
     autoLayout: view.autoLayout,
     nodes: x(
       view.nodes,
-      m$3(i$7(["id", "title", "description", "technology", "shape", "icon", "children"])),
-      l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$1(icon) ? "Y" : "N" }])
+      m$3(i$6(["id", "title", "description", "technology", "shape", "icon", "children"])),
+      l$3(({ id, icon, ...node }) => [id, { ...node, icon: n$2(icon) ? "Y" : "N" }])
     ),
     edges: x(
       view.edges,
-      m$3(i$7(["source", "target", "label", "description", "technology", "dir", "head", "tail", "line"])),
+      m$3(i$6(["source", "target", "label", "description", "technology", "dir", "head", "tail", "line"])),
       l$3(({ source, target, ...edge }) => [`${source}:${target}`, edge])
     )
   };
@@ -1538,6 +2144,9 @@ class AbstractDeploymentElementModel {
   get tags() {
     return this.$node.tags ?? [];
   }
+  get kind() {
+    return this.$node.kind ?? null;
+  }
   get description() {
     return this.$node.description ?? null;
   }
@@ -1797,6 +2406,9 @@ class DeployedInstanceModel extends AbstractDeploymentElementModel {
   get tags() {
     return this.$instance.tags ?? [];
   }
+  get kind() {
+    return this.$instance.kind ?? null;
+  }
   get description() {
     return this.$instance.description ?? this.element.description;
   }
@@ -1912,6 +2524,9 @@ class DeploymentRelationModel {
   get tags() {
     return this.$relationship.tags ?? [];
   }
+  get kind() {
+    return this.$relationship.kind ?? null;
+  }
   get navigateTo() {
     return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null;
   }
@@ -1926,6 +2541,9 @@ class DeploymentRelationModel {
     }
     return;
   }
+  isDeploymentRelation() {
+    return true;
+  }
 }
 class RelationshipsAccum {
   /**
@@ -2053,11 +2671,10 @@ class DeploymentConnectionModel {
     yield* this.relations.model;
     yield* this.relations.deployment;
   }
-  /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
   mergeWith(other) {
+    if (Array.isArray(other)) {
+      return other.reduce((acc, o) => acc.mergeWith(o), this);
+    }
     invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
     invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
     return new DeploymentConnectionModel(
@@ -2776,7 +3393,7 @@ class AbstractStageInclude {
     let state = this.precommit(this.memory.mutableState());
     let fromConnections = /* @__PURE__ */ new Set();
     if (this._connections.length > 0) {
-      const [fromKnown, rest] = d$1(
+      const [fromKnown, rest] = d$3(
         this._connections,
         (c) => state.final.has(c.source)
       );
@@ -2867,12 +3484,12 @@ function findCrossBoundarySameSourceOrTarget(connections) {
         { group: `$source-${conn.source.id}`, conn },
         { group: `$target-${conn.target.id}`, conn }
       ]),
-      i$1(p$1("group")),
+      i$2(p$1("group")),
       r$3(),
       T(i$9(2)),
       u(
         // In each group, sort by hierarchy, first are deepest
-        i$5(
+        i$4(
           m$3(p$1("conn")),
           sortConnectionsByBoundaryHierarchy("desc"),
           // Drop first, as it is the deepest
@@ -3332,31 +3949,31 @@ function mergePropsFromRelationships(relations, prefer) {
     relations,
     l$5(
       (acc, r) => {
-        if (n$1(r.title) && !acc.title.includes(r.title)) {
+        if (n$2(r.title) && !acc.title.includes(r.title)) {
           acc.title.push(r.title);
         }
-        if (n$1(r.description) && !acc.description.includes(r.description)) {
+        if (n$2(r.description) && !acc.description.includes(r.description)) {
           acc.description.push(r.description);
         }
-        if (n$1(r.technology) && !acc.technology.includes(r.technology)) {
+        if (n$2(r.technology) && !acc.technology.includes(r.technology)) {
           acc.technology.push(r.technology);
         }
-        if (n$1(r.kind) && !acc.kind.includes(r.kind)) {
+        if (n$2(r.kind) && !acc.kind.includes(r.kind)) {
           acc.kind.push(r.kind);
         }
-        if (n$1(r.color) && !acc.color.includes(r.color)) {
+        if (n$2(r.color) && !acc.color.includes(r.color)) {
           acc.color.push(r.color);
         }
-        if (n$1(r.line) && !acc.line.includes(r.line)) {
+        if (n$2(r.line) && !acc.line.includes(r.line)) {
           acc.line.push(r.line);
         }
-        if (n$1(r.head) && !acc.head.includes(r.head)) {
+        if (n$2(r.head) && !acc.head.includes(r.head)) {
           acc.head.push(r.head);
         }
-        if (n$1(r.tail) && !acc.tail.includes(r.tail)) {
+        if (n$2(r.tail) && !acc.tail.includes(r.tail)) {
           acc.tail.push(r.tail);
         }
-        if (n$1(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
+        if (n$2(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
           acc.navigateTo.push(r.navigateTo);
         }
         if (r.tags) {
@@ -3385,7 +4002,7 @@ function mergePropsFromRelationships(relations, prefer) {
   let technology = t$2(allprops.technology);
   let title = t$2(allprops.title) ?? (allprops.title.length > 1 ? "[...]" : null);
   const tags = i$8(allprops.tags);
-  let merged = d$3(
+  let merged = d$2(
     {
       // If there is no title, but there is technology, use technology as title
       title: title ?? (technology ? `[${technology}]` : null),
@@ -3400,12 +4017,12 @@ function mergePropsFromRelationships(relations, prefer) {
       ...isNonEmptyArray(allprops.links) && { links: allprops.links },
       ...isNonEmptyArray(tags) && { tags }
     },
-    n$1
+    n$2
   );
   if (prefer) {
     return {
       ...merged,
-      ...d$3(pickRelationshipProps(prefer), n$1)
+      ...d$2(pickRelationshipProps(prefer), n$2)
     };
   }
   return merged;
@@ -3687,57 +4304,312 @@ function includeDeployedNodeWithExpanded(node, { memory, stage }) {
       break;
     }
   }
-  if (hasConnectionsWithVisible) {
-    stage.connectWithExisting(children, "in");
-    stage.addConnections(findConnectionsWithin(children));
-    stage.connectWithExisting(children, "out");
+  if (hasConnectionsWithVisible) {
+    stage.connectWithExisting(children, "in");
+    stage.addConnections(findConnectionsWithin(children));
+    stage.connectWithExisting(children, "out");
+  }
+  stage.addImplicit(children);
+  if (stage.connections.length > 0) {
+    stage.addExplicit(node);
+  }
+}
+function includeDeployedNodeDescendants(node, { stage }) {
+  const dfs = (node2) => {
+    const children = [];
+    for (const child of node2.children()) {
+      if (child.isDeploymentNode()) {
+        children.push(...dfs(child));
+      }
+      children.push(child);
+    }
+    stage.connectWithExisting(children, "in");
+    stage.addConnections(findConnectionsWithin(children));
+    stage.addImplicit(children);
+    return children;
+  };
+  const descendants = dfs(node);
+  if (descendants.length === 0) {
+    return;
+  }
+  stage.connectWithExisting(descendants, "out");
+  const allconnected = findConnectedElements(stage);
+  descendants.forEach((desc) => {
+    if (allconnected.has(desc)) {
+      stage.addExplicit(desc);
+    }
+  });
+}
+function findConnectedElements(stage) {
+  return x(
+    stage.mergedConnections(),
+    cleanCrossBoundary,
+    cleanRedundantRelationships,
+    l$5((acc, c) => {
+      acc.add(c.source);
+      acc.add(c.target);
+      return acc;
+    }, /* @__PURE__ */ new Set())
+  );
+}
+
+function isDeploymentNode(model) {
+  return model.isDeploymentNode();
+}
+function isDeployedInstance(model) {
+  return model.isInstance();
+}
+function isNestedElementOfDeployedInstanceModel(model) {
+  return !model.isInstance() && !model.isDeploymentNode();
+}
+function isDeploymentElementModel(x) {
+  return x instanceof DeploymentNodeModel || x instanceof DeployedInstanceModel;
+}
+
+const OutgoingRelationPredicate = {
+  include: ({ expr, model, memory, stage, where }) => {
+    const targets = [...memory.elements];
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      for (const target of targets) {
+        if (target.allIncoming.isEmpty) {
+          continue;
+        }
+        for (const source of resolveAscendingSiblings(target)) {
+          const toInclude = applyPredicate(findConnection(source, target, "directed"), where);
+          stage.addConnections(toInclude);
+        }
+      }
+      return stage;
+    }
+    invariant(FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
+    const sources = resolveElements$1(model, expr.outgoing);
+    for (const source of sources) {
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, "directed"), where);
+      stage.addConnections(toInclude);
+    }
+    return stage;
+  },
+  exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isModelRef(expr.outgoing)) {
+      const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing);
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
+    }
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      return stage;
+    }
+    const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
+    const toExclude = x(
+      memory.connections,
+      T(isOutgoing),
+      applyPredicate(where)
+    );
+    stage.excludeConnections(toExclude);
+    return stage;
+  }
+};
+function filterOutgoingConnections(sources) {
+  return y$1(
+    sources.map((source) => {
+      const satisfies = (el) => el === source || isAncestor(source, el);
+      return (connection) => {
+        return satisfies(connection.source) && !satisfies(connection.target);
+      };
+    })
+  );
+}
+function resolveAllOutgoingRelations(model, moodelRef) {
+  const targets = resolveModelElements(model, moodelRef);
+  return new Set(targets.flatMap((e) => [...e.allOutgoing]));
+}
+
+const InOutRelationPredicate$1 = {
+  include: ({ expr, model, memory, stage, where }) => {
+    const sources = [...memory.elements];
+    if (FqnExpr.isWildcard(expr.inout)) {
+      for (const source of sources) {
+        const targets2 = [...resolveAscendingSiblings(source)];
+        const toInclude = matchConnections(findConnectionsBetween(source, targets2, "both"), where);
+        stage.addConnections(toInclude);
+      }
+      return stage;
+    }
+    invariant(FqnExpr.isDeploymentRef(expr.inout), "Only deployment refs are supported in include");
+    const targets = resolveElements$1(model, expr.inout);
+    for (const source of sources) {
+      const toInclude = matchConnections(findConnectionsBetween(source, targets, "both"), where);
+      stage.addConnections(toInclude);
+    }
+    return stage;
+  },
+  exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isModelRef(expr.inout)) {
+      const elements2 = resolveModelElements(model, expr.inout);
+      if (elements2.length === 0) {
+        return stage;
+      }
+      const excludedRelations = union(
+        /* @__PURE__ */ new Set(),
+        ...elements2.flatMap((e) => [e.allIncoming, e.allOutgoing])
+      );
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
+    }
+    if (FqnExpr.isWildcard(expr.inout)) {
+      return stage;
+    }
+    const elements = resolveElements$1(model, expr.inout);
+    const isIncoming = filterIncomingConnections(elements);
+    const isOutgoing = filterOutgoingConnections(elements);
+    const toExclude = x(
+      memory.connections,
+      T((c) => isIncoming(c) !== isOutgoing(c)),
+      applyPredicate(where)
+    );
+    stage.excludeConnections(toExclude);
+    return stage;
+  }
+};
+
+const WhereRelationPredicate = {
+  include: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("include", { expr: expr.where.expr, model, stage, memory, where });
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition);
+    return predicateToPatch("exclude", { expr: expr.where.expr, model, stage, memory, where });
+  }
+};
+
+const WildcardPredicate$1 = {
+  include: ({ model, stage }) => {
+    const children = [];
+    const rootElements = [...model.roots()].map((root) => {
+      if (!root.onlyOneInstance()) {
+        children.push(...root.children());
+      }
+      return root;
+    });
+    stage.addExplicit(rootElements);
+    if (children.length > 1) {
+      stage.addConnections(findConnectionsWithin([
+        ...rootElements,
+        ...children
+      ]));
+    }
+    return stage;
+  },
+  exclude: ({ stage, memory }) => {
+    stage.exclude(memory.elements);
+    return stage;
+  }
+};
+
+function predicateToPatch(op, { expr, where, ...ctx }) {
+  switch (true) {
+    case FqnExpr.isModelRef(expr):
+      return void 0;
+    case FqnExpr.isDeploymentRef(expr):
+      return DeploymentRefPredicate[op]({ ...ctx, expr, where });
+    case FqnExpr.isWildcard(expr):
+      return WildcardPredicate$1[op]({ ...ctx, expr, where });
+    case RelationExpr.isDirect(expr):
+      return DirectRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isInOut(expr):
+      return InOutRelationPredicate$1[op]({ ...ctx, expr, where });
+    case RelationExpr.isOutgoing(expr):
+      return OutgoingRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isIncoming(expr):
+      return IncomingRelationPredicate[op]({ ...ctx, expr, where });
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where });
+    default:
+      nonexhaustive(expr);
   }
-  stage.addImplicit(children);
-  if (stage.connections.length > 0) {
-    stage.addExplicit(node);
+}
+function excludeModelRelations(relationsToExclude, { stage, memory }, where, filterConnections = () => true) {
+  if (relationsToExclude.size === 0) {
+    return stage;
+  }
+  const toExclude = x(
+    memory.connections,
+    T((c) => filterConnections(c)),
+    // Find connections that have at least one relation in common with the excluded relations
+    T((c) => hasIntersection(c.relations.model, relationsToExclude)),
+    m$3(
+      (c) => c.update({
+        deployment: null,
+        model: intersection(c.relations.model, relationsToExclude)
+      })
+    ),
+    applyPredicate(where),
+    T((c) => c.nonEmpty())
+  );
+  if (toExclude.length === 0) {
+    return stage;
   }
+  return stage.excludeConnections(toExclude);
 }
-function includeDeployedNodeDescendants(node, { stage }) {
-  const dfs = (node2) => {
-    const children = [];
-    for (const child of node2.children()) {
-      if (child.isDeploymentNode()) {
-        children.push(...dfs(child));
-      }
-      children.push(child);
-    }
-    stage.connectWithExisting(children, "in");
-    stage.addConnections(findConnectionsWithin(children));
-    stage.addImplicit(children);
-    return children;
-  };
-  const descendants = dfs(node);
-  if (descendants.length === 0) {
-    return;
+function matchConnection(c, where) {
+  return applyPredicate(c, where).nonEmpty();
+}
+function applyPredicate(...args) {
+  if (args.length === 1) {
+    return (x) => applyPredicate(x, args[0]);
   }
-  stage.connectWithExisting(descendants, "out");
-  const allconnected = findConnectedElements(stage);
-  descendants.forEach((desc) => {
-    if (allconnected.has(desc)) {
-      stage.addExplicit(desc);
-    }
+  const [c, where] = args;
+  if (where === null) {
+    return c;
+  }
+  if (o$a(c)) {
+    return c.map((x) => applyPredicate(x, where)).filter((x) => x.nonEmpty());
+  }
+  return c.update({
+    model: new Set([...c.relations.model.values()].filter((r) => where(toFilterableRelation(c)(r)))),
+    deployment: new Set([...c.relations.deployment.values()].filter((r) => where(toFilterableRelation(c)(r))))
   });
 }
-function findConnectedElements(stage) {
+function matchConnections(connections, where) {
+  if (!where) {
+    return connections;
+  }
   return x(
-    stage.mergedConnections(),
-    cleanCrossBoundary,
-    cleanRedundantRelationships,
-    l$5((acc, c) => {
-      acc.add(c.source);
-      acc.add(c.target);
-      return acc;
-    }, /* @__PURE__ */ new Set())
+    connections,
+    T((c) => matchConnection(c, where))
   );
 }
+function toFilterable(relationEndpoint, connectionEndpoint) {
+  if (isElementModel(relationEndpoint)) {
+    const deployedInstance = isDeploymentElementModel(connectionEndpoint) && isDeployedInstance(connectionEndpoint) ? connectionEndpoint : null;
+    return {
+      kind: relationEndpoint.kind,
+      tags: [...relationEndpoint.tags, ...deployedInstance?.tags ?? []]
+    };
+  }
+  if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) {
+    return i$6(relationEndpoint.element, ["tags", "kind"]);
+  }
+  if (isDeployedInstance(relationEndpoint)) {
+    return {
+      kind: relationEndpoint.element.kind,
+      tags: [...relationEndpoint.tags, ...relationEndpoint.element.tags]
+    };
+  }
+  if (isDeploymentNode(relationEndpoint)) {
+    return i$6(relationEndpoint, ["tags", "kind"]);
+  }
+  nonexhaustive(relationEndpoint);
+}
+function toFilterableRelation(c) {
+  return (relation) => ({
+    tags: relation.tags,
+    kind: relation.kind,
+    source: toFilterable(relation.source, c.source),
+    target: toFilterable(relation.target, c.target)
+  });
+}
 
 const IncomingRelationPredicate = {
-  include: ({ expr, model, memory, stage }) => {
+  include: ({ expr, model, memory, stage, where }) => {
     const sources = [...memory.elements];
     if (FqnExpr.isWildcard(expr.incoming)) {
       for (const source of sources) {
@@ -3745,27 +4617,33 @@ const IncomingRelationPredicate = {
           continue;
         }
         const targets2 = [...resolveAscendingSiblings(source)];
-        stage.addConnections(findConnectionsBetween(source, targets2, "directed"));
+        const toInclude = applyPredicate(findConnectionsBetween(source, targets2, "directed"), where);
+        stage.addConnections(toInclude);
       }
       return stage;
     }
     invariant(FqnExpr.isDeploymentRef(expr.incoming), "Only deployment refs are supported in include");
     const targets = resolveElements$1(model, expr.incoming);
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, "directed"));
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, "directed"), where);
+      stage.addConnections(toInclude);
     }
     return stage;
   },
-  exclude: ({ expr, model, memory, stage }) => {
+  exclude: ({ expr, model, memory, stage, where }) => {
     if (FqnExpr.isModelRef(expr.incoming)) {
       const excludedRelations = resolveAllImcomingRelations(model, expr.incoming);
-      return excludeModelRelations(excludedRelations, { stage, memory });
+      return excludeModelRelations(excludedRelations, { stage, memory }, where);
     }
     if (FqnExpr.isWildcard(expr.incoming)) {
       return stage;
     }
     const isIncoming = filterIncomingConnections(resolveElements$1(model, expr.incoming));
-    const toExclude = memory.connections.filter(isIncoming);
+    const toExclude = x(
+      memory.connections,
+      T(isIncoming),
+      applyPredicate(where)
+    );
     stage.excludeConnections(toExclude);
     return stage;
   }
@@ -3785,56 +4663,6 @@ function resolveAllImcomingRelations(model, moodelRef) {
   return new Set(targets.flatMap((e) => [...e.allIncoming]));
 }
 
-const OutgoingRelationPredicate = {
-  include: ({ expr, model, memory, stage }) => {
-    const targets = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.outgoing)) {
-      for (const target of targets) {
-        if (target.allIncoming.isEmpty) {
-          continue;
-        }
-        for (const source of resolveAscendingSiblings(target)) {
-          stage.addConnections(findConnection(source, target, "directed"));
-        }
-      }
-      return stage;
-    }
-    invariant(FqnExpr.isDeploymentRef(expr.outgoing), "Only deployment refs are supported in include");
-    const sources = resolveElements$1(model, expr.outgoing);
-    for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, "directed"));
-    }
-    return stage;
-  },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isModelRef(expr.outgoing)) {
-      const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing);
-      return excludeModelRelations(excludedRelations, { stage, memory });
-    }
-    if (FqnExpr.isWildcard(expr.outgoing)) {
-      return stage;
-    }
-    const isOutgoing = filterOutgoingConnections(resolveElements$1(model, expr.outgoing));
-    const toExclude = memory.connections.filter(isOutgoing);
-    stage.excludeConnections(toExclude);
-    return stage;
-  }
-};
-function filterOutgoingConnections(sources) {
-  return y$1(
-    sources.map((source) => {
-      const satisfies = (el) => el === source || isAncestor(source, el);
-      return (connection) => {
-        return satisfies(connection.source) && !satisfies(connection.target);
-      };
-    })
-  );
-}
-function resolveAllOutgoingRelations(model, moodelRef) {
-  const targets = resolveModelElements(model, moodelRef);
-  return new Set(targets.flatMap((e) => [...e.allOutgoing]));
-}
-
 const resolveAscendingSiblings = (element) => {
   const siblings = /* @__PURE__ */ new Set();
   for (let sibling of element.descendingSiblings()) {
@@ -3843,7 +4671,7 @@ const resolveAscendingSiblings = (element) => {
   return siblings;
 };
 const DirectRelationPredicate = {
-  include: ({ expr: { source, target, isBidirectional = false }, model, stage }) => {
+  include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
     invariant(!FqnExpr.isModelRef(source), "Invalid source model ref in direct relation");
     invariant(!FqnExpr.isModelRef(target), "Invalid target model ref in direct relation");
     const sourceIsWildcard = FqnExpr.isWildcard(source);
@@ -3853,10 +4681,14 @@ const DirectRelationPredicate = {
     switch (true) {
       // * -> *
       case (sourceIsWildcard && targetIsWildcard): {
-        connections = findConnectionsWithin(model.instances()).map((c) => {
-          stage.addImplicit(c.boundary);
-          return c;
-        });
+        connections = x(
+          findConnectionsWithin(model.instances()),
+          applyPredicate(where),
+          m$3((c) => {
+            stage.addImplicit(c.boundary);
+            return c;
+          })
+        );
         break;
       }
       // source -> *; source <-> *
@@ -3868,10 +4700,15 @@ const DirectRelationPredicate = {
           const isTarget = filterIncomingConnections(sources);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = sources.flatMap((source2) => {
-          const targets = resolveAscendingSiblings(source2);
-          return findConnectionsBetween(source2, targets, dir);
-        }).filter(postFilter);
+        connections = x(
+          sources,
+          u$1((source2) => {
+            const targets = resolveAscendingSiblings(source2);
+            return findConnectionsBetween(source2, targets, dir);
+          }),
+          T(postFilter),
+          applyPredicate(where)
+        );
         break;
       }
       // * -> target; * <-> target
@@ -3883,10 +4720,15 @@ const DirectRelationPredicate = {
           const isSource = filterOutgoingConnections(targets);
           postFilter = (c) => isSource(c) !== isTarget(c);
         }
-        connections = targets.flatMap((target2) => {
-          const sources = resolveAscendingSiblings(target2);
-          return [...sources].flatMap((source2) => findConnection(source2, target2, dir));
-        }).filter(postFilter);
+        connections = x(
+          targets,
+          u$1((target2) => {
+            const sources = resolveAscendingSiblings(target2);
+            return [...sources].flatMap((source2) => findConnection(source2, target2, dir));
+          }),
+          T(postFilter),
+          applyPredicate(where)
+        );
         break;
       }
       default: {
@@ -3899,7 +4741,8 @@ const DirectRelationPredicate = {
         connections = x(
           sources,
           u$1((s) => findConnectionsBetween(s, targets, dir)),
-          T((c) => isSource(c) && isTarget(c))
+          T((c) => isSource(c) && isTarget(c)),
+          applyPredicate(where)
         );
       }
     }
@@ -3912,72 +4755,64 @@ const DirectRelationPredicate = {
     }
     return stage;
   },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target)) {
-      stage.excludeConnections(memory.connections);
-      return stage;
-    }
-    if (FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target)) {
-      const toExclude2 = resolveRelationsBetweenModelElements({
-        source: expr.source,
-        target: expr.target,
-        expr,
-        model
-      });
-      return excludeModelRelations(toExclude2, { stage, memory });
-    }
-    if (FqnExpr.isModelRef(expr.source)) {
-      if (FqnExpr.isWildcard(expr.target)) {
-        const toExclude2 = resolveAllOutgoingRelations(model, expr.source);
-        return excludeModelRelations(toExclude2, { stage, memory });
-      }
-      const allOutgoing = resolveAllOutgoingRelations(model, expr.source);
-      const isTarget2 = deploymentExpressionToPredicate(expr.target);
-      return excludeModelRelations(
-        allOutgoing,
-        { stage, memory },
-        (c) => isTarget2(c.target)
-      );
-    }
-    if (FqnExpr.isModelRef(expr.target)) {
-      const toExclude2 = resolveAllImcomingRelations(model, expr.target);
-      const isSource2 = deploymentExpressionToPredicate(expr.source);
-      return excludeModelRelations(
-        toExclude2,
-        { stage, memory },
-        (c) => isSource2(c.source)
-      );
-    }
-    const isSource = deploymentExpressionToPredicate(expr.source);
+  exclude: ({ expr, model, memory, stage, where }) => {
     const isTarget = deploymentExpressionToPredicate(expr.target);
-    const satisfies = (connection) => {
-      return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional && isSource(connection.target) && isTarget(connection.source);
-    };
-    const toExclude = memory.connections.filter(satisfies);
-    stage.excludeConnections(toExclude);
-    return stage;
+    const isSource = deploymentExpressionToPredicate(expr.source);
+    let modelRelationsToExclude;
+    switch (true) {
+      // * -> *
+      case (FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target)):
+        stage.excludeConnections(applyPredicate(memory.connections, where));
+        return stage;
+      // model -> model
+      case (FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target)):
+        modelRelationsToExclude = resolveRelationsBetweenModelElements({
+          source: expr.source,
+          target: expr.target,
+          expr,
+          model
+        });
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
+      // model -> *
+      case (FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target)):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where);
+      // model -> deployment
+      case FqnExpr.isModelRef(expr.source):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source);
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          (c) => isTarget(c.target)
+        );
+      // deployment -> model
+      case FqnExpr.isModelRef(expr.target):
+        modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target);
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          (c) => isSource(c.source)
+        );
+      // deployment -> deployment
+      default:
+        const satisfies = (connection) => {
+          return isSource(connection.source) && isTarget(connection.target) || expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source);
+        };
+        const deploymentRelationsToExclude = x(
+          memory.connections,
+          T(satisfies),
+          applyPredicate(where)
+        );
+        if (deploymentRelationsToExclude.length === 0) {
+          return stage;
+        }
+        stage.excludeConnections(deploymentRelationsToExclude);
+        return stage;
+    }
   }
 };
-function excludeModelRelations(relationsToExclude, { stage, memory }, filterConnections = () => true) {
-  if (relationsToExclude.size === 0) {
-    return stage;
-  }
-  const toExclude = x(
-    memory.connections,
-    // Find connections that have at least one relation in common with the excluded relations
-    T((c) => filterConnections(c) && hasIntersection(c.relations.model, relationsToExclude)),
-    m$3(
-      (c) => c.update({
-        deployment: null,
-        model: intersection(c.relations.model, relationsToExclude)
-      })
-    )
-  );
-  if (toExclude.length === 0) {
-    return stage;
-  }
-  return stage.excludeConnections(toExclude);
-}
 function resolveRelationsBetweenModelElements({
   source,
   target,
@@ -3986,78 +4821,13 @@ function resolveRelationsBetweenModelElements({
 }) {
   const sources = resolveModelElements(model, source);
   const targets = resolveModelElements(model, target);
-  const dir = expr.isBidirectional ? "both" : "directed";
-  const modelConnections = [];
-  for (const source2 of sources) {
-    modelConnections.push(...findConnectionsBetween$1(source2, targets, dir));
-  }
-  return new Set(modelConnections.flatMap((c) => [...c.relations]));
-}
-
-const InOutRelationPredicate$1 = {
-  include: ({ expr, model, memory, stage }) => {
-    const sources = [...memory.elements];
-    if (FqnExpr.isWildcard(expr.inout)) {
-      for (const source of sources) {
-        const targets2 = [...resolveAscendingSiblings(source)];
-        stage.addConnections(findConnectionsBetween(source, targets2, "both"));
-      }
-      return stage;
-    }
-    invariant(FqnExpr.isDeploymentRef(expr.inout), "Only deployment refs are supported in include");
-    const targets = resolveElements$1(model, expr.inout);
-    for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, "both"));
-    }
-    return stage;
-  },
-  exclude: ({ expr, model, memory, stage }) => {
-    if (FqnExpr.isModelRef(expr.inout)) {
-      const elements2 = resolveModelElements(model, expr.inout);
-      if (elements2.length === 0) {
-        return stage;
-      }
-      const excludedRelations = union(
-        /* @__PURE__ */ new Set(),
-        ...elements2.flatMap((e) => [e.allIncoming, e.allOutgoing])
-      );
-      return excludeModelRelations(excludedRelations, { stage, memory });
-    }
-    if (FqnExpr.isWildcard(expr.inout)) {
-      return stage;
-    }
-    const elements = resolveElements$1(model, expr.inout);
-    const isIncoming = filterIncomingConnections(elements);
-    const isOutgoing = filterOutgoingConnections(elements);
-    const toExclude = memory.connections.filter((c) => isIncoming(c) !== isOutgoing(c));
-    stage.excludeConnections(toExclude);
-    return stage;
-  }
-};
-
-const WildcardPredicate$1 = {
-  include: ({ model, stage }) => {
-    const children = [];
-    const rootElements = [...model.roots()].map((root) => {
-      if (!root.onlyOneInstance()) {
-        children.push(...root.children());
-      }
-      return root;
-    });
-    stage.addExplicit(rootElements);
-    if (children.length > 1) {
-      stage.addConnections(findConnectionsWithin([
-        ...rootElements,
-        ...children
-      ]));
-    }
-    return stage;
-  },
-  exclude: ({ stage, memory }) => {
-    stage.exclude(memory.elements);
-    return stage;
+  const dir = expr.isBidirectional ? "both" : "directed";
+  const modelConnections = [];
+  for (const source2 of sources) {
+    modelConnections.push(...findConnectionsBetween$1(source2, targets, dir));
   }
-};
+  return new Set(modelConnections.flatMap((c) => [...c.relations]));
+}
 
 let StageFinal$1 = class StageFinal {
   constructor(memory) {
@@ -4235,31 +5005,8 @@ function processPredicates$1(model, rules) {
       const exprs = rule.include ?? rule.exclude;
       for (const expr of exprs) {
         let stage = op === "include" ? memory.stageInclude(expr) : memory.stageExclude(expr);
-        const ctx = { model, stage, memory };
-        switch (true) {
-          case FqnExpr.isModelRef(expr):
-            break;
-          case FqnExpr.isDeploymentRef(expr):
-            stage = DeploymentRefPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case FqnExpr.isWildcard(expr):
-            stage = WildcardPredicate$1[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isDirect(expr):
-            stage = DirectRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isInOut(expr):
-            stage = InOutRelationPredicate$1[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isOutgoing(expr):
-            stage = OutgoingRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          case RelationExpr.isIncoming(expr):
-            stage = IncomingRelationPredicate[op]({ ...ctx, expr }) ?? stage;
-            break;
-          default:
-            nonexhaustive(expr);
-        }
+        const ctx = { expr, model, stage, memory, where: null };
+        stage = predicateToPatch(op, ctx) ?? stage;
         memory = stage.commit();
       }
     }
@@ -4273,7 +5020,7 @@ function computeDeploymentView(likec4model, {
   // exclude rules
   ...view
 }) {
-  let memory = processPredicates$1(likec4model.deployment, rules);
+  const memory = processPredicates$1(likec4model.deployment, rules);
   const nodesMap = buildNodes$1(memory);
   const computedEdges = toComputedEdges$1(memory.connections);
   linkNodesWithEdges(nodesMap, computedEdges);
@@ -4330,7 +5077,7 @@ function applyCustomElementProperties(_rules, _nodes) {
   for (const {
     custom: { expr, ...props }
   } of rules) {
-    const { border, opacity, ...rest } = d$2(props, n$4);
+    const { border, opacity, ...rest } = d$1(props, n$4);
     const notEmpty = !n(rest);
     const satisfies = elementExprToPredicate(expr);
     nodes.forEach((node, i) => {
@@ -4440,7 +5187,7 @@ class DynamicViewCompute {
       line,
       notation
     } = this.findRelations(source, target);
-    const navigateTo = n$1(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
+    const navigateTo = n$2(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
     this.steps.push({
       id,
       ...step,
@@ -4584,7 +5331,7 @@ class DynamicViewCompute {
     const alltags = x(
       relationships,
       u$1((r) => r.tags),
-      T(n$1),
+      T(n$2),
       i$8()
     );
     const tags = i$9(alltags, 1) ? alltags : null;
@@ -4594,7 +5341,7 @@ class DynamicViewCompute {
     const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : x(
       relationships,
       m$3((r) => r.$relationship.navigateTo),
-      T(n$1),
+      T(n$2),
       T((v) => v !== this.view.id),
       i$8(),
       t$2()
@@ -4602,11 +5349,11 @@ class DynamicViewCompute {
     const commonProperties = x(
       relationships,
       l$5((acc, { title, $relationship: r }) => {
-        n$1(title) && acc.title.add(title);
-        n$1(r.tail) && acc.tail.add(r.tail);
-        n$1(r.head) && acc.head.add(r.head);
-        n$1(r.color) && acc.color.add(r.color);
-        n$1(r.line) && acc.line.add(r.line);
+        n$2(title) && acc.title.add(title);
+        n$2(r.tail) && acc.tail.add(r.tail);
+        n$2(r.head) && acc.head.add(r.head);
+        n$2(r.color) && acc.color.add(r.color);
+        n$2(r.line) && acc.line.add(r.line);
         return acc;
       }, {
         tail: /* @__PURE__ */ new Set(),
@@ -4639,7 +5386,12 @@ function relationExpressionToPredicates(expr) {
     case isRelationWhere(expr): {
       const predicate = relationExpressionToPredicates(expr.where.expr);
       const where = whereOperatorAsPredicate(expr.where.condition);
-      return (e) => predicate(e) && where(e);
+      return (e) => predicate(e) && where({
+        source: { tags: e.source.tags, kind: e.source.kind },
+        target: { tags: e.target.tags, kind: e.target.kind },
+        ...e.tags && { tags: e.tags },
+        ...e.kind && { kind: e.kind }
+      });
     }
     case isRelation(expr): {
       const isSource = elementExprToPredicate(expr.source);
@@ -4674,7 +5426,7 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
   for (const {
     customRelation: { relation, title, ...customprops }
   } of rules) {
-    const props = d$2(customprops, n$4);
+    const props = d$1(customprops, n$4);
     const satisfies = relationExpressionToPredicates(relation);
     edges.forEach((edge, i) => {
       const source = nodes.find((n) => n.id === edge.source);
@@ -4682,7 +5434,7 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
       if (!source || !target) {
         return;
       }
-      if (satisfies({ source, target, ...i$7(edge, ["kind", "tags"]) })) {
+      if (satisfies({ source, target, ...i$6(edge, ["kind", "tags"]) })) {
         edges[i] = {
           ...edge,
           ...props,
@@ -4695,229 +5447,6 @@ function applyCustomRelationProperties(_rules, nodes, _edges) {
   return edges;
 }
 
-/**
- * Mnemonist Stack
- * ================
- *
- * Stack implementation relying on JavaScript arrays, which are fast enough &
- * correctly optimized for this kind of work.
- */
-
-var stack;
-var hasRequiredStack;
-
-function requireStack () {
-	if (hasRequiredStack) return stack;
-	hasRequiredStack = 1;
-	var Iterator = requireIterator(),
-	    forEach = requireForeach();
-
-	/**
-	 * Stack
-	 *
-	 * @constructor
-	 */
-	function Stack() {
-	  this.clear();
-	}
-
-	/**
-	 * Method used to clear the stack.
-	 *
-	 * @return {undefined}
-	 */
-	Stack.prototype.clear = function() {
-
-	  // Properties
-	  this.items = [];
-	  this.size = 0;
-	};
-
-	/**
-	 * Method used to add an item to the stack.
-	 *
-	 * @param  {any}    item - Item to add.
-	 * @return {number}
-	 */
-	Stack.prototype.push = function(item) {
-	  this.items.push(item);
-	  return ++this.size;
-	};
-
-	/**
-	 * Method used to retrieve & remove the last item of the stack.
-	 *
-	 * @return {any}
-	 */
-	Stack.prototype.pop = function() {
-	  if (this.size === 0)
-	    return;
-
-	  this.size--;
-	  return this.items.pop();
-	};
-
-	/**
-	 * Method used to get the last item of the stack.
-	 *
-	 * @return {any}
-	 */
-	Stack.prototype.peek = function() {
-	  return this.items[this.size - 1];
-	};
-
-	/**
-	 * Method used to iterate over the stack.
-	 *
-	 * @param  {function}  callback - Function to call for each item.
-	 * @param  {object}    scope    - Optional scope.
-	 * @return {undefined}
-	 */
-	Stack.prototype.forEach = function(callback, scope) {
-	  scope = arguments.length > 1 ? scope : this;
-
-	  for (var i = 0, l = this.items.length; i < l; i++)
-	    callback.call(scope, this.items[l - i - 1], i, this);
-	};
-
-	/**
-	 * Method used to convert the stack to a JavaScript array.
-	 *
-	 * @return {array}
-	 */
-	Stack.prototype.toArray = function() {
-	  var array = new Array(this.size),
-	      l = this.size - 1,
-	      i = this.size;
-
-	  while (i--)
-	    array[i] = this.items[l - i];
-
-	  return array;
-	};
-
-	/**
-	 * Method used to create an iterator over a stack's values.
-	 *
-	 * @return {Iterator}
-	 */
-	Stack.prototype.values = function() {
-	  var items = this.items,
-	      l = items.length,
-	      i = 0;
-
-	  return new Iterator(function() {
-	    if (i >= l)
-	      return {
-	        done: true
-	      };
-
-	    var value = items[l - i - 1];
-	    i++;
-
-	    return {
-	      value: value,
-	      done: false
-	    };
-	  });
-	};
-
-	/**
-	 * Method used to create an iterator over a stack's entries.
-	 *
-	 * @return {Iterator}
-	 */
-	Stack.prototype.entries = function() {
-	  var items = this.items,
-	      l = items.length,
-	      i = 0;
-
-	  return new Iterator(function() {
-	    if (i >= l)
-	      return {
-	        done: true
-	      };
-
-	    var value = items[l - i - 1];
-
-	    return {
-	      value: [i++, value],
-	      done: false
-	    };
-	  });
-	};
-
-	/**
-	 * Attaching the #.values method to Symbol.iterator if possible.
-	 */
-	if (typeof Symbol !== 'undefined')
-	  Stack.prototype[Symbol.iterator] = Stack.prototype.values;
-
-
-	/**
-	 * Convenience known methods.
-	 */
-	Stack.prototype.toString = function() {
-	  return this.toArray().join(',');
-	};
-
-	Stack.prototype.toJSON = function() {
-	  return this.toArray();
-	};
-
-	Stack.prototype.inspect = function() {
-	  var array = this.toArray();
-
-	  // Trick so that node displays the name of the constructor
-	  Object.defineProperty(array, 'constructor', {
-	    value: Stack,
-	    enumerable: false
-	  });
-
-	  return array;
-	};
-
-	if (typeof Symbol !== 'undefined')
-	  Stack.prototype[Symbol.for('nodejs.util.inspect.custom')] = Stack.prototype.inspect;
-
-	/**
-	 * Static @.from function taking an arbitrary iterable & converting it into
-	 * a stack.
-	 *
-	 * @param  {Iterable} iterable   - Target iterable.
-	 * @return {Stack}
-	 */
-	Stack.from = function(iterable) {
-	  var stack = new Stack();
-
-	  forEach(iterable, function(value) {
-	    stack.push(value);
-	  });
-
-	  return stack;
-	};
-
-	/**
-	 * Static @.of function taking an arbitrary number of arguments & converting it
-	 * into a stack.
-	 *
-	 * @param  {...any} args
-	 * @return {Stack}
-	 */
-	Stack.of = function() {
-	  return Stack.from(arguments);
-	};
-
-	/**
-	 * Exporting.
-	 */
-	stack = Stack;
-	return stack;
-}
-
-var stackExports = requireStack();
-const Stack = /*@__PURE__*/getDefaultExportFromCjs(stackExports);
-
 class NodesGroup {
   constructor(id, viewRule, parent = null, elements = /* @__PURE__ */ new Set()) {
     this.id = id;
@@ -5488,7 +6017,11 @@ function toComputedEdges(connections) {
       ...props
     } = mergePropsFromRelationships(
       relations.map((r) => r.$relationship),
-      relations.find((r) => r.source.id === source && r.target.id === target)?.$relationship
+      // Prefer only single relationship
+      // https://github.com/likec4/likec4/issues/1423
+      t$2(
+        T(relations, (r) => r.source.id === source && r.target.id === target)
+      )?.$relationship
     );
     const edge = {
       id: e.id,
@@ -5556,7 +6089,7 @@ const DirectRelationExprPredicate = {
               ifilter(where),
               iunique(),
               toArray(),
-              d$1((r) => r.source === source2),
+              d$3((r) => r.source === source2),
               ([outgoing, incoming]) => a(
                 x(
                   outgoing,
@@ -5611,7 +6144,7 @@ const DirectRelationExprPredicate = {
               }),
               ifilter(where),
               toArray(),
-              d$1((r) => r.target === target2),
+              d$3((r) => r.target === target2),
               ([incoming, outgoing]) => a(
                 x(
                   outgoing,
@@ -5678,7 +6211,7 @@ const DirectRelationExprPredicate = {
       case (sourceIsWildcard && targetIsWildcard): {
         relations = x(
           memory.connections,
-          u$1(i$5(
+          u$1(i$4(
             p$1("relations"),
             ifilter(where),
             toArray()
@@ -6718,6 +7251,9 @@ class RelationshipModel {
   get tags() {
     return this.$relationship.tags ?? [];
   }
+  get kind() {
+    return this.$relationship.kind ?? null;
+  }
   get links() {
     return this.$relationship.links ?? [];
   }
@@ -6732,6 +7268,9 @@ class RelationshipModel {
     }
     return;
   }
+  isDeploymentRelation() {
+    return false;
+  }
 }
 
 class EdgeModel {
@@ -6826,6 +7365,9 @@ class NodeModel {
   get color() {
     return this.$node.color;
   }
+  get icon() {
+    return this.$node.icon ?? null;
+  }
   get tags() {
     return this.$node.tags ?? [];
   }
@@ -7042,6 +7584,10 @@ class LikeC4ViewModel {
   findNode(node) {
     return this.#nodes.get(getId(node)) ?? null;
   }
+  findNodeWithElement(fqn) {
+    const nd = ifind(this.#nodes.values(), (node) => node.element?.id === fqn) ?? null;
+    return nd && nd.hasElement() ? nd : null;
+  }
   /**
    * Iterate over all nodes.
    */
@@ -7281,7 +7827,7 @@ class LikeC4Model {
     return nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
   }
   findView(viewId) {
-    return nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
+    return this.#views.get(viewId) ?? null;
   }
   /**
    * Returns the parent element of given element.
@@ -7433,11 +7979,4 @@ class LikeC4Model {
   }
 }
 
-function isDeploymentNode(model) {
-  return model.isDeploymentNode();
-}
-function isDeployedInstance(model) {
-  return model.isInstance();
-}
-
-export { sortConnectionsByBoundaryHierarchy as A, sortDeepestFirst as B, Connection as C, DeploymentConnectionModel as D, ElementModel as E, DeployedInstanceModel as F, Graph as G, DeploymentNodeModel as H, DeploymentRelationModel as I, EdgeModel as J, isDeployedInstance as K, LikeC4Model as L, isDeploymentNode as M, NodeModel as N, RelationshipModel as R, computeViews as a, LikeC4DeploymentModel as b, computeView as c, d$3 as d, LikeC4ViewModel as e, ConnectionModel as f, find as g, differenceConnections as h, i$3 as i, findAscendingConnections as j, findDeepestNestedConnection as k, l$3 as l, findDescendantConnections as m, hasSameSource as n, hasSameSourceTarget as o, hasSameTarget as p, isAnyInOut as q, r$3 as r, isIncoming as s, topologicalSortExports as t, unsafeComputeView as u, isNestedConnection as v, willCreateCycle as w, isOutgoing as x, mergeConnections as y, find$1 as z };
+export { isOutgoing as A, mergeConnections as B, Connection as C, DefaultMap as D, ElementModel as E, find$1 as F, Graph as G, sortConnectionsByBoundaryHierarchy as H, sortDeepestFirst as I, DeployedInstanceModel as J, DeploymentNodeModel as K, LikeC4Model as L, DeploymentRelationModel as M, EdgeModel as N, NodeModel as O, isDeployedInstance as P, isDeploymentNode as Q, RelationshipModel as R, Stack as S, computeViews as a, requireIterator as b, computeView as c, d$2 as d, requireForeach as e, LikeC4DeploymentModel as f, LikeC4ViewModel as g, ConnectionModel as h, i$3 as i, find as j, DeploymentConnectionModel as k, l$3 as l, differenceConnections as m, findAscendingConnections as n, findDeepestNestedConnection as o, findDescendantConnections as p, hasSameSource as q, r$3 as r, hasSameSourceTarget as s, topologicalSortExports as t, unsafeComputeView as u, hasSameTarget as v, willCreateCycle as w, isAnyInOut as x, isIncoming as y, isNestedConnection as z };