@likec4/language-server 1.8.1 → 1.9.0

package/dist/shared/language-server.D0bOlrCi.cjs

@@ -0,0 +1,1619 @@
+'use strict';
+
+const core = require('@likec4/core');
+const remeda = require('remeda');
+const graphlib = require('@dagrejs/graphlib');
+const objectHash = require('object-hash');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const graphlib__default = /*#__PURE__*/_interopDefaultCompat(graphlib);
+const objectHash__default = /*#__PURE__*/_interopDefaultCompat(objectHash);
+
+function calcViewLayoutHash(view) {
+  const tohash = {
+    id: view.id,
+    __: view.__ ?? "element",
+    autoLayout: view.autoLayout,
+    nodes: remeda.pipe(
+      view.nodes,
+      remeda.map(remeda.pick(["id", "title", "description", "technology", "shape", "icon", "children"])),
+      remeda.mapToObj(({ id, icon, ...node }) => [id, { ...node, icon: remeda.isTruthy(icon) ? "Y" : "N" }])
+    ),
+    edges: remeda.pipe(
+      view.edges,
+      remeda.map(remeda.pick(["source", "target", "label", "description", "technology", "dir", "head", "tail", "line"])),
+      remeda.mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+    )
+  };
+  view.hash = objectHash__default(tohash, {
+    ignoreUnknown: true,
+    respectType: false
+  });
+  return view;
+}
+
+function elementExprToPredicate(target) {
+  if (core.Expr.isElementWhere(target)) {
+    const predicate = elementExprToPredicate(target.where.expr);
+    const where = core.whereOperatorAsPredicate(target.where.condition);
+    return (n) => predicate(n) && where(n);
+  }
+  if (core.Expr.isWildcard(target)) {
+    return () => true;
+  }
+  if (core.Expr.isElementKindExpr(target)) {
+    return target.isEqual ? (n) => n.kind === target.elementKind : (n) => n.kind !== target.elementKind;
+  }
+  if (core.Expr.isElementTagExpr(target)) {
+    return target.isEqual ? ({ tags }) => !!tags && tags.includes(target.elementTag) : ({ tags }) => remeda.isNullish(tags) || !tags.includes(target.elementTag);
+  }
+  if (core.Expr.isExpandedElementExpr(target)) {
+    return (n) => n.id === target.expanded || core.parentFqn(n.id) === target.expanded;
+  }
+  if (core.Expr.isElementRef(target)) {
+    const { element, isDescedants } = target;
+    return isDescedants ? (n) => n.id.startsWith(element + ".") : (n) => n.id === element;
+  }
+  if (core.Expr.isCustomElement(target)) {
+    return elementExprToPredicate(target.custom.expr);
+  }
+  core.nonexhaustive(target);
+}
+
+function applyCustomElementProperties(_rules, _nodes) {
+  const rules = _rules.flatMap((r) => "include" in r ? r.include.filter(core.Expr.isCustomElement) : []);
+  if (rules.length === 0) {
+    return _nodes;
+  }
+  const nodes = [..._nodes];
+  for (const {
+    custom: { expr, ...props }
+  } of rules) {
+    const { border, opacity, ...rest } = remeda.omitBy(props, remeda.isNullish);
+    const notEmpty = !remeda.isEmpty(rest);
+    const satisfies = elementExprToPredicate(expr);
+    nodes.forEach((node, i) => {
+      if (!satisfies(node)) {
+        return;
+      }
+      if (notEmpty) {
+        node = {
+          ...node,
+          isCustomized: true,
+          ...rest
+        };
+      }
+      let styleOverride;
+      if (border !== void 0) {
+        styleOverride = { border };
+      }
+      if (opacity !== void 0) {
+        styleOverride = { ...styleOverride, opacity };
+      }
+      if (styleOverride) {
+        node = {
+          ...node,
+          isCustomized: true,
+          style: {
+            ...node.style,
+            ...styleOverride
+          }
+        };
+      }
+      nodes[i] = node;
+    });
+  }
+  return nodes;
+}
+
+function relationExpressionToPredicates(expr) {
+  switch (true) {
+    case core.Expr.isRelationWhere(expr):
+      return relationExpressionToPredicates(expr.where.expr);
+    case core.Expr.isRelation(expr): {
+      const isSource = elementExprToPredicate(expr.source);
+      const isTarget = elementExprToPredicate(expr.target);
+      return (edge) => {
+        return isSource(edge.source) && isTarget(edge.target) || !!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source);
+      };
+    }
+    case core.Expr.isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout);
+      return (edge) => isInOut(edge.source) || isInOut(edge.target);
+    }
+    case core.Expr.isIncoming(expr): {
+      const isTarget = elementExprToPredicate(expr.incoming);
+      return (edge) => isTarget(edge.target);
+    }
+    case core.Expr.isOutgoing(expr): {
+      const isSource = elementExprToPredicate(expr.outgoing);
+      return (edge) => isSource(edge.source);
+    }
+    default:
+      core.nonexhaustive(expr);
+  }
+}
+function applyCustomRelationProperties(_rules, nodes, _edges) {
+  const rules = _rules.flatMap((r) => "include" in r ? r.include.filter(core.Expr.isCustomRelationExpr) : []);
+  const edges = Array.from(_edges);
+  if (rules.length === 0 || edges.length === 0) {
+    return edges;
+  }
+  for (const {
+    customRelation: { relation, title, ...customprops }
+  } of rules) {
+    const props = remeda.omitBy(customprops, remeda.isNullish);
+    const satisfies = relationExpressionToPredicates(relation);
+    edges.forEach((edge, i) => {
+      const source = nodes.find((n) => n.id === edge.source);
+      const target = nodes.find((n) => n.id === edge.target);
+      if (!source || !target) {
+        return;
+      }
+      if (satisfies({ source, target })) {
+        edges[i] = {
+          ...edge,
+          label: title ?? edge.label,
+          isCustomized: true,
+          ...props
+        };
+      }
+    });
+  }
+  return edges;
+}
+
+function applyViewRuleStyles(_rules, nodes) {
+  const rules = _rules.filter(core.isViewRuleStyle);
+  if (rules.length === 0) {
+    return nodes;
+  }
+  for (const rule of rules) {
+    const predicates = [];
+    for (const target of rule.targets) {
+      if (core.Expr.isWildcard(target)) {
+        predicates.push(() => true);
+        break;
+      }
+      predicates.push(elementExprToPredicate(target));
+    }
+    remeda.filter(nodes, remeda.anyPass(predicates)).forEach((n) => {
+      n.shape = rule.style.shape ?? n.shape;
+      n.color = rule.style.color ?? n.color;
+      if (remeda.isDefined(rule.style.icon)) {
+        n.icon = rule.style.icon;
+      }
+      if (remeda.isDefined(rule.notation)) {
+        n.notation = rule.notation;
+      }
+      let styleOverride;
+      if (remeda.isDefined(rule.style.border)) {
+        styleOverride = { border: rule.style.border };
+      }
+      if (remeda.isDefined(rule.style.opacity)) {
+        styleOverride = { ...styleOverride, opacity: rule.style.opacity };
+      }
+      if (styleOverride) {
+        n.style = {
+          ...n.style,
+          ...styleOverride
+        };
+      }
+    });
+  }
+  return nodes;
+}
+
+function updateDepthOfAncestors(node, nodes) {
+  let parentNd;
+  while (!!node.parent && (parentNd = nodes.get(node.parent))) {
+    const depth = parentNd.depth ?? 1;
+    parentNd.depth = Math.max(depth, (node.depth ?? 0) + 1);
+    if (parentNd.depth === depth) {
+      break;
+    }
+    node = parentNd;
+  }
+}
+function buildComputeNodes(elements) {
+  return Array.from(elements).sort(core.compareByFqnHierarchically).reduce((map, { id, color, shape, style, ...el }) => {
+    let parent = core.parentFqn(id);
+    let level = 0;
+    while (parent) {
+      const parentNd = map.get(parent);
+      if (parentNd) {
+        if (parentNd.children.length == 0) {
+          parentNd.depth = 1;
+          updateDepthOfAncestors(parentNd, map);
+        }
+        parentNd.children.push(id);
+        level = parentNd.level + 1;
+        break;
+      }
+      parent = core.parentFqn(parent);
+    }
+    const node = {
+      ...el,
+      id,
+      parent,
+      level,
+      color: color ?? core.DefaultThemeColor,
+      shape: shape ?? core.DefaultElementShape,
+      children: [],
+      inEdges: [],
+      outEdges: [],
+      style: {
+        ...style
+      }
+    };
+    map.set(id, node);
+    return map;
+  }, /* @__PURE__ */ new Map());
+}
+
+function buildElementNotations(nodes) {
+  return remeda.pipe(
+    nodes,
+    remeda.groupBy(remeda.prop("notation")),
+    remeda.mapValues(
+      remeda.piped(
+        remeda.groupBy(remeda.prop("shape")),
+        remeda.mapValues(
+          remeda.piped(
+            remeda.groupBy(remeda.prop("color")),
+            remeda.mapValues(
+              remeda.piped(
+                remeda.map(remeda.prop("kind")),
+                remeda.unique()
+              )
+            ),
+            remeda.entries(),
+            remeda.map(([color, kinds]) => ({
+              kinds,
+              color
+            }))
+          )
+        ),
+        remeda.entries(),
+        remeda.flatMap(
+          ([shape, colors]) => colors.map(({ color, kinds }) => ({
+            shape,
+            color,
+            kinds
+          }))
+        )
+      )
+    ),
+    remeda.entries(),
+    remeda.flatMap(
+      ([title, shapes]) => shapes.map(({ shape, color, kinds }) => ({
+        title,
+        shape,
+        color,
+        kinds
+      }))
+    ),
+    remeda.sortBy(
+      remeda.prop("title"),
+      remeda.prop("shape"),
+      [
+        (n) => n.kinds.length,
+        "desc"
+      ]
+    )
+  );
+}
+
+const postorder = graphlib__default.alg.postorder;
+const findCycles = graphlib__default.alg.findCycles;
+const isAcyclic = graphlib__default.alg.isAcyclic;
+
+function sortChildren(nodes) {
+  nodes.forEach((parent) => {
+    if (parent.children.length > 0) {
+      parent.children = nodes.flatMap((n) => n.parent === parent.id ? n.id : []);
+    }
+  });
+}
+function sortNodes({
+  nodes,
+  edges
+}) {
+  if (edges.length === 0) {
+    return nodes;
+  }
+  const g = new graphlib.Graph({
+    compound: false,
+    directed: true,
+    multigraph: false
+  });
+  const getNode = (id) => core.nonNullable(
+    nodes.find((n) => n.id === id),
+    "Edge not found"
+  );
+  const getEdge = (id) => core.nonNullable(
+    edges.find((edge) => edge.id === id),
+    "Edge not found"
+  );
+  for (const e of [...edges].sort(core.compareRelations)) {
+    g.setEdge(e.source, e.target);
+  }
+  for (const n of nodes) {
+    g.setNode(n.id);
+    if (n.children.length > 0) {
+      n.inEdges.forEach((e) => {
+        const edge = getEdge(e);
+        if (edge.target !== n.id && getNode(edge.source).children.length === 0) {
+          g.setEdge(edge.source, n.id);
+        }
+      });
+    }
+    if (n.parent) {
+      g.setEdge(n.parent, n.id);
+    }
+  }
+  let sources = g.sources();
+  if (sources.length === 0) {
+    sources = remeda.pipe(
+      nodes,
+      remeda.sort(core.compareByFqnHierarchically),
+      remeda.filter((n) => n.inEdges.length === 0 || n.parent === null),
+      remeda.map((n) => n.id)
+    );
+  }
+  const orderedIds = postorder(g, sources).reverse();
+  const sorted = orderedIds.map(getNode);
+  if (sorted.length < nodes.length) {
+    const unsorted = remeda.difference(nodes, sorted);
+    sorted.push(...unsorted);
+  }
+  core.invariant(sorted.length === nodes.length, "Not all nodes were processed by graphlib");
+  sortChildren(sorted);
+  return sorted;
+}
+
+const NoFilter = () => true;
+const Identity = (x) => x;
+const filterBy = (pred) => pred === NoFilter ? Identity : remeda.filter(pred);
+const filterOne = (pred) => pred === NoFilter ? Identity : (x) => pred(x) ? x : null;
+function includeElementRef(expr, where = NoFilter) {
+  const currentElements = [...this.resolvedElements];
+  const filter = filterBy(where);
+  const elements = filter(
+    expr.isDescedants === true ? this.graph.childrenOrElement(expr.element) : [this.graph.element(expr.element)]
+  );
+  if (elements.length === 0) {
+    return;
+  }
+  this.addElement(...elements);
+  if (elements.length > 1) {
+    this.addEdges(this.graph.edgesWithin(elements));
+  }
+  if (currentElements.length > 0 && elements.length > 0) {
+    for (const el of elements) {
+      this.addEdges(this.graph.anyEdgesBetween(el, currentElements));
+    }
+  }
+}
+function excludeElementRef(expr, where = NoFilter) {
+  const elements = [...this.resolvedElements].filter(remeda.allPass([
+    elementExprToPredicate(expr),
+    where
+  ]));
+  this.excludeElement(...elements);
+}
+function includeWildcardRef(_expr, where = NoFilter) {
+  const root = this.root;
+  if (!root) {
+    const elements = this.graph.rootElements.filter(where);
+    if (elements.length <= 0) {
+      return;
+    }
+    const currentElements2 = [...this.resolvedElements];
+    this.addElement(...elements);
+    this.addEdges(this.graph.edgesWithin(elements));
+    if (currentElements2.length > 0) {
+      for (const el of elements) {
+        this.addEdges(this.graph.anyEdgesBetween(el, currentElements2));
+      }
+    }
+    return;
+  }
+  const currentElements = [...this.resolvedElements];
+  const _elRoot = filterOne(where)(this.graph.element(root));
+  if (_elRoot) {
+    this.addElement(_elRoot);
+  }
+  const filter = filterBy(where);
+  const children = filter(this.graph.children(root));
+  const hasChildren = children.length > 0;
+  if (hasChildren) {
+    this.addElement(...children);
+    this.addEdges(this.graph.edgesWithin(children));
+  } else if (_elRoot) {
+    children.push(_elRoot);
+  }
+  const neighbours = [
+    ...currentElements,
+    ...filter([
+      ...this.graph.siblings(root),
+      ...this.graph.ancestors(root).flatMap((a) => this.graph.siblings(a.id))
+    ])
+  ];
+  for (const el of children) {
+    this.addEdges(this.graph.anyEdgesBetween(el, neighbours));
+  }
+  if (!hasChildren && _elRoot) {
+    const edgesWithSiblings = this.graph.anyEdgesBetween(_elRoot, this.graph.siblings(root));
+    if (edgesWithSiblings.length === 0) {
+      const _parentId = core.parentFqn(root);
+      const parent = _parentId && this.graph.element(_parentId);
+      if (parent && where(parent)) {
+        this.addElement(parent);
+      }
+    }
+  }
+}
+function excludeWildcardRef(_expr, where = NoFilter) {
+  if (where !== NoFilter) {
+    const elements = [...this.resolvedElements].filter(where);
+    this.excludeElement(...elements);
+    return;
+  }
+  const root = this.root;
+  if (root) {
+    this.excludeElement(
+      this.graph.element(root),
+      ...this.graph.children(root)
+    );
+    this.excludeRelation(
+      ...this.graph.connectedRelations(root)
+    );
+  } else {
+    this.reset();
+  }
+}
+function includeExpandedElementExpr(expr, where = NoFilter) {
+  const filter = filterBy(where);
+  const currentElements = [...this.resolvedElements];
+  const parent = this.graph.element(expr.expanded);
+  if (where(parent)) {
+    this.addElement(parent);
+    const anyEdgesBetween = this.graph.anyEdgesBetween(parent, currentElements);
+    this.addEdges(anyEdgesBetween);
+  }
+  const expanded = [];
+  for (const el of filter(this.graph.children(expr.expanded))) {
+    this.addImplicit(el);
+    const edges = this.graph.anyEdgesBetween(el, currentElements);
+    if (edges.length > 0) {
+      this.addEdges(edges);
+      expanded.push(el);
+    }
+  }
+  if (expanded.length > 1) {
+    this.addEdges(this.graph.edgesWithin(expanded));
+  }
+}
+function excludeExpandedElementExpr(expr, where = NoFilter) {
+  const elements = [...this.resolvedElements].filter(remeda.allPass([
+    elementExprToPredicate(expr),
+    where
+  ]));
+  this.excludeElement(...elements);
+}
+const asElementPredicate = (expr) => {
+  if (expr.isEqual) {
+    if (core.Expr.isElementKindExpr(expr)) {
+      return (e) => e.kind === expr.elementKind;
+    } else {
+      return ({ tags }) => !!tags && tags.includes(expr.elementTag);
+    }
+  } else {
+    if (core.Expr.isElementKindExpr(expr)) {
+      return (e) => e.kind !== expr.elementKind;
+    } else {
+      return ({ tags }) => remeda.isNullish(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+    }
+  }
+};
+function includeElementKindOrTag(expr, where = NoFilter) {
+  const elements = this.graph.elements.filter(asElementPredicate(expr)).filter(where);
+  if (elements.length > 0) {
+    const currentElements = [...this.resolvedElements];
+    this.addElement(...elements);
+    this.addEdges(this.graph.edgesWithin(elements));
+    for (const el of elements) {
+      this.addEdges(this.graph.anyEdgesBetween(el, currentElements));
+    }
+  }
+}
+function excludeElementKindOrTag(expr, where = NoFilter) {
+  const elements = [...this.resolvedElements].filter(asElementPredicate(expr)).filter(where);
+  if (elements.length > 0) {
+    this.excludeElement(...elements);
+  }
+}
+function resolveNeighbours(expr) {
+  if (core.Expr.isElementRef(expr)) {
+    return this.graph.ascendingSiblings(expr.element);
+  }
+  return this.root ? this.graph.ascendingSiblings(this.root) : this.graph.rootElements;
+}
+function resolveElements(expr) {
+  if (core.Expr.isWildcard(expr)) {
+    if (this.root) {
+      return [...this.graph.children(this.root), this.graph.element(this.root)];
+    } else {
+      return this.graph.rootElements;
+    }
+  }
+  if (core.Expr.isElementKindExpr(expr)) {
+    return this.graph.elements.filter((el) => {
+      if (expr.isEqual) {
+        return el.kind === expr.elementKind;
+      }
+      return el.kind !== expr.elementKind;
+    });
+  }
+  if (core.Expr.isElementTagExpr(expr)) {
+    return this.graph.elements.filter((el) => {
+      const tags = el.tags;
+      if (expr.isEqual) {
+        return !!tags && tags.includes(expr.elementTag);
+      }
+      return remeda.isNullish(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+    });
+  }
+  if (core.Expr.isExpandedElementExpr(expr)) {
+    return [this.graph.element(expr.expanded)];
+  }
+  if (!core.Expr.isElementRef(expr)) {
+    return core.nonexhaustive(expr);
+  }
+  if (this.root === expr.element && expr.isDescedants !== true) {
+    return [...this.graph.children(this.root), this.graph.element(this.root)];
+  }
+  if (expr.isDescedants) {
+    return this.graph.childrenOrElement(expr.element);
+  } else {
+    return [this.graph.element(expr.element)];
+  }
+}
+function edgesIncomingExpr(expr) {
+  if (core.Expr.isWildcard(expr)) {
+    if (!this.root) {
+      return [];
+    }
+    const sources2 = this.graph.ascendingSiblings(this.root);
+    const targets2 = [...this.graph.children(this.root), this.graph.element(this.root)];
+    return this.graph.edgesBetween(sources2, targets2);
+  }
+  const targets = resolveElements.call(this, expr);
+  if (targets.length === 0) {
+    return [];
+  }
+  let sources = [...this.resolvedElements];
+  if (core.Expr.isElementRef(expr) || core.Expr.isExpandedElementExpr(expr)) {
+    const exprElement = expr.element ?? expr.expanded;
+    const isDescedants = expr.isDescedants ?? false;
+    sources = sources.filter(
+      (el) => (
+        // allow elements, that are not nested or are direct children
+        !core.isAncestor(exprElement, el.id) || isDescedants && core.parentFqn(el.id) === exprElement
+      )
+    );
+  }
+  if (sources.length === 0) {
+    sources = resolveNeighbours.call(this, expr);
+  }
+  return this.graph.edgesBetween(sources, targets);
+}
+const filterEdges = (edges, where) => {
+  if (!where) {
+    return edges;
+  }
+  return remeda.pipe(
+    edges,
+    remeda.map((e) => ({ ...e, relations: e.relations.filter(where) })),
+    remeda.filter((e) => e.relations.length > 0)
+  );
+};
+const filterRelations = (edges, where) => {
+  if (!where) {
+    return edges.flatMap((e) => e.relations);
+  }
+  return remeda.pipe(
+    edges,
+    remeda.flatMap((e) => e.relations),
+    remeda.filter(where)
+  );
+};
+function includeIncomingExpr(expr, where) {
+  const edges = filterEdges(edgesIncomingExpr.call(this, expr.incoming), where);
+  if (edges.length === 0) {
+    return;
+  }
+  this.addEdges(edges);
+  this.addImplicit(...edges.map((e) => e.target));
+}
+function excludeIncomingExpr(expr, where) {
+  let relations = filterRelations(edgesIncomingExpr.call(this, expr.incoming), where);
+  this.excludeRelation(...relations);
+}
+function edgesOutgoingExpr(expr) {
+  if (core.Expr.isWildcard(expr)) {
+    if (!this.root) {
+      return [];
+    }
+    const targets2 = this.graph.ascendingSiblings(this.root);
+    const sources2 = [...this.graph.children(this.root), this.graph.element(this.root)];
+    return this.graph.edgesBetween(sources2, targets2);
+  }
+  const sources = resolveElements.call(this, expr);
+  if (sources.length === 0) {
+    return [];
+  }
+  let targets = [...this.resolvedElements];
+  if (core.Expr.isElementRef(expr) || core.Expr.isExpandedElementExpr(expr)) {
+    const sourceElement = expr.element ?? expr.expanded;
+    const isDescedants = expr.isDescedants ?? false;
+    targets = targets.filter(
+      (el) => (
+        // allow elements, that are not nested or are direct children
+        !core.isAncestor(sourceElement, el.id) || isDescedants && core.parentFqn(el.id) === sourceElement
+      )
+    );
+  }
+  if (targets.length === 0) {
+    targets = resolveNeighbours.call(this, expr);
+  }
+  return this.graph.edgesBetween(sources, targets);
+}
+function includeOutgoingExpr(expr, where) {
+  const edges = filterEdges(edgesOutgoingExpr.call(this, expr.outgoing), where);
+  if (edges.length === 0) {
+    return;
+  }
+  this.addEdges(edges);
+  this.addImplicit(...edges.map((e) => e.source));
+}
+function excludeOutgoingExpr(expr, where) {
+  const relations = filterRelations(edgesOutgoingExpr.call(this, expr.outgoing), where);
+  this.excludeRelation(...relations);
+}
+var EdgePredicateResult;
+((EdgePredicateResult2) => {
+  EdgePredicateResult2.Empty = {
+    implicits: [],
+    edges: []
+  };
+})(EdgePredicateResult || (EdgePredicateResult = {}));
+function edgesInOutExpr({ inout }, where) {
+  if (core.Expr.isWildcard(inout)) {
+    if (!this.root) {
+      return EdgePredicateResult.Empty;
+    }
+    const neighbours = this.graph.ascendingSiblings(this.root);
+    return {
+      edges: filterEdges(this.graph.anyEdgesBetween(this.graph.element(this.root), neighbours), where),
+      implicits: []
+    };
+  }
+  const elements = resolveElements.call(this, inout);
+  if (elements.length === 0) {
+    return EdgePredicateResult.Empty;
+  }
+  let currentElements = [...this.resolvedElements];
+  if (core.Expr.isElementRef(inout) || core.Expr.isExpandedElementExpr(inout)) {
+    const exprElement = inout.element ?? inout.expanded;
+    const isDescedants = inout.isDescedants ?? false;
+    currentElements = currentElements.filter(
+      (el) => (
+        // allow elements, that are not nested or are direct children
+        !core.isAncestor(exprElement, el.id) || isDescedants && core.parentFqn(el.id) === exprElement
+      )
+    );
+  }
+  if (currentElements.length === 0) {
+    currentElements = resolveNeighbours.call(this, inout);
+  }
+  return elements.reduce((acc, el) => {
+    const edges = filterEdges(this.graph.anyEdgesBetween(el, currentElements), where);
+    if (edges.length > 0) {
+      acc.implicits.push(el);
+      acc.edges.push(...edges);
+    }
+    return acc;
+  }, { implicits: [], edges: [] });
+}
+function includeInOutExpr(expr, where) {
+  const { implicits, edges } = edgesInOutExpr.call(this, expr, where);
+  this.addEdges(edges);
+  this.addImplicit(...implicits);
+}
+function excludeInOutExpr(expr, where) {
+  const { edges } = edgesInOutExpr.call(this, expr, where);
+  this.excludeRelation(...edges.flatMap((e) => e.relations));
+}
+function resolveRelationExprElements(expr) {
+  if (core.Expr.isElementRef(expr) && this.root === expr.element && expr.isDescedants !== true) {
+    return [...this.graph.children(expr.element), this.graph.element(expr.element)];
+  }
+  if (core.Expr.isExpandedElementExpr(expr) && this.root === expr.expanded) {
+    return [...this.graph.children(expr.expanded), this.graph.element(expr.expanded)];
+  }
+  return resolveElements.call(this, expr);
+}
+function includeRelationExpr(expr, where) {
+  let sources, targets;
+  if (core.Expr.isWildcard(expr.source) && !core.Expr.isWildcard(expr.target)) {
+    sources = resolveNeighbours.call(this, expr.target);
+    targets = resolveRelationExprElements.call(this, expr.target);
+  } else if (!core.Expr.isWildcard(expr.source) && core.Expr.isWildcard(expr.target)) {
+    sources = resolveRelationExprElements.call(this, expr.source);
+    targets = resolveNeighbours.call(this, expr.source);
+  } else {
+    sources = resolveRelationExprElements.call(this, expr.source);
+    targets = resolveRelationExprElements.call(this, expr.target);
+  }
+  const edges = this.graph.edgesBetween(sources, targets);
+  if (expr.isBidirectional === true) {
+    edges.push(...this.graph.edgesBetween(targets, sources));
+  }
+  this.addEdges(filterEdges(edges, where));
+}
+function excludeRelationExpr(expr, where) {
+  const isSource = elementExprToPredicate(expr.source);
+  const isTarget = elementExprToPredicate(expr.target);
+  const satisfies = (edge) => {
+    let result = isSource(edge.source) && isTarget(edge.target);
+    if (!result && expr.isBidirectional) {
+      result = isSource(edge.target) && isTarget(edge.source);
+    }
+    return result;
+  };
+  const edges = this.edges.filter(satisfies);
+  const relations = filterRelations(edges, where);
+  this.excludeRelation(...relations);
+}
+
+function compareEdges(a, b) {
+  return core.compareRelations(
+    { source: a.source.id, target: a.target.id },
+    { source: b.source.id, target: b.target.id }
+  );
+}
+class ComputeCtx {
+  constructor(view, graph) {
+    this.view = view;
+    this.graph = graph;
+  }
+  // Intermediate state
+  explicits = /* @__PURE__ */ new Set();
+  implicits = /* @__PURE__ */ new Set();
+  ctxEdges = [];
+  static elementView(view, graph) {
+    return new ComputeCtx(view, graph).compute();
+  }
+  compute() {
+    this.reset();
+    const {
+      docUri: _docUri,
+      // exclude docUri
+      rules,
+      ...view
+    } = this.view;
+    const viewPredicates = rules.filter(core.isViewRulePredicate);
+    if (this.root && viewPredicates.length == 0) {
+      this.addElement(this.graph.element(this.root));
+    }
+    this.processPredicates(viewPredicates);
+    this.removeRedundantImplicitEdges();
+    const elements = [...this.includedElements];
+    const nodesMap = buildComputeNodes(elements);
+    const edgesMap = /* @__PURE__ */ new Map();
+    const edges = this.computeEdges();
+    for (const edge of edges) {
+      edgesMap.set(edge.id, edge);
+      const source = nodesMap.get(edge.source);
+      const target = nodesMap.get(edge.target);
+      core.invariant(source, `Source node ${edge.source} not found`);
+      core.invariant(target, `Target node ${edge.target} not found`);
+      while (edge.parent && !nodesMap.has(edge.parent)) {
+        edge.parent = core.parentFqn(edge.parent);
+      }
+      source.outEdges.push(edge.id);
+      target.inEdges.push(edge.id);
+      for (const sourceAncestor of core.ancestorsFqn(edge.source)) {
+        if (sourceAncestor === edge.parent) {
+          break;
+        }
+        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id);
+      }
+      for (const targetAncestor of core.ancestorsFqn(edge.target)) {
+        if (targetAncestor === edge.parent) {
+          break;
+        }
+        nodesMap.get(targetAncestor)?.inEdges.push(edge.id);
+      }
+    }
+    const initialSort = elements.flatMap((e) => nodesMap.get(e.id) ?? []);
+    const nodes = applyCustomElementProperties(
+      rules,
+      applyViewRuleStyles(
+        rules,
+        // Build graph and apply postorder sort
+        sortNodes({
+          nodes: initialSort,
+          edges
+        })
+      )
+    );
+    const sortedEdges = /* @__PURE__ */ new Set([
+      ...nodes.flatMap((n) => n.children.length === 0 ? n.outEdges.flatMap((id) => edgesMap.get(id) ?? []) : []),
+      ...edges
+    ]);
+    const autoLayoutRule = this.view.rules.findLast(core.isViewRuleAutoLayout);
+    const elementNotations = buildElementNotations(nodes);
+    return calcViewLayoutHash({
+      ...view,
+      autoLayout: autoLayoutRule?.autoLayout ?? "TB",
+      nodes: remeda.map(nodes, remeda.omit(["notation"])),
+      edges: applyCustomRelationProperties(rules, nodes, sortedEdges),
+      ...elementNotations.length > 0 && {
+        notation: {
+          elements: elementNotations
+        }
+      }
+    });
+  }
+  get root() {
+    return core.isScopedElementView(this.view) ? this.view.viewOf : null;
+  }
+  computeEdges() {
+    return this.ctxEdges.map((e) => {
+      core.invariant(remeda.hasAtLeast(e.relations, 1), "Edge must have at least one relation");
+      const relations = e.relations.toSorted(core.compareRelations);
+      const source = e.source.id;
+      const target = e.target.id;
+      const edge = {
+        id: `${source}:${target}`,
+        parent: core.commonAncestor(source, target),
+        source,
+        target,
+        label: null,
+        relations: relations.map((r) => r.id)
+      };
+      let relation;
+      if (relations.length === 1) {
+        relation = relations[0];
+      } else {
+        relation = relations.find((r) => r.source === source && r.target === target);
+      }
+      if (!relation) {
+        relation = relations.reduce((acc, r) => {
+          if (r.color && acc.color !== r.color) {
+            acc.color = void 0;
+          }
+          if (r.kind && acc.kind !== r.kind) {
+            acc.kind = void 0;
+          }
+          if (r.head && acc.head !== r.head) {
+            acc.head = void 0;
+          }
+          if (r.tail && acc.tail !== r.tail) {
+            acc.tail = void 0;
+          }
+          if (r.line && acc.line !== r.line) {
+            acc.line = void 0;
+          }
+          if (r.description && acc.description !== r.description) {
+            acc.description = void 0;
+          }
+          if (r.technology && acc.technology !== r.technology) {
+            acc.technology = void 0;
+          }
+          if (remeda.isTruthy(r.title) && acc.title !== r.title) {
+            acc.title = "[...]";
+          }
+          return acc;
+        }, {
+          title: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.title) ? r.title : [])) ?? "[...]",
+          description: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.description) ? r.description : [])),
+          technology: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.technology) ? r.technology : [])),
+          kind: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.kind) ? r.kind : [])),
+          head: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.head) ? r.head : [])),
+          tail: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.tail) ? r.tail : [])),
+          color: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.color) ? r.color : [])),
+          line: remeda.first(remeda.flatMap(relations, (r) => remeda.isTruthy(r.line) ? r.line : []))
+        });
+      }
+      const tags = remeda.unique(remeda.flatMap(relations, (r) => r.tags ?? []));
+      return Object.assign(
+        edge,
+        this.getEdgeLabel(relation),
+        remeda.isTruthy(relation.description) && { description: relation.description },
+        remeda.isTruthy(relation.technology) && { technology: relation.technology },
+        remeda.isTruthy(relation.kind) && { kind: relation.kind },
+        relation.color && { color: relation.color },
+        relation.line && { line: relation.line },
+        relation.head && { head: relation.head },
+        relation.tail && { tail: relation.tail },
+        remeda.hasAtLeast(tags, 1) && { tags }
+      );
+    });
+  }
+  get includedElements() {
+    return /* @__PURE__ */ new Set([
+      ...this.explicits,
+      ...this.ctxEdges.flatMap((e) => [e.source, e.target])
+    ]);
+  }
+  get resolvedElements() {
+    return /* @__PURE__ */ new Set([
+      ...this.explicits,
+      ...this.implicits,
+      ...this.ctxEdges.flatMap((e) => [e.source, e.target])
+    ]);
+  }
+  get edges() {
+    return this.ctxEdges;
+  }
+  addEdges(edges) {
+    for (const e of edges) {
+      if (!remeda.hasAtLeast(e.relations, 1)) {
+        continue;
+      }
+      const existing = this.ctxEdges.find(
+        (_e) => _e.source.id === e.source.id && _e.target.id === e.target.id
+      );
+      if (existing) {
+        existing.relations = remeda.unique([...existing.relations, ...e.relations]);
+        continue;
+      }
+      this.ctxEdges.push(e);
+    }
+  }
+  /**
+   * Add element explicitly
+   * Included even without relationships
+   */
+  addElement(...el) {
+    for (const r of el) {
+      this.explicits.add(r);
+      this.implicits.add(r);
+    }
+  }
+  /**
+   * Add element implicitly
+   * Included if only has relationships
+   */
+  addImplicit(...el) {
+    for (const r of el) {
+      this.implicits.add(r);
+    }
+  }
+  excludeElement(...excludes) {
+    for (const el of excludes) {
+      this.ctxEdges = this.ctxEdges.filter((e) => e.source.id !== el.id && e.target.id !== el.id);
+      this.explicits.delete(el);
+      this.implicits.delete(el);
+    }
+  }
+  excludeImplicit(...excludes) {
+    for (const el of excludes) {
+      this.implicits.delete(el);
+    }
+  }
+  excludeRelation(...relations) {
+    const excludedImplicits = /* @__PURE__ */ new Set();
+    for (const relation of relations) {
+      let edge;
+      while (edge = this.ctxEdges.find((e) => e.relations.includes(relation))) {
+        if (edge.relations.length === 1) {
+          excludedImplicits.add(edge.source);
+          excludedImplicits.add(edge.target);
+          this.ctxEdges.splice(this.ctxEdges.indexOf(edge), 1);
+          continue;
+        }
+        edge.relations = edge.relations.filter((r) => r !== relation);
+      }
+    }
+    if (excludedImplicits.size === 0) {
+      return;
+    }
+    const remaining = this.includedElements;
+    if (remaining.size === 0) {
+      this.implicits.clear();
+      return;
+    }
+    for (const el of excludedImplicits) {
+      if (!remaining.has(el)) {
+        this.implicits.delete(el);
+      }
+    }
+  }
+  reset() {
+    this.explicits.clear();
+    this.implicits.clear();
+    this.ctxEdges = [];
+  }
+  // Filter out edges if there are edges between descendants
+  // i.e. remove implicit edges, derived from childs
+  removeRedundantImplicitEdges() {
+    const processedRelations = /* @__PURE__ */ new Set();
+    const excludeProcessed = (relations) => relations.reduce((acc, rel) => {
+      if (!processedRelations.has(rel)) {
+        acc.push(rel);
+        processedRelations.add(rel);
+      }
+      return acc;
+    }, []);
+    const isNestedEdgeOf = (parent) => {
+      const { source, target } = parent;
+      return (edge) => {
+        const isSameSource = source.id === edge.source.id;
+        const isSameTarget = target.id === edge.target.id;
+        if (isSameSource && isSameTarget) {
+          return true;
+        }
+        const isSourceNested = core.isAncestor(source.id, edge.source.id);
+        const isTargetNested = core.isAncestor(target.id, edge.target.id);
+        return isSourceNested && isTargetNested || isSameSource && isTargetNested || isSameTarget && isSourceNested;
+      };
+    };
+    const edges = [...this.ctxEdges].sort(compareEdges).reverse();
+    this.ctxEdges = edges.reduce((acc, e) => {
+      const relations = excludeProcessed(e.relations);
+      if (relations.length === 0) {
+        return acc;
+      }
+      if (acc.length > 0 && acc.some(isNestedEdgeOf(e))) {
+        return acc;
+      }
+      acc.push({
+        source: e.source,
+        target: e.target,
+        relations
+      });
+      return acc;
+    }, []);
+  }
+  processPredicates(viewRules) {
+    for (const rule of viewRules) {
+      const isInclude = "include" in rule;
+      const exprs = rule.include ?? rule.exclude;
+      for (const expr of exprs) {
+        if (core.Expr.isElementPredicateExpr(expr)) {
+          this.processElementPredicate(expr, isInclude);
+          continue;
+        }
+        if (core.Expr.isRelationPredicateExpr(expr)) {
+          this.processRelationPredicate(expr, isInclude);
+          continue;
+        }
+        core.nonexhaustive(expr);
+      }
+    }
+    return this;
+  }
+  processElementPredicate(expr, isInclude, where) {
+    if (core.Expr.isCustomElement(expr)) {
+      if (isInclude) {
+        this.processElementPredicate(expr.custom.expr, isInclude);
+      }
+      return this;
+    }
+    if (core.Expr.isElementWhere(expr)) {
+      const where2 = core.whereOperatorAsPredicate(expr.where.condition);
+      this.processElementPredicate(expr.where.expr, isInclude, where2);
+      return this;
+    }
+    if (core.Expr.isExpandedElementExpr(expr)) {
+      isInclude ? includeExpandedElementExpr.call(this, expr, where) : excludeExpandedElementExpr.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isElementKindExpr(expr) || core.Expr.isElementTagExpr(expr)) {
+      isInclude ? includeElementKindOrTag.call(this, expr, where) : excludeElementKindOrTag.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isElementRef(expr)) {
+      isInclude ? includeElementRef.call(this, expr, where) : excludeElementRef.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isWildcard(expr)) {
+      isInclude ? includeWildcardRef.call(this, expr, where) : excludeWildcardRef.call(this, expr, where);
+      return this;
+    }
+    core.nonexhaustive(expr);
+  }
+  processRelationPredicate(expr, isInclude, where) {
+    if (core.Expr.isCustomRelationExpr(expr)) {
+      if (isInclude) {
+        this.processRelationPredicate(expr.customRelation.relation, isInclude);
+      }
+      return this;
+    }
+    if (core.Expr.isRelationWhere(expr)) {
+      const where2 = core.whereOperatorAsPredicate(expr.where.condition);
+      this.processRelationPredicate(expr.where.expr, isInclude, where2);
+      return this;
+    }
+    if (core.Expr.isIncoming(expr)) {
+      isInclude ? includeIncomingExpr.call(this, expr, where) : excludeIncomingExpr.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isOutgoing(expr)) {
+      isInclude ? includeOutgoingExpr.call(this, expr, where) : excludeOutgoingExpr.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isInOut(expr)) {
+      isInclude ? includeInOutExpr.call(this, expr, where) : excludeInOutExpr.call(this, expr, where);
+      return this;
+    }
+    if (core.Expr.isRelation(expr)) {
+      isInclude ? includeRelationExpr.call(this, expr, where) : excludeRelationExpr.call(this, expr, where);
+      return this;
+    }
+    core.nonexhaustive(expr);
+  }
+  getEdgeLabel(relation) {
+    const labelParts = [];
+    if (remeda.isTruthy(relation.title)) {
+      labelParts.push(relation.title);
+    }
+    if (remeda.isTruthy(relation.technology)) {
+      labelParts.push(`[${relation.technology}]`);
+    }
+    return labelParts.length > 0 && { label: labelParts.join("\n") };
+  }
+}
+
+function computeElementView(view, graph) {
+  return ComputeCtx.elementView(view, graph);
+}
+function computeView(view, graph) {
+  try {
+    return {
+      isSuccess: true,
+      view: computeElementView(view, graph)
+    };
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
+      view: void 0
+    };
+  }
+}
+
+class DynamicViewComputeCtx {
+  constructor(view, graph) {
+    this.view = view;
+    this.graph = graph;
+  }
+  // Intermediate state
+  explicits = /* @__PURE__ */ new Set();
+  steps = [];
+  static compute(view, graph) {
+    return new DynamicViewComputeCtx(view, graph).compute();
+  }
+  compute() {
+    const {
+      docUri: _docUri,
+      // exclude docUri
+      rules,
+      steps: viewSteps,
+      ...view
+    } = this.view;
+    for (let {
+      source: stepSource,
+      target: stepTarget,
+      title: stepTitle,
+      isBackward,
+      ...step
+    } of viewSteps) {
+      const source = this.graph.element(stepSource);
+      const target = this.graph.element(stepTarget);
+      this.explicits.add(source);
+      this.explicits.add(target);
+      const { title, relations, tags } = this.findRelations(source, target);
+      this.steps.push({
+        ...step,
+        source,
+        target,
+        title: remeda.isTruthy(stepTitle) ? stepTitle : title,
+        relations: relations ?? [],
+        isBackward: isBackward ?? false,
+        ...tags ? { tags } : {}
+      });
+    }
+    for (const rule of rules) {
+      if (core.isDynamicViewIncludeRule(rule)) {
+        for (const expr of rule.include) {
+          const predicate = elementExprToPredicate(expr);
+          this.graph.elements.filter(predicate).forEach((e) => this.explicits.add(e));
+        }
+      }
+    }
+    const elements = [...this.explicits];
+    const nodesMap = buildComputeNodes(elements);
+    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }, index) => {
+      const sourceNode = core.nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`);
+      const targetNode = core.nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`);
+      const stepNum = index + 1;
+      const edge = {
+        id: core.StepEdgeId(stepNum),
+        parent: core.commonAncestor(source.id, target.id),
+        source: source.id,
+        target: target.id,
+        label: title,
+        relations,
+        color: core.DefaultRelationshipColor,
+        line: core.DefaultLineStyle,
+        head: core.DefaultArrowType,
+        ...step
+      };
+      if (isBackward) {
+        edge.dir = "back";
+      }
+      while (edge.parent && !nodesMap.has(edge.parent)) {
+        edge.parent = core.parentFqn(edge.parent);
+      }
+      sourceNode.outEdges.push(edge.id);
+      targetNode.inEdges.push(edge.id);
+      for (const sourceAncestor of core.ancestorsFqn(edge.source)) {
+        if (sourceAncestor === edge.parent) {
+          break;
+        }
+        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id);
+      }
+      for (const targetAncestor of core.ancestorsFqn(edge.target)) {
+        if (targetAncestor === edge.parent) {
+          break;
+        }
+        nodesMap.get(targetAncestor)?.inEdges.push(edge.id);
+      }
+      return edge;
+    });
+    const nodes = applyCustomElementProperties(
+      rules,
+      applyViewRuleStyles(
+        rules,
+        // Keep order of elements
+        elements.map((e) => core.nonNullable(nodesMap.get(e.id)))
+      )
+    );
+    const autoLayoutRule = rules.findLast(core.isViewRuleAutoLayout);
+    const elementNotations = buildElementNotations(nodes);
+    return calcViewLayoutHash({
+      ...view,
+      autoLayout: autoLayoutRule?.autoLayout ?? "LR",
+      nodes: remeda.map(nodes, remeda.omit(["notation"])),
+      edges,
+      ...elementNotations.length > 0 && {
+        notation: {
+          elements: elementNotations
+        }
+      }
+    });
+  }
+  findRelations(source, target) {
+    const relationships = remeda.unique(this.graph.edgesBetween(source, target).flatMap((e) => e.relations));
+    const alltags = remeda.unique(relationships.flatMap((r) => r.tags ?? []));
+    const tags = remeda.hasAtLeast(alltags, 1) ? alltags : null;
+    const relations = remeda.hasAtLeast(relationships, 1) ? remeda.map(relationships, (r) => r.id) : null;
+    if (relationships.length === 0) {
+      return {
+        title: null,
+        tags,
+        relations
+      };
+    }
+    let relation;
+    if (relationships.length === 1) {
+      relation = relationships[0];
+    } else {
+      relation = relationships.find((r) => r.source === source.id && r.target === target.id);
+    }
+    if (relation && remeda.isTruthy(relation.title)) {
+      return {
+        title: relation.title,
+        tags,
+        relations
+      };
+    }
+    const labels = remeda.unique(relationships.flatMap((r) => remeda.isTruthy(r.title) ? r.title : []));
+    if (labels.length === 1) {
+      return {
+        title: labels[0],
+        tags,
+        relations
+      };
+    }
+    return {
+      title: null,
+      tags,
+      relations
+    };
+  }
+}
+
+function computeDynamicView(view, graph) {
+  try {
+    return {
+      isSuccess: true,
+      view: DynamicViewComputeCtx.compute(view, graph)
+    };
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
+      view: void 0
+    };
+  }
+}
+
+const RelationsSet = Set;
+const MapRelations = Map;
+function intersection(a, b) {
+  if (a.size === 0 || b.size === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set([...a].filter((value) => b.has(value)));
+}
+class LikeC4ModelGraph {
+  #elements = /* @__PURE__ */ new Map();
+  // Parent element for given FQN
+  #parents = /* @__PURE__ */ new Map();
+  // Children elements for given FQN
+  #children = /* @__PURE__ */ new Map();
+  #rootElements = /* @__PURE__ */ new Set();
+  #relations = /* @__PURE__ */ new Map();
+  // Incoming to an element or its descendants
+  #incoming = new MapRelations();
+  // Outgoing from an element or its descendants
+  #outgoing = new MapRelations();
+  // Relationships inside the element, among descendants
+  #internal = new MapRelations();
+  #cacheAscendingSiblings = /* @__PURE__ */ new Map();
+  constructor({ elements, relations }) {
+    for (const el of Object.values(elements)) {
+      this.addElement(el);
+    }
+    for (const rel of Object.values(relations)) {
+      this.addRelation(rel);
+    }
+  }
+  get rootElements() {
+    return [...this.#rootElements];
+  }
+  get elements() {
+    return [...this.#elements.values()];
+  }
+  element(id) {
+    const el = this.#elements.get(id);
+    core.invariant(el, `Element ${id} not found`);
+    return el;
+  }
+  connectedRelations(id) {
+    return [...this._incomingTo(id), ...this._outgoingFrom(id), ...this._internalOf(id)];
+  }
+  children(id) {
+    return this._childrenOf(id).slice();
+  }
+  // Get children or element itself if no children
+  childrenOrElement(id) {
+    const children = this.children(id);
+    return children.length > 0 ? children : [this.element(id)];
+  }
+  // Get all sibling (i.e. same parent)
+  siblings(element) {
+    const id = remeda.isString(element) ? element : element.id;
+    const parent = core.parentFqn(id);
+    const siblings = parent ? this._childrenOf(parent) : this.rootElements;
+    return siblings.filter((e) => e.id !== id);
+  }
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  ancestors(element) {
+    let id = remeda.isString(element) ? element : element.id;
+    const result = [];
+    let parent;
+    while (parent = this.#parents.get(id)) {
+      result.push(parent);
+      id = parent.id;
+    }
+    return result;
+  }
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from closest to root)
+   */
+  ascendingSiblings(element) {
+    const id = remeda.isString(element) ? element : element.id;
+    let siblings = this.#cacheAscendingSiblings.get(id);
+    if (!siblings) {
+      siblings = [
+        ...this.siblings(id),
+        ...this.ancestors(id).flatMap((a) => this.siblings(a.id))
+      ];
+      this.#cacheAscendingSiblings.set(id, siblings);
+    }
+    return siblings.slice();
+  }
+  /**
+   * Resolve all RelationEdges between element and others (any direction)
+   */
+  anyEdgesBetween(_element, others) {
+    if (others.length === 0) {
+      return [];
+    }
+    const element = remeda.isString(_element) ? this.element(_element) : _element;
+    const in_element = this._incomingTo(element.id);
+    const element_out = this._outgoingFrom(element.id);
+    if (in_element.size === 0 && element_out.size === 0) {
+      return [];
+    }
+    const result = [];
+    for (const _other of others) {
+      const other = remeda.isString(_other) ? this.element(_other) : _other;
+      if (core.isSameHierarchy(element, other)) {
+        continue;
+      }
+      if (element_out.size > 0) {
+        const outcoming = intersection(this._incomingTo(other.id), element_out);
+        if (outcoming.size > 0) {
+          result.push({
+            source: element,
+            target: other,
+            relations: [...outcoming]
+          });
+        }
+      }
+      if (in_element.size > 0) {
+        const incoming = intersection(this._outgoingFrom(other.id), in_element);
+        if (incoming.size > 0) {
+          result.push({
+            source: other,
+            target: element,
+            relations: [...incoming]
+          });
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve all RelationEdges between elements (any direction)
+   */
+  edgesWithin(elements) {
+    if (elements.length < 2) {
+      return [];
+    }
+    return elements.reduce((acc, el, index, array) => {
+      if (index === array.length - 1) {
+        return acc;
+      }
+      acc.push(...this.anyEdgesBetween(el, array.slice(index + 1)));
+      return acc;
+    }, []);
+  }
+  /**
+   * Get directed RelationEdge between source and target if exists
+   */
+  edgesBetween(_sources, _targets) {
+    const sources = remeda.isArray(_sources) ? _sources : [_sources];
+    const targets = remeda.isArray(_targets) ? _targets : [_targets];
+    if (sources.length === 0 || targets.length === 0) {
+      return [];
+    }
+    const result = [];
+    for (const _source of sources) {
+      const source = remeda.isString(_source) ? this.element(_source) : _source;
+      const outcoming = this._outgoingFrom(source.id);
+      if (outcoming.size === 0) {
+        continue;
+      }
+      for (const _target of targets) {
+        const target = remeda.isString(_target) ? this.element(_target) : _target;
+        if (core.isSameHierarchy(source, target)) {
+          continue;
+        }
+        const incoming = this._incomingTo(target.id);
+        const relations = intersection(outcoming, incoming);
+        if (relations.size > 0) {
+          result.push({
+            source,
+            target,
+            relations: [...relations]
+          });
+        }
+      }
+    }
+    return result;
+  }
+  addElement(el) {
+    if (this.#elements.has(el.id)) {
+      throw new Error(`Element ${el.id} already exists`);
+    }
+    this.#elements.set(el.id, el);
+    const parentId = core.parentFqn(el.id);
+    if (parentId) {
+      this.#parents.set(el.id, this.element(parentId));
+      this._childrenOf(parentId).push(el);
+    } else {
+      this.#rootElements.add(el);
+    }
+  }
+  addRelation(rel) {
+    if (this.#relations.has(rel.id)) {
+      throw new Error(`Relation ${rel.id} already exists`);
+    }
+    this.#relations.set(rel.id, rel);
+    this._incomingTo(rel.target).add(rel);
+    this._outgoingFrom(rel.source).add(rel);
+    const relParent = core.commonAncestor(rel.source, rel.target);
+    if (relParent) {
+      for (const ancestor of [relParent, ...core.ancestorsFqn(relParent)]) {
+        this._internalOf(ancestor).add(rel);
+      }
+    }
+    for (const sourceAncestor of core.ancestorsFqn(rel.source)) {
+      if (sourceAncestor === relParent) {
+        break;
+      }
+      this._outgoingFrom(sourceAncestor).add(rel);
+    }
+    for (const targetAncestor of core.ancestorsFqn(rel.target)) {
+      if (targetAncestor === relParent) {
+        break;
+      }
+      this._incomingTo(targetAncestor).add(rel);
+    }
+  }
+  _childrenOf(id) {
+    let children = this.#children.get(id);
+    if (!children) {
+      children = [];
+      this.#children.set(id, children);
+    }
+    return children;
+  }
+  _incomingTo(id) {
+    let incoming = this.#incoming.get(id);
+    if (!incoming) {
+      incoming = new RelationsSet();
+      this.#incoming.set(id, incoming);
+    }
+    return incoming;
+  }
+  _outgoingFrom(id) {
+    let outgoing = this.#outgoing.get(id);
+    if (!outgoing) {
+      outgoing = new RelationsSet();
+      this.#outgoing.set(id, outgoing);
+    }
+    return outgoing;
+  }
+  _internalOf(id) {
+    let internal = this.#internal.get(id);
+    if (!internal) {
+      internal = new RelationsSet();
+      this.#internal.set(id, internal);
+    }
+    return internal;
+  }
+}
+
+exports.LikeC4ModelGraph = LikeC4ModelGraph;
+exports.computeDynamicView = computeDynamicView;
+exports.computeElementView = computeElementView;
+exports.computeView = computeView;
+exports.findCycles = findCycles;
+exports.isAcyclic = isAcyclic;
+exports.postorder = postorder;