@likec4/core 1.30.0 → 1.32.0

package/dist/shared/core.cbA9VZ02.mjs

@@ -0,0 +1,2681 @@
+import { C, f as s$1, u as hierarchyLevel, a as isAncestor, k as commonAncestor, v as sortNaturalByFqn, s as sortParentsFirst, D as DefaultMap, p as parentFqn, l as ancestorsFqn, b as ifilter, m as compareNatural, i as isDescendantOf, w as isString, d as isSameHierarchy } from './core.rmvsy0n3.mjs';
+import { E as splitGlobalFqn, D as DefaultElementShape, a as DefaultThemeColor, l as DefaultShapeSize, c as n$1, g as DefaultLineStyle, F as FqnRef, k as isDeploymentNode, h as DefaultRelationshipColor, I as extractStep, d as isStepEdgeId, e as isGroupElementKind, _ as _type, b as _stage, j as isOnStage, w as whereOperatorAsPredicate, C as isGlobalFqn, B as GlobalFqn, o as o$2 } from './core.CUYDgv2-.mjs';
+import { f as memoizeProp, e as ihead, a as intersection, d as difference, u as union, g as getOrCreate, c as ifind, m as m$2, k as stringHash, j as equals, b as isome } from './core.DoK86JEe.mjs';
+import { u as u$1 } from './core.DbRvwARP.mjs';
+import { n as nonNullable, i as invariant } from './core.Cy9smucx.mjs';
+
+function y(t,i){let a=i.length-t.length;if(a===1){let[n,...r]=i;return C(n,{lazy:t,lazyArgs:r})}if(a===0){let n={lazy:t,lazyArgs:i};return Object.assign(e=>C(e,n),n)}throw new Error("Wrong number of arguments")}
+
+function i(...e){return y(a$1,e)}function a$1(){let e=new Set;return t=>e.has(t)?s$1:(e.add(t),{done:false,hasNext:true,next:t})}
+
+function r(...t){return u$1(Object.values,t)}
+
+var T={asc:(r,n)=>r>n,desc:(r,n)=>r<n};function s(r,n){let[e,...o]=n;if(!m$1(e)){let t=u(...o);return r(e,t)}let a=u(e,...o);return t=>r(t,a)}function u(r,n,...e){let o=typeof r=="function"?r:r[0],a=typeof r=="function"?"asc":r[1],{[a]:t}=T,i=n===void 0?void 0:u(n,...e);return (y,c)=>{let p=o(y),l=o(c);return t(p,l)?1:t(l,p)?-1:i?.(y,c)??0}}function m$1(r){if(d(r))return  true;if(typeof r!="object"||!Array.isArray(r))return  false;let[n,e,...o]=r;return d(n)&&typeof e=="string"&&e in T&&o.length===0}var d=r=>typeof r=="function"&&r.length===1;
+
+function m(...r){return u$1(o$1,r)}function o$1(r,t){let e=[...r];return e.sort(t),e}
+
+function a(...r){return s(n,r)}var n=(r,t)=>[...r].sort(t);
+
+function p(...e){return u$1(t$2,e)}var t$2=(e,o)=>e[o];
+
+function t$1(...n){return u$1(o,n)}var o=n=>n.length===1?n[0]:void 0;
+
+function t(...r){return u$1(Object.entries,r)}
+
+class ElementModel {
+  constructor($model, $element) {
+    this.$model = $model;
+    this.$element = $element;
+    this.id = this.$element.id;
+    this._literalId = this.$element.id;
+    const [projectId, fqn] = splitGlobalFqn(this.id);
+    if (projectId) {
+      this.imported = {
+        from: projectId,
+        fqn
+      };
+      this.hierarchyLevel = hierarchyLevel(fqn);
+    } else {
+      this.imported = null;
+      this.hierarchyLevel = hierarchyLevel(this.id);
+    }
+  }
+  id;
+  _literalId;
+  hierarchyLevel;
+  imported;
+  get parent() {
+    return this.$model.parent(this);
+  }
+  get kind() {
+    return this.$element.kind;
+  }
+  get shape() {
+    return this.$element.shape ?? DefaultElementShape;
+  }
+  get color() {
+    return this.$element.color ?? DefaultThemeColor;
+  }
+  get icon() {
+    return this.$element.icon ?? null;
+  }
+  /**
+   * Returns all tags of the element.
+   * It includes tags from the element and its kind.
+   */
+  get tags() {
+    return memoizeProp(this, Symbol.for("tags"), () => {
+      return i([
+        ...this.$element.tags ?? [],
+        ...this.$model.specification.elements[this.$element.kind]?.tags ?? []
+      ]);
+    });
+  }
+  get title() {
+    return this.$element.title;
+  }
+  get description() {
+    return this.$element.description ?? null;
+  }
+  get technology() {
+    return this.$element.technology ?? null;
+  }
+  get links() {
+    return this.$element.links ?? [];
+  }
+  get defaultView() {
+    return memoizeProp(this, Symbol.for("defaultView"), () => ihead(this.scopedViews()) ?? null);
+  }
+  get isRoot() {
+    return this.parent === null;
+  }
+  get style() {
+    return {
+      size: DefaultShapeSize,
+      ...this.$element.style
+    };
+  }
+  isAncestorOf(another) {
+    return isAncestor(this, another);
+  }
+  isDescendantOf(another) {
+    return isAncestor(another, this);
+  }
+  /**
+   * 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(sort) {
+    if (sort) {
+      const sorted = sortNaturalByFqn([...this.$model.descendants(this)], sort);
+      return sorted[Symbol.iterator]();
+    }
+    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 parent to root)
+   */
+  *ascendingSiblings() {
+    yield* this.siblings();
+    for (const ancestor of this.ancestors()) {
+      yield* ancestor.siblings();
+    }
+    return;
+  }
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from root to closest)
+   */
+  *descendingSiblings() {
+    for (const ancestor of [...this.ancestors()].reverse()) {
+      yield* ancestor.siblings();
+    }
+    yield* this.siblings();
+    return;
+  }
+  incoming(filter = "all") {
+    return this.$model.incoming(this, filter);
+  }
+  *incomers(filter = "all") {
+    const unique2 = /* @__PURE__ */ new Set();
+    for (const r of this.incoming(filter)) {
+      if (unique2.has(r.source.id)) {
+        continue;
+      }
+      unique2.add(r.source.id);
+      yield r.source;
+    }
+    return;
+  }
+  outgoing(filter = "all") {
+    return this.$model.outgoing(this, filter);
+  }
+  *outgoers(filter = "all") {
+    const unique2 = /* @__PURE__ */ new Set();
+    for (const r of this.outgoing(filter)) {
+      if (unique2.has(r.target.id)) {
+        continue;
+      }
+      unique2.add(r.target.id);
+      yield r.target;
+    }
+    return;
+  }
+  get allOutgoing() {
+    return memoizeProp(this, Symbol.for("allOutgoing"), () => new Set(this.outgoing()));
+  }
+  get allIncoming() {
+    return memoizeProp(this, Symbol.for("allIncoming"), () => new Set(this.incoming()));
+  }
+  /**
+   * Iterate over all views that include this element.
+   */
+  views() {
+    return memoizeProp(this, Symbol.for("views"), () => {
+      const views = /* @__PURE__ */ new Set();
+      for (const view of this.$model.views()) {
+        if (view.includesElement(this.id)) {
+          views.add(view);
+        }
+      }
+      return views;
+    });
+  }
+  /**
+   * Iterate over all views that scope this element.
+   * It is possible that element is not included in the view.
+   */
+  scopedViews() {
+    return memoizeProp(this, Symbol.for("scopedViews"), () => {
+      const views = /* @__PURE__ */ new Set();
+      for (const vm of this.$model.views()) {
+        if (vm.isScopedElementView() && vm.viewOf.id === this.id) {
+          views.add(vm);
+        }
+      }
+      return views;
+    });
+  }
+  /**
+   * @returns true if the element is deployed
+   */
+  isDeployed() {
+    return n$1(ihead(this.deployments()));
+  }
+  deployments() {
+    return this.$model.deployment.instancesOf(this);
+  }
+  getMetadata(field) {
+    if (field) {
+      return this.$element.metadata?.[field];
+    }
+    return this.$element.metadata ?? {};
+  }
+  /**
+   * Checks if the element has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+
+class AbstractDeploymentElementModel {
+  get style() {
+    return {
+      shape: DefaultElementShape,
+      color: DefaultThemeColor,
+      size: DefaultShapeSize,
+      ...this.$node.style
+    };
+  }
+  get shape() {
+    return this.$node.style?.shape ?? DefaultElementShape;
+  }
+  get color() {
+    return this.$node.style?.color ?? DefaultThemeColor;
+  }
+  get description() {
+    return this.$node.description ?? null;
+  }
+  get technology() {
+    return this.$node.technology ?? null;
+  }
+  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;
+  }
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from root to closest)
+   */
+  *descendingSiblings() {
+    for (const ancestor of [...this.ancestors()].reverse()) {
+      yield* ancestor.siblings();
+    }
+    yield* this.siblings();
+    return;
+  }
+  incoming(filter = "all") {
+    return this.$model.incoming(this, filter);
+  }
+  outgoing(filter = "all") {
+    return this.$model.outgoing(this, filter);
+  }
+  *incomers(filter = "all") {
+    const unique2 = /* @__PURE__ */ new Set();
+    for (const r of this.incoming(filter)) {
+      if (unique2.has(r.source.id)) {
+        continue;
+      }
+      unique2.add(r.source.id);
+      yield r.source;
+    }
+    return;
+  }
+  *outgoers(filter = "all") {
+    const unique2 = /* @__PURE__ */ new Set();
+    for (const r of this.outgoing(filter)) {
+      if (unique2.has(r.target.id)) {
+        continue;
+      }
+      unique2.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._type !== "deployment") {
+        continue;
+      }
+      if (view.includesDeployment(this.id)) {
+        yield view;
+      }
+    }
+  }
+  // type guard
+  isDeploymentNode() {
+    return false;
+  }
+  // type guard
+  isInstance() {
+    return false;
+  }
+  get allOutgoing() {
+    return memoizeProp(this, Symbol.for("allOutgoing"), () => RelationshipsAccum.from(
+      new Set(this.outgoingModelRelationships()),
+      new Set(this.outgoing())
+    ));
+  }
+  get allIncoming() {
+    return memoizeProp(this, Symbol.for("allIncoming"), () => RelationshipsAccum.from(
+      new Set(this.incomingModelRelationships()),
+      new Set(this.incoming())
+    ));
+  }
+  getMetadata(field) {
+    if (field) {
+      return this.$node.metadata?.[field];
+    }
+    return this.$node.metadata ?? {};
+  }
+  /**
+   * Checks if the deployment element has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+class DeploymentNodeModel extends AbstractDeploymentElementModel {
+  constructor($model, $node) {
+    super();
+    this.$model = $model;
+    this.$node = $node;
+    this.id = $node.id;
+    this._literalId = $node.id;
+    this.title = $node.title;
+    this.hierarchyLevel = hierarchyLevel($node.id);
+  }
+  id;
+  _literalId;
+  title;
+  hierarchyLevel;
+  get parent() {
+    return this.$model.parent(this);
+  }
+  get kind() {
+    return this.$node.kind;
+  }
+  get tags() {
+    return memoizeProp(this, Symbol.for("tags"), () => {
+      return i([
+        ...this.$node.tags ?? [],
+        ...this.$model.$model.specification.deployments[this.kind]?.tags ?? []
+      ]);
+    });
+  }
+  children() {
+    return this.$model.children(this);
+  }
+  descendants(sort = "desc") {
+    return this.$model.descendants(this, sort);
+  }
+  isDeploymentNode() {
+    return true;
+  }
+  /**
+   * Iterate over all instances nested in this deployment node.
+   */
+  *instances() {
+    for (const nested of this.descendants("desc")) {
+      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
+   */
+  outgoingModelRelationships() {
+    return this.relationshipsFromInstances().outgoing.values();
+  }
+  /**
+   * We return only relationships that are not already present in nested instances
+   */
+  incomingModelRelationships() {
+    return this.relationshipsFromInstances().incoming.values();
+  }
+  /**
+   * Returns an iterator of relationships between nested instances
+   */
+  internalModelRelationships() {
+    const {
+      outgoing,
+      incoming
+    } = this.relationshipsFromInstances();
+    return intersection(incoming, outgoing);
+  }
+}
+class DeployedInstanceModel extends AbstractDeploymentElementModel {
+  constructor($model, $instance, element) {
+    super();
+    this.$model = $model;
+    this.$instance = $instance;
+    this.element = element;
+    this.id = $instance.id;
+    this._literalId = $instance.id;
+    this.title = $instance.title ?? element.title;
+    this.hierarchyLevel = hierarchyLevel($instance.id);
+  }
+  id;
+  _literalId;
+  title;
+  hierarchyLevel;
+  get $node() {
+    return this.$instance;
+  }
+  get parent() {
+    return nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`);
+  }
+  get style() {
+    const { icon, style } = this.element.$element;
+    return {
+      shape: this.element.shape,
+      color: this.element.color,
+      size: DefaultShapeSize,
+      ...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 memoizeProp(this, Symbol.for("tags"), () => {
+      return i([
+        ...this.$instance.tags ?? [],
+        ...this.element.tags
+      ]);
+    });
+  }
+  get kind() {
+    return this.element.kind;
+  }
+  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;
+  }
+  outgoingModelRelationships() {
+    return this.element.outgoing();
+  }
+  incomingModelRelationships() {
+    return this.element.incoming();
+  }
+  /**
+   * Iterate over all views that include this instance.
+   * (Some views may include the parent deployment node instead of the instance.)
+   */
+  *views() {
+    for (const view of this.$model.views()) {
+      if (view._type !== "deployment") {
+        continue;
+      }
+      if (view.includesDeployment(this.id)) {
+        yield view;
+        continue;
+      }
+      if (view.includesDeployment(this.parent.id) && this.parent.onlyOneInstance()) {
+        yield view;
+      }
+    }
+  }
+}
+class NestedElementOfDeployedInstanceModel {
+  constructor(instance, element) {
+    this.instance = instance;
+    this.element = element;
+  }
+  get id() {
+    return this.instance.id;
+  }
+  get _literalId() {
+    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$1(this.$relationship.title)) {
+      return null;
+    }
+    return this.$relationship.title;
+  }
+  get technology() {
+    if (!n$1(this.$relationship.technology)) {
+      return null;
+    }
+    return this.$relationship.technology;
+  }
+  get description() {
+    if (!n$1(this.$relationship.description)) {
+      return null;
+    }
+    return this.$relationship.description;
+  }
+  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;
+  }
+  get links() {
+    return this.$relationship.links ?? [];
+  }
+  get color() {
+    return this.$relationship.color ?? DefaultThemeColor;
+  }
+  get line() {
+    return this.$relationship.line ?? DefaultLineStyle;
+  }
+  *views() {
+    for (const view of this.$model.views()) {
+      if (view.includesRelation(this.id)) {
+        yield view;
+      }
+    }
+    return;
+  }
+  isDeploymentRelation() {
+    return true;
+  }
+  isModelRelation() {
+    return false;
+  }
+  getMetadata(field) {
+    if (field) {
+      return this.$relationship.metadata?.[field];
+    }
+    return this.$relationship.metadata ?? {};
+  }
+  /**
+   * Checks if the relationship has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+class RelationshipsAccum {
+  /**
+   * @param model relationships from logical model
+   * @param deployment relationships from deployment model
+   */
+  constructor(model = /* @__PURE__ */ new Set(), deployment = /* @__PURE__ */ new Set()) {
+    this.model = model;
+    this.deployment = deployment;
+  }
+  static empty() {
+    return new RelationshipsAccum();
+  }
+  static from(model, deployment) {
+    return new RelationshipsAccum(
+      new Set(model),
+      new Set(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 RelationshipsAccum.from(
+      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 RelationshipsAccum.from(
+      difference(this.model, otherAccum.model),
+      difference(this.deployment, otherAccum.deployment)
+    );
+  }
+  /**
+   * Returns new Accum containing all the elements from both
+   */
+  union(otherAccum) {
+    return RelationshipsAccum.from(
+      union(this.model, otherAccum.model),
+      union(this.deployment, otherAccum.deployment)
+    );
+  }
+}
+
+function getId(element) {
+  return typeof element === "string" ? element : element.id;
+}
+
+class LikeC4DeploymentModel {
+  constructor($model) {
+    this.$model = $model;
+    const $deployments = this.$deployments = $model.$data.deployments;
+    const elements = r($deployments.elements);
+    for (const element of sortParentsFirst(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<A>>()
+  #allTags = new DefaultMap(
+    () => /* @__PURE__ */ new Set()
+  );
+  #nestedElementsOfDeployment = /* @__PURE__ */ new Map();
+  $deployments;
+  element(el) {
+    if (el instanceof DeploymentNodeModel || el instanceof DeployedInstanceModel) {
+      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;
+  }
+  *nodesOfKind(kind) {
+    for (const node of this.#elements.values()) {
+      if (node.isDeploymentNode() && node.kind === kind) {
+        yield node;
+      }
+    }
+    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 (FqnRef.isInsideInstanceRef(ref)) {
+      const { deployment, element } = ref;
+      return getOrCreate(this.#nestedElementsOfDeployment, `${deployment}@${element}`, () => {
+        return new NestedElementOfDeployedInstanceModel(this.instance(deployment), this.$model.element(element));
+      });
+    }
+    return this.element(ref.deployment);
+  }
+  /**
+   * 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(getId(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 = 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, sort = "desc") {
+    for (const child of this.children(element)) {
+      if (sort === "asc") {
+        yield child;
+        yield* this.descendants(child.id);
+      } else {
+        yield* this.descendants(child.id);
+        yield child;
+      }
+    }
+    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 = isDeploymentNode(element) ? new DeploymentNodeModel(this, Object.freeze(element)) : new DeployedInstanceModel(this, Object.freeze(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,
+      Object.freeze(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 RelationshipModel {
+  constructor(model, $relationship) {
+    this.model = model;
+    this.$relationship = $relationship;
+    this.source = model.element(FqnRef.flatten($relationship.source));
+    this.target = model.element(FqnRef.flatten($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$1(this.$relationship.title)) {
+      return null;
+    }
+    return this.$relationship.title;
+  }
+  get technology() {
+    if (!n$1(this.$relationship.technology)) {
+      return null;
+    }
+    return this.$relationship.technology;
+  }
+  get description() {
+    if (!n$1(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 kind() {
+    return this.$relationship.kind ?? null;
+  }
+  get links() {
+    return this.$relationship.links ?? [];
+  }
+  get color() {
+    return this.$relationship.color ?? DefaultRelationshipColor;
+  }
+  get line() {
+    return this.$relationship.line ?? DefaultLineStyle;
+  }
+  /**
+   * Iterate over all views that include this relationship.
+   */
+  *views() {
+    for (const view of this.model.views()) {
+      if (view.includesRelation(this.id)) {
+        yield view;
+      }
+    }
+    return;
+  }
+  isDeploymentRelation() {
+    return false;
+  }
+  isModelRelation() {
+    return true;
+  }
+  getMetadata(field) {
+    if (field) {
+      return this.$relationship.metadata?.[field];
+    }
+    return this.$relationship.metadata ?? {};
+  }
+  /**
+   * Checks if the relationship has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+
+class EdgeModel {
+  constructor(view, $edge, source, target) {
+    this.view = view;
+    this.$edge = $edge;
+    this.source = source;
+    this.target = target;
+    this.#edge = $edge;
+  }
+  #edge;
+  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;
+  }
+  get color() {
+    return this.#edge.color ?? "gray";
+  }
+  get line() {
+    return this.#edge.line ?? "dashed";
+  }
+  isStep() {
+    return isStepEdgeId(this.id);
+  }
+  *relationships(type) {
+    for (const id of this.#edge.relations) {
+      if (type) {
+        const rel = this.view.$model.findRelationship(id, type);
+        if (rel) {
+          yield rel;
+        }
+      } else {
+        yield this.view.$model.relationship(id);
+      }
+    }
+    return;
+  }
+  includesRelation(rel) {
+    const id = typeof rel === "string" ? rel : rel.id;
+    return this.#edge.relations.includes(id);
+  }
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+
+class NodeModel {
+  constructor($view, $node) {
+    this.$view = $view;
+    this.$node = $node;
+    this.#node = $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 ?? null;
+  }
+  get technology() {
+    return this.#node.technology ?? null;
+  }
+  get parent() {
+    return this.#node.parent ? this.$view.node(this.#node.parent) : null;
+  }
+  get element() {
+    const modelRef = this.#node.modelRef;
+    return modelRef ? this.$view.$model.element(modelRef) : null;
+  }
+  get deployment() {
+    const modelRef = this.#node.deploymentRef;
+    return modelRef ? this.$view.$model.deployment.element(modelRef) : null;
+  }
+  get shape() {
+    return this.#node.shape;
+  }
+  get color() {
+    return this.#node.color;
+  }
+  get icon() {
+    return this.#node.icon ?? null;
+  }
+  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 style() {
+    return this.#node.style;
+  }
+  children() {
+    return memoizeProp(this, "children", () => new Set(this.#node.children.map((child) => this.$view.node(child))));
+  }
+  /**
+   * 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;
+  }
+  *siblings() {
+    const siblings = this.parent?.children() ?? this.$view.roots();
+    for (const sibling of siblings) {
+      if (sibling.id !== this.id) {
+        yield sibling;
+      }
+    }
+    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 n$1(this.#node.modelRef);
+  }
+  /**
+   * Check if this node references to deployment element (Node or Instance).
+   */
+  hasDeployment() {
+    return n$1(this.#node.deploymentRef);
+  }
+  /**
+   * 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 isGroupElementKind(this.#node);
+  }
+  /**
+   * Checks if the node has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+}
+
+class LikeC4ViewModel {
+  /**
+   * Don't use in runtime, only for type inference
+   */
+  Aux;
+  #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 = new DefaultMap((_key) => /* @__PURE__ */ new Set());
+  $view;
+  $model;
+  constructor(model, view) {
+    this.$model = model;
+    this.$view = view;
+    for (const node of view.nodes) {
+      const el = new NodeModel(this, Object.freeze(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) {
+        this.#allTags.get(tag).add(el);
+      }
+    }
+    for (const edge of view.edges) {
+      const edgeModel = new EdgeModel(
+        this,
+        Object.freeze(edge),
+        this.node(edge.source),
+        this.node(edge.target)
+      );
+      for (const tag of edgeModel.tags) {
+        this.#allTags.get(tag).add(edgeModel);
+      }
+      for (const rel of edge.relations) {
+        this.#includeRelations.add(rel);
+      }
+      this.#edges.set(edge.id, edgeModel);
+    }
+  }
+  get _type() {
+    return this.$view[_type];
+  }
+  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() {
+    if (this.isElementView()) {
+      const viewOf = this.$view.viewOf;
+      return viewOf ? this.$model.element(viewOf) : null;
+    }
+    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;
+  }
+  findNodeWithElement(element) {
+    const id = getId(element);
+    return ifind(
+      this.#nodes.values(),
+      (node) => node.hasElement() && node.element.id === id
+    ) ?? 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;
+  }
+  /**
+   * Checks if the view has the given tag.
+   */
+  isTagged(tag) {
+    return this.tags.includes(tag);
+  }
+  includesElement(element) {
+    return this.#includeElements.has(getId(element));
+  }
+  includesDeployment(deployment) {
+    return this.#includeDeployments.has(getId(deployment));
+  }
+  includesRelation(relation) {
+    return this.#includeRelations.has(getId(relation));
+  }
+  /**
+   * Below are type guards.
+   */
+  isComputed() {
+    return this.$view[_stage] === "computed";
+  }
+  isDiagram() {
+    return this.$view[_stage] === "layouted";
+  }
+  isElementView() {
+    return this.$view[_type] === "element";
+  }
+  isScopedElementView() {
+    return this.$view[_type] === "element" && n$1(this.$view.viewOf);
+  }
+  isDeploymentView() {
+    return this.$view[_type] === "deployment";
+  }
+  isDynamicView() {
+    return this.$view[_type] === "dynamic";
+  }
+}
+
+class LikeC4Model {
+  /**
+   * Don't use in runtime, only for type inference
+   */
+  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()
+  );
+  static fromParsed(model) {
+    return new LikeC4Model(model).asParsed;
+  }
+  static create(model) {
+    return new LikeC4Model(model);
+  }
+  /**
+   * Creates a new LikeC4Model instance and infers types from a model dump.\
+   * Model dump expected to be computed or layouted.
+   *
+   * @typeParam D - A constant type parameter extending LikeC4ModelDump
+   * @param dump - The model dump to create the instance from
+   * @returns A  new LikeC4Model instance with types inferred from the dump
+   */
+  static fromDump(dump) {
+    const {
+      _stage: stage = "layouted",
+      projectId = "unknown",
+      globals,
+      imports,
+      deployments,
+      views,
+      relations,
+      elements,
+      specification
+    } = dump;
+    return new LikeC4Model({
+      [_stage]: stage,
+      projectId,
+      globals: {
+        predicates: globals?.predicates ?? {},
+        dynamicPredicates: globals?.dynamicPredicates ?? {},
+        styles: globals?.styles ?? {}
+      },
+      imports: imports ?? {},
+      deployments: {
+        elements: deployments?.elements ?? {},
+        relations: deployments?.relations ?? {}
+      },
+      views: views ?? {},
+      relations: relations ?? {},
+      elements: elements ?? {},
+      specification
+    });
+  }
+  deployment;
+  $data;
+  constructor($data) {
+    this.$data = $data;
+    for (const [, element] of t($data.elements)) {
+      const el = this.addElement(element);
+      for (const tag of el.tags) {
+        this._allTags.get(tag).add(el);
+      }
+    }
+    for (const [projectId, elements] of t($data.imports ?? {})) {
+      for (const element of sortParentsFirst(elements)) {
+        const el = this.addImportedElement(projectId, element);
+        for (const tag of el.tags) {
+          this._allTags.get(tag).add(el);
+        }
+      }
+    }
+    for (const relation of r($data.relations)) {
+      const el = this.addRelation(relation);
+      for (const tag of el.tags) {
+        this._allTags.get(tag).add(el);
+      }
+    }
+    this.deployment = new LikeC4DeploymentModel(this);
+    if (isOnStage($data, "computed") || isOnStage($data, "layouted")) {
+      const views = C(
+        r($data.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);
+        }
+      }
+    }
+  }
+  /**
+   * Type narrows the model to the parsed stage.
+   * This is useful for tests
+   */
+  get asParsed() {
+    return this;
+  }
+  /**
+   * Type narrows the model to the layouted stage.
+   * This is useful for tests
+   */
+  get asComputed() {
+    return this;
+  }
+  /**
+   * Type narrows the model to the layouted stage.
+   * This is useful for tests
+   */
+  get asLayouted() {
+    return this;
+  }
+  /**
+   * Type guard the model to the parsed stage.
+   */
+  isParsed() {
+    return this.stage === "parsed";
+  }
+  /**
+   * Type guard the model to the layouted stage.
+   */
+  isLayouted() {
+    return this.stage === "layouted";
+  }
+  /**
+   * Type guard the model to the computed stage.
+   */
+  isComputed() {
+    return this.stage === "computed";
+  }
+  /**
+   * Keeping here for backward compatibility
+   * @deprecated use {@link $data}
+   */
+  get $model() {
+    return this.$data;
+  }
+  get stage() {
+    return this.$data[_stage];
+  }
+  get projectId() {
+    return this.$data.projectId ?? "unknown";
+  }
+  get specification() {
+    return this.$data.specification;
+  }
+  get globals() {
+    return memoizeProp(this, Symbol.for("globals"), () => ({
+      predicates: {
+        ...this.$data.globals?.predicates
+      },
+      dynamicPredicates: {
+        ...this.$data.globals?.dynamicPredicates
+      },
+      styles: {
+        ...this.$data.globals?.styles
+      }
+    }));
+  }
+  element(el) {
+    if (el instanceof ElementModel) {
+      return el;
+    }
+    const id = getId(el);
+    return nonNullable(this._elements.get(id), `Element ${id} not found`);
+  }
+  findElement(el) {
+    return this._elements.get(getId(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(rel, type) {
+    if (type === "deployment") {
+      return this.deployment.relationship(rel);
+    }
+    const id = getId(rel);
+    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(getId(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) {
+    const id = getId(viewId);
+    return nonNullable(this._views.get(id), `View ${id} not found`);
+  }
+  findView(viewId) {
+    return this._views.get(viewId) ?? null;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Returns all tags used in the model, sorted alphabetically.
+   */
+  get tags() {
+    return memoizeProp(this, "tags", () => m([...this._allTags.keys()], compareNatural));
+  }
+  /**
+   * Returns all tags used in the model, sorted by usage count (descending).
+   */
+  get tagsSortedByUsage() {
+    return memoizeProp(this, "tagsSortedByUsage", () => C(
+      [...this._allTags.entries()],
+      m$2(([tag, tagged]) => ({
+        tag,
+        count: tagged.size,
+        tagged
+      })),
+      m((a, b) => compareNatural(a.tag, b.tag)),
+      a(
+        [p("count"), "desc"]
+      )
+    ));
+  }
+  findByTag(tag, type) {
+    return ifilter(this._allTags.get(tag), (el) => {
+      if (type === "elements") {
+        return el instanceof ElementModel;
+      }
+      if (type === "views") {
+        return el instanceof LikeC4ViewModel;
+      }
+      if (type === "relationships") {
+        return el instanceof RelationshipModel;
+      }
+      return true;
+    });
+  }
+  /**
+   * Returns all elements of the given kind.
+   */
+  *elementsOfKind(kind) {
+    for (const el of this._elements.values()) {
+      if (el.kind === kind) {
+        yield el;
+      }
+    }
+    return;
+  }
+  /**
+   * Returns all elements that match the given where operator.
+   *
+   * @example
+   * ```ts
+   * model.where({
+   *   and: [
+   *     { kind: 'component' },
+   *     {
+   *       or: [
+   *         { tag: 'old' },
+   *         { tag: { neq: 'new' } },
+   *       ],
+   *     },
+   *   ],
+   * })
+   * ```
+   */
+  *elementsWhere(where) {
+    const predicate = whereOperatorAsPredicate(where);
+    for (const el of this._elements.values()) {
+      if (predicate(el)) {
+        yield el;
+      }
+    }
+    return;
+  }
+  /**
+   * Returns all **model** relationships that match the given where operator.
+   *
+   * @example
+   * ```ts
+   * model.relationshipsWhere({
+   *   and: [
+   *     { kind: 'uses' },
+   *     {
+   *       or: [
+   *         { tag: 'old' },
+   *         { tag: { neq: 'new' } },
+   *       ],
+   *     },
+   *   ],
+   * })
+   * ```
+   */
+  *relationshipsWhere(where) {
+    const predicate = whereOperatorAsPredicate(where);
+    for (const rel of this._relations.values()) {
+      if (predicate(rel)) {
+        yield rel;
+      }
+    }
+    return;
+  }
+  addElement(element) {
+    if (this._elements.has(element.id)) {
+      throw new Error(`Element ${element.id} already exists`);
+    }
+    const el = new ElementModel(this, Object.freeze(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;
+  }
+  addImportedElement(projectId, element) {
+    invariant(!isGlobalFqn(element.id), `Imported element already has global FQN`);
+    const id = GlobalFqn(projectId, element.id);
+    if (this._elements.has(id)) {
+      throw new Error(`Element ${id} already exists`);
+    }
+    const el = new ElementModel(
+      this,
+      Object.freeze({
+        ...element,
+        id
+      })
+    );
+    this._elements.set(el.id, el);
+    let parentId = parentFqn(el.id);
+    while (parentId) {
+      if (parentId.includes(".") && this._elements.has(parentId)) {
+        this._parents.set(el.id, this.element(parentId));
+        this._children.get(parentId).add(el);
+        return el;
+      }
+      parentId = parentFqn(parentId);
+    }
+    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,
+      Object.freeze(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(source.id)) {
+      if (sourceAncestor === relParent) {
+        break;
+      }
+      this._outgoing.get(sourceAncestor).add(rel);
+    }
+    for (const targetAncestor of ancestorsFqn(target.id)) {
+      if (targetAncestor === relParent) {
+        break;
+      }
+      this._incoming.get(targetAncestor).add(rel);
+    }
+    return rel;
+  }
+}
+((LikeC4Model2) => {
+  LikeC4Model2.EMPTY = LikeC4Model2.create({
+    _stage: "computed",
+    projectId: "default",
+    specification: {
+      elements: {},
+      relationships: {},
+      deployments: {},
+      tags: {}
+    },
+    globals: {
+      predicates: {},
+      dynamicPredicates: {},
+      styles: {}
+    },
+    deployments: {
+      elements: {},
+      relations: {}
+    },
+    elements: {},
+    relations: {},
+    views: {},
+    imports: {}
+  });
+})(LikeC4Model || (LikeC4Model = {}));
+
+var Connection;
+((Connection2) => {
+  Connection2.isInside = (fqn) => {
+    return (connection) => isAncestor(fqn, connection.source.id) && isAncestor(fqn, connection.target.id);
+  };
+  Connection2.isDirectedBetween = (source, target) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && (connection.target.id === target || isAncestor(target, connection.target.id));
+  };
+  Connection2.isAnyBetween = (source, target) => {
+    const forward = (0, Connection2.isDirectedBetween)(source, target), backward = (0, Connection2.isDirectedBetween)(target, source);
+    return (connection) => forward(connection) || backward(connection);
+  };
+  Connection2.isIncoming = (target) => {
+    return (connection) => (connection.target.id === target || isAncestor(target, connection.target.id)) && !isAncestor(target, connection.source.id);
+  };
+  Connection2.isOutgoing = (source) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && !isAncestor(source, connection.target.id);
+  };
+  Connection2.isAnyInOut = (source) => {
+    const isIn = (0, Connection2.isIncoming)(source), isOut = (0, Connection2.isOutgoing)(source);
+    return (connection) => isIn(connection) || isOut(connection);
+  };
+})(Connection || (Connection = {}));
+
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+class DeploymentConnectionModel {
+  constructor(source, target, relations) {
+    this.source = source;
+    this.target = target;
+    this.relations = relations;
+    this.id = stringHash(`deployment:${source.id}:${target.id}`);
+  }
+  id;
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  get expression() {
+    return `${this.source.id} -> ${this.target.id}`;
+  }
+  _boundary;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  get boundary() {
+    this._boundary ??= this.source.commonAncestor(this.target);
+    return this._boundary;
+  }
+  nonEmpty() {
+    return this.relations.nonEmpty;
+  }
+  [customInspectSymbol](depth, inspectOptions, inspect) {
+    const asString = this.toString();
+    Object.defineProperty(asString, "constructor", {
+      value: DeploymentConnectionModel,
+      enumerable: false
+    });
+    return asString;
+  }
+  toString() {
+    const model = [...this.relations.model].map((c) => "    " + c.expression);
+    if (model.length) {
+      model.unshift("  model:");
+    } else {
+      model.unshift("  model: []");
+    }
+    const deployment = [...this.relations.deployment].map((c) => "    " + c.expression);
+    if (deployment.length) {
+      deployment.unshift("  deployment:");
+    } else {
+      deployment.unshift("  deployment: []");
+    }
+    return [
+      this.expression,
+      ...model,
+      ...deployment
+    ].join("\n");
+  }
+  /**
+   * Check if connection contains deployment relation,
+   * that is directly connected to source or target.
+   */
+  hasDirectDeploymentRelation() {
+    for (const relation of this.relations.deployment) {
+      if (relation.source.id === this.source.id || relation.target.id === this.target.id) {
+        return true;
+      }
+    }
+    return false;
+  }
+  *values() {
+    yield* this.relations.model;
+    yield* this.relations.deployment;
+  }
+  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(
+      this.source,
+      this.target,
+      this.relations.union(other.relations)
+    );
+  }
+  difference(other) {
+    return new DeploymentConnectionModel(
+      this.source,
+      this.target,
+      this.relations.difference(other.relations)
+    );
+  }
+  intersect(other) {
+    return new DeploymentConnectionModel(
+      this.source,
+      this.target,
+      this.relations.intersect(other.relations)
+    );
+  }
+  equals(other) {
+    invariant(other instanceof DeploymentConnectionModel, "Other should ne DeploymentConnectionModel");
+    return this.id === other.id && this.source.id === other.source.id && this.target.id === other.target.id && equals(this.relations.model, other.relations.model) && equals(this.relations.deployment, other.relations.deployment);
+  }
+  /**
+   * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
+   * if `null` is provided in overrides, the corresponding relation set will be empty.
+   */
+  update(overrides) {
+    if (overrides) {
+      overrides = {
+        model: this.relations.model,
+        deployment: this.relations.deployment,
+        ...overrides
+      };
+    }
+    return new DeploymentConnectionModel(
+      this.source,
+      this.target,
+      overrides ? new RelationshipsAccum(
+        overrides.model ?? /* @__PURE__ */ new Set(),
+        overrides.deployment ?? /* @__PURE__ */ new Set()
+      ) : this.relations
+    );
+  }
+}
+
+function isNestedConnection(nested, parent) {
+  if (!parent) {
+    const p = nested;
+    return (n) => isNestedConnection(n, p);
+  }
+  const isSameSource = nested.source === parent.source;
+  const isSameTarget = nested.target === parent.target;
+  if (isSameSource && isSameTarget) {
+    return false;
+  }
+  const isSourceNested = isAncestor(parent.source.id, nested.source.id);
+  const isTargetNested = isAncestor(parent.target.id, nested.target.id);
+  return isSourceNested && isTargetNested || isSameSource && isTargetNested || isSameTarget && isSourceNested;
+}
+function findDeepestNestedConnection(connections, connection) {
+  let deepest = connection;
+  for (const c of connections) {
+    if (isNestedConnection(c, deepest)) {
+      deepest = c;
+    }
+  }
+  return deepest !== connection ? deepest : null;
+}
+function sortDeepestFirst(connections) {
+  const sorted = [];
+  const unsorted = connections.slice();
+  let next;
+  while (next = unsorted.shift()) {
+    let deepest;
+    while (deepest = findDeepestNestedConnection(unsorted, next)) {
+      const index = unsorted.indexOf(deepest);
+      sorted.push(unsorted.splice(index, 1)[0]);
+    }
+    sorted.push(next);
+  }
+  return sorted;
+}
+const boundaryHierarchy = (conn) => conn.boundary?.id ? `.${conn.boundary.id}` : "";
+function sortConnectionsByBoundaryHierarchy(connections, sort) {
+  if (!connections || isString(connections)) {
+    const dir = connections ?? "asc";
+    return (arr) => _sortByBoundary(arr, dir);
+  }
+  return _sortByBoundary(connections, sort ?? "asc");
+}
+function _sortByBoundary(connections, order) {
+  return C(
+    connections,
+    m$2((conn) => ({
+      id: boundaryHierarchy(conn),
+      conn
+    })),
+    sortNaturalByFqn(order),
+    m$2(p("conn"))
+  );
+}
+function findAscendingConnections(connections, connection) {
+  return connections.filter((c) => isNestedConnection(connection, c));
+}
+function findDescendantConnections(connections, connection) {
+  return connections.filter(isNestedConnection(connection));
+}
+function mergeConnections(connections) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    const existing = map2.get(conn.id);
+    if (existing) {
+      map2.set(conn.id, conn.mergeWith(existing));
+    } else {
+      map2.set(conn.id, conn);
+    }
+  }
+  return [...map2.values()];
+}
+function differenceConnections(source, exclude) {
+  const minus = new Map([...exclude].map((c) => [c.id, c]));
+  return [...source].reduce((acc, c) => {
+    const other = minus.get(c.id);
+    if (!other) {
+      acc.push(c);
+      return acc;
+    }
+    const updated = c.difference(other);
+    if (updated.nonEmpty()) {
+      acc.push(updated);
+    }
+    return acc;
+  }, []);
+}
+function hasSameSourceTarget(a, b) {
+  if (b) {
+    return a.source === b.source && a.target === b.target;
+  }
+  return (b2) => a.source === b2.source && a.target === b2.target;
+}
+function hasSameSource(a, b) {
+  if (b) {
+    return a.source === b.source;
+  }
+  return (b2) => a.source === b2.source;
+}
+function hasSameTarget(a, b) {
+  if (b) {
+    return a.target === b.target;
+  }
+  return (b2) => a.target === b2.target;
+}
+function isOutgoing(a, source) {
+  if (!source) {
+    const _source = a;
+    return (b) => isOutgoing(b, _source);
+  }
+  const at = a;
+  return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source);
+}
+function isIncoming(a, target) {
+  if (!target) {
+    const _target = a;
+    return (b) => isIncoming(b, _target);
+  }
+  const at = a;
+  return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target);
+}
+function isAnyInOut(a, source) {
+  if (!source) {
+    const _source = a;
+    return (b) => isAnyInOut(b, _source);
+  }
+  const at = a;
+  return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source);
+}
+
+function findConnection$1(source, target, direction = "directed") {
+  if (source === target) {
+    return [];
+  }
+  if (isSameHierarchy(source, target)) {
+    return [];
+  }
+  const directedIntersection = intersection(source.allOutgoing, target.allIncoming);
+  const directed = directedIntersection.size > 0 ? new ConnectionModel(
+    source,
+    target,
+    directedIntersection
+  ) : null;
+  if (direction === "directed") {
+    return directed ? [directed] : [];
+  }
+  const reverseIntersection = intersection(source.allIncoming, target.allOutgoing);
+  const reverse = reverseIntersection.size > 0 ? new ConnectionModel(
+    target,
+    source,
+    reverseIntersection
+  ) : null;
+  if (directed && reverse) {
+    return [directed, reverse];
+  }
+  if (directed) {
+    return [directed];
+  }
+  if (reverse) {
+    return [reverse];
+  }
+  return [];
+}
+function findConnectionsBetween$1(element, others, direction = "both") {
+  if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) {
+    return [];
+  }
+  const outgoing = [];
+  const incoming = [];
+  for (const _other of others) {
+    if (element === _other) {
+      continue;
+    }
+    for (const found of findConnection$1(element, _other, direction)) {
+      if (found.source === element) {
+        outgoing.push(found);
+      } else {
+        incoming.push(found);
+      }
+    }
+  }
+  return [
+    ...outgoing,
+    ...incoming
+  ];
+}
+function findConnectionsWithin$1(elements) {
+  return [...elements].reduce((acc, el, index, array) => {
+    if (index === array.length - 1) {
+      return acc;
+    }
+    acc.push(
+      ...findConnectionsBetween$1(el, array.slice(index + 1), "both")
+    );
+    return acc;
+  }, []);
+}
+
+const modelConnection = {
+  __proto__: null,
+  findConnection: findConnection$1,
+  findConnectionsBetween: findConnectionsBetween$1,
+  findConnectionsWithin: findConnectionsWithin$1
+};
+
+class ConnectionModel {
+  constructor(source, target, relations = /* @__PURE__ */ new Set()) {
+    this.source = source;
+    this.target = target;
+    this.relations = relations;
+    this.id = stringHash(`model:${source.id}:${target.id}`);
+  }
+  id;
+  _boundary;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  get boundary() {
+    return this._boundary ??= this.source.commonAncestor(this.target);
+  }
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  get expression() {
+    return `${this.source.id} -> ${this.target.id}`;
+  }
+  /**
+   * Returns true if only includes relations between the source and target elements.
+   */
+  get isDirect() {
+    return this.nonEmpty() && !this.isImplicit;
+  }
+  /**
+   * Returns true if includes relations between nested elements of the source and target elements.
+   */
+  get isImplicit() {
+    return this.nonEmpty() && isome(this.relations, o$2(hasSameSourceTarget(this)));
+  }
+  get directRelations() {
+    return new Set(ifilter(this.relations, hasSameSourceTarget(this)));
+  }
+  nonEmpty() {
+    return this.relations.size > 0;
+  }
+  mergeWith(other) {
+    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 ConnectionModel(
+      this.source,
+      this.target,
+      union(this.relations, other.relations)
+    );
+  }
+  difference(other) {
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      difference(this.relations, other.relations)
+    );
+  }
+  intersect(other) {
+    invariant(other instanceof ConnectionModel, "Cannot intersect connection with different type");
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      intersection(this.relations, other.relations)
+    );
+  }
+  equals(other) {
+    invariant(other instanceof ConnectionModel, "Cannot merge connection with different type");
+    const _other = other;
+    return this.id === _other.id && this.source.id === _other.source.id && this.target.id === _other.target.id && equals(this.relations, _other.relations);
+  }
+  /**
+   * Returns a new instance with the updated relations.
+   *
+   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
+   * @returns A new `ConnectionModel` instance with the updated relations.
+   */
+  update(relations) {
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      relations
+    );
+  }
+  [customInspectSymbol](depth, inspectOptions, inspect) {
+    const asString = this.toString();
+    Object.defineProperty(asString, "constructor", {
+      value: ConnectionModel,
+      enumerable: false
+    });
+    return asString;
+  }
+  toString() {
+    return [
+      this.expression,
+      this.relations.size ? "  relations:" : "  relations: [ ]",
+      ...[...this.relations].map((c) => "    " + c.expression)
+    ].join("\n");
+  }
+  /**
+   * Creates a new connection with reversed direction (target becomes source and vice versa)
+   * @param search - When true, attempts to find an existing connection between the reversed nodes
+   */
+  reversed(search = false) {
+    if (!search) {
+      return new ConnectionModel(this.target, this.source);
+    }
+    const [found] = findConnection$1(this.target, this.source, "directed");
+    return found ?? new ConnectionModel(this.target, this.source, /* @__PURE__ */ new Set());
+  }
+}
+
+function findConnection(source, target, direction = "directed") {
+  if (source === target) {
+    return [];
+  }
+  if (isSameHierarchy(source, target)) {
+    return [];
+  }
+  const directedIntersection = source.allOutgoing.intersect(target.allIncoming);
+  const directed = directedIntersection.nonEmpty ? [
+    new DeploymentConnectionModel(
+      source,
+      target,
+      directedIntersection
+    )
+  ] : [];
+  if (direction === "directed") {
+    return directed;
+  }
+  return [
+    ...directed,
+    ...findConnection(target, source, "directed")
+  ];
+}
+function findConnectionsBetween(element, others, direction = "both") {
+  if (element.allIncoming.isEmpty && element.allOutgoing.isEmpty) {
+    return [];
+  }
+  const outgoing = [];
+  const incoming = [];
+  for (const _other of others) {
+    if (element === _other) {
+      continue;
+    }
+    for (const found of findConnection(element, _other, direction)) {
+      if (found.source === element) {
+        outgoing.push(found);
+      } else {
+        incoming.push(found);
+      }
+    }
+  }
+  return [
+    ...outgoing,
+    ...incoming
+  ];
+}
+function findConnectionsWithin(elements) {
+  return [...elements].reduce((acc, el, index, array) => {
+    if (index === array.length - 1) {
+      return acc;
+    }
+    acc.push(
+      ...findConnectionsBetween(el, array.slice(index + 1), "both")
+    );
+    return acc;
+  }, []);
+}
+
+const deploymentConnection = {
+  __proto__: null,
+  findConnection: findConnection,
+  findConnectionsBetween: findConnectionsBetween,
+  findConnectionsWithin: findConnectionsWithin
+};
+
+function isDeploymentNodeModel(model) {
+  return model instanceof DeploymentNodeModel;
+}
+function isDeployedInstanceModel(model) {
+  return model instanceof DeployedInstanceModel;
+}
+function isDeploymentElementModel(model) {
+  return isDeploymentNodeModel(model) || isDeployedInstanceModel(model);
+}
+function isNestedElementOfDeployedInstanceModel(model) {
+  return model instanceof NestedElementOfDeployedInstanceModel;
+}
+function isDeploymentRelationModel(x) {
+  return x instanceof DeploymentRelationModel;
+}
+function isRelationModel(x) {
+  return x instanceof RelationshipModel;
+}
+function isElementModel(element) {
+  return element instanceof ElementModel;
+}
+function isLikeC4ViewModel(view) {
+  return view instanceof LikeC4ViewModel;
+}
+function isNodeModel(node) {
+  return node instanceof NodeModel;
+}
+function isEdgeModel(edge) {
+  return edge instanceof EdgeModel;
+}
+
+export { RelationshipModel as A, hasSameSource as B, Connection as C, DeploymentConnectionModel as D, ElementModel as E, hasSameSourceTarget as F, hasSameTarget as G, sortDeepestFirst as H, DeployedInstanceModel as I, DeploymentNodeModel as J, DeploymentRelationModel as K, LikeC4Model as L, LikeC4DeploymentModel as M, EdgeModel as N, LikeC4ViewModel as O, NodeModel as P, isDeploymentRelationModel as Q, RelationshipsAccum as R, isRelationModel as S, isLikeC4ViewModel as T, isNodeModel as U, isEdgeModel as V, a, t$1 as b, differenceConnections as c, deploymentConnection as d, isNestedConnection as e, findAscendingConnections as f, customInspectSymbol as g, findConnectionsBetween$1 as h, i, isElementModel as j, isNestedElementOfDeployedInstanceModel as k, isDeployedInstanceModel as l, mergeConnections as m, isDeploymentNodeModel as n, isDeploymentElementModel as o, p, modelConnection as q, r, sortConnectionsByBoundaryHierarchy as s, t, findDescendantConnections as u, findDeepestNestedConnection as v, isAnyInOut as w, isOutgoing as x, isIncoming as y, ConnectionModel as z };