@likec4/core 1.17.1 → 1.18.0

package/dist/shared/core.BPyJvuMU.mjs

@@ -0,0 +1,2420 @@
+import { u, e as DefaultElementShape, d as DefaultThemeColor, f as nonNullable, b as invariant, D as DeploymentElement, F as extractStep, C as isStepEdgeId, H as ComputedNode, c as isScopedElementView, y as isElementView, w as isDeploymentView, x as isDynamicView } from './core.k12s_keD.mjs';
+
+function r(...t){return u(Object.values,t)}
+
+var s={done:!1,hasNext:!1},o$2=t=>({hasNext:!0,next:t,done:!1});
+
+function x(t,...o){let n=t,u=o.map(e=>"lazy"in e?f(e):void 0),p=0;for(;p<o.length;){if(u[p]===void 0||!B(n)){let i=o[p];n=i(n),p+=1;continue}let r=[];for(let i=p;i<o.length;i++){let l=u[i];if(l===void 0||(r.push(l),l.isSingle))break}let a=[];for(let i of n)if(A(i,a,r))break;let{isSingle:y}=r.at(-1);n=y?a[0]:a,p+=r.length;}return n}function A(t,o,n){if(n.length===0)return o.push(t),!1;let u=t,p=s,e=!1;for(let[r,a]of n.entries()){let{index:y,items:i}=a;if(i.push(u),p=a(u,y,i),a.index+=1,p.hasNext){if(p.hasMany??!1){for(let l of p.next)if(A(l,o,n.slice(r+1)))return !0;return e}u=p.next;}if(!p.hasNext)break;p.done&&(e=!0);}return p.hasNext&&o.push(u),e}function f(t){let{lazy:o,lazyArgs:n}=t,u=o(...n);return Object.assign(u,{isSingle:o.single??!1,index:0,items:[]})}function B(t){return typeof t=="string"||typeof t=="object"&&t!==null&&Symbol.iterator in t}
+
+function m(...r){return u(o$1,r)}function o$1(r,t){let e=[...r];return e.sort(t),e}
+
+function t$1(...n){return u(o,n)}var o=n=>n.length===1?n[0]:void 0;
+
+function t(r){return typeof r=="string"}
+
+function n$1(e){return !!e}
+
+function n(e){return e===void 0?!0:typeof e=="string"||Array.isArray(e)?e.length===0:Object.keys(e).length===0}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * 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);
+
+var naturalCompareLite = {exports: {}};
+
+var hasRequiredNaturalCompareLite;
+
+function requireNaturalCompareLite () {
+	if (hasRequiredNaturalCompareLite) return naturalCompareLite.exports;
+	hasRequiredNaturalCompareLite = 1;
+	/*
+	 * @version    1.4.0
+	 * @date       2015-10-26
+	 * @stability  3 - Stable
+	 * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+	 * @license    MIT License
+	 */
+
+
+	var naturalCompare = function(a, b) {
+		var i, codeA
+		, codeB = 1
+		, posA = 0
+		, posB = 0
+		, alphabet = String.alphabet;
+
+		function getCode(str, pos, code) {
+			if (code) {
+				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+				return +str.slice(pos - 1, i)
+			}
+			code = alphabet && alphabet.indexOf(str.charAt(pos));
+			return code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code
+				: code < 46 ? 65               // -
+				: code < 48 ? code - 1
+				: code < 58 ? code + 18        // 0-9
+				: code < 65 ? code - 11
+				: code < 91 ? code + 11        // A-Z
+				: code < 97 ? code - 37
+				: code < 123 ? code + 5        // a-z
+				: code - 63
+		}
+
+
+		if ((a+="") != (b+="")) for (;codeB;) {
+			codeA = getCode(a, posA++);
+			codeB = getCode(b, posB++);
+
+			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+				codeA = getCode(a, posA, posA);
+				codeB = getCode(b, posB, posA = i);
+				posB = i;
+			}
+
+			if (codeA != codeB) return (codeA < codeB) ? -1 : 1
+		}
+		return 0
+	};
+
+	try {
+		naturalCompareLite.exports = naturalCompare;
+	} catch (e) {
+		String.naturalCompare = naturalCompare;
+	}
+	return naturalCompareLite.exports;
+}
+
+var naturalCompareLiteExports = requireNaturalCompareLite();
+const compare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareLiteExports);
+
+function compareNatural(a, b) {
+  if (a === b) return 0;
+  if (t(a)) {
+    if (t(b)) {
+      return compare(a, b);
+    }
+    return 1;
+  }
+  return t(b) ? -1 : 0;
+}
+
+function isString(value) {
+  return value != null && typeof value === "string";
+}
+function isNonEmptyArray(arr) {
+  return !!arr && Array.isArray(arr) && arr.length > 0;
+}
+
+function parentFqn(fqn) {
+  const lastDot = fqn.lastIndexOf(".");
+  if (lastDot > 0) {
+    return fqn.slice(0, lastDot);
+  }
+  return null;
+}
+function parentFqnPredicate(parent) {
+  const prefix = parent + ".";
+  return (e) => !!e.parent && (e.parent === parent || e.parent.startsWith(prefix));
+}
+function nameFromFqn(fqn) {
+  const lastDot = fqn.lastIndexOf(".");
+  if (lastDot > 0) {
+    return fqn.slice(lastDot + 1);
+  } else {
+    return fqn;
+  }
+}
+function isAncestor(...args) {
+  const ancestor = isString(args[0]) ? args[0] : args[0].id;
+  const another = isString(args[1]) ? args[1] : args[1].id;
+  return another.startsWith(ancestor + ".");
+}
+function isSameHierarchy(one, another) {
+  const first = isString(one) ? one : one.id;
+  const second = isString(another) ? another : another.id;
+  return first === second || second.startsWith(first + ".") || first.startsWith(second + ".");
+}
+function isDescendantOf(ancestors) {
+  const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
+  return (e) => predicates.some((p) => p(e));
+}
+function notDescendantOf(ancestors) {
+  const isDescendant = isDescendantOf(ancestors);
+  return (e) => !isDescendant(e);
+}
+function hierarchyDepth(elementOfFqn) {
+  const first = isString(elementOfFqn) ? elementOfFqn : elementOfFqn.id;
+  return first.split(".").length;
+}
+function hierarchyDistance(one, another) {
+  const first = isString(one) ? one : one.id;
+  const second = isString(another) ? another : another.id;
+  if (first === second) {
+    return 0;
+  }
+  const firstDepth = hierarchyDepth(first);
+  const secondDepth = hierarchyDepth(second);
+  if (isSameHierarchy(first, second)) {
+    return Math.abs(firstDepth - secondDepth);
+  }
+  const ancestor = commonAncestor(first, second);
+  const ancestorDepth = ancestor ? hierarchyDepth(ancestor) : 0;
+  return firstDepth + secondDepth - (2 * ancestorDepth + 1);
+}
+function commonAncestor(first, second) {
+  const parentA = parentFqn(first);
+  const parentB = parentFqn(second);
+  if (parentA === parentB) {
+    return parentA;
+  }
+  if (!parentA || !parentB) {
+    return null;
+  }
+  const a = first.split(".");
+  const b = second.split(".");
+  let ancestor = null;
+  while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
+    ancestor = ancestor ? `${ancestor}.${a[0]}` : a[0];
+    a.shift();
+    b.shift();
+  }
+  return ancestor;
+}
+function ancestorsFqn(fqn) {
+  const path = fqn.split(".");
+  path.pop();
+  if (path.length === 0) {
+    return [];
+  }
+  return path.reduce((acc, part, idx) => {
+    if (idx === 0) {
+      acc.push(part);
+      return acc;
+    }
+    acc.unshift(`${acc[0]}.${part}`);
+    return acc;
+  }, []);
+}
+function compareFqnHierarchically(a, b) {
+  const depthA = a.split(".").length;
+  const depthB = b.split(".").length;
+  switch (true) {
+    case depthA > depthB: {
+      return 1;
+    }
+    case depthA < depthB: {
+      return -1;
+    }
+    default: {
+      return 0;
+    }
+  }
+}
+function compareByFqnHierarchically(a, b) {
+  return compareFqnHierarchically(a.id, b.id);
+}
+function sortByFqnHierarchically(array) {
+  return array.map((item) => ({ item, fqn: item.id.split(".") })).sort((a, b) => {
+    return a.fqn.length - b.fqn.length;
+  }).map(({ item }) => item);
+}
+function sortParentsFirst(array) {
+  const result = [];
+  const items = [...array];
+  let item;
+  while (item = items.shift()) {
+    const itemId = item.id;
+    let parentIndx;
+    while ((parentIndx = items.findIndex((parent) => isAncestor(parent.id, itemId))) !== -1) {
+      result.push(...items.splice(parentIndx, 1));
+    }
+    result.push(item);
+  }
+  return result;
+}
+function sortNaturalByFqn(array) {
+  return array.map((item) => ({ item, fqn: item.id.split(".") })).sort((a, b) => {
+    if (a.fqn.length !== b.fqn.length) {
+      return a.fqn.length - b.fqn.length;
+    }
+    for (let i = 0; i < a.fqn.length; i++) {
+      const compare = compareNatural(a.fqn[i], b.fqn[i]);
+      if (compare !== 0) {
+        return compare;
+      }
+    }
+    return 0;
+  }).map(({ item }) => item);
+}
+
+function getOrCreate(map, key, create) {
+  let entry = map.get(key);
+  if (!entry) {
+    entry = create(key);
+    map.set(key, entry);
+  }
+  return entry;
+}
+
+var set = {};
+
+/**
+ * Mnemonist Set
+ * ==============
+ *
+ * Useful function related to sets such as union, intersection and so on...
+ */
+
+var hasRequiredSet;
+
+function requireSet () {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	(function (exports) {
+		// TODO: optimize versions for less variadicities
+
+		/**
+		 * Variadic function computing the intersection of multiple sets.
+		 *
+		 * @param  {...Set} sets - Sets to intersect.
+		 * @return {Set}         - The intesection.
+		 */
+		exports.intersection = function() {
+		  if (arguments.length < 2)
+		    throw new Error('mnemonist/Set.intersection: needs at least two arguments.');
+
+		  var I = new Set();
+
+		  // First we need to find the smallest set
+		  var smallestSize = Infinity,
+		      smallestSet = null;
+
+		  var s, i, l = arguments.length;
+
+		  for (i = 0; i < l; i++) {
+		    s = arguments[i];
+
+		    // If one of the set has no items, we can stop right there
+		    if (s.size === 0)
+		      return I;
+
+		    if (s.size < smallestSize) {
+		      smallestSize = s.size;
+		      smallestSet = s;
+		    }
+		  }
+
+		  // Now we need to intersect this set with the others
+		  var iterator = smallestSet.values(),
+		      step,
+		      item,
+		      add,
+		      set;
+
+		  // TODO: we can optimize by iterating each next time over the current intersection
+		  // but this probably means more RAM to consume since we'll create n-1 sets rather than
+		  // only the one.
+		  while ((step = iterator.next(), !step.done)) {
+		    item = step.value;
+		    add = true;
+
+		    for (i = 0; i < l; i++) {
+		      set = arguments[i];
+
+		      if (set === smallestSet)
+		        continue;
+
+		      if (!set.has(item)) {
+		        add = false;
+		        break;
+		      }
+		    }
+
+		    if (add)
+		      I.add(item);
+		  }
+
+		  return I;
+		};
+
+		/**
+		 * Variadic function computing the union of multiple sets.
+		 *
+		 * @param  {...Set} sets - Sets to unite.
+		 * @return {Set}         - The union.
+		 */
+		exports.union = function() {
+		  if (arguments.length < 2)
+		    throw new Error('mnemonist/Set.union: needs at least two arguments.');
+
+		  var U = new Set();
+
+		  var i, l = arguments.length;
+
+		  var iterator,
+		      step;
+
+		  for (i = 0; i < l; i++) {
+		    iterator = arguments[i].values();
+
+		    while ((step = iterator.next(), !step.done))
+		      U.add(step.value);
+		  }
+
+		  return U;
+		};
+
+		/**
+		 * Function computing the difference between two sets.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {Set}   - The difference.
+		 */
+		exports.difference = function(A, B) {
+
+		  // If first set is empty
+		  if (!A.size)
+		    return new Set();
+
+		  if (!B.size)
+		    return new Set(A);
+
+		  var D = new Set();
+
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      D.add(step.value);
+		  }
+
+		  return D;
+		};
+
+		/**
+		 * Function computing the symmetric difference between two sets.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {Set}   - The symmetric difference.
+		 */
+		exports.symmetricDifference = function(A, B) {
+		  var S = new Set();
+
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      S.add(step.value);
+		  }
+
+		  iterator = B.values();
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!A.has(step.value))
+		      S.add(step.value);
+		  }
+
+		  return S;
+		};
+
+		/**
+		 * Function returning whether A is a subset of B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {boolean}
+		 */
+		exports.isSubset = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  // Shortcuts
+		  if (A === B)
+		    return true;
+
+		  if (A.size > B.size)
+		    return false;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      return false;
+		  }
+
+		  return true;
+		};
+
+		/**
+		 * Function returning whether A is a superset of B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {boolean}
+		 */
+		exports.isSuperset = function(A, B) {
+		  return exports.isSubset(B, A);
+		};
+
+		/**
+		 * Function adding the items of set B to the set A.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.add = function(A, B) {
+		  var iterator = B.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done))
+		    A.add(step.value);
+
+		  return;
+		};
+
+		/**
+		 * Function subtracting the items of set B from the set A.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.subtract = function(A, B) {
+		  var iterator = B.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done))
+		    A.delete(step.value);
+
+		  return;
+		};
+
+		/**
+		 * Function intersecting the items of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.intersect = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      A.delete(step.value);
+		  }
+
+		  return;
+		};
+
+		/**
+		 * Function disjuncting the items of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.disjunct = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  var toRemove = [];
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (B.has(step.value))
+		      toRemove.push(step.value);
+		  }
+
+		  iterator = B.values();
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!A.has(step.value))
+		      A.add(step.value);
+		  }
+
+		  for (var i = 0, l = toRemove.length; i < l; i++)
+		    A.delete(toRemove[i]);
+
+		  return;
+		};
+
+		/**
+		 * Function returning the size of the intersection of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.intersectionSize = function(A, B) {
+		  var tmp;
+
+		  // We need to know the smallest set
+		  if (A.size > B.size) {
+		    tmp = A;
+		    A = B;
+		    B = tmp;
+		  }
+
+		  if (A.size === 0)
+		    return 0;
+
+		  if (A === B)
+		    return A.size;
+
+		  var iterator = A.values(),
+		      step;
+
+		  var I = 0;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (B.has(step.value))
+		      I++;
+		  }
+
+		  return I;
+		};
+
+		/**
+		 * Function returning the size of the union of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.unionSize = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  return A.size + B.size - I;
+		};
+
+		/**
+		 * Function returning the Jaccard similarity between A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.jaccard = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  if (I === 0)
+		    return 0;
+
+		  var U = A.size + B.size - I;
+
+		  return I / U;
+		};
+
+		/**
+		 * Function returning the overlap coefficient between A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.overlap = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  if (I === 0)
+		    return 0;
+
+		  return I / Math.min(A.size, B.size);
+		}; 
+	} (set));
+	return set;
+}
+
+var setExports = requireSet();
+
+function union(...sets) {
+  return setExports.union(...sets);
+}
+function intersection(first, ...sets) {
+  let result = /* @__PURE__ */ new Set();
+  if (first.size === 0) {
+    return result;
+  }
+  let other = sets.length > 1 ? setExports.intersection(...sets) : sets[0];
+  if (other.size === 0) {
+    return result;
+  }
+  for (const value of first) {
+    if (other.has(value)) {
+      result.add(value);
+    }
+  }
+  return result;
+}
+function difference(a, b) {
+  if (a.size === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (b.size === 0) {
+    return new Set(a);
+  }
+  let result = /* @__PURE__ */ new Set();
+  for (const value of a) {
+    if (!b.has(value)) {
+      result.add(value);
+    }
+  }
+  return result;
+}
+function equals(a, b) {
+  return a.size === b.size && [...a].every((value) => b.has(value));
+}
+function symmetricDifference(a, b) {
+  return setExports.symmetricDifference(a, b);
+}
+function hasIntersection(a, b) {
+  if (a.size === 0 || b.size === 0) {
+    return false;
+  }
+  if (b.size < a.size) {
+    [a, b] = [b, a];
+  }
+  for (const value of a) {
+    if (b.has(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+class DeploymentElementModel {
+  get id() {
+    return this.$node.id;
+  }
+  get style() {
+    return {
+      shape: DefaultElementShape,
+      color: DefaultThemeColor,
+      ...this.$node.style
+    };
+  }
+  get shape() {
+    return this.$node.style?.shape ?? DefaultElementShape;
+  }
+  get color() {
+    return this.$node.style?.color ?? DefaultThemeColor;
+  }
+  get tags() {
+    return this.$node.tags ?? [];
+  }
+  get title() {
+    return this.$node.title ?? nameFromFqn(this.id);
+  }
+  get description() {
+    return this.$node.description ?? null;
+  }
+  get technology() {
+    return this.$node.technology ?? null;
+  }
+  get parent() {
+    return this.$model.parent(this);
+  }
+  get links() {
+    return this.$node.links ?? [];
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  ancestors() {
+    return this.$model.ancestors(this);
+  }
+  /**
+   * Returns the common ancestor of this element and another element.
+   */
+  commonAncestor(another) {
+    const common = commonAncestor(this.id, another.id);
+    return common ? this.$model.node(common) : null;
+  }
+  /**
+   * Get all sibling (i.e. same parent)
+   */
+  siblings() {
+    return this.$model.siblings(this);
+  }
+  /**
+   * Check if the element is a sibling of another element
+   */
+  isSibling(other) {
+    return this.parent === other.parent;
+  }
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from closest to root)
+   */
+  *ascendingSiblings() {
+    yield* this.siblings();
+    for (const ancestor of this.ancestors()) {
+      yield* ancestor.siblings();
+    }
+    return;
+  }
+  incoming(filter = "all") {
+    return this.$model.incoming(this, filter);
+  }
+  outgoing(filter = "all") {
+    return this.$model.outgoing(this, filter);
+  }
+  *incomers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.incoming(filter)) {
+      if (unique.has(r.source.id)) {
+        continue;
+      }
+      unique.add(r.source.id);
+      yield r.source;
+    }
+    return;
+  }
+  *outgoers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.outgoing(filter)) {
+      if (unique.has(r.target.id)) {
+        continue;
+      }
+      unique.add(r.target.id);
+      yield r.target;
+    }
+    return;
+  }
+  /**
+   * Iterate over all views that include this deployment element.
+   */
+  *views() {
+    for (const view of this.$model.views()) {
+      if (view.includesDeployment(this.id)) {
+        yield view;
+      }
+    }
+  }
+  // type guard
+  isDeploymentNode() {
+    return false;
+  }
+  // type guard
+  isInstance() {
+    return false;
+  }
+  cachedOutgoing = null;
+  cachedIncoming = null;
+  get allOutgoing() {
+    this.cachedOutgoing ??= new RelationshipsAccum(
+      new Set(this.outgoingFromModel()),
+      new Set(this.outgoing())
+    );
+    return this.cachedOutgoing;
+  }
+  get allIncoming() {
+    this.cachedIncoming ??= new RelationshipsAccum(
+      new Set(this.incomingFromModel()),
+      new Set(this.incoming())
+    );
+    return this.cachedIncoming;
+  }
+}
+class DeploymentNodeModel extends DeploymentElementModel {
+  constructor($model, $node) {
+    super();
+    this.$model = $model;
+    this.$node = $node;
+  }
+  get kind() {
+    return this.$node.kind;
+  }
+  children() {
+    return this.$model.children(this);
+  }
+  descendants() {
+    return this.$model.descendants(this);
+  }
+  isDeploymentNode() {
+    return true;
+  }
+  /**
+   * Iterate over all instances nested in this deployment node.
+   */
+  *instances() {
+    for (const nested of this.descendants()) {
+      if (nested.isInstance()) {
+        yield nested;
+      }
+    }
+    return;
+  }
+  /**
+   * Returns deployed instance inside this deployment node
+   * if only there are no more instances
+   */
+  onlyOneInstance() {
+    const children = this.children();
+    if (children.size !== 1) {
+      return null;
+    }
+    const child = t$1([...children]);
+    return child?.isInstance() ? child : null;
+  }
+  /**
+   * Cached result of relationships from instances
+   */
+  _relationshipsFromInstances = null;
+  relationshipsFromInstances() {
+    if (this._relationshipsFromInstances) {
+      return this._relationshipsFromInstances;
+    }
+    const {
+      outgoing,
+      incoming
+    } = this._relationshipsFromInstances = {
+      outgoing: /* @__PURE__ */ new Set(),
+      incoming: /* @__PURE__ */ new Set()
+    };
+    for (const instance of this.instances()) {
+      for (const r of instance.$element.outgoing()) {
+        outgoing.add(r);
+      }
+      for (const r of instance.$element.incoming()) {
+        incoming.add(r);
+      }
+    }
+    return this._relationshipsFromInstances;
+  }
+  /**
+   * We return only relationships that are not already present in nested instances
+   */
+  outgoingFromModel() {
+    const {
+      outgoing,
+      incoming
+    } = this.relationshipsFromInstances();
+    return difference(outgoing, incoming).values();
+  }
+  /**
+   * We return only relationships that are not already present in nested instances
+   */
+  incomingFromModel() {
+    const {
+      outgoing,
+      incoming
+    } = this.relationshipsFromInstances();
+    return difference(incoming, outgoing).values();
+  }
+}
+class DeployedInstanceModel extends DeploymentElementModel {
+  constructor($model, $instance, $element) {
+    super();
+    this.$model = $model;
+    this.$instance = $instance;
+    this.$element = $element;
+  }
+  get parent() {
+    return nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`);
+  }
+  get $node() {
+    return this.$instance;
+  }
+  get style() {
+    const { icon, style } = this.$element.$element;
+    return {
+      shape: this.$element.shape,
+      color: this.$element.color,
+      ...icon && { icon },
+      ...style,
+      ...this.$instance.style
+    };
+  }
+  get shape() {
+    return this.$instance.style?.shape ?? this.$element.shape;
+  }
+  get color() {
+    return this.$instance.style?.color ?? this.$element.color;
+  }
+  get tags() {
+    return this.$instance.tags ?? [];
+  }
+  get title() {
+    return this.$instance.title ?? this.$element.title;
+  }
+  get description() {
+    return this.$instance.description ?? this.$element.description;
+  }
+  get technology() {
+    return this.$instance.technology ?? this.$element.technology;
+  }
+  get links() {
+    return this.$instance.links ?? this.$element.links;
+  }
+  isInstance() {
+    return true;
+  }
+  outgoingFromModel() {
+    return this.$element.outgoing();
+  }
+  incomingFromModel() {
+    return this.$element.incoming();
+  }
+}
+class NestedElementOfDeployedInstanceModel {
+  constructor(instance, element) {
+    this.instance = instance;
+    this.element = element;
+  }
+  get id() {
+    return this.instance.id;
+  }
+  get style() {
+    const { icon, style } = this.element.$element;
+    return {
+      shape: this.element.shape,
+      color: this.element.color,
+      ...icon && { icon },
+      ...style
+    };
+  }
+  get shape() {
+    return this.element.shape;
+  }
+  get color() {
+    return this.element.color;
+  }
+  get title() {
+    return this.element.title;
+  }
+  get description() {
+    return this.element.description;
+  }
+  get technology() {
+    return this.element.technology;
+  }
+  isDeploymentNode() {
+    return false;
+  }
+  isInstance() {
+    return false;
+  }
+}
+class DeploymentRelationModel {
+  constructor($model, $relationship) {
+    this.$model = $model;
+    this.$relationship = $relationship;
+    this.source = $model.deploymentRef($relationship.source);
+    this.target = $model.deploymentRef($relationship.target);
+    const parent = commonAncestor(this.source.id, this.target.id);
+    this.boundary = parent ? this.$model.node(parent) : null;
+  }
+  boundary;
+  source;
+  target;
+  get id() {
+    return this.$relationship.id;
+  }
+  get expression() {
+    return `${this.source.id} -> ${this.target.id}`;
+  }
+  get title() {
+    if (n(this.$relationship.title)) {
+      return null;
+    }
+    return this.$relationship.title;
+  }
+  get technology() {
+    if (n(this.$relationship.technology)) {
+      return null;
+    }
+    return this.$relationship.technology;
+  }
+  get description() {
+    if (n(this.$relationship.description)) {
+      return null;
+    }
+    return this.$relationship.description;
+  }
+  get tags() {
+    return this.$relationship.tags ?? [];
+  }
+  get navigateTo() {
+    return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null;
+  }
+  get links() {
+    return this.$relationship.links ?? [];
+  }
+  *views() {
+    for (const view of this.$model.views()) {
+      if (view.includesRelation(this.id)) {
+        yield view;
+      }
+    }
+    return;
+  }
+}
+class RelationshipsAccum {
+  /**
+   * @param model relationships from logical model
+   * @param deployment relationships from deployment model
+   */
+  constructor(model, deployment) {
+    this.model = model;
+    this.deployment = deployment;
+  }
+  get isEmpty() {
+    return this.model.size === 0 && this.deployment.size === 0;
+  }
+  get nonEmpty() {
+    return this.model.size > 0 || this.deployment.size > 0;
+  }
+  get size() {
+    return this.model.size + this.deployment.size;
+  }
+  /**
+   * Returns new Accum containing all the elements which are both in this and otherAccum
+   */
+  intersect(otherAccum) {
+    return new RelationshipsAccum(
+      intersection(this.model, otherAccum.model),
+      intersection(this.deployment, otherAccum.deployment)
+    );
+  }
+  /**
+   * Returns new Accum containing all the elements which are both in this and otherAccum
+   */
+  difference(otherAccum) {
+    return new RelationshipsAccum(
+      difference(this.model, otherAccum.model),
+      difference(this.deployment, otherAccum.deployment)
+    );
+  }
+  /**
+   * Returns new Accum containing all the elements from both
+   */
+  union(otherAccum) {
+    return new RelationshipsAccum(
+      union(this.model, otherAccum.model),
+      union(this.deployment, otherAccum.deployment)
+    );
+  }
+}
+
+function getId(element) {
+  return isString(element) ? element : element.id;
+}
+
+class LikeC4DeploymentModel {
+  constructor($model, $deployments) {
+    this.$model = $model;
+    this.$deployments = $deployments;
+    for (const element of r($deployments.elements)) {
+      const el = this.addElement(element);
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el);
+      }
+      if (el.isInstance()) {
+        this.#instancesOf.get(el.$element.id).add(el);
+      }
+    }
+    for (const relation of r($deployments.relations)) {
+      const el = this.addRelation(relation);
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el);
+      }
+    }
+  }
+  #elements = /* @__PURE__ */ new Map();
+  // Parent element for given FQN
+  #parents = /* @__PURE__ */ new Map();
+  // Children elements for given FQN
+  #children = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // Keep track of instances of the logical element
+  #instancesOf = new DefaultMap(() => /* @__PURE__ */ new Set());
+  #rootElements = /* @__PURE__ */ new Set();
+  #relations = /* @__PURE__ */ new Map();
+  // Incoming to an element or its descendants
+  #incoming = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // Outgoing from an element or its descendants
+  #outgoing = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // Relationships inside the element, among descendants
+  #internal = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // readonly #views = new Map<ViewID, LikeC4ViewModel<M>>()
+  #allTags = new DefaultMap(
+    () => /* @__PURE__ */ new Set()
+  );
+  #nestedElementsOfDeployment = /* @__PURE__ */ new Map();
+  element(el) {
+    if (el instanceof DeploymentElementModel) {
+      return el;
+    }
+    const id = getId(el);
+    return nonNullable(this.#elements.get(id), `Element ${id} not found`);
+  }
+  findElement(el) {
+    return this.#elements.get(el) ?? null;
+  }
+  node(el) {
+    const element = this.element(el);
+    invariant(element.isDeploymentNode(), `Element ${element.id} is not a deployment node`);
+    return element;
+  }
+  findNode(el) {
+    const element = this.findElement(el);
+    if (!element) {
+      return null;
+    }
+    invariant(element.isDeploymentNode(), `Element ${element?.id} is not a deployment node`);
+    return element;
+  }
+  instance(el) {
+    const element = this.element(el);
+    invariant(element.isInstance(), `Element ${element.id} is not a deployed instance`);
+    return element;
+  }
+  findInstance(el) {
+    const element = this.findElement(el);
+    if (!element) {
+      return null;
+    }
+    invariant(element.isInstance(), `Element ${element?.id} is not a deployed instance`);
+    return element;
+  }
+  /**
+   * Returns the root elements of the model.
+   */
+  roots() {
+    return this.#rootElements.values();
+  }
+  /**
+   * Returns all elements in the model.
+   */
+  elements() {
+    return this.#elements.values();
+  }
+  /**
+   * Returns all elements in the model.
+   */
+  *nodes() {
+    for (const element of this.#elements.values()) {
+      if (element.isDeploymentNode()) {
+        yield element;
+      }
+    }
+    return;
+  }
+  *instances() {
+    for (const element of this.#elements.values()) {
+      if (element.isInstance()) {
+        yield element;
+      }
+    }
+    return;
+  }
+  /**
+   * Iterate over all instances of the given logical element.
+   */
+  *instancesOf(element) {
+    const id = getId(element);
+    const instances = this.#instancesOf.get(id);
+    if (instances) {
+      yield* instances;
+    }
+    return;
+  }
+  deploymentRef(ref) {
+    if ("element" in ref) {
+      const { id, element } = ref;
+      return getOrCreate(this.#nestedElementsOfDeployment, `${id}@${element}`, () => {
+        return new NestedElementOfDeployedInstanceModel(this.instance(id), this.$model.element(element));
+      });
+    }
+    return this.element(ref);
+  }
+  /**
+   * Returns all relationships in the model.
+   */
+  relationships() {
+    return this.#relations.values();
+  }
+  /**
+   * Returns a specific relationship by its ID.
+   */
+  relationship(id) {
+    return nonNullable(this.#relations.get(id), `DeploymentRelationModel ${id} not found`);
+  }
+  findRelationship(id) {
+    return this.#relations.get(id) ?? null;
+  }
+  /**
+   * Returns all deployment views in the model.
+   */
+  *views() {
+    for (const view of this.$model.views()) {
+      if (view.isDeploymentView()) {
+        yield view;
+      }
+    }
+    return;
+  }
+  /**
+   * Returns the parent element of given element.
+   * @see ancestors
+   */
+  parent(element) {
+    const id = getId(element);
+    return this.#parents.get(id) || null;
+  }
+  /**
+   * Get all children of the element (only direct children),
+   * @see descendants
+   */
+  children(element) {
+    const id = getId(element);
+    return this.#children.get(id);
+  }
+  /**
+   * Get all sibling (i.e. same parent)
+   */
+  *siblings(element) {
+    const id = getId(element);
+    const siblings = this.parent(element)?.children() ?? this.roots();
+    for (const sibling of siblings) {
+      if (sibling.id !== id) {
+        yield sibling;
+      }
+    }
+    return;
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  *ancestors(element) {
+    let id = isString(element) ? element : element.id;
+    let parent;
+    while (parent = this.#parents.get(id)) {
+      yield parent;
+      id = parent.id;
+    }
+    return;
+  }
+  /**
+   * Get all descendant elements (i.e. children, children’s children, etc.)
+   */
+  *descendants(element) {
+    for (const child of this.children(element)) {
+      yield child;
+      yield* this.descendants(child.id);
+    }
+    return;
+  }
+  /**
+   * Incoming relationships to the element and its descendants
+   * @see incomers
+   */
+  *incoming(element, filter = "all") {
+    const id = getId(element);
+    for (const rel of this.#incoming.get(id)) {
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && rel.target.id === id):
+        case (filter === "to-descendants" && rel.target.id !== id):
+          yield rel;
+          break;
+      }
+    }
+    return;
+  }
+  /**
+   * Outgoing relationships from the element and its descendants
+   * @see outgoers
+   */
+  *outgoing(element, filter = "all") {
+    const id = getId(element);
+    for (const rel of this.#outgoing.get(id)) {
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && rel.source.id === id):
+        case (filter === "from-descendants" && rel.source.id !== id):
+          yield rel;
+          break;
+      }
+    }
+    return;
+  }
+  addElement(element) {
+    if (this.#elements.has(element.id)) {
+      throw new Error(`Element ${element.id} already exists`);
+    }
+    const el = DeploymentElement.isDeploymentNode(element) ? new DeploymentNodeModel(this, element) : new DeployedInstanceModel(this, element, this.$model.element(element.element));
+    this.#elements.set(el.id, el);
+    const parentId = parentFqn(el.id);
+    if (parentId) {
+      invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
+      this.#parents.set(el.id, this.node(parentId));
+      this.#children.get(parentId).add(el);
+    } else {
+      invariant(el.isDeploymentNode(), `Root element ${el.id} is not a deployment node`);
+      this.#rootElements.add(el);
+    }
+    return el;
+  }
+  addRelation(relation) {
+    if (this.#relations.has(relation.id)) {
+      throw new Error(`Relation ${relation.id} already exists`);
+    }
+    const rel = new DeploymentRelationModel(
+      this,
+      relation
+    );
+    this.#relations.set(rel.id, rel);
+    this.#incoming.get(rel.target.id).add(rel);
+    this.#outgoing.get(rel.source.id).add(rel);
+    const relParent = rel.boundary?.id ?? null;
+    if (relParent) {
+      for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
+        this.#internal.get(ancestor).add(rel);
+      }
+    }
+    for (const sourceAncestor of ancestorsFqn(rel.source.id)) {
+      if (sourceAncestor === relParent) {
+        break;
+      }
+      this.#outgoing.get(sourceAncestor).add(rel);
+    }
+    for (const targetAncestor of ancestorsFqn(rel.target.id)) {
+      if (targetAncestor === relParent) {
+        break;
+      }
+      this.#incoming.get(targetAncestor).add(rel);
+    }
+    return rel;
+  }
+}
+
+class ElementModel {
+  constructor(model, $element) {
+    this.model = model;
+    this.$element = $element;
+  }
+  get id() {
+    return this.$element.id;
+  }
+  get kind() {
+    return this.$element.kind;
+  }
+  get shape() {
+    return this.$element.shape ?? DefaultElementShape;
+  }
+  get color() {
+    return this.$element.color ?? DefaultThemeColor;
+  }
+  get tags() {
+    return this.$element.tags ?? [];
+  }
+  get title() {
+    return this.$element.title;
+  }
+  get description() {
+    return this.$element.description;
+  }
+  get technology() {
+    return this.$element.technology;
+  }
+  get links() {
+    return this.$element.links ?? [];
+  }
+  get parent() {
+    return this.model.parent(this);
+  }
+  get defaultView() {
+    return this.scopedViews().next().value ?? null;
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  ancestors() {
+    return this.model.ancestors(this);
+  }
+  /**
+   * Returns the common ancestor of this element and another element.
+   */
+  commonAncestor(another) {
+    const common = commonAncestor(this.id, another.id);
+    return common ? this.model.element(common) : null;
+  }
+  children() {
+    return this.model.children(this);
+  }
+  /**
+   * Get all descendant elements (i.e. children, children’s children, etc.)
+   */
+  descendants() {
+    return this.model.descendants(this);
+  }
+  /**
+   * Get all sibling (i.e. same parent)
+   */
+  siblings() {
+    return this.model.siblings(this);
+  }
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from closest to root)
+   */
+  *ascendingSiblings() {
+    yield* this.siblings();
+    for (const ancestor of this.ancestors()) {
+      yield* ancestor.siblings();
+    }
+    return;
+  }
+  incoming(filter = "all") {
+    return this.model.incoming(this, filter);
+  }
+  *incomers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.incoming(filter)) {
+      if (unique.has(r.source.id)) {
+        continue;
+      }
+      unique.add(r.source.id);
+      yield r.source;
+    }
+    return;
+  }
+  outgoing(filter = "all") {
+    return this.model.outgoing(this, filter);
+  }
+  *outgoers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.outgoing(filter)) {
+      if (unique.has(r.target.id)) {
+        continue;
+      }
+      unique.add(r.target.id);
+      yield r.target;
+    }
+    return;
+  }
+  cachedOutgoing = null;
+  cachedIncoming = null;
+  get allOutgoing() {
+    this.cachedOutgoing ??= new Set(this.outgoing());
+    return this.cachedOutgoing;
+  }
+  get allIncoming() {
+    this.cachedIncoming ??= new Set(this.incoming());
+    return this.cachedIncoming;
+  }
+  /**
+   * Iterate over all views that include this element.
+   */
+  *views() {
+    for (const view of this.model.views()) {
+      if (view.includesElement(this.id)) {
+        yield view;
+      }
+    }
+    return;
+  }
+  /**
+   * Iterate over all views that scope this element.
+   * It is possible that element is not included in the view.
+   */
+  *scopedViews() {
+    for (const vm of this.model.views()) {
+      if (vm.isElementView() && vm.$view.viewOf === this.id) {
+        yield vm;
+      }
+    }
+    return;
+  }
+  /**
+   * @returns true if the element is deployed
+   */
+  isDeployed() {
+    return n$1(this.deployments().next().value);
+  }
+  deployments() {
+    return this.model.deployment.instancesOf(this);
+  }
+}
+
+class RelationshipModel {
+  constructor(model, $relationship) {
+    this.model = model;
+    this.$relationship = $relationship;
+    this.source = model.element($relationship.source);
+    this.target = model.element($relationship.target);
+    const parent = commonAncestor(this.source.id, this.target.id);
+    this.boundary = parent ? this.model.element(parent) : null;
+  }
+  source;
+  target;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the Relation.
+   */
+  boundary;
+  get id() {
+    return this.$relationship.id;
+  }
+  get expression() {
+    return `${this.source.id} -> ${this.target.id}`;
+  }
+  get title() {
+    if (n(this.$relationship.title)) {
+      return null;
+    }
+    return this.$relationship.title;
+  }
+  get technology() {
+    if (n(this.$relationship.technology)) {
+      return null;
+    }
+    return this.$relationship.technology;
+  }
+  get description() {
+    if (n(this.$relationship.description)) {
+      return null;
+    }
+    return this.$relationship.description;
+  }
+  get navigateTo() {
+    return this.$relationship.navigateTo ? this.model.view(this.$relationship.navigateTo) : null;
+  }
+  get tags() {
+    return this.$relationship.tags ?? [];
+  }
+  get links() {
+    return this.$relationship.links ?? [];
+  }
+  /**
+   * Iterate over all views that include this relationship.
+   */
+  *views() {
+    for (const view of this.model.views()) {
+      if (view.includesRelation(this.id)) {
+        yield view;
+      }
+    }
+    return;
+  }
+}
+
+class EdgeModel {
+  constructor(view, $edge, source, target) {
+    this.view = view;
+    this.$edge = $edge;
+    this.source = source;
+    this.target = target;
+  }
+  get id() {
+    return this.$edge.id;
+  }
+  get parent() {
+    return this.$edge.parent ? this.view.node(this.$edge.parent) : null;
+  }
+  get label() {
+    return this.$edge.label;
+  }
+  get description() {
+    return this.$edge.description ?? null;
+  }
+  get technology() {
+    return this.$edge.technology ?? null;
+  }
+  hasParent() {
+    return this.$edge.parent !== null;
+  }
+  get tags() {
+    return this.$edge.tags ?? [];
+  }
+  get stepNumber() {
+    return this.isStep() ? extractStep(this.id) : null;
+  }
+  get navigateTo() {
+    return this.$edge.navigateTo ? this.view.$model.view(this.$edge.navigateTo) : null;
+  }
+  isStep() {
+    return isStepEdgeId(this.id);
+  }
+  *relationships(type) {
+    for (const id of this.$edge.relations) {
+      if (type) {
+        yield this.view.$model.relationship(id, type);
+        const rel = this.view.$model.findRelationship(id, type);
+        if (rel) {
+          yield rel;
+        }
+      } else {
+        yield this.view.$model.relationship(id);
+      }
+    }
+    return;
+  }
+  includesRelation(rel) {
+    return this.$edge.relations.includes(rel);
+  }
+}
+
+class NodeModel {
+  constructor($view, $node) {
+    this.$view = $view;
+    this.$node = $node;
+  }
+  get id() {
+    return this.$node.id;
+  }
+  get title() {
+    return this.$node.title;
+  }
+  get kind() {
+    return this.$node.kind;
+  }
+  get description() {
+    return this.$node.description;
+  }
+  get technology() {
+    return this.$node.technology;
+  }
+  get parent() {
+    return this.$node.parent ? this.$view.node(this.$node.parent) : null;
+  }
+  get element() {
+    const modelRef = ComputedNode.modelRef(this.$node);
+    return modelRef ? this.$view.$model.element(modelRef) : null;
+  }
+  get deployment() {
+    const modelRef = ComputedNode.deploymentRef(this.$node);
+    return modelRef ? this.$view.$model.deployment.element(modelRef) : null;
+  }
+  get shape() {
+    return this.$node.shape;
+  }
+  get color() {
+    return this.$node.color;
+  }
+  get tags() {
+    return this.$node.tags ?? [];
+  }
+  get links() {
+    return this.$node.links ?? [];
+  }
+  get navigateTo() {
+    return this.$node.navigateTo ? this.$view.$model.view(this.$node.navigateTo) : null;
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  *ancestors() {
+    let parent = this.parent;
+    while (parent) {
+      yield parent;
+      parent = parent.parent;
+    }
+    return;
+  }
+  *children() {
+    for (const child of this.$node.children) {
+      yield this.$view.node(child);
+    }
+    return;
+  }
+  *sublings() {
+    const sublings = this.parent?.children() ?? this.$view.roots();
+    for (const subling of sublings) {
+      if (subling.id !== this.id) {
+        yield subling;
+      }
+    }
+    return;
+  }
+  *incoming(filter = "all") {
+    for (const edgeId of this.$node.inEdges) {
+      const edge = this.$view.edge(edgeId);
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && edge.target.id === this.id):
+        case (filter === "to-descendants" && edge.target.id !== this.id):
+          yield edge;
+          break;
+      }
+    }
+    return;
+  }
+  *incomers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.incoming(filter)) {
+      if (unique.has(r.source.id)) {
+        continue;
+      }
+      unique.add(r.source.id);
+      yield r.source;
+    }
+    return;
+  }
+  *outgoing(filter = "all") {
+    for (const edgeId of this.$node.outEdges) {
+      const edge = this.$view.edge(edgeId);
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && edge.source.id === this.id):
+        case (filter === "from-descendants" && edge.source.id !== this.id):
+          yield edge;
+          break;
+      }
+    }
+    return;
+  }
+  *outgoers(filter = "all") {
+    const unique = /* @__PURE__ */ new Set();
+    for (const r of this.outgoing(filter)) {
+      if (unique.has(r.target.id)) {
+        continue;
+      }
+      unique.add(r.target.id);
+      yield r.target;
+    }
+    return;
+  }
+  isDiagramNode() {
+    return "width" in this.$node && "height" in this.$node;
+  }
+  hasChildren() {
+    return this.$node.children.length > 0;
+  }
+  hasParent() {
+    return this.$node.parent !== null;
+  }
+  /**
+   * Check if this node references to logical model element.
+   */
+  hasElement() {
+    return ComputedNode.modelRef(this.$node) !== null;
+  }
+  /**
+   * Check if this node references to deployment element (Node or Instance).
+   */
+  hasDeployment() {
+    return ComputedNode.deploymentRef(this.$node) !== null;
+  }
+  /**
+   * Check if this node references to deployed instance
+   * Deployed instance always references to element and deployment element.
+   */
+  hasDeployedInstance() {
+    return this.hasElement() && this.hasDeployment();
+  }
+  isGroup() {
+    return ComputedNode.isNodesGroup(this.$node);
+  }
+}
+
+class LikeC4ViewModel {
+  constructor($model, $view) {
+    this.$model = $model;
+    this.$view = $view;
+    for (const node of m($view.nodes, compareByFqnHierarchically)) {
+      const el = new NodeModel(this, node);
+      this.#nodes.set(node.id, el);
+      if (!node.parent) {
+        this.#rootnodes.add(el);
+      }
+      if (el.hasDeployment()) {
+        this.#includeDeployments.add(el.deployment.id);
+      }
+      if (el.hasElement()) {
+        this.#includeElements.add(el.element.id);
+      }
+      for (const tag of el.tags) {
+        getOrCreate(this.#allTags, tag, () => /* @__PURE__ */ new Set()).add(el);
+      }
+    }
+    for (const edge of $view.edges) {
+      const edgeModel = new EdgeModel(this, edge, this.node(edge.source), this.node(edge.target));
+      for (const tag of edgeModel.tags) {
+        getOrCreate(this.#allTags, tag, () => /* @__PURE__ */ new Set()).add(edgeModel);
+      }
+      for (const rel of edge.relations) {
+        this.#includeRelations.add(rel);
+      }
+      this.#edges.set(edge.id, edgeModel);
+    }
+  }
+  #rootnodes = /* @__PURE__ */ new Set();
+  #nodes = /* @__PURE__ */ new Map();
+  #edges = /* @__PURE__ */ new Map();
+  #includeElements = /* @__PURE__ */ new Set();
+  #includeDeployments = /* @__PURE__ */ new Set();
+  #includeRelations = /* @__PURE__ */ new Set();
+  #allTags = /* @__PURE__ */ new Map();
+  get __() {
+    return this.$view.__ ?? "element";
+  }
+  get id() {
+    return this.$view.id;
+  }
+  get title() {
+    return this.$view.title;
+  }
+  get tags() {
+    return this.$view.tags ?? [];
+  }
+  get links() {
+    return this.$view.links ?? [];
+  }
+  get viewOf() {
+    const v = this.$view;
+    if (isScopedElementView(v)) {
+      return this.$model.element(v.viewOf);
+    }
+    return null;
+  }
+  /**
+   * All tags from nodes and edges.
+   */
+  get includedTags() {
+    return [...this.#allTags.keys()];
+  }
+  roots() {
+    return this.#rootnodes.values();
+  }
+  /**
+   * Iterate over all nodes that have children.
+   */
+  *compounds() {
+    for (const node of this.#nodes.values()) {
+      if (node.hasChildren()) {
+        yield node;
+      }
+    }
+    return;
+  }
+  /**
+   * Get node by id.
+   * @throws Error if node is not found.
+   */
+  node(node) {
+    const nodeId = getId(node);
+    return nonNullable(this.#nodes.get(nodeId), `Node ${nodeId} not found in view ${this.$view.id}`);
+  }
+  /**
+   * Find node by id.
+   */
+  findNode(node) {
+    return this.#nodes.get(getId(node)) ?? null;
+  }
+  /**
+   * Iterate over all nodes.
+   */
+  nodes() {
+    return this.#nodes.values();
+  }
+  /**
+   * Find edge by id.
+   * @param edge Edge or id
+   * @returns EdgeModel
+   */
+  edge(edge) {
+    const edgeId = getId(edge);
+    return nonNullable(this.#edges.get(edgeId), `Edge ${edgeId} not found in view ${this.$view.id}`);
+  }
+  findEdge(edge) {
+    return this.#edges.get(getId(edge)) ?? null;
+  }
+  /**
+   * Iterate over all edges.
+   */
+  edges() {
+    return this.#edges.values();
+  }
+  /**
+   * Iterate over all edges.
+   */
+  *edgesWithRelation(relation) {
+    for (const edge of this.#edges.values()) {
+      if (edge.includesRelation(relation)) {
+        yield edge;
+      }
+    }
+    return;
+  }
+  /**
+   * Nodes that have references to elements from logical model.
+   */
+  *elements() {
+    for (const node of this.#nodes.values()) {
+      if (node.hasElement()) {
+        yield node;
+      }
+    }
+    return;
+  }
+  includesElement(elementId) {
+    return this.#includeElements.has(elementId);
+  }
+  includesDeployment(deploymentId) {
+    return this.#includeDeployments.has(deploymentId);
+  }
+  includesRelation(relationId) {
+    return this.#includeRelations.has(relationId);
+  }
+  /**
+   * Below are type guards.
+   */
+  isComputed() {
+    return true;
+  }
+  isDiagram() {
+    return "bounds" in this.$view;
+  }
+  isElementView() {
+    return isElementView(this.$view);
+  }
+  isDeploymentView() {
+    return isDeploymentView(this.$view);
+  }
+  isDynamicView() {
+    return isDynamicView(this.$view);
+  }
+}
+
+class LikeC4Model {
+  constructor($model) {
+    this.$model = $model;
+    for (const element of r($model.elements)) {
+      const el = this.addElement(element);
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el);
+      }
+    }
+    for (const relation of r($model.relations)) {
+      const el = this.addRelation(relation);
+      for (const tag of el.tags) {
+        this.#allTags.get(tag).add(el);
+      }
+    }
+    this.deployment = new LikeC4DeploymentModel(this, $model.deployments);
+    const views = x(
+      r($model.views),
+      m((a, b) => compareNatural(a.title ?? "untitled", b.title ?? "untitled"))
+    );
+    for (const view of views) {
+      const vm = new LikeC4ViewModel(this, view);
+      this.#views.set(view.id, vm);
+      for (const tag of vm.tags) {
+        this.#allTags.get(tag).add(vm);
+      }
+    }
+  }
+  /**
+   * Only available in compile time
+   */
+  Aux;
+  #elements = /* @__PURE__ */ new Map();
+  // Parent element for given FQN
+  #parents = /* @__PURE__ */ new Map();
+  // Children elements for given FQN
+  #children = new DefaultMap(() => /* @__PURE__ */ new Set());
+  #rootElements = /* @__PURE__ */ new Set();
+  #relations = /* @__PURE__ */ new Map();
+  // Incoming to an element or its descendants
+  #incoming = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // Outgoing from an element or its descendants
+  #outgoing = new DefaultMap(() => /* @__PURE__ */ new Set());
+  // Relationships inside the element, among descendants
+  #internal = new DefaultMap(() => /* @__PURE__ */ new Set());
+  #views = /* @__PURE__ */ new Map();
+  #allTags = new DefaultMap(
+    () => /* @__PURE__ */ new Set()
+  );
+  deployment;
+  static create(model) {
+    return new LikeC4Model(model);
+  }
+  /**
+   * This method is supposed to be used only in dumps
+   */
+  static fromDump(dump) {
+    return new LikeC4Model(dump);
+  }
+  get type() {
+    return this.$model.__ ?? "computed";
+  }
+  element(el) {
+    if (el instanceof ElementModel) {
+      return el;
+    }
+    const id = getId(el);
+    return nonNullable(this.findElement(id), `Element ${getId(el)} not found`);
+  }
+  findElement(el) {
+    return this.#elements.get(el) ?? null;
+  }
+  /**
+   * Returns the root elements of the model.
+   */
+  roots() {
+    return this.#rootElements.values();
+  }
+  /**
+   * Returns all elements in the model.
+   */
+  elements() {
+    return this.#elements.values();
+  }
+  /**
+   * Returns all relationships in the model.
+   */
+  relationships() {
+    return this.#relations.values();
+  }
+  relationship(id, type) {
+    if (type === "deployment") {
+      return this.deployment.relationship(id);
+    }
+    let model = this.#relations.get(id) ?? null;
+    if (model || type === "model") {
+      return nonNullable(model, `Model relation ${id} not found`);
+    }
+    return nonNullable(this.deployment.findRelationship(id), `No model/deployment relation ${id} not found`);
+  }
+  findRelationship(id, type) {
+    if (type === "deployment") {
+      return this.deployment.findRelationship(id);
+    }
+    let model = this.#relations.get(id) ?? null;
+    if (model || type === "model") {
+      return model;
+    }
+    return this.deployment.findRelationship(id);
+  }
+  /**
+   * Returns all views in the model.
+   */
+  views() {
+    return this.#views.values();
+  }
+  /**
+   * Returns a specific view by its ID.
+   */
+  view(viewId) {
+    return nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
+  }
+  findView(viewId) {
+    return nonNullable(this.#views.get(viewId), `View ${viewId} not found`);
+  }
+  /**
+   * Returns the parent element of given element.
+   * @see ancestors
+   */
+  parent(element) {
+    const id = getId(element);
+    return this.#parents.get(id) || null;
+  }
+  /**
+   * Get all children of the element (only direct children),
+   * @see descendants
+   */
+  children(element) {
+    const id = getId(element);
+    return this.#children.get(id);
+  }
+  /**
+   * Get all sibling (i.e. same parent)
+   */
+  *siblings(element) {
+    const id = getId(element);
+    const parent = this.#parents.get(id);
+    const siblings = parent ? this.#children.get(parent.id).values() : this.roots();
+    for (const sibling of siblings) {
+      if (sibling.id !== id) {
+        yield sibling;
+      }
+    }
+    return;
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  *ancestors(element) {
+    let id = getId(element);
+    let parent;
+    while (parent = this.#parents.get(id)) {
+      yield parent;
+      id = parent.id;
+    }
+    return;
+  }
+  /**
+   * Get all descendant elements (i.e. children, children’s children, etc.)
+   */
+  *descendants(element) {
+    for (const child of this.children(element)) {
+      yield child;
+      yield* this.descendants(child.id);
+    }
+    return;
+  }
+  /**
+   * Incoming relationships to the element and its descendants
+   * @see incomers
+   */
+  *incoming(element, filter = "all") {
+    const id = getId(element);
+    for (const rel of this.#incoming.get(id)) {
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && rel.target.id === id):
+        case (filter === "to-descendants" && rel.target.id !== id):
+          yield rel;
+          break;
+      }
+    }
+    return;
+  }
+  /**
+   * Outgoing relationships from the element and its descendants
+   * @see outgoers
+   */
+  *outgoing(element, filter = "all") {
+    const id = getId(element);
+    for (const rel of this.#outgoing.get(id)) {
+      switch (true) {
+        case filter === "all":
+        case (filter === "direct" && rel.source.id === id):
+        case (filter === "from-descendants" && rel.source.id !== id):
+          yield rel;
+          break;
+      }
+    }
+    return;
+  }
+  addElement(element) {
+    if (this.#elements.has(element.id)) {
+      throw new Error(`Element ${element.id} already exists`);
+    }
+    const el = new ElementModel(this, element);
+    this.#elements.set(el.id, el);
+    const parentId = parentFqn(el.id);
+    if (parentId) {
+      invariant(this.#elements.has(parentId), `Parent ${parentId} of ${el.id} not found`);
+      this.#parents.set(el.id, this.element(parentId));
+      this.#children.get(parentId).add(el);
+    } else {
+      this.#rootElements.add(el);
+    }
+    return el;
+  }
+  addRelation(relation) {
+    if (this.#relations.has(relation.id)) {
+      throw new Error(`Relation ${relation.id} already exists`);
+    }
+    const rel = new RelationshipModel(
+      this,
+      relation
+    );
+    const { source, target } = rel;
+    this.#relations.set(rel.id, rel);
+    this.#incoming.get(target.id).add(rel);
+    this.#outgoing.get(source.id).add(rel);
+    const relParent = commonAncestor(source.id, target.id);
+    if (relParent) {
+      for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
+        this.#internal.get(ancestor).add(rel);
+      }
+    }
+    for (const sourceAncestor of ancestorsFqn(relation.source)) {
+      if (sourceAncestor === relParent) {
+        break;
+      }
+      this.#outgoing.get(sourceAncestor).add(rel);
+    }
+    for (const targetAncestor of ancestorsFqn(relation.target)) {
+      if (targetAncestor === relParent) {
+        break;
+      }
+      this.#incoming.get(targetAncestor).add(rel);
+    }
+    return rel;
+  }
+}
+
+export { difference as A, equals as B, symmetricDifference as C, hasIntersection as D, x as E, s as F, o$2 as G, getDefaultExportFromCjs as H, n$1 as I, DefaultMap as J, m as K, LikeC4Model as L, t$1 as M, n as N, RelationshipsAccum as R, LikeC4DeploymentModel as a, LikeC4ViewModel as b, compareNatural as c, parentFqnPredicate as d, isAncestor as e, isDescendantOf as f, notDescendantOf as g, hierarchyDepth as h, isSameHierarchy as i, hierarchyDistance as j, commonAncestor as k, ancestorsFqn as l, compareFqnHierarchically as m, nameFromFqn as n, compareByFqnHierarchically as o, parentFqn as p, sortParentsFirst as q, r, sortByFqnHierarchically as s, t, sortNaturalByFqn as u, getOrCreate as v, isString as w, isNonEmptyArray as x, union as y, intersection as z };